Respect shader render layer overrides (#1293)

src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuildContext.java

@@ -86,7 +86,11 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
         }
     }
 
-    private Material selectMaterial(Material material, TextureAtlasSprite sprite) {
+    private Material selectMaterial(Material material, TextureAtlasSprite sprite, boolean isShaderPackOverride) {
+        // Don't apply transparency-based optimization when shader pack explicitly overrides the material
+        if (isShaderPackOverride) {
+            return material;
+        }
         if (sprite != null && sprite.getClass() == TextureAtlasSprite.class && !sprite.hasAnimationMetadata()) {
             final var transparencyLevel = ((SpriteExtension)sprite).celeritas$getTransparencyLevel();
             if (transparencyLevel == SpriteTransparencyLevel.OPAQUE && material == AngelicaRenderPassConfiguration.CUTOUT_MIPPED_MATERIAL) {
@@ -99,7 +103,7 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
     }
 
     @SuppressWarnings("unchecked")
-    public void copyRawBuffer(int[] rawBuffer, int vertexCount, ChunkBuildBuffers buffers, Material material) {
+    public void copyRawBuffer(int[] rawBuffer, int vertexCount, ChunkBuildBuffers buffers, Material material, boolean isShaderPackOverride) {
         if (vertexCount == 0) {
             return;
         }
@@ -206,7 +210,7 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
                 }
             }
 
-            final Material correctMaterial = selectMaterial(material, sprite);
+            final Material correctMaterial = selectMaterial(material, sprite, isShaderPackOverride);
             final var builder = buffers.get(correctMaterial);
 
             if (correctMaterial != material && builder.getEncoder() instanceof IrisExtendedChunkVertexEncoder iris) {

src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuilderMeshingTask.java

@@ -1,7 +1,6 @@
 package com.gtnewhorizons.angelica.rendering.celeritas;
 
 import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
-import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
 import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue;
 import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider;
 import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder;
@@ -10,7 +9,6 @@ import com.gtnewhorizons.angelica.rendering.celeritas.iris.ContextAwareChunkVert
 import it.unimi.dsi.fastutil.objects.Reference2ReferenceMap;
 import net.coderbot.iris.vertices.ExtendedDataHelper;
 import net.minecraft.block.Block;
-import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.client.renderer.Tessellator;
 import net.minecraft.client.renderer.texture.TextureAtlasSprite;
@@ -30,6 +28,7 @@ import org.embeddedt.embeddium.impl.render.chunk.data.BuiltSectionMeshParts;
 import org.embeddedt.embeddium.impl.render.chunk.data.MinecraftBuiltRenderSectionData;
 import org.embeddedt.embeddium.impl.render.chunk.occlusion.SectionVisibilityBuilder;
 import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass;
+import org.embeddedt.embeddium.impl.render.chunk.terrain.material.Material;
 import org.embeddedt.embeddium.impl.util.task.CancellationToken;
 import org.joml.Vector3d;
 
@@ -49,7 +48,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
     private static final long DEFERRED_BLOCK_TIMEOUT_MS = 10_000; // 10 seconds
     private static final int MAX_RETRIES = 2;
 
-    protected record DeferredBlock(int x, int y, int z, Block block, int meta, int pass) {}
+    protected record DeferredBlock(int x, int y, int z, Block block, int meta, int pass, Material materialOverride, boolean isShaderPackOverride) {}
 
     public AngelicaChunkBuilderMeshingTask(RenderSection render, int time, Vector3d camera) {
         this.render = render;
@@ -108,7 +107,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
             SmoothBiomeColorCache.setActiveCache(biomeColorCache);
 
             final IrisShaderProvider provider = IrisShaderProviderHolder.getProvider();
-            final Map<Block, RenderLayer> blockTypeIds = provider != null ? provider.getBlockTypeIds() : null;
+            final Map<Block, BlockRenderLayer> blockTypeIds = provider != null ? provider.getBlockTypeIds() : null;
             final BlockRenderContext blockRenderContext = buildContext.getBlockRenderContext();
 
             final boolean threaded = isThreaded();
@@ -142,29 +141,32 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
 
                         final boolean canRenderOffThread = !threaded || canRenderOffThread(block);
 
-                        for (int pass = 0; pass < AngelicaChunkBuildContext.NUM_PASSES; pass++) {
-                            boolean canRender = block.canRenderInPass(pass);
+                        // Check for shader pack override
+                        final BlockRenderLayer override = blockTypeIds != null ? blockTypeIds.get(block) : null;
 
-                            // Shader pack can override render layer via block.properties
-                            if (blockTypeIds != null) {
-                                final RenderLayer overrideLayer = blockTypeIds.get(block);
-                                if (overrideLayer != null) {
-                                    canRender = switch (pass) {
-                                        case 0 -> overrideLayer == RenderLayer.cutout();
-                                        case 1 -> overrideLayer == RenderLayer.translucent();
-                                        default -> canRender;
-                                    };
+                        for (int pass = 0; pass < AngelicaChunkBuildContext.NUM_PASSES; pass++) {
+                            final boolean canRender;
+                            Material materialOverride = null;
+
+                            if (override != null) {
+                                // Shader pack override controls both pass and material
+                                canRender = (pass == override.toVanillaPass());
+                                if (canRender) {
+                                    materialOverride = buffers.getRenderPassConfiguration().getMaterialForRenderType(override);
                                 }
+                            } else {
+                                // Normal block rendering
+                                canRender = block.canRenderInPass(pass);
                             }
 
                             if (canRender) {
+                                final boolean isShaderPackOverride = materialOverride != null;
                                 if (!canRenderOffThread) {
-                                    deferredBlocks.add(new DeferredBlock(x, y, z, block, meta, pass));
+                                    deferredBlocks.add(new DeferredBlock(x, y, z, block, meta, pass, materialOverride, isShaderPackOverride));
                                     continue;
                                 }
 
-                                renderBlock(block, meta, x, y, z, pass, tessellator, renderBlocks,
-                                    buffers, buildContext, blockRenderContext, minX, minY, minZ);
+                                renderBlock(block, meta, x, y, z, pass, tessellator, renderBlocks, buffers, buildContext, blockRenderContext, minX, minY, minZ, materialOverride, isShaderPackOverride);
                             }
                         }
 
@@ -207,13 +209,21 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
         }
     }
 
-    protected void renderBlock(Block block, int metadata, int x, int y, int z, int pass, Tessellator tessellator, RenderBlocks renderBlocks, ChunkBuildBuffers buffers, AngelicaChunkBuildContext buildContext, BlockRenderContext blockRenderContext, int originX, int originY, int originZ) {
+    protected void renderBlock(Block block, int metadata, int x, int y, int z, int pass, Tessellator tessellator, RenderBlocks renderBlocks, ChunkBuildBuffers buffers, AngelicaChunkBuildContext buildContext, BlockRenderContext blockRenderContext, int originX, int originY, int originZ, Material materialOverride, boolean isShaderPackOverride) {
 
-        final Material blockMaterial = block.getMaterial();
-        final boolean isFluid = blockMaterial == Material.water || blockMaterial == Material.lava;
+        final var blockMaterial = block.getMaterial();
+        final boolean isFluid = blockMaterial == net.minecraft.block.material.Material.water || blockMaterial == net.minecraft.block.material.Material.lava;
 
+        // Use material override if provided, otherwise derive from pass
         // Lava is opaque - use solid to skip unnecessary alpha testing
-        final var passMaterial = blockMaterial == Material.lava ? AngelicaRenderPassConfiguration.SOLID_MATERIAL : buffers.getRenderPassConfiguration().getMaterialForRenderType(BlockRenderLayer.fromVanillaPass(pass));
+        final Material passMaterial;
+        if (materialOverride != null) {
+            passMaterial = materialOverride;
+        } else if (blockMaterial == net.minecraft.block.material.Material.lava) {
+            passMaterial = AngelicaRenderPassConfiguration.SOLID_MATERIAL;
+        } else {
+            passMaterial = buffers.getRenderPassConfiguration().getMaterialForRenderType(BlockRenderLayer.fromVanillaPass(pass));
+        }
 
         final var encoder = buffers.get(passMaterial).getEncoder();
         final ContextAwareChunkVertexEncoder contextEncoder = (encoder instanceof ContextAwareChunkVertexEncoder) ? (ContextAwareChunkVertexEncoder) encoder : null;
@@ -237,7 +247,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
         block.canRenderInPass(pass);
         tessellator.startDrawingQuads();
         renderBlocks.renderBlockByRenderType(block, x, y, z);
-        buildContext.copyRawBuffer(tessellator.rawBuffer, tessellator.vertexCount, buffers, passMaterial);
+        buildContext.copyRawBuffer(tessellator.rawBuffer, tessellator.vertexCount, buffers, passMaterial, isShaderPackOverride);
         tessellator.reset();
         tessellator.isDrawing = false;
 
@@ -258,7 +268,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
             for (DeferredBlock deferred : deferredBlocks) {
                 renderBlock(deferred.block(), deferred.meta(), deferred.x(), deferred.y(), deferred.z(), deferred.pass(),
                     mainTessellator, mainThreadRenderBlocks, buffers, buildContext,
-                    blockRenderContext, minX, minY, minZ);
+                    blockRenderContext, minX, minY, minZ, deferred.materialOverride(), deferred.isShaderPackOverride());
             }
 
             mainTessellator.setTranslation(0, 0, 0);

src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaRenderPassConfiguration.java

@@ -68,13 +68,16 @@ public class AngelicaRenderPassConfiguration {
         CUTOUT_MIPPED_MATERIAL = new Material(CUTOUT_MIPPED_PASS, AlphaCutoffParameter.ONE_TENTH, true);
 
         final ImmutableListMultimap.Builder<BlockRenderLayer, TerrainRenderPass> vanillaRenderStages = ImmutableListMultimap.builder();
-        vanillaRenderStages.put(BlockRenderLayer.TRANSLUCENT, TRANSLUCENT_PASS);
         vanillaRenderStages.put(BlockRenderLayer.SOLID, SOLID_PASS);
-        vanillaRenderStages.put(BlockRenderLayer.SOLID, CUTOUT_MIPPED_PASS);
+        vanillaRenderStages.put(BlockRenderLayer.CUTOUT, CUTOUT_MIPPED_PASS);
+        vanillaRenderStages.put(BlockRenderLayer.CUTOUT_MIPPED, CUTOUT_MIPPED_PASS);
+        vanillaRenderStages.put(BlockRenderLayer.TRANSLUCENT, TRANSLUCENT_PASS);
 
         // Material lookup by terrain layer
         final Map<BlockRenderLayer, Material> renderTypeToMaterialMap = new Reference2ReferenceOpenHashMap<>(4, Reference2ReferenceOpenHashMap.VERY_FAST_LOAD_FACTOR);
-        renderTypeToMaterialMap.put(BlockRenderLayer.SOLID, CUTOUT_MIPPED_MATERIAL);
+        renderTypeToMaterialMap.put(BlockRenderLayer.SOLID, SOLID_MATERIAL);
+        renderTypeToMaterialMap.put(BlockRenderLayer.CUTOUT, CUTOUT_MIPPED_MATERIAL);
+        renderTypeToMaterialMap.put(BlockRenderLayer.CUTOUT_MIPPED, CUTOUT_MIPPED_MATERIAL);
         renderTypeToMaterialMap.put(BlockRenderLayer.TRANSLUCENT, TRANSLUCENT_MATERIAL);
 
         return new RenderPassConfiguration<>(renderTypeToMaterialMap, vanillaRenderStages.build().asMap(), CUTOUT_MIPPED_MATERIAL, CUTOUT_MIPPED_MATERIAL, TRANSLUCENT_MATERIAL);

src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/BlockRenderLayer.java

@@ -1,12 +1,18 @@
 package com.gtnewhorizons.angelica.rendering.celeritas;
 
 public enum BlockRenderLayer {
-    SOLID,       // vanilla pass 0
-    TRANSLUCENT; // vanilla pass 1
+    SOLID,          // pass 0, no alpha test
+    CUTOUT,         // pass 0, alpha test (not mipped)
+    CUTOUT_MIPPED,  // pass 0, alpha test (mipped)
+    TRANSLUCENT;    // pass 1
 
-    private static final BlockRenderLayer[] VALUES = values();
+    public int toVanillaPass() {
+        return this == TRANSLUCENT ? 1 : 0;
+    }
 
     public static BlockRenderLayer fromVanillaPass(int pass) {
-        return VALUES[pass];
+        // CUTOUT_MIPPED is the safe default for pass 0
+        // SOLID/CUTOUT are only used for explicit shader pack and material overrides
+        return pass == 0 ? CUTOUT_MIPPED : TRANSLUCENT;
     }
 }

src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/api/IrisShaderProvider.java

@@ -1,12 +1,12 @@
 package com.gtnewhorizons.angelica.rendering.celeritas.api;
 
+import com.gtnewhorizons.angelica.rendering.celeritas.BlockRenderLayer;
 import net.minecraft.block.Block;
 import org.embeddedt.embeddium.impl.gl.shader.GlProgram;
 import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration;
 import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderInterface;
 import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass;
 import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType;
-import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Map;
@@ -26,5 +26,5 @@ public interface IrisShaderProvider {
     void setRenderPassConfiguration(RenderPassConfiguration<?> configuration);
 
     /** Block render layer overrides from shader pack */
-    @Nullable Map<Block, RenderLayer> getBlockTypeIds();
+    @Nullable Map<Block, BlockRenderLayer> getBlockTypeIds();
 }

src/main/java/net/coderbot/iris/block_rendering/BlockMaterialMapping.java

@@ -1,10 +1,9 @@
 package net.coderbot.iris.block_rendering;
 
-import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
+import com.gtnewhorizons.angelica.rendering.celeritas.BlockRenderLayer;
 import it.unimi.dsi.fastutil.ints.Int2IntMap;
 import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
-import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import it.unimi.dsi.fastutil.objects.Reference2ObjectMap;
 import it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
@@ -36,33 +35,37 @@ public class BlockMaterialMapping {
 		return blockMatches;
 	}
 
-	public static Map<Block, RenderLayer> createBlockTypeMap(Map<NamespacedId, BlockRenderType> blockPropertiesMap) {
-		Map<Block, RenderLayer> blockTypeIds = new Reference2ReferenceOpenHashMap<>();
+	public static Map<Block, BlockRenderLayer> createBlockTypeMap(Map<NamespacedId, BlockRenderType> blockPropertiesMap) {
+		Map<Block, BlockRenderLayer> blockTypeIds = new Reference2ReferenceOpenHashMap<>();
 
 		blockPropertiesMap.forEach((id, blockType) -> {
-			ResourceLocation resourceLocation = new ResourceLocation(id.getNamespace(), id.getName());
+			final ResourceLocation resourceLocation = new ResourceLocation(id.getNamespace(), id.getName());
+			final Block block = Block.getBlockFromName(resourceLocation.toString());
 
-			Block block = Block.getBlockFromName(resourceLocation.toString());
+			if (block == null || block == Blocks.air) {
+				return;
+			}
 
-			blockTypeIds.put(block, convertBlockToRenderType(blockType));
+			final BlockRenderLayer layer = convertBlockToRenderLayer(blockType);
+			if (layer != null) {
+				blockTypeIds.put(block, layer);
+			}
 		});
 
 		return blockTypeIds;
 	}
 
-	private static RenderLayer convertBlockToRenderType(BlockRenderType type) {
+	private static BlockRenderLayer convertBlockToRenderLayer(BlockRenderType type) {
 		if (type == null) {
 			return null;
 		}
 
-        return switch (type) {
-            // Everything renders in cutout or translucent in 1.7.10
-            case SOLID, CUTOUT, CUTOUT_MIPPED -> RenderLayer.cutout();
-            // case SOLID -> RenderLayer.solid();
-            // case CUTOUT_MIPPED -> RenderLayer.cutoutMipped();
-            case TRANSLUCENT -> RenderLayer.translucent();
-            default -> null;
-        };
+		return switch (type) {
+			case SOLID -> BlockRenderLayer.SOLID;
+			case CUTOUT -> BlockRenderLayer.CUTOUT;
+			case CUTOUT_MIPPED -> BlockRenderLayer.CUTOUT_MIPPED;
+			case TRANSLUCENT -> BlockRenderLayer.TRANSLUCENT;
+		};
 	}
 
 	/**

src/main/java/net/coderbot/iris/block_rendering/BlockRenderingSettings.java

@@ -1,6 +1,6 @@
 package net.coderbot.iris.block_rendering;
 
-import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
+import com.gtnewhorizons.angelica.rendering.celeritas.BlockRenderLayer;
 import it.unimi.dsi.fastutil.ints.Int2IntMap;
 import it.unimi.dsi.fastutil.objects.Object2IntFunction;
 import it.unimi.dsi.fastutil.objects.Reference2ObjectMap;
@@ -18,7 +18,7 @@ public class BlockRenderingSettings {
 	@Getter
     private boolean reloadRequired;
 	private Reference2ObjectMap<Block, Int2IntMap> blockMetaMatches;
-	private Map<Block, RenderLayer> blockTypeIds;
+	private Map<Block, BlockRenderLayer> blockTypeIds;
 	private Object2IntFunction<NamespacedId> entityIds;
 	private Object2IntFunction<NamespacedId> itemIds;
 	private float ambientOcclusionLevel;
@@ -55,7 +55,7 @@ public class BlockRenderingSettings {
 	}
 
 	@Nullable
-	public Map<Block, RenderLayer> getBlockTypeIds() {
+	public Map<Block, BlockRenderLayer> getBlockTypeIds() {
 		return blockTypeIds;
 	}
 
@@ -74,7 +74,7 @@ public class BlockRenderingSettings {
 		this.blockMetaMatches = blockMetaIds;
 	}
 
-	public void setBlockTypeIds(Map<Block, RenderLayer> blockTypeIds) {
+	public void setBlockTypeIds(Map<Block, BlockRenderLayer> blockTypeIds) {
 		if (this.blockTypeIds != null && this.blockTypeIds.equals(blockTypeIds)) {
 			return;
 		}

src/main/java/net/coderbot/iris/celeritas/IrisCeleritasShaderProvider.java

@@ -1,5 +1,6 @@
 package net.coderbot.iris.celeritas;
 
+import com.gtnewhorizons.angelica.rendering.celeritas.BlockRenderLayer;
 import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider;
 import com.gtnewhorizons.angelica.rendering.celeritas.iris.IrisExtendedChunkVertexType;
 import net.coderbot.iris.Iris;
@@ -11,7 +12,6 @@ import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration;
 import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderInterface;
 import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass;
 import org.embeddedt.embeddium.impl.render.chunk.vertex.format.ChunkVertexType;
-import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.Map;
@@ -61,7 +61,7 @@ public class IrisCeleritasShaderProvider implements IrisShaderProvider {
 
     @Override
     @Nullable
-    public Map<Block, RenderLayer> getBlockTypeIds() {
+    public Map<Block, BlockRenderLayer> getBlockTypeIds() {
         return BlockRenderingSettings.INSTANCE.getBlockTypeIds();
     }
 

src/main/java/net/coderbot/iris/pipeline/HandRenderer.java

@@ -3,9 +3,9 @@ package net.coderbot.iris.pipeline;
 import com.gtnewhorizons.angelica.compat.mojang.Camera;
 import com.gtnewhorizons.angelica.compat.mojang.GameModeUtil;
 import com.gtnewhorizons.angelica.compat.mojang.InteractionHand;
-import com.gtnewhorizons.angelica.compat.toremove.RenderLayer;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.rendering.RenderingState;
+import com.gtnewhorizons.angelica.rendering.celeritas.BlockRenderLayer;
 import net.coderbot.iris.block_rendering.BlockRenderingSettings;
 import net.coderbot.iris.layer.GbufferPrograms;
 import net.irisshaders.iris.api.v0.IrisApi;
@@ -81,14 +81,12 @@ public class HandRenderer {
     public boolean isHandTranslucent(InteractionHand hand) {
         ItemStack heldItem = hand.getItemInHand(Minecraft.getMinecraft().thePlayer);
 
-        if (heldItem == null) {
-            return false;
-        }
-        Item item = heldItem.getItem();
+        if (heldItem == null) return false;
+        final Item item = heldItem.getItem();
 
         if (item instanceof ItemBlock itemBlock) {
-            Map<Block, RenderLayer> blockTypeIds = BlockRenderingSettings.INSTANCE.getBlockTypeIds();
-            return blockTypeIds != null && blockTypeIds.get(itemBlock.field_150939_a) == RenderLayer.translucent();
+            final Map<Block, BlockRenderLayer> blockTypeIds = BlockRenderingSettings.INSTANCE.getBlockTypeIds();
+            return blockTypeIds != null && blockTypeIds.get(itemBlock.field_150939_a) == BlockRenderLayer.TRANSLUCENT;
         }
 
         return false;

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinRenderGlobal.java

@@ -158,8 +158,15 @@ public class MixinRenderGlobal implements IRenderGlobalExt {
         final double camZ = lerp(entity.lastTickPosZ, entity.posZ, partialTicks);
 
         try {
-            mc.mcProfiler.endStartSection("draw_chunk_layer_" + pass);
-            this.celeritas$renderer.drawChunkLayer(BlockRenderLayer.fromVanillaPass(pass), camX, camY, camZ);
+            if (pass == 0) {
+                mc.mcProfiler.endStartSection("draw_chunk_layer_solid");
+                this.celeritas$renderer.drawChunkLayer(BlockRenderLayer.SOLID, camX, camY, camZ);
+                mc.mcProfiler.endStartSection("draw_chunk_layer_cutout_mipped");
+                this.celeritas$renderer.drawChunkLayer(BlockRenderLayer.CUTOUT_MIPPED, camX, camY, camZ);
+            } else {
+                mc.mcProfiler.endStartSection("draw_chunk_layer_translucent");
+                this.celeritas$renderer.drawChunkLayer(BlockRenderLayer.TRANSLUCENT, camX, camY, camZ);
+            }
         } finally {
             RenderDevice.exitManagedCode();
         }