Asynchronous Render List Generation and Frame-Independent Task Scheduling

common/src/main/java/net/caffeinemc/mods/sodium/client/gl/arena/staging/FallbackStagingBuffer.java

@@ -8,6 +8,8 @@
 import java.nio.ByteBuffer;
 
 public class FallbackStagingBuffer implements StagingBuffer {
+    private static final float BYTES_PER_NANO_LIMIT = 8_000_000.0f / (1_000_000_000.0f / 60.0f); // MB per frame at 60fps
+
     private final GlMutableBuffer fallbackBufferObject;
 
     public FallbackStagingBuffer(CommandList commandList) {
@@ -39,4 +41,9 @@ public void flip() {
     public String toString() {
         return "Fallback";
     }
+
+    @Override
+    public long getUploadSizeLimit(long frameDuration) {
+        return (long) (frameDuration * BYTES_PER_NANO_LIMIT);
+    }
 }

common/src/main/java/net/caffeinemc/mods/sodium/client/gl/arena/staging/MappedStagingBuffer.java

@@ -15,6 +15,8 @@
 import java.util.List;
 
 public class MappedStagingBuffer implements StagingBuffer {
+    private static final float UPLOAD_LIMIT_MARGIN = 0.8f;
+
     private static final EnumBitField<GlBufferStorageFlags> STORAGE_FLAGS =
             EnumBitField.of(GlBufferStorageFlags.PERSISTENT, GlBufferStorageFlags.CLIENT_STORAGE, GlBufferStorageFlags.MAP_WRITE);
 
@@ -156,6 +158,11 @@ public void flip() {
         }
     }
 
+    @Override
+    public long getUploadSizeLimit(long frameDuration) {
+        return (long) (this.capacity * UPLOAD_LIMIT_MARGIN);
+    }
+
     private static final class CopyCommand {
         private final GlBuffer buffer;
         private final long readOffset;

common/src/main/java/net/caffeinemc/mods/sodium/client/gl/arena/staging/StagingBuffer.java

@@ -13,4 +13,6 @@ public interface StagingBuffer {
     void delete(CommandList commandList);
 
     void flip();
+
+    long getUploadSizeLimit(long frameDuration);
 }

common/src/main/java/net/caffeinemc/mods/sodium/client/gui/SodiumGameOptionPages.java

@@ -14,6 +14,7 @@
 import net.caffeinemc.mods.sodium.client.gui.options.storage.MinecraftOptionsStorage;
 import net.caffeinemc.mods.sodium.client.gui.options.storage.SodiumOptionsStorage;
 import net.caffeinemc.mods.sodium.client.compatibility.workarounds.Workarounds;
+import net.caffeinemc.mods.sodium.client.render.chunk.DeferMode;
 import net.caffeinemc.mods.sodium.client.services.PlatformRuntimeInformation;
 import net.minecraft.client.AttackIndicatorStatus;
 import net.minecraft.client.InactivityFpsLimit;
@@ -279,12 +280,12 @@ public static OptionPage performance() {
                         .setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
                         .build()
                 )
-                .add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
-                        .setName(Component.translatable("sodium.options.always_defer_chunk_updates.name"))
-                        .setTooltip(Component.translatable("sodium.options.always_defer_chunk_updates.tooltip"))
-                        .setControl(TickBoxControl::new)
+                .add(OptionImpl.createBuilder(DeferMode.class, sodiumOpts)
+                        .setName(Component.translatable("sodium.options.defer_chunk_updates.name"))
+                        .setTooltip(Component.translatable("sodium.options.defer_chunk_updates.tooltip"))
+                        .setControl(option -> new CyclingControl<>(option, DeferMode.class))
                         .setImpact(OptionImpact.HIGH)
-                        .setBinding((opts, value) -> opts.performance.alwaysDeferChunkUpdates = value, opts -> opts.performance.alwaysDeferChunkUpdates)
+                        .setBinding((opts, value) -> opts.performance.chunkBuildDeferMode = value, opts -> opts.performance.chunkBuildDeferMode)
                         .setFlags(OptionFlag.REQUIRES_RENDERER_UPDATE)
                         .build())
                 .build()

common/src/main/java/net/caffeinemc/mods/sodium/client/gui/SodiumGameOptions.java

@@ -5,6 +5,7 @@
 import com.google.gson.GsonBuilder;
 import com.google.gson.annotations.SerializedName;
 import net.caffeinemc.mods.sodium.client.gui.options.TextProvider;
+import net.caffeinemc.mods.sodium.client.render.chunk.DeferMode;
 import net.caffeinemc.mods.sodium.client.services.PlatformRuntimeInformation;
 import net.caffeinemc.mods.sodium.client.util.FileUtil;
 import net.caffeinemc.mods.sodium.client.render.chunk.translucent_sorting.SortBehavior;
@@ -37,8 +38,7 @@ public static SodiumGameOptions defaults() {
 
     public static class PerformanceSettings {
         public int chunkBuilderThreads = 0;
-        @SerializedName("always_defer_chunk_updates_v2") // this will reset the option in older configs
-        public boolean alwaysDeferChunkUpdates = true;
+        public DeferMode chunkBuildDeferMode = DeferMode.ALWAYS;
 
         public boolean animateOnlyVisibleTextures = true;
         public boolean useEntityCulling = true;

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

@@ -36,7 +36,6 @@
 import net.minecraft.client.renderer.entity.state.EntityRenderState;
 import net.minecraft.client.resources.model.ModelBakery;
 import net.minecraft.core.BlockPos;
-import net.minecraft.core.SectionPos;
 import net.minecraft.server.level.BlockDestructionProgress;
 import net.minecraft.util.Mth;
 import net.minecraft.util.profiling.Profiler;
@@ -193,48 +192,45 @@ public void setupTerrain(Camera camera,
         float fogDistance = RenderSystem.getShaderFog().end();
 
         if (this.lastCameraPos == null) {
-            this.lastCameraPos = new Vector3d(pos);
+            this.lastCameraPos = pos;
         }
         if (this.lastProjectionMatrix == null) {
             this.lastProjectionMatrix = new Matrix4f(projectionMatrix);
         }
         boolean cameraLocationChanged = !pos.equals(this.lastCameraPos);
         boolean cameraAngleChanged = pitch != this.lastCameraPitch || yaw != this.lastCameraYaw || fogDistance != this.lastFogDistance;
-        boolean cameraProjectionChanged = !projectionMatrix.equals(this.lastProjectionMatrix);
+        boolean cameraProjectionChanged = !projectionMatrix.equals(this.lastProjectionMatrix, 0.0001f);
 
         this.lastProjectionMatrix = projectionMatrix;
 
         this.lastCameraPitch = pitch;
         this.lastCameraYaw = yaw;
 
         if (cameraLocationChanged || cameraAngleChanged || cameraProjectionChanged) {
-            this.renderSectionManager.markGraphDirty();
+            this.renderSectionManager.notifyChangedCamera();
         }
 
         this.lastFogDistance = fogDistance;
 
-        this.renderSectionManager.updateCameraState(pos, camera);
+        this.renderSectionManager.prepareFrame(pos);
 
         if (cameraLocationChanged) {
             profiler.popPush("translucent_triggering");
 
             this.renderSectionManager.processGFNIMovement(new CameraMovement(this.lastCameraPos, pos));
-            this.lastCameraPos = new Vector3d(pos);
+            this.lastCameraPos = pos;
         }
 
         int maxChunkUpdates = updateChunksImmediately ? this.renderDistance : 1;
-
         for (int i = 0; i < maxChunkUpdates; i++) {
-            if (this.renderSectionManager.needsUpdate()) {
-                profiler.popPush("chunk_render_lists");
+            profiler.popPush("chunk_render_lists");
 
-                this.renderSectionManager.update(camera, viewport, spectator);
-            }
+            this.renderSectionManager.updateRenderLists(camera, viewport, spectator, updateChunksImmediately);
 
             profiler.popPush("chunk_update");
 
             this.renderSectionManager.cleanupAndFlip();
-            this.renderSectionManager.updateChunks(updateChunksImmediately);
+            this.renderSectionManager.updateChunks(viewport, updateChunksImmediately);
 
             profiler.popPush("chunk_upload");
 
@@ -255,6 +251,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);
     }
@@ -345,9 +342,8 @@ private void renderBlockEntities(PoseStack matrices,
 
             while (renderSectionIterator.hasNext()) {
                 var renderSectionId = renderSectionIterator.nextByteAsInt();
-                var renderSection = renderRegion.getSection(renderSectionId);
 
-                var blockEntities = renderSection.getCulledBlockEntities();
+                var blockEntities = renderRegion.getCulledBlockEntities(renderSectionId);
 
                 if (blockEntities == null) {
                     continue;
@@ -372,7 +368,7 @@ private void renderGlobalBlockEntities(PoseStack matrices,
                                            LocalPlayer player,
                                            LocalBooleanRef isGlowing) {
         for (var renderSection : this.renderSectionManager.getSectionsWithGlobalEntities()) {
-            var blockEntities = renderSection.getGlobalBlockEntities();
+            var blockEntities = renderSection.getRegion().getGlobalBlockEntities(renderSection.getSectionIndex());
 
             if (blockEntities == null) {
                 continue;
@@ -446,9 +442,7 @@ public void iterateVisibleBlockEntities(Consumer<BlockEntity> blockEntityConsume
 
             while (renderSectionIterator.hasNext()) {
                 var renderSectionId = renderSectionIterator.nextByteAsInt();
-                var renderSection = renderRegion.getSection(renderSectionId);
-
-                var blockEntities = renderSection.getCulledBlockEntities();
+                var blockEntities = renderRegion.getCulledBlockEntities(renderSectionId);
 
                 if (blockEntities == null) {
                     continue;
@@ -461,7 +455,7 @@ public void iterateVisibleBlockEntities(Consumer<BlockEntity> blockEntityConsume
         }
 
         for (var renderSection : this.renderSectionManager.getSectionsWithGlobalEntities()) {
-            var blockEntities = renderSection.getGlobalBlockEntities();
+            var blockEntities = renderSection.getRegion().getGlobalBlockEntities(renderSection.getSectionIndex());
 
             if (blockEntities == null) {
                 continue;
@@ -474,10 +468,13 @@ public void iterateVisibleBlockEntities(Consumer<BlockEntity> blockEntityConsume
     }
 
     // the volume of a section multiplied by the number of sections to be checked at most
-    private static final double MAX_ENTITY_CHECK_VOLUME = 16 * 16 * 16 * 15;
+    private static final double MAX_ENTITY_CHECK_VOLUME = 16 * 16 * 16 * 50;
 
     /**
-     * Returns whether or not the entity intersects with any visible chunks in the graph.
+     * Returns whether the entity intersects with any visible chunks in the graph.
+     *
+     * Note that this method assumes the entity is within the frustum. It does not perform a frustum check.
+     *
      * @return True if the entity is visible, otherwise false
      */
     public <T extends Entity, S extends EntityRenderState> boolean isEntityVisible(EntityRenderer<T, S> renderer, T entity) {
@@ -495,7 +492,7 @@ public <T extends Entity, S extends EntityRenderState> boolean isEntityVisible(E
         // bail on very large entities to avoid checking many sections
         double entityVolume = (bb.maxX - bb.minX) * (bb.maxY - bb.minY) * (bb.maxZ - bb.minZ);
         if (entityVolume > MAX_ENTITY_CHECK_VOLUME) {
-            // TODO: do a frustum check instead, even large entities aren't visible if they're outside the frustum
+            // large entities are only frustum tested, their sections are not checked for visibility
             return true;
         }
 
@@ -509,48 +506,28 @@ public boolean isBoxVisible(double x1, double y1, double z1, double x2, double y
             return true;
         }
 
-        int minX = SectionPos.posToSectionCoord(x1 - 0.5D);
-        int minY = SectionPos.posToSectionCoord(y1 - 0.5D);
-        int minZ = SectionPos.posToSectionCoord(z1 - 0.5D);
-
-        int maxX = SectionPos.posToSectionCoord(x2 + 0.5D);
-        int maxY = SectionPos.posToSectionCoord(y2 + 0.5D);
-        int maxZ = SectionPos.posToSectionCoord(z2 + 0.5D);
-
-        for (int x = minX; x <= maxX; x++) {
-            for (int z = minZ; z <= maxZ; z++) {
-                for (int y = minY; y <= maxY; y++) {
-                    if (this.renderSectionManager.isSectionVisible(x, y, z)) {
-                        return true;
-                    }
-                }
-            }
-        }
-
-        return false;
+        return this.renderSectionManager.isBoxVisible(x1, y1, z1, x2, y2, z2);
     }
 
     public String getChunksDebugString() {
-        // C: visible/total D: distance
-        // TODO: add dirty and queued counts
-        return String.format("C: %d/%d D: %d", this.renderSectionManager.getVisibleChunkCount(), this.renderSectionManager.getTotalSections(), this.renderDistance);
+        return this.renderSectionManager.getChunksDebugString();
     }
 
     /**
      * Schedules chunk rebuilds for all chunks in the specified block region.
      */
-    public void scheduleRebuildForBlockArea(int minX, int minY, int minZ, int maxX, int maxY, int maxZ, boolean important) {
-        this.scheduleRebuildForChunks(minX >> 4, minY >> 4, minZ >> 4, maxX >> 4, maxY >> 4, maxZ >> 4, important);
+    public void scheduleRebuildForBlockArea(int minX, int minY, int minZ, int maxX, int maxY, int maxZ, boolean playerChanged) {
+        this.scheduleRebuildForChunks(minX >> 4, minY >> 4, minZ >> 4, maxX >> 4, maxY >> 4, maxZ >> 4, playerChanged);
     }
 
     /**
      * Schedules chunk rebuilds for all chunks in the specified chunk region.
      */
-    public void scheduleRebuildForChunks(int minX, int minY, int minZ, int maxX, int maxY, int maxZ, boolean important) {
+    public void scheduleRebuildForChunks(int minX, int minY, int minZ, int maxX, int maxY, int maxZ, boolean playerChanged) {
         for (int chunkX = minX; chunkX <= maxX; chunkX++) {
             for (int chunkY = minY; chunkY <= maxY; chunkY++) {
                 for (int chunkZ = minZ; chunkZ <= maxZ; chunkZ++) {
-                    this.scheduleRebuildForChunk(chunkX, chunkY, chunkZ, important);
+                    this.scheduleRebuildForChunk(chunkX, chunkY, chunkZ, playerChanged);
                 }
             }
         }
@@ -559,8 +536,8 @@ public void scheduleRebuildForChunks(int minX, int minY, int minZ, int maxX, int
     /**
      * Schedules a chunk rebuild for the render belonging to the given chunk section position.
      */
-    public void scheduleRebuildForChunk(int x, int y, int z, boolean important) {
-        this.renderSectionManager.scheduleRebuild(x, y, z, important);
+    public void scheduleRebuildForChunk(int x, int y, int z, boolean playerChanged) {
+        this.renderSectionManager.scheduleRebuild(x, y, z, playerChanged);
     }
 
     public Collection<String> getDebugStrings() {

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

@@ -1,24 +1,46 @@
 package net.caffeinemc.mods.sodium.client.render.chunk;
 
-import net.caffeinemc.mods.sodium.client.render.chunk.compile.executor.ChunkBuilder;
+import org.jetbrains.annotations.NotNull;
 
+/**
+ * Important: Whether the task is scheduled immediately after its creation. Otherwise, they're scheduled through asynchronous culling that collects non-important tasks.
+ * Defer mode: For important tasks, how fast they are going to be executed. One or zero frame deferral only allows one or zero frames to pass before the frame blocks on the task. Always deferral allows the task to be deferred indefinitely, but if it's important it will still be put to the front of the queue.
+ */
 public enum ChunkUpdateType {
-    SORT(Integer.MAX_VALUE, ChunkBuilder.LOW_EFFORT),
-    INITIAL_BUILD(128, ChunkBuilder.HIGH_EFFORT),
-    REBUILD(Integer.MAX_VALUE, ChunkBuilder.HIGH_EFFORT),
-    IMPORTANT_REBUILD(Integer.MAX_VALUE, ChunkBuilder.HIGH_EFFORT),
-    IMPORTANT_SORT(Integer.MAX_VALUE, ChunkBuilder.LOW_EFFORT);
-
-    private final int maximumQueueSize;
-    private final int taskEffort;
-
-    ChunkUpdateType(int maximumQueueSize, int taskEffort) {
-        this.maximumQueueSize = maximumQueueSize;
-        this.taskEffort = taskEffort;
+    SORT(2),
+    INITIAL_BUILD(0),
+    REBUILD(1),
+    IMPORTANT_REBUILD(DeferMode.ZERO_FRAMES, 1),
+    IMPORTANT_SORT(DeferMode.ZERO_FRAMES, 2);
+
+    private final DeferMode deferMode;
+    private final boolean important;
+    private final float priorityValue;
+
+    ChunkUpdateType(float priorityValue) {
+        this.deferMode = DeferMode.ALWAYS;
+        this.important = false;
+        this.priorityValue = priorityValue;
+    }
+
+    ChunkUpdateType(@NotNull DeferMode deferMode, float priorityValue) {
+        this.deferMode = deferMode;
+        this.important = true;
+        this.priorityValue = priorityValue;
     }
 
-    public static ChunkUpdateType getPromotionUpdateType(ChunkUpdateType prev, ChunkUpdateType next) {
-        if (prev == null || prev == SORT || prev == next) {
+    /**
+     * Returns a promoted update type if the new update type is more important than the previous one. Nothing is returned if the update type is the same or less important.
+     *
+     * @param prev Previous update type
+     * @param next New update type
+     * @return Promoted update type or {@code null} if the update type is the same or less important
+     */
+    public static ChunkUpdateType getPromotedTypeChange(ChunkUpdateType prev, ChunkUpdateType next) {
+        if (prev == next) {
+            return null;
+        }
+        if (prev == null || prev == SORT || prev == INITIAL_BUILD) {
             return next;
         }
         if (next == IMPORTANT_REBUILD
@@ -29,15 +51,15 @@ public static ChunkUpdateType getPromotionUpdateType(ChunkUpdateType prev, Chunk
         return null;
     }
 
-    public int getMaximumQueueSize() {
-        return this.maximumQueueSize;
+    public boolean isImportant() {
+        return this.important;
     }
 
-    public boolean isImportant() {
-        return this == IMPORTANT_REBUILD || this == IMPORTANT_SORT;
+    public DeferMode getDeferMode(DeferMode importantRebuildDeferMode) {
+        return this == IMPORTANT_REBUILD ? importantRebuildDeferMode : this.deferMode;
     }
 
-    public int getTaskEffort() {
-        return this.taskEffort;
+    public float getPriorityValue() {
+        return this.priorityValue;
     }
 }