Fix quad render pass optimization bug with certain multi-layer models

FiniteReality · FiniteReality · commit fcd5137288f8 · 2025-01-22T16:38:05.000Z
Models such as the XyCraft Override Observer incorrectly rendered the wrong
quads as the top layer. This commit fixes that bug such that they render
correctly.
diff --git a/src/main/java/org/embeddedt/embeddium/impl/mixin/core/model/quad/BakedQuadMixin.java b/src/main/java/org/embeddedt/embeddium/impl/mixin/core/model/quad/BakedQuadMixin.java
@@ -1,12 +1,16 @@
 package org.embeddedt.embeddium.impl.mixin.core.model.quad;
 
 import org.embeddedt.embeddium.impl.model.quad.BakedQuadView;
+import org.embeddedt.embeddium.impl.model.quad.ModelQuad;
 import org.embeddedt.embeddium.impl.model.quad.properties.ModelQuadFacing;
 import org.embeddedt.embeddium.impl.model.quad.properties.ModelQuadFlags;
+import org.embeddedt.embeddium.impl.render.chunk.sprite.SpriteTransparencyLevel;
+import org.embeddedt.embeddium.impl.render.chunk.sprite.SpriteTransparencyLevelHolder;
 import org.embeddedt.embeddium.impl.util.ModelQuadUtil;
 import net.minecraft.client.renderer.block.model.BakedQuad;
 import net.minecraft.client.renderer.texture.TextureAtlasSprite;
 import net.minecraft.core.Direction;
+import org.jetbrains.annotations.Nullable;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -98,7 +102,7 @@ public int getForgeNormal(int idx) {
     public int getFlags() {
         int f = this.flags;
         if ((f & ModelQuadFlags.IS_POPULATED) == 0) {
-            this.flags = f = (f | ModelQuadFlags.getQuadFlags(this, direction));
+            this.flags = f = ModelQuadFlags.getQuadFlags(this, direction, f);
         }
         return f;
     }
@@ -108,6 +112,15 @@ public void setFlags(int flags) {
         this.flags = flags;
     }
 
+    @Override
+    public @Nullable SpriteTransparencyLevel getTransparencyLevel() {
+        if (this.sprite != null && (this.flags & ModelQuadFlags.IS_TRUSTED_SPRITE) != 0) {
+            return SpriteTransparencyLevelHolder.getTransparencyLevel(this.sprite);
+        } else {
+            return null;
+        }
+    }
+
     @Override
     public int getColorIndex() {
         return this.tintIndex;
diff --git a/src/main/java/org/embeddedt/embeddium/impl/model/quad/BakedQuadView.java b/src/main/java/org/embeddedt/embeddium/impl/model/quad/BakedQuadView.java
@@ -1,11 +1,15 @@
 package org.embeddedt.embeddium.impl.model.quad;
 
 import org.embeddedt.embeddium.impl.model.quad.properties.ModelQuadFacing;
+import org.embeddedt.embeddium.impl.render.chunk.sprite.SpriteTransparencyLevel;
+import org.jetbrains.annotations.Nullable;
 
 public interface BakedQuadView extends ModelQuadView {
     ModelQuadFacing getNormalFace();
     
     boolean hasShade();
 
     void setFlags(int flags);
+
+    @Nullable SpriteTransparencyLevel getTransparencyLevel();
 }
diff --git a/src/main/java/org/embeddedt/embeddium/impl/model/quad/properties/ModelQuadFlags.java b/src/main/java/org/embeddedt/embeddium/impl/model/quad/properties/ModelQuadFlags.java
@@ -1,5 +1,6 @@
 package org.embeddedt.embeddium.impl.model.quad.properties;
 
+import org.embeddedt.embeddium.api.util.ColorABGR;
 import org.embeddedt.embeddium.impl.model.quad.ModelQuadView;
 import net.minecraft.client.renderer.block.model.BakedQuad;
 import net.minecraft.core.Direction;
@@ -8,28 +9,35 @@ public class ModelQuadFlags {
     /**
      * Indicates that the quad does not fully cover the given face for the model.
      */
-    public static final int IS_PARTIAL = 0b001;
+    public static final int IS_PARTIAL = (1 << 0);
 
     /**
      * Indicates that the quad is parallel to its light face.
      */
-    public static final int IS_PARALLEL = 0b010;
+    public static final int IS_PARALLEL = (1 << 1);
 
     /**
      * Indicates that the quad is aligned to the block grid.
      * This flag is only set if {@link #IS_PARALLEL} is set.
      */
-    public static final int IS_ALIGNED = 0b100;
+    public static final int IS_ALIGNED = (1 << 2);
 
     /**
      * Indicates that the quad should be shaded using vanilla's getShade logic and the light face, rather than
      * the normals of each vertex.
      */
-    public static final int IS_VANILLA_SHADED = 0b1000;
+    public static final int IS_VANILLA_SHADED = (1 << 3);
+
     /**
      * Indicates that the particle sprite on this quad can be trusted to be the only sprite it shows.
      */
     public static final int IS_TRUSTED_SPRITE = (1 << 4);
+
+    /**
+     * Indicates that this quad can use a more optimal terrain render pass based on its sprite.
+     */
+    public static final int IS_PASS_OPTIMIZABLE = (1 << 5);
+
     /**
      * Indicates that the flags are populated for the quad.
      */
@@ -46,7 +54,7 @@ public static boolean contains(int flags, int mask) {
      * Calculates the properties of the given quad. This data is used later by the light pipeline in order to make
      * certain optimizations.
      */
-    public static int getQuadFlags(ModelQuadView quad, Direction face) {
+    public static int getQuadFlags(ModelQuadView quad, Direction face, int existingFlags) {
         float minX = 32.0F;
         float minY = 32.0F;
         float minZ = 32.0F;
@@ -61,7 +69,7 @@ public static int getQuadFlags(ModelQuadView quad, Direction face) {
         }
 
         float lX = Float.NaN, lY = Float.NaN, lZ = Float.NaN;
-        boolean degenerate = false;
+        boolean degenerate = false, nonOpaqueColor = false;
 
         for (int i = 0; i < numVertices; ++i) {
             float x = quad.getX(i);
@@ -82,6 +90,10 @@ public static int getQuadFlags(ModelQuadView quad, Direction face) {
                 lY = y;
                 lZ = z;
             }
+
+            if (ColorABGR.unpackAlpha(quad.getColor(i)) != 255) {
+                nonOpaqueColor = true;
+            }
         }
 
         boolean partial = degenerate || (switch (face.getAxis()) {
@@ -105,7 +117,7 @@ public static int getQuadFlags(ModelQuadView quad, Direction face) {
             case EAST -> maxX > 0.9999F;
         };
 
-        int flags = 0;
+        int flags = existingFlags & ~(IS_PARTIAL | IS_PARALLEL | IS_ALIGNED);
 
         if (partial) {
             flags |= IS_PARTIAL;
@@ -119,6 +131,10 @@ public static int getQuadFlags(ModelQuadView quad, Direction face) {
             flags |= IS_ALIGNED;
         }
 
+        if (!nonOpaqueColor && (flags & IS_TRUSTED_SPRITE) != 0) {
+            flags |= IS_PASS_OPTIMIZABLE;
+        }
+
         flags |= IS_POPULATED;
 
         return flags;
diff --git a/src/main/java/org/embeddedt/embeddium/impl/render/chunk/compile/pipeline/BlockRenderer.java b/src/main/java/org/embeddedt/embeddium/impl/render/chunk/compile/pipeline/BlockRenderer.java
@@ -64,13 +64,6 @@ public class BlockRenderer {
 
     private final int[] quadColors = new int[4];
 
-    /**
-     * Tracks whether the MC-138211 quad reorienting fix should be applied during emission of quad geometry.
-     * This fix must be disabled with certain modded models that use superimposed quads, as it can alter the triangulation
-     * of some layers but not others, resulting in Z-fighting.
-     */
-    private boolean useReorienting;
-
     /**
      * The list of registered custom block renderers. These may augment or fully bypass the model system for the
      * block.
@@ -81,7 +74,37 @@ public class BlockRenderer {
 
     private final ChunkColorWriter colorEncoder = ChunkColorWriter.get();
 
-    private final boolean useRenderPassOptimization;
+    /**
+     * If {@code true}, the {@link #QUAD_RENDER_PASS_OPTIMIZATION} flag will be enabled.
+     */
+    private final boolean enableRenderPassOptimization;
+
+    /**
+     * No changes should be applied when rendering quads.
+     */
+    private static final int QUAD_FLAGS_NONE = 0x0;
+    /**
+     * If specified, the MC-138211 quad reorienting fix should be applied during emission of quad geometry.
+     * This fix must be disabled with certain modded models that use superimposed quads, as it can alter the triangulation
+     * of some layers but not others, resulting in Z-fighting.
+     */
+    private static final int QUAD_REORIENTING = 0x1;
+    /**
+     * If specified, quads will be placed in differing render passes than what is specified. This can help avoid
+     * GPU bottlenecks by running the fragment shader on pixels which aren't visible anyway.
+     * @see <a href="https://www.khronos.org/opengl/wiki/Early_Fragment_Test">Early Fragment Test</a>
+     */
+    private static final int QUAD_RENDER_PASS_OPTIMIZATION = 0x2;
+    /**
+     * If specified, all changes should be applied when rendering quads.
+     */
+    private static final int QUAD_FLAGS_ALL = QUAD_REORIENTING | QUAD_RENDER_PASS_OPTIMIZATION;
+
+    /**
+     * Quad flags used to control how quads are emitted/rendered.
+     * These take the values of the {@code QUAD_} constants specified in this class.
+     */
+    private int quadRenderingFlags = QUAD_FLAGS_NONE;
 
     public BlockRenderer(ColorProviderRegistry colorRegistry, LightPipelineProvider lighters) {
         this.colorProviderRegistry = colorRegistry;
@@ -90,7 +113,7 @@ public BlockRenderer(ColorProviderRegistry colorRegistry, LightPipelineProvider
         this.occlusionCache = new BlockOcclusionCache();
         this.useAmbientOcclusion = Minecraft.useAmbientOcclusion();
         this.fabricModelRenderingHandler = FRAPIRenderHandler.INDIGO_PRESENT ? new IndigoBlockRenderContext(this.occlusionCache, lighters.getLightData()) : null;
-        this.useRenderPassOptimization = Embeddium.options().performance.useRenderPassOptimization && !ShaderModBridge.areShadersEnabled();
+        this.enableRenderPassOptimization = Embeddium.options().performance.useRenderPassOptimization && !ShaderModBridge.areShadersEnabled();
     }
 
     /**
@@ -137,26 +160,22 @@ public void renderModel(BlockRenderContext ctx, ChunkBuildBuffers buffers) {
             return;
         }
 
-        boolean canReorientNullCullface = true;
+        var nullCullfaceFlags = QUAD_FLAGS_ALL;
 
         for (Direction face : DirectionUtil.ALL_DIRECTIONS) {
             List<BakedQuad> quads = this.getGeometry(ctx, face);
 
             if (!quads.isEmpty() && this.isFaceVisible(ctx, face)) {
-                this.useReorienting = true;
+                this.quadRenderingFlags = QUAD_FLAGS_ALL;
                 this.renderQuadList(ctx, material, lighter, colorizer, renderOffset, buffers, meshBuilder, quads, face);
-                if (!this.useReorienting) {
-                    // Reorienting was disabled on this side, make sure it's disabled for the null cullface too, in case
-                    // a mod layers textures in different lists
-                    canReorientNullCullface = false;
-                }
+                nullCullfaceFlags &= this.quadRenderingFlags;
             }
         }
 
         List<BakedQuad> all = this.getGeometry(ctx, null);
 
         if (!all.isEmpty()) {
-            this.useReorienting = canReorientNullCullface;
+            this.quadRenderingFlags = nullCullfaceFlags;
             this.renderQuadList(ctx, material, lighter, colorizer, renderOffset, buffers, meshBuilder, all, null);
         }
     }
@@ -186,32 +205,54 @@ private static int computeLightFlagMask(BakedQuad quad) {
         return flag;
     }
 
-    /**
-     * {@return true if all quads in the given list use similar enough lighting configuration that reorientation is
-     * unlikely to lead to z-fighting}
-     */
-    private static boolean checkQuadsHaveSameLightingConfig(List<BakedQuad> quads) {
+    private SpriteTransparencyLevel getQuadTransparencyLevel(BakedQuadView quad) {
+        if ((quad.getFlags() & ModelQuadFlags.IS_PASS_OPTIMIZABLE) == 0 || quad.getSprite() == null) {
+            return SpriteTransparencyLevel.TRANSLUCENT;
+        }
+
+        return SpriteTransparencyLevelHolder.getTransparencyLevel(quad.getSprite());
+    }
+
+    private void checkQuadsHaveSameLightingConfig(List<BakedQuad> quads) {
         int quadsSize = quads.size();
 
         // By definition, singleton or empty lists of quads have a common lighting config. Only check larger lists
         if (quadsSize >= 2) {
             int flagMask = -1;
+
+            var highestSeenLevel = SpriteTransparencyLevel.OPAQUE;
+
             // noinspection ForLoopReplaceableByForEach
             for (int i = 0; i < quadsSize; i++) {
-                int newFlag = computeLightFlagMask(quads.get(i));
+                var quad = quads.get(i);
+                int newFlag = computeLightFlagMask(quad);
                 if (flagMask == -1) {
                     flagMask = newFlag;
                 } else if(newFlag != flagMask) {
-                    return false;
+                    this.quadRenderingFlags &= ~QUAD_REORIENTING;
+                }
+
+                var seenLevel = getQuadTransparencyLevel((BakedQuadView)quad);
+
+                if (seenLevel.ordinal() < highestSeenLevel.ordinal()) {
+                    this.quadRenderingFlags &= ~QUAD_RENDER_PASS_OPTIMIZATION;
+                } else {
+                    highestSeenLevel = seenLevel;
                 }
             }
         }
 
-        return true;
+        if (!this.enableRenderPassOptimization) {
+            this.quadRenderingFlags &= ~QUAD_RENDER_PASS_OPTIMIZATION;
+        }
     }
 
     private ChunkModelBuilder chooseOptimalBuilder(Material defaultMaterial, ChunkBuildBuffers buffers, ChunkModelBuilder defaultBuilder, BakedQuadView quad) {
-        if (defaultMaterial == DefaultMaterials.SOLID || !this.useRenderPassOptimization || (quad.getFlags() & ModelQuadFlags.IS_TRUSTED_SPRITE) == 0 || quad.getSprite() == null) {
+        if (defaultMaterial == DefaultMaterials.SOLID ||
+            ((this.quadRenderingFlags & QUAD_RENDER_PASS_OPTIMIZATION) == 0) ||
+            (quad.getFlags() & ModelQuadFlags.IS_PASS_OPTIMIZABLE) == 0 ||
+            quad.getSprite() == null) {
+
             // No improvement possible
             return defaultBuilder;
         }
@@ -233,11 +274,7 @@ private ChunkModelBuilder chooseOptimalBuilder(Material defaultMaterial, ChunkBu
     private void renderQuadList(BlockRenderContext ctx, Material material, LightPipeline lighter, ColorProvider<BlockState> colorizer, Vec3 offset,
                                 ChunkBuildBuffers buffers, ChunkModelBuilder defaultBuilder, List<BakedQuad> quads, Direction cullFace) {
 
-        if(!checkQuadsHaveSameLightingConfig(quads)) {
-            // Disable reorienting if quads use different light configurations, as otherwise layered quads
-            // may be triangulated differently from others in the stack, and that will cause z-fighting.
-            this.useReorienting = false;
-        }
+        checkQuadsHaveSameLightingConfig(quads);
 
         // This is a very hot allocation, iterate over it manually
         // noinspection ForLoopReplaceableByForEach
@@ -290,7 +327,7 @@ private void writeGeometry(BlockRenderContext ctx,
                                int[] colors,
                                QuadLightData light)
     {
-        ModelQuadOrientation orientation = this.useReorienting ? ModelQuadOrientation.orientByBrightness(light.br, light.lm) : ModelQuadOrientation.NORMAL;
+        ModelQuadOrientation orientation = ((this.quadRenderingFlags & QUAD_REORIENTING) != 0) ? ModelQuadOrientation.orientByBrightness(light.br, light.lm) : ModelQuadOrientation.NORMAL;
         var vertices = this.vertices;
 
         ModelQuadFacing normalFace = quad.getNormalFace();
diff --git a/src/main/java/org/embeddedt/embeddium/impl/render/chunk/sprite/SpriteTransparencyLevelHolder.java b/src/main/java/org/embeddedt/embeddium/impl/render/chunk/sprite/SpriteTransparencyLevelHolder.java
@@ -1,10 +1,15 @@
 package org.embeddedt.embeddium.impl.render.chunk.sprite;
 
 import net.minecraft.client.renderer.texture.SpriteContents;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
 
 public interface SpriteTransparencyLevelHolder {
     SpriteTransparencyLevel embeddium$getTransparencyLevel();
 
+    static SpriteTransparencyLevel getTransparencyLevel(TextureAtlasSprite sprite) {
+        return getTransparencyLevel(sprite.contents());
+    }
+
     static SpriteTransparencyLevel getTransparencyLevel(SpriteContents contents) {
         return ((SpriteTransparencyLevelHolder)contents).embeddium$getTransparencyLevel();
     }
