Implementation of bitmap-based trees for rendering something even when the camera is outside the graph (CaffeineMC#2887 merge item 2)

Author: douira

common/src/main/java/net/caffeinemc/mods/sodium/client/render/SodiumWorldRenderer.java

@@ -253,6 +253,7 @@ public void setupTerrain(Camera camera,
     }
 
     private void processChunkEvents() {
+        this.renderSectionManager.beforeSectionUpdates();
         var tracker = ChunkTrackerHolder.get(this.level);
         tracker.forEachEvent(this.renderSectionManager::onChunkAdded, this.renderSectionManager::onChunkRemoved);
     }

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/RenderSectionFlags.java

@@ -5,5 +5,14 @@ public class RenderSectionFlags {
     public static final int HAS_BLOCK_ENTITIES      = 1;
     public static final int HAS_ANIMATED_SPRITES    = 2;
 
+    public static final int MASK_HAS_BLOCK_GEOMETRY      = 1 << HAS_BLOCK_GEOMETRY;
+    public static final int MASK_HAS_BLOCK_ENTITIES      = 1 << HAS_BLOCK_ENTITIES;
+    public static final int MASK_HAS_ANIMATED_SPRITES    = 1 << HAS_ANIMATED_SPRITES;
+    public static final int MASK_NEEDS_RENDER            = MASK_HAS_BLOCK_GEOMETRY | MASK_HAS_BLOCK_ENTITIES | MASK_HAS_ANIMATED_SPRITES;
+
     public static final int NONE = 0;
+
+    public static boolean needsRender(int flags) {
+        return (flags & MASK_NEEDS_RENDER) != 0;
+    }
 }

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/RenderSectionManager.java

@@ -21,9 +21,7 @@
 import net.caffeinemc.mods.sodium.client.render.chunk.compile.tasks.ChunkBuilderSortingTask;
 import net.caffeinemc.mods.sodium.client.render.chunk.compile.tasks.ChunkBuilderTask;
 import net.caffeinemc.mods.sodium.client.render.chunk.data.BuiltSectionInfo;
-import net.caffeinemc.mods.sodium.client.render.chunk.lists.ChunkRenderList;
-import net.caffeinemc.mods.sodium.client.render.chunk.lists.SortedRenderLists;
-import net.caffeinemc.mods.sodium.client.render.chunk.lists.VisibleChunkCollector;
+import net.caffeinemc.mods.sodium.client.render.chunk.lists.*;
 import net.caffeinemc.mods.sodium.client.render.chunk.occlusion.GraphDirection;
 import net.caffeinemc.mods.sodium.client.render.chunk.occlusion.OcclusionCuller;
 import net.caffeinemc.mods.sodium.client.render.chunk.region.RenderRegion;
@@ -35,6 +33,7 @@
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.data.TranslucentData;
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.trigger.CameraMovement;
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.trigger.SortTriggering;
+import net.caffeinemc.mods.sodium.client.render.chunk.tree.RemovableMultiForest;
 import net.caffeinemc.mods.sodium.client.render.chunk.vertex.format.ChunkMeshFormats;
 import net.caffeinemc.mods.sodium.client.render.util.RenderAsserts;
 import net.caffeinemc.mods.sodium.client.render.viewport.CameraTransform;
@@ -110,6 +109,8 @@ public class RenderSectionManager {
 
     private @Nullable Vector3dc cameraPosition;
 
+    private final RemovableMultiForest renderableSectionTree;
+
     public RenderSectionManager(ClientLevel level, int renderDistance, CommandList commandList) {
         this.chunkRenderer = new DefaultChunkRenderer(RenderDevice.INSTANCE, ChunkMeshFormats.COMPACT);
 
@@ -127,6 +128,8 @@ public RenderSectionManager(ClientLevel level, int renderDistance, CommandList c
         this.renderLists = SortedRenderLists.empty();
         this.occlusionCuller = new OcclusionCuller(Long2ReferenceMaps.unmodifiable(this.sectionByPosition), this.level);
 
+        this.renderableSectionTree = new RemovableMultiForest(renderDistance);
+
         this.taskLists = new EnumMap<>(TaskQueueType.class);
 
         for (var type : TaskQueueType.values()) {
@@ -164,12 +167,28 @@ private void createTerrainRenderList(Camera camera, Viewport viewport, FogParame
         final var searchDistance = this.getSearchDistance(fogParameters);
         final var useOcclusionCulling = this.shouldUseOcclusionCulling(camera, spectator);
 
-        var visitor = new VisibleChunkCollector(frame, SodiumClientMod.options().performance.chunkBuildDeferMode.getImportantRebuildQueueType());
+        RenderListProvider renderListProvider;
+        var importantRebuildQueueType = SodiumClientMod.options().performance.chunkBuildDeferMode.getImportantRebuildQueueType();
+        if (this.isOutOfGraph(viewport.getChunkCoord())) {
+            var visitor = new TreeSectionCollector(frame, importantRebuildQueueType, this.sectionByPosition);
+            this.renderableSectionTree.prepareForTraversal();
+            this.renderableSectionTree.traverse(visitor, viewport, searchDistance);
+
+            renderListProvider = visitor;
+        } else {
+            var visitor = new OcclusionSectionCollector(frame, importantRebuildQueueType);
+            this.occlusionCuller.findVisible(visitor, viewport, searchDistance, useOcclusionCulling, frame);
+
+            renderListProvider = visitor;
+        }
 
-        this.occlusionCuller.findVisible(visitor, viewport, searchDistance, useOcclusionCulling, frame);
+        this.renderLists = renderListProvider.createRenderLists(viewport);
+        this.taskLists = renderListProvider.getTaskLists();
+    }
 
-        this.renderLists = visitor.createRenderLists(viewport);
-        this.taskLists = visitor.getRebuildLists();
+    private boolean isOutOfGraph(SectionPos pos) {
+        var sectionY = pos.getY();
+        return this.level.getMinSectionY() <= sectionY && sectionY <= this.level.getMaxSectionY() && !this.sectionByPosition.containsKey(pos.asLong());
     }
 
     private float getSearchDistance(FogParameters fogParameters) {
@@ -197,6 +216,10 @@ private boolean shouldUseOcclusionCulling(Camera camera, boolean spectator) {
         return useOcclusionCulling;
     }
 
+    public void beforeSectionUpdates() {
+        this.renderableSectionTree.ensureCapacity(this.getRenderDistance());
+    }
+
     private void resetRenderLists() {
         this.renderLists = SortedRenderLists.empty();
 
@@ -225,13 +248,14 @@ public void onSectionAdded(int x, int y, int z) {
         if (section.hasOnlyAir()) {
             this.updateSectionInfo(renderSection, BuiltSectionInfo.EMPTY);
         } else {
+            this.renderableSectionTree.add(renderSection);
             renderSection.setPendingUpdate(ChunkUpdateTypes.INITIAL_BUILD, this.lastFrameAtTime);
         }
 
         this.connectNeighborNodes(renderSection);
 
         // force update to schedule build task
-        this.needsGraphUpdate = true;
+        this.markGraphDirty();
     }
 
     public void onSectionRemoved(int x, int y, int z) {
@@ -242,6 +266,8 @@ public void onSectionRemoved(int x, int y, int z) {
             return;
         }
 
+        this.renderableSectionTree.remove(x, y, z);
+
         if (section.getTranslucentData() != null) {
             this.sortTriggering.removeSection(section.getTranslucentData(), sectionPos);
         }
@@ -258,7 +284,7 @@ public void onSectionRemoved(int x, int y, int z) {
         section.delete();
 
         // force update to remove section from render lists
-        this.needsGraphUpdate = true;
+        this.markGraphDirty();
     }
 
     public void renderLayer(ChunkRenderMatrices matrices, TerrainRenderPass pass, double x, double y, double z) {
@@ -375,6 +401,12 @@ private boolean processChunkBuildResults(ArrayList<BuilderTaskOutput> results) {
     }
 
     private boolean updateSectionInfo(RenderSection render, BuiltSectionInfo info) {
+        if (info == null || !RenderSectionFlags.needsRender(info.flags)) {
+            this.renderableSectionTree.remove(render);
+        } else {
+            this.renderableSectionTree.add(render);
+        }
+
         var infoChanged = render.setInfo(info);
 
         if (info == null || ArrayUtils.isEmpty(info.globalBlockEntities)) {

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/lists/ChunkRenderList.java

@@ -24,6 +24,7 @@ public class ChunkRenderList {
     private int lastRelativeCameraSectionX;
     private int lastRelativeCameraSectionY;
     private int lastRelativeCameraSectionZ;
+    private boolean addedSectionsAreSorted = false;
 
     private final byte[] sectionsWithSprites = new byte[RenderRegion.REGION_SIZE];
     private int sectionsWithSpritesCount = 0;
@@ -39,7 +40,7 @@ public ChunkRenderList(RenderRegion region) {
         this.region = region;
     }
 
-    public void reset(int frame) {
+    public void reset(int frame, boolean addedSectionsAreSorted) {
         this.prevSectionsWithGeometryCount = this.sectionsWithGeometryCount;
         Arrays.fill(this.sectionsWithGeometryMap, 0L);
 
@@ -49,12 +50,13 @@ public void reset(int frame) {
 
         this.size = 0;
         this.lastVisibleFrame = frame;
+        this.addedSectionsAreSorted = addedSectionsAreSorted;
     }
 
     // clamping the relative camera position to the region bounds means there can only be very few different distances
     private static final int SORTING_HISTOGRAM_SIZE = RenderRegion.REGION_WIDTH + RenderRegion.REGION_HEIGHT + RenderRegion.REGION_LENGTH - 2;
 
-    public void prepareForRender(SectionPos cameraPos, int[] sortItems) {
+    public void prepareForRender(SectionPos cameraPos, SortItemsProvider sortItemsProvider) {
         // The relative coordinates are clamped to one section larger than the region bounds to also capture cache invalidation that happens
         // when the camera moves from outside the region to inside the region (when seen on all axes independently).
         // This type of cache invalidation stems from different facings of sections being rendered if the camera is aligned with them on an axis.
@@ -78,16 +80,20 @@ public void prepareForRender(SectionPos cameraPos, int[] sortItems) {
             this.lastRelativeCameraSectionY = relativeCameraSectionY;
             this.lastRelativeCameraSectionZ = relativeCameraSectionZ;
 
-            this.sortSections(relativeCameraSectionX, relativeCameraSectionY, relativeCameraSectionZ, sortItems);
+            // only sort sections if necessary, read directly from bitmap instead of no sorting is required
+            if (!this.addedSectionsAreSorted) {
+                this.sortSections(relativeCameraSectionX, relativeCameraSectionY, relativeCameraSectionZ, sortItemsProvider);
+            }
         }
     }
 
-    public void sortSections(int relativeCameraSectionX, int relativeCameraSectionY, int relativeCameraSectionZ, int[] sortItems) {
+    private void sortSections(int relativeCameraSectionX, int relativeCameraSectionY, int relativeCameraSectionZ, SortItemsProvider sortItemsProvider) {
         relativeCameraSectionX = Mth.clamp(relativeCameraSectionX, 0, RenderRegion.REGION_WIDTH - 1);
         relativeCameraSectionY = Mth.clamp(relativeCameraSectionY, 0, RenderRegion.REGION_HEIGHT - 1);
         relativeCameraSectionZ = Mth.clamp(relativeCameraSectionZ, 0, RenderRegion.REGION_LENGTH - 1);
 
         int[] histogram = new int[SORTING_HISTOGRAM_SIZE];
+        var sortItems = sortItemsProvider.ensureSortItemsOfLength(this.sectionsWithGeometryCount);
 
         this.sectionsWithGeometryCount = 0;
         for (int mapIndex = 0; mapIndex < this.sectionsWithGeometryMap.length; mapIndex++) {
@@ -132,6 +138,9 @@ public void add(RenderSection render) {
 
         if (((flags >>> RenderSectionFlags.HAS_BLOCK_GEOMETRY) & 1) == 1) {
             this.sectionsWithGeometryMap[index >> 6] |= 1L << (index & 0b111111);
+            if (this.addedSectionsAreSorted) {
+                this.sectionsWithGeometry[this.sectionsWithGeometryCount] = (byte) index;
+            }
             this.sectionsWithGeometryCount++;
         }
 

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/lists/CoordinateSectionVisitor.java

@@ -0,0 +1,5 @@
+package net.caffeinemc.mods.sodium.client.render.chunk.lists;
+
+public interface CoordinateSectionVisitor {
+    void visit(int x, int y, int z);
+}

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/lists/OcclusionSectionCollector.java

@@ -0,0 +1,18 @@
+package net.caffeinemc.mods.sodium.client.render.chunk.lists;
+
+import net.caffeinemc.mods.sodium.client.render.chunk.TaskQueueType;
+
+/**
+ * The occlusion section collector is passed to the occlusion graph search culler to
+ * collect the visible chunks.
+ */
+public class OcclusionSectionCollector extends SectionCollector {
+    public OcclusionSectionCollector(int frame, TaskQueueType importantRebuildQueueType) {
+        super(frame, importantRebuildQueueType);
+    }
+
+    @Override
+    public boolean orderIsSorted() {
+        return false;
+    }
+}

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/lists/RenderListProvider.java

@@ -0,0 +1,57 @@
+package net.caffeinemc.mods.sodium.client.render.chunk.lists;
+
+import it.unimi.dsi.fastutil.ints.IntArrays;
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import net.caffeinemc.mods.sodium.client.render.chunk.RenderSection;
+import net.caffeinemc.mods.sodium.client.render.chunk.TaskQueueType;
+import net.caffeinemc.mods.sodium.client.render.chunk.region.RenderRegion;
+import net.caffeinemc.mods.sodium.client.render.viewport.Viewport;
+
+import java.util.ArrayDeque;
+import java.util.Map;
+
+public interface RenderListProvider extends SortItemsProvider {
+    ObjectArrayList<ChunkRenderList> getUnsortedRenderLists();
+
+    Map<TaskQueueType, ArrayDeque<RenderSection>> getTaskLists();
+
+    boolean orderIsSorted();
+
+    default SortedRenderLists createRenderLists(Viewport viewport) {
+        var sectionPos = viewport.getChunkCoord();
+        var unsorted = this.getUnsortedRenderLists();
+
+        // sort the regions by distance to fix rare region ordering problems.
+        // regions need to be sorted even when the order is generated by a correctly traversed section tree
+        // but sections don't need to be sorted within regions
+        var cameraX = sectionPos.getX() >> RenderRegion.REGION_WIDTH_SH;
+        var cameraY = sectionPos.getY() >> RenderRegion.REGION_HEIGHT_SH;
+        var cameraZ = sectionPos.getZ() >> RenderRegion.REGION_LENGTH_SH;
+
+        var size = unsorted.size();
+        var sortItems = this.ensureSortItemsOfLength(size);
+
+        for (var i = 0; i < size; i++) {
+            var region = unsorted.get(i).getRegion();
+            var x = Math.abs(region.getX() - cameraX);
+            var y = Math.abs(region.getY() - cameraY);
+            var z = Math.abs(region.getZ() - cameraZ);
+            sortItems[i] = (x + y + z) << 16 | i;
+        }
+
+        IntArrays.unstableSort(sortItems, 0, size);
+
+        var sorted = new ObjectArrayList<ChunkRenderList>(size);
+        for (var i = 0; i < size; i++) {
+            var key = sortItems[i];
+            var renderList = unsorted.get(key & 0xFFFF);
+            sorted.add(renderList);
+        }
+
+        for (var list : sorted) {
+            list.prepareForRender(sectionPos, this);
+        }
+
+        return new SortedRenderLists(sorted);
+    }
+}

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/lists/RenderSectionVisitor.java

@@ -0,0 +1,7 @@
+package net.caffeinemc.mods.sodium.client.render.chunk.lists;
+
+import net.caffeinemc.mods.sodium.client.render.chunk.RenderSection;
+
+public interface RenderSectionVisitor {
+    void visit(RenderSection section);
+}

common/src/main/java/net/caffeinemc/mods/sodium/client/render/chunk/lists/SectionCollector.java

@@ -0,0 +1,82 @@
+package net.caffeinemc.mods.sodium.client.render.chunk.lists;
+
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import net.caffeinemc.mods.sodium.client.render.chunk.ChunkUpdateTypes;
+import net.caffeinemc.mods.sodium.client.render.chunk.RenderSection;
+import net.caffeinemc.mods.sodium.client.render.chunk.TaskQueueType;
+import net.caffeinemc.mods.sodium.client.render.chunk.region.RenderRegion;
+
+import java.util.ArrayDeque;
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.Queue;
+
+public abstract class SectionCollector implements RenderListProvider, RenderSectionVisitor {
+    private final int frame;
+    private final TaskQueueType importantRebuildQueueType;
+    private final ObjectArrayList<ChunkRenderList> renderLists;
+    private final EnumMap<TaskQueueType, ArrayDeque<RenderSection>> sortedTaskLists;
+
+    private static int[] sortItems = new int[RenderRegion.REGION_SIZE];
+
+    public SectionCollector(int frame, TaskQueueType importantRebuildQueueType) {
+        this.frame = frame;
+        this.importantRebuildQueueType = importantRebuildQueueType;
+
+        this.renderLists = new ObjectArrayList<>();
+        this.sortedTaskLists = new EnumMap<>(TaskQueueType.class);
+
+        for (var type : TaskQueueType.values()) {
+            this.sortedTaskLists.put(type, new ArrayDeque<>());
+        }
+    }
+
+    @Override
+    public void visit(RenderSection section) {
+        // only process section (and associated render list) if it has content that needs rendering
+        if (section.getFlags() != 0) {
+            RenderRegion region = section.getRegion();
+            ChunkRenderList renderList = region.getRenderList();
+
+            if (renderList.getLastVisibleFrame() != this.frame) {
+                renderList.reset(this.frame, this.orderIsSorted());
+
+                this.renderLists.add(renderList);
+            }
+
+            renderList.add(section);
+        }
+
+        // always add to rebuild lists though, because it might just not be built yet
+        var pendingUpdate = section.getPendingUpdate();
+
+        if (pendingUpdate != 0 && section.getTaskCancellationToken() == null) {
+            var queueType = ChunkUpdateTypes.getQueueType(pendingUpdate, this.importantRebuildQueueType);
+            Queue<RenderSection> queue = this.sortedTaskLists.get(queueType);
+
+            if (queue.size() < queueType.queueSizeLimit()) {
+                queue.add(section);
+            }
+        }
+    }
+
+    @Override
+    public ObjectArrayList<ChunkRenderList> getUnsortedRenderLists() {
+        return this.renderLists;
+    }
+
+    @Override
+    public Map<TaskQueueType, ArrayDeque<RenderSection>> getTaskLists() {
+        return this.sortedTaskLists;
+    }
+
+    @Override
+    public void setCachedSortItems(int[] sortItems) {
+        SectionCollector.sortItems = sortItems;
+    }
+
+    @Override
+    public int[] getCachedSortItems() {
+        return SectionCollector.sortItems;
+    }
+}