Make shader based clouds work with iris shaderpacks, and port optimizations from #1685 (#1793)

* Make shader based clouds work with iris shaderpacks, and port optimizations from #1685

Co-Authored-By: Eclipse-Sol <[email protected]>

* Yeet GL_QUADS

* Optimize a little more

---------

Co-authored-by: Eclipse-Sol <[email protected]>
Co-authored-by: Logan Phillips <[email protected]>

README.MD

@@ -50,6 +50,7 @@ Targets GL 3.3+ core profile
 * CodeChicken[Core](https://github.com/GTNewHorizons/CodeChickenCore/releases)/[Lib](https://github.com/GTNewHorizons/CodeChickenLib/releases) <1.2.0 - Threading issues, use 1.3.0+
 * Neodymium - Untested, but unlikely to be compatible. (Chunk Meshing is definitely incompatible, other features might work depending on config)
 * SmoothFont - Equivalent functionality added
+* ClientFixer - Use a resource pack like [GTNH-FTI-Standard-Font](https://github.com/Eldrinn-Elantey/GTNH-FTI-Standard-Font)
 
 # Credits
 * ShadersMod

build.gradle.kts

@@ -1,9 +1,14 @@
+import xyz.wagyourtail.jvmdg.gradle.flags.DowngradeFlags
+import xyz.wagyourtail.jvmdg.gradle.task.DowngradeJar
 import xyz.wagyourtail.jvmdg.gradle.task.files.DowngradeFiles
 
 plugins {
     id("com.gtnewhorizons.gtnhconvention")
 }
 
+tasks.withType<DowngradeJar>().configureEach { logLevel.set("FATAL") }
+tasks.withType<DowngradeFiles>().configureEach { logLevel.set("FATAL") }
+
 minecraft {
     extraRunJvmArguments.add("-Dangelica.enableTestBlocks=true")
     extraRunJvmArguments.add("-Dangelica.dumpClass=true")

glsm/build.gradle.kts

@@ -124,6 +124,7 @@ tasks.withType<DowngradeFiles>().configureEach {
     downgradeTo.set(JavaVersion.VERSION_1_8)
     multiReleaseOriginal.set(false)
     multiReleaseVersions.set(emptySet())
+    logLevel.set("FATAL")
 }
 
 val downgradeDepsForTest by tasks.registering(DowngradeFiles::class) {
@@ -139,6 +140,7 @@ val downgradeMainClasses by tasks.registering(DowngradeFiles::class) {
 val downgradeTestClasses by tasks.registering(DowngradeFiles::class) {
     inputCollection = sourceSets["test"].output.classesDirs
     classpath = sourceSets["test"].compileClasspath
+    sourceSets["test"].output.classesDirs.files.forEach { outputs.dir(temporaryDir.resolve(it.name)) }
     dependsOn(tasks.named("testClasses"))
 }
 
@@ -174,6 +176,19 @@ tasks.test {
     jvmArgs("-Djava.library.path=${extractNatives.get().property("destinationFolder").let { (it as DirectoryProperty).asFile.get().path }}")
 }
 
+val verifyTestsRan by tasks.registering {
+    val resultsDir = layout.buildDirectory.dir("test-results/test")
+    dependsOn(tasks.test)
+    doLast {
+        val dir = resultsDir.get().asFile
+        val xmls = dir.listFiles { f -> f.name.startsWith("TEST-") && f.name.endsWith(".xml") } ?: emptyArray()
+        check(xmls.isNotEmpty()) {
+            ":glsm:test produced no TEST-*.xml in $dir - test task likely went NO-SOURCE"
+        }
+    }
+}
+tasks.check { dependsOn(verifyTestsRan) }
+
 publishing {
     publications {
         create<MavenPublication>("mavenJava") {

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

@@ -11,6 +11,7 @@ import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
 import org.joml.Matrix3f;
 import org.joml.Matrix4f;
+import org.joml.Vector3f;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;
 
@@ -112,6 +113,7 @@ public class CompatUniformManager {
     private static final FloatBuffer clipPlaneBuf = BufferUtils.createFloatBuffer(32); // 8 planes * vec4
     private static final Matrix3f normalMatrix = new Matrix3f();
     private static final Matrix4f scratchMatrix = new Matrix4f();
+    private static final Vector3f scratchCol = new Vector3f();
 
     private static final float LIGHTMAP_SCALE = 1.0f / 256.0f;
     private static final FloatBuffer lightmapMatrixBuf;
@@ -132,6 +134,16 @@ public class CompatUniformManager {
 
     private CompatUniformManager() {}
 
+    /**
+     * Normalize each column of a 3x3 matrix in place. Used to strip the residual 1/scale that
+     * inverse-transpose introduces.
+     */
+    private static void normalizeColumnsInPlace(Matrix3f m) {
+        m.setColumn(0, m.getColumn(0, scratchCol).normalize());
+        m.setColumn(1, m.getColumn(1, scratchCol).normalize());
+        m.setColumn(2, m.getColumn(2, scratchCol).normalize());
+    }
+
     public static void onLinkProgram(int program) {
         int[] locs = new int[LOC_COUNT];
         boolean hasAny = false;
@@ -222,13 +234,17 @@ public class CompatUniformManager {
             // Normal Matrix (inverse-transpose of upper-left 3x3 of ModelView)
             if (locs[LOC_NORMAL] != -1 || locs[LOC_IRIS_NORMAL] != -1) {
                 mv.normal(normalMatrix);
-                normalMatrix.get(mat3Buf);
                 if (locs[LOC_NORMAL] != -1) {
+                    normalMatrix.get(mat3Buf);
                     RENDER_BACKEND.uniformMatrix3(locs[LOC_NORMAL], false, mat3Buf);
                 }
+                // Column-normalized to unit magnitude
                 if (locs[LOC_IRIS_NORMAL] != -1) {
+                    normalizeColumnsInPlace(normalMatrix);
+                    normalMatrix.get(mat3Buf);
                     RENDER_BACKEND.uniformMatrix3(locs[LOC_IRIS_NORMAL], false, mat3Buf);
                 }
+
             }
         }
 

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

@@ -142,7 +142,7 @@ public class FeedbackManager {
         final int byteCount = count * stride;
         ensureReadbackCapacity(byteCount);
         readbackBuf.clear().limit(byteCount);
-        RENDER_BACKEND.getBufferSubData(GL15.GL_ARRAY_BUFFER, (long) first * stride + posOffset, readbackBuf);
+        readPositionBuffer((long) first * stride + posOffset, readbackBuf);
 
         emitAllPrimitives(mode, count, i -> i, stride);
     }
@@ -170,7 +170,7 @@ public class FeedbackManager {
         final int byteCount = vertexCount * stride;
         ensureReadbackCapacity(byteCount);
         readbackBuf.clear().limit(byteCount);
-        RENDER_BACKEND.getBufferSubData(GL15.GL_ARRAY_BUFFER, (long) minIdx * stride + posOffset, readbackBuf);
+        readPositionBuffer((long) minIdx * stride + posOffset, readbackBuf);
 
         final int base = minIdx;
         emitAllPrimitives(mode, indexCount, i -> ImmediateModeRecorder.readIndex(indexBuf, type, 0, i) - base, stride);
@@ -251,7 +251,23 @@ public class FeedbackManager {
         final int byteCount = vertexCount * stride;
         ensureReadbackCapacity(byteCount);
         readbackBuf.clear().limit(byteCount);
-        RENDER_BACKEND.getBufferSubData(GL15.GL_ARRAY_BUFFER, (long) minIdx * stride + posOffset, readbackBuf);
+        readPositionBuffer((long) minIdx * stride + posOffset, readbackBuf);
+    }
+
+    private static void readPositionBuffer(long offset, ByteBuffer destination) {
+        final int positionVbo = VertexAttribState.get(0).vboId;
+        final int previousVbo = GLStateManager.getBoundVBO();
+
+        if (positionVbo != 0 && positionVbo != previousVbo) {
+            GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, positionVbo);
+        }
+        try {
+            RENDER_BACKEND.getBufferSubData(GL15.GL_ARRAY_BUFFER, offset, destination);
+        } finally {
+            if (positionVbo != 0 && positionVbo != previousVbo) {
+                GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, previousVbo);
+            }
+        }
     }
 
     private static void emitVertex(int vertexIndex, int stride) {

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

@@ -148,22 +148,54 @@ public class GLStateManager {
     public static int projGeneration;  // projection matrix changes
     public static int texMatrixGeneration; // texture matrix changes
     public static int lightingGeneration;
-    public static int fragmentGeneration; // fog + alpha ref
+    public static int fragmentGeneration; // fog + alpha ref + overlay color
     public static int colorGeneration;    // current vertex color
     public static int clipPlaneGeneration; // clip plane equation changes
 
+    @Getter private static float overlayR = 0.0f;
+    @Getter private static float overlayG = 0.0f;
+    @Getter private static float overlayB = 0.0f;
+    @Getter private static float overlayA = 0.0f;
+
+    public static void setOverlayColor(float r, float g, float b, float a) {
+        if (r == overlayR && g == overlayG && b == overlayB && a == overlayA) return;
+        overlayR = r; overlayG = g; overlayB = b; overlayA = a;
+        fragmentGeneration++;
+    }
+
+    @Getter private static float shaderColorR = 1.0f;
+    @Getter private static float shaderColorG = 1.0f;
+    @Getter private static float shaderColorB = 1.0f;
+    @Getter private static float shaderColorA = 1.0f;
+
+    public static void setShaderColor(float r, float g, float b, float a) {
+        if (r == shaderColorR && g == shaderColorG && b == shaderColorB && a == shaderColorA) return;
+        shaderColorR = r; shaderColorG = g; shaderColorB = b; shaderColorA = a;
+        if (GLSMHooks.SHADER_COLOR_CHANGE.hasListeners()) {
+            GLSMHooks.shaderColorChangeEvent.red = r;
+            GLSMHooks.shaderColorChangeEvent.green = g;
+            GLSMHooks.shaderColorChangeEvent.blue = b;
+            GLSMHooks.shaderColorChangeEvent.alpha = a;
+            GLSMHooks.SHADER_COLOR_CHANGE.post(GLSMHooks.shaderColorChangeEvent);
+        }
+    }
+
     // Deferred vertex attribute upload flags — set when state changes, flushed before draw
-    private static boolean dirtyColorAttrib;
+    private static boolean dirtyColorAttrib = true;
     private static boolean dirtyNormalAttrib;
     private static boolean dirtyTexCoordAttrib;
-    private static boolean dirtyLightmapAttrib;
+    private static boolean dirtyLightmapAttrib = true;
 
     /** Flush deferred vertex attribute uploads. Called before draw to ensure default attrib values are current. */
     public static void flushDeferredVertexAttribs() {
-        RENDER_BACKEND.vertexAttrib4f(Usage.COLOR.getAttributeLocation(), color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha());
-        dirtyColorAttrib = false;
-        RENDER_BACKEND.vertexAttrib4f(Usage.SECONDARY_UV.getAttributeLocation(), GLSMConfig.lastBrightnessX, GLSMConfig.lastBrightnessY, 0.0f, 1.0f);
-        dirtyLightmapAttrib = false;
+        if (dirtyColorAttrib) {
+            RENDER_BACKEND.vertexAttrib4f(Usage.COLOR.getAttributeLocation(), color.getRed(), color.getGreen(), color.getBlue(), color.getAlpha());
+            dirtyColorAttrib = false;
+        }
+        if (dirtyLightmapAttrib) {
+            RENDER_BACKEND.vertexAttrib4f(Usage.SECONDARY_UV.getAttributeLocation(), GLSMConfig.lastBrightnessX, GLSMConfig.lastBrightnessY, 0.0f, 1.0f);
+            dirtyLightmapAttrib = false;
+        }
         if (dirtyNormalAttrib) {
             final var n = ShaderManager.getCurrentNormal();
             RENDER_BACKEND.vertexAttrib3f(Usage.NORMAL.getAttributeLocation(), n.x, n.y, n.z);
@@ -3865,7 +3897,12 @@ public class GLStateManager {
         return switch (pname) {
             case GL11.GL_TEXTURE_WIDTH -> info.getWidth();
             case GL11.GL_TEXTURE_HEIGHT -> info.getHeight();
-            case GL11.GL_TEXTURE_INTERNAL_FORMAT -> info.getInternalFormat();
+            case GL11.GL_TEXTURE_INTERNAL_FORMAT -> {
+                if (info.needsInternalFormatResolve() && isRecordingDisplayList()) {
+                    throw new IllegalStateException(String.format("glGetTexLevelParameteri(GL_TEXTURE_INTERNAL_FORMAT) needs to resolve a generic compressed format for texture %d during display list recording", getBoundTextureForServerState()));
+                }
+                yield info.getResolvedInternalFormat();
+            }
             default -> {
                 if (isRecordingDisplayList()) {
                     throw new IllegalStateException(String.format(
@@ -5147,8 +5184,12 @@ public class GLStateManager {
                 return;
             }
             setLightmapTextureCoords(target, s, t);
+        } else {
+            final int unit = target - GL13.GL_TEXTURE0;
+            if (unit >= 2 && unit < 4) {
+                ShaderManager.setCurrentTexCoord(unit, s, t, 0.0f, 1.0f);
+            }
         }
-        // Units 2+ silently ignored — shader uses v_TexCoord0 for all non-lightmap units
     }
 
     public static void glMultiTexCoord2d(int target, double s, double t) {

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

@@ -12,7 +12,7 @@ import org.lwjgl.opengl.GL13;
  * Packed-long fragment shader permutation key for FFP emulation.
  *
  * Layout:
- *   long[0]: global bits (10) + unit 0 (47 bits at offset 10)
+ *   long[0]: global bits (11) + unit 0 (47 bits at offset 11)
  *   long[1..3]: unit 1..3 (47 bits each, low-aligned)
  * Only max(1, nrEnabledUnits) longs are significant.
  *
@@ -63,12 +63,13 @@ public final class FragmentKey {
     public static final int FOG_EXP    = 2;
     public static final int FOG_EXP2   = 3;
 
-    private static final int GLOBAL_BITS = 10;
+    private static final int GLOBAL_BITS = 11;
     private static final int BIT_FOG_MODE          = 0;  // 2 bits
     private static final int BIT_ALPHA_TEST        = 2;  // 1 bit
     private static final int BIT_ALPHA_FUNC        = 3;  // 3 bits
     private static final int BIT_SEPARATE_SPECULAR = 6;  // 1 bit
     private static final int BIT_NR_ENABLED_UNITS  = 7;  // 3 bits
+    private static final int BIT_OVERLAY_ENABLED   = 10; // 1 bit
 
     private static final int U_ENABLED         = 0;
     private static final int U_MODE            = 1;   // 3 bits
@@ -119,6 +120,11 @@ public final class FragmentKey {
             global |= ((long) (encodeAlphaFunc(GLStateManager.getAlphaState().getFunction()) & 0x7)) << BIT_ALPHA_FUNC;
         }
 
+        // Damage overlay
+        if (GLStateManager.getOverlayA() != 0.0f) {
+            global |= (1L << BIT_OVERLAY_ENABLED);
+        }
+
         // Separate specular
         if (GLStateManager.getLightingState().isEnabled()
             && GLStateManager.getLightModel().colorControl == GL12.GL_SEPARATE_SPECULAR_COLOR) {
@@ -227,6 +233,7 @@ public final class FragmentKey {
     public int alphaTestFunc()        { return (int) ((packed[0] >> BIT_ALPHA_FUNC) & 0x7); }
     public boolean separateSpecular() { return ((packed[0] >> BIT_SEPARATE_SPECULAR) & 1) != 0; }
     public int nrEnabledUnits()       { return (int) ((packed[0] >> BIT_NR_ENABLED_UNITS) & 0x7); }
+    public boolean overlayEnabled()   { return ((packed[0] >> BIT_OVERLAY_ENABLED) & 1) != 0; }
 
     private long unitBits(int i) {
         return (i == 0) ? (packed[0] >>> GLOBAL_BITS) : packed[i];
@@ -252,6 +259,28 @@ public final class FragmentKey {
         return false;
     }
 
+    /** Per-unit enable bits as a 4-bit mask (bit i = unit i enabled). */
+    public int enabledUnitMask() {
+        int mask = 0;
+        final int n = Math.min(nrEnabledUnits(), MAX_UNITS);
+        for (int i = 0; i < n; i++) {
+            if (unitEnabled(i)) mask |= (1 << i);
+        }
+        return mask;
+    }
+
+    /** Per-unit enable bits from a packed scratch as a 4-bit mask (bit i = unit i enabled). */
+    public static int unitMaskFromPacked(long[] packed, int len) {
+        int mask = 0;
+        if (len < 1) return 0;
+        if (((packed[0] >>> GLOBAL_BITS) & 1L) != 0) mask |= 1;
+        final int n = Math.min(len, MAX_UNITS);
+        for (int i = 1; i < n; i++) {
+            if ((packed[i] & 1L) != 0) mask |= (1 << i);
+        }
+        return mask;
+    }
+
     public boolean lightmapEnabled() {
         return nrEnabledUnits() > 1 && unitEnabled(1);
     }
@@ -338,10 +367,10 @@ public final class FragmentKey {
             default -> "?";
         };
         final StringBuilder sb = new StringBuilder();
-        sb.append(String.format("FFPFragmentKey[fog=%s alpha=%b(%s) specSep=%b units=%d",
+        sb.append(String.format("FFPFragmentKey[fog=%s alpha=%b(%s) specSep=%b overlay=%b units=%d",
             fogName, alphaTestEnabled(),
             alphaTestEnabled() ? String.format("0x%04X", decodeAlphaFunc(alphaTestFunc())) : "-",
-            separateSpecular(), nrEnabledUnits()));
+            separateSpecular(), overlayEnabled(), nrEnabledUnits()));
         for (int i = 0; i < nrEnabledUnits(); i++) {
             if (!unitEnabled(i)) {
                 sb.append(String.format(" u%d=OFF", i));

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

@@ -37,11 +37,11 @@ public final class FragmentShaderGenerator {
         if (key.separateSpecular()) {
             sb.append("in vec3 v_SpecularColor;\n");
         }
-        if (key.textureEnabled()) {
-            sb.append("in vec4 v_TexCoord0;\n");
-        }
-        if (key.lightmapEnabled()) {
-            sb.append("in vec4 v_TexCoord1;\n");
+        // Per-unit texcoord inputs. Each enabled unit sources from its own varying
+        for (int i = 0; i < key.nrEnabledUnits(); i++) {
+            if (key.unitEnabled(i)) {
+                sb.append("in vec4 v_TexCoord").append(i).append(";\n");
+            }
         }
         if (key.fogMode() != FragmentKey.FOG_NONE) {
             sb.append("in float v_FogCoord;\n");
@@ -65,6 +65,9 @@ public final class FragmentShaderGenerator {
                 sb.append("uniform vec4 u_TexEnvColor").append(i).append(";\n");
             }
         }
+        if (key.overlayEnabled()) {
+            sb.append("uniform vec4 u_OverlayColor;\n");
+        }
         if (key.fogMode() != FragmentKey.FOG_NONE) {
             sb.append("uniform vec4 u_FogParams;\n");
             sb.append("uniform vec4 u_FogColor;\n");
@@ -75,11 +78,7 @@ public final class FragmentShaderGenerator {
     private static void emitTextureSampling(StringBuilder sb, FragmentKey key) {
         for (int i = 0; i < key.nrEnabledUnits(); i++) {
             if (!key.unitEnabled(i)) continue;
-            // Unit 1 is the lightmap — uses v_TexCoord1.
-            // Units 2-3 intentionally share unit 0's texture coordinates since
-            // the vertex shader only provides 2 tex coord varyings (unit 0 and unit 1/lightmap).
-            final String texCoord = (i == 1) ? "v_TexCoord1.st" : "v_TexCoord0.st";
-            sb.append("  vec4 tex").append(i).append("Color = texture(u_Sampler").append(i).append(", ").append(texCoord).append(");\n");
+            sb.append("  vec4 tex").append(i).append("Color = texture(u_Sampler").append(i).append(", v_TexCoord").append(i).append(".st);\n");
         }
     }
 
@@ -87,14 +86,21 @@ public final class FragmentShaderGenerator {
         if (!key.textureEnabled()) {
             sb.append("  // No texture -- vertex color only\n");
             sb.append("  vec4 color = v_Color;\n");
+            emitOverlay(sb, key);
             return;
         }
 
-        // Process units in order; "previous" starts as vertex color
+        // Process units in order; "previous" starts as vertex color.
         boolean firstUnit = true;
+        boolean overlayInjected = false;
         for (int i = 0; i < key.nrEnabledUnits(); i++) {
             if (!key.unitEnabled(i)) continue;
 
+            if (!firstUnit && !overlayInjected) {
+                emitOverlay(sb, key);
+                overlayInjected = true;
+            }
+
             final String texVar = "tex" + i + "Color";
             final String envColorVar = "u_TexEnvColor" + i;
             final String prevVar = firstUnit ? "v_Color" : "color";
@@ -107,6 +113,16 @@ public final class FragmentShaderGenerator {
             }
             firstUnit = false;
         }
+
+        if (!overlayInjected) emitOverlay(sb, key);
+    }
+
+    /**
+     * Emit the modern-style damage overlay mix.
+     */
+    private static void emitOverlay(StringBuilder sb, FragmentKey key) {
+        if (!key.overlayEnabled()) return;
+        sb.append("  color.rgb = mix(color.rgb, u_OverlayColor.rgb, u_OverlayColor.a);\n");
     }
 
     private static void emitSimpleUnit(StringBuilder sb, FragmentKey key, int unit, String texVar, String envColorVar, String prevVar, String assign) {

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

@@ -22,12 +22,10 @@ public final class GeometryShaderGenerator {
         if (key.separateSpecular()) {
             sb.append("in vec3 v_SpecularColor_gs[];\n");
         }
-        if (key.textureEnabled() || key.hasVertexTexCoord() || key.texGenEnabled()) {
-            sb.append("in vec4 v_TexCoord0_gs[];\n");
-        }
-        if (key.lightmapEnabled()) {
-            sb.append("in vec4 v_TexCoord1_gs[];\n");
-        }
+        if (key.unitTexCoordEnabled(0) || key.texGenEnabled()) sb.append("in vec4 v_TexCoord0_gs[];\n");
+        if (key.lightmapEnabled())            sb.append("in vec4 v_TexCoord1_gs[];\n");
+        if (key.unitTexCoordEnabled(2))       sb.append("in vec4 v_TexCoord2_gs[];\n");
+        if (key.unitTexCoordEnabled(3))       sb.append("in vec4 v_TexCoord3_gs[];\n");
         if (key.fogEnabled()) {
             sb.append("in float v_FogCoord_gs[];\n");
         }
@@ -37,12 +35,10 @@ public final class GeometryShaderGenerator {
         if (key.separateSpecular()) {
             sb.append("out vec3 v_SpecularColor;\n");
         }
-        if (key.textureEnabled() || key.hasVertexTexCoord() || key.texGenEnabled()) {
-            sb.append("out vec4 v_TexCoord0;\n");
-        }
-        if (key.lightmapEnabled()) {
-            sb.append("out vec4 v_TexCoord1;\n");
-        }
+        if (key.unitTexCoordEnabled(0) || key.texGenEnabled()) sb.append("out vec4 v_TexCoord0;\n");
+        if (key.lightmapEnabled())            sb.append("out vec4 v_TexCoord1;\n");
+        if (key.unitTexCoordEnabled(2))       sb.append("out vec4 v_TexCoord2;\n");
+        if (key.unitTexCoordEnabled(3))       sb.append("out vec4 v_TexCoord3;\n");
         if (key.fogEnabled()) {
             sb.append("out float v_FogCoord;\n");
         }
@@ -82,12 +78,10 @@ public final class GeometryShaderGenerator {
         if (key.separateSpecular()) {
             sb.append("    v_SpecularColor = v_SpecularColor_gs").append(idx).append(";\n");
         }
-        if (key.textureEnabled() || key.hasVertexTexCoord() || key.texGenEnabled()) {
-            sb.append("    v_TexCoord0 = v_TexCoord0_gs").append(idx).append(";\n");
-        }
-        if (key.lightmapEnabled()) {
-            sb.append("    v_TexCoord1 = v_TexCoord1_gs").append(idx).append(";\n");
-        }
+        if (key.unitTexCoordEnabled(0) || key.texGenEnabled()) sb.append("    v_TexCoord0 = v_TexCoord0_gs").append(idx).append(";\n");
+        if (key.lightmapEnabled())            sb.append("    v_TexCoord1 = v_TexCoord1_gs").append(idx).append(";\n");
+        if (key.unitTexCoordEnabled(2))       sb.append("    v_TexCoord2 = v_TexCoord2_gs").append(idx).append(";\n");
+        if (key.unitTexCoordEnabled(3))       sb.append("    v_TexCoord3 = v_TexCoord3_gs").append(idx).append(";\n");
         if (key.fogEnabled()) {
             sb.append("    v_FogCoord = v_FogCoord_gs").append(idx).append(";\n");
         }

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

@@ -32,12 +32,12 @@ public class Program {
     public int locProjectionMatrix = -1;
     public int locMVPMatrix = -1;
     public int locNormalMatrix = -1;
-    public int locTextureMatrix0 = -1;
+    public final int[] locTextureMatrix = { -1, -1, -1, -1 };
 
     // Current state defaults
     public int locCurrentNormal = -1;
     public int locCurrentColor = -1;
-    public int locCurrentTexCoord = -1;
+    public final int[] locCurrentTexCoord = { -1, -1, -1, -1 };
     public int locCurrentLightmapCoord = -1;
     public int locLightmapTextureMatrix = -1;
 
@@ -92,6 +92,7 @@ public class Program {
     public final int[] locSampler = { -1, -1, -1, -1 };
     public int locAlphaRef = -1;
     public final int[] locTexEnvColor = { -1, -1, -1, -1 };
+    public int locOverlayColor = -1;
     public int locFogParams = -1;
     public int locFogColor = -1;
 
@@ -107,11 +108,13 @@ public class Program {
         locProjectionMatrix = loc("u_ProjectionMatrix");
         locMVPMatrix = loc("u_MVPMatrix");
         locNormalMatrix = loc("u_NormalMatrix");
-        locTextureMatrix0 = loc("u_TextureMatrix0");
+        for (int i = 0; i < 4; i++) {
+            locTextureMatrix[i] = loc("u_TextureMatrix" + i);
+            locCurrentTexCoord[i] = loc("u_CurrentTexCoord" + i);
+        }
 
         locCurrentNormal = loc("u_CurrentNormal");
         locCurrentColor = loc("u_CurrentColor");
-        locCurrentTexCoord = loc("u_CurrentTexCoord");
         locCurrentLightmapCoord = loc("u_CurrentLightmapCoord");
         locLightmapTextureMatrix = loc("u_LightmapTextureMatrix");
 
@@ -169,6 +172,7 @@ public class Program {
         for (int i = 0; i < 4; i++) {
             locTexEnvColor[i] = loc("u_TexEnvColor" + i);
         }
+        locOverlayColor = loc("u_OverlayColor");
         locFogParams = loc("u_FogParams");
         locFogColor = loc("u_FogColor");
     }

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

@@ -42,11 +42,19 @@ public class ShaderManager {
     private int currentFKLen = 0;
 
     @Getter private static final Vector3f currentNormal = new Vector3f(0.0f, 0.0f, 1.0f);
-    @Getter private static final Vector4f currentTexCoord = new Vector4f(0.0f, 0.0f, 0.0f, 1.0f);
+    private static final Vector4f[] currentTexCoords = {
+        new Vector4f(0.0f, 0.0f, 0.0f, 1.0f),
+        new Vector4f(0.0f, 0.0f, 0.0f, 1.0f),
+        new Vector4f(0.0f, 0.0f, 0.0f, 1.0f),
+        new Vector4f(0.0f, 0.0f, 0.0f, 1.0f),
+    };
     @Getter private static final Vec3fStack normalStack = new Vec3fStack(currentNormal);
-    @Getter private static final Vec4fStack texCoordStack = new Vec4fStack(currentTexCoord);
+    @Getter private static final Vec4fStack texCoordStack = new Vec4fStack(currentTexCoords[0]);
     @Getter private static int normalGeneration;
     @Getter private static int texCoordGeneration;
+
+    public static Vector4f getCurrentTexCoord() { return currentTexCoords[0]; }
+    public static Vector4f getCurrentTexCoord(int unit) { return currentTexCoords[unit]; }
     @Getter private boolean enabled = false;
     private int currentVertexFlags = VertexFlags.TEXTURE_BIT | VertexFlags.COLOR_BIT | VertexFlags.NORMAL_BIT;
 
@@ -108,8 +116,9 @@ public class ShaderManager {
             }
         }
 
-        final long vkPacked = VertexKey.packFromState(hasColor, hasNormal, hasTexCoord, hasLightmap);
         final int fkLen = FragmentKey.packFromState(currentFKScratch);
+        final int fragMask = FragmentKey.unitMaskFromPacked(currentFKScratch, fkLen);
+        final long vkPacked = VertexKey.packFromState(hasColor, hasNormal, hasTexCoord, hasLightmap, fragMask);
 
         if (vkPacked != currentVertexKeyPacked || !Arrays.equals(currentFKScratch, 0, fkLen, currentFKPacked, 0, currentFKLen)) {
             commitVariant(vkPacked, fkLen);
@@ -133,8 +142,9 @@ public class ShaderManager {
     }
 
     private void updateVariant(boolean hasColor, boolean hasNormal, boolean hasTexCoord, boolean hasLightmap) {
-        final long vkPacked = VertexKey.packFromState(hasColor, hasNormal, hasTexCoord, hasLightmap);
         final int fkLen = FragmentKey.packFromState(currentFKScratch);
+        final int fragMask = FragmentKey.unitMaskFromPacked(currentFKScratch, fkLen);
+        final long vkPacked = VertexKey.packFromState(hasColor, hasNormal, hasTexCoord, hasLightmap, fragMask);
         commitVariant(vkPacked, fkLen);
     }
 
@@ -158,7 +168,12 @@ public class ShaderManager {
     }
 
     public static void setCurrentTexCoord(float s, float t, float r, float q) {
-        currentTexCoord.set(s, t, r, q);
+        currentTexCoords[0].set(s, t, r, q);
+        texCoordGeneration++;
+    }
+
+    public static void setCurrentTexCoord(int unit, float s, float t, float r, float q) {
+        currentTexCoords[unit].set(s, t, r, q);
         texCoordGeneration++;
     }
 

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

@@ -111,10 +111,10 @@ public class Uniforms {
             }
         }
 
-        if (!program.getVertexKey().hasVertexTexCoord() && program.getVertexKey().textureEnabled()) {
+        if (program.getVertexKey().anyUnitTexCoordEnabled()) {
             final int texGen = ShaderManager.getTexCoordGeneration();
             if (programChanged || texGen != lastTexCoordGen) {
-                uploadCurrentTexCoord(program);
+                uploadCurrentTexCoords(program);
                 lastTexCoordGen = texGen;
             }
         }
@@ -198,16 +198,15 @@ public class Uniforms {
             RENDER_BACKEND.uniformMatrix4(program.locMVPMatrix, false, mat4Buf);
         }
 
-        // Texture matrices
+        // Texture matrices (per-unit).
         if (texMatChanged) {
-            // Texture matrix unit 0
-            if (program.locTextureMatrix0 != -1) {
-                final Matrix4f texMat = GLStateManager.getTextures().getTextureUnitMatrix(0);
-                texMat.get(mat4Buf);
-                RENDER_BACKEND.uniformMatrix4(program.locTextureMatrix0, false, mat4Buf);
+            for (int i = 0; i < 4; i++) {
+                if (program.locTextureMatrix[i] != -1) {
+                    final Matrix4f texMat = GLStateManager.getTextures().getTextureUnitMatrix(i);
+                    texMat.get(mat4Buf);
+                    RENDER_BACKEND.uniformMatrix4(program.locTextureMatrix[i], false, mat4Buf);
+                }
             }
-
-            // Texture matrix unit 1 (lightmap)
             if (program.locLightmapTextureMatrix != -1) {
                 final Matrix4f lmTexMat = GLStateManager.getTextures().getTextureUnitMatrix(1);
                 lmTexMat.get(mat4Buf);
@@ -324,10 +323,12 @@ public class Uniforms {
         RENDER_BACKEND.uniform4(program.locCurrentColor, vec4Buf);
     }
 
-    private void uploadCurrentTexCoord(Program program) {
-        if (program.locCurrentTexCoord == -1) return;
-        final var tc = ShaderManager.getCurrentTexCoord();
-        uploadVec4(program.locCurrentTexCoord, tc);
+    private void uploadCurrentTexCoords(Program program) {
+        for (int i = 0; i < 4; i++) {
+            if (program.locCurrentTexCoord[i] != -1) {
+                uploadVec4(program.locCurrentTexCoord[i], ShaderManager.getCurrentTexCoord(i));
+            }
+        }
     }
 
     private void uploadCurrentLightmapCoord(Program program) {
@@ -421,6 +422,16 @@ public class Uniforms {
             }
         }
 
+        if (fk.overlayEnabled() && program.locOverlayColor != -1) {
+            vec4Buf.clear();
+            vec4Buf.put(GLStateManager.getOverlayR());
+            vec4Buf.put(GLStateManager.getOverlayG());
+            vec4Buf.put(GLStateManager.getOverlayB());
+            vec4Buf.put(GLStateManager.getOverlayA());
+            vec4Buf.flip();
+            RENDER_BACKEND.uniform4(program.locOverlayColor, vec4Buf);
+        }
+
         // Fog
         if (fk.fogMode() != FragmentKey.FOG_NONE) {
             uploadFog(program);

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

@@ -4,6 +4,7 @@ import com.gtnewhorizon.gtnhlib.client.renderer.MatrixHelper;
 import com.gtnewhorizons.angelica.glsm.DisplayListManager;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.states.TexGenState;
+import com.gtnewhorizons.angelica.glsm.states.TextureUnitArray;
 import org.joml.Matrix4f;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;
@@ -11,9 +12,14 @@ import org.lwjgl.opengl.GL12;
 /**
  * Compact key capturing the vertex shader permutation axes for FFP emulation.
  * Packed into a single long for fast hash/compare.
+ *
+ * Per-unit fields are 4-bit base-indexed: bit (BASE + i) for unit i in [0..3].
+ * Unit 1 is the lightmap; texcoord enable for unit 1 also gates the lightmap-specific code paths.
  */
 public final class VertexKey {
 
+    public static final int MAX_UNITS = 4;
+
     private final long packed;
 
     private static final int BIT_LIGHTING            = 0;
@@ -24,26 +30,25 @@ public final class VertexKey {
     private static final int BIT_COLOR_MATERIAL      = 5;
     private static final int BIT_SEPARATE_SPECULAR   = 6;
     private static final int BIT_FOG                 = 7;
-    private static final int BIT_FOG_DIST_MODE       = 8;
+    private static final int BIT_FOG_DIST_MODE       = 8;  // 2 bits: 8-9
     private static final int BIT_NORMALIZE           = 10;
     private static final int BIT_RESCALE_NORMAL      = 11;
-    private static final int BIT_TEXTURE             = 12;
-    private static final int BIT_LIGHTMAP            = 13;
-    private static final int BIT_TEX_MATRIX          = 14;
-    private static final int BIT_HAS_VERTEX_COLOR    = 15;
-    private static final int BIT_HAS_VERTEX_NORMAL   = 16;
-    private static final int BIT_HAS_VERTEX_TEX      = 17;
-    private static final int BIT_HAS_VERTEX_LIGHTMAP = 18;
-    private static final int BIT_COLOR_MAT_MODE      = 19;
-    // bits 19-21: colorMaterialMode (3 bits)
-    // TexGen modes: 3 bits each (0=NONE, 1=OBJ_LINEAR, 2=EYE_LINEAR)
-    private static final int BIT_TEXGEN_S            = 22;
-    private static final int BIT_TEXGEN_T            = 25;
-    private static final int BIT_TEXGEN_R            = 28;
-    private static final int BIT_TEXGEN_Q            = 31;
-    // bits 31-33: texGenModeQ (3 bits)
-    private static final int BIT_CLIP_PLANES         = 34;
-    private static final int BIT_WIDE_LINE           = 35;
+    // Per-unit texcoord enable: bits 12-15 (unit 0..3). Unit 1 doubles as the lightmap flag.
+    private static final int BIT_UNIT_TEX_BASE       = 12;
+    private static final int BIT_HAS_VERTEX_COLOR    = 16;
+    private static final int BIT_HAS_VERTEX_NORMAL   = 17;
+    private static final int BIT_HAS_VERTEX_TEX      = 18;
+    private static final int BIT_HAS_VERTEX_LIGHTMAP = 19;
+    private static final int BIT_COLOR_MAT_MODE      = 20;  // 3 bits: 20-22
+    // TexGen modes (unit 0 only, for now): 3 bits each (0=NONE, 1=OBJ_LINEAR, 2=EYE_LINEAR).
+    private static final int BIT_TEXGEN_S            = 23;  // 3 bits: 23-25
+    private static final int BIT_TEXGEN_T            = 26;  // 3 bits: 26-28
+    private static final int BIT_TEXGEN_R            = 29;  // 3 bits: 29-31
+    private static final int BIT_TEXGEN_Q            = 32;  // 3 bits: 32-34
+    private static final int BIT_CLIP_PLANES         = 35;
+    private static final int BIT_WIDE_LINE           = 36;
+    // Per-unit texmat enable: bits 37-40 (unit 0..3). Unit 1 is the lightmap matrix.
+    private static final int BIT_UNIT_TEXMAT_BASE    = 37;
 
     public static final int TG_NONE                  = 0;
     public static final int TG_OBJ_LINEAR            = 1;
@@ -72,9 +77,10 @@ public final class VertexKey {
     public int fogDistanceMode()           { return (int)((packed >> BIT_FOG_DIST_MODE) & 0x3); }
     public boolean normalizeEnabled()      { return bit(BIT_NORMALIZE); }
     public boolean rescaleNormalsEnabled() { return bit(BIT_RESCALE_NORMAL); }
-    public boolean textureEnabled()        { return bit(BIT_TEXTURE); }
-    public boolean lightmapEnabled()       { return bit(BIT_LIGHTMAP); }
-    public boolean textureMatrixEnabled()  { return bit(BIT_TEX_MATRIX); }
+    public boolean unitTexCoordEnabled(int unit) { return bit(BIT_UNIT_TEX_BASE + unit); }
+    public boolean unitTexMatEnabled(int unit)   { return bit(BIT_UNIT_TEXMAT_BASE + unit); }
+    public boolean anyUnitTexCoordEnabled() { return ((packed >> BIT_UNIT_TEX_BASE) & 0xF) != 0; }
+    public boolean lightmapEnabled()       { return unitTexCoordEnabled(1); }
     public boolean hasVertexColor()        { return bit(BIT_HAS_VERTEX_COLOR); }
     public boolean hasVertexNormal()       { return bit(BIT_HAS_VERTEX_NORMAL); }
     public boolean hasVertexTexCoord()     { return bit(BIT_HAS_VERTEX_TEX); }
@@ -82,28 +88,18 @@ public final class VertexKey {
     /** Color material mode (CM_AMBIENT, CM_DIFFUSE, CM_SPECULAR, CM_EMISSION, CM_AMBIENT_AND_DIFFUSE). Only meaningful when colorMaterialEnabled(). */
     public int colorMaterialMode()        { return (int)((packed >> BIT_COLOR_MAT_MODE) & 0x7); }
 
-    /** TexGen mode for S coordinate (TG_NONE, TG_OBJ_LINEAR, TG_EYE_LINEAR). */
+    /** TexGen mode for S coordinate (TG_NONE, TG_OBJ_LINEAR, TG_EYE_LINEAR). Unit 0 only; see TODO in packFromState. */
     public int texGenModeS()              { return (int)((packed >> BIT_TEXGEN_S) & 0x7); }
-    /** TexGen mode for T coordinate. */
     public int texGenModeT()              { return (int)((packed >> BIT_TEXGEN_T) & 0x7); }
-    /** TexGen mode for R coordinate. */
     public int texGenModeR()              { return (int)((packed >> BIT_TEXGEN_R) & 0x7); }
-    /** TexGen mode for Q coordinate. */
     public int texGenModeQ()              { return (int)((packed >> BIT_TEXGEN_Q) & 0x7); }
-    /** Whether any texgen coordinate is enabled. */
     public boolean texGenEnabled()        { return texGenModeS() != TG_NONE || texGenModeT() != TG_NONE || texGenModeR() != TG_NONE || texGenModeQ() != TG_NONE; }
-    /** Whether any clip plane is enabled. */
     public boolean clipPlanesEnabled()    { return bit(BIT_CLIP_PLANES); }
-    /** Whether wide line GS emulation is active for this variant. */
     public boolean wideLineEmulation()   { return bit(BIT_WIDE_LINE); }
 
-    /** Whether vertex color replaces material ambient in this variant. */
     public boolean cmReplacesAmbient()    { final int m = colorMaterialMode(); return m == CM_AMBIENT || m == CM_AMBIENT_AND_DIFFUSE; }
-    /** Whether vertex color replaces material diffuse in this variant. */
     public boolean cmReplacesDiffuse()    { final int m = colorMaterialMode(); return m == CM_DIFFUSE || m == CM_AMBIENT_AND_DIFFUSE; }
-    /** Whether vertex color replaces material specular in this variant. */
     public boolean cmReplacesSpecular()   { return colorMaterialMode() == CM_SPECULAR; }
-    /** Whether vertex color replaces material emission in this variant. */
     public boolean cmReplacesEmission()   { return colorMaterialMode() == CM_EMISSION; }
 
     private boolean bit(int pos) { return ((packed >> pos) & 1) != 0; }
@@ -127,7 +123,7 @@ public final class VertexKey {
         };
     }
 
-    public static long packFromState(boolean hasColor, boolean hasNormal, boolean hasTexCoord, boolean hasLightmap) {
+    public static long packFromState(boolean hasColor, boolean hasNormal, boolean hasTexCoord, boolean hasLightmap, int fragUnitMask) {
         long bits = 0;
 
         final boolean lighting = GLStateManager.getLightingState().isEnabled();
@@ -172,23 +168,18 @@ public final class VertexKey {
             bits |= (1L << BIT_RESCALE_NORMAL);
         }
 
-        // Texture unit 0 (base texture)
-        if (GLStateManager.getTextures().getTextureUnitStates(0).isEnabled()) {
-            bits |= (1L << BIT_TEXTURE);
-        }
-        // Texture unit 1 (lightmap)
-        if (GLStateManager.getTextures().getTextureUnitStates(1).isEnabled()) {
-            bits |= (1L << BIT_LIGHTMAP);
+        final TextureUnitArray texUnit = GLStateManager.getTextures();
+        for (int i = 0; i < MAX_UNITS; i++) {
+            if ((fragUnitMask & (1 << i)) != 0) {
+                bits |= (1L << (BIT_UNIT_TEX_BASE + i));
+            }
+            if (!MatrixHelper.isIdentity(texUnit.getTextureUnitMatrix(i))) {
+                bits |= (1L << (BIT_UNIT_TEXMAT_BASE + i));
+            }
         }
 
-        // Check if texture matrix unit 0 is non-identity
-        final Matrix4f texMat = GLStateManager.getTextures().getTextureUnitMatrix(0);
-        if (!MatrixHelper.isIdentity(texMat)) {
-            bits |= (1L << BIT_TEX_MATRIX);
-        }
-
-        // TexGen (unit 0 only) — encode per-coordinate mode if enabled
-        final var texUnit = GLStateManager.getTextures();
+        // TexGen (unit 0 only) - per-coordinate mode if enabled.
+        // TODO: per-unit texgen for units 2/3. Deferred - no MC code path uses glTexGen on those.
         final TexGenState tg = texUnit.getTexGenState(0);
         boolean anyTexGen = false;
         if (texUnit.getTexGenSStates(0).isEnabled() && tg.getMode(GL11.GL_S) != 0) {
@@ -211,9 +202,9 @@ public final class VertexKey {
             bits |= ((long) m & 0x7) << BIT_TEXGEN_Q;
             if (m != TG_NONE) anyTexGen = true;
         }
-        // Force texture matrix on when texgen is active (end portal pattern always uses it)
+        // Force unit-0 texture matrix on when texgen is active (end portal pattern always uses it).
         if (anyTexGen) {
-            bits |= (1L << BIT_TEX_MATRIX);
+            bits |= (1L << BIT_UNIT_TEXMAT_BASE);
         }
 
         // Vertex format flags
@@ -222,12 +213,10 @@ public final class VertexKey {
         if (hasTexCoord) bits |= (1L << BIT_HAS_VERTEX_TEX);
         if (hasLightmap) bits |= (1L << BIT_HAS_VERTEX_LIGHTMAP);
 
-        // Clip planes
         if (GLStateManager.anyClipPlaneEnabled()) {
             bits |= (1L << BIT_CLIP_PLANES);
         }
 
-        // Wide line GS emulation
         if (GLStateManager.wideLineEmulationActive) {
             bits |= (1L << BIT_WIDE_LINE);
         }
@@ -235,8 +224,8 @@ public final class VertexKey {
         return bits;
     }
 
-    public static VertexKey fromState(boolean hasColor, boolean hasNormal, boolean hasTexCoord, boolean hasLightmap) {
-        return new VertexKey(packFromState(hasColor, hasNormal, hasTexCoord, hasLightmap));
+    public static VertexKey fromState(boolean hasColor, boolean hasNormal, boolean hasTexCoord, boolean hasLightmap, int fragUnitMask) {
+        return new VertexKey(packFromState(hasColor, hasNormal, hasTexCoord, hasLightmap, fragUnitMask));
     }
 
     static VertexKey fromPacked(long packed) {
@@ -257,9 +246,11 @@ public final class VertexKey {
 
     @Override
     public String toString() {
-        return String.format("FFPVertexKey[0x%09X: lit=%b l0=%b l1=%b cm=%b fog=%b tex=%b lm=%b col=%b nrm=%b vtex=%b vlm=%b tg=%d/%d/%d/%d clip=%b wline=%b]",
+        return String.format("FFPVertexKey[0x%011X: lit=%b l0=%b l1=%b cm=%b fog=%b tex=%d%d%d%d texmat=%d%d%d%d col=%b nrm=%b vtex=%b vlm=%b tg=%d/%d/%d/%d clip=%b wline=%b]",
             packed, lightingEnabled(), light0Enabled(), light1Enabled(),
-            colorMaterialEnabled(), fogEnabled(), textureEnabled(), lightmapEnabled(),
+            colorMaterialEnabled(), fogEnabled(),
+            unitTexCoordEnabled(0)?1:0, unitTexCoordEnabled(1)?1:0, unitTexCoordEnabled(2)?1:0, unitTexCoordEnabled(3)?1:0,
+            unitTexMatEnabled(0)?1:0, unitTexMatEnabled(1)?1:0, unitTexMatEnabled(2)?1:0, unitTexMatEnabled(3)?1:0,
             hasVertexColor(), hasVertexNormal(), hasVertexTexCoord(), hasVertexLightmap(),
             texGenModeS(), texGenModeT(), texGenModeR(), texGenModeQ(), clipPlanesEnabled(), wideLineEmulation());
     }

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

@@ -42,6 +42,8 @@ public final class VertexShaderGenerator {
             source = source.replace("v_SpecularColor", "v_SpecularColor_gs")
                            .replace("v_TexCoord0", "v_TexCoord0_gs")
                            .replace("v_TexCoord1", "v_TexCoord1_gs")
+                           .replace("v_TexCoord2", "v_TexCoord2_gs")
+                           .replace("v_TexCoord3", "v_TexCoord3_gs")
                            .replace("v_FogCoord", "v_FogCoord_gs")
                            .replace("v_Color", "v_Color_gs");
         }
@@ -76,11 +78,14 @@ public final class VertexShaderGenerator {
             sb.append("uniform mat3 u_NormalMatrix;\n");
         }
 
-        if (key.textureMatrixEnabled()) {
-            sb.append("uniform mat4 u_TextureMatrix0;\n");
+        for (int i = 0; i < VertexKey.MAX_UNITS; i++) {
+            if (i == 1) continue;
+            if (key.unitTexMatEnabled(i)) {
+                sb.append("uniform mat4 u_TextureMatrix").append(i).append(";\n");
+            }
         }
 
-        // TexGen plane uniforms
+        // TexGen plane uniforms (unit 0 only - TODO: per-unit)
         if (key.texGenModeS() == VertexKey.TG_OBJ_LINEAR) sb.append("uniform vec4 u_TexGenObjPlaneS;\n");
         if (key.texGenModeS() == VertexKey.TG_EYE_LINEAR) sb.append("uniform vec4 u_TexGenEyePlaneS;\n");
         if (key.texGenModeT() == VertexKey.TG_OBJ_LINEAR) sb.append("uniform vec4 u_TexGenObjPlaneT;\n");
@@ -98,9 +103,11 @@ public final class VertexShaderGenerator {
             sb.append("uniform vec4 u_CurrentColor;\n");
         }
 
-        if (!key.hasVertexTexCoord() && key.textureEnabled()) {
-            sb.append("uniform vec4 u_CurrentTexCoord;\n");
+        if (key.unitTexCoordEnabled(0) && !key.hasVertexTexCoord()) {
+            sb.append("uniform vec4 u_CurrentTexCoord0;\n");
         }
+        if (key.unitTexCoordEnabled(2)) sb.append("uniform vec4 u_CurrentTexCoord2;\n");
+        if (key.unitTexCoordEnabled(3)) sb.append("uniform vec4 u_CurrentTexCoord3;\n");
 
         if (key.lightmapEnabled() && !key.hasVertexLightmap()) {
             sb.append("uniform vec2 u_CurrentLightmapCoord;\n");
@@ -178,12 +185,15 @@ public final class VertexShaderGenerator {
         if (key.separateSpecular()) {
             sb.append("out vec3 v_SpecularColor;\n");
         }
-        if (key.textureEnabled() || key.hasVertexTexCoord() || key.texGenEnabled()) {
+        // Per-unit varying outputs. Each enabled texture unit (and texgen, which targets unit 0) gets its own v_TexCoord<i>.
+        if (key.unitTexCoordEnabled(0) || key.texGenEnabled()) {
             sb.append("out vec4 v_TexCoord0;\n");
         }
         if (key.lightmapEnabled()) {
             sb.append("out vec4 v_TexCoord1;\n");
         }
+        if (key.unitTexCoordEnabled(2)) sb.append("out vec4 v_TexCoord2;\n");
+        if (key.unitTexCoordEnabled(3)) sb.append("out vec4 v_TexCoord3;\n");
         if (key.fogEnabled()) {
             sb.append("out float v_FogCoord;\n");
         }
@@ -331,22 +341,18 @@ public final class VertexShaderGenerator {
     private static void emitTexCoordPassthrough(StringBuilder sb, VertexKey key) {
         if (key.texGenEnabled()) {
             emitTexGenCoordGeneration(sb, key);
-        } else if (key.textureEnabled() || key.hasVertexTexCoord()) {
-            sb.append("  // Texture coordinates\n");
-            if (key.hasVertexTexCoord()) {
-                if (key.textureMatrixEnabled()) {
-                    sb.append("  v_TexCoord0 = u_TextureMatrix0 * vec4(a_TexCoord0, 0.0, 1.0);\n");
-                } else {
-                    sb.append("  v_TexCoord0 = vec4(a_TexCoord0, 0.0, 1.0);\n");
-                }
+        } else if (key.unitTexCoordEnabled(0)) {
+            sb.append("  // Texture coordinates - unit 0\n");
+            final String src = key.hasVertexTexCoord()
+                ? "vec4(a_TexCoord0, 0.0, 1.0)"
+                : "u_CurrentTexCoord0";
+            if (key.unitTexMatEnabled(0)) {
+                sb.append("  v_TexCoord0 = u_TextureMatrix0 * ").append(src).append(";\n");
             } else {
-                if (key.textureMatrixEnabled()) {
-                    sb.append("  v_TexCoord0 = u_TextureMatrix0 * u_CurrentTexCoord;\n");
-                } else {
-                    sb.append("  v_TexCoord0 = u_CurrentTexCoord;\n");
-                }
+                sb.append("  v_TexCoord0 = ").append(src).append(";\n");
             }
         }
+
         if (key.lightmapEnabled()) {
             if (key.hasVertexLightmap()) {
                 sb.append("  v_TexCoord1 = u_LightmapTextureMatrix * vec4(a_TexCoord1, 0.0, 1.0);\n");
@@ -354,6 +360,16 @@ public final class VertexShaderGenerator {
                 sb.append("  v_TexCoord1 = u_LightmapTextureMatrix * vec4(u_CurrentLightmapCoord, 0.0, 1.0);\n");
             }
         }
+
+        for (int i = 2; i < VertexKey.MAX_UNITS; i++) {
+            if (!key.unitTexCoordEnabled(i)) continue;
+            final String src = "u_CurrentTexCoord" + i;
+            if (key.unitTexMatEnabled(i)) {
+                sb.append("  v_TexCoord").append(i).append(" = u_TextureMatrix").append(i).append(" * ").append(src).append(";\n");
+            } else {
+                sb.append("  v_TexCoord").append(i).append(" = ").append(src).append(";\n");
+            }
+        }
     }
 
     /**

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/GLSMHooks.java

@@ -18,6 +18,7 @@ public final class GLSMHooks {
     public static final EventBus<FogStateChangeEvent> FOG_STATE_CHANGE = EventBus.create(FogStateChangeEvent.class);
     public static final EventBus<LightmapCoordsEvent> LIGHTMAP_COORDS = EventBus.create(LightmapCoordsEvent.class);
     public static final EventBus<AlphaStateChangeEvent> ALPHA_STATE_CHANGE = EventBus.create(AlphaStateChangeEvent.class);
+    public static final EventBus<ShaderColorChangeEvent> SHADER_COLOR_CHANGE = EventBus.create(ShaderColorChangeEvent.class);
 
     // Reusable event instances
     public static final TextureBindEvent textureBindEvent = new TextureBindEvent();
@@ -28,6 +29,7 @@ public final class GLSMHooks {
     public static final FogStateChangeEvent fogStateChangeEvent = new FogStateChangeEvent();
     public static final LightmapCoordsEvent lightmapCoordsEvent = new LightmapCoordsEvent();
     public static final AlphaStateChangeEvent alphaStateChangeEvent = new AlphaStateChangeEvent();
+    public static final ShaderColorChangeEvent shaderColorChangeEvent = new ShaderColorChangeEvent();
 
     private GLSMHooks() {}
 }

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/events/ShaderColorChangeEvent.java

@@ -0,0 +1,10 @@
+package com.gtnewhorizons.angelica.glsm.hooks.events;
+
+import net.minecraftforge.eventbus.api.event.MutableEvent;
+
+public final class ShaderColorChangeEvent extends MutableEvent {
+    public float red;
+    public float green;
+    public float blue;
+    public float alpha;
+}

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/texture/TextureInfo.java

@@ -9,6 +9,7 @@ public class TextureInfo {
 
     @Getter protected final int id;
     protected int internalFormat = -1;
+    protected int resolvedInternalFormat = -1;
     protected int width = -1;
     protected int height = -1;
 
@@ -34,6 +35,17 @@ public class TextureInfo {
         return internalFormat;
     }
 
+    public int getResolvedInternalFormat() {
+        if (resolvedInternalFormat == -1) {
+            resolvedInternalFormat = RenderSystem.getTexLevelParameteri(id, 0, GL11.GL_TEXTURE_INTERNAL_FORMAT);
+        }
+        return resolvedInternalFormat;
+    }
+
+    public boolean needsInternalFormatResolve() {
+        return resolvedInternalFormat == -1;
+    }
+
     public int getWidth() {
         if (width == -1) {
             width = RenderSystem.getTexLevelParameteri(id, 0, GL11.GL_TEXTURE_WIDTH);

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/texture/TextureInfoCache.java

@@ -5,6 +5,9 @@ import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import org.jetbrains.annotations.Nullable;
 import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL13;
+import org.lwjgl.opengl.GL21;
+import org.lwjgl.opengl.GL30;
 
 import java.nio.Buffer;
 import java.util.concurrent.locks.ReentrantLock;
@@ -45,6 +48,7 @@ public class TextureInfoCache {
             final TextureInfo info = getInfo(GLStateManager.getBoundTextureForServerState());
             if (info == null) return;
             info.internalFormat = internalformat;
+            info.resolvedInternalFormat = isGenericCompressedInternalFormat(internalformat) ? -1 : internalformat;
             info.width = width;
             info.height = height;
         }
@@ -55,11 +59,24 @@ public class TextureInfoCache {
             final TextureInfo info = getInfo(GLStateManager.getBoundTextureForServerState());
             if (info == null) return;
             info.internalFormat = internalformat;
+            info.resolvedInternalFormat = isGenericCompressedInternalFormat(internalformat) ? -1 : internalformat;
             info.width = width;
             info.height = height;
         }
     }
 
+    public static boolean isGenericCompressedInternalFormat(int internalFormat) {
+        return switch (internalFormat) {
+            case GL30.GL_COMPRESSED_RED,
+                 GL30.GL_COMPRESSED_RG,
+                 GL13.GL_COMPRESSED_RGB,
+                 GL13.GL_COMPRESSED_RGBA,
+                 GL21.GL_COMPRESSED_SRGB,
+                 GL21.GL_COMPRESSED_SRGB_ALPHA -> true;
+            default -> false;
+        };
+    }
+
     public void onDeleteTexture(int id) {
         if (id < 0) return;
 

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

@@ -6,6 +6,10 @@ import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL13;
+import org.lwjgl.opengl.GL21;
+import org.lwjgl.opengl.GL30;
+import org.lwjgl.opengl.EXTTextureCompressionS3TC;
 
 import java.lang.reflect.Field;
 import java.nio.ByteBuffer;
@@ -15,6 +19,98 @@ import static org.junit.jupiter.api.Assertions.*;
 @ExtendWith(GLSMExtension.class)
 public class GLSM_TextureInfoCache_UnitTest {
 
+    @Test
+    void testGenericCompressedUploadResolvesToSpecificFormat() {
+        int texId = GL11.glGenTextures();
+        try {
+            GL11.glBindTexture(GL11.GL_TEXTURE_2D, texId);
+            ByteBuffer pixels = BufferUtils.createByteBuffer(64 * 64 * 4);
+            GL11.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL13.GL_COMPRESSED_RGBA, 64, 64, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixels);
+
+            int format = GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, 0, GL11.GL_TEXTURE_INTERNAL_FORMAT);
+            assertNotEquals(-1, format);
+            assertNotEquals(GL30.GL_COMPRESSED_RED, format);
+            assertNotEquals(GL30.GL_COMPRESSED_RG, format);
+            assertNotEquals(GL13.GL_COMPRESSED_RGB, format);
+            assertNotEquals(GL13.GL_COMPRESSED_RGBA, format);
+            assertNotEquals(GL21.GL_COMPRESSED_SRGB, format);
+            assertNotEquals(GL21.GL_COMPRESSED_SRGB_ALPHA, format);
+        } finally {
+            GL11.glDeleteTextures(texId);
+            GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
+        }
+    }
+
+    @Test
+    void testNonGenericUploadCachesWithoutRoundtrip() {
+        int texId = GL11.glGenTextures();
+        try {
+            GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texId);
+            ByteBuffer pixels = BufferUtils.createByteBuffer(64 * 64 * 4);
+            GLStateManager.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, 64, 64, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixels);
+
+            TextureInfo info = TextureInfoCache.INSTANCE.getInfo(texId);
+            assertFalse(info.needsInternalFormatResolve());
+            assertEquals(GL11.GL_RGBA8, info.getResolvedInternalFormat());
+            assertEquals(GL11.GL_RGBA8, GL11.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, 0, GL11.GL_TEXTURE_INTERNAL_FORMAT));
+        } finally {
+            GL11.glDeleteTextures(texId);
+            GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
+        }
+    }
+
+    @Test
+    void testGenericCompressedPreservesAsPassedInternalFormat() {
+        int texId = GL11.glGenTextures();
+        try {
+            GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texId);
+            ByteBuffer pixels = BufferUtils.createByteBuffer(64 * 64 * 4);
+            GLStateManager.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL13.GL_COMPRESSED_RGBA, 64, 64, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixels);
+
+            TextureInfo info = TextureInfoCache.INSTANCE.getInfo(texId);
+            assertEquals(GL13.GL_COMPRESSED_RGBA, info.getInternalFormat());
+            assertTrue(info.needsInternalFormatResolve());
+        } finally {
+            GL11.glDeleteTextures(texId);
+            GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
+        }
+    }
+
+    @Test
+    void testRepeatedQueryAfterResolveUsesCache() {
+        int texId = GL11.glGenTextures();
+        try {
+            GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texId);
+            ByteBuffer pixels = BufferUtils.createByteBuffer(64 * 64 * 4);
+            GLStateManager.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL13.GL_COMPRESSED_RGBA, 64, 64, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixels);
+
+            TextureInfo info = TextureInfoCache.INSTANCE.getInfo(texId);
+            assertTrue(info.needsInternalFormatResolve());
+            int first = GLStateManager.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, 0, GL11.GL_TEXTURE_INTERNAL_FORMAT);
+            assertFalse(info.needsInternalFormatResolve());
+            int second = GLStateManager.glGetTexLevelParameteri(GL11.GL_TEXTURE_2D, 0, GL11.GL_TEXTURE_INTERNAL_FORMAT);
+            assertEquals(first, second);
+        } finally {
+            GL11.glDeleteTextures(texId);
+            GL11.glBindTexture(GL11.GL_TEXTURE_2D, 0);
+        }
+    }
+
+    @Test
+    void testIsGenericCompressedInternalFormatHelper() {
+        assertTrue(TextureInfoCache.isGenericCompressedInternalFormat(GL30.GL_COMPRESSED_RED));
+        assertTrue(TextureInfoCache.isGenericCompressedInternalFormat(GL30.GL_COMPRESSED_RG));
+        assertTrue(TextureInfoCache.isGenericCompressedInternalFormat(GL13.GL_COMPRESSED_RGB));
+        assertTrue(TextureInfoCache.isGenericCompressedInternalFormat(GL13.GL_COMPRESSED_RGBA));
+        assertTrue(TextureInfoCache.isGenericCompressedInternalFormat(GL21.GL_COMPRESSED_SRGB));
+        assertTrue(TextureInfoCache.isGenericCompressedInternalFormat(GL21.GL_COMPRESSED_SRGB_ALPHA));
+        assertFalse(TextureInfoCache.isGenericCompressedInternalFormat(GL11.GL_RGBA));
+        assertFalse(TextureInfoCache.isGenericCompressedInternalFormat(GL11.GL_RGBA8));
+        assertFalse(TextureInfoCache.isGenericCompressedInternalFormat(EXTTextureCompressionS3TC.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT));
+        assertFalse(TextureInfoCache.isGenericCompressedInternalFormat(0));
+        assertFalse(TextureInfoCache.isGenericCompressedInternalFormat(-1));
+    }
+
     /**
      * Texture deletion is server-side; cache must be invalidated regardless of client caching state.
      */

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

@@ -21,6 +21,8 @@ class SharedDrawableVaoTest {
     private static final String VERT_330 = "#version 330 core\nvoid main() { gl_Position = vec4(0.0); }\n";
     private static final String FRAG_330 = "#version 330 core\nout vec4 o;\nvoid main() { o = vec4(0.0); }\n";
 
+    private static boolean ownsDisplay = false;
+
     @BeforeAll
     static void createContext() throws LWJGLException {
         assumeTrue(!Display.isCreated(), "inherited Display -- skipping to avoid profile drift");
@@ -31,11 +33,13 @@ class SharedDrawableVaoTest {
             new PixelFormat().withDepthBits(24).withStencilBits(8),
             new ContextAttribs(4, 1).withProfileCore(true).withForwardCompatible(true));
         GL30.glBindVertexArray(GL30.glGenVertexArrays());
+        ownsDisplay = true;
     }
 
     @AfterAll
     static void destroyContext() {
-        if (Display.isCreated()) Display.destroy();
+        if (ownsDisplay && Display.isCreated()) Display.destroy();
+        ownsDisplay = false;
     }
 
     @Test

glsm/src/test/java/com/gtnewhorizons/angelica/glsm/ffp/FFPCombineShaderTest.java

@@ -128,7 +128,7 @@ class FFPCombineShaderTest {
         setupXaeroState();
 
         FragmentKey fk = FragmentKey.fromState();
-        VertexKey vk = VertexKey.fromState(true, false, true, false);
+        VertexKey vk = VertexKey.fromState(true, false, true, false, fk.enabledUnitMask());
 
         String fragSource = FragmentShaderGenerator.generate(fk);
         String vertSource = VertexShaderGenerator.generate(vk);

src/main/java/com/gtnewhorizons/angelica/client/font/BatchingFontRenderer.java

@@ -560,6 +560,9 @@ public class BatchingFontRenderer {
             boolean curWave = false;
             boolean curDinnerbone = false;
             boolean curGradient = false;
+            boolean curShadow = false;
+            boolean curShadowCustomColor = false;
+            int curShadowColorOverride = 0;
             int gradientStartRgb = 0, gradientEndRgb = 0;
             int gradientCharIndex = 0, gradientTotalChars = 0;
             float gradientStep = 0f;
@@ -651,6 +654,19 @@ public class BatchingFontRenderer {
                         curWave = !curWave;
                     } else if (fmtCode == 'v' && AngelicaConfig.enableDinnerboneText) {
                         curDinnerbone = !curDinnerbone;
+                    } else if (fmtCode == 'u' && AngelicaConfig.enableDropShadow) {
+                        int customRgb = (charIdx + SECTION_X_LENGTH < stringEnd)
+                            ? ColorCodeUtils.parseSectionXAt(string, charIdx + 1)
+                            : -1;
+                        if (customRgb != -1) {
+                            curShadow = true;
+                            curShadowCustomColor = true;
+                            curShadowColorOverride = customRgb;
+                            charIdx += SECTION_X_LENGTH;
+                        } else {
+                            curShadow = !curShadow;
+                            if (!curShadow) curShadowCustomColor = false;
+                        }
                     } else if (fmtCode == 'g' && AngelicaConfig.enableGradients && charIdx + GRADIENT_PAYLOAD < stringEnd) {
                         int color1 = ColorCodeUtils.parseSectionXAt(string, charIdx + 1);
                         int color2 = ColorCodeUtils.parseSectionXAt(string, charIdx + 1 + SECTION_X_LENGTH);
@@ -674,6 +690,8 @@ public class BatchingFontRenderer {
                         curWave = false;
                         curDinnerbone = false;
                         curGradient = false;
+                        curShadow = false;
+                        curShadowCustomColor = false;
                         curColor = color;
                         curShadowColor = shadowColor;
                     }
@@ -682,6 +700,8 @@ public class BatchingFontRenderer {
                     continue;
                 }
 
+                if (chr == ColorCodeUtils.ESCAPED_AMPERSAND) { chr = '&'; }
+
                 if (FontConfig.enableCustomFont && FontConfig.enableGlyphReplacements) {
                     final char replacement = GlyphReplacements.getReplacementGlyph(chr);
                     if (replacement != 0) {
@@ -747,13 +767,17 @@ public class BatchingFontRenderer {
                     renderY += (float) Math.sin(visibleCharIndex * WAVE_FREQUENCY + time) * AngelicaConfig.waveAmplitude;
                 }
 
-                if (enableShadow) {
+                final boolean drawShadow = enableShadow || curShadow;
+                if (drawShadow) {
+                    final int effectiveShadowColor = curShadowCustomColor
+                        ? ((curColor & 0xFF000000) | (curShadowColorOverride & 0x00FFFFFF))
+                        : curShadowColor;
                     for (int n = 1; n <= shadowCopies; n++) {
                         final float shadowOffsetPart = shadowOffset * ((float) n / shadowCopies);
-                        pushTexRect(curX + shadowOffsetPart, renderY + shadowOffsetPart, glyphW - 1.0f, heightSouth, itOff, curShadowColor, uStart, vStart, uSz, vSz, curDinnerbone);
+                        pushTexRect(curX + shadowOffsetPart, renderY + shadowOffsetPart, glyphW - 1.0f, heightSouth, itOff, effectiveShadowColor, uStart, vStart, uSz, vSz, curDinnerbone);
 
                         if (curBold) {
-                            pushTexRect(curX + 2.0f * shadowOffsetPart, renderY + shadowOffsetPart, glyphW - 1.0f, heightSouth, itOff, curShadowColor, uStart, vStart, uSz, vSz, curDinnerbone);
+                            pushTexRect(curX + 2.0f * shadowOffsetPart, renderY + shadowOffsetPart, glyphW - 1.0f, heightSouth, itOff, effectiveShadowColor, uStart, vStart, uSz, vSz, curDinnerbone);
                         }
                     }
                 }
@@ -775,7 +799,7 @@ public class BatchingFontRenderer {
                     both:           4(1 + 2 * shadowCopies + boldCopies)
                  */
                 int charCount = 1;
-                if (enableShadow) { charCount += shadowCopies * (curBold ? 2 : 1); }
+                if (drawShadow) { charCount += shadowCopies * (curBold ? 2 : 1); }
                 if (curBold) { charCount += boldCopies; }
                 final int vtxCount = 4 * charCount;
                 pushDrawCmd(idxId, vtxCount / 2 * 3, texture, chr > 255);
@@ -822,6 +846,7 @@ public class BatchingFontRenderer {
     }
 
     public float getCharWidthFine(char chr) {
+        if (chr == ColorCodeUtils.ESCAPED_AMPERSAND) { chr = '&'; }
         if (chr == FORMATTING_CHAR) { return -1; }
 
         if (chr == ' ' || chr == '\u00A0' || chr == '\u202F') {

src/main/java/com/gtnewhorizons/angelica/client/font/ColorCodeUtils.java

@@ -18,6 +18,7 @@ public final class ColorCodeUtils {
     private ColorCodeUtils() {}
 
     public static final char FORMATTING_CHAR = '§';
+    public static final char ESCAPED_AMPERSAND = '';
 
     public static final int SECTION_X_PAYLOAD = 12;
     public static final int SECTION_X_LENGTH = 14;
@@ -25,7 +26,7 @@ public final class ColorCodeUtils {
     public static final int GRADIENT_LENGTH = 30;
 
     /** Valid single {@code &} codes. {@code g} is excluded; {@code &g} only converts as part of a gradient. */
-    public static final String VALID_SINGLE_CODES = "0123456789abcdefklmnorqzv";
+    public static final String VALID_SINGLE_CODES = "0123456789abcdefklmnorqzvu";
 
     private static final String[] SECTION_PREFIX = new String[128];
     static {
@@ -87,6 +88,14 @@ public final class ColorCodeUtils {
         StringBuilder sb = null;
         int last = 0;
         while (idx != -1 && idx + 1 < len) {
+            if (idx > 0 && text.charAt(idx - 1) == '\\') {
+                if (sb == null) sb = new StringBuilder(len + 16);
+                sb.append(text, last, idx - 1);
+                sb.append(ESCAPED_AMPERSAND);
+                last = idx + 1;
+                idx = text.indexOf('&', last);
+                continue;
+            }
             if (text.charAt(idx + 1) == '#' && idx + 7 < len) {
                 boolean validHex = true;
                 for (int i = 2; i <= 7; i++) {

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

@@ -132,6 +132,10 @@ public class AngelicaConfig {
     @Config.DefaultBoolean(true)
     public static boolean enableDinnerboneText;
 
+    @Config.Comment("Enable per-segment drop shadow toggle (&u) and colored shadow (&u&#RRGGBB)")
+    @Config.DefaultBoolean(true)
+    public static boolean enableDropShadow;
+
     @Config.Comment("Wave text amplitude (how far characters bounce)")
     @Config.DefaultFloat(2.0f)
     @Config.RangeFloat(min = 1.0f, max = 8.0f)

src/main/java/com/gtnewhorizons/angelica/event/ChunkBiomeDataChangedEvent.java

@@ -0,0 +1,21 @@
+package com.gtnewhorizons.angelica.event;
+
+import net.minecraftforge.eventbus.api.bus.EventBus;
+import net.minecraftforge.eventbus.api.event.MutableEvent;
+
+public final class ChunkBiomeDataChangedEvent extends MutableEvent {
+
+    public static final EventBus<ChunkBiomeDataChangedEvent> BUS = EventBus.create(ChunkBiomeDataChangedEvent.class);
+
+    private static final ChunkBiomeDataChangedEvent INSTANCE = new ChunkBiomeDataChangedEvent();
+
+    public int chunkX;
+    public int chunkZ;
+
+    public static void post(int chunkX, int chunkZ) {
+        if (!BUS.hasListeners()) return;
+        INSTANCE.chunkX = chunkX;
+        INSTANCE.chunkZ = chunkZ;
+        BUS.post(INSTANCE);
+    }
+}

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

@@ -26,6 +26,7 @@ public class IrisGLSMBridge {
     private static Runnable fogStartListener = null;
     private static Runnable fogEndListener = null;
     private static Runnable fogDensityListener = null;
+    private static Runnable colorModulatorListener = null;
 
     static {
         StateUpdateNotifiers.alphaFuncNotifier = listener -> alphaFuncListener = listener;
@@ -35,6 +36,7 @@ public class IrisGLSMBridge {
         StateUpdateNotifiers.fogStartNotifier = listener -> fogStartListener = listener;
         StateUpdateNotifiers.fogEndNotifier = listener -> fogEndListener = listener;
         StateUpdateNotifiers.fogDensityNotifier = listener -> fogDensityListener = listener;
+        StateUpdateNotifiers.colorModulatorNotifier = listener -> colorModulatorListener = listener;
     }
 
     public static void register() {
@@ -108,6 +110,10 @@ public class IrisGLSMBridge {
             }
         });
 
+        GLSMHooks.SHADER_COLOR_CHANGE.addListener(event -> {
+            if (Iris.enabled && colorModulatorListener != null) colorModulatorListener.run();
+        });
+
         GLSMHooks.FOG_STATE_CHANGE.addListener(event -> {
             if (Iris.enabled) {
                 if (fogModeListener != null) fogModeListener.run();
@@ -157,17 +163,17 @@ public class IrisGLSMBridge {
         GLSMHooks.PROGRAM_CHANGE.addListener(event -> {
             if (!Iris.enabled) return;
             if (event.postBind) return;
-            
+
             final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
             if (!(pipeline instanceof DeferredWorldRenderingPipeline drp)) return;
             if (!drp.shouldOverrideShaders()) return;
             if (drp.getActivePassProgramId() == -1) return;
-            
+
             if (DepthColorStorage.isOwnedProgram(event.newProgram)) {
                 DepthColorStorage.unlockDepthColor();
             }
         });
-        
+
         GLSMHooks.PROGRAM_CHANGE.addListener(event -> {
             if (!Iris.enabled) return;
             if (!event.postBind) return;

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

@@ -45,7 +45,9 @@ public enum Mixins implements IMixins {
             , "angelica.bugfixes.MixinRenderCreeper_AuraDepth"
             , "angelica.bugfixes.MixinRenderGlobal_DeferredEntityOverlay"
             , "angelica.bugfixes.MixinRenderGlobal_DestroyBlock"
+            , "angelica.bugfixes.MixinRenderMooshroom_MushroomTint"
             , "angelica.bugfixes.MixinRendererLivingEntity_DeferredEntityOverlay"
+            , "angelica.bugfixes.MixinRendererLivingEntity_OverlayTint"
             , "angelica.bugfixes.MixinRenderWither_ArmorCentering"
             , "angelica.bugfixes.MixinRendererLivingEntity_EyeDepth"
             , "angelica.debug.MixinMinecraft_FPSCap"
@@ -275,6 +277,8 @@ public enum Mixins implements IMixins {
             , "shaders.MixinRenderNameTag"
             , "shaders.MixinRenderPlayerArmor"
             , "shaders.MixinTileEntityBeaconRenderer"
+            , "shaders.MixinWorldNbtCache"
+            , "shaders.MixinNetHandlerPlayClient_NbtRemesh"
             , "shaders.MixinRenderEndPortal"
             , "shaders.MixinTileEntityRendererDispatcher"
             , "shaders.MixinGlProgram"

src/main/java/com/gtnewhorizons/angelica/render/CloudEdges.java

@@ -0,0 +1,75 @@
+package com.gtnewhorizons.angelica.render;
+
+import java.nio.ByteBuffer;
+
+final class CloudEdges {
+    private static final int CELL_EMPTY_THRESHOLD = 10;
+
+    final int width, height;
+    private final int wMask, hMask;
+    private final boolean whPow2;
+    private final long[] opaqueBits;
+    final int opaqueCount;
+
+    CloudEdges(int width, int height, ByteBuffer rgba) {
+        this.width = width;
+        this.height = height;
+        this.wMask = width - 1;
+        this.hMask = height - 1;
+        this.whPow2 = (width & wMask) == 0 && (height & hMask) == 0;
+        final int total = width * height;
+        final long[] bits = new long[(total + 63) >>> 6];
+        int op = 0;
+        for (int i = 0; i < total; i++) {
+            if ((rgba.get(i * 4 + 3) & 0xFF) >= CELL_EMPTY_THRESHOLD) {
+                bits[i >>> 6] |= 1L << (i & 63);
+                op++;
+            }
+        }
+        this.opaqueBits = bits;
+        this.opaqueCount = op;
+    }
+
+    boolean cellOpaque(int x, int z) {
+        final int xw, zh;
+        if (whPow2) {
+            xw = x & wMask;
+            zh = z & hMask;
+        } else {
+            xw = Math.floorMod(x, width);
+            zh = Math.floorMod(z, height);
+        }
+        final int idx = xw + zh * width;
+        return ((opaqueBits[idx >>> 6] >>> (idx & 63)) & 1L) != 0L;
+    }
+
+    long readOpaqueRowBits(int x0, int z) {
+        final int zMod, x0Mod;
+        if (whPow2) {
+            zMod = z & hMask;
+            x0Mod = x0 & wMask;
+        } else {
+            zMod = Math.floorMod(z, height);
+            x0Mod = Math.floorMod(x0, width);
+        }
+        if (x0Mod + 10 <= width) {
+            return readContigBits(opaqueBits, (long) zMod * width + x0Mod, 10);
+        }
+        final int colsBeforeWrap = width - x0Mod;
+        final long firstPart = readContigBits(opaqueBits, (long) zMod * width + x0Mod, colsBeforeWrap);
+        final long secondPart = readContigBits(opaqueBits, (long) zMod * width, 10 - colsBeforeWrap);
+        return firstPart | (secondPart << colsBeforeWrap);
+    }
+
+    private static long readContigBits(long[] bits, long startBitIdx, int count) {
+        final int wordIdx = (int) (startBitIdx >>> 6);
+        final int bitOff = (int) (startBitIdx & 63);
+        final long mask = count == 64 ? -1L : (1L << count) - 1L;
+        final long w0 = bits[wordIdx];
+        if (bitOff + count <= 64) {
+            return (w0 >>> bitOff) & mask;
+        }
+        final long w1 = bits[wordIdx + 1];
+        return ((w0 >>> bitOff) | (w1 << (64 - bitOff))) & mask;
+    }
+}

src/main/java/com/gtnewhorizons/angelica/render/CloudUniforms.java

@@ -0,0 +1,78 @@
+package com.gtnewhorizons.angelica.render;
+
+import org.embeddedt.embeddium.impl.gl.shader.ShaderBindingContext;
+import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformFloat4v;
+import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformInt;
+import org.embeddedt.embeddium.impl.gl.shader.uniform.GlUniformMatrix4f;
+
+final class CloudUniforms {
+    static final float ALPHA = 0.8f;
+
+    final GlUniformMatrix4f mvp;
+    final GlUniformFloat4v colorMult;
+    final GlUniformFloat4v fogParams;
+    final GlUniformFloat4v fogColor;
+    final GlUniformInt fogEnabled;
+    final GlUniformInt tex;
+
+    private int lastFogEnabled = -1;
+    private float lastFogR = Float.NaN, lastFogG = Float.NaN, lastFogB = Float.NaN;
+    private float lastColorR = Float.NaN, lastColorG = Float.NaN, lastColorB = Float.NaN;
+    private float lastFogParamX = Float.NaN, lastFogParamY = Float.NaN;
+    private final float[] uploadBuf = new float[4];
+
+    CloudUniforms(ShaderBindingContext ctx) {
+        mvp = ctx.bindUniform("u_MVPMatrix", GlUniformMatrix4f::new);
+        colorMult = ctx.bindUniform("u_ColorMult", GlUniformFloat4v::new);
+        fogParams = ctx.bindUniform("u_FogParams", GlUniformFloat4v::new);
+        fogColor = ctx.bindUniform("u_FogColor", GlUniformFloat4v::new);
+        fogEnabled = ctx.bindUniform("u_FogEnabled", GlUniformInt::new);
+        tex = ctx.bindUniform("u_Tex", GlUniformInt::new);
+    }
+
+    void setFogEnabled(boolean enabled) {
+        final int val = enabled ? 1 : 0;
+        if (val != lastFogEnabled) {
+            lastFogEnabled = val;
+            fogEnabled.setInt(val);
+        }
+    }
+
+    void setFogColor(float r, float g, float b) {
+        if (r != lastFogR || g != lastFogG || b != lastFogB) {
+            lastFogR = r;
+            lastFogG = g;
+            lastFogB = b;
+            uploadBuf[0] = r;
+            uploadBuf[1] = g;
+            uploadBuf[2] = b;
+            uploadBuf[3] = 1.0f;
+            fogColor.set(uploadBuf);
+        }
+    }
+
+    void setFogParams(float x, float y) {
+        if (x != lastFogParamX || y != lastFogParamY) {
+            lastFogParamX = x;
+            lastFogParamY = y;
+            uploadBuf[0] = x;
+            uploadBuf[1] = y;
+            uploadBuf[2] = 0f;
+            uploadBuf[3] = 0f;
+            fogParams.set(uploadBuf);
+        }
+    }
+
+    void setColorMult(float r, float g, float b) {
+        if (r != lastColorR || g != lastColorG || b != lastColorB) {
+            lastColorR = r;
+            lastColorG = g;
+            lastColorB = b;
+            uploadBuf[0] = r;
+            uploadBuf[1] = g;
+            uploadBuf[2] = b;
+            uploadBuf[3] = ALPHA;
+            colorMult.set(uploadBuf);
+        }
+    }
+}

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

@@ -12,8 +12,10 @@ import com.prupe.mcpatcher.mal.block.RenderBlocksUtils;
 import it.unimi.dsi.fastutil.objects.Reference2ReferenceMap;
 import net.coderbot.iris.block_rendering.BlockMaterialMapping;
 import net.coderbot.iris.block_rendering.BlockRenderingSettings;
+import net.coderbot.iris.block_rendering.NbtConditionalIdMap;
 import net.coderbot.iris.vertices.ExtendedDataHelper;
 import net.minecraft.block.Block;
+import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.RenderBlocks;
 import net.minecraft.client.renderer.Tessellator;
@@ -118,6 +120,10 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
             final Map<Block, BlockRenderLayer> blockTypeIds = provider != null ? provider.getBlockTypeIds() : null;
             final BlockRenderContext blockRenderContext = buildContext.getBlockRenderContext();
 
+            final NbtConditionalIdMap<Block> teMap = BlockRenderingSettings.INSTANCE.getBlockNbtMap();
+            final net.minecraft.world.World mcWorld = Minecraft.getMinecraft().theWorld;
+            final long currentTick = mcWorld != null ? mcWorld.getTotalWorldTime() : 0L;
+
             final boolean threaded = isThreaded();
             final List<DeferredBlock> deferredBlocks = threaded ? new ArrayList<>() : null;
 
@@ -192,7 +198,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
                                     continue;
                                 }
 
-                                renderBlock(block, meta, x, y, z, pass, tessellator, renderBlocks, buffers, buildContext, blockRenderContext, minX, minY, minZ, materialOverride, isShaderPackOverride);
+                                renderBlock(block, meta, x, y, z, pass, tessellator, renderBlocks, buffers, buildContext, blockRenderContext, minX, minY, minZ, materialOverride, isShaderPackOverride, teMap, currentTick);
                             }
                         }
 
@@ -205,7 +211,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
 
             // Process deferred blocks on main thread if any
             if (deferredBlocks != null && !deferredBlocks.isEmpty()) {
-                processDeferredBlocks(deferredBlocks, buildContext, buffers, region, minX, minY, minZ);
+                processDeferredBlocks(deferredBlocks, buildContext, buffers, region, minX, minY, minZ, teMap, currentTick);
             }
 
             final Reference2ReferenceMap<TerrainRenderPass, BuiltSectionMeshParts> meshes =
@@ -236,7 +242,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
         }
     }
 
-    protected void renderBlock(Block block, int metadata, int x, int y, int z, int pass, Tessellator tessellator, RenderBlocks renderBlocks, ChunkBuildBuffers buffers, AngelicaChunkBuildContext buildContext, BlockRenderContext blockRenderContext, int originX, int originY, int originZ, Material materialOverride, boolean isShaderPackOverride) {
+    protected void renderBlock(Block block, int metadata, int x, int y, int z, int pass, Tessellator tessellator, RenderBlocks renderBlocks, ChunkBuildBuffers buffers, AngelicaChunkBuildContext buildContext, BlockRenderContext blockRenderContext, int originX, int originY, int originZ, Material materialOverride, boolean isShaderPackOverride, NbtConditionalIdMap<Block> teMap, long currentTick) {
 
         final var blockMaterial = block.getMaterial();
         final boolean isFluid = blockMaterial == net.minecraft.block.material.Material.water || blockMaterial == net.minecraft.block.material.Material.lava;
@@ -272,6 +278,27 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
                 }
                 contextEncoder.prepareToRenderBlock(blockRenderContext, block, effectiveMeta,
                     ExtendedDataHelper.BLOCK_RENDER_TYPE, lightValue);
+                // Check for TileEntity NBT-conditional shader block ID override
+                if (teMap != null && teMap.hasConditions(block)) {
+                    final long packedPos = BlockRenderingSettings.packBlockPos(x, y, z);
+                    int teBlockId = BlockRenderingSettings.getCachedTeNbtId(packedPos, currentTick);
+
+                    if (teBlockId == BlockRenderingSettings.CACHE_MISS) {
+                        final TileEntity te = getBlockAccess().getTileEntity(x, y, z);
+                        if (te != null) {
+                            final NBTTagCompound teNbt = new NBTTagCompound();
+                            te.writeToNBT(teNbt);
+                            teBlockId = teMap.resolve(block, teNbt);
+                        } else {
+                            teBlockId = -1;
+                        }
+                        BlockRenderingSettings.cacheTeNbtId(packedPos, teBlockId, currentTick);
+                    }
+
+                    if (teBlockId != -1) {
+                        blockRenderContext.blockId = (short) teBlockId;
+                    }
+                }
             }
         }
 
@@ -294,7 +321,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
         }
     }
 
-    private void processDeferredBlocks(List<DeferredBlock> deferredBlocks, AngelicaChunkBuildContext buildContext, ChunkBuildBuffers buffers, IBlockAccess region, int minX, int minY, int minZ) {
+    private void processDeferredBlocks(List<DeferredBlock> deferredBlocks, AngelicaChunkBuildContext buildContext, ChunkBuildBuffers buffers, IBlockAccess region, int minX, int minY, int minZ, NbtConditionalIdMap<Block> teMap, long currentTick) {
 
         final BlockRenderContext blockRenderContext = buildContext.getBlockRenderContext();
 
@@ -308,7 +335,7 @@ public abstract class AngelicaChunkBuilderMeshingTask extends ChunkBuilderTask<C
                 for (DeferredBlock deferred : deferredBlocks) {
                     renderBlock(deferred.block(), deferred.meta(), deferred.x(), deferred.y(), deferred.z(), deferred.pass(),
                         mainTessellator, mainThreadRenderBlocks, buffers, buildContext,
-                        blockRenderContext, minX, minY, minZ, deferred.materialOverride(), deferred.isShaderPackOverride());
+                        blockRenderContext, minX, minY, minZ, deferred.materialOverride(), deferred.isShaderPackOverride(), teMap, currentTick);
                 }
             } finally {
                 ((StateAwareTessellator)mainTessellator).angelica$setCeleritasMeshing(false);

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

@@ -7,6 +7,8 @@ import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHold
 import com.gtnewhorizons.angelica.rendering.celeritas.threading.ChunkTaskProvider;
 import com.gtnewhorizons.angelica.rendering.celeritas.threading.ChunkTaskRegistry;
 import com.gtnewhorizons.angelica.rendering.celeritas.world.cloned.ClonedChunkSectionCache;
+import it.unimi.dsi.fastutil.longs.LongIterator;
+import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.multiplayer.WorldClient;
 import net.minecraft.client.renderer.texture.TextureAtlasSprite;
@@ -40,6 +42,7 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
     private final WorldClient world;
     private final ClonedChunkSectionCache sectionCache;
     private final ChunkTaskProvider taskProvider;
+    private final LongOpenHashSet biomeRebuildColumns = new LongOpenHashSet();
 
     public AngelicaRenderSectionManager(RenderPassConfiguration<?> configuration, WorldClient world, int renderDistance, CommandList commandList, int minSection, int maxSection, int requestedThreads, ChunkTaskProvider taskProvider) {
         super(configuration, () -> new AngelicaChunkBuildContext(configuration, world), AngelicaChunkRenderer::new, renderDistance, commandList, minSection, maxSection, requestedThreads, true  /* hasShadowPass = true for Iris */);
@@ -144,9 +147,35 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
         this.sectionCache.invalidate(section.getChunkX(), section.getChunkY(), section.getChunkZ());
     }
 
+    public void onBiomesChanged(int chunkX, int chunkZ) {
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dz = -1; dz <= 1; dz++) {
+                this.biomeRebuildColumns.add(PositionUtil.packChunk(chunkX + dx, chunkZ + dz));
+            }
+        }
+    }
+
+    private void flushBiomeRebuilds() {
+        if (this.biomeRebuildColumns.isEmpty()) {
+            return;
+        }
+        final int sectionCountY = this.world.getHeight() >> 4;
+        for (final LongIterator it = this.biomeRebuildColumns.iterator(); it.hasNext(); ) {
+            final long column = it.nextLong();
+            final int cx = PositionUtil.unpackChunkX(column);
+            final int cz = PositionUtil.unpackChunkZ(column);
+            for (int cy = 0; cy < sectionCountY; cy++) {
+                this.sectionCache.invalidate(cx, cy, cz);
+                this.scheduleRebuild(cx, cy, cz, false);
+            }
+        }
+        this.biomeRebuildColumns.clear();
+    }
+
     @Override
     public void updateChunks(boolean updateImmediately) {
         this.sectionCache.cleanup();
+        this.flushBiomeRebuilds();
         super.updateChunks(updateImmediately);
     }
 

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

@@ -1,6 +1,7 @@
 package com.gtnewhorizons.angelica.rendering.celeritas;
 
 import com.gtnewhorizons.angelica.config.AngelicaConfig;
+import com.gtnewhorizons.angelica.event.ChunkBiomeDataChangedEvent;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.loading.AngelicaClientTweaker;
 import org.embeddedt.embeddium.impl.gl.device.GLRenderDevice;
@@ -12,8 +13,16 @@ public class CeleritasSetup {
     public static void ensureInitialized() {
         if (!initialized && AngelicaConfig.enableCeleritas) {
             GLRenderDevice.VANILLA_STATE_RESETTER = () -> GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+            ChunkBiomeDataChangedEvent.BUS.addListener(CeleritasSetup::onChunkBiomeDataChanged);
             AngelicaClientTweaker.LOGGER.debug("Celeritas init");
             initialized = true;
         }
     }
+
+    private static void onChunkBiomeDataChanged(ChunkBiomeDataChangedEvent event) {
+        final CeleritasWorldRenderer renderer = CeleritasWorldRenderer.getInstanceOrNull();
+        if (renderer != null && renderer.isActive()) {
+            renderer.getRenderSectionManager().onBiomesChanged(event.chunkX, event.chunkZ);
+        }
+    }
 }

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

@@ -74,6 +74,10 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
         return instance;
     }
 
+    public static CeleritasWorldRenderer getInstanceOrNull() {
+        return instance;
+    }
+
     public AngelicaRenderSectionManager getRenderSectionManager() {
         return this.renderSectionManager;
     }
@@ -118,7 +122,16 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang
     protected ChunkRenderMatrices createChunkRenderMatrices() {
         final boolean shadowPass = renderSectionManager.isInShadowPass();
         final Matrix4f projection = shadowPass ? ShadowRenderer.PROJECTION : RenderingState.INSTANCE.getProjectionMatrix();
-        final Matrix4f modelView = shadowPass ? ShadowRenderer.MODELVIEW : RenderingState.INSTANCE.getModelViewMatrix();
+        Matrix4f modelView = shadowPass ? ShadowRenderer.MODELVIEW : RenderingState.INSTANCE.getModelViewMatrix();
+        if (!shadowPass) {
+            // Minecraft's setupCameraTransform bakes translate(0, -eyeHeight, 0) into the modelview.
+            // Chunk rendering passes eye position to drawChunkLayer so vertices arrive at
+            // the shader as (vert_world - eye).
+            final Entity view = mc.renderViewEntity;
+            if (view != null) {
+                modelView = new Matrix4f(modelView).translate(0f, view.getEyeHeight(), 0f);
+            }
+        }
         return new ChunkRenderMatrices(projection, modelView);
     }
 

src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/iris/IrisExtendedChunkVertexEncoder.java

@@ -26,6 +26,11 @@ public class IrisExtendedChunkVertexEncoder implements ContextAwareChunkVertexEn
     private static final int NORMAL_OFFSET = IrisExtendedChunkVertexType.VERTEX_FORMAT.getAttribute("iris_Normal").getPointer();
     private static final int MC_ENTITY_OFFSET = IrisExtendedChunkVertexType.VERTEX_FORMAT.getAttribute("mc_Entity").getPointer();
     private static final int MID_BLOCK_OFFSET = IrisExtendedChunkVertexType.VERTEX_FORMAT.getAttribute("at_midBlock").getPointer();
+    private static final int A_TEXCOORD_OFFSET = IrisExtendedChunkVertexType.VERTEX_FORMAT.getAttribute("a_TexCoord").getPointer();
+
+    // One unit of UV-space shift toward the quad centroid. Stops bilinear /
+    // mipmap sampling from bleeding pixels from neighboring atlas cells.
+    private static final float TEX_CENTROID_BIAS = 1.0f / 32768.0f;
 
     private final ChunkVertexEncoder baseEncoder = IrisExtendedChunkVertexType.BASE_TYPE.createEncoder();
     private final CeleritasQuadView quad = new CeleritasQuadView();
@@ -98,6 +103,14 @@ public class IrisExtendedChunkVertexEncoder implements ContextAwareChunkVertexEn
             memPutInt(ptr + MID_TEX_OFFSET - STRIDE * 2, midUV);
             memPutInt(ptr + MID_TEX_OFFSET - STRIDE * 3, midUV);
 
+            for (int vIdx = 0; vIdx < 4; vIdx++) {
+                final long uvBase = ptr - (long) (3 - vIdx) * STRIDE + A_TEXCOORD_OFFSET;
+                final float vU = memGetFloat(uvBase);
+                final float vV = memGetFloat(uvBase + 4L);
+                memPutFloat(uvBase, vU + (vU < midU ? TEX_CENTROID_BIAS : -TEX_CENTROID_BIAS));
+                memPutFloat(uvBase + 4L, vV + (vV < midV ? TEX_CENTROID_BIAS : -TEX_CENTROID_BIAS));
+            }
+
             quad.setup(ptr, STRIDE);
             NormalHelper.computeFaceNormal(normal, quad);
             final int packedNormal = NormI8.pack(normal);

src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/cloned/ClonedChunkSection.java

@@ -1,6 +1,5 @@
 package com.gtnewhorizons.angelica.rendering.celeritas.world.cloned;
 
-import com.falsepattern.endlessids.mixin.helpers.ChunkBiomeHook;
 import com.gtnewhorizons.angelica.api.BlockLightProvider;
 import com.gtnewhorizons.angelica.api.SectionLightData;
 import com.gtnewhorizons.angelica.compat.ExtendedBlockStorageExt;
@@ -20,6 +19,7 @@ import net.minecraft.world.ChunkPosition;
 import net.minecraft.world.EnumSkyBlock;
 import net.minecraft.world.World;
 import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraft.world.biome.WorldChunkManager;
 import net.minecraft.world.chunk.Chunk;
 import net.minecraft.world.chunk.NibbleArray;
 import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
@@ -62,50 +62,51 @@ public class ClonedChunkSection {
         this.pos = pos;
         this.data = new ExtendedBlockStorageExt(chunk, section);
 
-        final int bArrLength;
-        if (ModStatus.isEIDBiomeLoaded) {
-            bArrLength = ((ChunkBiomeHook) chunk).getBiomeShortArray().length;
-        } else {
-            bArrLength = chunk.getBiomeArray().length;
-        }
-        this.biomeData = new BiomeGenBase[bArrLength];
+        this.biomeData = new BiomeGenBase[16 * 16];
 
         copyBlockEntities(chunk, pos);
 
-        // Fill biome data
-        for (int z = pos.getMinZ(); z <= pos.getMaxZ(); z++) {
-            for (int x = pos.getMinX(); x <= pos.getMaxX(); x++) {
-                this.biomeData[(x & 15) | ((z & 15) << 4)] = world.getBiomeGenForCoords(x, z);
-            }
-        }
+        fillBiomeData(chunk);
 
         this.sectionLightData = BlockLightProvider.getInstance().prepareSectionData(chunk, pos.y);
     }
 
+    private void fillBiomeData(Chunk chunk) {
+        final WorldChunkManager wcm = world.getWorldChunkManager();
+        for (int lz = 0; lz < 16; lz++) {
+            for (int lx = 0; lx < 16; lx++) {
+                this.biomeData[lx | (lz << 4)] = chunk.getBiomeGenForWorldCoords(lx, lz, wcm);
+            }
+        }
+    }
+
     @SuppressWarnings("unchecked")
     private void copyBlockEntities(Chunk chunk, ChunkSectionPos pos) {
         this.tileEntities.clear();
 
         final ConcurrentTileEntityMap map = ((IChunkTileEntityMapHolder) chunk).angelica$getConcurrentTEMap();
 
-        map.withReadLock(() -> {
+        map.readLock();
+        try {
             final Object2ObjectOpenHashMap<ChunkPosition, TileEntity> delegate = map.getDelegate();
 
-            if (delegate.isEmpty()) return;
+            if (!delegate.isEmpty()) {
+                final int minY = pos.getMinY();
+                final int maxY = pos.getMaxY();
 
-            final int minY = pos.getMinY();
-            final int maxY = pos.getMaxY();
+                for (Object2ObjectMap.Entry<ChunkPosition, TileEntity> entry : Object2ObjectMaps.fastIterable(delegate)) {
+                    final ChunkPosition tePos = entry.getKey();
+                    if (tePos.chunkPosY < minY || tePos.chunkPosY > maxY) continue;
 
-            for (Object2ObjectMap.Entry<ChunkPosition, TileEntity> entry : Object2ObjectMaps.fastIterable(delegate)) {
-                final ChunkPosition tePos = entry.getKey();
-                if (tePos.chunkPosY < minY || tePos.chunkPosY > maxY) continue;
-
-                final TileEntity te = entry.getValue();
-                if (te != null && !te.isInvalid()) {
-                    this.tileEntities.put(ChunkSectionPos.packLocal(tePos.chunkPosX & 15, tePos.chunkPosY & 15, tePos.chunkPosZ & 15), te);
+                    final TileEntity te = entry.getValue();
+                    if (te != null && !te.isInvalid()) {
+                        this.tileEntities.put(ChunkSectionPos.packLocal(tePos.chunkPosX & 15, tePos.chunkPosY & 15, tePos.chunkPosZ & 15), te);
+                    }
                 }
             }
-        });
+        } finally {
+            map.readUnlock();
+        }
 
         this.tileEntities.trim();
     }

src/main/java/com/gtnewhorizons/angelica/rendering/celeritas/world/cloned/ClonedChunkSectionCache.java

@@ -21,7 +21,13 @@ public class ClonedChunkSectionCache {
 
     public synchronized void cleanup() {
         this.time = getMonotonicTimeSource();
-        this.byPosition.values().removeIf(entry -> this.time > (entry.getLastUsedTimestamp() + MAX_CACHE_DURATION));
+        while (!this.byPosition.isEmpty()) {
+            final ClonedChunkSection oldest = this.byPosition.get(this.byPosition.firstLongKey());
+            if (this.time <= oldest.getLastUsedTimestamp() + MAX_CACHE_DURATION) {
+                break;
+            }
+            this.byPosition.removeFirst();
+        }
     }
 
     public synchronized ClonedChunkSection acquire(int x, int y, int z) {
@@ -32,18 +38,17 @@ public class ClonedChunkSectionCache {
             while (this.byPosition.size() >= MAX_CACHE_SIZE) {
                 this.byPosition.removeFirst();
             }
-            section = this.createSection(x, y, z);
+            section = this.createSection(key, x, y, z);
         }
 
         section.setLastUsedTimestamp(this.time);
         return section;
     }
 
-    private ClonedChunkSection createSection(int x, int y, int z) {
+    private ClonedChunkSection createSection(long key, int x, int y, int z) {
         final ClonedChunkSection section = new ClonedChunkSection(this, this.world);
-        final ChunkSectionPos pos = ChunkSectionPos.from(x, y, z);
-        section.init(pos);
-        this.byPosition.putAndMoveToLast(pos.asLong(), section);
+        section.init(ChunkSectionPos.from(x, y, z));
+        this.byPosition.putAndMoveToLast(key, section);
         return section;
     }
 

src/main/java/com/gtnewhorizons/angelica/utils/ConcurrentTileEntityMap.java

@@ -42,6 +42,14 @@ public class ConcurrentTileEntityMap implements Map<ChunkPosition, TileEntity> {
         }
     }
 
+    public void readLock() {
+        lock.readLock().lock();
+    }
+
+    public void readUnlock() {
+        lock.readLock().unlock();
+    }
+
     public void withWriteLock(Runnable action) {
         lock.writeLock().lock();
         try {

src/main/java/me/jellysquid/mods/sodium/client/gui/SodiumGameOptionPages.java

@@ -540,56 +540,63 @@ public class SodiumGameOptionPages {
 
         groups.add(OptionGroup.createBuilder()
                 .add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
-                        .setName("RGB Colors")
-                        .setTooltip("Enable hex colors via &#RRGGBB syntax")
+                        .setName(I18n.format("options.angelica.texteffects.rgb_colors"))
+                        .setTooltip(I18n.format("options.angelica.texteffects.rgb_colors.tooltip", "\\&#RRGGBB"))
                         .setControl(TickBoxControl::new)
                         .setBinding((opts, value) -> AngelicaConfig.enableRGBColors = value,
                                     opts -> AngelicaConfig.enableRGBColors)
                         .build())
                 .add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
-                        .setName("Gradients")
-                        .setTooltip("Smooth color transitions via &g&#start&#end")
+                        .setName(I18n.format("options.angelica.texteffects.gradients"))
+                        .setTooltip(I18n.format("options.angelica.texteffects.gradients.tooltip") + " \\&g\\&#start\\&#end")
                         .setControl(TickBoxControl::new)
                         .setBinding((opts, value) -> AngelicaConfig.enableGradients = value,
                                     opts -> AngelicaConfig.enableGradients)
                         .build())
                 .add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
-                        .setName("Rainbow")
-                        .setTooltip("Cycling rainbow colors via &q")
+                        .setName(I18n.format("options.angelica.texteffects.rainbow"))
+                        .setTooltip(I18n.format("options.angelica.texteffects.rainbow.tooltip") + " \\&q")
                         .setControl(TickBoxControl::new)
                         .setBinding((opts, value) -> AngelicaConfig.enableRainbow = value,
                                     opts -> AngelicaConfig.enableRainbow)
                         .build())
                 .add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
-                        .setName("Wave Text")
-                        .setTooltip("Animated bouncing text via &z")
+                        .setName(I18n.format("options.angelica.texteffects.wave_text"))
+                        .setTooltip(I18n.format("options.angelica.texteffects.wave_text.tooltip") + " \\&z")
                         .setControl(TickBoxControl::new)
                         .setBinding((opts, value) -> AngelicaConfig.enableWaveText = value,
                                     opts -> AngelicaConfig.enableWaveText)
                         .build())
                 .add(OptionImpl.createBuilder(int.class, angelicaOpts)
-                        .setName("Wave Amplitude")
-                        .setTooltip("How far wave text bounces (default 2.0)")
+                        .setName(I18n.format("options.angelica.texteffects.wave_amplitude"))
+                        .setTooltip(I18n.format("options.angelica.texteffects.wave_amplitude.tooltip"))
                         .setControl(option -> new SliderControl(option, 10, 80, 5, v -> (v / 10) + "." + (v % 10)))
                         .setBinding((opts, value) -> AngelicaConfig.waveAmplitude = value / 10f, opts -> Math.round(AngelicaConfig.waveAmplitude * 10f))
                         .build())
                 .add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
-                        .setName("Dinnerbone Text")
-                        .setTooltip("Flipped upside down text via &v")
+                        .setName(I18n.format("options.angelica.texteffects.dinnerbone_text"))
+                        .setTooltip(I18n.format("options.angelica.texteffects.dinnerbone_text.tooltip") + " \\&v")
                         .setControl(TickBoxControl::new)
                         .setBinding((opts, value) -> AngelicaConfig.enableDinnerboneText = value,
                                     opts -> AngelicaConfig.enableDinnerboneText)
                         .build())
                 .add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
-                        .setName("Ampersand Conversion")
-                        .setTooltip("Convert & prefix codes to formatting codes at render time")
+                        .setName(I18n.format("options.angelica.texteffects.drop_shadow"))
+                        .setTooltip(I18n.format("options.angelica.texteffects.drop_shadow.tooltip", "\\&u") + " \\&u\\&#RRGGBB")
+                        .setControl(TickBoxControl::new)
+                        .setBinding((opts, value) -> AngelicaConfig.enableDropShadow = value,
+                                    opts -> AngelicaConfig.enableDropShadow)
+                        .build())
+                .add(OptionImpl.createBuilder(boolean.class, angelicaOpts)
+                        .setName(I18n.format("options.angelica.texteffects.ampersand_conversion"))
+                        .setTooltip(I18n.format("options.angelica.texteffects.ampersand_conversion.tooltip", "\\&"))
                         .setControl(TickBoxControl::new)
                         .setBinding((opts, value) -> AngelicaConfig.enableAmpersandConversion = value,
                                     opts -> AngelicaConfig.enableAmpersandConversion)
                         .build())
                 .build());
 
-        return new OptionPage("Text Effects", ImmutableList.copyOf(groups));
+        return new OptionPage(I18n.format("sodium.options.pages.text"), ImmutableList.copyOf(groups));
     }
 
 }

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

@@ -23,26 +23,33 @@ import java.util.Set;
 
 public class BlockMaterialMapping {
 
+	public record BlockIdMaps(Reference2ObjectMap<Block, Int2IntMap> blockMetaMap, NbtConditionalIdMap<Block> tileEntityMap) {}
+
 	/** Meta-key bit OR'd in at runtime when a snowy-tagged block has snow above it. */
 	public static final int SNOWY_META_BIT = 0x10;
 
 	/**
-	 * Creates a two-level map structure for block material IDs.
-	 * Based on Iris's BlockState mapping approach adapted for 1.7.10's metadata system.
+	 * Creates the standard block meta ID map, the TileEntity NBT-conditional map, and registers
+	 * snowy blocks on {@link BlockRenderingSettings}.
 	 */
-	public static Reference2ObjectMap<Block, Int2IntMap> createBlockMetaIdMap(Int2ObjectMap<List<BlockEntry>> blockPropertiesMap, boolean skipFlattening) {
+	public static BlockIdMaps createBlockIdMaps(Int2ObjectMap<List<BlockEntry>> blockPropertiesMap, boolean skipFlattening) {
 		final Reference2ObjectMap<Block, Int2IntMap> blockMatches = new Reference2ObjectOpenHashMap<>();
+		final NbtConditionalIdMap<Block> tileEntityMap = new NbtConditionalIdMap<>();
 		final ReferenceSet<Block> snowyBlocks = new ReferenceOpenHashSet<>();
 
 		blockPropertiesMap.forEach((intId, entries) -> {
 			for (BlockEntry entry : entries) {
-				addBlockMetas(entry, blockMatches, intId, skipFlattening, snowyBlocks);
+				if (entry.hasNbtProperties()) {
+					addTileEntityEntry(entry, tileEntityMap, intId);
+				} else {
+					addBlockMetas(entry, blockMatches, tileEntityMap, intId, skipFlattening, snowyBlocks);
+				}
 			}
 		});
 
 		BlockRenderingSettings.INSTANCE.setHasSnowyEntries(!snowyBlocks.isEmpty());
 		BlockRenderingSettings.INSTANCE.setSnowyBlocks(snowyBlocks);
-		return blockMatches;
+		return new BlockIdMaps(blockMatches, tileEntityMap);
 	}
 
 	public static Map<Block, BlockRenderLayer> createBlockTypeMap(Map<NamespacedId, BlockRenderType> blockPropertiesMap) {
@@ -55,7 +62,8 @@ public class BlockMaterialMapping {
 			if (block == null && "minecraft".equals(id.getNamespace())) {
 				final List<BlockEntry> legacyEntries = FlatteningMap.toLegacy(id.getName(), Map.of());
 				if (legacyEntries != null) {
-					block = resolveBlockOrNull(legacyEntries.getFirst().getId());
+					// Use the first entry for render type (render type applies per-block)
+					block = resolveBlockOrNull(legacyEntries.getFirst().id());
 				}
 			}
 
@@ -80,28 +88,64 @@ public class BlockMaterialMapping {
 		};
 	}
 
+	/**
+	 * Creates an NBT-conditional ID map keyed by NamespacedId, for items or entities.
+	 */
+	public static NbtConditionalIdMap<NamespacedId> createNamespacedNbtMap(Int2ObjectMap<List<BlockEntry>> nbtEntries) {
+		NbtConditionalIdMap<NamespacedId> map = new NbtConditionalIdMap<>();
+
+		nbtEntries.forEach((intId, entries) -> {
+			for (BlockEntry entry : entries) {
+				if (entry.hasNbtProperties()) {
+					map.addCondition(entry.id(), entry.nbtProperties(), intId);
+				}
+			}
+		});
+
+		return map;
+	}
+
+	private static void addTileEntityEntry(BlockEntry entry, NbtConditionalIdMap<Block> teMap, int intId) {
+		final NamespacedId id = entry.id();
+		final ResourceLocation resourceLocation = new ResourceLocation(id.getNamespace(), id.getName());
+
+		final Block block = (Block) Block.blockRegistry.getObject(resourceLocation.toString());
+
+		if (block == null || block == Blocks.air) {
+			return;
+		}
+
+		teMap.addCondition(block, entry.nbtProperties(), intId);
+	}
+
 	/**
 	 * Adds block+metadata combinations to the material ID map.
 	 * Based on Iris's addBlockStates method, adapted for 1.7.10 metadata system.
 	 */
-	private static void addBlockMetas(BlockEntry entry, Reference2ObjectMap<Block, Int2IntMap> idMap, int intId, boolean skipFlattening, ReferenceSet<Block> snowyBlocks) {
-		final NamespacedId id = entry.getId();
-		final Map<String, String> stateProps = entry.getStateProperties();
+	private static void addBlockMetas(BlockEntry entry, Reference2ObjectMap<Block, Int2IntMap> idMap,
+									  NbtConditionalIdMap<Block> tileEntityMap, int intId,
+									  boolean skipFlattening, ReferenceSet<Block> snowyBlocks) {
+		final NamespacedId id = entry.id();
+		final Map<String, String> stateProps = entry.stateProperties();
 		final String snowy = stateProps.get("snowy");
 		final int snowyBit = "true".equals(snowy) ? SNOWY_META_BIT : 0;
 
 		// Vanilla modern names go through FlatteningMap; legacy-section packs and modded blocks
 		// resolve directly from the registry.
 		List<BlockEntry> targets = null;
-		if (!skipFlattening && "minecraft".equals(id.getNamespace()) && (!stateProps.isEmpty() || entry.getMetas().isEmpty())) {
+		if (!skipFlattening && "minecraft".equals(id.getNamespace()) && (!stateProps.isEmpty() || entry.metas().isEmpty())) {
 			targets = FlatteningMap.toLegacy(id.getName(), stateProps);
 		}
 		if (targets == null) targets = List.of(entry);
 
 		for (BlockEntry target : targets) {
-			final Block block = resolveBlockOrNull(target.getId());
+			if (target.hasNbtProperties()) {
+				addTileEntityEntry(target, tileEntityMap, intId);
+				continue;
+			}
+			final Block block = resolveBlockOrNull(target.id());
 			if (block == null) continue;
-			applyMetas(block, target.getMetas(), idMap, intId, snowyBit);
+			applyMetas(block, target.metas(), idMap, intId, snowyBit);
 			if (snowy != null) snowyBlocks.add(block);
 		}
 	}

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

@@ -2,6 +2,7 @@ package net.coderbot.iris.block_rendering;
 
 import com.gtnewhorizons.angelica.rendering.celeritas.BlockRenderLayer;
 import it.unimi.dsi.fastutil.ints.Int2IntMap;
+import it.unimi.dsi.fastutil.longs.Long2LongLinkedOpenHashMap;
 import it.unimi.dsi.fastutil.objects.Object2IntFunction;
 import it.unimi.dsi.fastutil.objects.Reference2ObjectMap;
 import it.unimi.dsi.fastutil.objects.ReferenceSet;
@@ -18,16 +19,76 @@ import java.util.Map;
 public class BlockRenderingSettings {
 	public static final BlockRenderingSettings INSTANCE = new BlockRenderingSettings();
 
+	public static final int CACHE_MISS = Integer.MIN_VALUE;
+
+	private static final int NBT_CACHE_INTERVAL_TICKS = 20;
+	private static final int TE_NBT_CACHE_MAX = 8192;
+
+	private static final Long2LongLinkedOpenHashMap teNbtIdCache = new Long2LongLinkedOpenHashMap(256);
+	private static final Object teNbtIdCacheLock = new Object();
+
+	static {
+		teNbtIdCache.defaultReturnValue(-1L);
+	}
+
+	public static long packBlockPos(int x, int y, int z) {
+		return ((long) x & 0x3FFFFFFL) << 38 | ((long) y & 0xFFFL) << 26 | ((long) z & 0x3FFFFFFL);
+	}
+
+	public static void invalidateTeNbtCache(int x, int y, int z) {
+		final long key = packBlockPos(x, y, z);
+		synchronized (teNbtIdCacheLock) {
+			teNbtIdCache.remove(key);
+		}
+	}
+
+	public static int getCachedTeNbtId(long packedPos, long currentTick) {
+		final long entry;
+		synchronized (teNbtIdCacheLock) {
+			entry = teNbtIdCache.get(packedPos);
+		}
+		if (entry == -1L) {
+			return CACHE_MISS;
+		}
+		final long entryTick = entry >>> 32;
+		if (currentTick - entryTick >= NBT_CACHE_INTERVAL_TICKS) {
+			return CACHE_MISS;
+		}
+		return (int) entry;
+	}
+
+	public static void cacheTeNbtId(long packedPos, int shaderId, long currentTick) {
+		// Mask tick into low 31 bits so packed value never collides with the -1L sentinel.
+		final long packed = ((currentTick & 0x7FFFFFFFL) << 32) | (shaderId & 0xFFFFFFFFL);
+		synchronized (teNbtIdCacheLock) {
+			teNbtIdCache.put(packedPos, packed);
+			while (teNbtIdCache.size() > TE_NBT_CACHE_MAX) {
+				teNbtIdCache.removeFirstLong();
+			}
+		}
+	}
+
+	public static void clearTeNbtCache() {
+		synchronized (teNbtIdCacheLock) {
+			teNbtIdCache.clear();
+		}
+	}
+
 	@Getter
     private boolean reloadRequired;
 	private Reference2ObjectMap<Block, Int2IntMap> blockMetaMatches;
+	private NbtConditionalIdMap<Block> blockNbtMap;
 	private Map<Block, BlockRenderLayer> blockTypeIds;
     // note: no reload needed, entities are rebuilt every frame.
     @Setter
     private Object2IntFunction<NamespacedId> entityIds;
+	@Setter
+    private NbtConditionalIdMap<NamespacedId> entityNbtMap;
     // note: no reload needed, items are rendered every frame.
     @Setter
     private Object2IntFunction<NamespacedId> itemIds;
+	@Setter
+    private NbtConditionalIdMap<NamespacedId> itemNbtMap;
 	@Getter
     private float ambientOcclusionLevel;
 	private boolean disableDirectionalShading;
@@ -41,6 +102,7 @@ public class BlockRenderingSettings {
 	public BlockRenderingSettings() {
 		reloadRequired = false;
 		blockMetaMatches = null;
+		blockNbtMap = null;
 		blockTypeIds = null;
 		ambientOcclusionLevel = 1.0F;
 		disableDirectionalShading = false;
@@ -82,11 +144,32 @@ public class BlockRenderingSettings {
 		return itemIds;
 	}
 
+	@Nullable
+	public NbtConditionalIdMap<Block> getBlockNbtMap() {
+		return blockNbtMap;
+	}
+
+	@Nullable
+	public NbtConditionalIdMap<NamespacedId> getItemNbtMap() {
+		return itemNbtMap;
+	}
+
+	@Nullable
+	public NbtConditionalIdMap<NamespacedId> getEntityNbtMap() {
+		return entityNbtMap;
+	}
+
 	public void setBlockMetaMatches(Reference2ObjectMap<Block, Int2IntMap> blockMetaIds) {
 		this.reloadRequired = true;
 		this.blockMetaMatches = blockMetaIds;
 	}
 
+	public void setBlockNbtMap(NbtConditionalIdMap<Block> blockNbtMap) {
+		this.reloadRequired = true;
+		this.blockNbtMap = blockNbtMap;
+		clearTeNbtCache();
+	}
+
 	public boolean hasSnowyEntries() {
 		return hasSnowyEntries;
 	}

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

@@ -0,0 +1,233 @@
+package net.coderbot.iris.block_rendering;
+
+import net.coderbot.iris.Iris;
+import net.coderbot.iris.shaderpack.materialmap.PropertiesTokenizer;
+import net.minecraft.block.Block;
+import net.minecraft.item.Item;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Maps objects with specific NBT properties to shader IDs. Generic over the
+ * key type so it works for blocks, items, and entities.
+ *
+ * Example:
+ *   block.37=flower_pot[Item=minecraft:red_flower,Data=0]
+ *   item.10=diamond_sword[display.Name='Pointy Stick']
+ */
+public class NbtConditionalIdMap<K> {
+
+    /**
+     * A single property matcher within a condition.
+     */
+    record PropertyMatcher(String key, String[] path, String expectedValue,
+                           long expectedLong, boolean isExpectedLong,
+                           double expectedDouble, boolean isExpectedDouble) {
+        boolean isPathMatch() { return path != null; }
+        boolean isExistenceOnly() { return expectedValue == null; }
+    }
+
+    record NbtCondition(PropertyMatcher[] matchers, int shaderId) {}
+
+    private final Map<K, List<NbtCondition>> conditionsByKey;
+
+    public NbtConditionalIdMap() {
+        this.conditionsByKey = new HashMap<>();
+    }
+
+    /**
+     * Registers an NBT condition. Unquoted values are resolved via item/block
+     * registries at registration time. Single-quoted values are kept as literals.
+     * Dot notation paths are pre-split here so we prevent allocations.
+     */
+    public void addCondition(K key, Map<String, PropertiesTokenizer.NbtValue> nbtProperties, int shaderId) {
+        final PropertyMatcher[] matchers = new PropertyMatcher[nbtProperties.size()];
+        int i = 0;
+
+        for (Map.Entry<String, PropertiesTokenizer.NbtValue> entry : nbtProperties.entrySet()) {
+            final String nbtKey = entry.getKey();
+            final PropertiesTokenizer.NbtValue nbtValue = entry.getValue();
+
+            final String resolvedValue;
+            if (nbtValue == null) {
+                resolvedValue = null;
+
+            } else if (nbtValue.literal()) {
+                resolvedValue = nbtValue.value();
+
+            } else {
+                resolvedValue = resolveValue(nbtValue.value());
+            }
+
+            final String[] path = nbtKey.contains(".") ? nbtKey.split("\\.") : null;
+
+            long expectedLong = 0;
+            boolean isExpectedLong = false;
+            double expectedDouble = 0;
+            boolean isExpectedDouble = false;
+            if (resolvedValue != null) {
+                try {
+                    expectedLong = Long.parseLong(resolvedValue);
+                    isExpectedLong = true;
+                } catch (NumberFormatException ignored) {}
+                try {
+                    expectedDouble = Double.parseDouble(resolvedValue);
+                    isExpectedDouble = true;
+                } catch (NumberFormatException ignored) {}
+            }
+
+            matchers[i++] = new PropertyMatcher(nbtKey, path, resolvedValue,
+                expectedLong, isExpectedLong, expectedDouble, isExpectedDouble);
+        }
+
+        conditionsByKey.computeIfAbsent(key, k -> new ArrayList<>())
+            .add(new NbtCondition(matchers, shaderId));
+    }
+
+    public boolean hasConditions(K key) {
+        return conditionsByKey.containsKey(key);
+    }
+
+    public boolean isEmpty() {
+        return conditionsByKey.isEmpty();
+    }
+
+    /**
+     * Resolves the shader ID by matching the provided NBT data.
+     */
+    public int resolve(K key, NBTTagCompound nbt) {
+        final List<NbtCondition> conditions = conditionsByKey.get(key);
+        if (conditions == null) {
+            return -1;
+        }
+
+        for (NbtCondition condition : conditions) {
+            if (matchesNbt(nbt, condition.matchers())) {
+                return condition.shaderId;
+            }
+        }
+
+        return -1;
+    }
+
+    private static boolean matchesNbt(NBTTagCompound nbt, PropertyMatcher[] matchers) {
+        for (PropertyMatcher matcher : matchers) {
+            if (matcher.isPathMatch()) {
+                if (!matchesPath(nbt, matcher.path(), 0, matcher)) {
+                    return false;
+                }
+
+            } else {
+                if (!nbt.hasKey(matcher.key())) {
+                    return false;
+                }
+
+                if (!matcher.isExistenceOnly()) {
+                    if (!matchesNbtValue(nbt.getTag(matcher.key()), matcher)) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    /**
+     * Search through dot-separated path in NBT data.
+     */
+    private static boolean matchesPath(NBTBase tag, String[] path, int depth, PropertyMatcher matcher) {
+        if (depth == path.length) {
+            if (matcher.isExistenceOnly()) {
+                return true;
+            }
+
+            return matchesNbtValue(tag, matcher);
+        }
+
+        final String segment = path[depth];
+
+        if (tag instanceof NBTTagCompound compound) {
+            if (!compound.hasKey(segment)) {
+                return false;
+            }
+
+            return matchesPath(compound.getTag(segment), path, depth + 1, matcher);
+        }
+
+        if (tag instanceof NBTTagList list) {
+            for (int i = 0; i < list.tagCount(); i++) {
+                if (matchesPath(list.getCompoundTagAt(i), path, depth, matcher)) {
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        return false;
+    }
+
+    /**
+     * Compares an NBT tag's value against an expected string using type-specific
+     * accessors to avoid toString() allocations where possible.
+     * Makes it so you don't need to specify the type either in the .properties files.
+     */
+    private static boolean matchesNbtValue(NBTBase tag, PropertyMatcher matcher) {
+        return switch (tag.getId()) {
+            case 1 -> // TAG_Byte
+                matcher.isExpectedLong() && ((net.minecraft.nbt.NBTTagByte) tag).func_150290_f() == matcher.expectedLong();
+            case 2 -> // TAG_Short
+                matcher.isExpectedLong() && ((net.minecraft.nbt.NBTTagShort) tag).func_150289_e() == matcher.expectedLong();
+            case 3 -> // TAG_Int
+                matcher.isExpectedLong() && ((net.minecraft.nbt.NBTTagInt) tag).func_150287_d() == matcher.expectedLong();
+            case 4 -> // TAG_Long
+                matcher.isExpectedLong() && ((net.minecraft.nbt.NBTTagLong) tag).func_150291_c() == matcher.expectedLong();
+            case 5 -> // TAG_Float
+                matcher.isExpectedDouble() && ((net.minecraft.nbt.NBTTagFloat) tag).func_150288_h() == (float) matcher.expectedDouble();
+            case 6 -> // TAG_Double
+                matcher.isExpectedDouble() && ((net.minecraft.nbt.NBTTagDouble) tag).func_150286_g() == matcher.expectedDouble();
+            case 8 -> // TAG_String
+                matcher.expectedValue().equals(((net.minecraft.nbt.NBTTagString) tag).func_150285_a_());
+            default -> // Compounds, lists, arrays — fall back to toString
+                matcher.expectedValue().equals(PropertiesTokenizer.stripQuotes(tag.toString()));
+        };
+    }
+
+    /**
+     * Tries to resolve a value as a registry name (item or block) to its numeric ID.
+     * If the value is already numeric or can't be resolved, return it unchanged.
+     */
+    private static String resolveValue(String value) {
+        try {
+            Integer.parseInt(value);
+            return value;
+        } catch (NumberFormatException ignored) {}
+
+        if (!value.contains(":")) {
+            Iris.logger.warn("NBT value '{}' is missing a namespace, please use the full form e.g. 'minecraft:{}'", value, value);
+            return value;
+        }
+
+        final ResourceLocation loc = new ResourceLocation(value);
+
+        final Item item = (Item) Item.itemRegistry.getObject(loc.toString());
+        if (item != null) {
+            return String.valueOf(Item.getIdFromItem(item));
+        }
+
+        final Block block = (Block) Block.blockRegistry.getObject(loc.toString());
+        if (block != null) {
+            return String.valueOf(Block.getIdFromBlock(block));
+        }
+
+        Iris.logger.warn("Could not resolve '{}' to an item or block ID", value);
+        return value;
+    }
+}

src/main/java/net/coderbot/iris/gbuffer_overrides/matching/RenderCondition.java

@@ -18,6 +18,7 @@ public enum RenderCondition {
 	HAND_TRANSLUCENT,
 	RAIN_SNOW,
 	WORLD_BORDER,
+	LIGHTNING,
 	SHADOW_TRANSLUCENT,
 	// NB: Must be last due to implementation details of DeferredWorldRenderingPipeline
 	SHADOW

src/main/java/net/coderbot/iris/gbuffer_overrides/matching/SpecialCondition.java

@@ -3,5 +3,6 @@ package net.coderbot.iris.gbuffer_overrides.matching;
 public enum SpecialCondition {
 	ENTITY_EYES,
 	BEACON_BEAM,
-	GLINT
+	GLINT,
+	LIGHTNING
 }

src/main/java/net/coderbot/iris/gl/buffer/ShaderStorageBuffer.java

@@ -2,16 +2,16 @@ package net.coderbot.iris.gl.buffer;
 
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.RenderSystem;
+import lombok.Getter;
 import org.embeddedt.embeddium.impl.gl.debug.GLDebug;
 import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL15;
 import org.lwjgl.opengl.GL30;
 import org.lwjgl.opengl.GL43;
 
 public class ShaderStorageBuffer {
 	protected final int index;
 	protected final ShaderStorageInfo info;
-	protected int id;
+	@Getter protected int id;
 
 	public ShaderStorageBuffer(int index, ShaderStorageInfo info) {
 		this.id = RenderSystem.createBuffers();
@@ -45,16 +45,13 @@ public class ShaderStorageBuffer {
 		GLStateManager.glBindBuffer(GL43.GL_SHADER_STORAGE_BUFFER, newId);
 
 		// Calculation time
-		int newWidth = (int) (width * info.scaleX());
-		int newHeight = (int) (height * info.scaleY());
-		int finalSize = (newHeight * newWidth) * info.size();
+		long newWidth = (long) (width * info.scaleX());
+		long newHeight = (long) (height * info.scaleY());
+		long finalSize = (newHeight * newWidth) * info.size();
 		RenderSystem.bufferStorage(GL43.GL_SHADER_STORAGE_BUFFER, finalSize, 0);
 		RenderSystem.clearBufferSubData(GL43.GL_SHADER_STORAGE_BUFFER, GL30.GL_R8, 0, finalSize, GL11.GL_RED, GL11.GL_BYTE, new int[]{0});
 		RenderSystem.bindBufferBase(GL43.GL_SHADER_STORAGE_BUFFER, index, newId);
 		id = newId;
 	}
 
-	public int getId() {
-		return id;
-	}
 }

src/main/java/net/coderbot/iris/gl/buffer/ShaderStorageInfo.java

@@ -1,4 +1,4 @@
 package net.coderbot.iris.gl.buffer;
 
-public record ShaderStorageInfo(int size, boolean relative, float scaleX, float scaleY) {
+public record ShaderStorageInfo(long size, boolean relative, float scaleX, float scaleY) {
 }

src/main/java/net/coderbot/iris/gl/program/Program.java

@@ -4,15 +4,18 @@ import lombok.Getter;
 import net.coderbot.iris.gl.GlResource;
 import net.coderbot.iris.gl.blending.DepthColorStorage;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.RenderSystem;
+import org.lwjgl.opengl.GL42;
+import org.lwjgl.opengl.GL43;
 
 public final class Program extends GlResource {
-	
+
 	@Getter
 	private final ProgramUniforms uniforms;
-	
+
 	@Getter
 	private final ProgramSamplers samplers;
-	
+
 	@Getter
 	private final ProgramImages images;
 
@@ -25,15 +28,16 @@ public final class Program extends GlResource {
 
 		DepthColorStorage.registerOwnedProgram(program);
 	}
-	
+
 	public void use() {
+		RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT | GL43.GL_SHADER_STORAGE_BARRIER_BIT);
 		GLStateManager.glUseProgram(getGlId());
-		
+
 		uniforms.update();
 		samplers.update();
 		images.update();
 	}
-	
+
 	public static void unbind() {
 		ProgramUniforms.clearActiveUniforms();
 		ProgramSamplers.clearActiveSamplers();
@@ -45,7 +49,7 @@ public final class Program extends GlResource {
 		DepthColorStorage.unregisterOwnedProgram(getGlId());
 		GLStateManager.glDeleteProgram(getGlId());
 	}
-	
+
 	public int getProgramId() {
 		return getGlId();
 	}

src/main/java/net/coderbot/iris/gl/shader/StandardMacros.java

@@ -8,6 +8,7 @@ import net.coderbot.iris.compat.dh.DHCompat;
 import net.coderbot.iris.parsing.BiomeCategories;
 import net.coderbot.iris.pipeline.HandRenderer;
 import net.coderbot.iris.pipeline.WorldRenderingPhase;
+import net.coderbot.iris.shaderpack.IrisLimits;
 import net.coderbot.iris.shaderpack.StringPair;
 import net.coderbot.iris.texture.format.TextureFormat;
 import net.coderbot.iris.texture.format.TextureFormatLoader;
@@ -81,6 +82,9 @@ public class StandardMacros {
 		define(standardDefines, "IS_ANGELICA");
 		if (AngelicaConfig.defineIsIris) {
 			define(standardDefines, "IS_IRIS");
+			define(standardDefines, "IRIS_VERSION", "10803");
+			define(standardDefines, "IRIS_HAS_TRANSLUCENCY_SORTING");
+			define(standardDefines, "MAX_COLOR_BUFFERS", String.valueOf(IrisLimits.MAX_COLOR_BUFFERS));
 		}
 
 		if (DHCompat.hasRenderingEnabled()) {

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

@@ -11,6 +11,7 @@ public class StateUpdateNotifiers {
     public static ValueUpdateNotifier alphaFuncNotifier;
     public static ValueUpdateNotifier alphaTestNotifier;
 	public static ValueUpdateNotifier blendFuncNotifier;
+	public static ValueUpdateNotifier colorModulatorNotifier;
 	public static ValueUpdateNotifier bindTextureNotifier;
 	public static ValueUpdateNotifier normalTextureChangeNotifier;
 	public static ValueUpdateNotifier specularTextureChangeNotifier;

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

@@ -90,6 +90,7 @@ import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL13;
 import org.lwjgl.opengl.GL30;
 import org.lwjgl.opengl.GL42;
+import org.lwjgl.opengl.GL43;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -277,15 +278,19 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
             holder -> CommonUniforms.addNonDynamicUniforms(holder, programs.getPack().getIdMap(), programs.getPackDirectives(), this.updateNotifier)
         );
 
-		BlockRenderingSettings.INSTANCE.setBlockMetaMatches(BlockMaterialMapping.createBlockMetaIdMap(
+		final var blockIdMaps = BlockMaterialMapping.createBlockIdMaps(
 			programs.getPack().getIdMap().getBlockProperties(),
-			programs.getPack().getIdMap().hasLegacySection()));
+			programs.getPack().getIdMap().hasLegacySection());
+		BlockRenderingSettings.INSTANCE.setBlockMetaMatches(blockIdMaps.blockMetaMap());
+		BlockRenderingSettings.INSTANCE.setBlockNbtMap(blockIdMaps.tileEntityMap());
 		BlockRenderingSettings.INSTANCE.setBlockTypeIds(BlockMaterialMapping.createBlockTypeMap(programs.getPack().getIdMap().getBlockRenderTypeMap()));
 
 		BlockRenderingSettings.INSTANCE.setEntityIds(programs.getPack().getIdMap().getEntityIdMap());
+		BlockRenderingSettings.INSTANCE.setEntityNbtMap(BlockMaterialMapping.createNamespacedNbtMap(programs.getPack().getIdMap().getEntityNbtEntries()));
 
 		ItemMaterialHelper.clearCache();
 		BlockRenderingSettings.INSTANCE.setItemIds(programs.getPack().getIdMap().getItemIdMap());
+		BlockRenderingSettings.INSTANCE.setItemNbtMap(BlockMaterialMapping.createNamespacedNbtMap(programs.getPack().getIdMap().getItemNbtEntries()));
 		BlockRenderingSettings.INSTANCE.setAmbientOcclusionLevel(programs.getPackDirectives().getAmbientOcclusionLevel());
 		BlockRenderingSettings.INSTANCE.setDisableDirectionalShading(shouldDisableDirectionalShading());
 		BlockRenderingSettings.INSTANCE.setUseSeparateAo(programs.getPackDirectives().shouldUseSeparateAo());
@@ -390,6 +395,7 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
 				null, null, ProgramId.Weather,
 				// world border uses textured_lit even though it has no lightmap :/
 				null, ProgramId.TexturedLit, ProgramId.TexturedLit,
+				ProgramId.Lightning, ProgramId.Lightning, ProgramId.Lightning,
 				ProgramId.ShadowWater, ProgramId.ShadowWater, ProgramId.ShadowWater,
 				ProgramId.Shadow, ProgramId.Shadow, ProgramId.Shadow
 		};
@@ -513,7 +519,7 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
 		}
 		if (hasSetup) {
 			ComputeProgram.unbind();
-			RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT);
+			RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT | GL43.GL_SHADER_STORAGE_BARRIER_BIT);
 		}
 
 		// Terrain pipeline sampler/image factory setup follows.
@@ -719,6 +725,8 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
 				return RenderCondition.ENTITY_EYES;
 			} else if (special == SpecialCondition.GLINT) {
 				return RenderCondition.GLINT;
+			} else if (special == SpecialCondition.LIGHTNING) {
+				return RenderCondition.LIGHTNING;
 			}
 		}
 
@@ -767,11 +775,11 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
 	public boolean shouldOverrideShaders() {
 		return isRenderingWorld && !isRenderingFullScreenPass && !isPostChain && isMainBound;
 	}
-	
+
 	public Pass getActivePassProgram() {
 		return current;
 	}
-	
+
 	public int getActivePassProgramId() {
 		if (current == null) return -1;
 		final Program p = current.getProgram();
@@ -789,10 +797,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);
 	}
 
@@ -1328,7 +1336,7 @@ public class DeferredWorldRenderingPipeline implements WorldRenderingPipeline, R
 			}
 			if (ranSetup) {
 				ComputeProgram.unbind();
-				RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT);
+				RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT | GL43.GL_SHADER_STORAGE_BARRIER_BIT);
 			}
 		}
 

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

@@ -34,7 +34,7 @@ class AttributeTransformer {
 			transformer.injectVariable("layout(location = 4) in vec3 iris_Normal;");
 
 			transformer.rename("gl_Vertex", "iris_Vertex");
-			transformer.rename("gl_Color", "iris_Color");
+			transformer.replaceExpression("gl_Color", "(iris_Color * iris_ColorModulator)");
 			transformer.rename("gl_Normal", "iris_Normal");
 
 			// ftransform() = gl_ModelViewProjectionMatrix * gl_Vertex

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

@@ -34,6 +34,7 @@ class CeleritasTransformer {
         transformer.injectFunction(
             "void _celeritas_init() { " +
             "_vert_init(); " +
+            "_vert_color = _vert_color * iris_ColorModulator; " +
             "iris_LightTexCoord = vec4(vec2(_vert_tex_light_coord), 0.0, 1.0); }");
         transformer.prependMain("_celeritas_init();");
         transformShared(transformer, parameters);
@@ -60,6 +61,7 @@ class CeleritasTransformer {
     }
 
     private static void transformShared(Transformer transformer, Parameters parameters) {
+        transformer.replaceExpression("gl_TextureMatrix[0]", "mat4(1.0)");
         CoreTransformHelper.injectMatrixUniforms(transformer);
     }
 }

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

@@ -20,9 +20,10 @@ public class CommonTransformer {
 		}
 
 		if (parameters.type == ShaderType.VERTEX) {
+			root.injectVariable("uniform vec4 iris_ColorModulator;");
 			root.injectVariable("out vec4 iris_FrontColor;");
 			root.rename("gl_FrontColor", "iris_FrontColor");
-			root.prependMain("iris_FrontColor = vec4(1.0);");
+			root.prependMain("iris_FrontColor = iris_ColorModulator;");
 		} else if (parameters.type == ShaderType.FRAGMENT) {
 			root.injectVariable("in vec4 iris_FrontColor;");
 			root.rename("gl_Color", "iris_FrontColor");

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

@@ -94,7 +94,7 @@ public class DHGenericTransformer {
                 + " float skyLight = (float(uSkyLight) + 0.5) / 16.0;"
                 + " _vert_tex_light_coord = vec2(blockLight, skyLight);"
                 + " dhMaterialId = aMaterial;"
-                + " _vert_color = iris_color;"
+                + " _vert_color = iris_color * iris_ColorModulator;"
                 + " }"
         );
         transformer.prependMain("_vert_init();");

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

@@ -86,7 +86,7 @@ public class DHTerrainTransformer {
                 + " _vert_normal = irisNormals[int(irisExtra.y)];"
                 + " dhMaterialId = int(irisExtra.x);"
                 + " _vert_tex_light_coord = vec2((float(lights / 16u) + 0.5) / 16.0, (mod(float(lights), 16.0) + 0.5) / 16.0);"
-                + " _vert_color = iris_color;"
+                + " _vert_color = iris_color * iris_ColorModulator;"
                 + " }"
         );
         transformer.prependMain("_vert_init();");

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

@@ -44,6 +44,7 @@ import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL13;
 import org.lwjgl.opengl.GL30;
 import org.lwjgl.opengl.GL42;
+import org.lwjgl.opengl.GL43;
 
 import java.util.Map;
 import java.util.Objects;
@@ -263,7 +264,7 @@ public class CompositeRenderer {
 			}
 
 			if (ranCompute) {
-				RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT);
+				RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT | GL43.GL_SHADER_STORAGE_BARRIER_BIT);
 			}
 
 			Program.unbind();

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

@@ -42,6 +42,7 @@ import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL13;
 import org.lwjgl.opengl.GL30;
 import org.lwjgl.opengl.GL42;
+import org.lwjgl.opengl.GL43;
 
 import java.util.Map;
 import java.util.Objects;
@@ -229,7 +230,7 @@ public class FinalPassRenderer {
 				}
 			}
 
-			RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT);
+			RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT | GL43.GL_SHADER_STORAGE_BARRIER_BIT);
 
 			if (!finalPass.mipmappedBuffers.isEmpty()) {
 				GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);

src/main/java/net/coderbot/iris/shaderpack/IdMap.java

@@ -14,6 +14,7 @@ import net.coderbot.iris.shaderpack.materialmap.BlockEntry;
 import net.coderbot.iris.shaderpack.materialmap.EntityFlatteningMap;
 import net.coderbot.iris.shaderpack.materialmap.BlockRenderType;
 import net.coderbot.iris.shaderpack.materialmap.NamespacedId;
+import net.coderbot.iris.shaderpack.materialmap.PropertiesTokenizer;
 import net.coderbot.iris.shaderpack.option.ShaderPackOptions;
 import net.coderbot.iris.shaderpack.preprocessor.PropertiesPreprocessor;
 import net.minecraft.item.Item;
@@ -45,11 +46,15 @@ public class IdMap {
 	 * Maps a given item ID to an integer ID
 	 */
 	private final Object2IntMap<NamespacedId> itemIdMap;
+	@Getter
+    private final Int2ObjectMap<List<BlockEntry>> itemNbtEntries;
 
 	/**
 	 * Maps a given entity ID to an integer ID
 	 */
 	private final Object2IntMap<NamespacedId> entityIdMap;
+	@Getter
+    private final Int2ObjectMap<List<BlockEntry>> entityNbtEntries;
 
 	/**
 	 * Maps block states to block ids defined in block.properties
@@ -106,8 +111,17 @@ public class IdMap {
 			});
 		}
 
-		itemIdMap = loadProperties(shaderPath, "item.properties", shaderPackOptions, resolvedDefines).map(IdMap::parseItemIdMap).orElse(Object2IntMaps.emptyMap());
-		entityIdMap = loadProperties(shaderPath, "entity.properties", shaderPackOptions, resolvedDefines).map(IdMap::parseEntityIdMap).orElse(Object2IntMaps.emptyMap());
+		final ParsedIdMap parsedItems = loadProperties(shaderPath, "item.properties", shaderPackOptions, resolvedDefines)
+			.map(p -> parseIdMap(p, "item.", "item.properties"))
+			.orElse(new ParsedIdMap(Object2IntMaps.emptyMap(), new Int2ObjectOpenHashMap<>()));
+		itemIdMap = parsedItems.simpleMap();
+		itemNbtEntries = parsedItems.nbtEntries();
+
+		final ParsedIdMap parsedEntities = loadProperties(shaderPath, "entity.properties", shaderPackOptions, resolvedDefines)
+			.map(p -> parseIdMap(p, "entity.", "entity.properties"))
+			.orElse(new ParsedIdMap(Object2IntMaps.emptyMap(), new Int2ObjectOpenHashMap<>()));
+		entityIdMap = augmentEntityIdMap(parsedEntities.simpleMap(), parsedEntities.nbtEntries());
+		entityNbtEntries = parsedEntities.nbtEntries();
 
 		// TODO: Properly override block render layers
 
@@ -166,25 +180,37 @@ public class IdMap {
 		}
 	}
 
-	private static Object2IntMap<NamespacedId> parseItemIdMap(Properties properties) {
-		return parseIdMap(properties, "item.", "item.properties");
-	}
-
-	private static Object2IntMap<NamespacedId> parseEntityIdMap(Properties properties) {
-		Object2IntMap<NamespacedId> idMap = parseIdMap(properties, "entity.", "entity.properties");
-
-		// For modern shader packs: translate modern entity names to 1.7.10 names
-		// so runtime lookups match EntityList's registered names directly.
+	/**
+	 * For modern shaderpacks: also expose entries under their 1.7.10 entity names
+	 * so runtime lookups match EntityList's registered names directly.
+	 *
+	 * Modern names whose 1.7.10 counterpart is NBT-discriminated (e.g. wither_skeleton
+	 * is just Skeleton with SkeletonType=1) are routed into the NBT-conditional map
+	 * instead of being aliased into the simple map — otherwise the simple lookup for
+	 * "Skeleton" would short-circuit and match every skeleton variant.
+	 */
+	private static Object2IntMap<NamespacedId> augmentEntityIdMap(
+			Object2IntMap<NamespacedId> idMap,
+			Int2ObjectMap<List<BlockEntry>> nbtEntries) {
 		Object2IntMap<NamespacedId> augmented = new Object2IntOpenHashMap<>(idMap);
 		augmented.defaultReturnValue(-1);
 
 		for (Object2IntMap.Entry<NamespacedId> entry : idMap.object2IntEntrySet()) {
 			NamespacedId id = entry.getKey();
-			if ("minecraft".equals(id.getNamespace())) {
-				String legacyName = EntityFlatteningMap.toLegacy(id.getName());
-				if (legacyName != null) {
-					augmented.putIfAbsent(new NamespacedId(legacyName), entry.getIntValue());
-				}
+			if (!"minecraft".equals(id.getNamespace())) {
+				continue;
+			}
+			final int intId = entry.getIntValue();
+
+			BlockEntry nbtMapping = EntityFlatteningMap.toLegacyWithNbt(id.getName());
+			if (nbtMapping != null) {
+				nbtEntries.computeIfAbsent(intId, k -> new ArrayList<>()).add(nbtMapping);
+				continue;
+			}
+
+			String legacyName = EntityFlatteningMap.toLegacy(id.getName());
+			if (legacyName != null) {
+				augmented.putIfAbsent(new NamespacedId(legacyName), intId);
 			}
 		}
 
@@ -212,67 +238,18 @@ public class IdMap {
 	 * @return List of parsed identifiers
 	 */
 	static List<String> parseIdentifierList(String value, String fileName, String key) {
-		if (value.indexOf('"') == -1) {
-			String[] parts = value.split("\\s+");
-			List<String> result = new ArrayList<>(parts.length);
-			for (String part : parts) {
-				if (!part.isEmpty()) {
-					result.add(part);
-				}
-			}
-			return result;
-		}
-
-		// Found quote, start of a dumb block ID
-		List<String> result = new ArrayList<>();
-		StringBuilder current = new StringBuilder();
-		boolean inQuotes = false;
-		boolean escaped = false;
-
-		for (int i = 0; i < value.length(); i++) {
-			char c = value.charAt(i);
-
-			if (escaped) {
-				current.append(c);
-				escaped = false;
-			} else if (c == '\\') {
-				escaped = true;
-			} else if (c == '"') {
-				inQuotes = !inQuotes;
-			} else if (Character.isWhitespace(c) && !inQuotes) {
-				if (!current.isEmpty()) {
-					result.add(current.toString());
-					current.setLength(0);
-				}
-			} else {
-				current.append(c);
-			}
-		}
-
-		// Didn't close a quote, warn
-		if (inQuotes) {
-			Iris.logger.warn(fileName + " [" + key + "]: Unclosed quote");
-		}
-
-		// Trailing backslash, warn
-		if (escaped) {
-			Iris.logger.warn(fileName + " [" + key + "]: Trailing backslash");
-		}
-
-		// Add final token
-		if (!current.isEmpty()) {
-			result.add(current.toString());
-		}
-
-		return result;
+		return PropertiesTokenizer.tokenizeValues(value, ' ');
 	}
 
+	record ParsedIdMap(Object2IntMap<NamespacedId> simpleMap, Int2ObjectMap<List<BlockEntry>> nbtEntries) {}
+
 	/**
 	 * Parses a NamespacedId map in OptiFine format
 	 */
-	private static Object2IntMap<NamespacedId> parseIdMap(Properties properties, String keyPrefix, String fileName) {
+	private static ParsedIdMap parseIdMap(Properties properties, String keyPrefix, String fileName) {
 		Object2IntMap<NamespacedId> idMap = new Object2IntOpenHashMap<>();
 		idMap.defaultReturnValue(-1);
+		Int2ObjectMap<List<BlockEntry>> nbtEntries = new Int2ObjectOpenHashMap<>();
 
 		properties.forEach((keyObject, valueObject) -> {
 			String key = (String) keyObject;
@@ -295,6 +272,20 @@ public class IdMap {
 
 			// Parse identifiers
 			for (String part : parseIdentifierList(value, fileName, key)) {
+				if (part.contains("[")) {
+					// NBT-conditional entry
+					try {
+						BlockEntry entry = BlockEntry.parse(part);
+						if (entry.hasNbtProperties()) {
+							nbtEntries.computeIfAbsent(intId, k -> new ArrayList<>()).add(entry);
+						} else {
+							idMap.put(entry.id(), intId);
+						}
+					} catch (Exception e) {
+						Iris.logger.warn("Failed to parse NBT entry in " + fileName + " for key " + key + ": " + part, e);
+					}
+					continue;
+				}
 				if (part.contains("=")) {
 					// Avoid tons of logspam for now
 					Iris.logger.warn("Failed to parse an ResourceLocation in " + fileName + " for the key " + key + ": state properties are currently not supported: " + part);
@@ -307,7 +298,7 @@ public class IdMap {
 			}
 		});
 
-		return Object2IntMaps.unmodifiable(idMap);
+		return new ParsedIdMap(Object2IntMaps.unmodifiable(idMap), nbtEntries);
 	}
 
 	private static Int2ObjectMap<List<BlockEntry>> parseBlockMap(Properties properties, String keyPrefix, String fileName) {
@@ -408,7 +399,7 @@ public class IdMap {
 		return itemIdMap;
 	}
 
-	public Object2IntFunction<NamespacedId> getEntityIdMap() {
+    public Object2IntFunction<NamespacedId> getEntityIdMap() {
 		return entityIdMap;
 	}
 

src/main/java/net/coderbot/iris/shaderpack/ProgramSet.java

@@ -41,6 +41,7 @@ public class ProgramSet {
 	private final ProgramSource gbuffersEntities;
 	private final ProgramSource gbuffersEntitiesTrans;
 	private final ProgramSource gbuffersEntitiesGlowing;
+	private final ProgramSource gbuffersLightning;
 	private final ProgramSource gbuffersGlint;
 	private final ProgramSource gbuffersEntityEyes;
 	private final ProgramSource gbuffersBlock;
@@ -120,6 +121,7 @@ public class ProgramSet {
 		this.gbuffersEntities = readProgramSource(directory, sourceProvider, "gbuffers_entities", this, shaderProperties);
 		this.gbuffersEntitiesTrans = readProgramSource(directory, sourceProvider, "gbuffers_entities_translucent", this, shaderProperties);
 		this.gbuffersEntitiesGlowing = readProgramSource(directory, sourceProvider, "gbuffers_entities_glowing", this, shaderProperties);
+		this.gbuffersLightning = readProgramSource(directory, sourceProvider, "gbuffers_lightning", this, shaderProperties);
 		this.gbuffersGlint = readProgramSource(directory, sourceProvider, "gbuffers_armor_glint", this, shaderProperties);
 		this.gbuffersEntityEyes = readProgramSource(directory, sourceProvider, "gbuffers_spidereyes", this, shaderProperties);
 		this.gbuffersBlock = readProgramSource(directory, sourceProvider, "gbuffers_block", this, shaderProperties);
@@ -229,7 +231,7 @@ public class ProgramSet {
 		programs.addAll (Arrays.asList(
 				gbuffersBasic, gbuffersBeaconBeam, gbuffersTextured, gbuffersTexturedLit, gbuffersTerrain,
 				gbuffersDamagedBlock, gbuffersSkyBasic, gbuffersSkyTextured, gbuffersClouds, gbuffersWeather,
-				gbuffersEntities, gbuffersEntitiesTrans, gbuffersEntitiesGlowing, gbuffersGlint, gbuffersEntityEyes, gbuffersBlock, gbuffersBlockTrans,
+				gbuffersEntities, gbuffersEntitiesTrans, gbuffersEntitiesGlowing, gbuffersLightning, gbuffersGlint, gbuffersEntityEyes, gbuffersBlock, gbuffersBlockTrans,
 				gbuffersHand, dhShadow, dhTerrain, dhGeneric, dhWater
 		));
 
@@ -382,6 +384,10 @@ public class ProgramSet {
 		return gbuffersEntitiesGlowing.requireValid();
 	}
 
+	public Optional<ProgramSource> getGbuffersLightning() {
+		return gbuffersLightning.requireValid();
+	}
+
 	public Optional<ProgramSource> getGbuffersGlint() {
 		return gbuffersGlint.requireValid();
 	}
@@ -437,6 +443,7 @@ public class ProgramSet {
 			case Entities -> getGbuffersEntities();
 			case EntitiesTrans -> getGbuffersEntitiesTrans();
 			case EntitiesGlowing -> getGbuffersEntitiesGlowing();
+			case Lightning -> getGbuffersLightning();
 			case ArmorGlint -> getGbuffersGlint();
 			case SpiderEyes -> getGbuffersEntityEyes();
 			case Hand -> getGbuffersHand();

src/main/java/net/coderbot/iris/shaderpack/ShaderProperties.java

@@ -771,7 +771,7 @@ public class ShaderProperties {
 				return;
 			}
 
-			final int size = Integer.parseInt(parts[0]);
+			final long size = Long.parseLong(parts[0]);
 
 			// Size < 1 means the shader dev intended to disable the buffer
 			if (size < 1) {

src/main/java/net/coderbot/iris/shaderpack/loading/ProgramId.java

@@ -23,7 +23,7 @@ public enum ProgramId {
 	TexturedLit(ProgramGroup.Gbuffers, "textured_lit", Textured),
 	SkyBasic(ProgramGroup.Gbuffers, "skybasic", Basic),
 	SkyTextured(ProgramGroup.Gbuffers, "skytextured", Textured),
-	Clouds(ProgramGroup.Gbuffers, "clouds", Textured),
+	Clouds(ProgramGroup.Gbuffers, "clouds", Textured, null, new AlphaTestOverride(new AlphaTest(AlphaTestFunction.GREATER, 0.1F))),
 
 	Terrain(ProgramGroup.Gbuffers, "terrain", TexturedLit),
 	TerrainSolid(ProgramGroup.Gbuffers, "terrain_solid", Terrain),
@@ -39,6 +39,7 @@ public enum ProgramId {
 	Entities(ProgramGroup.Gbuffers, "entities", TexturedLit),
 	EntitiesTrans(ProgramGroup.Gbuffers, "entities_translucent", Entities),
 	EntitiesGlowing(ProgramGroup.Gbuffers, "entities_glowing", Entities),
+	Lightning(ProgramGroup.Gbuffers, "lightning", Entities),
 	ArmorGlint(ProgramGroup.Gbuffers, "armor_glint", Textured),
 	SpiderEyes(ProgramGroup.Gbuffers, "spidereyes", Textured,
 		new BlendModeOverride(new BlendState(GL11.GL_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO, GL11.GL_ONE)),

src/main/java/net/coderbot/iris/shaderpack/materialmap/BlockEntry.java

@@ -1,124 +1,45 @@
 package net.coderbot.iris.shaderpack.materialmap;
 
-import lombok.Getter;
-import net.coderbot.iris.Iris;
-import org.apache.commons.lang3.StringUtils;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Collections;
-import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Set;
 
-@Getter
-public class BlockEntry {
-	private final NamespacedId id;
-	private final Set<Integer> metas;
-	private final Map<String, String> stateProperties;
+public record BlockEntry(
+    NamespacedId id,
+    Set<Integer> metas,
+    Map<String, String> stateProperties,
+    Map<String, PropertiesTokenizer.NbtValue> nbtProperties
+) {
+    public BlockEntry(NamespacedId id, Set<Integer> metas) {
+        this(id, metas, Collections.emptyMap(), Collections.emptyMap());
+    }
 
-	public BlockEntry(NamespacedId id, Set<Integer> metas) {
-		this(id, metas, Collections.emptyMap());
-	}
+    public BlockEntry(NamespacedId id, Set<Integer> metas, Map<String, String> stateProperties) {
+        this(id, metas, stateProperties, Collections.emptyMap());
+    }
 
-	public BlockEntry(NamespacedId id, Set<Integer> metas, Map<String, String> stateProperties) {
-		this.id = id;
-		this.metas = metas;
-		this.stateProperties = stateProperties;
-	}
+    public boolean hasNbtProperties() {
+        return !nbtProperties.isEmpty();
+    }
 
-	/**
-	 * Parses a block ID entry.
-	 *
-	 * @param entry The string representation of the entry. Must not be empty.
-	 */
-	@NotNull
-	public static BlockEntry parse(@NotNull String entry) {
-		if (entry.isEmpty()) {
-			throw new IllegalArgumentException("Called BlockEntry::parse with an empty string");
-		}
+    public boolean hasStateProperties() {
+        return !stateProperties.isEmpty();
+    }
 
-		// We can assume that this array is of at least array length because the input string is non-empty.
-		final String[] splitStates = entry.split(":");
-
-		// Trivial case: no states, no namespace
-		if (splitStates.length == 1) {
-			return new BlockEntry(new NamespacedId("minecraft", entry), Collections.emptySet());
-		}
-
-        // Examples of what we accept:
-        // stone
-        // stone:0
-        // minecraft:stone:0
-        // minecraft:stone:0,1,2
-        // minecraft:furnace:lit=true      (blockstate property)
-        // minecraft:oak_log:axis=y         (blockstate property)
-
-		// Less trivial case: no metas or state properties, just a namespace
-		if (splitStates.length == 2 && !StringUtils.isNumeric(splitStates[1].substring(0, 1))
-				&& !splitStates[1].contains("=")) {
-			return new BlockEntry(new NamespacedId(splitStates[0], splitStates[1]), Collections.emptySet());
-		}
-
-		// Complex case: metas and/or state properties
-		final int statesStart;
-		final NamespacedId id;
-
-		if (splitStates.length == 2) {
-			// "stone:0" or "stone:lit=true"
-			statesStart = 1;
-			id = new NamespacedId("minecraft", splitStates[0]);
-		} else if (StringUtils.isNumeric(splitStates[1].substring(0, 1)) || splitStates[1].contains("=")) {
-			// "stone:0:something" or "stone:lit=true:something" — unlikely but handle it
-			statesStart = 1;
-			id = new NamespacedId("minecraft", splitStates[0]);
-		} else {
-			// "minecraft:stone:0" or "minecraft:furnace:lit=true"
-			statesStart = 2;
-			id = new NamespacedId(splitStates[0], splitStates[1]);
-		}
-
-		final Set<Integer> metas = new HashSet<>();
-		final Map<String, String> properties = new HashMap<>();
-
-		for (int index = statesStart; index < splitStates.length; index++) {
-			String segment = splitStates[index];
-
-			if (segment.contains("=")) {
-				// Blockstate property: key=value
-				for (String prop : segment.split(",")) {
-					int eq = prop.indexOf('=');
-					if (eq > 0 && eq < prop.length() - 1) {
-						properties.put(prop.substring(0, eq), prop.substring(eq + 1));
-					}
-				}
-			} else {
-				// Metadata IDs: comma-separated integers
-				for (String metaPart : segment.split(",")) {
-					try {
-						metas.add(Integer.parseInt(metaPart));
-					} catch (NumberFormatException e) {
-						Iris.logger.warn("Warning: the block ID map entry \"" + entry + "\" could not be fully parsed:");
-						Iris.logger.warn("- Metadata ids must be a comma separated list of one or more integers, but " + segment + " is not of that form!");
-					}
-				}
-			}
+    /**
+     * Parses a block ID entry. All tokenization is delegated to {@link PropertiesTokenizer}.
+     *
+     * @param entry The string representation of the entry. Must not be empty.
+     */
+    @NotNull
+    public static BlockEntry parse(@NotNull String entry) {
+        if (entry.isEmpty()) {
+            throw new IllegalArgumentException("Called BlockEntry::parse with an empty string");
         }
 
-		return new BlockEntry(id, metas, properties);
-	}
-
-    @Override
-	public boolean equals(Object o) {
-		if (this == o) return true;
-		if (o == null || getClass() != o.getClass()) return false;
-		final BlockEntry that = (BlockEntry) o;
-		return Objects.equals(id, that.id) && Objects.equals(metas, that.metas) && Objects.equals(stateProperties, that.stateProperties);
-	}
-
-	@Override
-	public int hashCode() {
-		return Objects.hash(id, metas, stateProperties);
-	}
+        final PropertiesTokenizer.ParsedBlockIdentifier parsed = PropertiesTokenizer.parseBlockIdentifier(entry);
+        return new BlockEntry(parsed.id(), parsed.metas(), parsed.stateProperties(), parsed.nbtProperties());
+    }
 }

src/main/java/net/coderbot/iris/shaderpack/materialmap/EntityFlatteningMap.java

@@ -1,5 +1,6 @@
 package net.coderbot.iris.shaderpack.materialmap;
 
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -10,14 +11,15 @@ import java.util.Map;
  * In 1.7.10, entities are registered with names like "CaveSpider".
  * Some entities were also renamed or split into multiple types.
  *
- * This map is used at lookup time: when a modern shader pack references an entity by its
- * modern name, we resolve it to the 1.7.10 name that EntityList uses.
  */
 public class EntityFlatteningMap {
 
 	/** Maps modern entity name -> 1.7.10 entity name. */
 	private static final Map<String, String> MODERN_TO_LEGACY = new HashMap<>();
 
+	/** Maps modern entity name -> legacy entity name + NBT. */
+	private static final Map<String, BlockEntry> MODERN_TO_LEGACY_NBT = new HashMap<>();
+
 	static {
 		// Simple case changes
 		simple("Arrow", "arrow");
@@ -35,7 +37,6 @@ public class EntityFlatteningMap {
 		simple("Pig", "pig");
 		simple("Sheep", "sheep");
 		simple("Silverfish", "silverfish");
-		simple("Skeleton", "skeleton");
 		simple("Slime", "slime");
 		simple("Snowball", "snowball");
 		simple("Spider", "spider");
@@ -49,7 +50,6 @@ public class EntityFlatteningMap {
 		simple("CaveSpider", "cave_spider");
 		simple("EnderCrystal", "end_crystal");
 		simple("EnderDragon", "ender_dragon");
-		simple("EntityHorse", "horse");
 		simple("EyeOfEnderSignal", "eye_of_ender");
 		simple("FallingSand", "falling_block");
 		simple("Fireball", "fireball");
@@ -79,6 +79,36 @@ public class EntityFlatteningMap {
 		simple("MinecartHopper", "hopper_minecart");
 		simple("MinecartSpawner", "spawner_minecart");
 		simple("MinecartTNT", "tnt_minecart");
+
+		MODERN_TO_LEGACY_NBT.put("skeleton", new BlockEntry(
+			new NamespacedId("Skeleton"), Collections.emptySet(), Collections.emptyMap(),
+			Map.of("SkeletonType", new PropertiesTokenizer.NbtValue("0", false))));
+		MODERN_TO_LEGACY_NBT.put("wither_skeleton", new BlockEntry(
+			new NamespacedId("Skeleton"), Collections.emptySet(), Collections.emptyMap(),
+			Map.of("SkeletonType", new PropertiesTokenizer.NbtValue("1", false))));
+
+		// 1.7.10 EntityHorse with Type byte: 0=horse, 1=donkey, 2=mule, 3=zombie_horse,
+		// 4=skeleton_horse. 1.11+ split each into its own entity type.
+		MODERN_TO_LEGACY_NBT.put("horse", new BlockEntry(
+			new NamespacedId("EntityHorse"), Collections.emptySet(), Collections.emptyMap(),
+			Map.of("Type", new PropertiesTokenizer.NbtValue("0", false))));
+		MODERN_TO_LEGACY_NBT.put("donkey", new BlockEntry(
+			new NamespacedId("EntityHorse"), Collections.emptySet(), Collections.emptyMap(),
+			Map.of("Type", new PropertiesTokenizer.NbtValue("1", false))));
+		MODERN_TO_LEGACY_NBT.put("mule", new BlockEntry(
+			new NamespacedId("EntityHorse"), Collections.emptySet(), Collections.emptyMap(),
+			Map.of("Type", new PropertiesTokenizer.NbtValue("2", false))));
+		MODERN_TO_LEGACY_NBT.put("zombie_horse", new BlockEntry(
+			new NamespacedId("EntityHorse"), Collections.emptySet(), Collections.emptyMap(),
+			Map.of("Type", new PropertiesTokenizer.NbtValue("3", false))));
+		MODERN_TO_LEGACY_NBT.put("skeleton_horse", new BlockEntry(
+			new NamespacedId("EntityHorse"), Collections.emptySet(), Collections.emptyMap(),
+			Map.of("Type", new PropertiesTokenizer.NbtValue("4", false))));
+
+		// 1.7.10 Zombie with IsVillager.
+		MODERN_TO_LEGACY_NBT.put("zombie_villager", new BlockEntry(
+			new NamespacedId("Zombie"), Collections.emptySet(), Collections.emptyMap(),
+			Map.of("IsVillager", new PropertiesTokenizer.NbtValue("1", false))));
 	}
 
 	/**
@@ -89,6 +119,10 @@ public class EntityFlatteningMap {
 		return MODERN_TO_LEGACY.get(modernName);
 	}
 
+	public static BlockEntry toLegacyWithNbt(String modernName) {
+		return MODERN_TO_LEGACY_NBT.get(modernName);
+	}
+
 	private static void simple(String legacy, String modern) {
 		MODERN_TO_LEGACY.put(modern, legacy);
 	}

src/main/java/net/coderbot/iris/shaderpack/materialmap/FlatteningMap.java

@@ -158,18 +158,18 @@ public class FlatteningMap {
 		rename("dark_oak_wall_sign",    "wall_sign");
 
 		// === Skull / Head blocks (ID 144) ===
-		// In 1.7.10, skull type is stored in tile entity, not metadata.
-		// All modern skull blocks map to the same 1.7.10 block.
-		rename("skeleton_skull",                "skull");
-		rename("skeleton_wall_skull",           "skull");
-		rename("wither_skeleton_skull",         "skull");
-		rename("wither_skeleton_wall_skull",    "skull");
-		rename("zombie_head",                   "skull");
-		rename("zombie_wall_head",              "skull");
-		rename("player_head",                   "skull");
-		rename("player_wall_head",              "skull");
-		rename("creeper_head",                  "skull");
-		rename("creeper_wall_head",             "skull");
+		// 1.7.10 stores skull type in TileEntitySkull's SkullType byte (0=skeleton,
+		// 1=wither, 2=zombie, 3=player, 4=creeper).
+		MODERN_TO_LEGACY.put("skeleton_skull",             List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("0", false)))));
+		MODERN_TO_LEGACY.put("skeleton_wall_skull",        List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("0", false)))));
+		MODERN_TO_LEGACY.put("wither_skeleton_skull",      List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("1", false)))));
+		MODERN_TO_LEGACY.put("wither_skeleton_wall_skull", List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("1", false)))));
+		MODERN_TO_LEGACY.put("zombie_head",                List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("2", false)))));
+		MODERN_TO_LEGACY.put("zombie_wall_head",           List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("2", false)))));
+		MODERN_TO_LEGACY.put("player_head",                List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("3", false)))));
+		MODERN_TO_LEGACY.put("player_wall_head",           List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("3", false)))));
+		MODERN_TO_LEGACY.put("creeper_head",               List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("4", false)))));
+		MODERN_TO_LEGACY.put("creeper_wall_head",          List.of(new BlockEntry(new NamespacedId("minecraft", "skull"), Collections.emptySet(), Collections.emptyMap(), Map.of("SkullType", new PropertiesTokenizer.NbtValue("4", false)))));
 
 		// ==========================================
 		// Metadata variants (block split by flattening)
@@ -321,29 +321,29 @@ public class FlatteningMap {
 		meta("mossy_cobblestone_wall", "cobblestone_wall", 1);
 
 		// === Flower pot (ID 140) ===
-		// In 1.7.10, flower pot contents are in the tile entity.
-		// In 1.13+, each potted plant is a separate block.
-		rename("potted_oak_sapling",        "flower_pot");
-		rename("potted_spruce_sapling",     "flower_pot");
-		rename("potted_birch_sapling",      "flower_pot");
-		rename("potted_jungle_sapling",     "flower_pot");
-		rename("potted_acacia_sapling",     "flower_pot");
-		rename("potted_dark_oak_sapling",   "flower_pot");
-		rename("potted_fern",               "flower_pot");
-		rename("potted_dandelion",          "flower_pot");
-		rename("potted_poppy",              "flower_pot");
-		rename("potted_blue_orchid",        "flower_pot");
-		rename("potted_allium",             "flower_pot");
-		rename("potted_azure_bluet",        "flower_pot");
-		rename("potted_red_tulip",          "flower_pot");
-		rename("potted_orange_tulip",       "flower_pot");
-		rename("potted_white_tulip",        "flower_pot");
-		rename("potted_pink_tulip",         "flower_pot");
-		rename("potted_oxeye_daisy",        "flower_pot");
-		rename("potted_red_mushroom",       "flower_pot");
-		rename("potted_brown_mushroom",     "flower_pot");
-		rename("potted_dead_bush",          "flower_pot");
-		rename("potted_cactus",             "flower_pot");
+		// 1.7.10 stores potted contents in TileEntityFlowerPot's NBT. 1.13+ has a separate block
+		// per potted plant.
+		MODERN_TO_LEGACY.put("potted_oak_sapling",      List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false),        "Data", new PropertiesTokenizer.NbtValue("0", false)))));
+		MODERN_TO_LEGACY.put("potted_spruce_sapling",   List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false),        "Data", new PropertiesTokenizer.NbtValue("1", false)))));
+		MODERN_TO_LEGACY.put("potted_birch_sapling",    List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false),        "Data", new PropertiesTokenizer.NbtValue("2", false)))));
+		MODERN_TO_LEGACY.put("potted_jungle_sapling",   List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false),        "Data", new PropertiesTokenizer.NbtValue("3", false)))));
+		MODERN_TO_LEGACY.put("potted_acacia_sapling",   List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false),        "Data", new PropertiesTokenizer.NbtValue("4", false)))));
+		MODERN_TO_LEGACY.put("potted_dark_oak_sapling", List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:sapling", false),        "Data", new PropertiesTokenizer.NbtValue("5", false)))));
+		MODERN_TO_LEGACY.put("potted_fern",             List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:tallgrass", false),      "Data", new PropertiesTokenizer.NbtValue("2", false)))));
+		MODERN_TO_LEGACY.put("potted_dandelion",        List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:yellow_flower", false),  "Data", new PropertiesTokenizer.NbtValue("0", false)))));
+		MODERN_TO_LEGACY.put("potted_poppy",            List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false),     "Data", new PropertiesTokenizer.NbtValue("0", false)))));
+		MODERN_TO_LEGACY.put("potted_blue_orchid",      List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false),     "Data", new PropertiesTokenizer.NbtValue("1", false)))));
+		MODERN_TO_LEGACY.put("potted_allium",           List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false),     "Data", new PropertiesTokenizer.NbtValue("2", false)))));
+		MODERN_TO_LEGACY.put("potted_azure_bluet",      List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false),     "Data", new PropertiesTokenizer.NbtValue("3", false)))));
+		MODERN_TO_LEGACY.put("potted_red_tulip",        List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false),     "Data", new PropertiesTokenizer.NbtValue("4", false)))));
+		MODERN_TO_LEGACY.put("potted_orange_tulip",     List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false),     "Data", new PropertiesTokenizer.NbtValue("5", false)))));
+		MODERN_TO_LEGACY.put("potted_white_tulip",      List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false),     "Data", new PropertiesTokenizer.NbtValue("6", false)))));
+		MODERN_TO_LEGACY.put("potted_pink_tulip",       List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false),     "Data", new PropertiesTokenizer.NbtValue("7", false)))));
+		MODERN_TO_LEGACY.put("potted_oxeye_daisy",      List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_flower", false),     "Data", new PropertiesTokenizer.NbtValue("8", false)))));
+		MODERN_TO_LEGACY.put("potted_red_mushroom",     List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:red_mushroom", false),   "Data", new PropertiesTokenizer.NbtValue("0", false)))));
+		MODERN_TO_LEGACY.put("potted_brown_mushroom",   List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:brown_mushroom", false), "Data", new PropertiesTokenizer.NbtValue("0", false)))));
+		MODERN_TO_LEGACY.put("potted_dead_bush",        List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:deadbush", false),       "Data", new PropertiesTokenizer.NbtValue("0", false)))));
+		MODERN_TO_LEGACY.put("potted_cactus",           List.of(new BlockEntry(new NamespacedId("minecraft", "flower_pot"), Collections.emptySet(), Collections.emptyMap(), Map.of("Item", new PropertiesTokenizer.NbtValue("minecraft:cactus", false),         "Data", new PropertiesTokenizer.NbtValue("0", false)))));
 
 		// === Anvil (ID 145) ===
 		// Bits 0-1 = facing, bits 2-3 = damage level
@@ -928,26 +928,26 @@ public class FlatteningMap {
 		List<BlockEntry> result = new ArrayList<>(Math.min(a.size(), b.size()));
 		for (BlockEntry entryA : a) {
 			for (BlockEntry entryB : b) {
-				if (!entryA.getId().equals(entryB.getId())) continue;
+				if (!entryA.id().equals(entryB.id())) continue;
 
-				Set<Integer> metasA = entryA.getMetas();
-				Set<Integer> metasB = entryB.getMetas();
+				Set<Integer> metasA = entryA.metas();
+				Set<Integer> metasB = entryB.metas();
 
 				if (metasA.isEmpty() && metasB.isEmpty()) {
 					// Both wildcard -> wildcard
-					result.add(new BlockEntry(entryA.getId(), Collections.emptySet()));
+					result.add(new BlockEntry(entryA.id(), Collections.emptySet()));
 				} else if (metasA.isEmpty()) {
 					// A is wildcard -> use B's constraint
-					result.add(new BlockEntry(entryA.getId(), metasB));
+					result.add(new BlockEntry(entryA.id(), metasB));
 				} else if (metasB.isEmpty()) {
 					// B is wildcard -> use A's constraint
-					result.add(new BlockEntry(entryA.getId(), metasA));
+					result.add(new BlockEntry(entryA.id(), metasA));
 				} else {
 					// Both have specific metas -> intersect
 					Set<Integer> intersection = new IntOpenHashSet(metasA);
 					intersection.retainAll(metasB);
 					if (!intersection.isEmpty()) {
-						result.add(new BlockEntry(entryA.getId(), intersection));
+						result.add(new BlockEntry(entryA.id(), intersection));
 					}
 				}
 			}

src/main/java/net/coderbot/iris/shaderpack/materialmap/PropertiesTokenizer.java

@@ -0,0 +1,388 @@
+package net.coderbot.iris.shaderpack.materialmap;
+
+import net.coderbot.iris.Iris;
+import org.apache.commons.lang3.StringUtils;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+// This got complicated fast
+
+/**
+ * This class handles all processing of individual block entries per material ID line.
+ */
+public final class PropertiesTokenizer {
+
+    private PropertiesTokenizer() {
+    }
+
+    /**
+     * Splits a property value into individual block identifier tokens.
+     */
+    public static List<String> tokenizeValues(String input, char delimiter) {
+        if (input.indexOf('"') == -1 && input.indexOf('\\') == -1 && input.indexOf('[') == -1) {
+            return tokenizeSimple(input, delimiter);
+        }
+        return tokenizeFull(input, delimiter);
+    }
+
+    // Most blocks should take this path
+    private static List<String> tokenizeSimple(String input, char delimiter) {
+        final List<String> result = new ArrayList<>();
+        final boolean isWhitespaceDelim = Character.isWhitespace(delimiter);
+
+        if (isWhitespaceDelim) {
+            for (String part : input.split("\\s+")) {
+                if (!part.isEmpty()) {
+                    result.add(part);
+                }
+            }
+        } else {
+            for (String part : input.split(String.valueOf(delimiter))) {
+                final String trimmed = part.trim();
+                if (!trimmed.isEmpty()) {
+                    result.add(trimmed);
+                }
+            }
+        }
+        return result;
+    }
+
+    // Found special characters
+    private static List<String> tokenizeFull(String input, char delimiter) {
+        final boolean isWhitespaceDelim = Character.isWhitespace(delimiter);
+        final List<String> result = new ArrayList<>();
+        final StringBuilder current = new StringBuilder();
+        boolean inQuotes = false;
+        boolean escaped = false;
+        int bracketDepth = 0;
+
+        for (int i = 0; i < input.length(); i++) {
+            final char c = input.charAt(i);
+
+            if (escaped) {
+                if (bracketDepth > 0) {
+                    // Preserve escapes inside brackets for parseBlockIdentifier
+                    current.append('\\');
+                }
+                current.append(c);
+                escaped = false;
+
+            } else if (c == '\\') {
+                escaped = true;
+
+            } else if (bracketDepth > 0) {
+                current.append(c);
+
+                if (c == '[') {
+                    bracketDepth++;
+                }
+
+                else if (c == ']') {
+                    bracketDepth--;
+                }
+
+            } else if (c == '[' && !inQuotes) {
+                current.append(c);
+                bracketDepth = 1;
+
+            } else if (c == '"') {
+                inQuotes = !inQuotes;
+
+            } else if (!inQuotes && (isWhitespaceDelim ? Character.isWhitespace(c) : c == delimiter)) {
+                if (!current.isEmpty()) {
+                    result.add(current.toString());
+                    current.setLength(0);
+                }
+
+            } else {
+                current.append(c);
+            }
+        }
+
+        if (inQuotes) {
+            Iris.logger.warn("Unclosed quote in properties token: {}", input);
+        }
+
+        if (!current.isEmpty()) {
+            result.add(current.toString());
+        }
+
+        return result;
+    }
+
+    // Begin reading the special case block
+    public static ParsedBlockIdentifier parseBlockIdentifier(String entry) {
+        final StringBuilder blockIdBuilder = new StringBuilder();
+        final Map<String, NbtValue> nbt = new LinkedHashMap<>();
+
+        boolean escaped = false;
+        boolean inDoubleQuotes = false;
+        boolean inSingleQuotes = false;
+        boolean inBracket = false;
+
+        // NBT pair
+        StringBuilder nbtKey = new StringBuilder();
+        StringBuilder nbtValue = new StringBuilder();
+        boolean readingValue = false;
+        boolean valueLiteral = false;
+
+        for (int i = 0; i < entry.length(); i++) {
+            final char c = entry.charAt(i);
+
+            // Ignore special characters
+            if (escaped) {
+                appendCurrent(inBracket, readingValue, blockIdBuilder, nbtKey, nbtValue, c);
+                escaped = false;
+                continue;
+            }
+            if (c == '\\') {
+                escaped = true;
+                continue;
+            }
+
+            // Detect special characters
+            if (inSingleQuotes) {
+                if (c == '\'') {
+                    inSingleQuotes = false;
+
+                } else {
+                    nbtValue.append(c);
+                }
+                continue;
+            }
+
+            if (inDoubleQuotes) {
+                if (c == '"') {
+                    inDoubleQuotes = false;
+
+                } else {
+                    appendCurrent(inBracket, readingValue, blockIdBuilder, nbtKey, nbtValue, c);
+                }
+                continue;
+            }
+
+
+            if (c == '"') {
+                inDoubleQuotes = true;
+                continue;
+            }
+
+            if (!inBracket) {
+                if (c == '[') {
+                    inBracket = true;
+                    nbtKey.setLength(0);
+                    nbtValue.setLength(0);
+                    readingValue = false;
+                    valueLiteral = false;
+
+                } else {
+                    blockIdBuilder.append(c);
+                }
+
+            } else {
+                if (c == ']') {
+                    flushNbtPair(nbtKey, nbtValue, readingValue, valueLiteral, nbt);
+                    inBracket = false;
+
+                } else if (c == '=' && !readingValue) {
+                    readingValue = true;
+                    valueLiteral = false;
+
+                } else if (c == '\'' && readingValue && nbtValue.isEmpty()) {
+                    inSingleQuotes = true;
+                    valueLiteral = true;
+
+                } else if (c == ',') {
+                    flushNbtPair(nbtKey, nbtValue, readingValue, valueLiteral, nbt);
+                    nbtKey.setLength(0);
+                    nbtValue.setLength(0);
+                    readingValue = false;
+                    valueLiteral = false;
+
+                } else {
+                    if (readingValue) {
+                        nbtValue.append(c);
+
+                    } else {
+                        nbtKey.append(c);
+                    }
+                }
+            }
+        }
+
+        if (inDoubleQuotes) {
+            Iris.logger.warn("Unclosed double quote in block entry: {}", entry);
+        }
+        if (inSingleQuotes) {
+            Iris.logger.warn("Unclosed single quote in block entry: {}", entry);
+        }
+        if (escaped) {
+            Iris.logger.warn("Trailing backslash in block entry: {}", entry);
+        }
+        if (inBracket) {
+            Iris.logger.warn("Unclosed bracket in block entry: {}", entry);
+            flushNbtPair(nbtKey, nbtValue, readingValue, valueLiteral, nbt);
+        }
+
+        final String baseEntry = blockIdBuilder.toString().trim();
+        final Map<String, NbtValue> nbtProperties = nbt.isEmpty() ? Collections.emptyMap() : nbt;
+
+        return splitBaseEntry(entry, baseEntry, nbtProperties);
+    }
+
+    /**
+     * Splits the bracket-stripped portion of a block identifier (e.g. {@code minecraft:furnace:lit=true})
+     * into its components.
+     *
+     * Accepted forms:
+     *   stone                                                  (vanilla block)
+     *   stone:0                                                (vanilla block with meta)
+     *   minecraft:stone                                        (block with namespaced id specified)
+     *   minecraft:stone:0                                      (single meta)
+     *   minecraft:stone:0,1,2                                  (multiple metas)
+     *   minecraft:furnace:lit=true                             (blockstate property)
+     *   minecraft:oak_log:axis=y,x:variant=oak                 (multiple blockstate properties)
+     *   flower_pot:1[Item=minecraft:red_flower,Data=0]         (used together with NBT brackets)
+     */
+    private static ParsedBlockIdentifier splitBaseEntry(String entry, String baseEntry, Map<String, NbtValue> nbtProperties) {
+        final Set<Integer> metas = new HashSet<>();
+        final Map<String, String> stateProperties = new LinkedHashMap<>();
+
+        if (baseEntry.isEmpty()) {
+            return new ParsedBlockIdentifier(
+                new NamespacedId("minecraft", baseEntry),
+                Collections.emptySet(),
+                Collections.emptyMap(),
+                nbtProperties
+            );
+        }
+
+        final String[] splitStates = baseEntry.split(":");
+
+        // Vanilla block (minecraft namespaced)
+        if (splitStates.length == 1) {
+            return new ParsedBlockIdentifier(
+                new NamespacedId("minecraft", baseEntry),
+                Collections.emptySet(),
+                Collections.emptyMap(),
+                nbtProperties
+            );
+        }
+
+        // Two-segment with no metas/state properties: "minecraft:stone"
+        if (splitStates.length == 2
+                && !StringUtils.isNumeric(splitStates[1].substring(0, 1))
+                && !splitStates[1].contains("=")) {
+            return new ParsedBlockIdentifier(
+                new NamespacedId(splitStates[0], splitStates[1]),
+                Collections.emptySet(),
+                Collections.emptyMap(),
+                nbtProperties
+            );
+        }
+
+        // Metas and/or state properties
+        final NamespacedId id;
+        final int statesStart;
+
+        if (splitStates.length == 2) {
+            // "stone:0" or "stone:lit=true"
+            id = new NamespacedId("minecraft", splitStates[0]);
+            statesStart = 1;
+
+        } else if (StringUtils.isNumeric(splitStates[1].substring(0, 1)) || splitStates[1].contains("=")) {
+            // "stone:0:something" or "stone:lit=true:something", likely will need this for snowy blocks in the future.
+            id = new NamespacedId("minecraft", splitStates[0]);
+            statesStart = 1;
+
+        } else {
+            // "minecraft:stone:0" or "minecraft:furnace:lit=true"
+            id = new NamespacedId(splitStates[0], splitStates[1]);
+            statesStart = 2;
+        }
+
+        for (int index = statesStart; index < splitStates.length; index++) {
+            final String segment = splitStates[index];
+
+            if (segment.contains("=")) {
+                // Blockstate property segment: key=value[,key=value...]
+                for (String prop : segment.split(",")) {
+                    final int eq = prop.indexOf('=');
+                    if (eq > 0 && eq < prop.length() - 1) {
+                        stateProperties.put(prop.substring(0, eq), prop.substring(eq + 1));
+                    }
+                }
+            } else {
+                // Metadata segment (stone:[1,2,3,4,5])
+                for (String metaPart : segment.split(",")) {
+                    try {
+                        metas.add(Integer.parseInt(metaPart));
+                    } catch (NumberFormatException e) {
+                        Iris.logger.warn("Warning: the block ID map entry \"{}\" could not be fully parsed:", entry);
+                        Iris.logger.warn("- Metadata ids must be a comma separated list of one or more integers, but {} is not of that form!", segment);
+                    }
+                }
+            }
+        }
+
+        return new ParsedBlockIdentifier(
+            id,
+            metas.isEmpty() ? Collections.emptySet() : metas,
+            stateProperties.isEmpty() ? Collections.emptyMap() : stateProperties,
+            nbtProperties
+        );
+    }
+
+    private static void appendCurrent(boolean inBracket, boolean readingValue,
+                                      StringBuilder blockIdBuilder, StringBuilder nbtKey,
+                                      StringBuilder nbtValue, char c) {
+        if (!inBracket) {
+            blockIdBuilder.append(c);
+
+        } else if (readingValue) {
+            nbtValue.append(c);
+
+        } else {
+            nbtKey.append(c);
+        }
+    }
+
+    private static void flushNbtPair(StringBuilder key, StringBuilder value,
+                                     boolean readingValue, boolean valueLiteral,
+                                     Map<String, NbtValue> nbt) {
+        final String k = key.toString().trim();
+        if (k.isEmpty()) return;
+
+        if (!readingValue) {
+            // No = was found, existence is good enough
+            nbt.put(k, null);
+            return;
+        }
+
+        nbt.put(k, new NbtValue(value.toString().trim(), valueLiteral));
+    }
+
+    public static String stripQuotes(String value) {
+        if (value.length() >= 2 && value.charAt(0) == '"' && value.charAt(value.length() - 1) == '"') {
+            return value.substring(1, value.length() - 1);
+        }
+        return value;
+    }
+
+    public record NbtValue(String value, boolean literal) {
+    }
+
+    public record ParsedBlockIdentifier(
+        NamespacedId id,
+        Set<Integer> metas,
+        Map<String, String> stateProperties,
+        Map<String, NbtValue> nbtProperties
+    ) {
+    }
+}

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

@@ -43,6 +43,7 @@ import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL13;
 import org.lwjgl.opengl.GL30;
 import org.lwjgl.opengl.GL42;
+import org.lwjgl.opengl.GL43;
 
 import java.util.Map;
 import java.util.Objects;
@@ -208,7 +209,7 @@ public class ShadowCompositeRenderer {
 
             if (ranCompute) {
                 // Memory barrier for shader image access and texture fetch
-                RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT);
+                RenderSystem.memoryBarrier(GL42.GL_SHADER_IMAGE_ACCESS_BARRIER_BIT | GL42.GL_TEXTURE_FETCH_BARRIER_BIT | GL43.GL_SHADER_STORAGE_BARRIER_BIT);
             }
 
             Program.unbind();

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

@@ -89,7 +89,7 @@ public class CameraUniforms {
 
 		private void update() {
 			previousCameraPosition.set(currentCameraPosition);
-			previousCameraPositionUnshifted = currentCameraPositionUnshifted;
+			previousCameraPositionUnshifted.set(currentCameraPositionUnshifted);
 			currentCameraPosition.set(getUnshiftedCameraPosition()).add(shift);
 			currentCameraPositionUnshifted.set(getUnshiftedCameraPosition());
 

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

@@ -1,10 +1,16 @@
 package net.coderbot.iris.uniforms;
 
+import it.unimi.dsi.fastutil.ints.Int2LongLinkedOpenHashMap;
 import it.unimi.dsi.fastutil.objects.Object2IntFunction;
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 import net.coderbot.iris.block_rendering.BlockRenderingSettings;
+import net.coderbot.iris.block_rendering.NbtConditionalIdMap;
 import net.coderbot.iris.shaderpack.materialmap.NamespacedId;
+import net.minecraft.nbt.NBTTagCompound;
+
+import java.util.IdentityHashMap;
+import java.util.Map;
 import net.minecraft.client.Minecraft;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.EntityList;
@@ -21,15 +27,25 @@ public final class EntityIdHelper {
     private static final NamespacedId LIGHTNING_BOLT_ID = new NamespacedId("minecraft", "lightning_bolt");
 
     private static final Object2IntMap<Class<?>> entityIdCache = new Object2IntOpenHashMap<>();
+    private static final Map<Class<?>, NamespacedId> entityNameCache = new IdentityHashMap<>();
     private static Object2IntFunction<NamespacedId> cachedEntityIdMap;
 
+    private static final Int2LongLinkedOpenHashMap entityNbtCache = new Int2LongLinkedOpenHashMap();
+    private static final int NBT_CACHE_INTERVAL_TICKS = 20;
+    private static final int ENTITY_NBT_CACHE_MAX = 256;
+
     static {
         entityIdCache.defaultReturnValue(Integer.MIN_VALUE);
+        entityNbtCache.defaultReturnValue(-1L);
     }
 
     private EntityIdHelper() {
     }
 
+    public static boolean isLightningBolt(Entity entity) {
+        return entity instanceof EntityLightningBolt;
+    }
+
     /**
      * Get the entity ID for the given entity.
      *
@@ -42,17 +58,48 @@ public final class EntityIdHelper {
             return -1;
         }
 
-        // Invalidate cache if the map changed (shader reload)
+        // Invalidate caches if the map changed (shader reload)
         if (entityIdMap != cachedEntityIdMap) {
             entityIdCache.clear();
+            entityNameCache.clear();
+            entityNbtCache.clear();
             cachedEntityIdMap = entityIdMap;
         }
 
+        // Check NBT-conditional match first
+        final NbtConditionalIdMap<NamespacedId> entityNbtMap = BlockRenderingSettings.INSTANCE.getEntityNbtMap();
+        if (entityNbtMap != null && !entityNbtMap.isEmpty() && entity.worldObj != null) {
+            final NamespacedId namespacedId = getCachedEntityName(entity);
+            if (namespacedId != null && entityNbtMap.hasConditions(namespacedId)) {
+                final int entityRuntimeId = entity.getEntityId();
+                final long currentTick = entity.worldObj.getTotalWorldTime();
+                final long cached = entityNbtCache.get(entityRuntimeId);
+
+                final int nbtId;
+                if (cached != -1L && (currentTick - (cached >>> 32)) < NBT_CACHE_INTERVAL_TICKS) {
+                    nbtId = (int) cached;
+                } else {
+                    final NBTTagCompound nbt = new NBTTagCompound();
+                    entity.writeToNBT(nbt);
+                    nbtId = entityNbtMap.resolve(namespacedId, nbt);
+                    final long packed = ((currentTick & 0x7FFFFFFFL) << 32) | (nbtId & 0xFFFFFFFFL);
+                    entityNbtCache.put(entityRuntimeId, packed);
+                    while (entityNbtCache.size() > ENTITY_NBT_CACHE_MAX) {
+                        entityNbtCache.removeFirstLong();
+                    }
+                }
+
+                if (nbtId != -1) {
+                    return nbtId;
+                }
+            }
+        }
+
         // Normal entity type lookup
-        int normalId = getNormalEntityId(entity, entityIdMap);
+        final int normalId = getNormalEntityId(entity, entityIdMap);
 
         // Check for special entity type overrides
-        int specialId = getSpecialEntityId(entity, entityIdMap);
+        final int specialId = getSpecialEntityId(entity, entityIdMap);
         if (specialId != -1) {
             return specialId;
         }
@@ -134,4 +181,24 @@ public final class EntityIdHelper {
 
         return id;
     }
+
+    /**
+     * Returns a cached NamespacedId for the entity's registered type.
+     */
+    private static NamespacedId getCachedEntityName(Entity entity) {
+        Class<?> entityClass = entity.getClass();
+        NamespacedId cached = entityNameCache.get(entityClass);
+        if (cached != null) {
+            return cached;
+        }
+
+        String entityType = EntityList.getEntityString(entity);
+        if (entityType == null) {
+            return null;
+        }
+
+        cached = new NamespacedId(entityType);
+        entityNameCache.put(entityClass, cached);
+        return cached;
+    }
 }

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

@@ -2,6 +2,7 @@ package net.coderbot.iris.uniforms;
 
 import com.gtnewhorizons.angelica.compat.mojang.Camera;
 import com.gtnewhorizons.angelica.compat.mojang.GameModeUtil;
+import com.gtnewhorizons.angelica.render.CloudRenderer;
 import net.coderbot.iris.gl.uniform.UniformHolder;
 import net.coderbot.iris.gl.uniform.UniformUpdateFrequency;
 import net.minecraft.client.Minecraft;
@@ -40,6 +41,16 @@ public class IrisExclusiveUniforms {
 		uniforms.uniform3d(UniformUpdateFrequency.PER_FRAME, "eyePosition", IrisExclusiveUniforms::getEyePosition);
 		uniforms.uniform3d(UniformUpdateFrequency.PER_FRAME, "relativeEyePosition", IrisExclusiveUniforms::getRelativeEyePosition);
 		uniforms.uniform4f(UniformUpdateFrequency.PER_TICK, "lightningBoltPosition", IrisExclusiveUniforms::getLightningBoltPosition);
+		uniforms.uniform1f(UniformUpdateFrequency.PER_FRAME, "cloudTime", IrisExclusiveUniforms::getCloudTime);
+	}
+
+	private static float getCloudTime() {
+		final WorldClient level = Minecraft.getMinecraft().theWorld;
+		if (level == null) return 0f;
+		final long cycle = (long) CloudRenderer.getCloudTextureWidth() * 400L * CloudRenderer.getScaleMult();
+		final long t = level.getTotalWorldTime() % cycle;
+		final float partial = Minecraft.getMinecraft().timer.renderPartialTicks;
+		return (t + partial) * 0.03F;
 	}
 
 	private static float getThunderStrength() {

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

@@ -12,10 +12,19 @@ import static net.coderbot.iris.gl.uniform.UniformUpdateFrequency.PER_FRAME;
 
 public class IrisInternalUniforms {
     private static final Vector4f FOG_COLOR = new Vector4f();
+    private static final Vector4f COLOR_MODULATOR = new Vector4f(1f, 1f, 1f, 1f);
 
     private IrisInternalUniforms() {
     }
 
+    private static Vector4f getColorModulator() {
+        return COLOR_MODULATOR.set(
+            GLStateManager.getShaderColorR(),
+            GLStateManager.getShaderColorG(),
+            GLStateManager.getShaderColorB(),
+            GLStateManager.getShaderColorA());
+    }
+
     private static float getEffectiveAlphaRef() {
         if (!GLStateManager.getAlphaTest().isEnabled() || GLStateManager.getAlphaState().getFunction() == GL11.GL_ALWAYS) {
             return -1.0f;
@@ -44,5 +53,7 @@ public class IrisInternalUniforms {
             .uniform1f("iris_currentAlphaTest", IrisInternalUniforms::getEffectiveAlphaRef, StateUpdateNotifiers.alphaTestNotifier)
             .uniform1f("alphaTestRef", IrisInternalUniforms::getEffectiveAlphaRef, StateUpdateNotifiers.alphaTestNotifier)
             .uniform1i("iris_currentAlphaFunc", IrisInternalUniforms::getEffectiveAlphaFunc, StateUpdateNotifiers.alphaFuncNotifier);
+
+        uniforms.uniform4f("iris_ColorModulator", IrisInternalUniforms::getColorModulator, StateUpdateNotifiers.colorModulatorNotifier);
     }
 }

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

@@ -6,6 +6,7 @@ import it.unimi.dsi.fastutil.objects.Object2IntFunction;
 import it.unimi.dsi.fastutil.objects.Reference2ObjectMap;
 import it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap;
 import net.coderbot.iris.block_rendering.BlockRenderingSettings;
+import net.coderbot.iris.block_rendering.NbtConditionalIdMap;
 import net.coderbot.iris.shaderpack.materialmap.NamespacedId;
 import net.minecraft.block.Block;
 import net.minecraft.item.Item;
@@ -20,6 +21,7 @@ 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;
+    private static final Reference2ObjectMap<Item, NamespacedId> ITEM_NAME_CACHE = new Reference2ObjectOpenHashMap<>();
     /**
      * Get the material ID for an ItemStack.
      * For ItemBlock: checks block.properties first, then item.properties.
@@ -32,6 +34,19 @@ public class ItemMaterialHelper {
         if (itemStack == null || itemStack.getItem() == null) {
             return -1;
         }
+
+        // Check item NBT conditions first
+        final NbtConditionalIdMap<NamespacedId> itemNbtMap = BlockRenderingSettings.INSTANCE.getItemNbtMap();
+        if (itemNbtMap != null && !itemNbtMap.isEmpty() && itemStack.hasTagCompound()) {
+            NamespacedId namespacedId = getCachedItemName(itemStack.getItem());
+            if (namespacedId != null && itemNbtMap.hasConditions(namespacedId)) {
+                int nbtId = itemNbtMap.resolve(namespacedId, itemStack.getTagCompound());
+                if (nbtId != -1) {
+                    return nbtId;
+                }
+            }
+        }
+
         return getMaterialId(itemStack.getItem(), itemStack.getItemDamage());
     }
 
@@ -73,8 +88,7 @@ public class ItemMaterialHelper {
      */
     private static int lookupMaterialId(Item item, int metadata) {
         // For ItemBlock: check block.properties first
-        if (item instanceof ItemBlock) {
-            final ItemBlock itemBlock = (ItemBlock) item;
+        if (item instanceof ItemBlock itemBlock) {
             final Block block = itemBlock.field_150939_a; // The block this item places
 
             if (block != null) {
@@ -94,7 +108,7 @@ public class ItemMaterialHelper {
         // Fall back to item.properties
         Object2IntFunction<NamespacedId> itemIds = BlockRenderingSettings.INSTANCE.getItemIds();
         if (itemIds != null) {
-            String itemIdString = (String) Item.itemRegistry.getNameForObject(item);
+            String itemIdString = Item.itemRegistry.getNameForObject(item);
             if (itemIdString != null) {
                 ResourceLocation itemId = new ResourceLocation(itemIdString);
                 return itemIds.applyAsInt(new NamespacedId(itemId.getResourceDomain(), itemId.getResourcePath()));
@@ -110,5 +124,23 @@ public class ItemMaterialHelper {
      */
     public static void clearCache() {
         MATERIAL_CACHE.clear();
+        ITEM_NAME_CACHE.clear();
+    }
+
+    private static NamespacedId getCachedItemName(Item item) {
+        NamespacedId cached = ITEM_NAME_CACHE.get(item);
+        if (cached != null) {
+            return cached;
+        }
+
+        String itemIdString = Item.itemRegistry.getNameForObject(item);
+        if (itemIdString == null) {
+            return null;
+        }
+
+        ResourceLocation itemId = new ResourceLocation(itemIdString);
+        cached = new NamespacedId(itemId.getResourceDomain(), itemId.getResourcePath());
+        ITEM_NAME_CACHE.put(item, cached);
+        return cached;
     }
 }

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

@@ -6,6 +6,8 @@ import net.coderbot.iris.gl.uniform.UniformHolder;
 import net.coderbot.iris.pipeline.ShadowRenderer;
 import net.coderbot.iris.shaderpack.PackDirectives;
 import net.coderbot.iris.shadow.ShadowMatrices;
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.Entity;
 import org.joml.Matrix4f;
 import org.joml.Matrix4fc;
 
@@ -17,8 +19,18 @@ public final class MatrixUniforms {
 	private MatrixUniforms() {
 	}
 
+	private static final Matrix4f GBUFFER_MODELVIEW_SCRATCH = new Matrix4f();
+	private static Matrix4fc getGbufferModelView() {
+		final Matrix4fc raw = RenderingState.INSTANCE.getModelViewMatrix();
+		final Entity view = Minecraft.getMinecraft().renderViewEntity;
+		if (view == null) {
+			return raw;
+		}
+		return GBUFFER_MODELVIEW_SCRATCH.set(raw).translate(0f, view.getEyeHeight(), 0f);
+	}
+
 	public static void addMatrixUniforms(UniformHolder uniforms, PackDirectives directives) {
-		addMatrix(uniforms, "ModelView", RenderingState.INSTANCE::getModelViewMatrix);
+		addMatrix(uniforms, "ModelView", MatrixUniforms::getGbufferModelView);
 		// TODO: In some cases, gbufferProjectionInverse takes on a value much different than OptiFine...
 		// We need to audit Mojang's linear algebra.
 		addMatrix(uniforms, "Projection", RenderingState.INSTANCE::getProjectionMatrix);

src/main/resources/assets/angelica/lang/en_US.lang

@@ -14,6 +14,7 @@ sodium.options.pages.quality=Quality
 sodium.options.pages.performance=Performance
 sodium.options.pages.advanced=Advanced
 sodium.options.pages.appearance=Appearance
+sodium.options.pages.text=Text Effects
 sodium.options.view_distance.tooltip=The render distance controls how far away terrain will be rendered. Shorter distances mean that less terrain will be rendered, improving frame rates.
 sodium.options.simulation_distance.tooltip=The simulation distance controls how far away terrain and entities will be loaded and ticked. Shorter distances can reduce the internal server's load and may improve frame rates.
 sodium.options.brightness.tooltip=Controls the brightness (gamma) of the game.
@@ -223,6 +224,22 @@ options.angelica.aggressiveChunkLoading=Aggressive Chunk Loading
 options.angelica.aggressiveChunkLoading.tooltip=Renders chunks immediately when loaded, even if neighbors aren't ready yet. Improves perceived loading speed at render distance edges. Chunks rebuild automatically when neighbors load. Useful for low render distance servers.
 options.angelica.disablef3=Disable F3 Additions
 options.angelica.disablef3.tooltip=Disables Angelica's additions to the F3 debug screen.
+options.angelica.texteffects.rgb_colors=RGB Colors
+options.angelica.texteffects.rgb_colors.tooltip=Enable hex colors via %s syntax
+options.angelica.texteffects.gradients=Gradients
+options.angelica.texteffects.gradients.tooltip=Smooth color transitions via
+options.angelica.texteffects.rainbow=Rainbow
+options.angelica.texteffects.rainbow.tooltip=Cycling rainbow colors via
+options.angelica.texteffects.wave_text=Wave Text
+options.angelica.texteffects.wave_text.tooltip=Animated bouncing text via
+options.angelica.texteffects.wave_amplitude=Wave Amplitude
+options.angelica.texteffects.wave_amplitude.tooltip=How far wave text bounces (default 2.0)
+options.angelica.texteffects.dinnerbone_text=Dinnerbone Text
+options.angelica.texteffects.dinnerbone_text.tooltip=Flipped upside down text via
+options.angelica.texteffects.drop_shadow=Drop Shadow
+options.angelica.texteffects.drop_shadow.tooltip=Per-segment drop shadow via %s, colored shadow via
+options.angelica.texteffects.ampersand_conversion=Ampersand Conversion
+options.angelica.texteffects.ampersand_conversion.tooltip=Convert %s prefix codes to formatting codes at render time
 
 sodium.options.multidraw_mode.name=Multi-Draw Mode
 sodium.options.multidraw_mode.tooltip=Controls how draw commands are dispatched for terrain rendering. §lDirect§r uses glMultiDrawElementsBaseVertex (default, GL 3.2+). §lIndirect§r uses GPU indirect rendering (GL 4.3+), may reduce CPU overhead on some hardware. §lIndividual§r issues individual draw calls.

src/main/resources/assets/angelica/shaders/cloud.frag

@@ -1,11 +1,11 @@
 #version 330 core
 
-in vec4 v_Color;
-in vec2 v_TexCoord0;
+in vec2 v_UV;
 in float v_FogCoord;
+in float v_Factor;
 
-uniform sampler2D u_CloudTexture;
-uniform vec3 u_ColorMultiplier;
+uniform sampler2D u_Tex;
+uniform vec4 u_ColorMult;
 uniform vec4 u_FogParams; // x: -1/(end-start), y: end/(end-start)
 uniform vec4 u_FogColor;
 uniform bool u_FogEnabled;
@@ -13,11 +13,10 @@ uniform bool u_FogEnabled;
 out vec4 fragColor;
 
 void main() {
-    vec4 texColor = texture(u_CloudTexture, v_TexCoord0);
-    vec4 color = v_Color * texColor;
-    color.rgb *= u_ColorMultiplier;
-
-    if (color.a < 0.1) discard;
+    vec4 texel = texture(u_Tex, v_UV);
+    if (texel.a < 0.1) discard;
+    vec4 color = texel * u_ColorMult;
+    color.rgb *= v_Factor;
 
     if (u_FogEnabled) {
         float f = clamp(v_FogCoord * u_FogParams.x + u_FogParams.y, 0.0, 1.0);

src/main/resources/assets/angelica/shaders/cloud.vert

@@ -1,22 +1,18 @@
 #version 330 core
 
 layout(location = 0) in vec3 a_Position;
-layout(location = 1) in vec4 a_Color;
-layout(location = 2) in vec2 a_TexCoord0;
+layout(location = 2) in vec2 a_UV;
+layout(location = 5) in float a_Factor;
 
 uniform mat4 u_MVPMatrix;
-uniform vec2 u_TexOffset;
-uniform vec2 u_FogOrigin;
 
-out vec4 v_Color;
-out vec2 v_TexCoord0;
+out vec2 v_UV;
 out float v_FogCoord;
+out float v_Factor;
 
 void main() {
-    vec4 pos4 = vec4(a_Position, 1.0);
-    gl_Position = u_MVPMatrix * pos4;
-    v_Color = a_Color;
-    v_TexCoord0 = a_TexCoord0 + u_TexOffset;
-    vec2 horizDelta = a_Position.xz - u_FogOrigin;
-    v_FogCoord = length(horizDelta);
+    gl_Position = u_MVPMatrix * vec4(a_Position, 1.0);
+    v_UV = a_UV;
+    v_FogCoord = length(a_Position.xz);
+    v_Factor = a_Factor;
 }

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

@@ -3,6 +3,7 @@ package com.gtnewhorizons.angelica.mixins.early.angelica.bugfixes;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import net.coderbot.iris.pipeline.ShadowRenderer;
 import net.minecraft.client.renderer.ItemRenderer;
 import net.minecraft.client.renderer.Tessellator;
 import org.lwjgl.opengl.GL11;
@@ -26,6 +27,11 @@ import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
  *       where depth passes. This determines pixel ownership without corrupting the depth buffer (damn potions...)
  *    b. Color pass: draw only where stencil == 2, GL_ALWAYS depth test, decrement the stencil
  *       2→1 to reset for the next glint pass.
+ *
+ * For the shadow pass, all stencil operations are skipped. Shadow FBOs have no stencil attachment.
+ * On AMD Windows, glClear(GL_STENCIL_BUFFER_BIT) on a depth-only FBO causes the driver to
+ * promote it to GL_DEPTH24_STENCIL8 internally, corrupting depth values and breaking shadows.
+ * Someone needs to yell at AMD to fix this decade old bug.
  */
 @Mixin(value = ItemRenderer.class, priority = 1100)
 public class MixinItemRenderer_EdgeDepth {
@@ -41,11 +47,12 @@ public class MixinItemRenderer_EdgeDepth {
         remap = false
     )
     private void angelica$stencilWriteStart(CallbackInfo ci) {
+        if (ShadowRenderer.ACTIVE) return;
         GLStateManager.glEnable(GL11.GL_STENCIL_TEST);
-        GLStateManager.glStencilMask(0xFF);
+        GLStateManager.glStencilMask(0x03);
         GLStateManager.glClearStencil(0);
         GLStateManager.glClear(GL11.GL_STENCIL_BUFFER_BIT);
-        GLStateManager.glStencilFunc(GL11.GL_ALWAYS, 1, 0xFF);
+        GLStateManager.glStencilFunc(GL11.GL_ALWAYS, 1, 0x03);
         GLStateManager.glStencilOp(GL11.GL_KEEP, GL11.GL_KEEP, GL11.GL_REPLACE);
     }
 
@@ -55,6 +62,7 @@ public class MixinItemRenderer_EdgeDepth {
         remap = false
     )
     private void angelica$stencilWriteEnd(CallbackInfo ci) {
+        if (ShadowRenderer.ACTIVE) return;
         GLStateManager.glStencilMask(0x00);
         GLStateManager.glDisable(GL11.GL_STENCIL_TEST);
     }
@@ -67,9 +75,13 @@ public class MixinItemRenderer_EdgeDepth {
         remap = false
     )
     private void angelica$glintStart(int func) {
+        if (ShadowRenderer.ACTIVE) {
+            GLStateManager.glDepthFunc(func);
+            return;
+        }
         angelica$glintMode = true;
         GLStateManager.glEnable(GL11.GL_STENCIL_TEST);
-        GLStateManager.glStencilFunc(GL11.GL_EQUAL, 1, 0xFF);
+        GLStateManager.glStencilFunc(GL11.GL_EQUAL, 1, 0x03);
         GLStateManager.glStencilOp(GL11.GL_KEEP, GL11.GL_KEEP, GL11.GL_KEEP);
     }
 
@@ -79,11 +91,15 @@ public class MixinItemRenderer_EdgeDepth {
         remap = false
     )
     private void angelica$glintEnd(int func) {
+        if (ShadowRenderer.ACTIVE) {
+            GLStateManager.glDepthFunc(func);
+            return;
+        }
         angelica$glintMode = false;
         GLStateManager.glDepthFunc(GL11.GL_LEQUAL);
         GLStateManager.glDepthMask(true);
         GLStateManager.glDisable(GL11.GL_STENCIL_TEST);
-        GLStateManager.glStencilMask(0xFF);
+        GLStateManager.glStencilMask(0x03);
     }
 
     // Stencil pre-pass inside renderItemIn2D when in glint mode
@@ -91,7 +107,7 @@ public class MixinItemRenderer_EdgeDepth {
     @WrapMethod(method = "renderItemIn2D")
     private static void angelica$glintPrepass(Tessellator tess, float minU, float minV, float maxU, float maxV,
                                                int w, int h, float thickness, Operation<Void> original) {
-        if (!angelica$glintMode || angelica$inPrepass) {
+        if (ShadowRenderer.ACTIVE || !angelica$glintMode || angelica$inPrepass) {
             original.call(tess, minU, minV, maxU, maxV, w, h, thickness);
             return;
         }
@@ -102,21 +118,21 @@ public class MixinItemRenderer_EdgeDepth {
         GLStateManager.glColorMask(false, false, false, false);
         GLStateManager.glDepthMask(false);
         GLStateManager.glDepthFunc(GL11.GL_LEQUAL);
-        GLStateManager.glStencilMask(0xFF);
-        GLStateManager.glStencilFunc(GL11.GL_EQUAL, 1, 0xFF);
+        GLStateManager.glStencilMask(0x03);
+        GLStateManager.glStencilFunc(GL11.GL_EQUAL, 1, 0x03);
         GLStateManager.glStencilOp(GL11.GL_KEEP, GL11.GL_KEEP, GL11.GL_INCR);
         original.call(tess, minU, minV, maxU, maxV, w, h, thickness);
 
         // Color pass: draw only at pre-pass pixels.
         GLStateManager.glColorMask(true, true, true, true);
-        GLStateManager.glStencilFunc(GL11.GL_EQUAL, 2, 0xFF);
+        GLStateManager.glStencilFunc(GL11.GL_EQUAL, 2, 0x03);
         GLStateManager.glStencilOp(GL11.GL_KEEP, GL11.GL_KEEP, GL11.GL_DECR);
         GLStateManager.glDepthFunc(GL11.GL_ALWAYS);
         original.call(tess, minU, minV, maxU, maxV, w, h, thickness);
 
         // Restore state for the next glint renderItemIn2D call
         GLStateManager.glStencilMask(0x00);
-        GLStateManager.glStencilFunc(GL11.GL_EQUAL, 1, 0xFF);
+        GLStateManager.glStencilFunc(GL11.GL_EQUAL, 1, 0x03);
         GLStateManager.glStencilOp(GL11.GL_KEEP, GL11.GL_KEEP, GL11.GL_KEEP);
         GLStateManager.glDepthFunc(GL11.GL_LEQUAL);
 

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

@@ -0,0 +1,70 @@
+package com.gtnewhorizons.angelica.mixins.early.angelica.bugfixes;
+
+import com.gtnewhorizons.angelica.config.AngelicaConfig;
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import net.coderbot.iris.Iris;
+import net.coderbot.iris.pipeline.FixedFunctionWorldRenderingPipeline;
+import net.coderbot.iris.pipeline.WorldRenderingPipeline;
+import net.coderbot.iris.uniforms.CapturedRenderingState;
+import net.minecraft.client.renderer.entity.RenderMooshroom;
+import net.minecraft.entity.passive.EntityMooshroom;
+import org.spongepowered.asm.mixin.Mixin;
+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;
+
+/**
+ * Make it so that the mushrooms on the mooshroom are also tinted when the mob is damaged.
+ */
+@Mixin(RenderMooshroom.class)
+public class MixinRenderMooshroom_MushroomTint {
+
+    @Unique private static final float ANGELICA$RED_MIX = 1.0F - (0xB2 / 255.0F);
+
+    @Unique private boolean angelica$mushroomTintActive;
+    @Unique private boolean angelica$mushroomTintShaderPath;
+
+    @Inject(
+        method = "renderEquippedItems(Lnet/minecraft/entity/passive/EntityMooshroom;F)V",
+        at = @At(value = "INVOKE",
+            target = "Lnet/minecraft/client/renderer/RenderBlocks;renderBlockAsItem(Lnet/minecraft/block/Block;IF)V",
+            ordinal = 0),
+        require = 1, expect = 1
+    )
+    private void angelica$applyMushroomTint(EntityMooshroom entity, float partialTick, CallbackInfo ci) {
+        if (entity.hurtTime <= 0 && entity.deathTime <= 0) return;
+        angelica$mushroomTintShaderPath = angelica$isShaderPackActive();
+        if (angelica$mushroomTintShaderPath) {
+            CapturedRenderingState.INSTANCE.setCurrentEntityColor(1.0F, 0.0F, 0.0F, ANGELICA$RED_MIX);
+        } else {
+            GLStateManager.setOverlayColor(1.0F, 0.0F, 0.0F, ANGELICA$RED_MIX);
+        }
+        angelica$mushroomTintActive = true;
+    }
+
+    @Inject(
+        method = "renderEquippedItems(Lnet/minecraft/entity/passive/EntityMooshroom;F)V",
+        at = @At(value = "INVOKE",
+            target = "Lnet/minecraft/client/renderer/RenderBlocks;renderBlockAsItem(Lnet/minecraft/block/Block;IF)V",
+            ordinal = 2,
+            shift = At.Shift.AFTER),
+        require = 1, expect = 1
+    )
+    private void angelica$clearMushroomTint(EntityMooshroom entity, float partialTick, CallbackInfo ci) {
+        if (!angelica$mushroomTintActive) return;
+        if (angelica$mushroomTintShaderPath) {
+            CapturedRenderingState.INSTANCE.setCurrentEntityColor(0.0F, 0.0F, 0.0F, 0.0F);
+        } else {
+            GLStateManager.setOverlayColor(0.0F, 0.0F, 0.0F, 0.0F);
+        }
+        angelica$mushroomTintActive = false;
+    }
+
+    @Unique
+    private static boolean angelica$isShaderPackActive() {
+        if (!AngelicaConfig.enableIris) return false;
+        final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
+        return pipeline != null && !(pipeline instanceof FixedFunctionWorldRenderingPipeline);
+    }
+}

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

@@ -0,0 +1,179 @@
+package com.gtnewhorizons.angelica.mixins.early.angelica.bugfixes;
+
+import com.gtnewhorizons.angelica.config.AngelicaConfig;
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.coderbot.iris.Iris;
+import net.coderbot.iris.pipeline.FixedFunctionWorldRenderingPipeline;
+import net.coderbot.iris.pipeline.WorldRenderingPipeline;
+import net.coderbot.iris.uniforms.CapturedRenderingState;
+import net.minecraft.client.model.ModelBase;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL14;
+import org.spongepowered.asm.mixin.Mixin;
+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.Slice;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+/**
+ * Single-pass damage-overlay tint, modeled on modern Minecraft's OverlayTexture.
+ */
+@Mixin(RendererLivingEntity.class)
+public class MixinRendererLivingEntity_OverlayTint {
+
+    @Unique private static final float ANGELICA$RED_MIX = 1.0F - (0xB2 / 255.0F);
+
+    @Unique private boolean angelica$skipReRender;
+    @Unique private boolean angelica$ffpOverlayActive;
+    @Unique private boolean angelica$shaderEntityColorActive;
+
+    @Unique private boolean angelica$emissivePass;
+
+    @Inject(
+        method = "doRender(Lnet/minecraft/entity/EntityLivingBase;DDDFF)V",
+        at = @At(value = "INVOKE",
+            target = "Lnet/minecraft/client/renderer/entity/RendererLivingEntity;renderModel(Lnet/minecraft/entity/EntityLivingBase;FFFFFF)V"),
+        require = 1, expect = 1
+    )
+    private void angelica$setupOverlay(EntityLivingBase entity, double x, double y, double z,
+                                       float yaw, float partialTick, CallbackInfo ci) {
+        GLStateManager.glDisable(GL11.GL_BLEND);
+        GLStateManager.glEnable(GL11.GL_ALPHA_TEST);
+        GLStateManager.glDepthFunc(GL11.GL_LEQUAL);
+        GLStateManager.glDepthMask(true);
+
+        if (entity.hurtTime <= 0 && entity.deathTime <= 0) return;
+        if (angelica$isShaderPackActive()) {
+            // Iris path
+            CapturedRenderingState.INSTANCE.setCurrentEntityColor(1.0F, 0.0F, 0.0F, ANGELICA$RED_MIX);
+            angelica$shaderEntityColorActive = true;
+        } else {
+            // FFP path
+            GLStateManager.setOverlayColor(1.0F, 0.0F, 0.0F, ANGELICA$RED_MIX);
+            angelica$ffpOverlayActive = true;
+        }
+        angelica$skipReRender = true;
+    }
+
+    @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"),
+        require = 1, expect = 1
+    )
+    private void angelica$teardownOverlay(EntityLivingBase entity, double x, double y, double z,
+                                          float yaw, float partialTick, CallbackInfo ci) {
+        if (angelica$ffpOverlayActive) {
+            GLStateManager.setOverlayColor(0.0F, 0.0F, 0.0F, 0.0F);
+            angelica$ffpOverlayActive = false;
+        }
+        if (angelica$shaderEntityColorActive) {
+            // Don't tint held items
+            CapturedRenderingState.INSTANCE.setCurrentEntityColor(0.0F, 0.0F, 0.0F, 0.0F);
+            angelica$shaderEntityColorActive = false;
+        }
+    }
+
+    /**
+     * Skip the vanilla re-render block.
+     */
+    @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"),
+        slice = @Slice(
+            from = @At(value = "FIELD",
+                target = "Lnet/minecraft/entity/EntityLivingBase;hurtTime:I",
+                ordinal = 1)
+        ),
+        require = 1, expect = 1
+    )
+    private void angelica$skipOverlayReRender(ModelBase model, Entity entity,
+            float p1, float p2, float p3, float p4, float p5, float p6, Operation<Void> original) {
+        if (angelica$skipReRender) return;
+        original.call(model, entity, p1, p2, p3, p4, p5, p6);
+    }
+
+    /**
+     * Prevent bleed by saving last state and comparing with current blend state.
+     */
+    @WrapOperation(
+        method = "doRender(Lnet/minecraft/entity/EntityLivingBase;DDDFF)V",
+        at = @At(value = "INVOKE",
+            target = "Lnet/minecraft/client/renderer/entity/RendererLivingEntity;shouldRenderPass(Lnet/minecraft/entity/EntityLivingBase;IF)I"),
+        require = 1, expect = 1
+    )
+    private int angelica$detectEmissivePass(RendererLivingEntity self, EntityLivingBase entity, int pass,
+            float partialTick, Operation<Integer> original) {
+        GLStateManager.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        final int result = original.call(self, entity, pass, partialTick);
+        final int srcAfter = GLStateManager.glGetInteger(GL14.GL_BLEND_SRC_RGB);
+        final int dstAfter = GLStateManager.glGetInteger(GL14.GL_BLEND_DST_RGB);
+        angelica$emissivePass = srcAfter == GL11.GL_ONE && dstAfter == GL11.GL_ONE;
+        return result;
+    }
+
+    /**
+     * Skip the overlay on emissive eye pass.
+     */
+    @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"),
+        slice = @Slice(
+            from = @At(value = "INVOKE",
+                target = "Lnet/minecraft/client/renderer/entity/RendererLivingEntity;shouldRenderPass(Lnet/minecraft/entity/EntityLivingBase;IF)I"),
+            to = @At(value = "INVOKE",
+                target = "Lnet/minecraft/client/renderer/entity/RendererLivingEntity;renderEquippedItems(Lnet/minecraft/entity/EntityLivingBase;F)V")
+        ),
+        require = 1, expect = 1
+    )
+    private void angelica$untintEmissivePass(ModelBase model, Entity entity,
+            float p1, float p2, float p3, float p4, float p5, float p6, Operation<Void> original) {
+        if (!angelica$skipReRender || !angelica$emissivePass) {
+            original.call(model, entity, p1, p2, p3, p4, p5, p6);
+            return;
+        }
+        if (angelica$ffpOverlayActive) {
+            GLStateManager.setOverlayColor(0.0F, 0.0F, 0.0F, 0.0F);
+            original.call(model, entity, p1, p2, p3, p4, p5, p6);
+            GLStateManager.setOverlayColor(1.0F, 0.0F, 0.0F, ANGELICA$RED_MIX);
+        } else if (angelica$shaderEntityColorActive) {
+            CapturedRenderingState.INSTANCE.setCurrentEntityColor(0.0F, 0.0F, 0.0F, 0.0F);
+            original.call(model, entity, p1, p2, p3, p4, p5, p6);
+            CapturedRenderingState.INSTANCE.setCurrentEntityColor(1.0F, 0.0F, 0.0F, ANGELICA$RED_MIX);
+        } else {
+            original.call(model, entity, p1, p2, p3, p4, p5, p6);
+        }
+    }
+
+    @Inject(
+        method = "doRender(Lnet/minecraft/entity/EntityLivingBase;DDDFF)V",
+        at = @At("RETURN")
+    )
+    private void angelica$reset(CallbackInfo ci) {
+        if (angelica$ffpOverlayActive) {
+            GLStateManager.setOverlayColor(0.0F, 0.0F, 0.0F, 0.0F);
+            angelica$ffpOverlayActive = false;
+        }
+        if (angelica$shaderEntityColorActive) {
+            CapturedRenderingState.INSTANCE.setCurrentEntityColor(0.0F, 0.0F, 0.0F, 0.0F);
+            angelica$shaderEntityColorActive = false;
+        }
+        angelica$skipReRender = false;
+        angelica$emissivePass = false;
+    }
+
+    @Unique
+    private static boolean angelica$isShaderPackActive() {
+        if (!AngelicaConfig.enableIris) return false;
+        final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
+        return pipeline != null && !(pipeline instanceof FixedFunctionWorldRenderingPipeline);
+    }
+}

src/mixin/java/com/gtnewhorizons/angelica/mixins/early/angelica/fontrenderer/MixinFontRenderer.java

@@ -292,6 +292,17 @@ public abstract class MixinFontRenderer implements FontRendererAccessor, IFontPa
             } else if (code >= 'k' && code <= 'o') {
                 styles.append(ColorCodeUtils.sectionPrefix(code));
                 i++;
+            } else if (code == 'u') {
+                if (i + 2 + SECTION_X_LENGTH <= len && ColorCodeUtils.isValidSectionX(text, i + 2)) {
+                    final StringBuilder cb = EXTRACT_COLOR;
+                    cb.setLength(0);
+                    for (int j = 0; j < 2 + SECTION_X_LENGTH; j++) cb.append(text.charAt(i + j));
+                    effects.append(cb);
+                    i += 1 + SECTION_X_LENGTH;
+                } else {
+                    effects.append(ColorCodeUtils.sectionPrefix(code));
+                    i++;
+                }
             } else if (code == 'q' || code == 'z' || code == 'v') {
                 effects.append(ColorCodeUtils.sectionPrefix(code));
                 i++;

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

@@ -2,6 +2,8 @@ package com.gtnewhorizons.angelica.mixins.early.celeritas.terrain;
 
 import java.util.Map;
 
+import com.gtnewhorizon.gtnhlib.hash.Fnv1a64;
+import com.gtnewhorizons.angelica.event.ChunkBiomeDataChangedEvent;
 import com.gtnewhorizons.angelica.mixins.interfaces.IChunkTileEntityMapHolder;
 import com.gtnewhorizons.angelica.rendering.RenderThreadContext;
 import com.gtnewhorizons.angelica.utils.ConcurrentTileEntityMap;
@@ -9,12 +11,15 @@ import net.minecraft.block.Block;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.world.ChunkPosition;
 import net.minecraft.world.World;
+import net.minecraft.world.biome.BiomeGenBase;
+import net.minecraft.world.biome.WorldChunkManager;
 import net.minecraft.world.chunk.Chunk;
 import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
 
 import org.spongepowered.asm.mixin.Final;
 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;
@@ -31,6 +36,11 @@ public abstract class MixinChunk implements IChunkTileEntityMapHolder {
 
     @Shadow public abstract void addTileEntity(TileEntity te);
 
+    @Shadow public abstract BiomeGenBase getBiomeGenForWorldCoords(int x, int z, WorldChunkManager wcm);
+
+    @Unique private long angelica$biomeHash;
+    @Unique private boolean angelica$biomeHashValid;
+
     @Override
     public ConcurrentTileEntityMap angelica$getConcurrentTEMap() {
         return (ConcurrentTileEntityMap) this.chunkTileEntityMap;
@@ -116,4 +126,30 @@ public abstract class MixinChunk implements IChunkTileEntityMapHolder {
             }
         });
     }
+
+    @Inject(method = "fillChunk", at = @At("RETURN"))
+    private void angelica$onBiomesFilled(byte[] data, int primaryBitMask, int addBitMask, boolean groundUp, CallbackInfo ci) {
+        if (!groundUp || !this.worldObj.isRemote) return;
+        final long hash = angelica$hashBiomes();
+        if (!this.angelica$biomeHashValid) {
+            this.angelica$biomeHashValid = true;
+            this.angelica$biomeHash = hash;
+            return;
+        }
+        if (hash == this.angelica$biomeHash) return;
+        this.angelica$biomeHash = hash;
+        ChunkBiomeDataChangedEvent.post(this.xPosition, this.zPosition);
+    }
+
+    @Unique
+    private long angelica$hashBiomes() {
+        final WorldChunkManager wcm = this.worldObj.getWorldChunkManager();
+        long hash = Fnv1a64.initialState();
+        for (int z = 0; z < 16; z++) {
+            for (int x = 0; x < 16; x++) {
+                hash = Fnv1a64.hashStep(hash, getBiomeGenForWorldCoords(x, z, wcm).biomeID);
+            }
+        }
+        return hash;
+    }
 }

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

@@ -148,7 +148,11 @@ public class MixinRenderGlobal implements IRenderGlobalExt {
         this.mc.entityRenderer.enableLightmap(partialTicks);
 
         final double camX = lerp(entity.lastTickPosX, entity.posX, partialTicks);
-        final double camY = lerp(entity.lastTickPosY, entity.posY, partialTicks);
+        // Minecraft's setupCameraTransform bakes -eyeHeight into the modelview, which would normally
+        // require feet here; CeleritasWorldRenderer.createChunkRenderMatrices compensates this by
+        // post-multiplying the chunk-shader modelview with translate(0, +eyeHeight, 0).
+        // Otherwise, we get issues with Iris shaders getting normals at a shifted y-position.
+        final double camY = lerp(entity.lastTickPosY, entity.posY, partialTicks) + entity.getEyeHeight();
         final double camZ = lerp(entity.lastTickPosZ, entity.posZ, partialTicks);
 
         try {

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

@@ -51,6 +51,8 @@ public abstract class MixinEntityRenderer implements IResourceManagerReloadListe
 
         pipeline.set(Iris.getPipelineManager().preparePipeline(Iris.getCurrentDimensionName()));
 
+        GLStateManager.setShaderColor(1f, 1f, 1f, 1f);
+
         pipeline.get().beginLevelRendering();
     }
 

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

@@ -0,0 +1,41 @@
+package com.gtnewhorizons.angelica.mixins.early.shaders;
+
+import net.coderbot.iris.block_rendering.BlockRenderingSettings;
+import net.coderbot.iris.block_rendering.NbtConditionalIdMap;
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.network.NetHandlerPlayClient;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.world.World;
+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(NetHandlerPlayClient.class)
+public class MixinNetHandlerPlayClient_NbtRemesh {
+
+    // Needed or TEs will be missed when meshing
+    @Inject(method = "handleUpdateTileEntity", at = @At("RETURN"))
+    private void angelica$remeshOnTileEntityUpdate(S35PacketUpdateTileEntity packet, CallbackInfo ci) {
+        final NbtConditionalIdMap<Block> teMap = BlockRenderingSettings.INSTANCE.getBlockNbtMap();
+        if (teMap == null || teMap.isEmpty()) {
+            return;
+        }
+
+        final World world = Minecraft.getMinecraft().theWorld;
+        if (world == null) {
+            return;
+        }
+
+        final int x = packet.func_148856_c/*getX*/() ;
+        final int y = packet.func_148855_d/*getY*/();
+        final int z = packet.func_148854_e/*getZ*/();
+        final Block block = world.getBlock(x, y, z);
+        if (block == null || !teMap.hasConditions(block)) {
+            return;
+        }
+
+        world.markBlockForUpdate(x, y, z);
+    }
+}

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

@@ -1,29 +1,45 @@
 package com.gtnewhorizons.angelica.mixins.early.shaders;
 
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import it.unimi.dsi.fastutil.objects.Object2IntFunction;
 import net.coderbot.iris.block_rendering.BlockRenderingSettings;
+import net.coderbot.iris.gbuffer_overrides.matching.SpecialCondition;
+import net.coderbot.iris.layer.GbufferPrograms;
 import net.coderbot.iris.shaderpack.materialmap.NamespacedId;
 import net.coderbot.iris.uniforms.CapturedRenderingState;
 import net.minecraft.client.renderer.entity.RenderDragon;
+import net.minecraft.entity.EntityLivingBase;
 import net.minecraft.entity.boss.EntityDragon;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.gen.Invoker;
 import org.spongepowered.asm.mixin.injection.At;
 import org.spongepowered.asm.mixin.injection.Inject;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
 /**
- * Mixin to set the entity ID to "end_crystal_beam" when rendering ender dragon healing beams.
- * This allows shaders to apply special effects to the healing beams separately from the dragon itself.
+ * Mixin allows devs to target the ender crystal beams as a separate entity.
+ * Also sets the special condition "lightning" on the dragon's death beams.
  */
 @Mixin(RenderDragon.class)
-public class MixinRenderDragon {
+public abstract class MixinRenderDragon {
     @Unique
     private static final NamespacedId END_CRYSTAL_BEAM = new NamespacedId("minecraft", "end_crystal_beam");
 
     @Unique
     private int angelica$previousEntityId = -1;
 
+    @Unique
+    private boolean angelica$deathBeamsActive = false;
+
+    @Unique
+    private int angelica$depthPassReplay = 0;
+
+    @Invoker("renderEquippedItems")
+    protected abstract void angelica$invokeRenderEquippedItems(EntityDragon dragon, float partialTicks);
+
     @Inject(
         method = "doRender(Lnet/minecraft/entity/boss/EntityDragon;DDDFF)V",
         at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glPushMatrix()V", ordinal = 0, shift = At.Shift.AFTER, remap = false)
@@ -52,4 +68,58 @@ public class MixinRenderDragon {
             angelica$previousEntityId = -1;
         }
     }
+
+    /**
+     * We adapt the 2 pass structure that Modern Iris uses for the death beams.
+     * Replay like this so mixins that target the vanilla code hopefully runs too.
+     * <p>
+     * Pass 1: Write the depth buffer.
+     * Pass 2: Write color.
+    */
+    @Inject(method = "renderEquippedItems(Lnet/minecraft/entity/boss/EntityDragon;F)V", at = @At("HEAD"))
+    private void angelica$beginDeathBeamsLightningBuffer(EntityDragon dragon, float partialTicks, CallbackInfo ci) {
+        if (angelica$depthPassReplay > 0) return;
+        if (dragon.deathTicks > 0) {
+            GbufferPrograms.setupSpecialRenderCondition(SpecialCondition.LIGHTNING);
+            angelica$deathBeamsActive = true;
+
+            angelica$depthPassReplay++;
+            GLStateManager.glColorMask(false, false, false, false);
+            angelica$invokeRenderEquippedItems(dragon, partialTicks);
+            GLStateManager.glColorMask(true, true, true, true);
+            angelica$depthPassReplay--;
+        }
+    }
+
+    // Don't render items twice
+    @WrapOperation(
+        method = "renderEquippedItems(Lnet/minecraft/entity/boss/EntityDragon;F)V",
+        at = @At(value = "INVOKE", target = "Lnet/minecraft/client/renderer/entity/RenderLiving;renderEquippedItems(Lnet/minecraft/entity/EntityLivingBase;F)V")
+    )
+    private void angelica$skipSuperDuringReplay(RenderDragon self, EntityLivingBase entity, float partialTicks, Operation<Void> original) {
+        if (angelica$depthPassReplay == 0) {
+            original.call(self, entity, partialTicks);
+        }
+    }
+
+    // No-op the depth buffer being set to false on first pass
+    @WrapOperation(
+        method = "renderEquippedItems(Lnet/minecraft/entity/boss/EntityDragon;F)V",
+        at = @At(value = "INVOKE", target = "Lorg/lwjgl/opengl/GL11;glDepthMask(Z)V", ordinal = 0, remap = false)
+    )
+    private void angelica$keepDepthMaskDuringReplay(boolean flag, Operation<Void> original) {
+        if (angelica$depthPassReplay == 0) {
+            original.call(flag);
+        }
+    }
+
+    // End replay
+    @Inject(method = "renderEquippedItems(Lnet/minecraft/entity/boss/EntityDragon;F)V", at = @At("RETURN"))
+    private void angelica$endDeathBeamsLighting(EntityDragon dragon, float partialTicks, CallbackInfo ci) {
+        if (angelica$depthPassReplay > 0) return;
+        if (angelica$deathBeamsActive) {
+            GbufferPrograms.teardownSpecialRenderCondition();
+            angelica$deathBeamsActive = false;
+        }
+    }
 }

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

@@ -2,6 +2,8 @@ package com.gtnewhorizons.angelica.mixins.early.shaders;
 
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.coderbot.iris.gbuffer_overrides.matching.SpecialCondition;
+import net.coderbot.iris.layer.GbufferPrograms;
 import net.coderbot.iris.uniforms.CapturedRenderingState;
 import net.coderbot.iris.uniforms.EntityIdHelper;
 import net.minecraft.client.renderer.entity.Render;
@@ -25,7 +27,14 @@ 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);
+        final boolean lightning = EntityIdHelper.isLightningBolt(entity);
+        if (lightning) {
+            GbufferPrograms.setupSpecialRenderCondition(SpecialCondition.LIGHTNING);
+        }
         original.call(render, entity, x, y, z, entityYaw, partialTicks);
+        if (lightning) {
+            GbufferPrograms.teardownSpecialRenderCondition();
+        }
         CapturedRenderingState.INSTANCE.setCurrentEntity(-1);
     }
 }

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

@@ -2,6 +2,8 @@ package com.gtnewhorizons.angelica.mixins.early.shaders;
 
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
+import net.coderbot.iris.gbuffer_overrides.matching.SpecialCondition;
+import net.coderbot.iris.layer.GbufferPrograms;
 import net.coderbot.iris.uniforms.CapturedRenderingState;
 import net.coderbot.iris.uniforms.EntityIdHelper;
 import net.minecraft.client.renderer.entity.Render;
@@ -23,7 +25,14 @@ 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);
+        final boolean lightning = EntityIdHelper.isLightningBolt(entity);
+        if (lightning) {
+            GbufferPrograms.setupSpecialRenderCondition(SpecialCondition.LIGHTNING);
+        }
         original.call(render, entity, x, y, z, entityYaw, partialTicks);
+        if (lightning) {
+            GbufferPrograms.teardownSpecialRenderCondition();
+        }
         CapturedRenderingState.INSTANCE.setCurrentEntity(-1);
     }
 }

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

@@ -0,0 +1,17 @@
+package com.gtnewhorizons.angelica.mixins.early.shaders;
+
+import net.coderbot.iris.block_rendering.BlockRenderingSettings;
+import net.minecraft.world.World;
+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(World.class)
+public class MixinWorldNbtCache {
+
+    @Inject(method = "markBlockForUpdate", at = @At("HEAD"))
+    private void angelica$onMarkBlockForUpdate(int x, int y, int z, CallbackInfo ci) {
+        BlockRenderingSettings.invalidateTeNbtCache(x, y, z);
+    }
+}