Fix item reset hopefully for the last time (#1621)

Co-authored-by: Alexdoru <[email protected]>

dependencies.gradle

@@ -83,7 +83,7 @@ dependencies {
     shadowImplementation("net.minecraftforge:eventbus:7.0-beta.15")
 
     shadowImplementation("org.anarres:jcpp:1.4.14") // Apache 2.0
-    shadowImplementation("org.taumc:glsl-transformation-lib:0.2.0-26.g5ee7d96-GTNH") {
+    shadowImplementation("org.taumc:glsl-transformation-lib:0.2.0-32.g7dd88a4-GTNH") {
         exclude module: "antlr4" // we only want to shadow the runtime module
     }
     shadowImplementation("org.antlr:antlr4-runtime:4.13.2")

glsm/build.gradle.kts

@@ -76,7 +76,7 @@ dependencies {
     compileOnly("org.lwjgl.lwjgl:lwjgl:${property("lwjglVersion")}")
     compileOnly("org.lwjgl.lwjgl:lwjgl_util:${property("lwjglVersion")}")
 
-    compileOnly("org.ow2.asm:asm-tree:9.7")
+    compileOnly("org.ow2.asm:asm-tree:5.0.3")
 
     // Our Deps
     api("com.github.GTNewHorizons:GTNHLib:${property("gtnhlibVersion")}:dev")
@@ -100,6 +100,7 @@ dependencies {
     testImplementation(sourceSets["stubs"].output)
     testImplementation(platform("org.junit:junit-bom:${property("junitBomVersion")}"))
     testImplementation("org.junit.jupiter:junit-jupiter")
+    testImplementation("org.ow2.asm:asm-tree:9.7")
     testImplementation("org.lwjgl.lwjgl:lwjgl:${property("lwjglVersion")}")
     testRuntimeOnly("org.junit.platform:junit-platform-launcher")
     testRuntimeOnly("org.apache.logging.log4j:log4j-core:${property("log4jVersion")}")

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/FeedbackManager.java

@@ -345,6 +345,16 @@ public class FeedbackManager {
                 }
                 break;
 
+            case GL11.GL_POLYGON:
+                if (count >= 3) {
+                    feedbackToken(GL11.GL_POLYGON_TOKEN);
+                    feedbackToken(count);
+                    for (int i = 0; i < count; i++) {
+                        emitVertex(reader.read(i), stride);
+                    }
+                }
+                break;
+
             default:
                 throw new UnsupportedOperationException("Feedback mode: unsupported primitive mode 0x" + Integer.toHexString(mode));
         }

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GLStateManager.java

@@ -419,6 +419,9 @@ public class GLStateManager {
     @Getter protected static int boundVBO;
     @Getter protected static int boundEBO;
     @Getter protected static int boundVAO;
+    private static int clientArraysVBO = 0;
+    private static int clientArraysVBOCapacity = 0;
+    private static final int[] clientArraysVBOOffsets = new int[VertexAttribState.MAX_ATTRIBS];
     private static int boundPixelUnpackBuffer;
     private static int boundPixelPackBuffer;
     private static final Int2IntOpenHashMap vaoEboMap = new Int2IntOpenHashMap();
@@ -2145,6 +2148,7 @@ public class GLStateManager {
         }
         prepareWideLineEmulation(mode);
         ShaderManager.getInstance().preDraw();
+        prepareClientArrays();
         RENDER_BACKEND.drawElements(mode, indices);
     }
 
@@ -2158,6 +2162,7 @@ public class GLStateManager {
         }
         prepareWideLineEmulation(mode);
         ShaderManager.getInstance().preDraw();
+        prepareClientArrays();
         if (mode == GL11.GL_QUADS) {
             QuadConverter.drawQuadElementsAsTriangles(indices);
         } else {
@@ -2175,6 +2180,7 @@ public class GLStateManager {
         }
         prepareWideLineEmulation(mode);
         ShaderManager.getInstance().preDraw();
+        prepareClientArrays();
         if (mode == GL11.GL_QUADS) {
             QuadConverter.drawQuadElementsAsTriangles(indices);
         } else {
@@ -2192,6 +2198,7 @@ public class GLStateManager {
         }
         prepareWideLineEmulation(mode);
         ShaderManager.getInstance().preDraw();
+        prepareClientArrays();
         if (mode == GL11.GL_QUADS) {
             QuadConverter.drawQuadElementsAsTriangles(count, type, indices);
         } else {
@@ -2223,6 +2230,7 @@ public class GLStateManager {
         }
         prepareWideLineEmulation(mode);
         ShaderManager.getInstance().preDraw();
+        prepareClientArrays();
         if (mode == GL11.GL_QUADS) {
             QuadConverter.drawQuadElementsAsTriangles(indices_count, type, indices_buffer_offset);
         } else {
@@ -2245,20 +2253,72 @@ public class GLStateManager {
 
     public static void glMultiDrawElementsIndirect(int mode, int type, long indirect, int drawcount, int stride) {
         ShaderManager.getInstance().preDraw();
+        prepareClientArrays();
         RENDER_BACKEND.multiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
     }
 
     public static void glMultiDrawElementsBaseVertex(int mode, long pCount, int type, long pIndices, int drawcount, long pBaseVertex) {
         ShaderManager.getInstance().preDraw();
+        prepareClientArrays();
         RENDER_BACKEND.multiDrawElementsBaseVertex(mode, pCount, type, pIndices, drawcount, pBaseVertex);
     }
 
     public static void glDrawElementsBaseVertex(int mode, int count, int type, long indices, int basevertex) {
         ShaderManager.getInstance().preDraw();
+        prepareClientArrays();
         RENDER_BACKEND.drawElementsBaseVertex(mode, count, type, indices, basevertex);
     }
 
-    public static void glDrawElementsInstanced(int mode, int count, int type, long indices, int primcount) { RENDER_BACKEND.drawElementsInstanced(mode, count, type, indices, primcount); }
+    public static void glDrawElementsInstanced(int mode, int count, int type, long indices, int primcount) {
+        ShaderManager.getInstance().preDraw();
+        prepareClientArrays();
+        RENDER_BACKEND.drawElementsInstanced(mode, count, type, indices, primcount);
+    }
+
+    private static void prepareClientArrays() {
+        if (ShaderManager.getInstance().isEnabled() && VertexAttribState.hasAnyClientSideEnabledAttrib()) {
+            uploadClientArraysToVBO();
+        }
+    }
+
+    /**
+     * If any enabled vertex attribute uses a client-side pointer (no VBO), upload all such
+     * attribs into a shared stream VBO so the draw succeeds under core profile.
+     */
+    private static void uploadClientArraysToVBO() {
+        int totalBytes = 0;
+        for (int i = 0; i < VertexAttribState.MAX_ATTRIBS; i++) {
+            clientArraysVBOOffsets[i] = -1;
+            final VertexAttribState.Attrib a = VertexAttribState.get(i);
+            if (!a.enabled || a.clientPointer == null) continue;
+            clientArraysVBOOffsets[i] = totalBytes;
+            totalBytes += a.clientPointer.remaining();
+        }
+        if (totalBytes == 0) return;
+
+        if (clientArraysVBO == 0) {
+            clientArraysVBO = RENDER_BACKEND.genBuffers();
+        }
+
+        final int savedVBO = boundVBO;
+        glBindBuffer(GL15.GL_ARRAY_BUFFER, clientArraysVBO);
+
+        if (totalBytes > clientArraysVBOCapacity) {
+            int newCap = Math.max(4096, clientArraysVBOCapacity);
+            while (newCap < totalBytes) newCap *= 2;
+            clientArraysVBOCapacity = newCap;
+        }
+        RENDER_BACKEND.bufferData(GL15.GL_ARRAY_BUFFER, clientArraysVBOCapacity, GL15.GL_STREAM_DRAW);
+
+        for (int i = 0; i < VertexAttribState.MAX_ATTRIBS; i++) {
+            if (clientArraysVBOOffsets[i] < 0) continue;
+            final VertexAttribState.Attrib a = VertexAttribState.get(i);
+            RENDER_BACKEND.bufferSubData(GL15.GL_ARRAY_BUFFER, clientArraysVBOOffsets[i], a.clientPointer.duplicate());
+            RENDER_BACKEND.vertexAttribPointer(i, a.size, a.type, a.normalized, a.stride, (long) clientArraysVBOOffsets[i]);
+        }
+
+        glBindBuffer(GL15.GL_ARRAY_BUFFER, savedVBO);
+    }
 
     public static void glDrawArrays(int mode, int first, int count) {
         CommandRecorder savedRecorder = null;
@@ -2278,8 +2338,11 @@ public class GLStateManager {
         }
         prepareWideLineEmulation(mode);
         ShaderManager.getInstance().preDraw();
+        prepareClientArrays();
         if (mode == GL11.GL_QUADS) {
             QuadConverter.drawQuadsAsTriangles(first, count);
+        } else if (mode == GL11.GL_POLYGON) {
+            RENDER_BACKEND.drawArrays(GL11.GL_TRIANGLE_FAN, first, count);
         } else {
             RENDER_BACKEND.drawArrays(mode, first, count);
         }
@@ -2298,6 +2361,10 @@ public class GLStateManager {
         glVertexAttribPointer(Usage.POSITION.getAttributeLocation(), size, GL11.GL_FLOAT, false, stride, MemoryUtilities.memByteBuffer(pointer));
     }
 
+    public static void glVertexPointer(int size, int stride, DoubleBuffer pointer) {
+        glVertexAttribPointer(Usage.POSITION.getAttributeLocation(), size, GL11.GL_DOUBLE, false, stride, MemoryUtilities.memByteBuffer(pointer));
+    }
+
     public static void glVertexPointer(int size, int type, int stride, ByteBuffer pointer) {
         glVertexAttribPointer(Usage.POSITION.getAttributeLocation(), size, type, false, stride, pointer);
     }
@@ -2339,6 +2406,10 @@ public class GLStateManager {
         glNormalPointer(GL11.GL_INT, stride, pointer);
     }
 
+    public static void glNormalPointer(int stride, DoubleBuffer pointer) {
+        glNormalPointer(GL11.GL_DOUBLE, stride, pointer);
+    }
+
     public static void glNormalPointer(int type, int stride, ByteBuffer pointer) {
         glVertexAttribPointer(Usage.NORMAL.getAttributeLocation(), 3, type, Usage.NORMAL.isNormalized(), stride, pointer);
     }
@@ -2355,6 +2426,10 @@ public class GLStateManager {
         glVertexAttribPointer(Usage.NORMAL.getAttributeLocation(), 3, GL11.GL_INT, Usage.NORMAL.isNormalized(), stride, MemoryUtilities.memByteBuffer(pointer));
     }
 
+    public static void glNormalPointer(int type, int stride, DoubleBuffer pointer) {
+        glVertexAttribPointer(Usage.NORMAL.getAttributeLocation(), 3, GL11.GL_DOUBLE, Usage.NORMAL.isNormalized(), stride, MemoryUtilities.memByteBuffer(pointer));
+    }
+
     public static void glNormalPointer(int type, int stride, long pointer_buffer_offset) {
         glVertexAttribPointer(Usage.NORMAL.getAttributeLocation(), 3, type, Usage.NORMAL.isNormalized(), stride, pointer_buffer_offset);
     }
@@ -2377,6 +2452,10 @@ public class GLStateManager {
         glTexCoordPointer(size, GL11.GL_SHORT, stride, pointer);
     }
 
+    public static void glTexCoordPointer(int size, int stride, DoubleBuffer pointer) {
+        glTexCoordPointer(size, GL11.GL_DOUBLE, stride, pointer);
+    }
+
     public static void glTexCoordPointer(int size, int type, int stride, FloatBuffer pointer) {
         final int loc = texCoordAttributeLocation();
         if (loc < 0) return;
@@ -2395,6 +2474,12 @@ public class GLStateManager {
         glVertexAttribPointer(loc, size, GL11.GL_INT, false, stride, MemoryUtilities.memByteBuffer(pointer));
     }
 
+    public static void glTexCoordPointer(int size, int type, int stride, DoubleBuffer pointer) {
+        final int loc = texCoordAttributeLocation();
+        if (loc < 0) return;
+        glVertexAttribPointer(loc, size, GL11.GL_DOUBLE, false, stride, MemoryUtilities.memByteBuffer(pointer));
+    }
+
     public static void glTexCoordPointer(int size, int type, int stride, long pointer_buffer_offset) {
         final int loc = texCoordAttributeLocation();
         if (loc < 0) return;
@@ -2441,32 +2526,23 @@ public class GLStateManager {
     }
 
     public static void glVertexAttribPointer(int index, int size, int type, boolean normalized, int stride, FloatBuffer pointer) {
-        final ByteBuffer bb = MemoryUtilities.memByteBuffer(pointer);
-        VertexAttribState.set(index, size, type, normalized, stride, bb, boundVBO);
-        RENDER_BACKEND.vertexAttribPointer(index, size, type, normalized, stride, bb);
+        VertexAttribState.set(index, size, type, normalized, stride, MemoryUtilities.memByteBuffer(pointer), 0);
     }
 
     public static void glVertexAttribPointer(int index, int size, int type, boolean normalized, int stride, DoubleBuffer pointer) {
-        final ByteBuffer bb = MemoryUtilities.memByteBuffer(pointer);
-        VertexAttribState.set(index, size, type, normalized, stride, bb, boundVBO);
-        RENDER_BACKEND.vertexAttribPointer(index, size, type, normalized, stride, bb);
+        VertexAttribState.set(index, size, type, normalized, stride, MemoryUtilities.memByteBuffer(pointer), 0);
     }
 
     public static void glVertexAttribPointer(int index, int size, int type, boolean normalized, int stride, IntBuffer pointer) {
-        final ByteBuffer bb = MemoryUtilities.memByteBuffer(pointer);
-        VertexAttribState.set(index, size, type, normalized, stride, bb, boundVBO);
-        RENDER_BACKEND.vertexAttribPointer(index, size, type, normalized, stride, bb);
+        VertexAttribState.set(index, size, type, normalized, stride, MemoryUtilities.memByteBuffer(pointer), 0);
     }
 
     public static void glVertexAttribPointer(int index, int size, int type, boolean normalized, int stride, ShortBuffer pointer) {
-        final ByteBuffer bb = MemoryUtilities.memByteBuffer(pointer);
-        VertexAttribState.set(index, size, type, normalized, stride, bb, boundVBO);
-        RENDER_BACKEND.vertexAttribPointer(index, size, type, normalized, stride, bb);
+        VertexAttribState.set(index, size, type, normalized, stride, MemoryUtilities.memByteBuffer(pointer), 0);
     }
 
     public static void glVertexAttribPointer(int index, int size, int type, boolean normalized, int stride, ByteBuffer pointer) {
-        VertexAttribState.set(index, size, type, normalized, stride, pointer, boundVBO);
-        RENDER_BACKEND.vertexAttribPointer(index, size, type, normalized, stride, pointer);
+        VertexAttribState.set(index, size, type, normalized, stride, pointer, 0);
     }
 
     public static void glVertexAttribIPointer(int index, int size, int type, int stride, long offset) {
@@ -2475,20 +2551,15 @@ public class GLStateManager {
     }
 
     public static void glVertexAttribIPointer(int index, int size, int type, int stride, ByteBuffer pointer) {
-        VertexAttribState.set(index, size, type, false, stride, pointer, boundVBO);
-        RENDER_BACKEND.vertexAttribIPointer(index, size, type, stride, pointer);
+        VertexAttribState.set(index, size, type, false, stride, pointer, 0);
     }
 
     public static void glVertexAttribIPointer(int index, int size, int type, int stride, IntBuffer pointer) {
-        final ByteBuffer bb = MemoryUtilities.memByteBuffer(pointer);
-        VertexAttribState.set(index, size, type, false, stride, bb, boundVBO);
-        RENDER_BACKEND.vertexAttribIPointer(index, size, type, stride, bb);
+        VertexAttribState.set(index, size, type, false, stride, MemoryUtilities.memByteBuffer(pointer), 0);
     }
 
     public static void glVertexAttribIPointer(int index, int size, int type, int stride, ShortBuffer pointer) {
-        final ByteBuffer bb = MemoryUtilities.memByteBuffer(pointer);
-        VertexAttribState.set(index, size, type, false, stride, bb, boundVBO);
-        RENDER_BACKEND.vertexAttribIPointer(index, size, type, stride, bb);
+        VertexAttribState.set(index, size, type, false, stride, MemoryUtilities.memByteBuffer(pointer), 0);
     }
 
     public static void glVertexAttribDivisor(int index, int divisor) { RENDER_BACKEND.vertexAttribDivisor(index, divisor); }
@@ -5814,5 +5885,7 @@ public class GLStateManager {
     public static void glGetUniform(int program, int location, IntBuffer params) {
         RENDER_BACKEND.getUniformiv(program, location, params);
     }
-
+    public static void glGetTexImage(int target, int level, int format, int type, long pixels) {
+        GL11.glGetTexImage(target, level, format, type, pixels);
+    }
 }

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/GlslTransformUtils.java

@@ -36,8 +36,11 @@ public class GlslTransformUtils {
     /** Reserved words added in later GLSL versions that may appear as identifiers in older shaders. */
     private record ReservedWordRename(Pattern pattern, String replacement) {}
     private static final Map<Integer, List<ReservedWordRename>> VERSIONED_RESERVED_WORDS = Map.of(
+        // Always rename sample, glsl-transformation-lib doesn't like it
+        0, List.of(
+            new ReservedWordRename(Pattern.compile("\\bsample\\b"), RENAMED_PREFIX + "sample")
+        ),
         400, List.of(
-            new ReservedWordRename(Pattern.compile("\\bsample\\b"), RENAMED_PREFIX + "sample"),
             new ReservedWordRename(Pattern.compile("\\bsampler\\b(?!\\d)"), RENAMED_PREFIX + "sampler")
         )
     );

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/ffp/FragmentShaderGenerator.java

@@ -273,21 +273,27 @@ public final class FragmentShaderGenerator {
         sb.append("  // Alpha test\n");
         final int func = FragmentKey.decodeAlphaFunc(key.alphaTestFunc());
 
+
+        sb.append("  float qa = round(color.a * 255.0);\n");
         switch (func) {
             case GL11.GL_NEVER ->
                 sb.append("  discard;\n");
             case GL11.GL_LESS ->
-                sb.append("  if (color.a >= u_AlphaRef) discard;\n");
-            case GL11.GL_EQUAL ->
-                sb.append("  if (color.a != u_AlphaRef) discard;\n");
+                sb.append("  if (qa >= u_AlphaRef * 255.0) discard;\n");
+            case GL11.GL_EQUAL -> {
+                sb.append("  float qr = round(u_AlphaRef * 255.0);\n");
+                sb.append("  if (qa != qr) discard;\n");
+            }
             case GL11.GL_LEQUAL ->
-                sb.append("  if (color.a > u_AlphaRef) discard;\n");
+                sb.append("  if (qa > u_AlphaRef * 255.0) discard;\n");
             case GL11.GL_GREATER ->
-                sb.append("  if (color.a <= u_AlphaRef) discard;\n");
-            case GL11.GL_NOTEQUAL ->
-                sb.append("  if (color.a == u_AlphaRef) discard;\n");
+                sb.append("  if (qa <= u_AlphaRef * 255.0) discard;\n");
+            case GL11.GL_NOTEQUAL -> {
+                sb.append("  float qr = round(u_AlphaRef * 255.0);\n");
+                sb.append("  if (qa == qr) discard;\n");
+            }
             case GL11.GL_GEQUAL ->
-                sb.append("  if (color.a < u_AlphaRef) discard;\n");
+                sb.append("  if (qa < u_AlphaRef * 255.0) discard;\n");
             case GL11.GL_ALWAYS -> {}
         }
     }

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/DisplayListVBOBuilder.java

@@ -75,6 +75,9 @@ public final class DisplayListVBOBuilder {
                 if (data.drawMode == GL11.GL_QUADS) {
                     final IVertexArrayObject indexedVAO = new IndexedVAO(vbo, IndexBuffer.convertQuadsToTrigs(start, start + vertexCount));
                     vbos[data.drawIndex] = new DisplayListVBO.SubVBO(indexedVAO, GL11.GL_TRIANGLES, 0, vertexCount / 4 * 6);
+                } else if (data.drawMode == GL11.GL_POLYGON) {
+                    // GL_POLYGON is removed in core profile; convert to GL_TRIANGLE_FAN which is equivalent for convex polygons
+                    vbos[data.drawIndex] = new DisplayListVBO.SubVBO(vao, GL11.GL_TRIANGLE_FAN, start, vertexCount);
                 } else {
                     vbos[data.drawIndex] = new DisplayListVBO.SubVBO(vao, data.drawMode, start, vertexCount);
                 }

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/redirect/GLSMRedirector.java

@@ -4,16 +4,19 @@ import com.google.common.collect.ImmutableSet;
 import com.gtnewhorizon.gtnhlib.asm.ClassConstantPoolParser;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.objectweb.asm.Handle;
 import org.objectweb.asm.Opcodes;
 import org.objectweb.asm.tree.AbstractInsnNode;
 import org.objectweb.asm.tree.ClassNode;
 import org.objectweb.asm.tree.IntInsnNode;
+import org.objectweb.asm.tree.InvokeDynamicInsnNode;
 import org.objectweb.asm.tree.LdcInsnNode;
 import org.objectweb.asm.tree.MethodInsnNode;
 import org.objectweb.asm.tree.MethodNode;
 import org.objectweb.asm.tree.TypeInsnNode;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
@@ -79,6 +82,9 @@ public class GLSMRedirector {
         glCapRedirects.put(org.lwjgl.opengl.GL11.GL_SCISSOR_TEST, "ScissorTest");
 
         final var gl11 = RedirectMap.newMap()
+            // glEnable/Disable - Special cased in GLSMRedirector, but included here for the external API
+            .add("glEnable")
+            .add("glDisable")
             .add("glAlphaFunc")
             .add("glBegin")
             .add("glBindTexture")
@@ -495,6 +501,22 @@ public class GLSMRedirector {
         return CORE_EXCLUSIONS.clone();
     }
 
+    /** The internal-name prefix used to match GL version classes (e.g., {@code "org/lwjgl/opengl/GL"}). */
+    public static String getGLPrefix() { return GL_PREFIX; }
+
+    /** The internal name of the redirect target class. */
+    public static String getTargetClassName() { return GLStateManager; }
+
+    /** Method redirects for GL-prefix classes. Key: original method name, Value: GLStateManager method name. */
+    public static Map<String, String> getGLPrefixMethodRedirects() {
+        return Collections.unmodifiableMap(glMethodRedirects);
+    }
+
+    /** Method redirects for named (non-GL-prefix) classes. Key: internal class name, Value: per-method redirect map. */
+    public static Map<String, Map<String, String>> getNamedClassMethodRedirects() {
+        return Collections.unmodifiableMap(methodRedirects);
+    }
+
     public boolean shouldTransform(byte[] basicClass) {
         return cstPoolParser.find(basicClass, true);
     }
@@ -504,7 +526,7 @@ public class GLSMRedirector {
         boolean changed = false;
         final boolean isOpenGlHelper = transformedName.equals("net.minecraft.client.renderer.OpenGlHelper");
 
-        for (MethodNode mn : cn.methods) {
+        for (MethodNode mn : (List<MethodNode>) cn.methods) {
             if (isOpenGlHelper && (mn.name.equals("glBlendFunc") || mn.name.equals("func_148821_a"))) {
                 continue;
             }
@@ -590,6 +612,22 @@ public class GLSMRedirector {
                             changed = true;
                         }
                     }
+                } else if (node instanceof InvokeDynamicInsnNode dynNode) {
+                    // Redirect method handles in invokedynamic bootstrap arguments
+                    for (int i = 0; i < dynNode.bsmArgs.length; i++) {
+                        if (!(dynNode.bsmArgs[i] instanceof Handle handle)) continue;
+                        final Map<String, String> redirects = handle.getOwner().startsWith(GL_PREFIX) ? glMethodRedirects : methodRedirects.get(handle.getOwner());
+                        if (redirects == null) continue;
+                        final String glsmName = redirects.get(handle.getName());
+                        if (glsmName == null) continue;
+                        if (LOG_SPAM) {
+                            final String shortOwner = handle.getOwner().substring(handle.getOwner().lastIndexOf("/") + 1);
+                            LOGGER.info("Redirecting invokedynamic handle in {} from {}.{}{} to GLStateManager.{}{}", transformedName, shortOwner, handle.getName(), handle.getDesc(), glsmName, handle.getDesc());
+                        }
+                        dynNode.bsmArgs[i] = new Handle(handle.getTag(), GLStateManager, glsmName, handle.getDesc());
+                        changed = true;
+                        redirectInMethod = true;
+                    }
                 }
             }
             if (ASSERT_MAIN_THREAD && redirectInMethod && !transformedName.startsWith(SplashProgress) && !(transformedName.startsWith(MinecraftClient) && ExcludedMinecraftMainThreadChecks.contains(mn.name))) {

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/states/VertexAttribState.java

@@ -16,16 +16,19 @@ public class VertexAttribState {
     private static final Int2ObjectOpenHashMap<Attrib[]> vaoAttribs = new Int2ObjectOpenHashMap<>();
     private static Attrib[] current;
     private static final ArrayDeque<Attrib[]> pool = new ArrayDeque<>();
+    private static int clientSideEnabledCount;
 
     public static void init(int defaultVAO) {
         vaoAttribs.clear();
         pool.clear();
         current = allocAttribArray();
         vaoAttribs.put(defaultVAO, current);
+        clientSideEnabledCount = 0;
     }
 
     public static void onBindVertexArray(int newVAO) {
         current = vaoAttribs.computeIfAbsent(newVAO, k -> allocAttribArray());
+        recomputeClientSideCount();
     }
 
     public static void onDeleteVertexArray(int vaoId) {
@@ -39,6 +42,7 @@ public class VertexAttribState {
         vaoAttribs.clear();
         pool.clear();
         current = null;
+        clientSideEnabledCount = 0;
     }
 
     private static Attrib[] allocAttribArray() {
@@ -55,6 +59,7 @@ public class VertexAttribState {
     public static void set(int index, int size, int type, boolean normalized, int stride, long offset, int vboId) {
         if (index < 0 || index >= MAX_ATTRIBS) return;
         final Attrib a = current[index];
+        final boolean was = a.isClientSide();
         a.size = size;
         a.type = type;
         a.normalized = normalized;
@@ -62,11 +67,13 @@ public class VertexAttribState {
         a.offset = offset;
         a.vboId = vboId;
         a.clientPointer = null;
+        if (was) clientSideEnabledCount--;
     }
 
     public static void set(int index, int size, int type, boolean normalized, int stride, ByteBuffer pointer, int vboId) {
         if (index < 0 || index >= MAX_ATTRIBS) return;
         final Attrib a = current[index];
+        final boolean was = a.isClientSide();
         a.size = size;
         a.type = type;
         a.normalized = normalized;
@@ -74,17 +81,33 @@ public class VertexAttribState {
         a.offset = 0;
         a.vboId = vboId;
         a.clientPointer = (vboId == 0) ? pointer : null;
+        final boolean now = a.isClientSide();
+        if (was != now) clientSideEnabledCount += now ? 1 : -1;
     }
 
     public static void setEnabled(int index, boolean enabled) {
         if (index < 0 || index >= MAX_ATTRIBS) return;
-        current[index].enabled = enabled;
+        final Attrib a = current[index];
+        if (a.clientPointer != null && a.enabled != enabled) {
+            clientSideEnabledCount += enabled ? 1 : -1;
+        }
+        a.enabled = enabled;
     }
 
     public static Attrib get(int index) {
         return current[index];
     }
 
+
+
+    private static void recomputeClientSideCount() {
+        int count = 0;
+        for (int i = 0; i < MAX_ATTRIBS; i++) {
+            if (current[i].isClientSide()) count++;
+        }
+        clientSideEnabledCount = count;
+    }
+
     public static boolean hasVBOBoundAttrib() {
         for (int i = 0; i < MAX_ATTRIBS; i++) {
             if (current[i].enabled && current[i].vboId != 0) return true;
@@ -92,6 +115,14 @@ public class VertexAttribState {
         return false;
     }
 
+    /**
+     * Returns true if any currently enabled vertex attribute was registered without a VBO
+     * (i.e. as a client-side pointer). In core profile, such attribs are treated as null
+     * offsets into a non-existent buffer, causing a native crash at draw time.
+     */
+    public static boolean hasAnyClientSideEnabledAttrib() {
+        return clientSideEnabledCount > 0;
+    }
     public static class Attrib {
         public boolean enabled;
         public int size;
@@ -102,6 +133,10 @@ public class VertexAttribState {
         public int vboId;
         public ByteBuffer clientPointer;
 
+        public boolean isClientSide() {
+            return enabled && clientPointer != null;
+        }
+
         public void reset() {
             enabled = false;
             size = 0;

glsm/src/test/java/com/gtnewhorizons/angelica/glsm/FeedbackManagerTest.java

@@ -156,6 +156,57 @@ class FeedbackManagerTest {
         GLStateManager.glDeleteVertexArrays(vao);
     }
 
+    @Test
+    void testPolygonFeedback_GL2D() {
+        final FloatBuffer buf = BufferUtils.createFloatBuffer(128);
+        FeedbackManager.glFeedbackBuffer(GL11.GL_2D, buf);
+        FeedbackManager.glRenderMode(GL11.GL_FEEDBACK);
+
+        GLStateManager.getModelViewMatrix().identity();
+        GLStateManager.getProjectionMatrix().identity();
+        GLStateManager.getViewportState().setViewPort(0, 0, 800, 600);
+        GLStateManager.getViewportState().setDepthRange(0.0, 1.0);
+
+        final int vao = GL30.glGenVertexArrays();
+        GLStateManager.glBindVertexArray(vao);
+
+        final float[] verts = {
+            0f, 0f, 0f,
+            1f, 0f, 0f,
+            1f, 1f, 0f,
+            0f, 1f, 0f
+        };
+        final FloatBuffer vertBuf = BufferUtils.createFloatBuffer(verts.length);
+        vertBuf.put(verts).flip();
+
+        final int vbo = GL15.glGenBuffers();
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
+        GL15.glBufferData(GL15.GL_ARRAY_BUFFER, vertBuf, GL15.GL_STATIC_DRAW);
+        GLStateManager.glVertexAttribPointer(0, 3, GL11.GL_FLOAT, false, 12, 0);
+        GLStateManager.glEnableVertexAttribArray(0);
+
+        FeedbackManager.processDrawArrays(GL11.GL_POLYGON, 0, 4);
+
+        final int count = FeedbackManager.glRenderMode(GL11.GL_RENDER);
+
+        assertEquals(10, count, "Polygon in GL_2D should produce 10 floats");
+        assertEquals(GL11.GL_POLYGON_TOKEN, buf.get(0), 0.001f);
+        assertEquals(4.0f, buf.get(1), 0.001f);
+        assertEquals(400.0f, buf.get(2), 0.01f);
+        assertEquals(300.0f, buf.get(3), 0.01f);
+        assertEquals(800.0f, buf.get(4), 0.01f);
+        assertEquals(300.0f, buf.get(5), 0.01f);
+        assertEquals(800.0f, buf.get(6), 0.01f);
+        assertEquals(600.0f, buf.get(7), 0.01f);
+        assertEquals(400.0f, buf.get(8), 0.01f);
+        assertEquals(600.0f, buf.get(9), 0.01f);
+
+        GLStateManager.glDisableVertexAttribArray(0);
+        GLStateManager.glBindVertexArray(0);
+        GL15.glDeleteBuffers(vbo);
+        GLStateManager.glDeleteVertexArrays(vao);
+    }
+
     @Test
     void testIdentityTransform_viewportMapping() {
         final FloatBuffer buf = BufferUtils.createFloatBuffer(64);

glsm/src/test/java/com/gtnewhorizons/angelica/glsm/redirect/GLSMRedirectorTest.java

@@ -0,0 +1,142 @@
+package com.gtnewhorizons.angelica.glsm.redirect;
+
+import org.junit.jupiter.api.Test;
+import org.objectweb.asm.ClassWriter;
+import org.objectweb.asm.Handle;
+import org.objectweb.asm.Opcodes;
+import org.objectweb.asm.Type;
+import org.objectweb.asm.tree.ClassNode;
+import org.objectweb.asm.tree.InsnNode;
+import org.objectweb.asm.tree.InvokeDynamicInsnNode;
+import org.objectweb.asm.tree.MethodNode;
+
+import java.util.ArrayList;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class GLSMRedirectorTest {
+
+    private static final String GLSM = GLSMRedirector.getTargetClassName();
+
+    private static final Handle LAMBDA_METAFACTORY = new Handle(
+            Opcodes.H_INVOKESTATIC,
+            "java/lang/invoke/LambdaMetafactory",
+            "metafactory",
+            "(Ljava/lang/invoke/MethodHandles$Lookup;Ljava/lang/String;Ljava/lang/invoke/MethodType;"
+                    + "Ljava/lang/invoke/MethodType;Ljava/lang/invoke/MethodHandle;Ljava/lang/invoke/MethodType;)"
+                    + "Ljava/lang/invoke/CallSite;",
+            false);
+
+    private static ClassNode makeClassWithInvokeDynamic(Handle implHandle) {
+        final ClassNode cn = new ClassNode();
+        cn.version = Opcodes.V1_8;
+        cn.access = Opcodes.ACC_PUBLIC;
+        cn.name = "com/example/TestClass";
+        cn.superName = "java/lang/Object";
+        cn.methods = new ArrayList<>();
+
+        final MethodNode mn = new MethodNode(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "test", "()V", null, null);
+        mn.instructions.add(new InvokeDynamicInsnNode(
+                "run",
+                "()Ljava/lang/Runnable;",
+                LAMBDA_METAFACTORY,
+                Type.getType("()V"),
+                implHandle,
+                Type.getType("()V")));
+        mn.instructions.add(new InsnNode(Opcodes.RETURN));
+        cn.methods.add(mn);
+
+        return cn;
+    }
+
+    private static Handle getResultHandle(ClassNode cn) {
+        final InvokeDynamicInsnNode dyn = (InvokeDynamicInsnNode) cn.methods.get(0).instructions.get(0);
+        return (Handle) dyn.bsmArgs[1];
+    }
+
+    @Test
+    void invokeDynamicGL11HandleIsRedirected() {
+        final Handle impl = new Handle(Opcodes.H_INVOKESTATIC, "org/lwjgl/opengl/GL11", "glPopMatrix", "()V", false);
+        final ClassNode cn = makeClassWithInvokeDynamic(impl);
+
+        final boolean changed = new GLSMRedirector().transformClassNode("com.example.TestClass", cn);
+
+        assertTrue(changed);
+        final Handle result = getResultHandle(cn);
+        assertEquals(GLSM, result.getOwner());
+        assertEquals("glPopMatrix", result.getName());
+        assertEquals("()V", result.getDesc());
+        assertEquals(Opcodes.H_INVOKESTATIC, result.getTag());
+    }
+
+    @Test
+    void invokeDynamicNamedClassHandleIsRedirected() {
+        final Handle impl = new Handle(Opcodes.H_INVOKESTATIC, "org/lwjgl/opengl/EXTBlendFuncSeparate", "glBlendFuncSeparateEXT", "(IIII)V", false);
+        final ClassNode cn = makeClassWithInvokeDynamic(impl);
+
+        final boolean changed = new GLSMRedirector().transformClassNode("com.example.TestClass", cn);
+
+        assertTrue(changed);
+        final Handle result = getResultHandle(cn);
+        assertEquals(GLSM, result.getOwner());
+        assertEquals("tryBlendFuncSeparate", result.getName());
+        assertEquals("(IIII)V", result.getDesc());
+    }
+
+    @Test
+    void invokeDynamicNonGLHandleIsNotTouched() {
+        final Handle impl = new Handle(Opcodes.H_INVOKESTATIC, "java/lang/System", "currentTimeMillis", "()J", false);
+        final ClassNode cn = makeClassWithInvokeDynamic(impl);
+
+        final boolean changed = new GLSMRedirector().transformClassNode("com.example.TestClass", cn);
+
+        assertFalse(changed);
+        final Handle result = getResultHandle(cn);
+        assertEquals("java/lang/System", result.getOwner());
+        assertEquals("currentTimeMillis", result.getName());
+    }
+
+    @Test
+    void invokeDynamicUnknownGLMethodIsNotTouched() {
+        final Handle impl = new Handle(Opcodes.H_INVOKESTATIC, "org/lwjgl/opengl/GL11", "glNonexistent", "()V", false);
+        final ClassNode cn = makeClassWithInvokeDynamic(impl);
+
+        final boolean changed = new GLSMRedirector().transformClassNode("com.example.TestClass", cn);
+
+        assertFalse(changed);
+        final Handle result = getResultHandle(cn);
+        assertEquals("org/lwjgl/opengl/GL11", result.getOwner());
+    }
+
+    @Test
+    void invokeDynamicGLCVariantIsRedirected() {
+        final Handle impl = new Handle(Opcodes.H_INVOKESTATIC, "org/lwjgl/opengl/GL11C", "glDrawArrays", "(III)V", false);
+        final ClassNode cn = makeClassWithInvokeDynamic(impl);
+
+        final boolean changed = new GLSMRedirector().transformClassNode("com.example.TestClass", cn);
+
+        assertTrue(changed);
+        final Handle result = getResultHandle(cn);
+        assertEquals(GLSM, result.getOwner());
+        assertEquals("glDrawArrays", result.getName());
+        assertEquals("(III)V", result.getDesc());
+    }
+
+    @Test
+    void transformedClassProducesValidBytecode() {
+        final Handle impl = new Handle(Opcodes.H_INVOKESTATIC, "org/lwjgl/opengl/GL11", "glPopMatrix", "()V", false);
+        final ClassNode cn = makeClassWithInvokeDynamic(impl);
+
+        new GLSMRedirector().transformClassNode("com.example.TestClass", cn);
+
+        final ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
+        assertDoesNotThrow(() -> {
+            cn.accept(cw);
+            final byte[] bytes = cw.toByteArray();
+            assertTrue(bytes.length > 0);
+        });
+    }
+}

src/main/java/com/gtnewhorizons/angelica/api/GLRedirects.java

@@ -0,0 +1,118 @@
+package com.gtnewhorizons.angelica.api;
+
+import com.gtnewhorizons.angelica.glsm.redirect.GLSMRedirector;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.TreeSet;
+import java.util.regex.Pattern;
+
+/**
+ * Public API for querying Angelica's GL call redirections.
+ * <p>
+ * Angelica's bytecode transformer redirects GL calls (e.g., {@code GL11.glPushMatrix()}) to
+ * {@link com.gtnewhorizons.angelica.glsm.GLStateManager GLStateManager} for state tracking and
+ * core profile compatibility. This works for normal Java bytecode loaded through the Forge classloader,
+ * but callers that bypass class transformation (e.g., Nashorn/script engines, reflection, MethodHandles)
+ * need to perform their own redirection.
+ * <p>
+ * This class provides the redirect mapping data and a precompiled regex pattern for transforming
+ * script source text before evaluation.
+ *
+ * <h3>Example: transforming a Nashorn script before eval</h3>
+ * Given a script that uses {@code importPackage(Packages.org.lwjgl.opengl)} and calls
+ * {@code GL11.glPushMatrix()}, the text transformation rewrites those calls before evaluation:
+ * <pre>{@code
+ * // Make GLStateManager available to the script -- either via importPackage:
+ * script = "importPackage(Packages.com.gtnewhorizons.angelica.glsm);\n" + script;
+ * // ... or via Java.type for an explicit binding:
+ * // script = "var GLStateManager = Java.type('" + GLRedirects.TARGET_CLASS + "');\n" + script;
+ *
+ * // Rewrite: GL11.glPushMatrix() -> GLStateManager.glPushMatrix()
+ * script = GLRedirects.getMethodRedirectPattern().matcher(script).replaceAll(mr -> {
+ *     String target = GLRedirects.getTargetMethodName(mr.group(0));
+ *     return target != null ? "GLStateManager." + target : mr.group(0);
+ * });
+ *
+ * engine.eval(script);
+ * }</pre>
+ */
+public final class GLRedirects {
+    /** Fully qualified name of the GLStateManager class that all methods redirect to. */
+    @SuppressWarnings("unused")
+    public static final String TARGET_CLASS = "com.gtnewhorizons.angelica.glsm.GLStateManager";
+
+    private static final String SHORT_GL_PREFIX;
+    private static final Map<String, Map<String, String>> NAMED_CLASS_SHORT_NAME_MAP;
+    private static final Map<String, String> GL_PREFIX_METHOD_REDIRECTS;
+    private static final Pattern METHOD_REDIRECT_PATTERN;
+
+    static {
+        SHORT_GL_PREFIX = buildShortGLPrefix();
+        NAMED_CLASS_SHORT_NAME_MAP = buildNamedClassShortNameMap();
+        GL_PREFIX_METHOD_REDIRECTS = GLSMRedirector.getGLPrefixMethodRedirects();
+        METHOD_REDIRECT_PATTERN = buildMethodRedirectPattern();
+    }
+
+    private GLRedirects() {}
+
+    /**
+     * Returns a precompiled pattern that matches redirected {@code ClassName.methodName} references
+     * using short (simple) class names, as they might typically appear in script text.
+     *
+     * @return compiled regex pattern
+     */
+    public static Pattern getMethodRedirectPattern() {
+        return METHOD_REDIRECT_PATTERN;
+    }
+
+    /**
+     * Looks up the GLStateManager target method name for a short-name reference.
+     *
+     * @param classAndMethod short class name and method, e.g., {@code "GL11.glPushMatrix"}
+     * @return the target method name on GLStateManager (e.g., {@code "glPushMatrix"}), or {@code null} if this reference is not redirected
+     */
+    public static String getTargetMethodName(String classAndMethod) {
+        final int dot = classAndMethod.indexOf('.');
+        if (dot < 0) return null;
+
+        final String className = classAndMethod.substring(0, dot);
+        final String methodName = classAndMethod.substring(dot + 1);
+
+        final Map<String, String> classRedirects = NAMED_CLASS_SHORT_NAME_MAP.get(className);
+        if (classRedirects != null) {
+            return classRedirects.get(methodName);
+        }
+
+        if (className.startsWith(SHORT_GL_PREFIX)) {
+            return GL_PREFIX_METHOD_REDIRECTS.get(methodName);
+        }
+
+        return null;
+    }
+
+    private static String buildShortGLPrefix() {
+        final String glPrefix = GLSMRedirector.getGLPrefix();
+        return glPrefix.substring(glPrefix.lastIndexOf('/') + 1);
+    }
+
+    private static Map<String, Map<String, String>> buildNamedClassShortNameMap() {
+        final Map<String, Map<String, String>> named = new HashMap<>();
+        for (final var entry : GLSMRedirector.getNamedClassMethodRedirects().entrySet()) {
+            final String internalName = entry.getKey();
+            final String shortName = internalName.substring(internalName.lastIndexOf('/') + 1);
+            named.put(shortName, entry.getValue());
+        }
+        return named;
+    }
+
+    private static Pattern buildMethodRedirectPattern() {
+        final TreeSet<String> alternatives = new TreeSet<>();
+        alternatives.add(Pattern.quote(SHORT_GL_PREFIX) + "\\w+");
+        for (final String shortName : NAMED_CLASS_SHORT_NAME_MAP.keySet()) {
+            alternatives.add(Pattern.quote(shortName));
+        }
+        final String classAlt = String.join("|", alternatives);
+        return Pattern.compile("\\b(" + classAlt + ")\\.\\w+\\b");
+    }
+}

src/main/java/com/gtnewhorizons/angelica/client/rendering/DeferredBatchTessellator.java

@@ -2,6 +2,7 @@ package com.gtnewhorizons.angelica.client.rendering;
 
 import com.github.bsideup.jabel.Desugar;
 import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
+import com.gtnewhorizon.gtnhlib.client.renderer.ITessellatorInstance;
 import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags;
 import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
@@ -33,10 +34,30 @@ class DeferredBatchTessellator extends DirectTessellator {
     private final Vector3f scratch = new Vector3f();
     private Matrix4fc currentTransform;
 
+    private Tessellator parentTessellator;
+    private boolean inIntercept;
+
     DeferredBatchTessellator(ByteBuffer buffer) {
         super(buffer, false); // deleteAfter=false: keep buffer across resets for reuse
     }
 
+    void setParentTessellator(Tessellator parent) {
+        this.parentTessellator = parent;
+    }
+
+    @Override
+    public int draw() {
+        if (!inIntercept) {
+            final Tessellator parent = parentTessellator;
+            if (parent != null && parent.isDrawing) {
+                interceptDraw(parent);
+                ((ITessellatorInstance) parent).discard();
+            }
+        }
+        isDrawing = false;
+        return 0;
+    }
+
     @Override
     protected long writeVertexData(VertexFormat format, int[] rawBuffer, int rawBufferIndex) {
         if (currentTransform != null) {
@@ -53,27 +74,32 @@ class DeferredBatchTessellator extends DirectTessellator {
 
     @Override
     protected int interceptDraw(Tessellator tess) {
-        // Compute delta: if current MV differs from default, pre-transform vertices
-        final Matrix4f currentMV = GLStateManager.getModelViewMatrix();
-        if (!currentMV.equals(defaultModelview)) {
-            defaultModelviewInverse.mul(currentMV, deltaMatrix);
-            this.currentTransform = deltaMatrix;
-        } else {
-            this.currentTransform = null;
+        inIntercept = true;
+        try {
+            // Compute delta: if current MV differs from default, pre-transform vertices
+            final Matrix4f currentMV = GLStateManager.getModelViewMatrix();
+            if (!currentMV.equals(defaultModelview)) {
+                defaultModelviewInverse.mul(currentMV, deltaMatrix);
+                this.currentTransform = deltaMatrix;
+            } else {
+                this.currentTransform = null;
+            }
+
+            final int byteOffsetBefore = bufferLimit();
+            final int vertCount = tess.vertexCount;
+            final int drawMode = tess.drawMode;
+            final int flags = VertexFlags.convertToFlags(tess.hasTexture, tess.hasColor, tess.hasNormals, tess.hasBrightness);
+            final long stateKey = DeferredDrawBatcher.captureStateKey();
+
+            final int result = super.interceptDraw(tess); // repacks int[] -> ByteBuffer + transforms if vertexTransform set
+
+            final int byteOffsetAfter = bufferLimit();
+            ranges.add(new DrawRange(stateKey, byteOffsetBefore, byteOffsetAfter - byteOffsetBefore, vertCount, drawMode, flags));
+            this.currentTransform = null; // clear for next draw
+            return result;
+        } finally {
+            inIntercept = false;
         }
-
-        final int byteOffsetBefore = bufferLimit();
-        final int vertCount = tess.vertexCount;
-        final int drawMode = tess.drawMode;
-        final int flags = VertexFlags.convertToFlags(tess.hasTexture, tess.hasColor, tess.hasNormals, tess.hasBrightness);
-        final long stateKey = DeferredDrawBatcher.captureStateKey();
-
-        final int result = super.interceptDraw(tess); // repacks int[] → ByteBuffer + transforms if vertexTransform set
-
-        final int byteOffsetAfter = bufferLimit();
-        ranges.add(new DrawRange(stateKey, byteOffsetBefore, byteOffsetAfter - byteOffsetBefore, vertCount, drawMode, flags));
-        this.currentTransform = null; // clear for next draw
-        return result;
     }
 
     List<DrawRange> getRanges() { return ranges; }
@@ -86,6 +112,7 @@ class DeferredBatchTessellator extends DirectTessellator {
 
     @Override
     protected void onRemovedFromStack() {
+        parentTessellator = null;
         clearRanges();
         super.onRemovedFromStack(); // calls reset(), keeps baseBuffer (deleteAfter=false)
     }

src/main/java/com/gtnewhorizons/angelica/client/rendering/DeferredDrawBatcher.java

@@ -3,6 +3,7 @@ package com.gtnewhorizons.angelica.client.rendering;
 import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import lombok.Getter;
+import net.minecraft.client.renderer.Tessellator;
 import org.lwjgl.opengl.GL11;
 
 import java.util.Comparator;
@@ -37,6 +38,7 @@ public class DeferredDrawBatcher {
             batchTessellator = new DeferredBatchTessellator(memAlloc(INITIAL_BUFFER_SIZE));
         }
         batchTessellator.clearRanges();
+        batchTessellator.setParentTessellator(Tessellator.instance);
         batchTessellator.snapshotDefaultModelview();
         TessellatorManager.startCapturingDirect(batchTessellator);
     }

src/main/java/com/gtnewhorizons/angelica/client/rendering/TextureTracker.java

@@ -1,10 +1,8 @@
 package com.gtnewhorizons.angelica.client.rendering;
 
-import com.gtnewhorizons.angelica.glsm.GLStateManager;
-import com.gtnewhorizons.angelica.glsm.RenderSystem;
-import com.gtnewhorizons.angelica.glsm.hooks.GLSMHooks;
 import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+import net.coderbot.iris.gl.state.StateUpdateNotifiers;
 import net.minecraft.client.renderer.texture.AbstractTexture;
 import org.jetbrains.annotations.Nullable;
 
@@ -15,11 +13,15 @@ public class TextureTracker {
      */
 
     public static final TextureTracker INSTANCE = new TextureTracker();
-
+    
+    private static Runnable bindTextureListener;
+    
+    static {
+        StateUpdateNotifiers.bindTextureNotifier = listener -> bindTextureListener = listener;
+    }
+    
     private final Int2ObjectMap<AbstractTexture> textures = new Int2ObjectOpenHashMap<>();
 
-    private boolean lockBindCallback;
-
     private TextureTracker() {
     }
 
@@ -31,23 +33,13 @@ public class TextureTracker {
     public AbstractTexture getTexture(int id) {
         return textures.get(id);
     }
-
-    public void onBindTexture(int id) {
-        if (lockBindCallback) {
-            return;
-        }
-        if (GLStateManager.getActiveTextureUnit() == 0) {
-            lockBindCallback = true;
-            if (GLSMHooks.TEXTURE_BIND.hasListeners()) {
-                GLSMHooks.textureBindEvent.textureId = id;
-                GLSMHooks.TEXTURE_BIND.post(GLSMHooks.textureBindEvent);
-            }
-            // Reset texture state
-            RenderSystem.bindTextureToUnit(0, id);
-            lockBindCallback = false;
+    
+    public void onBindTexture() {
+        if (bindTextureListener != null) {
+            bindTextureListener.run();
         }
     }
-
+    
     public void onDeleteTexture(int id) {
         textures.remove(id);
     }

src/main/java/com/gtnewhorizons/angelica/compat/ModStatus.java

@@ -25,6 +25,7 @@ public class ModStatus {
     public static boolean isThaumicHorizonsLoaded;
     public static boolean isBaublesLoaded;
     public static boolean isFluidLoggedLoaded;
+    public static boolean isBOPLoaded;
 
     public static void preInit() {
         if (Loader.isModLoaded("backhand")) {
@@ -45,6 +46,7 @@ public class ModStatus {
         isFluidLoggedLoaded = Loader.isModLoaded("fluidlogged");
 
         isHoloInventoryLoaded = Loader.isModLoaded("holoinventory");
+        isBOPLoaded = Loader.isModLoaded("BiomesOPlenty");
 
         // remove compat with original release of BG2
         if (isBattlegearLoaded){

src/main/java/com/gtnewhorizons/angelica/config/AngelicaConfig.java

@@ -262,6 +262,11 @@ public class AngelicaConfig {
         @Config.DefaultBoolean(true)
         @Config.RequiresMcRestart
         public boolean narrowAlfheim;
+
+        @Config.Comment("Narrow Ears transformer exclusions to allow GL redirection")
+        @Config.DefaultBoolean(true)
+        @Config.RequiresMcRestart
+        public boolean narrowEars;
     }
 
     @Config.Comment("Renders chunks before neighbors are ready. Improves loading at render distance edges, useful for low render distance servers.")

src/main/java/com/gtnewhorizons/angelica/iris/IrisGLSMBridge.java

@@ -1,5 +1,6 @@
 package com.gtnewhorizons.angelica.iris;
 
+import com.gtnewhorizons.angelica.client.rendering.TextureTracker;
 import com.gtnewhorizons.angelica.glsm.hooks.DeferredAlphaHandler;
 import com.gtnewhorizons.angelica.glsm.hooks.DeferredBlendHandler;
 import com.gtnewhorizons.angelica.glsm.hooks.DeferredDepthColorHandler;
@@ -10,6 +11,7 @@ import net.coderbot.iris.gl.blending.AlphaTestStorage;
 import net.coderbot.iris.gl.blending.BlendModeStorage;
 import net.coderbot.iris.gl.blending.DepthColorStorage;
 import net.coderbot.iris.gl.program.ProgramUniforms;
+import net.coderbot.iris.gl.state.StateUpdateNotifiers;
 import net.coderbot.iris.pipeline.DeferredWorldRenderingPipeline;
 import net.coderbot.iris.pipeline.WorldRenderingPipeline;
 import net.coderbot.iris.samplers.IrisSamplers;
@@ -17,7 +19,21 @@ import net.coderbot.iris.texture.pbr.PBRTextureManager;
 import net.coderbot.iris.vertices.ImmediateState;
 
 public class IrisGLSMBridge {
-
+    
+    private static Runnable blendFuncListener = null;
+    private static Runnable fogModeListener = null;
+    private static Runnable fogStartListener = null;
+    private static Runnable fogEndListener = null;
+    private static Runnable fogDensityListener = null;
+    
+    static {
+        StateUpdateNotifiers.blendFuncNotifier = listener -> blendFuncListener = listener;
+        StateUpdateNotifiers.fogModeNotifier = listener -> fogModeListener = listener;
+        StateUpdateNotifiers.fogStartNotifier = listener -> fogStartListener = listener;
+        StateUpdateNotifiers.fogEndNotifier = listener -> fogEndListener = listener;
+        StateUpdateNotifiers.fogDensityNotifier = listener -> fogDensityListener = listener;
+    }
+    
     public static void register() {
         IrisSamplers.initRenderer();
         GLSMHooks.blendHandler = new DeferredBlendHandler() {
@@ -75,9 +91,25 @@ public class IrisGLSMBridge {
                 DepthColorStorage.deferColorMask(r, g, b, a);
             }
         };
-
+        
+        GLSMHooks.BLEND_FUNC_CHANGE.addListener(event -> {
+            if (Iris.enabled) {
+                if (blendFuncListener != null) blendFuncListener.run();
+            }
+        });
+        
+        GLSMHooks.FOG_STATE_CHANGE.addListener(event -> {
+            if (Iris.enabled) {
+                if (fogModeListener != null) fogModeListener.run();
+                if (fogStartListener != null) fogStartListener.run();
+                if (fogEndListener != null) fogEndListener.run();
+                if (fogDensityListener != null) fogDensityListener.run();
+            }
+        });
+        
         GLSMHooks.TEXTURE_BIND.addListener(event -> {
             if (Iris.enabled) {
+                TextureTracker.INSTANCE.onBindTexture();
                 final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
                 if (pipeline != null) {
                     pipeline.onBindTexture(event.textureId);

src/main/java/com/gtnewhorizons/angelica/loading/AngelicaClientTweaker.java

@@ -152,6 +152,7 @@ public final class AngelicaClientTweaker implements IFMLLoadingPlugin, IEarlyMix
             narrowTransformerConfig("Xaeros", AngelicaConfig.transformerCompat.narrowXaeros);
             narrowTransformerConfig("AdvancedLightsabers", AngelicaConfig.transformerCompat.narrowAdvancedLightsabers);
             narrowTransformerConfig("Alfheim", AngelicaConfig.transformerCompat.narrowAlfheim);
+            narrowTransformerConfig("Ears", AngelicaConfig.transformerCompat.narrowEars);
 
             tweaks.add("com.gtnewhorizons.angelica.loading.fml.tweakers.IncompatibleModsDisablerTweaker");
             if (AngelicaConfig.enableHudCaching) {

src/main/java/com/gtnewhorizons/angelica/loading/fml/tweakers/AngelicaLateTweaker.java

@@ -71,6 +71,12 @@ public class AngelicaLateTweaker implements ITweaker {
                 FMLRelaunchLog.info("[Angelica] Narrowed com.fiskmods.lightsabers.asm transformer exclusion to allow GL redirection");
             }
 
+            if (narrowEnabled("Ears") && exceptions.remove("com.unascribed.ears")) {
+                exceptions.add("com.unascribed.ears.asm");
+                exceptions.add("com.unascribed.ears.common.agent");
+                FMLRelaunchLog.info("[Angelica] Narrowed com.unascribed.ears transformer exclusion to allow GL redirection");
+            }
+
             if (narrowEnabled("Alfheim") && exceptions.remove("alfheim.common.core.asm.hook")) {
                 exceptions.add("alfheim.common.core.asm.hook.AlfheimFieldHookHandler");
                 exceptions.add("alfheim.common.core.asm.hook.AlfheimHPHooks");

src/main/java/com/gtnewhorizons/angelica/loading/rfb/AngelicaRfbPlugin.java

@@ -15,6 +15,7 @@ public class AngelicaRfbPlugin implements RfbPlugin {
     @Override
     public void onConstruction(@NotNull PluginContext ctx) {
         Launch.blackboard.put("angelica.rfbPluginLoaded", Boolean.TRUE);
+        Launch.classLoader.addClassLoaderExclusion("com.gtnewhorizons.angelica.glsm.redirect.");
     }
 
     @Override

src/main/java/com/gtnewhorizons/angelica/mixins/Mixins.java

@@ -37,7 +37,14 @@ public enum Mixins implements IMixins {
             , "angelica.MixinMinecraft_FrameHook"
             , "angelica.MixinMinecraftServer"
             , "angelica.bugfixes.MixinItemRenderer_EdgeDepth"
+            , "angelica.bugfixes.MixinModelCreeper_AuraBodyInflate"
+            , "angelica.bugfixes.MixinModelWither_ArmorCentering"
+            , "angelica.bugfixes.MixinRenderBlocks_CrossedSquaresNormal"
+            , "angelica.bugfixes.MixinRenderCreeper_AuraDepth"
+            , "angelica.bugfixes.MixinRenderGlobal_DeferredEntityOverlay"
             , "angelica.bugfixes.MixinRenderGlobal_DestroyBlock"
+            , "angelica.bugfixes.MixinRendererLivingEntity_DeferredEntityOverlay"
+            , "angelica.bugfixes.MixinRenderWither_ArmorCentering"
             , "angelica.bugfixes.MixinRendererLivingEntity_EyeDepth"
             , "angelica.debug.MixinMinecraft_FPSCap"
             , "angelica.ffp.MixinTessellator_CoreProfile"
@@ -249,6 +256,7 @@ public enum Mixins implements IMixins {
             , "shaders.MixinRenderEntityFlame"
             , "shaders.MixinRendererLivingEntity"
             , "shaders.MixinRenderGlobal"
+            , "shaders.AccessorEntityHorse"
             , "shaders.MixinRenderHorse"
             , "shaders.MixinRenderItem"
             , "shaders.MixinRenderNameTag"

src/main/java/com/gtnewhorizons/angelica/proxy/ClientProxy.java

@@ -1,5 +1,6 @@
 package com.gtnewhorizons.angelica.proxy;
 
+import biomesoplenty.api.content.BOPCBlocks;
 import com.google.common.base.Objects;
 import com.gtnewhorizon.gtnhlib.client.model.loading.ModelRegistry;
 import com.gtnewhorizon.gtnhlib.client.renderer.vao.VAOManager;
@@ -85,6 +86,7 @@ public final class ClientProxy extends CommonProxy {
     private final Minecraft mc = Minecraft.getMinecraft();
     private final FrametimeGraph frametimeGraph = new FrametimeGraph();
     private final TPSGraph tpsGraph = new TPSGraph();
+    public static Block bopGrass;
 
     public static SodiumGameOptions options() {
         if (CONFIG == null) {
@@ -182,6 +184,9 @@ public final class ClientProxy extends CommonProxy {
                 LOGGER.error("Could not replace LOTR handle render code with thread safe version");
             }
         }
+        if(ModStatus.isBOPLoaded) {
+            bopGrass = BOPCBlocks.newBopGrass;
+        }
     }
 
     float lastIntegratedTickTime;

src/main/java/com/gtnewhorizons/angelica/rendering/DeferredEntityOverlay.java

@@ -0,0 +1,215 @@
+package com.gtnewhorizons.angelica.rendering;
+
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import lombok.Getter;
+import net.coderbot.iris.layer.GbufferPrograms;
+import net.coderbot.iris.uniforms.CapturedRenderingState;
+import net.coderbot.iris.uniforms.EntityIdHelper;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.entity.EntityLivingBase;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+
+import java.nio.FloatBuffer;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Defers entity overlay rendering (auras, armor effects, etc.) to after all entities have been drawn.
+ * This lets us fix z-fighting between overlay's own coplanar faces by disabling the depth mask,
+ * and ensures the overlay composites correctly on top of all opaque geometry.
+ *
+ * Used by both the charged creeper aura and the Wither armor overlay.
+ *
+ * The deferred render replays shouldRenderPass on the original renderer instance so that any
+ * mod mixins targeting that method still fire during the deferred pass.
+ */
+public class DeferredEntityOverlay {
+
+    @FunctionalInterface
+    public interface ShouldRenderPassFn {
+        int invoke(EntityLivingBase entity, int pass, float partialTick);
+    }
+
+    private static final int INITIAL_CAPACITY = 4;
+    private static final List<DeferredEntry> deferred = new ArrayList<>(INITIAL_CAPACITY);
+    private static final List<DeferredEntry> pool = new ArrayList<>(INITIAL_CAPACITY);
+
+    private static final FloatBuffer MATRIX_BUF = BufferUtils.createFloatBuffer(16);
+
+    // Set by the shouldRenderPass inject, consumed by the doRender WrapOperation.
+    @Getter
+    private static boolean overlayPassActive = false;
+
+    // Set during deferred flush to prevent re-deferring when shouldRenderPass is replayed.
+    @Getter
+    private static boolean replaying = false;
+
+    // Pending context from the shouldRenderPass inject, consumed by deferRender.
+    private static ShouldRenderPassFn pendingShouldRenderPass;
+    private static RendererLivingEntity pendingRenderer;
+    private static EntityLivingBase pendingEntity;
+    private static float pendingPartialTick;
+
+    /**
+     * Called from shouldRenderPass HEAD injects. Marks that the upcoming renderPassModel.render()
+     * should be deferred. If a previous mark was not consumed (shouldRenderPass returned <= 0,
+     * so render() was never called).
+     */
+    public static void markOverlayPass(ShouldRenderPassFn shouldRenderPass, RendererLivingEntity renderer,
+                                    EntityLivingBase entity, float partialTick) {
+        overlayPassActive = true;
+        pendingShouldRenderPass = shouldRenderPass;
+        pendingRenderer = renderer;
+        pendingEntity = entity;
+        pendingPartialTick = partialTick;
+    }
+
+    public static void clearStaleOverlayFlag() {
+        overlayPassActive = false;
+    }
+
+    /**
+     * Called from the WrapOperation on renderPassModel.render() in doRender.
+     * Captures the modelview matrix and animation params, skipping the actual render.
+     */
+    public static void deferRender(float limbSwing, float limbSwingAmount, float ageInTicks,
+                                   float headYaw, float headPitch, float scale) {
+        overlayPassActive = false;
+
+        DeferredEntry entry = acquireEntry();
+        entry.set(pendingShouldRenderPass, pendingRenderer, pendingEntity, pendingPartialTick,
+            limbSwing, limbSwingAmount, ageInTicks, headYaw, headPitch, scale);
+
+        MATRIX_BUF.clear();
+        GLStateManager.glGetFloat(GL11.GL_MODELVIEW_MATRIX, MATRIX_BUF);
+        MATRIX_BUF.get(entry.matrix);
+
+        deferred.add(entry);
+
+        pendingShouldRenderPass = null;
+        pendingRenderer = null;
+        pendingEntity = null;
+    }
+
+    private static DeferredEntry acquireEntry() {
+        int size = pool.size();
+        if (size > 0) {
+            return pool.remove(size - 1);
+        }
+        return new DeferredEntry();
+    }
+
+    private static void recycle() {
+        for (DeferredEntry entry : deferred) {
+            entry.shouldRenderPass = null;
+            entry.renderer = null;
+            entry.entity = null;
+            pool.add(entry);
+        }
+        deferred.clear();
+    }
+
+    public static void clear() {
+        recycle();
+        overlayPassActive = false;
+        replaying = false;
+    }
+
+    public static void renderAll() {
+        if (deferred.isEmpty()) return;
+
+        GbufferPrograms.beginEntities();
+        try {
+            for (DeferredEntry entry : deferred) {
+                CapturedRenderingState.INSTANCE.setCurrentEntity(EntityIdHelper.getEntityId(entry.entity));
+                renderOverlay(entry);
+            }
+        } finally {
+            CapturedRenderingState.INSTANCE.setCurrentEntity(-1);
+            GbufferPrograms.endEntities();
+        }
+        recycle();
+    }
+
+    private static void renderOverlay(DeferredEntry entry) {
+        EntityLivingBase entity = entry.entity;
+
+        // Restore the entity's lightmap coords
+        int brightness = entity.getBrightnessForRender(entry.partialTick);
+        OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit,
+            brightness % 65536, (float) brightness / 65536);
+
+        // Restore the saved modelview matrix
+        GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+        GLStateManager.glPushMatrix();
+        boolean depthMaskDisabled = false;
+        try {
+            MATRIX_BUF.clear();
+            MATRIX_BUF.put(entry.matrix);
+            MATRIX_BUF.flip();
+            GLStateManager.glLoadMatrix(MATRIX_BUF);
+
+            // Replay shouldRenderPass pass 1
+            replaying = true;
+            int result = entry.shouldRenderPass.invoke(entity, 1, entry.partialTick);
+            if (result > 0) {
+                // Disable depth writes so coplanar faces don't z-fight each other
+                GLStateManager.glDepthMask(false);
+                depthMaskDisabled = true;
+
+                // Disable backface culling so both sides of the overlay shell are visible
+                GLStateManager.glDisable(GL11.GL_CULL_FACE);
+
+                // Render using the model set by shouldRenderPass
+                entry.renderer.renderPassModel.setLivingAnimations(entity,
+                    entry.limbSwing, entry.limbSwingAmount, entry.partialTick);
+
+                entry.renderer.renderPassModel.render(entity,
+                    entry.limbSwing, entry.limbSwingAmount, entry.ageInTicks,
+                    entry.headYaw, entry.headPitch, entry.scale);
+            }
+
+            // Replay shouldRenderPass pass 2
+            entry.shouldRenderPass.invoke(entity, 2, entry.partialTick);
+        } finally {
+            replaying = false;
+            if (depthMaskDisabled) {
+                GLStateManager.glDepthMask(true);
+                GLStateManager.glEnable(GL11.GL_CULL_FACE);
+            }
+            GLStateManager.glPopMatrix();
+        }
+    }
+
+    private static class DeferredEntry {
+        final float[] matrix = new float[16];
+        ShouldRenderPassFn shouldRenderPass;
+        RendererLivingEntity renderer;
+        EntityLivingBase entity;
+        float partialTick;
+        float limbSwing;
+        float limbSwingAmount;
+        float ageInTicks;
+        float headYaw;
+        float headPitch;
+        float scale;
+
+        void set(ShouldRenderPassFn shouldRenderPass, RendererLivingEntity renderer,
+                 EntityLivingBase entity, float partialTick,
+                 float limbSwing, float limbSwingAmount, float ageInTicks,
+                 float headYaw, float headPitch, float scale) {
+            this.shouldRenderPass = shouldRenderPass;
+            this.renderer = renderer;
+            this.entity = entity;
+            this.partialTick = partialTick;
+            this.limbSwing = limbSwing;
+            this.limbSwingAmount = limbSwingAmount;
+            this.ageInTicks = ageInTicks;
+            this.headYaw = headYaw;
+            this.headPitch = headPitch;
+            this.scale = scale;
+        }
+    }
+}

src/main/java/com/gtnewhorizons/angelica/rendering/ModelHorseArmor.java

@@ -0,0 +1,31 @@
+package com.gtnewhorizons.angelica.rendering;
+
+import net.minecraft.client.model.ModelBox;
+import net.minecraft.client.model.ModelHorse;
+import net.minecraft.client.model.ModelRenderer;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Horse model with all boxes inflated outward, used as a separate armor layer.
+ * Extends ModelHorse to inherit all animation and render logic. The constructor
+ * builds the default geometry, then we rebuild every box with inflate applied.
+ * This mirrors how modern MC uses a separate ModelLayers.HORSE_ARMOR.
+ */
+public class ModelHorseArmor extends ModelHorse {
+
+    public ModelHorseArmor(float inflate) {
+        super();
+        for (ModelRenderer renderer : this.boxList) {
+            List<ModelBox> originalBoxes = new ArrayList<>(renderer.cubeList);
+            renderer.cubeList.clear();
+            for (ModelBox box : originalBoxes) {
+                int width = Math.round(box.posX2 - box.posX1);
+                int height = Math.round(box.posY2 - box.posY1);
+                int depth = Math.round(box.posZ2 - box.posZ1);
+                renderer.addBox(box.posX1, box.posY1, box.posZ1, width, height, depth, inflate);
+            }
+        }
+    }
+}

src/main/java/com/gtnewhorizons/angelica/rendering/WitherArmorState.java

@@ -0,0 +1,5 @@
+package com.gtnewhorizons.angelica.rendering;
+
+public class WitherArmorState {
+    public static boolean pendingInflate = false;
+}

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

@@ -20,6 +20,7 @@ import net.minecraft.crash.CrashReport;
 import net.minecraft.crash.CrashReportCategory;
 import net.minecraft.init.Blocks;
 import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
 import net.minecraft.util.ReportedException;
 import net.minecraft.world.IBlockAccess;
 import org.embeddedt.embeddium.impl.render.chunk.RenderSection;
@@ -139,7 +140,20 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
                         if (block.hasTileEntity(meta)) {
                             final TileEntity tileEntity = region.getTileEntity(x, y, z);
                             if (tileEntity != null && TileEntityRendererDispatcher.instance.hasSpecialRenderer(tileEntity)) {
-                                (TileEntityRenderBoundsRegistry.isAlwaysInfiniteExtent(tileEntity) ? renderData.globalBlockEntities : renderData.culledBlockEntities).add(tileEntity);
+                                final boolean isGlobal;
+                                if (TileEntityRenderBoundsRegistry.isAlwaysInfiniteExtent(tileEntity)) {
+                                    isGlobal = true;
+                                } else {
+                                    final AxisAlignedBB aabb = tileEntity.getRenderBoundingBox();
+                                    if (aabb != null) {
+                                        final int secMinX = x & ~15, secMinY = y & ~15, secMinZ = z & ~15;
+                                        isGlobal = aabb.minX < secMinX || aabb.minY < secMinY || aabb.minZ < secMinZ
+                                            || aabb.maxX > secMinX + 16 || aabb.maxY > secMinY + 16 || aabb.maxZ > secMinZ + 16;
+                                    } else {
+                                        isGlobal = false;
+                                    }
+                                }
+                                (isGlobal ? renderData.globalBlockEntities : renderData.culledBlockEntities).add(tileEntity);
                             }
                         }
 

src/main/java/net/coderbot/iris/gl/state/StateUpdateNotifiers.java

@@ -1,9 +1,16 @@
 package net.coderbot.iris.gl.state;
 
 /**
- * Holds update notifiers for PBR texture changes.
+ * Holds some standard update notifiers for various elements of GL state.
  */
 public class StateUpdateNotifiers {
+	public static ValueUpdateNotifier fogModeNotifier;
+	public static ValueUpdateNotifier fogStartNotifier;
+	public static ValueUpdateNotifier fogEndNotifier;
+	public static ValueUpdateNotifier fogDensityNotifier;
+	public static ValueUpdateNotifier blendFuncNotifier;
+	public static ValueUpdateNotifier bindTextureNotifier;
 	public static ValueUpdateNotifier normalTextureChangeNotifier;
 	public static ValueUpdateNotifier specularTextureChangeNotifier;
+	public static ValueUpdateNotifier phaseChangeNotifier;
 }

src/main/java/net/coderbot/iris/gl/uniform/DynamicLocationalUniformHolder.java

@@ -1,11 +1,10 @@
 package net.coderbot.iris.gl.uniform;
 
 import net.coderbot.iris.gl.state.ValueUpdateNotifier;
-import org.joml.Vector2i;
-import org.joml.Vector3i;
+import org.joml.Vector2ic;
 import org.joml.Vector3ic;
-import org.joml.Vector4f;
-import org.joml.Vector4i;
+import org.joml.Vector4fc;
+import org.joml.Vector4ic;
 
 import java.util.function.DoubleSupplier;
 import java.util.function.IntSupplier;
@@ -38,7 +37,7 @@ public interface DynamicLocationalUniformHolder extends LocationalUniformHolder,
 		return this;
 	}
 
-	default DynamicLocationalUniformHolder uniform2i(String name, Supplier<Vector2i> value, ValueUpdateNotifier notifier) {
+	default DynamicLocationalUniformHolder uniform2i(String name, Supplier<Vector2ic> value, ValueUpdateNotifier notifier) {
 		location(name, UniformType.VEC2I).ifPresent(id -> addDynamicUniform(new Vector2IntegerJomlUniform(id, value, notifier), notifier));
 
 		return this;
@@ -50,7 +49,7 @@ public interface DynamicLocationalUniformHolder extends LocationalUniformHolder,
         return this;
     }
 
-	default DynamicUniformHolder uniform4f(String name, Supplier<Vector4f> value, ValueUpdateNotifier notifier) {
+	default DynamicUniformHolder uniform4f(String name, Supplier<Vector4fc> value, ValueUpdateNotifier notifier) {
 		location(name, UniformType.VEC4).ifPresent(id -> addDynamicUniform(new Vector4Uniform(id, value, notifier), notifier));
 
 		return this;
@@ -61,7 +60,7 @@ public interface DynamicLocationalUniformHolder extends LocationalUniformHolder,
         return this;
     }
 
-	default DynamicUniformHolder uniform4i(String name, Supplier<Vector4i> value, ValueUpdateNotifier notifier) {
+	default DynamicUniformHolder uniform4i(String name, Supplier<Vector4ic> value, ValueUpdateNotifier notifier) {
 		location(name, UniformType.VEC4I).ifPresent(id -> addDynamicUniform(new Vector4IntegerJomlUniform(id, value, notifier), notifier));
 
 		return this;

src/main/java/net/coderbot/iris/gl/uniform/DynamicUniformHolder.java

@@ -1,11 +1,10 @@
 package net.coderbot.iris.gl.uniform;
 
 import net.coderbot.iris.gl.state.ValueUpdateNotifier;
-import org.joml.Vector2i;
-import org.joml.Vector3i;
+import org.joml.Vector2ic;
 import org.joml.Vector3ic;
-import org.joml.Vector4f;
-import org.joml.Vector4i;
+import org.joml.Vector4fc;
+import org.joml.Vector4ic;
 
 import java.util.function.DoubleSupplier;
 import java.util.function.IntSupplier;
@@ -16,9 +15,9 @@ public interface DynamicUniformHolder extends UniformHolder {
 	DynamicUniformHolder uniform1f(String name, IntSupplier value, ValueUpdateNotifier notifier);
 	DynamicUniformHolder uniform1f(String name, DoubleSupplier value, ValueUpdateNotifier notifier);
 	DynamicUniformHolder uniform1i(String name, IntSupplier value, ValueUpdateNotifier notifier);
-	DynamicUniformHolder uniform2i(String name, Supplier<Vector2i> value, ValueUpdateNotifier notifier);
+	DynamicUniformHolder uniform2i(String name, Supplier<Vector2ic> value, ValueUpdateNotifier notifier);
     DynamicUniformHolder uniform3i(String name, Supplier<Vector3ic> value, ValueUpdateNotifier notifier);
-	DynamicUniformHolder uniform4f(String name, Supplier<Vector4f> value, ValueUpdateNotifier notifier);
+	DynamicUniformHolder uniform4f(String name, Supplier<Vector4fc> value, ValueUpdateNotifier notifier);
     DynamicUniformHolder uniform4fArray(String name, Supplier<float[]> value, ValueUpdateNotifier notifier);
-	DynamicUniformHolder uniform4i(String name, Supplier<Vector4i> value, ValueUpdateNotifier notifier);
+	DynamicUniformHolder uniform4i(String name, Supplier<Vector4ic> value, ValueUpdateNotifier notifier);
 }

src/main/java/net/coderbot/iris/gl/uniform/LocationalUniformHolder.java

@@ -4,13 +4,13 @@ import net.minecraft.util.Vec3;
 import org.joml.Matrix4f;
 import org.joml.Matrix4fc;
 import org.joml.Vector2f;
-import org.joml.Vector2i;
+import org.joml.Vector2ic;
 import org.joml.Vector3d;
 import org.joml.Vector3f;
 import org.joml.Vector3fc;
 import org.joml.Vector3i;
 import org.joml.Vector3ic;
-import org.joml.Vector4f;
+import org.joml.Vector4fc;
 
 import java.util.OptionalInt;
 import java.util.function.BooleanSupplier;
@@ -66,7 +66,7 @@ public interface LocationalUniformHolder extends UniformHolder {
 	}
 
 	@Override
-	default LocationalUniformHolder uniform2i(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector2i> value) {
+	default LocationalUniformHolder uniform2i(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector2ic> value) {
 		location(name, UniformType.VEC2I).ifPresent(id -> addUniform(updateFrequency, new Vector2IntegerJomlUniform(id, value)));
 
 		return this;
@@ -94,7 +94,7 @@ public interface LocationalUniformHolder extends UniformHolder {
 	}
 
 	@Override
-	default LocationalUniformHolder uniformTruncated3f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4f> value) {
+	default LocationalUniformHolder uniformTruncated3f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4fc> value) {
 		location(name, UniformType.VEC3).ifPresent(id -> addUniform(updateFrequency, Vector3Uniform.truncated(id, value)));
 
 		return this;
@@ -108,7 +108,7 @@ public interface LocationalUniformHolder extends UniformHolder {
 	}
 
 	@Override
-	default LocationalUniformHolder uniform4f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4f> value) {
+	default LocationalUniformHolder uniform4f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4fc> value) {
 		location(name, UniformType.VEC4).ifPresent(id -> addUniform(updateFrequency, new Vector4Uniform(id, value)));
 
 		return this;

src/main/java/net/coderbot/iris/gl/uniform/UniformHolder.java

@@ -3,12 +3,12 @@ package net.coderbot.iris.gl.uniform;
 import net.minecraft.util.Vec3;
 import org.joml.Matrix4fc;
 import org.joml.Vector2f;
-import org.joml.Vector2i;
+import org.joml.Vector2ic;
 import org.joml.Vector3d;
 import org.joml.Vector3fc;
 import org.joml.Vector3i;
 import org.joml.Vector3ic;
-import org.joml.Vector4f;
+import org.joml.Vector4fc;
 
 import java.util.function.BooleanSupplier;
 import java.util.function.DoubleSupplier;
@@ -28,7 +28,7 @@ public interface UniformHolder {
 
 	UniformHolder uniform2f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector2f> value);
 
-	UniformHolder uniform2i(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector2i> value);
+	UniformHolder uniform2i(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector2ic> value);
 
 	UniformHolder uniform3f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector3fc> value);
 
@@ -36,11 +36,11 @@ public interface UniformHolder {
 
 	UniformHolder uniformVanilla3f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vec3> value);
 
-	UniformHolder uniformTruncated3f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4f> value);
+	UniformHolder uniformTruncated3f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4fc> value);
 
 	UniformHolder uniform3d(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector3d> value);
 
-	UniformHolder uniform4f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4f> value);
+	UniformHolder uniform4f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4fc> value);
 
     UniformHolder uniform4fArray(UniformUpdateFrequency updateFrequency, String name, Supplier<float[]> value);
 

src/main/java/net/coderbot/iris/gl/uniform/Vector2IntegerJomlUniform.java

@@ -3,21 +3,22 @@ package net.coderbot.iris.gl.uniform;
 import com.gtnewhorizons.angelica.glsm.RenderSystem;
 import net.coderbot.iris.gl.state.ValueUpdateNotifier;
 import org.joml.Vector2i;
+import org.joml.Vector2ic;
 
 import java.util.function.Supplier;
 
 public class Vector2IntegerJomlUniform extends Uniform {
-	private Vector2i cachedValue;
-	private final Supplier<Vector2i> value;
+	private final Vector2i cachedValue;
+	private final Supplier<Vector2ic> value;
 
-	Vector2IntegerJomlUniform(int location, Supplier<Vector2i> value) {
+	Vector2IntegerJomlUniform(int location, Supplier<Vector2ic> value) {
 		this(location, value, null);
 	}
 
-	Vector2IntegerJomlUniform(int location, Supplier<Vector2i> value, ValueUpdateNotifier notifier) {
+	Vector2IntegerJomlUniform(int location, Supplier<Vector2ic> value, ValueUpdateNotifier notifier) {
 		super(location, notifier);
 
-		this.cachedValue = null;
+		this.cachedValue = new Vector2i();
 		this.value = value;
 	}
 
@@ -31,11 +32,11 @@ public class Vector2IntegerJomlUniform extends Uniform {
 	}
 
 	private void updateValue() {
-		Vector2i newValue = value.get();
+		Vector2ic newValue = value.get();
 
-		if (cachedValue == null || !newValue.equals(cachedValue)) {
-			cachedValue = newValue;
-			RenderSystem.uniform2i(this.location, newValue.x, newValue.y);
+		if (!newValue.equals(cachedValue)) {
+			cachedValue.set(newValue.x(), newValue.y());
+			RenderSystem.uniform2i(this.location, cachedValue.x, cachedValue.y);
 		}
 	}
 }

src/main/java/net/coderbot/iris/gl/uniform/Vector3Uniform.java

@@ -4,7 +4,7 @@ import com.gtnewhorizons.angelica.glsm.RenderSystem;
 import org.joml.Vector3d;
 import org.joml.Vector3f;
 import org.joml.Vector3fc;
-import org.joml.Vector4f;
+import org.joml.Vector4fc;
 
 import java.util.function.Supplier;
 
@@ -31,11 +31,11 @@ public class Vector3Uniform extends Uniform {
 		});
 	}
 
-	static Vector3Uniform truncated(int location, Supplier<Vector4f> value) {
+	static Vector3Uniform truncated(int location, Supplier<Vector4fc> value) {
 		Vector3f held = new Vector3f();
 
 		return new Vector3Uniform(location, () -> {
-			Vector4f updated = value.get();
+			Vector4fc updated = value.get();
 
 			held.set(updated.x(), updated.y(), updated.z());
 

src/main/java/net/coderbot/iris/gl/uniform/Vector4IntegerJomlUniform.java

@@ -3,21 +3,22 @@ package net.coderbot.iris.gl.uniform;
 import com.gtnewhorizons.angelica.glsm.RenderSystem;
 import net.coderbot.iris.gl.state.ValueUpdateNotifier;
 import org.joml.Vector4i;
+import org.joml.Vector4ic;
 
 import java.util.function.Supplier;
 
 public class Vector4IntegerJomlUniform extends Uniform {
-	private Vector4i cachedValue;
-	private final Supplier<Vector4i> value;
+	private final Vector4i cachedValue;
+	private final Supplier<Vector4ic> value;
 
-	Vector4IntegerJomlUniform(int location, Supplier<Vector4i> value) {
+	Vector4IntegerJomlUniform(int location, Supplier<Vector4ic> value) {
 		this(location, value, null);
 	}
 
-	Vector4IntegerJomlUniform(int location, Supplier<Vector4i> value, ValueUpdateNotifier notifier) {
+	Vector4IntegerJomlUniform(int location, Supplier<Vector4ic> value, ValueUpdateNotifier notifier) {
 		super(location, notifier);
 
-		this.cachedValue = null;
+		this.cachedValue = new Vector4i();
 		this.value = value;
 	}
 
@@ -31,11 +32,11 @@ public class Vector4IntegerJomlUniform extends Uniform {
 	}
 
 	private void updateValue() {
-		Vector4i newValue = value.get();
+		Vector4ic newValue = value.get();
 
-		if (cachedValue == null || !newValue.equals(cachedValue)) {
-			cachedValue = newValue;
-			RenderSystem.uniform4i(this.location, newValue.x, newValue.y, newValue.z, newValue.w);
+		if (!newValue.equals(cachedValue)) {
+			cachedValue.set(newValue.x(), newValue.y(), newValue.z(), newValue.w());
+			RenderSystem.uniform4i(this.location, cachedValue.x, cachedValue.y, cachedValue.z, cachedValue.w);
 		}
 	}
 }

src/main/java/net/coderbot/iris/gl/uniform/Vector4Uniform.java

@@ -3,18 +3,19 @@ package net.coderbot.iris.gl.uniform;
 import com.gtnewhorizons.angelica.glsm.RenderSystem;
 import net.coderbot.iris.gl.state.ValueUpdateNotifier;
 import org.joml.Vector4f;
+import org.joml.Vector4fc;
 
 import java.util.function.Supplier;
 
 public class Vector4Uniform extends Uniform {
 	private final Vector4f cachedValue;
-	private final Supplier<Vector4f> value;
+	private final Supplier<Vector4fc> value;
 
-	Vector4Uniform(int location, Supplier<Vector4f> value) {
+	Vector4Uniform(int location, Supplier<Vector4fc> value) {
 		this(location, value, null);
 	}
 
-	Vector4Uniform(int location, Supplier<Vector4f> value, ValueUpdateNotifier notifier) {
+	Vector4Uniform(int location, Supplier<Vector4fc> value, ValueUpdateNotifier notifier) {
 		super(location, notifier);
 
 		this.cachedValue = new Vector4f();
@@ -31,7 +32,7 @@ public class Vector4Uniform extends Uniform {
 	}
 
 	private void updateValue() {
-		Vector4f newValue = value.get();
+		Vector4fc newValue = value.get();
 
 		if (!newValue.equals(cachedValue)) {
 			cachedValue.set(newValue.x(), newValue.y(), newValue.z(), newValue.w());

src/main/java/net/coderbot/iris/layer/GbufferPrograms.java

@@ -4,6 +4,7 @@ import net.coderbot.iris.Iris;
 import net.coderbot.iris.gbuffer_overrides.matching.SpecialCondition;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import net.coderbot.iris.gl.shader.ProgramCreator;
+import net.coderbot.iris.gl.state.StateUpdateNotifiers;
 import net.coderbot.iris.pipeline.WorldRenderingPhase;
 import net.coderbot.iris.pipeline.WorldRenderingPipeline;
 
@@ -11,7 +12,12 @@ public class GbufferPrograms {
 	private static boolean entities;
 	private static boolean blockEntities;
 	private static boolean outline;
-
+	private static Runnable phaseChangeListener;
+	
+	static {
+		StateUpdateNotifiers.phaseChangeNotifier = listener -> phaseChangeListener = listener;
+	}
+	
 	private static void checkReentrancy() {
 		if (entities || blockEntities || outline) {
 			throw new IllegalStateException("GbufferPrograms in weird state, tried to call begin function when entities = "
@@ -106,7 +112,13 @@ public class GbufferPrograms {
 	public static void teardownSpecialRenderCondition() {
 		Iris.getPipelineManager().getPipeline().ifPresent(p -> p.setSpecialCondition(null));
 	}
-
+	
+	public static void runPhaseChangeNotifier() {
+		if (phaseChangeListener != null) {
+			phaseChangeListener.run();
+		}
+	}
+	
 	public static void init() {
 		// Empty initializer to run static
 	}

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

@@ -41,6 +41,7 @@ import net.coderbot.iris.gl.state.FogMode;
 import net.coderbot.iris.gl.texture.DepthBufferFormat;
 import net.coderbot.iris.gl.texture.TextureType;
 import net.coderbot.iris.helpers.Tri;
+import net.coderbot.iris.layer.GbufferPrograms;
 import net.coderbot.iris.pipeline.transform.PatchShaderType;
 import net.coderbot.iris.pipeline.transform.TransformPatcher;
 import net.coderbot.iris.postprocess.BufferFlipper;
@@ -200,14 +201,17 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
 	public DeferredWorldRenderingPipeline(ProgramSet programs) {
 		Objects.requireNonNull(programs);
 
-		final Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> prepareTransformFutures = submitCompositeTransforms(programs.getPrepare());
-		final Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> deferredTransformFutures = submitCompositeTransforms(programs.getDeferred());
-		final Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> compositeTransformFutures = submitCompositeTransforms(programs.getComposite());
+		final Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> prepareTransformFutures =
+			submitCompositeTransforms(programs.getPrepare(), TextureStage.PREPARE, programs.getPackDirectives().getTextureMap());
+		final Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> deferredTransformFutures =
+			submitCompositeTransforms(programs.getDeferred(), TextureStage.DEFERRED, programs.getPackDirectives().getTextureMap());
+		final Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> compositeTransformFutures =
+			submitCompositeTransforms(programs.getComposite(), TextureStage.COMPOSITE_AND_FINAL, programs.getPackDirectives().getTextureMap());
 
 		final CompletableFuture<Map<PatchShaderType, String>> finalTransformFuture =
 			programs.getCompositeFinal()
 				.filter(ProgramSource::isValid)
-				.map(DeferredWorldRenderingPipeline::submitCompositeTransform)
+				.map(source -> submitCompositeTransform(source, TextureStage.COMPOSITE_AND_FINAL, programs.getPackDirectives().getTextureMap()))
 				.orElse(null);
 
 		resolver = new ProgramFallbackResolver(programs);
@@ -771,10 +775,10 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
 		if (!isRenderingWorld || isRenderingFullScreenPass || isPostChain || !isMainBound) {
 			return;
 		}
-
+		
 		final RenderCondition condition = getCondition(getPhase());
 		final Pass matched = table.match(condition, inputs);
-
+		
 		beginPass(matched);
 	}
 
@@ -1653,12 +1657,14 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
 	public void setOverridePhase(WorldRenderingPhase phase) {
 		this.overridePhase = phase;
 		matchPass();
+		GbufferPrograms.runPhaseChangeNotifier();
 	}
 
 	@Override
 	public void setPhase(WorldRenderingPhase phase) {
 		this.phase = phase;
 		matchPass();
+		GbufferPrograms.runPhaseChangeNotifier();
 	}
 
 	@Override
@@ -1710,11 +1716,20 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
 	private static final InputAvailability INPUT_TEXTURE_LIGHTMAP = new InputAvailability(true, true);
 	private static final InputAvailability[] INPUT_AVAILABILITIES = { INPUT_NONE, INPUT_TEXTURE, INPUT_TEXTURE_LIGHTMAP };
 
-	private static CompletableFuture<Map<PatchShaderType, String>> submitCompositeTransform(ProgramSource source) {
-		return Iris.ShaderTransformExecutor.submitTracked(() -> TransformPatcher.patchComposite(source.getVertexSource().orElse(null), source.getGeometrySource().orElse(null), source.getTessControlSource().orElse(null), source.getTessEvalSource().orElse(null), source.getFragmentSource().orElse(null)));
+	private static CompletableFuture<Map<PatchShaderType, String>> submitCompositeTransform(ProgramSource source, TextureStage stage,
+		Object2ObjectMap<Tri<String, TextureType, TextureStage>, String> textureMap) {
+		return Iris.ShaderTransformExecutor.submitTracked(() -> TransformPatcher.patchComposite(
+			source.getVertexSource().orElse(null),
+			source.getGeometrySource().orElse(null),
+			source.getTessControlSource().orElse(null),
+			source.getTessEvalSource().orElse(null),
+			source.getFragmentSource().orElse(null),
+			stage,
+			textureMap));
 	}
 
-	private static Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> submitCompositeTransforms(ProgramSource[] sources) {
+	private static Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> submitCompositeTransforms(ProgramSource[] sources,
+		TextureStage stage, Object2ObjectMap<Tri<String, TextureType, TextureStage>, String> textureMap) {
 		// Count valid sources for initial capacity
 		int count = 0;
 		for (ProgramSource source : sources) {
@@ -1723,7 +1738,7 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
 		final Map<Integer, CompletableFuture<Map<PatchShaderType, String>>> futures = new HashMap<>(count);
 		for (int i = 0; i < sources.length; i++) {
 			if (sources[i] != null && sources[i].isValid()) {
-				futures.put(i, submitCompositeTransform(sources[i]));
+				futures.put(i, submitCompositeTransform(sources[i], stage, textureMap));
 			}
 		}
 		return futures;

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

@@ -39,56 +39,54 @@ public class PatchedShaderPrinter {
 	}
 
 	public static void debugPatchedShaders(String name, String vertex, String geometry, String tessControl, String tessEval, String fragment, String compute) {
-		if (!Iris.getIrisConfig().areDebugOptionsEnabled()) {
+		if (!prettyPrintShaders && !Iris.getIrisConfig().areDebugOptionsEnabled()) {
 			return;
 		}
-		if (prettyPrintShaders) {
-			final Path debugOutDir = Minecraft.getMinecraft().mcDataDir.toPath().resolve("patched_shaders");
-			if (!outputLocationCleared) {
-				try {
-					if (Files.exists(debugOutDir)) {
-						try (Stream<Path> stream = Files.list(debugOutDir)) {
-							stream.forEach(path -> {
-								try {
-									Files.delete(path);
-								} catch (IOException e) {
-									throw new RuntimeException(e);
-								}
-							});
-						}
-					}
-
-					Files.createDirectories(debugOutDir);
-				} catch (IOException e) {
-					Iris.logger.warn("Failed to initialize debug patched shader source location", e);
-				}
-				outputLocationCleared = true;
-			}
-
+		final Path debugOutDir = Minecraft.getMinecraft().mcDataDir.toPath().resolve("patched_shaders");
+		if (!outputLocationCleared) {
 			try {
-				programCounter++;
-				String prefix = String.format("%03d_", programCounter);
-				if (vertex != null) {
-					Files.write(debugOutDir.resolve(prefix + name + ".vsh"), vertex.getBytes(StandardCharsets.UTF_8));
-				}
-				if (geometry != null) {
-					Files.write(debugOutDir.resolve(prefix + name + ".gsh"), geometry.getBytes(StandardCharsets.UTF_8));
-				}
-				if (tessControl != null) {
-					Files.write(debugOutDir.resolve(prefix + name + ".tcs"), tessControl.getBytes(StandardCharsets.UTF_8));
-				}
-				if (tessEval != null) {
-					Files.write(debugOutDir.resolve(prefix + name + ".tes"), tessEval.getBytes(StandardCharsets.UTF_8));
-				}
-				if (fragment != null) {
-					Files.write(debugOutDir.resolve(prefix + name + ".fsh"), fragment.getBytes(StandardCharsets.UTF_8));
-				}
-				if (compute != null) {
-					Files.write(debugOutDir.resolve(prefix + name + ".csh"), compute.getBytes(StandardCharsets.UTF_8));
+				if (Files.exists(debugOutDir)) {
+					try (Stream<Path> stream = Files.list(debugOutDir)) {
+						stream.forEach(path -> {
+							try {
+								Files.delete(path);
+							} catch (IOException e) {
+								throw new RuntimeException(e);
+							}
+						});
+					}
 				}
+
+				Files.createDirectories(debugOutDir);
 			} catch (IOException e) {
-				Iris.logger.warn("Failed to write debug patched shader source", e);
+				Iris.logger.warn("Failed to initialize debug patched shader source location", e);
 			}
+			outputLocationCleared = true;
+		}
+
+		try {
+			programCounter++;
+			String prefix = String.format("%03d_", programCounter);
+			if (vertex != null) {
+				Files.write(debugOutDir.resolve(prefix + name + ".vsh"), vertex.getBytes(StandardCharsets.UTF_8));
+			}
+			if (geometry != null) {
+				Files.write(debugOutDir.resolve(prefix + name + ".gsh"), geometry.getBytes(StandardCharsets.UTF_8));
+			}
+			if (tessControl != null) {
+				Files.write(debugOutDir.resolve(prefix + name + ".tcs"), tessControl.getBytes(StandardCharsets.UTF_8));
+			}
+			if (tessEval != null) {
+				Files.write(debugOutDir.resolve(prefix + name + ".tes"), tessEval.getBytes(StandardCharsets.UTF_8));
+			}
+			if (fragment != null) {
+				Files.write(debugOutDir.resolve(prefix + name + ".fsh"), fragment.getBytes(StandardCharsets.UTF_8));
+			}
+			if (compute != null) {
+				Files.write(debugOutDir.resolve(prefix + name + ".csh"), compute.getBytes(StandardCharsets.UTF_8));
+			}
+		} catch (IOException e) {
+			Iris.logger.warn("Failed to write debug patched shader source", e);
 		}
 	}
 }

src/main/java/net/coderbot/iris/pipeline/transform/ShaderTransformer.java

@@ -448,6 +448,7 @@ public class ShaderTransformer {
             default:
                 throw new IllegalStateException("Unknown patch type: " + patchType.name());
         }
+        TextureTransformer.transform(transformer, parameters);
         CompatibilityTransformer.transformEach(transformer, parameters);
     }
 

src/main/java/net/coderbot/iris/pipeline/transform/TextureTransformer.java

@@ -0,0 +1,51 @@
+package net.coderbot.iris.pipeline.transform;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectMap;
+import net.coderbot.iris.gl.texture.TextureType;
+import net.coderbot.iris.helpers.Tri;
+import net.coderbot.iris.pipeline.transform.parameter.Parameters;
+import net.coderbot.iris.shaderpack.texture.TextureStage;
+import org.taumc.glsl.Transformer;
+import org.taumc.glsl.grammar.GLSLLexer;
+
+final class TextureTransformer {
+	private TextureTransformer() {
+	}
+
+	static void transform(Transformer transformer, Parameters parameters) {
+		final Object2ObjectMap<Tri<String, TextureType, TextureStage>, String> textureMap = parameters.getTextureMap();
+		if (textureMap == null || textureMap.isEmpty()) {
+			return;
+		}
+
+		final TextureStage stage = parameters.getTextureStage();
+		textureMap.forEach((key, replacement) -> {
+			if (key.third() != stage) {
+				return;
+			}
+
+			final String name = key.first();
+			final int type = transformer.findType(name);
+			if (type != 0 && isTypeValid(key.second(), type)) {
+				transformer.rename(name, replacement);
+			}
+		});
+	}
+
+	private static boolean isTypeValid(TextureType expectedType, int extractedType) {
+		return switch (expectedType) {
+			case TEXTURE_1D -> extractedType == GLSLLexer.SAMPLER1D ||
+				extractedType == GLSLLexer.ISAMPLER1D ||
+				extractedType == GLSLLexer.USAMPLER1D;
+			case TEXTURE_RECTANGLE -> extractedType == GLSLLexer.SAMPLER2DRECT ||
+				extractedType == GLSLLexer.ISAMPLER2DRECT ||
+				extractedType == GLSLLexer.USAMPLER2DRECT;
+			case TEXTURE_2D -> extractedType == GLSLLexer.SAMPLER2D ||
+				extractedType == GLSLLexer.ISAMPLER2D ||
+				extractedType == GLSLLexer.USAMPLER2D;
+			case TEXTURE_3D -> extractedType == GLSLLexer.SAMPLER3D ||
+				extractedType == GLSLLexer.ISAMPLER3D ||
+				extractedType == GLSLLexer.USAMPLER3D;
+		};
+	}
+}

src/main/java/net/coderbot/iris/pipeline/transform/TransformPatcher.java

@@ -120,10 +120,6 @@ public class TransformPatcher {
         return patchComposite(vertex, geometry, null, null, fragment, TextureStage.COMPOSITE_AND_FINAL, null);
     }
 
-    public static Map<PatchShaderType, String> patchComposite(String vertex, String geometry, String tessControl, String tessEval, String fragment) {
-        return patchComposite(vertex, geometry, tessControl, tessEval, fragment, TextureStage.COMPOSITE_AND_FINAL, null);
-    }
-
     public static Map<PatchShaderType, String> patchComposite(String vertex, String geometry, String tessControl, String tessEval, String fragment, TextureStage stage, Object2ObjectMap<Tri<String, TextureType, TextureStage>, String> textureMap) {
         return transform(vertex, geometry, tessControl, tessEval, fragment, new TextureStageParameters(Patch.COMPOSITE, stage, textureMap));
     }

src/main/java/net/coderbot/iris/postprocess/FinalPassRenderer.java

@@ -146,7 +146,7 @@ public class FinalPassRenderer {
 		GLStateManager.glBindFramebuffer(GL30.GL_READ_FRAMEBUFFER, 0);
 	}
 
-	private static Map<PatchShaderType, String> getTransformed(ProgramSource source, CompletableFuture<Map<PatchShaderType, String>> precomputedTransformFuture, String stageName) {
+	private Map<PatchShaderType, String> getTransformed(ProgramSource source, CompletableFuture<Map<PatchShaderType, String>> precomputedTransformFuture, String stageName) {
 		if (precomputedTransformFuture != null) {
 			try {
 				final Map<PatchShaderType, String> result = precomputedTransformFuture.join();
@@ -157,7 +157,14 @@ public class FinalPassRenderer {
 				throw new RuntimeException("Shader transformation failed for '" + source.getName() + "' in stage '" + stageName + "'", e.getCause() != null ? e.getCause() : e);
 			}
 		}
-		return TransformPatcher.patchComposite(source.getVertexSource().orElseThrow(NullPointerException::new), source.getGeometrySource().orElse(null), source.getTessControlSource().orElse(null), source.getTessEvalSource().orElse(null), source.getFragmentSource().orElseThrow(NullPointerException::new));
+		return TransformPatcher.patchComposite(
+			source.getVertexSource().orElseThrow(NullPointerException::new),
+			source.getGeometrySource().orElse(null),
+			source.getTessControlSource().orElse(null),
+			source.getTessEvalSource().orElse(null),
+			source.getFragmentSource().orElseThrow(NullPointerException::new),
+			TextureStage.COMPOSITE_AND_FINAL,
+			pipeline != null ? pipeline.getTextureMap() : null);
 	}
 
 	private static final class Pass {

src/main/java/net/coderbot/iris/shadows/ShadowCompositeRenderer.java

@@ -263,7 +263,9 @@ public class ShadowCompositeRenderer {
                 source.getGeometrySource().orElse(null),
                 source.getTessControlSource().orElse(null),
                 source.getTessEvalSource().orElse(null),
-                source.getFragmentSource().orElseThrow(NullPointerException::new));
+                source.getFragmentSource().orElseThrow(NullPointerException::new),
+                TextureStage.SHADOWCOMP,
+                pipeline.getTextureMap());
         String vertex = transformed.get(PatchShaderType.VERTEX);
         String geometry = transformed.get(PatchShaderType.GEOMETRY);
         String tessControl = transformed.get(PatchShaderType.TESS_CONTROL);

src/main/java/net/coderbot/iris/uniforms/CapturedRenderingState.java

@@ -1,6 +1,7 @@
 package net.coderbot.iris.uniforms;
 
 import lombok.Getter;
+import lombok.Setter;
 import net.coderbot.iris.gl.state.ValueUpdateNotifier;
 
 import org.joml.Vector4f;
@@ -8,7 +9,8 @@ import org.joml.Vector4f;
 public class CapturedRenderingState {
 	public static final CapturedRenderingState INSTANCE = new CapturedRenderingState();
 
-	@Getter
+	@Setter
+    @Getter
     private float tickDelta;
 	@Getter
     private int currentRenderedBlockEntity;
@@ -29,10 +31,6 @@ public class CapturedRenderingState {
 	private CapturedRenderingState() {
 	}
 
-	public void setTickDelta(float tickDelta) {
-		this.tickDelta = tickDelta;
-	}
-
     public void setCurrentBlockEntity(int entity) {
 		this.currentRenderedBlockEntity = entity;
 
@@ -47,6 +45,7 @@ public class CapturedRenderingState {
 		if (this.entityIdListener != null) {
 			this.entityIdListener.run();
 		}
+        setCurrentRenderedItem(0);
 	}
 
     public void setCurrentEntityColor(float r, float g, float b, float a) {

src/main/java/net/coderbot/iris/uniforms/CommonUniforms.java

@@ -9,6 +9,7 @@ import com.gtnewhorizons.angelica.client.rendering.TextureTracker;
 import com.gtnewhorizons.angelica.mixins.interfaces.EntityRendererAccessor;
 import net.coderbot.iris.compat.dh.DHCompat;
 import net.coderbot.iris.gl.state.FogMode;
+import net.coderbot.iris.gl.state.StateUpdateNotifiers;
 import net.coderbot.iris.gl.state.ValueUpdateNotifier;
 import net.coderbot.iris.gl.uniform.DynamicUniformHolder;
 import net.coderbot.iris.gl.uniform.UniformHolder;
@@ -40,9 +41,12 @@ import static net.coderbot.iris.gl.uniform.UniformUpdateFrequency.ONCE;
 public final class CommonUniforms {
 	private static final Minecraft client = Minecraft.getMinecraft();
 	private static final Vector2i ZERO_VECTOR_2i = new Vector2i();
-	private static final Vector4i ZERO_VECTOR_4i = new Vector4i(0, 0, 0, 0);
 	private static final Vector3d ZERO_VECTOR_3d = new Vector3d();
 
+	// Scratch vectors for push-notified suppliers -- GL thread only, never escapes
+	private static final Vector2i scratch2i = new Vector2i();
+	private static final Vector4i scratch4i = new Vector4i();
+
 	private CommonUniforms() {
 		// no construction allowed
 	}
@@ -78,29 +82,29 @@ public final class CommonUniforms {
 			final AbstractTexture texture = TextureTracker.INSTANCE.getTexture(glId);
 			if (texture instanceof TextureMap) {
 				final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(glId);
-				return new Vector2i(info.getWidth(), info.getHeight());
+				return scratch2i.set(info.getWidth(), info.getHeight());
 			}
 
-			return ZERO_VECTOR_2i;
-		}, ValueUpdateNotifier.NONE);
+			return scratch2i.set(0, 0);
+		}, StateUpdateNotifiers.bindTextureNotifier);
 
 		uniforms.uniform2i("gtextureSize", () -> {
 			final int glId = GLStateManager.getBoundTextureForServerState(0);
 
 			final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(glId);
-			return new Vector2i(info.getWidth(), info.getHeight());
+			return scratch2i.set(info.getWidth(), info.getHeight());
 
-		}, ValueUpdateNotifier.NONE);
+		}, StateUpdateNotifiers.bindTextureNotifier);
 
 		uniforms.uniform4i("blendFunc", () -> {
             if(GLStateManager.getBlendMode().isEnabled()) {
                 final BlendState blend = GLStateManager.getBlendState();
-                return new Vector4i(blend.getSrcRgb(), blend.getDstRgb(), blend.getSrcAlpha(), blend.getDstAlpha());
+                return scratch4i.set(blend.getSrcRgb(), blend.getDstRgb(), blend.getSrcAlpha(), blend.getDstAlpha());
             }
-            return ZERO_VECTOR_4i;
-		}, ValueUpdateNotifier.NONE);
+            return scratch4i.set(0, 0, 0, 0);
+		}, StateUpdateNotifiers.blendFuncNotifier);
 
-		uniforms.uniform1i("renderStage", () -> GbufferPrograms.getCurrentPhase().ordinal(), ValueUpdateNotifier.NONE);
+		uniforms.uniform1i("renderStage", () -> GbufferPrograms.getCurrentPhase().ordinal(), StateUpdateNotifiers.phaseChangeNotifier);
 
         uniforms.uniform4f("entityColor", CapturedRenderingState.INSTANCE::getCurrentEntityColor, CapturedRenderingState.INSTANCE.getEntityColorNotifier());
 

src/main/java/net/coderbot/iris/uniforms/FogUniforms.java

@@ -2,6 +2,7 @@ package net.coderbot.iris.uniforms;
 
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import net.coderbot.iris.gl.state.FogMode;
+import net.coderbot.iris.gl.state.StateUpdateNotifiers;
 import net.coderbot.iris.gl.state.ValueUpdateNotifier;
 import net.coderbot.iris.gl.uniform.DynamicUniformHolder;
 import net.coderbot.iris.gl.uniform.UniformUpdateFrequency;
@@ -19,12 +20,12 @@ public class FogUniforms {
 			uniforms.uniform1i("fogMode", () -> {
 				if (!GLStateManager.getFogMode().isEnabled()) return 0;
 				return GLStateManager.getFogState().getFogMode();
-			}, ValueUpdateNotifier.NONE);
+			}, StateUpdateNotifiers.fogModeNotifier);
 			uniforms.uniform1i("fogShape", () -> 0, ValueUpdateNotifier.NONE);
 		}
 
-		uniforms.uniform1f("fogDensity", () -> GLStateManager.getFogState().getDensity(), ValueUpdateNotifier.NONE);
-		uniforms.uniform1f("fogStart", () -> GLStateManager.getFogState().getStart(), ValueUpdateNotifier.NONE);
-		uniforms.uniform1f("fogEnd", () -> GLStateManager.getFogState().getEnd(), ValueUpdateNotifier.NONE);
+		uniforms.uniform1f("fogDensity", () -> GLStateManager.getFogState().getDensity(), StateUpdateNotifiers.fogDensityNotifier);
+		uniforms.uniform1f("fogStart", () -> GLStateManager.getFogState().getStart(), StateUpdateNotifiers.fogStartNotifier);
+		uniforms.uniform1f("fogEnd", () -> GLStateManager.getFogState().getEnd(), StateUpdateNotifiers.fogEndNotifier);
 	}
 }

src/main/java/net/coderbot/iris/uniforms/ItemMaterialHelper.java

@@ -2,8 +2,6 @@ package net.coderbot.iris.uniforms;
 
 import it.unimi.dsi.fastutil.ints.Int2IntMap;
 import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
-import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
-import it.unimi.dsi.fastutil.ints.IntSet;
 import it.unimi.dsi.fastutil.objects.Object2IntFunction;
 import it.unimi.dsi.fastutil.objects.Reference2ObjectMap;
 import it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap;
@@ -22,8 +20,6 @@ import net.minecraft.util.ResourceLocation;
 public class ItemMaterialHelper {
     private static final Reference2ObjectMap<Item, Int2IntMap> MATERIAL_CACHE = new Reference2ObjectOpenHashMap<>();
     private static final int CACHE_MISS_SENTINEL = Integer.MIN_VALUE;
-    public static final IntSet WARNED_UNKNOWN_ARMOR_INDICES = new IntOpenHashSet();
-
     /**
      * Get the material ID for an ItemStack.
      * For ItemBlock: checks block.properties first, then item.properties.
@@ -114,6 +110,5 @@ public class ItemMaterialHelper {
      */
     public static void clearCache() {
         MATERIAL_CACHE.clear();
-        WARNED_UNKNOWN_ARMOR_INDICES.clear();
     }
 }

src/main/java/net/coderbot/iris/uniforms/custom/CustomUniformFixedInputUniformsHolder.java

@@ -22,12 +22,13 @@ import net.minecraft.util.Vec3;
 import org.joml.Matrix4f;
 import org.joml.Matrix4fc;
 import org.joml.Vector2f;
-import org.joml.Vector2i;
+import org.joml.Vector2ic;
 import org.joml.Vector3d;
 import org.joml.Vector3f;
 import org.joml.Vector3fc;
 import org.joml.Vector3ic;
 import org.joml.Vector4f;
+import org.joml.Vector4fc;
 
 import java.util.Collection;
 import java.util.Map;
@@ -112,7 +113,7 @@ public class CustomUniformFixedInputUniformsHolder {
 		}
 
 		@Override
-		public Builder uniform2i(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector2i> value) {
+		public Builder uniform2i(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector2ic> value) {
 			return this.put(name, new Int2VectorCachedUniform(name, updateFrequency, value));
 		}
 
@@ -132,10 +133,10 @@ public class CustomUniformFixedInputUniformsHolder {
         }
 
         @Override
-		public Builder uniformTruncated3f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4f> value) {
+		public Builder uniformTruncated3f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4fc> value) {
 			Vector3f held = new Vector3f();
 			return this.put(name, new Float3VectorCachedUniform(name, updateFrequency, () -> {
-				Vector4f vec = value.get();
+				final Vector4fc vec = value.get();
 				held.set(vec.x(), vec.y(), vec.z());
 				return held;
 			}));
@@ -152,10 +153,10 @@ public class CustomUniformFixedInputUniformsHolder {
 		}
 
 		@Override
-		public UniformHolder uniform4f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4f> value) {
+		public UniformHolder uniform4f(UniformUpdateFrequency updateFrequency, String name, Supplier<Vector4fc> value) {
 			Vector4f held = new Vector4f();
 			return this.put(name, new Float4VectorCachedUniform(name, updateFrequency, () -> {
-				Vector4f vec = value.get();
+				final Vector4fc vec = value.get();
 				held.set(vec.x(), vec.y(), vec.z(), vec.w());
 				return held;
 			}));

src/main/java/net/coderbot/iris/uniforms/custom/cached/Float4VectorCachedUniform.java

@@ -3,14 +3,23 @@ package net.coderbot.iris.uniforms.custom.cached;
 import net.coderbot.iris.gl.uniform.UniformUpdateFrequency;
 import net.coderbot.iris.parsing.VectorType;
 import org.joml.Vector4f;
+import org.joml.Vector4fc;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 
 import java.util.function.Supplier;
 
 public class Float4VectorCachedUniform extends VectorCachedUniform<Vector4f> {
 
-	public Float4VectorCachedUniform(String name, UniformUpdateFrequency updateFrequency, Supplier<Vector4f> supplier) {
-		super(name, updateFrequency, new Vector4f(), supplier);
+	public Float4VectorCachedUniform(String name, UniformUpdateFrequency updateFrequency, Supplier<Vector4fc> supplier) {
+		super(name, updateFrequency, new Vector4f(), adapt(supplier));
+	}
+
+	private static Supplier<Vector4f> adapt(Supplier<Vector4fc> supplier) {
+		final Vector4f scratch = new Vector4f();
+		return () -> {
+			final Vector4fc v = supplier.get();
+			return scratch.set(v.x(), v.y(), v.z(), v.w());
+		};
 	}
 
 	@Override

src/main/java/net/coderbot/iris/uniforms/custom/cached/Int2VectorCachedUniform.java

@@ -4,14 +4,23 @@ import kroppeb.stareval.function.FunctionReturn;
 import net.coderbot.iris.gl.uniform.UniformUpdateFrequency;
 import net.coderbot.iris.parsing.VectorType;
 import org.joml.Vector2i;
+import org.joml.Vector2ic;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 
 import java.util.function.Supplier;
 
 public class Int2VectorCachedUniform extends VectorCachedUniform<Vector2i> {
 
-	public Int2VectorCachedUniform(String name, UniformUpdateFrequency updateFrequency, Supplier<Vector2i> supplier) {
-		super(name, updateFrequency, new Vector2i(), supplier);
+	public Int2VectorCachedUniform(String name, UniformUpdateFrequency updateFrequency, Supplier<Vector2ic> supplier) {
+		super(name, updateFrequency, new Vector2i(), adapt(supplier));
+	}
+
+	private static Supplier<Vector2i> adapt(Supplier<Vector2ic> supplier) {
+		final Vector2i scratch = new Vector2i();
+		return () -> {
+			final Vector2ic v = supplier.get();
+			return scratch.set(v.x(), v.y());
+		};
 	}
 
 	@Override

src/main/java/net/coderbot/iris/uniforms/transforms/SmoothedVec2f.java

@@ -2,7 +2,7 @@ package net.coderbot.iris.uniforms.transforms;
 
 import net.coderbot.iris.uniforms.FrameUpdateNotifier;
 import org.joml.Vector2f;
-import org.joml.Vector2i;
+import org.joml.Vector2ic;
 
 import java.util.function.Supplier;
 
@@ -10,9 +10,9 @@ public class SmoothedVec2f implements Supplier<Vector2f> {
 	private final SmoothedFloat x;
 	private final SmoothedFloat y;
 
-	public SmoothedVec2f(float halfLifeUp, float halfLifeDown, Supplier<Vector2i> unsmoothed, FrameUpdateNotifier updateNotifier) {
-		x = new SmoothedFloat(halfLifeUp, halfLifeDown, () -> unsmoothed.get().x, updateNotifier);
-		y = new SmoothedFloat(halfLifeUp, halfLifeDown, () -> unsmoothed.get().y, updateNotifier);
+	public SmoothedVec2f(float halfLifeUp, float halfLifeDown, Supplier<Vector2ic> unsmoothed, FrameUpdateNotifier updateNotifier) {
+		x = new SmoothedFloat(halfLifeUp, halfLifeDown, () -> unsmoothed.get().x(), updateNotifier);
+		y = new SmoothedFloat(halfLifeUp, halfLifeDown, () -> unsmoothed.get().y(), updateNotifier);
 	}
 
 	@Override

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/bugfixes/MixinModelCreeper_AuraBodyInflate.java

@@ -0,0 +1,26 @@
+package com.gtnewhorizons.angelica.mixins.early.angelica.bugfixes;
+
+import net.minecraft.client.model.ModelCreeper;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.ModifyArg;
+
+@Mixin(ModelCreeper.class)
+public class MixinModelCreeper_AuraBodyInflate {
+
+    /**
+     * Reduce the body inflate by 2^20 ULPs so the aura body doesn't intersect the base model's head.
+     * Only applies when inflate > 0 (the aura model), leaving the base model untouched.
+     * The body addBox is the 3rd call (ordinal 2) in the constructor, and inflate is parameter index 6.
+     */
+    @ModifyArg(
+        method = "<init>(F)V", at = @At(value = "INVOKE",
+            target = "Lnet/minecraft/client/model/ModelRenderer;addBox(FFFIIIF)V", ordinal = 2), index = 6
+    )
+    private float angelica$shrinkAuraBody(float inflate) {
+        if (inflate > 0.0F) {
+            return Float.intBitsToFloat(Float.floatToIntBits(inflate) - 1048576);
+        }
+        return inflate;
+    }
+}

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/bugfixes/MixinModelWither_ArmorCentering.java

@@ -0,0 +1,81 @@
+package com.gtnewhorizons.angelica.mixins.early.angelica.bugfixes;
+
+import com.gtnewhorizons.angelica.rendering.WitherArmorState;
+import net.minecraft.client.model.ModelRenderer;
+import net.minecraft.client.model.ModelWither;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+/**
+ * Creates a centered armor model for the Wither.
+ *
+ * Vanilla 1.7.10 uses glScalef(1.1) on the base model for the armor overlay, which
+ * shifts off-center and rotating parts away from their correct positions. Modern Minecraft
+ * (1.21+) replaced this with a separate model using CubeDeformation(0.5).
+ * This mixin backports that approach.
+ */
+@Mixin(ModelWither.class)
+public class MixinModelWither_ArmorCentering {
+
+    // Contains body segments: [0] shoulder, [1] upper body + ribs, [2] tail
+    @Shadow private ModelRenderer[] field_82905_a;
+
+    // Heads: [0] center, [1] left, [2] right
+    @Shadow private ModelRenderer[] field_82904_b;
+
+    @Unique
+    private static final float ARMOR_INFLATE = 0.5F;
+
+    // Ribs armor size is reduced by 2^22 ULPs to sit just inside the base spine, preventing z-fighting.
+    @Unique
+    private static final float NO_RIBS_Z_INFLATE = Float.intBitsToFloat(Float.floatToIntBits(ARMOR_INFLATE) - 4194304);
+
+    // Side head armor is inflated by 2^22 ULPs to make the armor sit above the base shoulder, preventing z-fighting.
+    @Unique
+    private static final float NO_HEADS_Z_INFLATE = Float.intBitsToFloat(Float.floatToIntBits(ARMOR_INFLATE) + 4194304);
+
+    // If the armor inflate flag is set, rebuild all boxes with uniform inflate.
+    @Inject(method = "<init>", at = @At("TAIL"))
+    private void angelica$applyInflate(CallbackInfo ci) {
+        if (!WitherArmorState.pendingInflate) return;
+        WitherArmorState.pendingInflate = false;
+
+        ModelWither self = (ModelWither) (Object) this;
+
+        // [0] Shoulder
+        field_82905_a[0] = new ModelRenderer(self, 0, 16);
+        field_82905_a[0].addBox(-10.0F, 3.9F, -0.5F, 20, 3, 3, ARMOR_INFLATE);
+
+        // [1] Upper body (spine + ribs things)
+        field_82905_a[1] = (new ModelRenderer(self)).setTextureSize(self.textureWidth, self.textureHeight);
+        field_82905_a[1].setRotationPoint(-2.0F, 6.9F, -0.5F);
+        field_82905_a[1].setTextureOffset(0, 22).addBox(0.0F, 0.0F, 0.0F, 3, 10, 3, ARMOR_INFLATE);
+        field_82905_a[1].setTextureOffset(24, 22).addBox(-4.0F, 1.5F, 0.5F, 11, 2, 2, NO_RIBS_Z_INFLATE);
+        field_82905_a[1].setTextureOffset(24, 22).addBox(-4.0F, 4.0F, 0.5F, 11, 2, 2, NO_RIBS_Z_INFLATE);
+        field_82905_a[1].setTextureOffset(24, 22).addBox(-4.0F, 6.5F, 0.5F, 11, 2, 2, NO_RIBS_Z_INFLATE);
+
+        // [2] Tail
+        field_82905_a[2] = new ModelRenderer(self, 12, 22);
+        field_82905_a[2].addBox(0.0F, 0.0F, 0.0F, 3, 6, 3, ARMOR_INFLATE);
+
+        // [0] Center head
+        field_82904_b[0] = new ModelRenderer(self, 0, 0);
+        field_82904_b[0].addBox(-4.0F, -4.0F, -4.0F, 8, 8, 8, ARMOR_INFLATE);
+
+        // [1] Left head
+        field_82904_b[1] = new ModelRenderer(self, 32, 0);
+        field_82904_b[1].addBox(-4.0F, -4.0F, -4.0F, 6, 6, 6, NO_HEADS_Z_INFLATE);
+        field_82904_b[1].rotationPointX = -8.0F;
+        field_82904_b[1].rotationPointY = 4.0F;
+
+        // [2] Right head
+        field_82904_b[2] = new ModelRenderer(self, 32, 0);
+        field_82904_b[2].addBox(-4.0F, -4.0F, -4.0F, 6, 6, 6, NO_HEADS_Z_INFLATE);
+        field_82904_b[2].rotationPointX = 10.0F;
+        field_82904_b[2].rotationPointY = 4.0F;
+    }
+}

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/bugfixes/MixinRenderBlocks_CrossedSquaresNormal.java

@@ -0,0 +1,75 @@
+package com.gtnewhorizons.angelica.mixins.early.angelica.bugfixes;
+
+import net.minecraft.client.renderer.RenderBlocks;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.util.IIcon;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+@Mixin(RenderBlocks.class)
+public abstract class MixinRenderBlocks_CrossedSquaresNormal {
+
+    @Shadow public IIcon overrideBlockTexture;
+    @Shadow public abstract boolean hasOverrideBlockTexture();
+
+    /**
+     * Vanilla sets a single (0, -1, 0) normal for all crossed-square vertices in renderBlockAsItem.
+     * This downward-pointing normal causes shader packs to compute incorrect shadow bias (pushing the
+     * shadow sample into the parent entity's body, e.g. mooshroom and anything that extends mooshrooms)
+     * and zero diffuse sun lighting.
+     *
+     * This mixin replaces the singular normal with per-quad face normals perpendicular to each diagonal plane.
+     * This gives each face correct directional lighting and shadow bias that pushes samples away from the face rather
+     * than into the entity body.
+     */
+    @Redirect(
+        method = "renderBlockAsItem(Lnet/minecraft/block/Block;IF)V",
+        at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/RenderBlocks;drawCrossedSquares(Lnet/minecraft/util/IIcon;DDDF)V")
+    )
+    private void angelica$drawCrossedSquaresWithPerFaceNormals(RenderBlocks instance, IIcon icon, double x, double y, double z, float scale) {
+        if (this.hasOverrideBlockTexture()) {
+            icon = this.overrideBlockTexture;
+        }
+
+        final Tessellator tess = Tessellator.instance;
+        final double minU = icon.getMinU();
+        final double minV = icon.getMinV();
+        final double maxU = icon.getMaxU();
+        final double maxV = icon.getMaxV();
+
+        final double d7 = 0.45D * scale;
+        final double x0 = x + 0.5D - d7;
+        final double x1 = x + 0.5D + d7;
+        final double z0 = z + 0.5D - d7;
+        final double z1 = z + 0.5D + d7;
+        final double yTop = y + (double) scale;
+
+        final float inv_sqrt_2 = (float) (1.0 / Math.sqrt(2.0));
+
+        tess.setNormal(inv_sqrt_2, 0.0F, -inv_sqrt_2);
+        tess.addVertexWithUV(x0, yTop, z0, minU, minV);
+        tess.addVertexWithUV(x0, y,    z0, minU, maxV);
+        tess.addVertexWithUV(x1, y,    z1, maxU, maxV);
+        tess.addVertexWithUV(x1, yTop, z1, maxU, minV);
+
+        tess.setNormal(-inv_sqrt_2, 0.0F, inv_sqrt_2);
+        tess.addVertexWithUV(x1, yTop, z1, minU, minV);
+        tess.addVertexWithUV(x1, y,    z1, minU, maxV);
+        tess.addVertexWithUV(x0, y,    z0, maxU, maxV);
+        tess.addVertexWithUV(x0, yTop, z0, maxU, minV);
+
+        tess.setNormal(-inv_sqrt_2, 0.0F, -inv_sqrt_2);
+        tess.addVertexWithUV(x0, yTop, z1, minU, minV);
+        tess.addVertexWithUV(x0, y,    z1, minU, maxV);
+        tess.addVertexWithUV(x1, y,    z0, maxU, maxV);
+        tess.addVertexWithUV(x1, yTop, z0, maxU, minV);
+
+        tess.setNormal(inv_sqrt_2, 0.0F, inv_sqrt_2);
+        tess.addVertexWithUV(x1, yTop, z0, minU, minV);
+        tess.addVertexWithUV(x1, y,    z0, minU, maxV);
+        tess.addVertexWithUV(x0, y,    z1, maxU, maxV);
+        tess.addVertexWithUV(x0, yTop, z1, maxU, minV);
+    }
+}

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/bugfixes/MixinRenderCreeper_AuraDepth.java

@@ -0,0 +1,43 @@
+package com.gtnewhorizons.angelica.mixins.early.angelica.bugfixes;
+
+import com.gtnewhorizons.angelica.rendering.DeferredEntityOverlay;
+import net.minecraft.client.renderer.entity.RenderCreeper;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.entity.monster.EntityCreeper;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(RenderCreeper.class)
+public abstract class MixinRenderCreeper_AuraDepth {
+
+    @Shadow
+    protected abstract int shouldRenderPass(EntityCreeper entity, int pass, float partialTick);
+
+    @Unique
+    private DeferredEntityOverlay.ShouldRenderPassFn angelica$cachedPassFn;
+
+    /**
+     * Mark that a charged creeper aura pass is about to execute. The method runs normally
+     * so any mixins added by mods within shouldRenderPass still fire. The flag is consumed by the
+     * WrapOperation on renderPassModel.render() in doRender, which defers the actual render.
+     * See MixinRendererLivingEntity_DeferredEntityOverlay
+     */
+    @Inject(method = "shouldRenderPass(Lnet/minecraft/entity/monster/EntityCreeper;IF)I",
+        at = @At("HEAD"))
+    private void angelica$markOverlayPass(EntityCreeper creeper, int pass, float partialTick, CallbackInfoReturnable<Integer> cir) {
+        if (pass == 1 && creeper.getPowered() && !DeferredEntityOverlay.isReplaying()) {
+            if (angelica$cachedPassFn == null) {
+                angelica$cachedPassFn = (entity, pass2, tick) -> this.shouldRenderPass((EntityCreeper) entity, pass2, tick);
+            }
+            DeferredEntityOverlay.markOverlayPass(
+                angelica$cachedPassFn,
+                (RendererLivingEntity) (Object) this,
+                creeper, partialTick
+            );
+        }
+    }
+}

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/bugfixes/MixinRenderGlobal_DeferredEntityOverlay.java

@@ -0,0 +1,30 @@
+package com.gtnewhorizons.angelica.mixins.early.angelica.bugfixes;
+
+import com.gtnewhorizons.angelica.rendering.DeferredEntityOverlay;
+import net.minecraft.client.renderer.RenderGlobal;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(RenderGlobal.class)
+public class MixinRenderGlobal_DeferredEntityOverlay {
+
+    /**
+     * Clear stale deferred entries before collecting new ones.
+     */
+    @Inject(method = "renderEntities", at = @At("HEAD"))
+    private void angelica$clearStaleDeferredOverlays(CallbackInfo ci) {
+        DeferredEntityOverlay.clear();
+    }
+
+    /**
+     * Render deferred entity overlays after all entities have been drawn,
+     * so additive-blended overlays composite correctly without depth issues.
+     */
+    @Inject(method = "renderEntities", at = @At(value = "INVOKE",
+        target = "Lnet/minecraft/client/renderer/RenderHelper;enableStandardItemLighting()V"))
+    private void angelica$renderDeferredOverlays(CallbackInfo ci) {
+        DeferredEntityOverlay.renderAll();
+    }
+}

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/bugfixes/MixinRenderWither_ArmorCentering.java

@@ -0,0 +1,85 @@
+package com.gtnewhorizons.angelica.mixins.early.angelica.bugfixes;
+
+import com.gtnewhorizons.angelica.rendering.DeferredEntityOverlay;
+import com.gtnewhorizons.angelica.rendering.WitherArmorState;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelWither;
+import net.minecraft.client.renderer.entity.RenderWither;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.entity.boss.EntityWither;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.Redirect;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+/**
+ * Replaces the Wither's glScalef(1.1) armor approach with a per-box inflated model.
+ * This fixes the armor being visually off-center on off-center and rotating parts.
+ * Not exactly mod friendly but we can figure that out later.
+ */
+@Mixin(RenderWither.class)
+public abstract class MixinRenderWither_ArmorCentering {
+
+    @Shadow
+    protected abstract int shouldRenderPass(EntityWither entity, int pass, float partialTick);
+
+    @Unique
+    private ModelWither angelica$armorModel;
+
+    @Unique
+    private DeferredEntityOverlay.ShouldRenderPassFn angelica$cachedPassFn;
+
+    @Inject(method = "<init>", at = @At("TAIL"))
+    private void angelica$createArmorModel(CallbackInfo ci) {
+        WitherArmorState.pendingInflate = true;
+        angelica$armorModel = new ModelWither();
+    }
+
+    // Use the inflated armor model instead of mainModel.
+    @Redirect(
+        method = "shouldRenderPass(Lnet/minecraft/entity/boss/EntityWither;IF)I",
+        at = @At(value = "INVOKE",
+            target = "Lnet/minecraft/client/renderer/entity/RenderWither;setRenderPassModel(Lnet/minecraft/client/model/ModelBase;)V")
+    )
+    private void angelica$useInflatedModel(RenderWither instance, ModelBase model) {
+        ((RenderWither) (Object) this).setRenderPassModel(angelica$armorModel);
+    }
+
+    // No-op the model offset translate (ordinal 1)
+    @Redirect(
+        method = "shouldRenderPass(Lnet/minecraft/entity/boss/EntityWither;IF)I",
+        at = @At(value = "INVOKE",
+            target = "Lorg/lwjgl/opengl/GL11;glTranslatef(FFF)V", ordinal = 1, remap = false)
+    )
+    private void angelica$skipTranslate(float x, float y, float z) {
+    }
+
+    // No-op glScalef
+    @Redirect(
+        method = "shouldRenderPass(Lnet/minecraft/entity/boss/EntityWither;IF)I",
+        at = @At(value = "INVOKE",
+            target = "Lorg/lwjgl/opengl/GL11;glScalef(FFF)V", remap = false)
+    )
+    private void angelica$skipScale(float x, float y, float z) {
+    }
+
+    // Mark the Wither's armor pass for deferred rendering.
+    @Inject(method = "shouldRenderPass(Lnet/minecraft/entity/boss/EntityWither;IF)I",
+        at = @At("HEAD"))
+    private void angelica$markArmorPass(EntityWither wither, int pass, float partialTick, CallbackInfoReturnable<Integer> cir) {
+        if (pass == 1 && wither.isArmored() && !DeferredEntityOverlay.isReplaying()) {
+            if (angelica$cachedPassFn == null) {
+                angelica$cachedPassFn = (entity, pass2, tick) -> this.shouldRenderPass((EntityWither) entity, pass2, tick);
+            }
+            DeferredEntityOverlay.markOverlayPass(
+                angelica$cachedPassFn,
+                (RendererLivingEntity) (Object) this,
+                wither, partialTick
+            );
+        }
+    }
+}

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/bugfixes/MixinRendererLivingEntity_DeferredEntityOverlay.java

@@ -0,0 +1,50 @@
+package com.gtnewhorizons.angelica.mixins.early.angelica.bugfixes;
+
+import com.gtnewhorizons.angelica.rendering.DeferredEntityOverlay;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.entity.Entity;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(value = RendererLivingEntity.class, priority = 1200)
+public class MixinRendererLivingEntity_DeferredEntityOverlay {
+
+    /**
+     * Intercepts the first renderPassModel.render() call in the shouldRenderPass loop.
+     * When an entity overlay pass is active, captures the animation params and modelview
+     * matrix for deferred rendering, skipping the immediate render.
+     */
+    @WrapOperation(
+        method = "doRender(Lnet/minecraft/entity/EntityLivingBase;DDDFF)V", at = @At(value = "INVOKE",
+            target = "Lnet/minecraft/client/model/ModelBase;render(Lnet/minecraft/entity/Entity;FFFFFF)V", ordinal = 0)
+    )
+    private void angelica$maybeDeferOverlay(ModelBase model, Entity entity,
+            float limbSwing, float limbSwingAmount, float ageInTicks,
+            float headYaw, float headPitch, float scale,
+            Operation<Void> original) {
+        if (DeferredEntityOverlay.isOverlayPassActive()) {
+            DeferredEntityOverlay.deferRender(limbSwing, limbSwingAmount, ageInTicks, headYaw, headPitch, scale);
+        } else {
+            original.call(model, entity, limbSwing, limbSwingAmount, ageInTicks, headYaw, headPitch, scale);
+        }
+    }
+
+    /**
+     * Clear a stale overlayPassActive flag after the shouldRenderPass loop.
+     * Handles the case where markOverlayPass fired but shouldRenderPass returned <= 0,
+     * so renderPassModel.render() was never called and deferRender never consumed the flag.
+     */
+    @Inject(
+        method = "doRender(Lnet/minecraft/entity/EntityLivingBase;DDDFF)V",
+        at = @At(value = "INVOKE",
+            target = "Lnet/minecraft/client/renderer/entity/RendererLivingEntity;renderEquippedItems(Lnet/minecraft/entity/EntityLivingBase;F)V")
+    )
+    private void angelica$clearStaleOverlayFlag(CallbackInfo ci) {
+        DeferredEntityOverlay.clearStaleOverlayFlag();
+    }
+}

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/rendering/MixinRenderBlocks.java

@@ -123,7 +123,7 @@ public abstract class MixinRenderBlocks {
     @ModifyExpressionValue(method = "renderStandardBlockWithColorMultiplier",
         at = @At(value = "FIELD", target = "Lnet/minecraft/init/Blocks;grass:Lnet/minecraft/block/BlockGrass;", opcode = Opcodes.GETSTATIC))
     private BlockGrass angelica$widenGrassCheck(BlockGrass grassBlock, @Local(argsOnly = true, ordinal = 0) Block block) {
-        return (block instanceof BlockGrass bg) ? bg : grassBlock;
+        return (block instanceof BlockGrass bg && block == ClientProxy.bopGrass) ? bg : grassBlock;
     }
 
     /* Disable diffuse when celeritas AO is in use */

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/AccessorEntityHorse.java

@@ -0,0 +1,13 @@
+package com.gtnewhorizons.angelica.mixins.early.shaders;
+
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.item.ItemStack;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+@Mixin(EntityHorse.class)
+public interface AccessorEntityHorse {
+
+    @Invoker("getHorseArmorIndex")
+    int invokeGetHorseArmorIndex(ItemStack stack);
+}

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinRenderHorse.java

@@ -1,84 +1,136 @@
 package com.gtnewhorizons.angelica.mixins.early.shaders;
 
+import com.gtnewhorizons.angelica.rendering.ModelHorseArmor;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.coderbot.iris.uniforms.CapturedRenderingState;
 import net.coderbot.iris.uniforms.ItemIdManager;
 import net.coderbot.iris.uniforms.ItemMaterialHelper;
+import net.minecraft.client.Minecraft;
 import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.model.ModelRenderer;
 import net.minecraft.client.renderer.entity.RenderHorse;
 import net.minecraft.entity.passive.EntityHorse;
-import net.minecraft.init.Items;
 import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Unique;
 import org.spongepowered.asm.mixin.injection.At;
 
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+
+import java.util.HashMap;
+import java.util.Map;
+
 /**
- * Mixin to set the currentRenderedItem ID when rendering horse armor.
- * This allows shaders to identify and apply different materials to horse armor.
+ * Mixin to set the currentRenderedItem ID on the armor portion of horse rendering.
  */
 @Mixin(RenderHorse.class)
 public abstract class MixinRenderHorse {
+    @Unique
     private static final Logger LOGGER = LogManager.getLogger("Angelica");
 
+    @Unique
+    private static final float ARMOR_INFLATE = 0.125F;
+
+    @Unique
+    private static ModelHorseArmor angelica$armorModel;
+
     /**
-     * Set the item ID when rendering the horse model if it has armor.
-     * Wraps the mainModel.render() call to set the material ID only around the actual render.
+     * Reverse mapping from armor index to Item, built lazily by scanning the item registry
+     * for items recognized by EntityHorse.func_146085_a (isHorseArmor) and invoking
+     * EntityHorse.getHorseArmorIndex to determine their index.
+     * Automatically picks up modded armor that hooks into the vanilla's system. (I hope)
+     */
+    @Unique
+    private static Int2ObjectOpenHashMap<Item> angelica$armorIndexToItem;
+
+    @Unique
+    private static final Map<String, ResourceLocation> angelica$armorTextureCache = new HashMap<>();
+
+    /**
+     * Two-pass rendering with a separate inflated armor model:
+     * Pass 1: Render the base horse with the composite texture, no item ID.
+     * Pass 2: Render the inflated armor model with the armor-only texture and item ID set.
+     *         The inflate makes armor geometry sit above the base.
+     *         Alpha test discards transparent (non-armor) pixels.
      */
     @WrapOperation(
         method = "renderModel(Lnet/minecraft/entity/passive/EntityHorse;FFFFFF)V",
         at = @At(value = "INVOKE", target = "Lnet/minecraft/client/model/ModelBase;render(Lnet/minecraft/entity/Entity;FFFFFF)V")
     )
     private void iris$setHorseArmorItemId(ModelBase model, net.minecraft.entity.Entity entity, float p1, float p2, float p3, float p4, float p5, float p6, Operation<Void> original, EntityHorse horse) {
-        // Only set ID if horse has armor equipped
-        boolean hasArmor = false;
-
-        // Check if horse type == 0 (regular horse)
-        if (horse.func_110259_cr()) {
-            // Get armor index from DataWatcher (synced from server)
-            int armorIndex = horse.func_110241_cb();
-
-            if (armorIndex > 0) {
-                // Map armor index to vanilla items
-                Item armorItem = null;
-                switch (armorIndex) {
-                    case 1:
-                        armorItem = Items.iron_horse_armor;
-                        break;
-                    case 2:
-                        armorItem = Items.golden_horse_armor;
-                        break;
-                    case 3:
-                        armorItem = Items.diamond_horse_armor;
-                        break;
-                    default:
-                        // Unknown armor index - likely from a mod
-                        // Warn once per unique index to avoid spam
-                        if (!ItemMaterialHelper.WARNED_UNKNOWN_ARMOR_INDICES.contains(armorIndex)) {
-                            ItemMaterialHelper.WARNED_UNKNOWN_ARMOR_INDICES.add(armorIndex);
-                            LOGGER.warn("Unknown horse armor index detected: {}. " +
-                                "This is likely from a mod. Vanilla horse armor uses indices 1-3 (iron/gold/diamond). " +
-                                "Modded horse armor material IDs are not currently supported.", armorIndex);
-                        }
-                        break;
-                }
-
-                if (armorItem != null) {
-                    int id = ItemMaterialHelper.getMaterialId(armorItem, 0);
-                    CapturedRenderingState.INSTANCE.setCurrentRenderedItem(id);
-                    hasArmor = true;
-                }
-            }
-        }
-
-        // Call original render
+        // Pass 1: Render the base horse normally
         original.call(model, entity, p1, p2, p3, p4, p5, p6);
 
-        // Reset only if we set it
-        if (hasArmor) {
-            ItemIdManager.resetItemId();
+        if (!horse.func_110259_cr()) return;
+
+        int armorIndex = horse.func_110241_cb();
+        if (armorIndex <= 0) return;
+
+        String armorTexturePath = horse.getVariantTexturePaths()[2];
+        if (armorTexturePath == null) return;
+
+        // Pass 2: Render inflated armor model with item ID
+        if (angelica$armorModel == null) {
+            angelica$armorModel = new ModelHorseArmor(ARMOR_INFLATE);
+        }
+
+        Item armorItem = angelica$getArmorItem(horse, armorIndex);
+        if (armorItem != null) {
+            int id = ItemMaterialHelper.getMaterialId(armorItem, 0);
+            CapturedRenderingState.INSTANCE.setCurrentRenderedItem(id);
+        }
+
+        // Copy animation state from the base model to the armor model
+        angelica$copyRotations(model, angelica$armorModel);
+
+        ResourceLocation armorTexture = angelica$armorTextureCache.computeIfAbsent(armorTexturePath, ResourceLocation::new);
+        Minecraft.getMinecraft().getTextureManager().bindTexture(armorTexture);
+
+        angelica$armorModel.render(horse, p1, p2, p3, p4, p5, p6);
+
+        ItemIdManager.resetItemId();
+    }
+
+    // Copy rotation angles and positions from one model's renderers to another's
+    @Unique
+    private static void angelica$copyRotations(ModelBase from, ModelBase to) {
+        for (int i = 0; i < from.boxList.size() && i < to.boxList.size(); i++) {
+            ModelRenderer src = from.boxList.get(i);
+            ModelRenderer dst = to.boxList.get(i);
+            dst.rotateAngleX = src.rotateAngleX;
+            dst.rotateAngleY = src.rotateAngleY;
+            dst.rotateAngleZ = src.rotateAngleZ;
+            dst.rotationPointX = src.rotationPointX;
+            dst.rotationPointY = src.rotationPointY;
+            dst.rotationPointZ = src.rotationPointZ;
         }
     }
+
+    /**
+     * Look up the item for a given armor index. On first call, builds a reverse mapping
+     * by scanning the item registry for items that pass EntityHorse.func_146085_a (isHorseArmor)
+     * and invoking the getHorseArmorIndex to determine their index.
+     */
+    @Unique
+    private static Item angelica$getArmorItem(EntityHorse horse, int armorIndex) {
+        if (angelica$armorIndexToItem == null) {
+            angelica$armorIndexToItem = new Int2ObjectOpenHashMap<>();
+            AccessorEntityHorse accessor = (AccessorEntityHorse) horse;
+            for (Object obj : Item.itemRegistry) {
+                Item item = (Item) obj;
+                if (!EntityHorse.func_146085_a(item)) continue;
+                int idx = accessor.invokeGetHorseArmorIndex(new ItemStack(item));
+                if (idx > 0) {
+                    angelica$armorIndexToItem.put(idx, item);
+                }
+            }
+            LOGGER.debug("Built horse armor index map: {} entries", angelica$armorIndexToItem.size());
+        }
+        return angelica$armorIndexToItem.get(armorIndex);
+    }
 }

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinRenderItem.java

@@ -30,17 +30,6 @@ public class MixinRenderItem {
         ItemIdManager.setItemId(itemStack);
     }
 
-    /**
-     * Reset the item ID after rendering dropped items.
-     */
-    @Inject(
-        method = "doRender(Lnet/minecraft/entity/item/EntityItem;DDDFF)V",
-        at = @At("RETURN")
-    )
-    private void iris$resetItemIdAfterRender(EntityItem entity, double x, double y, double z, float entityYaw, float partialTicks, CallbackInfo ci) {
-        ItemIdManager.resetItemId();
-    }
-
     /**
      * Activate GLINT shader before rendering enchantment glint on dropped items.
      */

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinRenderManager.java

@@ -4,7 +4,6 @@ import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.coderbot.iris.uniforms.CapturedRenderingState;
 import net.coderbot.iris.uniforms.EntityIdHelper;
-import net.coderbot.iris.uniforms.ItemIdManager;
 import net.minecraft.client.renderer.entity.Render;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.entity.Entity;
@@ -26,7 +25,6 @@ public class MixinRenderManager {
     private void iris$wrapDoRender(Render render, Entity entity, double x, double y, double z, float entityYaw, float partialTicks, Operation<Void> original) {
         int entityId = EntityIdHelper.getEntityId(entity);
         CapturedRenderingState.INSTANCE.setCurrentEntity(entityId);
-        ItemIdManager.resetItemId();
         original.call(render, entity, x, y, z, entityYaw, partialTicks);
         CapturedRenderingState.INSTANCE.setCurrentEntity(-1);
     }

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinRenderManagerDAPI.java

@@ -4,7 +4,6 @@ import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.coderbot.iris.uniforms.CapturedRenderingState;
 import net.coderbot.iris.uniforms.EntityIdHelper;
-import net.coderbot.iris.uniforms.ItemIdManager;
 import net.minecraft.client.renderer.entity.Render;
 import net.minecraft.client.renderer.entity.RenderManager;
 import net.minecraft.entity.Entity;
@@ -24,7 +23,6 @@ public class MixinRenderManagerDAPI {
     private void iris$wrapDoRenderDragonAPI(Render render, Entity entity, double x, double y, double z, float entityYaw, float partialTicks, Operation<Void> original) {
         int entityId = EntityIdHelper.getEntityId(entity);
         CapturedRenderingState.INSTANCE.setCurrentEntity(entityId);
-        ItemIdManager.resetItemId();
         original.call(render, entity, x, y, z, entityYaw, partialTicks);
         CapturedRenderingState.INSTANCE.setCurrentEntity(-1);
     }

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/shaders/MixinRendererLivingEntity.java

@@ -22,13 +22,13 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 @Mixin(RendererLivingEntity.class)
 public class MixinRendererLivingEntity {
     /**
-     * Reset currentRenderedItemId at the start of rendering each living entity.
+     * Reset ID before damage overlay renders, otherwise you get random shiny zombies
      */
     @Inject(
         method = "doRender(Lnet/minecraft/entity/EntityLivingBase;DDDFF)V",
-        at = @At("HEAD")
+        at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/entity/RendererLivingEntity;renderEquippedItems(Lnet/minecraft/entity/EntityLivingBase;F)V", shift = At.Shift.AFTER)
     )
-    private void iris$resetItemIdAtStart(EntityLivingBase entity, double x, double y, double z, float entityYaw, float partialTicks, CallbackInfo ci) {
+    private void iris$resetItemIdAfterEquipped(EntityLivingBase entity, double x, double y, double z, float entityYaw, float partialTicks, CallbackInfo ci) {
         ItemIdManager.resetItemId();
     }
 
@@ -79,7 +79,6 @@ public class MixinRendererLivingEntity {
         remap = false
     )
     private void iris$glintStart(CallbackInfo ci) {
-        ItemIdManager.resetItemId();
         GbufferPrograms.setupSpecialRenderCondition(SpecialCondition.GLINT);
     }
 

src/test/java/com/gtnewhorizons/angelica/api/GLRedirectsTest.java

@@ -0,0 +1,181 @@
+package com.gtnewhorizons.angelica.api;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class GLRedirectsTest {
+
+    @ParameterizedTest(name = "{0}.{1} -> {2}")
+    @CsvSource({
+        "GL11, glPushMatrix, glPushMatrix",
+        "GL11, glPopMatrix, glPopMatrix",
+        "GL11, glTranslatef, glTranslatef",
+        "GL11, glRotatef, glRotatef",
+        "GL11, glScalef, glScalef",
+        "GL11, glEnable, glEnable",
+        "GL11, glDisable, glDisable",
+        "GL11, glBegin, glBegin",
+        "GL11, glEnd, glEnd",
+        "GL11, glVertex3f, glVertex3f",
+        "GL11, glColor4f, glColor4f",
+        "GL11, glNormal3f, glNormal3f",
+        "GL11, glTexCoord2f, glTexCoord2f",
+        "GL11, glBindTexture, glBindTexture",
+        "GL11, glBlendFunc, glBlendFunc",
+        "GL11, glDepthMask, glDepthMask",
+        "GL11, glDepthFunc, glDepthFunc",
+        "GL11, glAlphaFunc, glAlphaFunc",
+        "GL11, glMatrixMode, glMatrixMode",
+        "GL11, glLoadIdentity, glLoadIdentity",
+        "GL11, glShadeModel, glShadeModel",
+        "GL11, glDrawArrays, glDrawArrays",
+        "GL11, glDrawElements, glDrawElements",
+        "GL11, glNewList, glNewList",
+        "GL11, glEndList, glEndList",
+        "GL11, glCallList, glCallList",
+        "GL11, glViewport, glViewport",
+        "GL12, glTexImage3D, glTexImage3D",
+        "GL13, glActiveTexture, glActiveTexture",
+        "GL13, glMultiTexCoord2f, glMultiTexCoord2f",
+        "GL14, glBlendFuncSeparate, tryBlendFuncSeparate",
+        "GL14, glBlendColor, glBlendColor",
+        "GL15, glGenBuffers, glGenBuffers",
+        "GL15, glBindBuffer, glBindBuffer",
+        "GL15, glBufferData, glBufferData",
+        "GL15, glDeleteBuffers, glDeleteBuffers",
+        "GL20, glUseProgram, glUseProgram",
+        "GL20, glCreateShader, glCreateShader",
+        "GL20, glShaderSource, glShaderSource",
+        "GL20, glLinkProgram, glLinkProgram",
+        "GL20, glUniform1f, glUniform1f",
+        "GL20, glUniform4f, glUniform4f",
+        "GL20, glGetUniformLocation, glGetUniformLocation",
+        "GL20, glVertexAttribPointer, glVertexAttribPointer",
+        "GL30, glGenFramebuffers, glGenFramebuffers",
+        "GL30, glBindFramebuffer, glBindFramebuffer",
+        "GL30, glGenVertexArrays, glGenVertexArrays",
+        "GL30, glBindVertexArray, glBindVertexArray",
+        "GL30, glGenerateMipmap, glGenerateMipmap",
+        "GL31, glDrawElementsInstanced, glDrawElementsInstanced",
+        "GL33, glGenSamplers, glGenSamplers",
+        "GL33, glBindSampler, glBindSampler",
+        "GL42, glTexStorage2D, glTexStorage2D",
+        "GL43, glDispatchCompute, glDispatchCompute",
+        "GL44, glBufferStorage, glBufferStorage",
+    })
+    void glVersionClassMethodRedirects(String className, String method, String expected) {
+        assertEquals(expected, GLRedirects.getTargetMethodName(className + "." + method));
+    }
+
+    @ParameterizedTest(name = "{0}.{1} -> {2}")
+    @CsvSource({
+        "GL11C, glDrawArrays, glDrawArrays",
+        "GL20C, glUseProgram, glUseProgram",
+        "GL30C, glBindFramebuffer, glBindFramebuffer",
+        "GL33C, glBindSampler, glBindSampler",
+    })
+    void cVariantsUseGLPrefixMap(String className, String method, String expected) {
+        assertEquals(expected, GLRedirects.getTargetMethodName(className + "." + method));
+    }
+
+    @ParameterizedTest(name = "{0}.{1} -> {2}")
+    @CsvSource({
+        "EXTBlendFuncSeparate, glBlendFuncSeparateEXT, tryBlendFuncSeparate",
+        "ARBMultitexture, glActiveTextureARB, glActiveTextureARB",
+        "ARBShaderObjects, glUseProgramObjectARB, glUseProgram",
+        "ARBShaderObjects, glCreateShaderObjectARB, glCreateShader",
+        "ARBShaderObjects, glCompileShaderARB, glCompileShader",
+        "ARBShaderObjects, glAttachObjectARB, glAttachShader",
+        "ARBShaderObjects, glUniform1fARB, glUniform1f",
+        "ARBShaderObjects, glUniformMatrix4ARB, glUniformMatrix4",
+        "ARBShaderObjects, glGetUniformLocationARB, glGetUniformLocation",
+        "ARBVertexArrayObject, glBindVertexArray, glBindVertexArray",
+        "ARBInstancedArrays, glVertexAttribDivisorARB, glVertexAttribDivisorARB",
+        "APPLEVertexArrayObject, glBindVertexArrayAPPLE, glBindVertexArray",
+        "UniversalVAO, bindVertexArray, glBindVertexArray",
+        "UniversalVAO, deleteVertexArrays, glDeleteVertexArrays",
+        "OpenGlHelper, glBlendFunc, tryBlendFuncSeparate",
+        "OpenGlHelper, setActiveTexture, setActiveTexture",
+        "OpenGlHelper, setLightmapTextureCoords, setLightmapTextureCoords",
+        "OpenGlHelper, isFramebufferEnabled, isFramebufferEnabled",
+        "GLU, gluPerspective, gluPerspective",
+        "GLU, gluLookAt, gluLookAt",
+        "GLU, gluOrtho2D, gluOrtho2D",
+        "Project, gluPerspective, gluPerspective",
+        "Project, gluPickMatrix, gluPickMatrix",
+    })
+    void namedClassMethodRedirects(String className, String method, String expected) {
+        assertEquals(expected, GLRedirects.getTargetMethodName(className + "." + method));
+    }
+
+    @ParameterizedTest(name = "{0} -> null")
+    @CsvSource({
+        "GL11.GL_TEXTURE_2D",
+        "GL11.GL_BLEND",
+        "GL20.GL_FRAGMENT_SHADER",
+        "Foo.bar",
+        "String.valueOf",
+        "ARBShaderObjects.GL_OBJECT_COMPILE_STATUS_ARB",
+    })
+    void nonRedirectedReturnsNull(String classAndMethod) {
+        assertNull(GLRedirects.getTargetMethodName(classAndMethod));
+    }
+
+    @Test
+    void nullDotReturnsNull() {
+        assertNull(GLRedirects.getTargetMethodName("noDotHere"));
+    }
+
+    @ParameterizedTest(name = "pattern matches {0}")
+    @CsvSource({
+        "GL11.glPushMatrix",
+        "GL20C.glUseProgram",
+        "GL44.glBufferStorage",
+        "ARBShaderObjects.glUseProgramObjectARB",
+        "OpenGlHelper.setActiveTexture",
+        "GLU.gluPerspective",
+        "UniversalVAO.bindVertexArray",
+    })
+    void patternMatchesRedirectedClasses(String input) {
+        assertTrue(GLRedirects.getMethodRedirectPattern().matcher(input).find(),
+            "Pattern should match: " + input);
+    }
+
+    @ParameterizedTest(name = "pattern does not match {0}")
+    @CsvSource({
+        "String.valueOf",
+        "Math.abs",
+        "Tessellator.instance",
+        "System.currentTimeMillis",
+    })
+    void patternDoesNotMatchUnrelatedClasses(String input) {
+        assertFalse(GLRedirects.getMethodRedirectPattern().matcher(input).find(),
+            "Pattern should not match: " + input);
+    }
+
+    @Test
+    void endToEndScriptTransformation() {
+        String script = "GL11.glPushMatrix();\nGL11.glTranslatef(1,2,3);\nGL11.glEnable(GL11.GL_BLEND);";
+
+        String result = GLRedirects.getMethodRedirectPattern().matcher(script).replaceAll(mr -> {
+            String target = GLRedirects.getTargetMethodName(mr.group(0));
+            return target != null ? "GLStateManager." + target : mr.group(0);
+        });
+
+        assertTrue(result.contains("GLStateManager.glPushMatrix()"), "glPushMatrix not redirected: " + result);
+        assertTrue(result.contains("GLStateManager.glTranslatef(1,2,3)"), "glTranslatef not redirected: " + result);
+        assertTrue(result.contains("GLStateManager.glEnable(GL11.GL_BLEND)"), "glEnable not redirected or GL_BLEND mangled: " + result);
+    }
+
+    @Test
+    void patternIsNotNull() {
+        assertNotNull(GLRedirects.getMethodRedirectPattern());
+    }
+}