feat: Combined depth for RenderWorldLastEvent

Author: basdxz

src/main/java/com/ventooth/swansong/mixin/mixins/client/hooks/EntityRendererMixin.java

@@ -132,9 +132,12 @@ private boolean renderWorld_anaglyph(GameSettings instance) {
                             remap = false),
                    require = 1)
     private void hook_RenderLastAndEndRenderWorld(RenderGlobal rg, float subTick, Operation<Void> original) {
-        original.call(rg, subTick);
         if (ShaderEngine.isInitialized()) {
+            ShaderEngine.preRenderLast();
+            original.call(rg, subTick);
             ShaderEngine.finishRenderFinal();
+        } else {
+            original.call(rg, subTick);
         }
     }
 

src/main/java/com/ventooth/swansong/shader/ShaderEngine.java

@@ -64,6 +64,7 @@
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.world.WorldProvider;
 import net.minecraftforge.client.ForgeHooksClient;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
 
 import java.nio.DoubleBuffer;
 import java.util.ArrayList;
@@ -783,9 +784,37 @@ public static void beginRenderWorld() {
         renderShadowMap();
     }
 
+    /**
+     * Experimental feature that might either be just left in, or put behind a toggle depending on perf overhead.
+     * <p>
+     * What we're doing is handing whatever will render in the {@link RenderWorldLastEvent} depth that excludes translucent geometry.
+     * <p>
+     * This is closer to what vanilla does, but in turn this will cost us an additional 3 full-screen depth blits.
+     */
+    private static final boolean COMBINED_DEPTH = true;
+
+    public static void preRenderLast() {
+        if (COMBINED_DEPTH) {
+            DebugMarker.GENERIC.insert("PRE_SAVE_DEPTH_0");
+            blitDepth(buffers.gDepthTex, buffers.depthTex0);
+            DebugMarker.GENERIC.insert("POST_SAVE_DEPTH_0");
+
+            DebugMarker.GENERIC.insert("PRE_LOAD_DEPTH_1");
+            GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
+            blitDepth(buffers.depthTex1, buffers.gDepthTex);
+            DebugMarker.GENERIC.insert("POST_LOAD_DEPTH_1");
+        }
+    }
+
     public static void finishRenderFinal() {
         ShaderState.updateRenderStage(MCRenderStage.NONE);
 
+        if (COMBINED_DEPTH) {
+            DebugMarker.GENERIC.insert("PRE_COMBINE_DEPTH");
+            blitDepth(buffers.depthTex0, buffers.gDepthTex, true);
+            DebugMarker.GENERIC.insert("POST_COMBINE_DEPTH");
+        }
+
         captureLastDepth();
         // Composite first
         renderComposite();
@@ -1156,6 +1185,10 @@ public static void blitColors(Int2ObjectMap<Texture2D> src, Int2ObjectMap<Textur
     }
 
     public static void blitDepth(Texture2D srcTex, Texture2D dstTex) {
+        blitDepth(srcTex, dstTex, false);
+    }
+
+    public static void blitDepth(Texture2D srcTex, Texture2D dstTex, boolean combine) {
         if (state == null) {
             Share.log.warn("Tried to blit depth with no state");
             return;
@@ -1183,10 +1216,12 @@ public static void blitDepth(Texture2D srcTex, Texture2D dstTex) {
         // Bind Destination Texture
         dstTex.attachToFramebufferDepth();
 
-        GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
+        if (!combine) {
+            GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
+        }
 
         // Draw using the regular composite (with depth only)
-        ShadersCompositeMesh.drawWithDepth();
+        ShadersCompositeMesh.drawWithDepth(combine);
 
         if (DebugMarker.isEnabled()) {
             DebugMarker.TEXTURE_DEPTH_BLIT.insertFormat("{0} -> {1}", srcTex.name(), dstTex.name());

src/main/java/com/ventooth/swansong/shader/ShadersCompositeMesh.java

@@ -38,8 +38,8 @@ public static void drawWithAnaglyphField(int field) {
         }
     }
 
-    public static void drawWithDepth() {
-        draw(Mask.Depth);
+    public static void drawWithDepth(boolean combine) {
+        draw(combine ? Mask.DepthCombine : Mask.Depth);
     }
 
     public static void draw(Mask mask) {
@@ -60,10 +60,15 @@ public static void draw(Mask mask) {
         GL11.glEnable(GL11.GL_TEXTURE_2D);
         GL11.glDisable(GL11.GL_ALPHA_TEST);
         GL11.glDisable(GL11.GL_BLEND);
-        GL11.glEnable(GL11.GL_DEPTH_TEST);
-        GL11.glDepthFunc(GL11.GL_ALWAYS);
         GL11.glDisable(GL11.GL_LIGHTING);
 
+        GL11.glEnable(GL11.GL_DEPTH_TEST);
+        if (mask == Mask.DepthCombine) {
+            GL11.glDepthFunc(GL11.GL_LEQUAL);
+        } else {
+            GL11.glDepthFunc(GL11.GL_ALWAYS);
+        }
+
         switch (mask) {
             case Color -> {
                 GL11.glDepthMask(false);
@@ -77,7 +82,7 @@ public static void draw(Mask mask) {
                 GL11.glDepthMask(false);
                 GL11.glColorMask(false, true, true, false);
             }
-            case Depth -> {
+            case Depth, DepthCombine -> {
                 GL11.glDepthMask(true);
                 GL11.glColorMask(false, false, false, false);
             }
@@ -178,6 +183,7 @@ public enum Mask {
         AnaglyphRed,
         AnaglyphCyan,
         Depth,
+        DepthCombine,
         Both
     }
 }