Restructure B

src/main/java/me/cortex/voxy/client/core/AbstractRenderWorldInteractor.java

@@ -0,0 +1,17 @@
+package me.cortex.voxy.client.core;
+
+import me.cortex.voxy.client.core.rendering.building.BuiltSection;
+import me.cortex.voxy.client.core.rendering.building.RenderGenerationService;
+import me.cortex.voxy.common.world.WorldSection;
+
+public interface AbstractRenderWorldInteractor {
+    void processBuildResult(BuiltSection section);
+
+    void sectionUpdated(WorldSection worldSection);
+
+    void setRenderGen(RenderGenerationService renderService);
+
+    void initPosition(int x, int z);
+
+    void setCenter(int x, int y, int z);
+}

src/main/java/me/cortex/voxy/client/core/DefaultRenderWorldInteractor.java

@@ -0,0 +1,66 @@
+package me.cortex.voxy.client.core;
+
+import me.cortex.voxy.client.config.VoxyConfig;
+import me.cortex.voxy.client.core.rendering.AbstractFarWorldRenderer;
+import me.cortex.voxy.client.core.rendering.IRenderInterface;
+import me.cortex.voxy.client.core.rendering.RenderTracker;
+import me.cortex.voxy.client.core.rendering.building.BuiltSection;
+import me.cortex.voxy.client.core.rendering.building.RenderGenerationService;
+import me.cortex.voxy.client.saver.ContextSelectionSystem;
+import me.cortex.voxy.common.world.WorldEngine;
+import me.cortex.voxy.common.world.WorldSection;
+import net.minecraft.client.MinecraftClient;
+
+public class DefaultRenderWorldInteractor implements AbstractRenderWorldInteractor {
+    private final DistanceTracker distanceTracker;
+    private final RenderTracker renderTracker;
+
+
+    public DefaultRenderWorldInteractor(ContextSelectionSystem.WorldConfig cfg, WorldEngine world, IRenderInterface renderer)  {
+        this.renderTracker = new RenderTracker(world, (AbstractFarWorldRenderer) renderer);
+
+        //To get to chunk scale multiply the scale by 2, the scale is after how many chunks does the lods halve
+        int q = VoxyConfig.CONFIG.qualityScale;
+        int minY = MinecraftClient.getInstance().world.getBottomSectionCoord()/2;
+        int maxY = MinecraftClient.getInstance().world.getTopSectionCoord()/2;
+
+        if (cfg.minYOverride != Integer.MAX_VALUE) {
+            minY = cfg.minYOverride;
+        }
+
+        if (cfg.maxYOverride != Integer.MIN_VALUE) {
+            maxY = cfg.maxYOverride;
+        }
+
+        this.distanceTracker = new DistanceTracker(this.renderTracker, new int[]{q,q,q,q},
+                (VoxyConfig.CONFIG.renderDistance<0?VoxyConfig.CONFIG.renderDistance:((VoxyConfig.CONFIG.renderDistance+1)/2)),
+                minY, maxY);
+
+        System.out.println("Distance tracker initialized");
+    }
+
+    @Override
+    public void processBuildResult(BuiltSection section) {
+        this.renderTracker.processBuildResult(section);
+    }
+
+    @Override
+    public void sectionUpdated(WorldSection worldSection) {
+        this.renderTracker.sectionUpdated(worldSection);
+    }
+
+    @Override
+    public void setRenderGen(RenderGenerationService renderService) {
+        this.renderTracker.setRenderGen(renderService);
+    }
+
+    @Override
+    public void initPosition(int x, int z) {
+        this.distanceTracker.init(x,z);
+    }
+
+    @Override
+    public void setCenter(int x, int y, int z) {
+        this.distanceTracker.setCenter(x,y,z);
+    }
+}

src/main/java/me/cortex/voxy/client/core/VoxelCore.java

@@ -48,9 +48,7 @@ public class VoxelCore {
     private final WorldEngine world;
     private final RenderGenerationService renderGen;
     private final ModelManager modelManager;
-
+    private final AbstractRenderWorldInteractor interactor;
-    private final DistanceTracker distanceTracker;
-    private final RenderTracker renderTracker;
 
     private final IRenderInterface renderer;
     private final ViewportSelector viewportSelector;
@@ -71,30 +69,14 @@ public class VoxelCore {
         this.renderer = this.createRenderBackend();
         this.viewportSelector = new ViewportSelector<>(this.renderer::createViewport);
         System.out.println("Renderer initialized");
+        this.interactor = new DefaultRenderWorldInteractor(cfg, this.world, this.renderer);
 
-        this.renderTracker = new RenderTracker(this.world, (AbstractFarWorldRenderer) this.renderer);
+        this.renderGen = new RenderGenerationService(this.world, this.modelManager, VoxyConfig.CONFIG.renderThreads, this.interactor::processBuildResult, this.renderer.generateMeshlets());
-        this.renderGen = new RenderGenerationService(this.world, this.modelManager, VoxyConfig.CONFIG.renderThreads, this.renderTracker::processBuildResult, this.renderer.generateMeshlets());
+        this.world.setDirtyCallback(this.interactor::sectionUpdated);
-        this.world.setDirtyCallback(this.renderTracker::sectionUpdated);
+        this.interactor.setRenderGen(this.renderGen);
-        this.renderTracker.setRenderGen(this.renderGen);
         System.out.println("Render tracker and generator initialized");
 
-        //To get to chunk scale multiply the scale by 2, the scale is after how many chunks does the lods halve
-        int q = VoxyConfig.CONFIG.qualityScale;
-        int minY = MinecraftClient.getInstance().world.getBottomSectionCoord()/2;
-        int maxY = MinecraftClient.getInstance().world.getTopSectionCoord()/2;
 
-        if (cfg.minYOverride != Integer.MAX_VALUE) {
-            minY = cfg.minYOverride;
-        }
-
-        if (cfg.maxYOverride != Integer.MIN_VALUE) {
-            maxY = cfg.maxYOverride;
-        }
-
-        this.distanceTracker = new DistanceTracker(this.renderTracker, new int[]{q,q,q,q},
-                (VoxyConfig.CONFIG.renderDistance<0?VoxyConfig.CONFIG.renderDistance:((VoxyConfig.CONFIG.renderDistance+1)/2)),
-                minY, maxY);
-        System.out.println("Distance tracker initialized");
 
         this.postProcessing = new PostProcessing();
 
@@ -142,11 +124,11 @@ public class VoxelCore {
     boolean firstTime = true;
     public void renderSetup(Frustum frustum, Camera camera) {
         if (this.firstTime) {
-            this.distanceTracker.init(camera.getBlockPos().getX(), camera.getBlockPos().getZ());
+            this.interactor.initPosition(camera.getBlockPos().getX(), camera.getBlockPos().getZ());
             this.firstTime = false;
             //this.renderTracker.addLvl0(0,6,0);
         }
-        this.distanceTracker.setCenter(camera.getBlockPos().getX(), camera.getBlockPos().getY(), camera.getBlockPos().getZ());
+        this.interactor.setCenter(camera.getBlockPos().getX(), camera.getBlockPos().getY(), camera.getBlockPos().getZ());
         this.renderer.setupRender(frustum, camera);
     }