Merge remote-tracking branch 'origin/20.1/forge' into 20.6/neoforge

build.gradle.kts

@@ -183,6 +183,10 @@ publishMods {
         incompatible {
             slug = "rubidium"
         }
+
+        incompatible {
+            slug = "textrues-embeddium-options"
+        }
     }
     modrinth {
         projectId = "sk9rgfiA"
@@ -192,6 +196,10 @@ publishMods {
         incompatible {
             slug = "rubidium"
         }
+
+        incompatible {
+            slug = "textrues-embeddium-options"
+        }
     }
 
     displayName = "[${"minecraft_version"()}] Embeddium ${"mod_version"()}"

src/main/java/me/jellysquid/mods/sodium/client/gl/arena/GlBufferArena.java

@@ -18,8 +18,12 @@ public class GlBufferArena {
     static final boolean CHECK_ASSERTIONS = false;
 
     private static final GlBufferUsage BUFFER_USAGE = GlBufferUsage.STATIC_DRAW;
+    /**
+     * When the arena needs to be grown, it will generally attempt to increase its size by (1 / RESIZE_FACTOR).
+     */
+    private static final int RESIZE_FACTOR = 2;
 
-    private final int resizeIncrement;
+    private int resizeIncrement;
 
     private final StagingBuffer stagingBuffer;
     private GlMutableBuffer arenaBuffer;
@@ -33,7 +37,7 @@ public class GlBufferArena {
 
     public GlBufferArena(CommandList commands, int initialCapacity, int stride, StagingBuffer stagingBuffer) {
         this.capacity = initialCapacity;
-        this.resizeIncrement = initialCapacity / 16;
+        this.resizeIncrement = initialCapacity / RESIZE_FACTOR;
 
         this.stride = stride;
 
@@ -134,6 +138,7 @@ private void transferSegments(CommandList commandList, Collection<PendingBufferC
 
         this.arenaBuffer = dstBufferObj;
         this.capacity = capacity;
+        this.resizeIncrement = this.capacity / RESIZE_FACTOR;
     }
 
     private ArrayList<GlBufferSegment> getUsedSegments() {

src/main/java/me/jellysquid/mods/sodium/client/gui/SodiumGameOptionPages.java

@@ -267,6 +267,19 @@ public static OptionPage quality() {
                         .build())
                 .build());
 
+        groups.add(OptionGroup.createBuilder()
+                .setId(StandardOptions.Group.SORTING)
+                .add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
+                        .setId(StandardOptions.Option.TRANSLUCENT_FACE_SORTING)
+                        .setName(Component.translatable("sodium.options.translucent_face_sorting.name"))
+                        .setTooltip(Component.translatable("sodium.options.translucent_face_sorting.tooltip"))
+                        .setControl(TickBoxControl::new)
+                        .setImpact(OptionImpact.VARIES)
+                        .setBinding((opts, value) -> opts.performance.useTranslucentFaceSorting = value, opts -> opts.performance.useTranslucentFaceSorting)
+                        .setEnabled(!ShaderModBridge.isNvidiumEnabled())
+                        .setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
+                        .build())
+                .build());
 
         return new OptionPage(Component.translatable("sodium.options.pages.quality"), ImmutableList.copyOf(groups));
     }
@@ -397,17 +410,6 @@ public static OptionPage advanced() {
                         .setBinding((opts, value) -> opts.advanced.cpuRenderAheadLimit = value, opts -> opts.advanced.cpuRenderAheadLimit)
                         .build()
                 )
-                .add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
-                        .setId(StandardOptions.Option.TRANSLUCENT_FACE_SORTING)
-                        .setName(Component.translatable("sodium.options.translucent_face_sorting.name"))
-                        .setTooltip(Component.translatable("sodium.options.translucent_face_sorting.tooltip"))
-                        .setControl(TickBoxControl::new)
-                        .setImpact(OptionImpact.VARIES)
-                        .setBinding((opts, value) -> opts.performance.useTranslucentFaceSorting = value, opts -> opts.performance.useTranslucentFaceSorting)
-                        .setEnabled(!ShaderModBridge.isNvidiumEnabled())
-                        .setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
-                        .build()
-                )
                 .build());
 
         return new OptionPage(Component.translatable("sodium.options.pages.advanced"), ImmutableList.copyOf(groups));

src/main/java/me/jellysquid/mods/sodium/client/render/chunk/DefaultChunkRenderer.java

@@ -35,6 +35,8 @@ public class DefaultChunkRenderer extends ShaderChunkRenderer {
 
     private final GlVertexAttributeBinding[] vertexAttributeBindings;
 
+    private boolean isIndexedPass;
+
     public DefaultChunkRenderer(RenderDevice device, ChunkVertexType vertexType) {
         super(device, vertexType);
 
@@ -60,6 +62,8 @@ public void render(ChunkRenderMatrices matrices,
 
         Iterator<ChunkRenderList> iterator = renderLists.iterator(renderPass.isReverseOrder());
 
+        this.isIndexedPass = renderPass.isSorted();
+
         while (iterator.hasNext()) {
             ChunkRenderList renderList = iterator.next();
 
@@ -76,7 +80,11 @@ public void render(ChunkRenderMatrices matrices,
                 continue;
             }
 
-            this.sharedIndexBuffer.ensureCapacity(commandList, this.batch.getIndexBufferSize());
+
+
+            if (!this.isIndexedPass) {
+                this.sharedIndexBuffer.ensureCapacity(commandList, this.batch.getIndexBufferSize());
+            }
 
             var tessellation = this.prepareTessellation(commandList, region);
 
@@ -106,6 +114,8 @@ private static void fillCommandBuffer(MultiDrawBatch batch,
         int originY = renderRegion.getChunkY();
         int originZ = renderRegion.getChunkZ();
 
+        int indexPointerMask = pass.isSorted() ? 0xFFFFFFFF : 0;
+
         while (iterator.hasNext()) {
             int sectionIndex = iterator.nextByteAsInt();
 
@@ -117,7 +127,7 @@ private static void fillCommandBuffer(MultiDrawBatch batch,
 
             int slices;
 
-            if (useBlockFaceCulling && (!pass.isReverseOrder() || !SodiumClientMod.canApplyTranslucencySorting())) {
+            if (useBlockFaceCulling && !pass.isSorted()) {
                 slices = getVisibleFaces(camera.intX, camera.intY, camera.intZ, chunkX, chunkY, chunkZ);
             } else {
                 slices = ModelQuadFacing.ALL;
@@ -126,21 +136,23 @@ private static void fillCommandBuffer(MultiDrawBatch batch,
             slices &= SectionRenderDataUnsafe.getSliceMask(pMeshData);
 
             if (slices != 0) {
-                addDrawCommands(batch, pMeshData, slices);
+                addDrawCommands(batch, pMeshData, slices, indexPointerMask);
             }
         }
     }
 
     @SuppressWarnings("IntegerMultiplicationImplicitCastToLong")
-    private static void addDrawCommands(MultiDrawBatch batch, long pMeshData, int mask) {
+    private static void addDrawCommands(MultiDrawBatch batch, long pMeshData, int mask, int indexPointerMask) {
         final var pBaseVertex = batch.pBaseVertex;
         final var pElementCount = batch.pElementCount;
+        final var pElementPointer = batch.pElementPointer;
 
         int size = batch.size;
 
         for (int facing = 0; facing < ModelQuadFacing.COUNT; facing++) {
             MemoryUtil.memPutInt(pBaseVertex + (size << 2), SectionRenderDataUnsafe.getVertexOffset(pMeshData, facing));
             MemoryUtil.memPutInt(pElementCount + (size << 2), SectionRenderDataUnsafe.getElementCount(pMeshData, facing));
+            MemoryUtil.memPutAddress(pElementPointer + (size << 3), SectionRenderDataUnsafe.getIndexOffset(pMeshData, facing) & indexPointerMask);
 
             size += (mask >> facing) & 1;
         }
@@ -213,10 +225,15 @@ private static float getCameraTranslation(int chunkBlockPos, int cameraBlockPos,
 
     private GlTessellation prepareTessellation(CommandList commandList, RenderRegion region) {
         var resources = region.getResources();
-        var tessellation = resources.getTessellation();
+        var tessellation = this.isIndexedPass ? resources.getIndexedTessellation() : resources.getTessellation();
 
         if (tessellation == null) {
-            resources.updateTessellation(commandList, tessellation = this.createRegionTessellation(commandList, resources));
+            tessellation = this.createRegionTessellation(commandList, resources);
+            if (this.isIndexedPass) {
+                resources.updateIndexedTessellation(commandList, tessellation);
+            } else {
+                resources.updateTessellation(commandList, tessellation);
+            }
         }
 
         return tessellation;
@@ -253,7 +270,7 @@ private GlVertexAttributeBinding[] getBindingsForType() {
     private GlTessellation createRegionTessellation(CommandList commandList, RenderRegion.DeviceResources resources) {
         return commandList.createTessellation(GlPrimitiveType.TRIANGLES, new TessellationBinding[] {
                 TessellationBinding.forVertexBuffer(resources.getVertexBuffer(), this.vertexAttributeBindings),
-                TessellationBinding.forElementBuffer(this.sharedIndexBuffer.getBufferObject())
+                TessellationBinding.forElementBuffer(this.isIndexedPass ? resources.getIndexBuffer() : this.sharedIndexBuffer.getBufferObject())
         });
     }
 

src/main/java/me/jellysquid/mods/sodium/client/render/chunk/RenderSection.java

@@ -1,6 +1,5 @@
 package me.jellysquid.mods.sodium.client.render.chunk;
 
-import me.jellysquid.mods.sodium.client.render.chunk.compile.ChunkBufferSorter;
 import me.jellysquid.mods.sodium.client.render.chunk.data.BuiltSectionInfo;
 import me.jellysquid.mods.sodium.client.render.chunk.occlusion.GraphDirection;
 import me.jellysquid.mods.sodium.client.render.chunk.occlusion.GraphDirectionSet;
@@ -11,6 +10,7 @@
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.SectionPos;
 import net.minecraft.world.level.block.entity.BlockEntity;
+import org.embeddedt.embeddium.render.chunk.sorting.TranslucentQuadAnalyzer;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -49,7 +49,7 @@ public class RenderSection {
     private BlockEntity @Nullable[] culledBlockEntities;
     private TextureAtlasSprite @Nullable[] animatedSprites;
 
-    private ChunkBufferSorter.SortBuffer translucencyData;
+    private TranslucentQuadAnalyzer.SortState sortState;
 
 
     // Pending Update State
@@ -65,6 +65,9 @@ public class RenderSection {
     // Lifetime state
     private boolean disposed;
 
+    // Used by the translucency sorter, to determine when a section needs sorting again
+    public double lastCameraX, lastCameraY, lastCameraZ;
+
     public RenderSection(RenderRegion region, int chunkX, int chunkY, int chunkZ) {
         this.chunkX = chunkX;
         this.chunkY = chunkY;
@@ -285,6 +288,10 @@ public int getFlags() {
         return this.flags;
     }
 
+    public boolean isAlignedWithSectionOnGrid(int otherX, int otherY, int otherZ) {
+        return this.chunkX == otherX || this.chunkY == otherY || this.chunkZ == otherZ;
+    }
+
     /**
      * Returns the occlusion culling data which determines this chunk's connectedness on the visibility graph.
      */
@@ -314,12 +321,17 @@ public long getVisibilityData() {
         return this.globalBlockEntities;
     }
 
-    public ChunkBufferSorter.SortBuffer getTranslucencyData() {
-        return this.translucencyData;
+    @Nullable
+    public TranslucentQuadAnalyzer.SortState getSortState() {
+        return this.sortState;
+    }
+
+    public boolean containsTranslucentGeometry() {
+        return (this.getFlags() & (1 << RenderSectionFlags.HAS_TRANSLUCENT_DATA)) != 0;
     }
 
-    public void setTranslucencyData(ChunkBufferSorter.SortBuffer data) {
-        this.translucencyData = data;
+    public void setSortState(@Nullable TranslucentQuadAnalyzer.SortState data) {
+        this.sortState = data != null ? data.compactForStorage() : null;
     }
 
     public @Nullable CancellationToken getBuildCancellationToken() {