diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuildContext.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuildContext.java
index 300a35688..d8811122a 100644
--- a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuildContext.java
+++ b/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) {
diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuilderMeshingTask.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuilderMeshingTask.java
index b058581bf..0d12178cd 100644
--- a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaChunkBuilderMeshingTask.java
+++ b/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);
diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaRenderPassConfiguration.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaRenderPassConfiguration.java
index ba8ce0eb1..4211c4c5d 100644
--- a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/AngelicaRenderPassConfiguration.java
+++ b/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);
diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/BlockRenderLayer.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/BlockRenderLayer.java
index 5e46d3fbd..22fab69b7 100644
--- a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/BlockRenderLayer.java
+++ b/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;
     }
 }
diff --git a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/api/IrisShaderProvider.java b/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/api/IrisShaderProvider.java
index 7c462c3d8..789a03f09 100644
--- a/src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/api/IrisShaderProvider.java
+++ b/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();
 }
diff --git a/src/main/java/net/coderbot/iris/block_rendering/BlockMaterialMapping.java b/src/main/java/net/coderbot/iris/block_rendering/BlockMaterialMapping.java
index 8041ea93f..e8fdbda6a 100644
--- a/src/main/java/net/coderbot/iris/block_rendering/BlockMaterialMapping.java
+++ b/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;
+		};
 	}
 
 	/**
diff --git a/src/main/java/net/coderbot/iris/block_rendering/BlockRenderingSettings.java b/src/main/java/net/coderbot/iris/block_rendering/BlockRenderingSettings.java
index 65dc4317f..292b2a59f 100644
--- a/src/main/java/net/coderbot/iris/block_rendering/BlockRenderingSettings.java
+++ b/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;
 		}
diff --git a/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasShaderProvider.java b/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasShaderProvider.java
index 651f38675..2ce3e7e09 100644
--- a/src/main/java/net/coderbot/iris/celeritas/IrisCeleritasShaderProvider.java
+++ b/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();
     }
 
diff --git a/src/main/java/net/coderbot/iris/pipeline/HandRenderer.java b/src/main/java/net/coderbot/iris/pipeline/HandRenderer.java
index 8690cd2f8..adab076b3 100644
--- a/src/main/java/net/coderbot/iris/pipeline/HandRenderer.java
+++ b/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;
diff --git a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinRenderGlobal.java b/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinRenderGlobal.java
index b3f4225cf..1b90b9d5a 100644
--- a/src/mixin/java/com/gtnewhorizons/angelica/mixins/early/celeritas/terrain/MixinRenderGlobal.java
+++ b/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();
         }