Do less work (#1971 )

fix(DisplayListVBO): guard against null VAO and zero-count draw during display list replay (#1969 )
Cache a few more things on glsm (#1970 )
2026-11-15 01:34:48 +00:00 · 2026-07-28 15:24:36 -07:00 · 2026-07-28 13:28:59 -07:00 · 2026-07-28 13:28:25 -07:00 · 2026-07-27 19:14:19 -07:00 · 2026-07-27 10:54:26 -07:00
194 changed files with 5765 additions and 1167 deletions
@@ -1,4 +1,4 @@
-# Description or your *PR* and other info
+# Description of your *PR* and other info
 <!-- Please include a summary of the change -->
 <!-- Any details that you think are important to review this PR? -->
 <!-- Are there any Issues / PRs related to this one? -->
@@ -12,6 +12,7 @@ build/
 /config/
 /crash-reports/
 /logs/
+tmp/
 options.txt
 /saves/
 usernamecache.json
@@ -90,13 +90,17 @@ dependencies {
    compileOnly "org.apache.ant:ant:1.8.2"

    // Celeritas (transitive=false: deps provided by GTNHLib/runtime)
-    embedOnly("org.embeddedt.celeritas:celeritas-common:2.5.4-GTNH") { transitive = false }
+    embedOnly("org.embeddedt.celeritas:celeritas-common:2.5.8-GTNH") { transitive = false }
    embedOnly("org.embeddedt.celeritas:celeritas-lwjgl2-service:2.5.3-GTNH") { transitive = false }

    // Because who doesn't want NEI
    devOnlyNonPublishable('com.github.GTNewHorizons:NotEnoughItems:2.8.35-GTNH:dev')
    devOnlyNonPublishable('com.github.GTNewHorizons:CodeChickenCore:1.4.7:dev')

+    // BQ Testing
+//    devOnlyNonPublishable("com.github.GTNewHorizons:BetterQuesting:3.8.74-GTNH:dev")
+
+
    // Display List Testing
    /*
    runtimeOnlyNonPublishable("com.github.GTNewHorizons:Applied-Energistics-2-Unofficial:rv3-beta-749-GTNH:dev")
@@ -144,7 +148,7 @@ dependencies {
    compileOnly(rfg.deobf("curse.maven:campfirebackport-387444:4611675"))
    compileOnly(rfg.deobf("curse.maven:xaeros-minimap-263420:5060684"))
    compileOnly(rfg.deobf("curse.maven:security-craft-64760:2818228"))
-    compileOnly(rfg.deobf("curse.maven:et-futurum-requiem-441392:5873837"))
+    compileOnly("ganymedes01.etfuturum:Et-Futurum-Requiem:2.6.49-GTNH:dev")
    compileOnly(rfg.deobf("curse.maven:biomes-o-plenty-220318:2499612"))

    devOnlyNonPublishable("com.github.GTNewHorizons:CosmeticArmorReworked:1.0.3-GTNH:dev")
@@ -180,4 +184,6 @@ dependencies {
    }

    compileOnly("mega:fluidlogged-mc1.7.10:0.1.2")
+
+    compileOnly("com.cardinalstar.cubicchunks:CubicChunks1710:v0.1.5-alpha:dev") { transitive = false }
 }
@@ -146,9 +146,13 @@ val downgradeTestClasses by tasks.registering(DowngradeFiles::class) {
    dependsOn(tasks.named("testClasses"))
 }

-tasks.test {
-    useJUnitPlatform()
+val GL_TASK_TAGS = mapOf(
+    "glCompatTest" to "gl-compat",
+    "glCoreTest" to "gl-core",
+    "glSharedTest" to "gl-shared",
+)

+fun Test.configureGlsmJava8() {
    javaLauncher = javaToolchains.launcherFor {
        languageVersion = JavaLanguageVersion.of(8)
        if (System.getProperty("os.name").lowercase().contains("mac")
@@ -171,23 +175,53 @@ tasks.test {
    classpath = downgradedTest
        .plus(downgradedMain)
        .plus(downgradedDeps)
-        .plus(classpath.minus(mainClassesDirs).minus(testClassesDirs).minus(depsToDowngrade))
+        .plus(sourceSets["test"].runtimeClasspath.minus(mainClassesDirs).minus(testClassesDirs).minus(depsToDowngrade))

    val extractNatives = rootProject.tasks.named("extractNatives2")
    dependsOn(extractNatives)
    jvmArgs("-Djava.library.path=${extractNatives.get().property("destinationFolder").let { (it as DirectoryProperty).asFile.get().path }}")
 }

+tasks.test {
+    useJUnitPlatform {
+        excludeTags = GL_TASK_TAGS.values.toSet()
+    }
+    configureGlsmJava8()
+}
+
+val glTestTasks = GL_TASK_TAGS.map { (taskName, tag) ->
+    tasks.register<Test>(taskName) {
+        description = "Runs the $tag GL tests in their own JVM, so they get their own Display and GL profile."
+        group = "verification"
+        useJUnitPlatform {
+            includeTags = setOf(tag)
+        }
+        configureGlsmJava8()
+    }
+}
+
+(listOf(tasks.test) + glTestTasks).zipWithNext { earlier, later ->
+    later.configure { mustRunAfter(earlier) }
+}
+tasks.test { finalizedBy(glTestTasks) }
+
 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"
+    dependsOn(tasks.test, glTestTasks)
+}
+(listOf(tasks.test) + glTestTasks).forEach { testTask ->
+    val name = testTask.name
+    val verify = tasks.register("verify${name.replaceFirstChar { it.uppercase() }}Ran") {
+        val resultsDir = layout.buildDirectory.dir("test-results/$name")
+        dependsOn(testTask)
+        doLast {
+            val dir = resultsDir.get().asFile
+            val xmls = dir.listFiles { f -> f.name.startsWith("TEST-") && f.name.endsWith(".xml") } ?: emptyArray()
+            check(xmls.isNotEmpty()) {
+                ":glsm:$name produced no TEST-*.xml in $dir - test task likely went NO-SOURCE"
+            }
        }
    }
+    verifyTestsRan.configure { dependsOn(verify) }
 }
 tasks.check { dependsOn(verifyTestsRan) }

@@ -1,6 +1,6 @@
 lwjglVersion = 2.9.4-nightly-20150209
 eventbusVersion = 7.0-beta.15
-celeritasVersion = 2.5.3-GTNH
+celeritasVersion = 2.5.8-GTNH
 lombokVersion = 1.18.42
 log4jVersion = 2.0-beta9
 guavaVersion = 18.0
@@ -877,9 +877,14 @@ public class DisplayListManager {
            // Empty display list - per OpenGL spec, still valid after glNewList/glEndList
            compiled = CompiledDisplayList.EMPTY;
        }
-        final CompiledDisplayList previous = displayListCache.put(glListId, compiled);
-        if (previous != null && previous != CompiledDisplayList.EMPTY && previous != compiled) {
-            previous.delete();
+        final boolean locked = GLStateManager.acquireDrawLock();
+        try {
+            final CompiledDisplayList previous = displayListCache.put(glListId, compiled);
+            if (previous != null && previous != CompiledDisplayList.EMPTY && previous != compiled) {
+                previous.delete();
+            }
+        } finally {
+            if (locked) GLStateManager.releaseDrawLock();
        }

        // Log compilation details if enabled (before context restoration changes glListId)
@@ -1012,33 +1017,43 @@ public class DisplayListManager {
    }

    private static void executeDisplayList(int list) {
-        final CompiledDisplayList compiled = displayListCache.get(list);
-        if (compiled != null) {
-            compiled.render(list);
-            return;
-        }
-
-        // Fall back to VBOManager or legacy display list
-        if (list < 0) {
-            // Negative IDs are VBOManager space (entity models, etc.)
-            final VertexBuffer vbo = VBOManager.get(list);
-            if (vbo != null) {
-                vbo.render();
+        final boolean locked = GLStateManager.acquireDrawLock();
+        try {
+            final CompiledDisplayList compiled = displayListCache.get(list);
+            if (compiled != null) {
+                compiled.render(list);
+                return;
            }
-            // Per OpenGL spec: if list is undefined, glCallList has no effect
+
+            // Fall back to VBOManager or legacy display list
+            if (list < 0) {
+                // Negative IDs are VBOManager space (entity models, etc.)
+                final VertexBuffer vbo = VBOManager.get(list);
+                if (vbo != null) {
+                    vbo.render();
+                }
+                // Per OpenGL spec: if list is undefined, glCallList has no effect
+            }
+            // An uncached positive-ID list = no-op (per OpenGL spec)
+        } finally {
+            if (locked) GLStateManager.releaseDrawLock();
        }
-        // An uncached positive-ID list = no-op (per OpenGL spec)
    }

    /**
     * Delete display lists and free their VBO resources.
     */
    public static void glDeleteLists(int list, int range) {
-        for (int i = list; i < list + range; i++) {
-            CompiledDisplayList compiled = displayListCache.remove(i);
-            if (compiled != null) {
-                compiled.delete();
+        final boolean locked = GLStateManager.acquireDrawLock();
+        try {
+            for (int i = list; i < list + range; i++) {
+                CompiledDisplayList compiled = displayListCache.remove(i);
+                if (compiled != null) {
+                    compiled.delete();
+                }
            }
+        } finally {
+            if (locked) GLStateManager.releaseDrawLock();
        }
    }

@@ -57,8 +57,8 @@ import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.joml.Matrix4d;
 import org.joml.Matrix4f;
-import org.joml.Matrix4fc;
 import org.joml.Matrix4fStack;
+import org.joml.Matrix4fc;
 import org.joml.Vector3d;
 import org.joml.Vector3f;
 import org.joml.Vector4f;
@@ -89,6 +89,7 @@ import java.nio.ByteBuffer;
 import java.nio.DoubleBuffer;
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
+import java.nio.LongBuffer;
 import java.nio.ShortBuffer;
 import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
@@ -96,6 +97,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.IntSupplier;

 import static com.gtnewhorizons.angelica.glsm.Vendor.AMD;
@@ -251,6 +253,18 @@ public class GLStateManager {
    // Reference to DrawableGL (main display context) - works with both FML and BLS splash
    @Setter private static Drawable drawableGL = null;

+    private static final ReentrantLock DRAW_LOCK = new ReentrantLock();
+
+    public static boolean acquireDrawLock() {
+        if (splashComplete) return false;
+        DRAW_LOCK.lock();
+        return true;
+    }
+
+    public static void releaseDrawLock() {
+        DRAW_LOCK.unlock();
+    }
+
    public static boolean isCachingEnabled() {
        if (splashComplete) return true;
        return Thread.currentThread() == drawableGLHolder;
@@ -367,16 +381,16 @@ public class GLStateManager {
    @Getter protected static final BooleanStateStack ditherState = new BooleanStateStack(GL11.GL_DITHER, true); // Defaults to true per OpenGL spec
    @Getter protected static final BooleanStateStack stencilTest = new BooleanStateStack(GL11.GL_STENCIL_TEST);
    @Getter protected static final BooleanStateStack lineSmoothState = new BooleanStateStack(GL11.GL_LINE_SMOOTH);
-    @Getter protected static final BooleanStateStack lineStippleState = new BooleanStateStack(GL11.GL_LINE_STIPPLE);
-    @Getter protected static final BooleanStateStack pointSmoothState = new BooleanStateStack(GL11.GL_POINT_SMOOTH);
+    @Getter protected static final BooleanStateStack lineStippleState = new BooleanStateStack(GL11.GL_LINE_STIPPLE, false, true);
+    @Getter protected static final BooleanStateStack pointSmoothState = new BooleanStateStack(GL11.GL_POINT_SMOOTH, false, true);
    @Getter protected static final BooleanStateStack polygonSmoothState = new BooleanStateStack(GL11.GL_POLYGON_SMOOTH);
-    @Getter protected static final BooleanStateStack polygonStippleState = new BooleanStateStack(GL11.GL_POLYGON_STIPPLE);
+    @Getter protected static final BooleanStateStack polygonStippleState = new BooleanStateStack(GL11.GL_POLYGON_STIPPLE, false, true);
    @Getter protected static final BooleanStateStack multisampleState = new BooleanStateStack(GL13.GL_MULTISAMPLE, true); // Defaults to true per OpenGL spec
    @Getter protected static final BooleanStateStack sampleAlphaToCoverageState = new BooleanStateStack(GL13.GL_SAMPLE_ALPHA_TO_COVERAGE);
    @Getter protected static final BooleanStateStack sampleAlphaToOneState = new BooleanStateStack(GL13.GL_SAMPLE_ALPHA_TO_ONE);
    @Getter protected static final BooleanStateStack sampleCoverageState = new BooleanStateStack(GL13.GL_SAMPLE_COVERAGE);
    @Getter protected static final BooleanStateStack colorLogicOpState = new BooleanStateStack(GL11.GL_COLOR_LOGIC_OP);
-    @Getter protected static final BooleanStateStack indexLogicOpState = new BooleanStateStack(GL11.GL_INDEX_LOGIC_OP);
+    @Getter protected static final BooleanStateStack indexLogicOpState = new BooleanStateStack(GL11.GL_INDEX_LOGIC_OP, false, true);

    // Polygon offset states (enable bits)
    @Getter protected static final BooleanStateStack polygonOffsetPointState = new BooleanStateStack(GL11.GL_POLYGON_OFFSET_POINT);
@@ -396,6 +410,7 @@ public class GLStateManager {
     * {@link com.gtnewhorizons.angelica.glsm.ffp.VertexKey}.
     */
    public static boolean wideLineEmulationActive = false;
+    public static boolean lineStippleActive = false;

    // Point state (GL_POINT_BIT)
    @Getter protected static final PointStateStack pointState = new PointStateStack();
@@ -407,25 +422,25 @@ public class GLStateManager {
    @Getter protected static final StencilStateStack stencilState = new StencilStateStack();
    private static int stencilBitMask = 0xFFFFFFFF;

-    @Getter protected static final BooleanStateStack autoNormalState = new BooleanStateStack(GL11.GL_AUTO_NORMAL);
-    @Getter protected static final BooleanStateStack map1Color4State = new BooleanStateStack(GL11.GL_MAP1_COLOR_4);
-    @Getter protected static final BooleanStateStack map1IndexState = new BooleanStateStack(GL11.GL_MAP1_INDEX);
-    @Getter protected static final BooleanStateStack map1NormalState = new BooleanStateStack(GL11.GL_MAP1_NORMAL);
-    @Getter protected static final BooleanStateStack map1TextureCoord1State = new BooleanStateStack(GL11.GL_MAP1_TEXTURE_COORD_1);
-    @Getter protected static final BooleanStateStack map1TextureCoord2State = new BooleanStateStack(GL11.GL_MAP1_TEXTURE_COORD_2);
-    @Getter protected static final BooleanStateStack map1TextureCoord3State = new BooleanStateStack(GL11.GL_MAP1_TEXTURE_COORD_3);
-    @Getter protected static final BooleanStateStack map1TextureCoord4State = new BooleanStateStack(GL11.GL_MAP1_TEXTURE_COORD_4);
-    @Getter protected static final BooleanStateStack map1Vertex3State = new BooleanStateStack(GL11.GL_MAP1_VERTEX_3);
-    @Getter protected static final BooleanStateStack map1Vertex4State = new BooleanStateStack(GL11.GL_MAP1_VERTEX_4);
-    @Getter protected static final BooleanStateStack map2Color4State = new BooleanStateStack(GL11.GL_MAP2_COLOR_4);
-    @Getter protected static final BooleanStateStack map2IndexState = new BooleanStateStack(GL11.GL_MAP2_INDEX);
-    @Getter protected static final BooleanStateStack map2NormalState = new BooleanStateStack(GL11.GL_MAP2_NORMAL);
-    @Getter protected static final BooleanStateStack map2TextureCoord1State = new BooleanStateStack(GL11.GL_MAP2_TEXTURE_COORD_1);
-    @Getter protected static final BooleanStateStack map2TextureCoord2State = new BooleanStateStack(GL11.GL_MAP2_TEXTURE_COORD_2);
-    @Getter protected static final BooleanStateStack map2TextureCoord3State = new BooleanStateStack(GL11.GL_MAP2_TEXTURE_COORD_3);
-    @Getter protected static final BooleanStateStack map2TextureCoord4State = new BooleanStateStack(GL11.GL_MAP2_TEXTURE_COORD_4);
-    @Getter protected static final BooleanStateStack map2Vertex3State = new BooleanStateStack(GL11.GL_MAP2_VERTEX_3);
-    @Getter protected static final BooleanStateStack map2Vertex4State = new BooleanStateStack(GL11.GL_MAP2_VERTEX_4);
+    @Getter protected static final BooleanStateStack autoNormalState = new BooleanStateStack(GL11.GL_AUTO_NORMAL, false, true);
+    @Getter protected static final BooleanStateStack map1Color4State = new BooleanStateStack(GL11.GL_MAP1_COLOR_4, false, true);
+    @Getter protected static final BooleanStateStack map1IndexState = new BooleanStateStack(GL11.GL_MAP1_INDEX, false, true);
+    @Getter protected static final BooleanStateStack map1NormalState = new BooleanStateStack(GL11.GL_MAP1_NORMAL, false, true);
+    @Getter protected static final BooleanStateStack map1TextureCoord1State = new BooleanStateStack(GL11.GL_MAP1_TEXTURE_COORD_1, false, true);
+    @Getter protected static final BooleanStateStack map1TextureCoord2State = new BooleanStateStack(GL11.GL_MAP1_TEXTURE_COORD_2, false, true);
+    @Getter protected static final BooleanStateStack map1TextureCoord3State = new BooleanStateStack(GL11.GL_MAP1_TEXTURE_COORD_3, false, true);
+    @Getter protected static final BooleanStateStack map1TextureCoord4State = new BooleanStateStack(GL11.GL_MAP1_TEXTURE_COORD_4, false, true);
+    @Getter protected static final BooleanStateStack map1Vertex3State = new BooleanStateStack(GL11.GL_MAP1_VERTEX_3, false, true);
+    @Getter protected static final BooleanStateStack map1Vertex4State = new BooleanStateStack(GL11.GL_MAP1_VERTEX_4, false, true);
+    @Getter protected static final BooleanStateStack map2Color4State = new BooleanStateStack(GL11.GL_MAP2_COLOR_4, false, true);
+    @Getter protected static final BooleanStateStack map2IndexState = new BooleanStateStack(GL11.GL_MAP2_INDEX, false, true);
+    @Getter protected static final BooleanStateStack map2NormalState = new BooleanStateStack(GL11.GL_MAP2_NORMAL, false, true);
+    @Getter protected static final BooleanStateStack map2TextureCoord1State = new BooleanStateStack(GL11.GL_MAP2_TEXTURE_COORD_1, false, true);
+    @Getter protected static final BooleanStateStack map2TextureCoord2State = new BooleanStateStack(GL11.GL_MAP2_TEXTURE_COORD_2, false, true);
+    @Getter protected static final BooleanStateStack map2TextureCoord3State = new BooleanStateStack(GL11.GL_MAP2_TEXTURE_COORD_3, false, true);
+    @Getter protected static final BooleanStateStack map2TextureCoord4State = new BooleanStateStack(GL11.GL_MAP2_TEXTURE_COORD_4, false, true);
+    @Getter protected static final BooleanStateStack map2Vertex3State = new BooleanStateStack(GL11.GL_MAP2_VERTEX_3, false, true);
+    @Getter protected static final BooleanStateStack map2Vertex4State = new BooleanStateStack(GL11.GL_MAP2_VERTEX_4, false, true);

    // Clip plane states
    @Getter protected static final BooleanStateStack[] clipPlaneStates = new BooleanStateStack[MAX_CLIP_PLANES];
@@ -1036,6 +1051,7 @@ public class GLStateManager {
            case GL11.GL_SHADE_MODEL -> shadeModelState.getValue();
            // GL_TEXTURE_2D makes no sense here, but some mod still queries it...
            case GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_BINDING_2D -> getBoundTextureForServerState();
+            case GL13.GL_ACTIVE_TEXTURE -> GL13.GL_TEXTURE0 + getActiveTextureUnitForServerState();
            case GL11.GL_COLOR_MATERIAL_FACE -> colorMaterialFace.getValue();
            case GL11.GL_COLOR_MATERIAL_PARAMETER -> colorMaterialParameter.getValue();
            case GL11.GL_MODELVIEW_STACK_DEPTH -> getMatrixStackDepth(modelViewMatrix);
@@ -1044,15 +1060,18 @@ public class GLStateManager {
            case GL12.GL_LIGHT_MODEL_COLOR_CONTROL -> lightModel.colorControl;

            case GL14.GL_BLEND_DST_ALPHA -> blendState.getDstAlpha();
-            case GL14.GL_BLEND_DST_RGB -> blendState.getDstRgb();
+            case GL11.GL_BLEND_DST, GL14.GL_BLEND_DST_RGB -> blendState.getDstRgb();
            case GL14.GL_BLEND_SRC_ALPHA -> blendState.getSrcAlpha();
-            case GL14.GL_BLEND_SRC_RGB -> blendState.getSrcRgb();
+            case GL11.GL_BLEND_SRC, GL14.GL_BLEND_SRC_RGB -> blendState.getSrcRgb();
            case GL14.GL_BLEND_EQUATION -> blendState.getEquationRgb();
            case GL20.GL_BLEND_EQUATION_ALPHA -> blendState.getEquationAlpha();

            case GL11.GL_LOGIC_OP_MODE -> logicOpMode.getValue();
            case GL11.GL_DRAW_BUFFER -> drawBuffer.getValue();

+            case GL11.GL_CULL_FACE_MODE -> polygonState.getCullFaceMode();
+            case GL11.GL_FRONT_FACE -> polygonState.getFrontFace();
+
            case GL11.GL_STENCIL_FUNC -> stencilState.getFuncFront();
            case GL11.GL_STENCIL_REF -> stencilState.getRefFront();
            case GL11.GL_STENCIL_VALUE_MASK -> stencilState.getValueMaskFront();
@@ -1091,6 +1110,10 @@ public class GLStateManager {

        switch (pname) {
            case GL11.GL_VIEWPORT -> viewportState.get(params);
+            case GL11.GL_POLYGON_MODE -> {
+                params.put(0, polygonState.getFrontMode());
+                params.put(1, polygonState.getBackMode());
+            }
            default -> {
                if (!HAS_MULTIPLE_SET.contains(pname)) {
                    params.put(0, glGetInteger(pname));
@@ -2243,15 +2266,25 @@ public class GLStateManager {
    }

    public static void preDraw(int drawMode) {
-        prepareWideLineEmulation(drawMode);
-        ShaderManager.getInstance().preDraw();
-        prepareClientArrays();
+        final boolean locked = acquireDrawLock();
+        try {
+            prepareLineEmulation(drawMode);
+            ShaderManager.getInstance().preDraw();
+            prepareClientArrays();
+        } finally {
+            if (locked) releaseDrawLock();
+        }
    }

    public static void preDraw() {
-        disableWideLineEmulation();
-        ShaderManager.getInstance().preDraw();
-        prepareClientArrays();
+        final boolean locked = acquireDrawLock();
+        try {
+            disableLineEmulation();
+            ShaderManager.getInstance().preDraw();
+            prepareClientArrays();
+        } finally {
+            if (locked) releaseDrawLock();
+        }
    }

    public static void glDrawElements(int mode, ByteBuffer indices) {
@@ -3245,6 +3278,7 @@ public class GLStateManager {
        splashComplete = true;
        drawableGLHolder = null;
        drawableGL = null;
+        ImmediateModeRecorder.cleanupOrphanTessellators();
    }

    public static void glNewList(int list, int mode) {
@@ -4054,8 +4088,8 @@ public class GLStateManager {
            return RENDER_BACKEND.getTexLevelParameteri(target, level, pname);
        }
        return switch (pname) {
-            case GL11.GL_TEXTURE_WIDTH -> info.getWidth();
-            case GL11.GL_TEXTURE_HEIGHT -> info.getHeight();
+            case GL11.GL_TEXTURE_WIDTH -> Math.max(info.getWidth() >> level, 1);
+            case GL11.GL_TEXTURE_HEIGHT -> Math.max(info.getHeight() >> level, 1);
            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()));
@@ -4581,15 +4615,21 @@ public class GLStateManager {
        }
    }

-    public static void prepareWideLineEmulation(int drawMode) {
-        wideLineEmulationActive =
-            (drawMode == GL11.GL_LINES || drawMode == GL11.GL_LINE_STRIP || drawMode == GL11.GL_LINE_LOOP)
-                && lineState.getWidth() > 1.0f
-                && wideLineEmulationEnabled;
+    public static void prepareLineEmulation(int drawMode) {
+        final boolean isLine = drawMode == GL11.GL_LINES || drawMode == GL11.GL_LINE_STRIP || drawMode == GL11.GL_LINE_LOOP;
+        wideLineEmulationActive = isLine && lineState.getWidth() > 1.0f && wideLineEmulationEnabled;
+        setLineStippleActive(isLine && lineStippleState.isEnabled());
    }

-    public static void disableWideLineEmulation() {
+    public static void disableLineEmulation() {
        wideLineEmulationActive = false;
+        setLineStippleActive(false);
+    }
+
+    private static void setLineStippleActive(boolean active) {
+        if (lineStippleActive == active) return;
+        lineStippleActive = active;
+        RENDER_BACKEND.provokingVertex(active ? GL32.GL_FIRST_VERTEX_CONVENTION : GL32.GL_LAST_VERTEX_CONVENTION);
    }

    public static void glFlush() {
@@ -5174,17 +5214,20 @@ public class GLStateManager {
        RENDER_BACKEND.deleteBuffers(buffers);
    }

+    public static void glDeleteBuffers(int[] buffers) {
+        for (int buffer : buffers) {
+            glDeleteBuffers(buffer);
+        }
+    }
+
    private static void invalidateDeletedBuffer(int buffer) {
        if (buffer == 0) return;
-        if (boundVBO == buffer) boundVBO = 0;
-        if (VAOManager.boundEBO == buffer) VAOManager.boundEBO = 0;
-        if (boundPixelUnpackBuffer == buffer) boundPixelUnpackBuffer = 0;
-        if (boundPixelPackBuffer == buffer) boundPixelPackBuffer = 0;
+        if (boundVBO == buffer) glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+        if (VAOManager.boundEBO == buffer) glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
+        if (boundPixelUnpackBuffer == buffer) glBindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, 0);
+        if (boundPixelPackBuffer == buffer) glBindBuffer(GL21.GL_PIXEL_PACK_BUFFER, 0);

-        // Sweep all VAOs: an unbound VAO may later rebind with a dangling EBO id.
-        for (VAOManager.VAOData data : VAOManager.vaoMap.values()) {
-            if (data.ebo == buffer) data.ebo = 0;
-        }
+        VAOManager.onDeleteBuffer(buffer);
    }

    public static void glBindBuffer(int target, int buffer) {
@@ -5209,9 +5252,21 @@ public class GLStateManager {
        PixelUnpackState.applyDiff(applied, pixelUnpackState);
    }

+    private static boolean warnedUntrackedPixelBuffer;
+
+    private static void warnUntrackedPixelBuffer(int binding, String name) {
+        if (warnedUntrackedPixelBuffer || initConfig == null || !initConfig.isLwjglDebug()) return;
+        final int actual = RENDER_BACKEND.getInteger(binding);
+        if (actual == 0) return;
+        warnedUntrackedPixelBuffer = true;
+        LOGGER.warn("{} is bound to {} but GLSM's cache says 0; a call site bypassed GLStateManager.glBindBuffer", name, actual, new Throwable());
+    }
+
    static void suspendPixelUnpackBuffer() {
        if (boundPixelUnpackBuffer != 0) {
            RENDER_BACKEND.bindBuffer(GL21.GL_PIXEL_UNPACK_BUFFER, 0);
+        } else {
+            warnUntrackedPixelBuffer(GL21.GL_PIXEL_UNPACK_BUFFER_BINDING, "GL_PIXEL_UNPACK_BUFFER");
        }
    }

@@ -5224,6 +5279,8 @@ public class GLStateManager {
    static void suspendPixelPackBuffer() {
        if (boundPixelPackBuffer != 0) {
            RENDER_BACKEND.bindBuffer(GL21.GL_PIXEL_PACK_BUFFER, 0);
+        } else {
+            warnUntrackedPixelBuffer(GL21.GL_PIXEL_PACK_BUFFER_BINDING, "GL_PIXEL_PACK_BUFFER");
        }
    }

@@ -5237,34 +5294,279 @@ public class GLStateManager {
        return RENDER_BACKEND.genBuffers();
    }

+    public static void glGenBuffers(IntBuffer buffers) {
+        for (int i = buffers.position(); i < buffers.limit(); i++) buffers.put(i, RENDER_BACKEND.genBuffers());
+    }
+
+    public static void glGenBuffers(int[] buffers) {
+        for (int i = 0; i < buffers.length; i++) buffers[i] = RENDER_BACKEND.genBuffers();
+    }
+
+    public static int glCreateBuffers() {
+        return RENDER_BACKEND.createBuffers();
+    }
+
+    public static void glCreateBuffers(IntBuffer buffers) {
+        for (int i = buffers.position(); i < buffers.limit(); i++) buffers.put(i, RENDER_BACKEND.createBuffers());
+    }
+
+    public static void glCreateBuffers(int[] buffers) {
+        for (int i = 0; i < buffers.length; i++) buffers[i] = RENDER_BACKEND.createBuffers();
+    }
+
    public static void glBufferData(int target, long size, int usage) { RENDER_BACKEND.bufferData(target, size, usage); }
+    public static void glBufferData(int target, ByteBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
+    public static void glBufferData(int target, ShortBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
+    public static void glBufferData(int target, IntBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
+    public static void glBufferData(int target, FloatBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
+    public static void glBufferData(int target, DoubleBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
+    public static void glBufferData(int target, LongBuffer data, int usage) { glBufferData(target, MemoryUtilities.memByteBuffer(data), usage); }
    public static void glBufferData(int target, int[] data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
    public static void glBufferData(int target, float[] data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
-    public static void glBufferData(int target, java.nio.ByteBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
-    public static void glBufferData(int target, java.nio.ShortBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
-    public static void glBufferData(int target, java.nio.IntBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
-    public static void glBufferData(int target, java.nio.FloatBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
-    public static void glBufferData(int target, java.nio.DoubleBuffer data, int usage) { RENDER_BACKEND.bufferData(target, data, usage); }
-    public static void glBufferSubData(int target, long offset, java.nio.ByteBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
-    public static void glBufferSubData(int target, long offset, java.nio.ShortBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
-    public static void glBufferSubData(int target, long offset, java.nio.IntBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
-    public static void glBufferSubData(int target, long offset, java.nio.FloatBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
-    public static void glBufferSubData(int target, long offset, java.nio.DoubleBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
+    public static void glBufferData(int target, short[] data, int usage) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferData(target, copy, usage);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glBufferData(int target, long[] data, int usage) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferData(target, copy, usage);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glBufferData(int target, double[] data, int usage) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferData(target, copy, usage);
+        MemoryUtilities.memFree(copy);
+    }
+
+    public static void nglBufferData(int target, long size, long data, int usage) {
+        if (data == 0L) {
+            glBufferData(target, size, usage);
+            return;
+        }
+        glBufferData(target, MemoryUtilities.memByteBuffer(data, checkedSize(size)), usage);
+    }
+
+    public static void glBufferSubData(int target, long offset, ByteBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
+    public static void glBufferSubData(int target, long offset, ShortBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
+    public static void glBufferSubData(int target, long offset, IntBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
+    public static void glBufferSubData(int target, long offset, FloatBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
+    public static void glBufferSubData(int target, long offset, DoubleBuffer data) { RENDER_BACKEND.bufferSubData(target, offset, data); }
+    public static void glBufferSubData(int target, long offset, LongBuffer data) { glBufferSubData(target, offset, MemoryUtilities.memByteBuffer(data)); }
+    public static void glBufferSubData(int target, long offset, short[] data) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferSubData(target, offset, copy);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glBufferSubData(int target, long offset, int[] data) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferSubData(target, offset, copy);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glBufferSubData(int target, long offset, long[] data) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferSubData(target, offset, copy);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glBufferSubData(int target, long offset, float[] data) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferSubData(target, offset, copy);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glBufferSubData(int target, long offset, double[] data) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferSubData(target, offset, copy);
+        MemoryUtilities.memFree(copy);
+    }
+
+    public static void nglBufferSubData(int target, long offset, long size, long data) { glBufferSubData(target, offset, MemoryUtilities.memByteBuffer(data, checkedSize(size))); }
+
    public static ByteBuffer glMapBuffer(int target, int access) { return RENDER_BACKEND.mapBuffer(target, access); }
+    public static ByteBuffer glMapBuffer(int target, int access, ByteBuffer old_buffer) { return glMapBuffer(target, access); }
    public static ByteBuffer glMapBuffer(int target, int access, long length, ByteBuffer old_buffer) { return RENDER_BACKEND.mapBuffer(target, access, length, old_buffer); }
+    public static ByteBuffer glMapBufferRange(int target, long offset, long length, int access) { return RENDER_BACKEND.mapBufferRange(target, offset, length, access); }
+    public static ByteBuffer glMapBufferRange(int target, long offset, long length, int access, ByteBuffer old_buffer) { return glMapBufferRange(target, offset, length, access); }
+    public static void glFlushMappedBufferRange(int target, long offset, long length) { RENDER_BACKEND.flushMappedBufferRange(target, offset, length); }
    public static boolean glUnmapBuffer(int target) { return RENDER_BACKEND.unmapBuffer(target); }
-    public static void glGetBufferSubData(int target, long offset, java.nio.ByteBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
-    public static void glGetBufferSubData(int target, long offset, java.nio.ShortBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
-    public static void glGetBufferSubData(int target, long offset, java.nio.IntBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
-    public static void glGetBufferSubData(int target, long offset, java.nio.FloatBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
-    public static void glGetBufferSubData(int target, long offset, java.nio.DoubleBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
+
+    public static void glGetBufferSubData(int target, long offset, ByteBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
+    public static void glGetBufferSubData(int target, long offset, ShortBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
+    public static void glGetBufferSubData(int target, long offset, IntBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
+    public static void glGetBufferSubData(int target, long offset, FloatBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
+    public static void glGetBufferSubData(int target, long offset, DoubleBuffer data) { RENDER_BACKEND.getBufferSubData(target, offset, data); }
+    public static void glGetBufferSubData(int target, long offset, LongBuffer data) { glGetBufferSubData(target, offset, MemoryUtilities.memByteBuffer(data)); }
+    public static void glGetBufferSubData(int target, long offset, short[] data) {
+        final ByteBuffer copy = MemoryUtilities.memAlloc(data.length << 1);
+        glGetBufferSubData(target, offset, copy);
+        copy.asShortBuffer().get(data);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glGetBufferSubData(int target, long offset, int[] data) {
+        final ByteBuffer copy = MemoryUtilities.memAlloc(data.length << 2);
+        glGetBufferSubData(target, offset, copy);
+        copy.asIntBuffer().get(data);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glGetBufferSubData(int target, long offset, long[] data) {
+        final ByteBuffer copy = MemoryUtilities.memAlloc(data.length << 3);
+        glGetBufferSubData(target, offset, copy);
+        copy.asLongBuffer().get(data);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glGetBufferSubData(int target, long offset, float[] data) {
+        final ByteBuffer copy = MemoryUtilities.memAlloc(data.length << 2);
+        glGetBufferSubData(target, offset, copy);
+        copy.asFloatBuffer().get(data);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glGetBufferSubData(int target, long offset, double[] data) {
+        final ByteBuffer copy = MemoryUtilities.memAlloc(data.length << 3);
+        glGetBufferSubData(target, offset, copy);
+        copy.asDoubleBuffer().get(data);
+        MemoryUtilities.memFree(copy);
+    }
+
+    public static void nglGetBufferSubData(int target, long offset, long size, long data) { glGetBufferSubData(target, offset, MemoryUtilities.memByteBuffer(data, checkedSize(size))); }
+
    public static int glGetBufferParameteri(int target, int pname) { return RENDER_BACKEND.getBufferParameteri(target, pname); }
-    public static void glBufferStorage(int target, java.nio.ByteBuffer data, int flags) { RENDER_BACKEND.bufferStorage(target, data, flags); }
+    public static int glGetBufferParameter(int target, int pname) { return glGetBufferParameteri(target, pname); }
+    public static void glGetBufferParameter(int target, int pname, IntBuffer params) { params.put(params.position(), glGetBufferParameteri(target, pname)); }
+    public static void glGetBufferParameteriv(int target, int pname, IntBuffer params) { params.put(params.position(), glGetBufferParameteri(target, pname)); }
+    public static void glGetBufferParameteriv(int target, int pname, int[] params) { params[0] = glGetBufferParameteri(target, pname); }
+
    public static void glBufferStorage(int target, long size, int flags) { RENDER_BACKEND.bufferStorage(target, size, flags); }
-    public static void glClearBufferSubData(int target, int internalFormat, long offset, long size, int format, int type, java.nio.ByteBuffer data) { RENDER_BACKEND.clearBufferSubData(target, internalFormat, offset, size, format, type, data); }
+    public static void glBufferStorage(int target, ByteBuffer data, int flags) { RENDER_BACKEND.bufferStorage(target, data, flags); }
+    public static void glBufferStorage(int target, ShortBuffer data, int flags) { glBufferStorage(target, MemoryUtilities.memByteBuffer(data), flags); }
+    public static void glBufferStorage(int target, IntBuffer data, int flags) { glBufferStorage(target, MemoryUtilities.memByteBuffer(data), flags); }
+    public static void glBufferStorage(int target, FloatBuffer data, int flags) { glBufferStorage(target, MemoryUtilities.memByteBuffer(data), flags); }
+    public static void glBufferStorage(int target, DoubleBuffer data, int flags) { glBufferStorage(target, MemoryUtilities.memByteBuffer(data), flags); }
+    public static void glBufferStorage(int target, short[] data, int flags) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferStorage(target, copy, flags);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glBufferStorage(int target, int[] data, int flags) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferStorage(target, copy, flags);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glBufferStorage(int target, float[] data, int flags) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferStorage(target, copy, flags);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glBufferStorage(int target, double[] data, int flags) {
+        final ByteBuffer copy = copyOf(data);
+        glBufferStorage(target, copy, flags);
+        MemoryUtilities.memFree(copy);
+    }
+
+    public static void glNamedBufferData(int buffer, long size, int usage) { RENDER_BACKEND.namedBufferData(buffer, size, usage); }
+    public static void glNamedBufferData(int buffer, ByteBuffer data, int usage) { RENDER_BACKEND.namedBufferData(buffer, data, usage); }
+    public static void glNamedBufferData(int buffer, FloatBuffer data, int usage) { RENDER_BACKEND.namedBufferData(buffer, data, usage); }
+    public static void glNamedBufferData(int buffer, ShortBuffer data, int usage) { glNamedBufferData(buffer, MemoryUtilities.memByteBuffer(data), usage); }
+    public static void glNamedBufferData(int buffer, IntBuffer data, int usage) { glNamedBufferData(buffer, MemoryUtilities.memByteBuffer(data), usage); }
+    public static void glNamedBufferData(int buffer, LongBuffer data, int usage) { glNamedBufferData(buffer, MemoryUtilities.memByteBuffer(data), usage); }
+    public static void glNamedBufferData(int buffer, DoubleBuffer data, int usage) { glNamedBufferData(buffer, MemoryUtilities.memByteBuffer(data), usage); }
+    public static void glNamedBufferData(int buffer, short[] data, int usage) {
+        final ByteBuffer copy = copyOf(data);
+        glNamedBufferData(buffer, copy, usage);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glNamedBufferData(int buffer, int[] data, int usage) {
+        final ByteBuffer copy = copyOf(data);
+        glNamedBufferData(buffer, copy, usage);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glNamedBufferData(int buffer, long[] data, int usage) {
+        final ByteBuffer copy = copyOf(data);
+        glNamedBufferData(buffer, copy, usage);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glNamedBufferData(int buffer, float[] data, int usage) {
+        final ByteBuffer copy = copyOf(data);
+        glNamedBufferData(buffer, copy, usage);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glNamedBufferData(int buffer, double[] data, int usage) {
+        final ByteBuffer copy = copyOf(data);
+        glNamedBufferData(buffer, copy, usage);
+        MemoryUtilities.memFree(copy);
+    }
+
+    public static void glNamedBufferSubData(int buffer, long offset, ByteBuffer data) { RENDER_BACKEND.namedBufferSubData(buffer, offset, data); }
+    public static void glNamedBufferSubData(int buffer, long offset, ShortBuffer data) { glNamedBufferSubData(buffer, offset, MemoryUtilities.memByteBuffer(data)); }
+    public static void glNamedBufferSubData(int buffer, long offset, IntBuffer data) { glNamedBufferSubData(buffer, offset, MemoryUtilities.memByteBuffer(data)); }
+    public static void glNamedBufferSubData(int buffer, long offset, LongBuffer data) { glNamedBufferSubData(buffer, offset, MemoryUtilities.memByteBuffer(data)); }
+    public static void glNamedBufferSubData(int buffer, long offset, FloatBuffer data) { glNamedBufferSubData(buffer, offset, MemoryUtilities.memByteBuffer(data)); }
+    public static void glNamedBufferSubData(int buffer, long offset, DoubleBuffer data) { glNamedBufferSubData(buffer, offset, MemoryUtilities.memByteBuffer(data)); }
+    public static void glNamedBufferSubData(int buffer, long offset, short[] data) {
+        final ByteBuffer copy = copyOf(data);
+        glNamedBufferSubData(buffer, offset, copy);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glNamedBufferSubData(int buffer, long offset, int[] data) {
+        final ByteBuffer copy = copyOf(data);
+        glNamedBufferSubData(buffer, offset, copy);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glNamedBufferSubData(int buffer, long offset, long[] data) {
+        final ByteBuffer copy = copyOf(data);
+        glNamedBufferSubData(buffer, offset, copy);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glNamedBufferSubData(int buffer, long offset, float[] data) {
+        final ByteBuffer copy = copyOf(data);
+        glNamedBufferSubData(buffer, offset, copy);
+        MemoryUtilities.memFree(copy);
+    }
+    public static void glNamedBufferSubData(int buffer, long offset, double[] data) {
+        final ByteBuffer copy = copyOf(data);
+        glNamedBufferSubData(buffer, offset, copy);
+        MemoryUtilities.memFree(copy);
+    }
+
+    public static void glClearBufferSubData(int target, int internalFormat, long offset, long size, int format, int type, ByteBuffer data) { RENDER_BACKEND.clearBufferSubData(target, internalFormat, offset, size, format, type, data); }
    public static boolean glIsBuffer(int buffer) { return RENDER_BACKEND.isBuffer(buffer); }
    public static void glCopyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size) { RENDER_BACKEND.copyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size); }

+    private static int checkedSize(long size) {
+        if (size < 0 || size > Integer.MAX_VALUE) {
+            throw new IllegalArgumentException("Buffer range does not fit a ByteBuffer wrapper: " + size);
+        }
+        return (int) size;
+    }
+
+    private static ByteBuffer copyOf(short[] data) {
+        final ByteBuffer bb = MemoryUtilities.memAlloc(data.length << 1);
+        bb.asShortBuffer().put(data);
+        return bb;
+    }
+
+    private static ByteBuffer copyOf(int[] data) {
+        final ByteBuffer bb = MemoryUtilities.memAlloc(data.length << 2);
+        bb.asIntBuffer().put(data);
+        return bb;
+    }
+
+    private static ByteBuffer copyOf(long[] data) {
+        final ByteBuffer bb = MemoryUtilities.memAlloc(data.length << 3);
+        bb.asLongBuffer().put(data);
+        return bb;
+    }
+
+    private static ByteBuffer copyOf(float[] data) {
+        final ByteBuffer bb = MemoryUtilities.memAlloc(data.length << 2);
+        bb.asFloatBuffer().put(data);
+        return bb;
+    }
+
+    private static ByteBuffer copyOf(double[] data) {
+        final ByteBuffer bb = MemoryUtilities.memAlloc(data.length << 3);
+        bb.asDoubleBuffer().put(data);
+        return bb;
+    }
+
    public static void glBindVertexArray(int array) {
        if (DisplayListManager.isRecording()) {
            DisplayListManager.recordBindVAO(array);
@@ -6165,7 +6467,7 @@ public class GLStateManager {
        RENDER_BACKEND.getUniformiv(program, location, params);
    }
    public static void glGetTexImage(int target, int level, int format, int type, long pixels) {
-        GL11.glGetTexImage(target, level, format, type, pixels);
+        RENDER_BACKEND.getTexImage(target, level, format, type, pixels);
    }

    /**
@@ -91,21 +91,26 @@ public final class QuadConverter {
    }

    private static void drawSharedQuadEbo(int first, int vertexCount, int primcount, boolean instanced) {
-        GLStateManager.preDraw();
-        assert first % 4 == 0 : "QuadConverter: first (" + first + ") must be a multiple of 4";
-        assert vertexCount % 4 == 0 : "QuadConverter: vertexCount (" + vertexCount + ") must be a multiple of 4";
-        final int quadCount = vertexCount / 4;
-        final int prevEbo = GLStateManager.getBoundEBO();
-        ensureCapacity(first / 4 + quadCount);
-        RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, eboId);
-        // Index offset: first vertex / 4 quads * 6 indices * 4 bytes per int
-        final long indexOffset = (long) (first / 4) * 6 * 4;
-        if (instanced) {
-            RENDER_BACKEND.drawElementsInstanced(GL11.GL_TRIANGLES, quadCount * 6, INDEX_TYPE, indexOffset, primcount);
-        } else {
-            RENDER_BACKEND.drawElements(GL11.GL_TRIANGLES, quadCount * 6, INDEX_TYPE, indexOffset);
+        final boolean locked = GLStateManager.acquireDrawLock();
+        try {
+            GLStateManager.preDraw();
+            assert first % 4 == 0 : "QuadConverter: first (" + first + ") must be a multiple of 4";
+            assert vertexCount % 4 == 0 : "QuadConverter: vertexCount (" + vertexCount + ") must be a multiple of 4";
+            final int quadCount = vertexCount / 4;
+            final int prevEbo = GLStateManager.getBoundEBO();
+            ensureCapacity(first / 4 + quadCount);
+            RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, eboId);
+            // Index offset: first vertex / 4 quads * 6 indices * 4 bytes per int
+            final long indexOffset = (long) (first / 4) * 6 * 4;
+            if (instanced) {
+                RENDER_BACKEND.drawElementsInstanced(GL11.GL_TRIANGLES, quadCount * 6, INDEX_TYPE, indexOffset, primcount);
+            } else {
+                RENDER_BACKEND.drawElements(GL11.GL_TRIANGLES, quadCount * 6, INDEX_TYPE, indexOffset);
+            }
+            RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEbo);
+        } finally {
+            if (locked) GLStateManager.releaseDrawLock();
        }
-        RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEbo);
    }

    /**
@@ -123,32 +128,37 @@ public final class QuadConverter {
    }

    private static void uploadAndDraw(ByteBuffer dst, int triIndexCount, int indexType, int bytesPerIndex, int primcount, boolean instanced) {
-        GLStateManager.preDraw();
-        final int needed = triIndexCount * bytesPerIndex;
-        final int prevEbo = GLStateManager.getBoundEBO();
+        final boolean locked = GLStateManager.acquireDrawLock();
+        try {
+            GLStateManager.preDraw();
+            final int needed = triIndexCount * bytesPerIndex;
+            final int prevEbo = GLStateManager.getBoundEBO();

-        if (scratchEboId == 0) {
-            scratchEboId = RENDER_BACKEND.genBuffers();
+            if (scratchEboId == 0) {
+                scratchEboId = RENDER_BACKEND.genBuffers();
+            }
+
+            RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, scratchEboId);
+
+            if (needed > scratchEboCapacity) {
+                // Power-of-2 growth -- allocate full capacity, upload actual data
+                int newCap = Math.max(4096, scratchEboCapacity);
+                while (newCap < needed) newCap *= 2;
+                RENDER_BACKEND.bufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, newCap, GL15.GL_STREAM_DRAW);
+                scratchEboCapacity = newCap;
+            }
+            RENDER_BACKEND.bufferSubData(GL15.GL_ELEMENT_ARRAY_BUFFER, 0, dst);
+
+            if (instanced) {
+                RENDER_BACKEND.drawElementsInstanced(GL11.GL_TRIANGLES, triIndexCount, indexType, 0L, primcount);
+            } else {
+                RENDER_BACKEND.drawElements(GL11.GL_TRIANGLES, triIndexCount, indexType, 0L);
+            }
+
+            RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEbo);
+        } finally {
+            if (locked) GLStateManager.releaseDrawLock();
        }
-
-        RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, scratchEboId);
-
-        if (needed > scratchEboCapacity) {
-            // Power-of-2 growth — allocate full capacity, upload actual data
-            int newCap = Math.max(4096, scratchEboCapacity);
-            while (newCap < needed) newCap *= 2;
-            RENDER_BACKEND.bufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, newCap, GL15.GL_STREAM_DRAW);
-            scratchEboCapacity = newCap;
-        }
-        RENDER_BACKEND.bufferSubData(GL15.GL_ELEMENT_ARRAY_BUFFER, 0, dst);
-
-        if (instanced) {
-            RENDER_BACKEND.drawElementsInstanced(GL11.GL_TRIANGLES, triIndexCount, indexType, 0L, primcount);
-        } else {
-            RENDER_BACKEND.drawElements(GL11.GL_TRIANGLES, triIndexCount, indexType, 0L);
-        }
-
-        RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEbo);
        memFree(dst);
    }

@@ -146,6 +146,9 @@ public class RenderSystem {
                coreProfile = true;
                GLStateManager.LOGGER.info("GL 3.3 core profile detected, enabling FFP shader emulation.");
                ShaderManager.getInstance().enable();
+            } else {
+                throw new IllegalStateException("Non-core GL context (profile mask 0x" + Integer.toHexString(profileMask)
+                    + "); FFP emulation requires a core profile and nothing would render. Context creation should have rejected this.");
            }
        }

@@ -301,7 +304,7 @@ public class RenderSystem {
    }

    public static void bufferData(int target, FloatBuffer data, int usage) {
-        RENDER_BACKEND.bufferData(target, data, usage);
+        GLStateManager.glBufferData(target, data, usage);
    }

    public static int bufferStorage(int target, FloatBuffer data, int usage) {
@@ -447,7 +450,7 @@ public class RenderSystem {
    }

    public static int createBuffers() {
-        return RENDER_BACKEND.genBuffers();
+        return GLStateManager.glGenBuffers();
    }

    public static void bindBufferBase(int target, int index, int buffer) {
@@ -455,13 +458,13 @@ public class RenderSystem {
    }

    public static void bufferStorage(int target, long size, int flags) {
-        RENDER_BACKEND.bufferStorage(target, size, flags);
+        GLStateManager.glBufferStorage(target, size, flags);
    }

    public static void clearBufferSubData(int target, int internalFormat, long offset, long size, int format, int type, int[] data) {
        final ByteBuffer buf = BufferUtils.createByteBuffer(data.length * 4);
        buf.asIntBuffer().put(data);
-        RENDER_BACKEND.clearBufferSubData(target, internalFormat, offset, size, format, type, buf);
+        GLStateManager.glClearBufferSubData(target, internalFormat, offset, size, format, type, buf);
    }

    public static void deleteBuffers(int buffer) {
@@ -549,7 +552,7 @@ public class RenderSystem {
        }
    }

-    /** Parse a GL version string (e.g. "4.6.0 NVIDIA ...") into concatenated digits "460". Inlined from StandardMacros.getGlVersion(). */
+    /** Parse a GL version string (e.g. "4.6.0 NVIDIA ...") into concatenated digits "460" */
    static String parseGlVersionString(String info) {
        final Matcher matcher = SEMVER_PATTERN.matcher(Objects.requireNonNull(info));
        if (!matcher.matches()) {
@@ -561,4 +564,18 @@ public class RenderSystem {
        if (bugfix == null || bugfix.isEmpty()) bugfix = "0";
        return major + minor + bugfix;
    }
+
+    /** Parse a GL version string into packed major*10+minor (e.g. "4.3.0 - Build ..." -> 43), or -1 if unparseable. */
+    public static int parseMajorMinor(String glVersion) {
+        if (glVersion == null) return -1;
+        final Matcher matcher = SEMVER_PATTERN.matcher(glVersion.trim());
+        if (!matcher.matches()) return -1;
+        return Integer.parseInt(matcher.group("major")) * 10 + Integer.parseInt(matcher.group("minor"));
+    }
+
+    public static boolean isContextValid(int requestedMajor, int requestedMinor, int actualVersion, boolean coreBitSet) {
+        if (!coreBitSet) return false;
+        if (actualVersion < 0) return true;
+        return actualVersion >= requestedMajor * 10 + requestedMinor;
+    }
 }
@@ -327,7 +327,7 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {

    @Override
    public void copyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size) {
-        throw new UnsupportedOperationException("GLRenderBackend.copyBufferSubData should not be called — LWJGL service handles this");
+        GL31.glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
    }

    @Override
@@ -622,6 +622,11 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
        GL11.glGetTexImage(target, level, format, type, pixels);
    }

+    @Override
+    public void getTexImage(int target, int level, int format, int type, long pixelBufferOffset) {
+        GL11.glGetTexImage(target, level, format, type, pixelBufferOffset);
+    }
+
    @Override
    public int getFramebufferAttachmentParameteri(int target, int attachment, int pname) {
        return GL30.glGetFramebufferAttachmentParameteri(target, attachment, pname);
@@ -1058,6 +1063,11 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
        return GL30.glMapBufferRange(target, offset, length, access, null);
    }

+    @Override
+    public void flushMappedBufferRange(int target, long offset, long length) {
+        GL30.glFlushMappedBufferRange(target, offset, length);
+    }
+
    @Override
    public int genVertexArrays() {
        return GL30.glGenVertexArrays();
@@ -1249,6 +1259,11 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
        return GL45.glCreateBuffers();
    }

+    @Override
+    public void namedBufferData(int buffer, long size, int usage) {
+        GL45.glNamedBufferData(buffer, size, usage);
+    }
+
    @Override
    public void namedBufferData(int buffer, ByteBuffer data, int usage) {
        GL45.glNamedBufferData(buffer, data, usage);
@@ -151,6 +151,7 @@ public abstract class RenderBackend {
    public abstract void readPixels(int x, int y, int width, int height, int format, int type, IntBuffer pixels);
    public abstract void getTexImage(int target, int level, int format, int type, ByteBuffer pixels);
    public abstract void getTexImage(int target, int level, int format, int type, IntBuffer pixels);
+    public abstract void getTexImage(int target, int level, int format, int type, long pixelBufferOffset);
    public abstract int getFramebufferAttachmentParameteri(int target, int attachment, int pname);

    public abstract int createShader(int type);
@@ -249,6 +250,7 @@ public abstract class RenderBackend {
    public abstract int getBufferParameteri(int target, int pname);
    public abstract boolean isBuffer(int buffer);
    public abstract ByteBuffer mapBufferRange(int target, long offset, long length, int access);
+    public abstract void flushMappedBufferRange(int target, long offset, long length);

    public abstract int genVertexArrays();
    public abstract void deleteVertexArrays(int array);
@@ -292,6 +294,7 @@ public abstract class RenderBackend {
    public abstract void namedFramebufferDrawBuffers(int framebuffer, IntBuffer bufs);
    public abstract void blitNamedFramebuffer(int readFramebuffer, int drawFramebuffer, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, int mask, int filter);
    public abstract int createBuffers();
+    public abstract void namedBufferData(int buffer, long size, int usage);
    public abstract void namedBufferData(int buffer, ByteBuffer data, int usage);
    public abstract void namedBufferData(int buffer, FloatBuffer data, int usage);
    public abstract void namedBufferSubData(int buffer, long offset, ByteBuffer data);
@@ -104,8 +104,8 @@ public class DSAARB extends DSAUnsupported {

    @Override
    public int bufferStorage(int target, FloatBuffer data, int usage) {
-        final int buffer = RENDER_BACKEND.createBuffers();
-        RENDER_BACKEND.namedBufferData(buffer, data, usage);
+        final int buffer = GLStateManager.glCreateBuffers();
+        GLStateManager.glNamedBufferData(buffer, data, usage);
        return buffer;
    }

@@ -121,9 +121,9 @@ public class DSAUnsupported implements DSAAccess {

    @Override
    public int bufferStorage(int target, FloatBuffer data, int usage) {
-        final int buffer = RENDER_BACKEND.genBuffers();
+        final int buffer = GLStateManager.glGenBuffers();
        GLStateManager.glBindBuffer(target, buffer);
-        RENDER_BACKEND.bufferData(target, data, usage);
+        GLStateManager.glBufferData(target, data, usage);
        GLStateManager.glBindBuffer(target, 0);

        return buffer;
@@ -12,7 +12,7 @@ import org.lwjgl.opengl.GL13;
 * Packed-long fragment shader permutation key for FFP emulation.
 *
 * Layout:
- *   long[0]: global bits (11) + unit 0 (47 bits at offset 11)
+ *   long[0]: global bits (12) + unit 0 (47 bits at offset 12)
 *   long[1..3]: unit 1..3 (47 bits each, low-aligned)
 * Only max(1, nrEnabledUnits) longs are significant.
 *
@@ -63,13 +63,14 @@ public final class FragmentKey {
    public static final int FOG_EXP    = 2;
    public static final int FOG_EXP2   = 3;

-    private static final int GLOBAL_BITS = 11;
+    private static final int GLOBAL_BITS = 12;
    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 BIT_LINE_STIPPLE      = 11; // 1 bit

    private static final int U_ENABLED         = 0;
    private static final int U_MODE            = 1;   // 3 bits
@@ -125,6 +126,10 @@ public final class FragmentKey {
            global |= (1L << BIT_OVERLAY_ENABLED);
        }

+        if (GLStateManager.lineStippleActive) {
+            global |= (1L << BIT_LINE_STIPPLE);
+        }
+
        // Separate specular
        if (GLStateManager.getLightingState().isEnabled()
            && GLStateManager.getLightModel().colorControl == GL12.GL_SEPARATE_SPECULAR_COLOR) {
@@ -233,6 +238,7 @@ public final class FragmentKey {
    public boolean alphaTestEnabled() { return ((packed[0] >> BIT_ALPHA_TEST) & 1) != 0; }
    public int alphaTestFunc()        { return (int) ((packed[0] >> BIT_ALPHA_FUNC) & 0x7); }
    public boolean separateSpecular() { return ((packed[0] >> BIT_SEPARATE_SPECULAR) & 1) != 0; }
+    public boolean lineStipple()      { return ((packed[0] >> BIT_LINE_STIPPLE) & 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; }

@@ -20,6 +20,7 @@ public final class FragmentShaderGenerator {
        sb.append("out vec4 fragColor;\n\n");

        sb.append("void main() {\n");
+        emitLineStipple(sb, key);
        emitTextureSampling(sb, key);
        emitTexEnvChain(sb, key);
        emitSpecularAdd(sb, key);
@@ -46,9 +47,19 @@ public final class FragmentShaderGenerator {
        if (key.fogMode() != FragmentKey.FOG_NONE) {
            sb.append("in float v_FogCoord;\n");
        }
+        if (key.lineStipple()) {
+            sb.append("flat in vec2 v_LineStart;\n");
+        }
        sb.append('\n');
    }

+    private static void emitLineStipple(StringBuilder sb, FragmentKey key) {
+        if (!key.lineStipple()) return;
+        sb.append("  vec2 stippleDelta = abs(gl_FragCoord.xy - v_LineStart);\n");
+        sb.append("  int stippleBit = int(floor(max(stippleDelta.x, stippleDelta.y) / float(u_LineStipple >> 16))) & 15;\n");
+        sb.append("  if (((u_LineStipple >> stippleBit) & 1) == 0) discard;\n\n");
+    }
+
    private static void emitUniforms(StringBuilder sb, FragmentKey key) {
        // Samplers for each enabled unit
        for (int i = 0; i < key.nrEnabledUnits(); i++) {
@@ -59,6 +70,9 @@ public final class FragmentShaderGenerator {
        if (key.alphaTestEnabled()) {
            sb.append("uniform float u_AlphaRef;\n");
        }
+        if (key.lineStipple()) {
+            sb.append("uniform int u_LineStipple;\n");
+        }
        // Per-unit texEnvColor uniforms
        for (int i = 0; i < key.nrEnabledUnits(); i++) {
            if (key.unitEnabled(i) && key.unitNeedsEnvColor(i)) {
@@ -29,6 +29,9 @@ public final class GeometryShaderGenerator {
        if (key.fogEnabled()) {
            sb.append("in float v_FogCoord_gs[];\n");
        }
+        if (key.lineStipple()) {
+            sb.append("flat in vec2 v_LineStart_gs[];\n");
+        }
        sb.append('\n');

        sb.append("out vec4 v_Color;\n");
@@ -42,6 +45,9 @@ public final class GeometryShaderGenerator {
        if (key.fogEnabled()) {
            sb.append("out float v_FogCoord;\n");
        }
+        if (key.lineStipple()) {
+            sb.append("flat out vec2 v_LineStart;\n");
+        }
        sb.append('\n');

        sb.append("void main() {\n");
@@ -85,6 +91,9 @@ public final class GeometryShaderGenerator {
        if (key.fogEnabled()) {
            sb.append("    v_FogCoord = v_FogCoord_gs").append(idx).append(";\n");
        }
+        if (key.lineStipple()) {
+            sb.append("    v_LineStart = v_LineStart_gs[0];\n");
+        }

        if (key.clipPlanesEnabled()) {
            for (int i = 0; i < 8; i++) {
@@ -33,6 +33,9 @@ public class Program {
        int texGenGen = -1, clipPlaneGen = -1;
        float lightmapX = Float.NaN, lightmapY = Float.NaN, lineWidth = Float.NaN;
        int viewportWidth = -1, viewportHeight = -1;
+        int stippleViewportX = Integer.MIN_VALUE, stippleViewportY = Integer.MIN_VALUE;
+        int stippleViewportW = -1, stippleViewportH = -1;
+        int lineStipple = -1;
    }
    final UploadState uploadState = new UploadState();

@@ -98,6 +101,10 @@ public class Program {
    public int locViewportSize = -1;
    public int locLineWidth = -1;

+    // Line stipple emulation
+    public int locViewport = -1;
+    public int locLineStipple = -1;
+
    // Fragment uniforms
    public final int[] locSampler = { -1, -1, -1, -1 };
    public int locAlphaRef = -1;
@@ -174,6 +181,10 @@ public class Program {
        locViewportSize = loc("u_ViewportSize");
        locLineWidth = loc("u_LineWidth");

+        // Line stipple emulation
+        locViewport = loc("u_Viewport");
+        locLineStipple = loc("u_LineStipple");
+
        // Fragment
        for (int i = 0; i < 4; i++) {
            locSampler[i] = loc("u_Sampler" + i);
@@ -6,8 +6,10 @@ import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.hooks.DeferredBlendHandler;
 import com.gtnewhorizons.angelica.glsm.hooks.GLSMHooks;
 import com.gtnewhorizons.angelica.glsm.hooks.GLSMInitConfig;
+import com.gtnewhorizons.angelica.glsm.QuadConverter;
 import com.gtnewhorizons.angelica.glsm.stacks.Vec3fStack;
 import com.gtnewhorizons.angelica.glsm.stacks.Vec4fStack;
+import com.gtnewhorizons.angelica.glsm.streaming.TessellatorStreamingDrawer;
 import lombok.Getter;
 import org.joml.Vector3f;
 import org.joml.Vector4f;
@@ -66,11 +68,33 @@ public final class ShaderManager {
    }

    public void enable() {
+        warmUp();
        enabled = true;

        GLStateManager.LOGGER.info("FFP shader emulation enabled");
    }

+    // Force loading of classes before the SplashThread kicks off
+    // Ensure it's GL free
+    private static void warmUp() {
+        try {
+            final long[] fkScratch = new long[FragmentKey.MAX_UNITS];
+            final int fkLen = FragmentKey.packFromState(fkScratch);
+            final int fragMask = FragmentKey.unitMaskFromPacked(fkScratch, fkLen);
+            final long vkPacked = VertexKey.packFromState(true, true, true, true, fragMask);
+            final VertexKey vk = VertexKey.fromPacked(vkPacked);
+            VertexShaderGenerator.generate(vk);
+            FragmentShaderGenerator.generate(FragmentKey.fromPacked(fkScratch, fkLen));
+            GeometryShaderGenerator.generate(vk);
+            final Class<?>[] touched = { Program.class, ShaderCache.class, TessellatorStreamingDrawer.class, QuadConverter.class };
+            for (Class<?> c : touched) {
+                c.getName();
+            }
+        } catch (Throwable t) {
+            GLStateManager.LOGGER.warn("FFP warmup failed; draw-path classes will resolve lazily", t);
+        }
+    }
+
    public void disable() {
        enabled = false;
    }
@@ -4,8 +4,10 @@ import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.states.ClipPlaneState;
 import com.gtnewhorizons.angelica.glsm.states.FogState;
 import com.gtnewhorizons.angelica.glsm.states.LightState;
+import com.gtnewhorizons.angelica.glsm.states.LineState;
 import com.gtnewhorizons.angelica.glsm.states.MaterialState;
 import com.gtnewhorizons.angelica.glsm.states.TexGenState;
+import com.gtnewhorizons.angelica.glsm.states.ViewportState;
 import com.gtnewhorizons.angelica.glsm.hooks.GLSMConfig;
 import org.joml.Math;
 import org.joml.Matrix3f;
@@ -136,6 +138,31 @@ public class Uniforms {
        if (program.locLineWidth != -1 && program.locViewportSize != -1) {
            uploadWideLineUniforms(program);
        }
+
+        if (program.locLineStipple != -1) {
+            uploadLineStippleUniforms(program);
+        }
+    }
+
+    private void uploadLineStippleUniforms(Program program) {
+        final Program.UploadState st = program.uploadState;
+        final LineState line = GLStateManager.getLineState();
+
+        final int factor = line.getStippleFactor() < 1 ? 1 : line.getStippleFactor();
+        final int packed = (line.getStipplePattern() & 0xFFFF) | (factor << 16);
+        if (packed != st.lineStipple) {
+            RENDER_BACKEND.uniform1i(program.locLineStipple, packed);
+            st.lineStipple = packed;
+        }
+
+        final ViewportState vp = GLStateManager.getViewportState();
+        if (vp.x != st.stippleViewportX || vp.y != st.stippleViewportY || vp.width != st.stippleViewportW || vp.height != st.stippleViewportH) {
+            RENDER_BACKEND.uniform4f(program.locViewport, vp.x, vp.y, vp.width, vp.height);
+            st.stippleViewportX = vp.x;
+            st.stippleViewportY = vp.y;
+            st.stippleViewportW = vp.width;
+            st.stippleViewportH = vp.height;
+        }
    }

    private void uploadMatrices(Program program, boolean mvChanged, boolean mvLinearChanged, boolean projChanged, boolean texMatChanged) {
@@ -15,6 +15,8 @@ public final class VAOManager {

    public static final Int2ObjectOpenHashMap<VAOData> vaoMap = new Int2ObjectOpenHashMap<>();

+    static final Int2ObjectOpenHashMap<VAOData> eboOwners = new Int2ObjectOpenHashMap<>();
+
    private static VAOData current = null;
    private static int currentVertexFlags = 0;
    private static Attrib[] currentAttribs = null;
@@ -38,8 +40,13 @@ public final class VAOManager {
        // Save old VAO data
        if (current != null) {
            current.vertexFlags = currentVertexFlags;
-            current.ebo = boundEBO;
+            if (current.ebo != boundEBO) {
+                removeEboOwner(current.ebo, current);
+                current.ebo = boundEBO;
+                addEboOwner(current.ebo, current);
+            }
            current.attribs = currentAttribs;
+            current.clientSideEnabledCount = clientSideEnabledCount;
        }

        VAOData data = vaoMap.get(vaoId);
@@ -51,12 +58,50 @@ public final class VAOManager {
        currentVertexFlags = data.vertexFlags;
        currentAttribs = data.attribs;
        boundEBO = data.ebo;
-
-        recomputeClientSideCount();
+        clientSideEnabledCount = data.clientSideEnabledCount;
    }

    public static void onDeleteVertexArray(int vaoId) {
-        vaoMap.remove(vaoId);
+        final VAOData data = vaoMap.remove(vaoId);
+        if (data == null) return;
+        removeEboOwner(data.ebo, data);
+        if (data == current) current = null;
+    }
+
+    public static void onDeleteBuffer(int buffer) {
+        if (buffer == 0) return;
+        VAOData owner = eboOwners.remove(buffer);
+        while (owner != null) {
+            final VAOData next = owner.nextEboOwner;
+            owner.nextEboOwner = null;
+            owner.ebo = 0;
+            owner = next;
+        }
+    }
+
+    private static void addEboOwner(int ebo, VAOData data) {
+        if (ebo == 0) return;
+        data.nextEboOwner = eboOwners.put(ebo, data);
+    }
+
+    private static void removeEboOwner(int ebo, VAOData data) {
+        if (ebo == 0) return;
+        VAOData node = eboOwners.get(ebo);
+        if (node == data) {
+            final VAOData next = data.nextEboOwner;
+            if (next == null) eboOwners.remove(ebo); else eboOwners.put(ebo, next);
+            data.nextEboOwner = null;
+            return;
+        }
+        while (node != null) {
+            final VAOData next = node.nextEboOwner;
+            if (next == data) {
+                node.nextEboOwner = data.nextEboOwner;
+                data.nextEboOwner = null;
+                return;
+            }
+            node = next;
+        }
    }

    public static void enableClientVertexFlag(int flag) { currentVertexFlags |= flag; }
@@ -68,6 +113,8 @@ public final class VAOManager {
        public Attrib[] attribs;
        public int vertexFlags;
        public int ebo;
+        public int clientSideEnabledCount;
+        private VAOData nextEboOwner;

        public VAOData() {
            attribs = new Attrib[MAX_ATTRIBS];
@@ -183,14 +230,6 @@ public final class VAOManager {



-    private static void recomputeClientSideCount() {
-        int count = 0;
-        for (int i = 0; i < MAX_ATTRIBS; i++) {
-            if (isClientSideAttrib(i)) count++;
-        }
-        clientSideEnabledCount = count;
-    }
-
    /**
     * Returns true if any currently enabled vertex attribute was registered without a VBO
     * (i.e. as a client-side pointer). In core profile, such attribs are treated as null
@@ -50,6 +50,7 @@ public final class VertexKey {
    // 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;
    private static final int BIT_UNIT23_UV_FROM_UNIT0 = 41;
+    private static final int BIT_LINE_STIPPLE        = 42;

    public static final int TG_NONE                  = 0;
    public static final int TG_OBJ_LINEAR            = 1;
@@ -98,6 +99,7 @@ public final class VertexKey {
    public boolean texGenEnabled()        { return texGenModeS() != TG_NONE || texGenModeT() != TG_NONE || texGenModeR() != TG_NONE || texGenModeQ() != TG_NONE; }
    public boolean clipPlanesEnabled()    { return bit(BIT_CLIP_PLANES); }
    public boolean wideLineEmulation()   { return bit(BIT_WIDE_LINE); }
+    public boolean lineStipple()          { return bit(BIT_LINE_STIPPLE); }

    public boolean cmReplacesAmbient()    { final int m = colorMaterialMode(); return m == CM_AMBIENT || m == CM_AMBIENT_AND_DIFFUSE; }
    public boolean cmReplacesDiffuse()    { final int m = colorMaterialMode(); return m == CM_DIFFUSE || m == CM_AMBIENT_AND_DIFFUSE; }
@@ -227,6 +229,10 @@ public final class VertexKey {
            bits |= (1L << BIT_WIDE_LINE);
        }

+        if (GLStateManager.lineStippleActive) {
+            bits |= (1L << BIT_LINE_STIPPLE);
+        }
+
        return bits;
    }

@@ -29,6 +29,9 @@ public final class VertexShaderGenerator {
            emitColorPassthrough(sb, key);
        }
        emitTexCoordPassthrough(sb, key);
+        if (key.lineStipple()) {
+            emitLineStart(sb);
+        }
        if (key.fogEnabled()) {
            emitFogDistance(sb, key);
        }
@@ -45,6 +48,7 @@ public final class VertexShaderGenerator {
                           .replace("v_TexCoord2", "v_TexCoord2_gs")
                           .replace("v_TexCoord3", "v_TexCoord3_gs")
                           .replace("v_FogCoord", "v_FogCoord_gs")
+                           .replace("v_LineStart", "v_LineStart_gs")
                           .replace("v_Color", "v_Color_gs");
        }
        return source;
@@ -68,6 +72,11 @@ public final class VertexShaderGenerator {
        sb.append('\n');
    }

+    private static void emitLineStart(StringBuilder sb) {
+        sb.append("  vec2 ndc = gl_Position.xy / gl_Position.w;\n");
+        sb.append("  v_LineStart = u_Viewport.xy + (ndc * 0.5 + 0.5) * u_Viewport.zw;\n\n");
+    }
+
    private static void emitUniforms(StringBuilder sb, VertexKey key) {
        sb.append("// Matrices\n");
        sb.append("uniform mat4 u_ModelViewMatrix;\n");
@@ -77,6 +86,9 @@ public final class VertexShaderGenerator {
        if (key.lightingEnabled()) {
            sb.append("uniform mat3 u_NormalMatrix;\n");
        }
+        if (key.lineStipple()) {
+            sb.append("uniform vec4 u_Viewport;\n");
+        }

        for (int i = 0; i < VertexKey.MAX_UNITS; i++) {
            if (i == 1) continue;
@@ -182,6 +194,9 @@ public final class VertexShaderGenerator {
    private static void emitOutputs(StringBuilder sb, VertexKey key) {
        sb.append("// Outputs\n");
        sb.append("out vec4 v_Color;\n");
+        if (key.lineStipple()) {
+            sb.append("flat out vec2 v_LineStart;\n");
+        }
        if (key.separateSpecular()) {
            sb.append("out vec3 v_SpecularColor;\n");
        }
@@ -62,11 +62,14 @@ public final class DisplayListVBO {
        }

        public void render() {
-            vao.bind();
-            vao.draw(drawMode, start, count);
-            vao.unbind();
+        if (vao == null) return;
+        vao.bind();
+        if (count <= 0) { vao.unbind(); return; }
+        vao.draw(drawMode, start, count);
+        vao.unbind();
        }

+
        public IVertexArrayObject getVAO() {
            return vao;
        }
@@ -10,6 +10,8 @@ import org.lwjgl.opengl.GL11;

 import java.nio.ByteBuffer;
 import java.util.Arrays;
+import java.util.Queue;
+import java.util.concurrent.ConcurrentLinkedQueue;

 /**
 * Records immediate mode GL calls (glBegin/glEnd/glVertex) via {@link DirectTessellator}.
@@ -18,28 +20,37 @@ import java.util.Arrays;
 public final class ImmediateModeRecorder {
    private static final CallbackTessellator tessellator = new CallbackTessellator(TessellatorManager.DEFAULT_BUFFER_SIZE);

-    /** Separate tessellator for the splash thread. Nulled after splash completes. */
-    private static DirectTessellator splashTessellator;
+    private record ThreadTessellator(Thread thread, DirectTessellator tessellator) {}
+
+    private static final Queue<ThreadTessellator> threadTessellators = new ConcurrentLinkedQueue<>();
+    private static final ThreadLocal<DirectTessellator> threadTessellator = ThreadLocal.withInitial(() -> {
+        final DirectTessellator t = new DirectTessellator(TessellatorManager.DEFAULT_BUFFER_SIZE);
+        threadTessellators.add(new ThreadTessellator(Thread.currentThread(), t));
+        cleanupOrphanTessellators();
+        return t;
+    });

    private ImmediateModeRecorder() {

    }

-    public static void initSplashTessellator() {
-        splashTessellator = new DirectTessellator(TessellatorManager.DEFAULT_BUFFER_SIZE);
+    public static int getThreadTessellatorCount() {
+        return threadTessellators.size();
    }

-    public static void destroySplashTessellator() {
-        splashTessellator.delete();
-        splashTessellator = null;
+    public static synchronized void cleanupOrphanTessellators() {
+        threadTessellators.removeIf(tt -> {
+            if (tt.thread().isAlive()) return false;
+            tt.tessellator().delete();
+            return true;
+        });
    }

    private static DirectTessellator tessellator() {
-        final DirectTessellator splash = splashTessellator;
-        if (splash != null && Thread.currentThread() != GLStateManager.getMainThread()) {
-            return splash;
+        if (Thread.currentThread() == GLStateManager.getMainThread()) {
+            return tessellator;
        }
-        return tessellator;
+        return threadTessellator.get();
    }

    public static DirectTessellator getInternalTessellator() {
@@ -48,6 +48,11 @@ public class GLSMRedirector {
    private static final String ARBInstancedArrays = "org/lwjgl/opengl/ARBInstancedArrays";
    private static final String ARBDrawInstanced = "org/lwjgl/opengl/ARBDrawInstanced";
    private static final String EXTDrawInstanced = "org/lwjgl/opengl/EXTDrawInstanced";
+    private static final String ARBBufferObject = "org/lwjgl/opengl/ARBBufferObject";
+    private static final String ARBVertexBufferObject = "org/lwjgl/opengl/ARBVertexBufferObject";
+    private static final String ARBBufferStorage = "org/lwjgl/opengl/ARBBufferStorage";
+    private static final String ARBCopyBuffer = "org/lwjgl/opengl/ARBCopyBuffer";
+    private static final String ARBMapBufferRange = "org/lwjgl/opengl/ARBMapBufferRange";

    // Redirect VAO related calls from NHLib
    private static final String UniversalVAO = "com/gtnewhorizon/gtnhlib/client/opengl/UniversalVAO";
@@ -285,11 +290,16 @@ public class GLSMRedirector {
            .add("glBindBuffer")
            .add("glDeleteBuffers")
            .add("glBufferData")
+            .add("nglBufferData")
            .add("glBufferSubData")
+            .add("nglBufferSubData")
            .add("glMapBuffer")
            .add("glUnmapBuffer")
            .add("glGetBufferSubData")
+            .add("nglGetBufferSubData")
            .add("glGetBufferParameteri")
+            .add("glGetBufferParameter")
+            .add("glGetBufferParameteriv")
            .add("glIsBuffer");
        final var gl20 = RedirectMap.newMap()
            .add("glBlendEquationSeparate")
@@ -356,10 +366,13 @@ public class GLSMRedirector {
            .add("glVertexAttribIPointer")
            .add("glGenerateMipmap")
            .add("glGetFramebufferAttachmentParameteri")
-            .add("glBlitFramebuffer");
+            .add("glBlitFramebuffer")
+            .add("glMapBufferRange")
+            .add("glFlushMappedBufferRange");
        final var gl31 = RedirectMap.newMap()
            .add("glDrawElementsInstanced")
-            .add("glDrawArraysInstanced");
+            .add("glDrawArraysInstanced")
+            .add("glCopyBufferSubData");
        final var gl32 = RedirectMap.newMap()
            .add("glFramebufferTexture");
        final var gl33 = RedirectMap.newMap()
@@ -383,6 +396,10 @@ public class GLSMRedirector {
        final var gl44 = RedirectMap.newMap()
            .add("glBufferStorage")
            .add("glClearTexImage");
+        final var gl45 = RedirectMap.newMap()
+            .add("glCreateBuffers")
+            .add("glNamedBufferData")
+            .add("glNamedBufferSubData");

        // Merge all GL version maps into the flat lookup
        glMethodRedirects.putAll(gl11);
@@ -398,6 +415,7 @@ public class GLSMRedirector {
        glMethodRedirects.putAll(gl42);
        glMethodRedirects.putAll(gl43);
        glMethodRedirects.putAll(gl44);
+        glMethodRedirects.putAll(gl45);

        // MINECRAFT
        methodRedirects.put(OpenGlHelper, RedirectMap.newMap()
@@ -470,6 +488,31 @@ public class GLSMRedirector {
            .add("glDrawArraysInstancedEXT", "glDrawArraysInstanced")
            .add("glDrawElementsInstancedEXT", "glDrawElementsInstanced")
        );
+        final var arbBufferObject = RedirectMap.newMap()
+            .add("glBindBufferARB", "glBindBuffer")
+            .add("glGenBuffersARB", "glGenBuffers")
+            .add("glDeleteBuffersARB", "glDeleteBuffers")
+            .add("glIsBufferARB", "glIsBuffer")
+            .add("glBufferDataARB", "glBufferData")
+            .add("glBufferSubDataARB", "glBufferSubData")
+            .add("glGetBufferSubDataARB", "glGetBufferSubData")
+            .add("glMapBufferARB", "glMapBuffer")
+            .add("glUnmapBufferARB", "glUnmapBuffer")
+            .add("glGetBufferParameterARB", "glGetBufferParameter")
+            .add("glGetBufferParameteriARB", "glGetBufferParameteri")
+            .add("glGetBufferParameterivARB", "glGetBufferParameteriv");
+        methodRedirects.put(ARBBufferObject, arbBufferObject);
+        methodRedirects.put(ARBVertexBufferObject, arbBufferObject);
+        methodRedirects.put(ARBBufferStorage, RedirectMap.newMap()
+            .add("glBufferStorage")
+        );
+        methodRedirects.put(ARBCopyBuffer, RedirectMap.newMap()
+            .add("glCopyBufferSubData")
+        );
+        methodRedirects.put(ARBMapBufferRange, RedirectMap.newMap()
+            .add("glMapBufferRange")
+            .add("glFlushMappedBufferRange")
+        );

        // APPLE
        methodRedirects.put(APPLEVertexArrayObject, RedirectMap.newMap()
@@ -167,7 +167,9 @@ public class PersistentStreamingBuffer implements StreamingBuffer {
    private boolean syncOldest() {
        if (fenceQueue.isEmpty()) return false;
        final FencedRegion region = fenceQueue.first();
-        region.fence.sync();
+        if (!region.fence.sync()) {
+            GLStateManager.LOGGER.warn("Streaming buffer fence wait did not signal; reclaiming {} bytes anyway", region.bytes);
+        }
        region.fence.delete();
        fenceQueue.dequeue();
        remaining += region.bytes;
@@ -88,13 +88,18 @@ public class TessellatorStreamingDrawer {
        final int vertexSize = format.getVertexSize();

        final int requiredBytes = vertexCount * vertexSize;
-        ensureRepackCapacity(requiredBytes);
+        final boolean locked = GLStateManager.acquireDrawLock();
+        try {
+            ensureRepackCapacity(requiredBytes);

-        final long writePtr = format.writeToBuffer0(repackAddress, tess.rawBuffer, tess.rawBufferIndex);
-        repackBuffer.position(0);
-        repackBuffer.limit((int)(writePtr - repackAddress));
+            final long writePtr = format.writeToBuffer0(repackAddress, tess.rawBuffer, tess.rawBufferIndex);
+            repackBuffer.position(0);
+            repackBuffer.limit((int)(writePtr - repackAddress));

-        uploadAndDraw(repackBuffer, flags, format, vertexSize, tess.drawMode, vertexCount);
+            uploadAndDraw(repackBuffer, flags, format, vertexSize, tess.drawMode, vertexCount);
+        } finally {
+            if (locked) GLStateManager.releaseDrawLock();
+        }

        // Shrink rawBuffer if oversized
        if (tess.rawBufferSize > 0x20000 && tess.rawBufferIndex < (tess.rawBufferSize << 3)) {
@@ -187,24 +192,29 @@ public class TessellatorStreamingDrawer {
     * Tries the persistent ring buffer first, falls back to orphan buffer on overflow.
     */
    private static void uploadAndDraw(ByteBuffer packed, int flags, VertexFormat format, int vertexSize, int drawMode, int vertexCount) {
-        ensureVAO(flags, format);
+        final boolean locked = GLStateManager.acquireDrawLock();
+        try {
+            ensureVAO(flags, format);

-        int firstVertex = -1;
+            int firstVertex = -1;

-        if (persistentBuffer != null) {
-            firstVertex = persistentBuffer.upload(packed, vertexSize);
+            if (persistentBuffer != null) {
+                firstVertex = persistentBuffer.upload(packed, vertexSize);
+            }
+
+            if (firstVertex >= 0) {
+                GLStateManager.glBindVertexArray(persistentVAOs[flags]);
+            } else {
+                GLStateManager.glBindVertexArray(orphanVAOs[flags]);
+                orphanBuffers[flags].upload(packed);
+                firstVertex = 0;
+            }
+
+            drawWithQuadConversion(drawMode, firstVertex, vertexCount);
+            GLStateManager.glBindVertexArray(0);
+        } finally {
+            if (locked) GLStateManager.releaseDrawLock();
        }
-
-        if (firstVertex >= 0) {
-            GLStateManager.glBindVertexArray(persistentVAOs[flags]);
-        } else {
-            GLStateManager.glBindVertexArray(orphanVAOs[flags]);
-            orphanBuffers[flags].upload(packed);
-            firstVertex = 0;
-        }
-
-        drawWithQuadConversion(drawMode, firstVertex, vertexCount);
-        GLStateManager.glBindVertexArray(0);
    }

    private static void drawWithQuadConversion(int drawMode, int firstVertex, int vertexCount) {
@@ -1,7 +1,6 @@
 package com.gtnewhorizons.angelica.glsm;

 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.GL20;
@@ -12,7 +11,7 @@ import java.nio.IntBuffer;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;

-@ExtendWith(GLSMCoreExtension.class)
+@GLCoreTest
 class ArrayUniformUploadGLTest {

    private static int compile(int type, String src) {
@@ -2,7 +2,6 @@ package com.gtnewhorizons.angelica.glsm;

 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL20;

 import static org.junit.jupiter.api.Assertions.assertEquals;
@@ -12,7 +11,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;

-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class CompatUniformManagerTest {

    private int program = 0;
@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.glsm;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;

@@ -17,7 +16,7 @@ import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;

 /** Tests GLSM display list behavior matches OpenGL spec. */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class DisplayListCompilationGLSMTest {

    private int testList = -1;
@@ -3,16 +3,17 @@ package com.gtnewhorizons.angelica.glsm;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;

 import java.nio.FloatBuffer;

-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;

 /** Tests raw GL11 display list behavior (reference for GLSM). */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class DisplayListCompilationRawGLTest {

    private int testList = -1;
@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.glsm;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 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.GL15;
@@ -11,9 +10,11 @@ import org.lwjgl.opengl.GL30;

 import java.nio.FloatBuffer;

-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;

-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class FeedbackManagerTest {

    @BeforeEach
@@ -0,0 +1,18 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+@Tag(GLTestTags.COMPAT)
+@ExtendWith(GLSMExtension.class)
+public @interface GLCompatTest {
+}
@@ -0,0 +1,18 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Inherited;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+@Tag(GLTestTags.CORE)
+@ExtendWith(GLSMCoreExtension.class)
+public @interface GLCoreTest {
+}
@@ -1,40 +1,73 @@
 package com.gtnewhorizons.angelica.glsm;

 import com.gtnewhorizons.angelica.glsm.hooks.GLSMInitConfig;
-import org.junit.jupiter.api.extension.AfterAllCallback;
 import org.junit.jupiter.api.extension.BeforeAllCallback;
+import org.junit.jupiter.api.extension.BeforeEachCallback;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.lwjgl.LWJGLException;
 import org.lwjgl.opengl.ContextAttribs;
 import org.lwjgl.opengl.Display;
 import org.lwjgl.opengl.DisplayMode;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL32;
 import org.lwjgl.opengl.PixelFormat;

+import static org.junit.jupiter.api.extension.ExtensionContext.Namespace.GLOBAL;
+
 /**
 * 3.3 core-profile context extension
 */
-public class GLSMCoreExtension implements BeforeAllCallback, AfterAllCallback {
-    private boolean ownsDisplay = false;
+public class GLSMCoreExtension implements BeforeAllCallback, BeforeEachCallback, ExtensionContext.Store.CloseableResource {
+
+    private static boolean started = false;
+    private static Throwable startFailure;

    @Override
    public void beforeAll(ExtensionContext context) throws LWJGLException {
-        if (Display.isCreated()) return;
-        Display.setDisplayModeAndFullscreen(new DisplayMode(800, 600));
-        Display.setResizable(false);
-        Display.setFullscreen(false);
-        Display.create(
-            new PixelFormat().withDepthBits(24).withStencilBits(8),
-            new ContextAttribs(3, 3).withProfileCore(true).withForwardCompatible(true));
-        ownsDisplay = true;
-        GLStateManager.initialize(GLSMInitConfig.builder().displaySize(800, 600).build());
-        GLStateManager.setRunningSplash(false);
-        GLStateManager.markSplashComplete();
-        GLStateManager.BYPASS_CACHE = false;
+        if (startFailure != null) {
+            throw new IllegalStateException("GLSMCoreExtension context setup failed earlier in this JVM", startFailure);
+        }
+        if (started) return;
+        try {
+            Display.setDisplayModeAndFullscreen(new DisplayMode(800, 600));
+            Display.setResizable(false);
+            Display.setFullscreen(false);
+            Display.create(
+                new PixelFormat().withDepthBits(24).withStencilBits(8),
+                new ContextAttribs(3, 3).withProfileCore(true).withForwardCompatible(true));
+
+            GLSMExtension.setMainThread(Thread.currentThread());
+            GLStateManager.initialize(GLSMInitConfig.builder().displaySize(800, 600).build());
+            GLStateManager.setRunningSplash(false);
+            GLStateManager.markSplashComplete();
+            GLStateManager.BYPASS_CACHE = false;
+
+            GLSMExtension.glVendor = GL11.glGetString(GL11.GL_VENDOR);
+            GLSMExtension.glRenderer = GL11.glGetString(GL11.GL_RENDERER);
+            GLSMExtension.glVersion = GL11.glGetString(GL11.GL_VERSION);
+            System.out.println("OpenGL Vendor: " + GLSMExtension.glVendor);
+            System.out.println("OpenGL Renderer: " + GLSMExtension.glRenderer);
+            System.out.println("OpenGL Version: " + GLSMExtension.glVersion);
+
+            final int profileMask = GL11.glGetInteger(GL32.GL_CONTEXT_PROFILE_MASK);
+            if ((profileMask & GL32.GL_CONTEXT_CORE_PROFILE_BIT) == 0) {
+                throw new IllegalStateException("Expected a GL core context, got profile mask 0x" + Integer.toHexString(profileMask) + " (" + GLSMExtension.glVersion + ")");
+            }
+            context.getRoot().getStore(GLOBAL).put("GLSMCoreExtension", this);
+            started = true;
+        } catch (LWJGLException | RuntimeException | Error e) {
+            startFailure = e;
+            throw e;
+        }
    }

    @Override
-    public void afterAll(ExtensionContext context) {
-        if (ownsDisplay && Display.isCreated()) Display.destroy();
-        ownsDisplay = false;
+    public void beforeEach(ExtensionContext context) {
+        while (GL11.glGetError() != GL11.GL_NO_ERROR) {}
+    }
+
+    @Override
+    public void close() {
+        if (Display.isCreated()) Display.destroy();
    }
 }
@@ -8,9 +8,11 @@ import org.junit.jupiter.api.extension.ConditionEvaluationResult;
 import org.junit.jupiter.api.extension.ExecutionCondition;
 import org.junit.jupiter.api.extension.ExtensionContext;
 import org.lwjgl.LWJGLException;
+import org.lwjgl.opengl.ContextAttribs;
 import org.lwjgl.opengl.Display;
 import org.lwjgl.opengl.DisplayMode;
 import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL32;
 import org.lwjgl.opengl.PixelFormat;
 import sun.misc.Unsafe;

@@ -45,6 +47,7 @@ public class GLSMExtension implements BeforeAllCallback, BeforeEachCallback, Aft
    }

    private static boolean started = false;
+    private static Throwable startFailure;
    private static DisplayMode displayMode;
    public static String glVendor;
    public static String glRenderer;
@@ -55,21 +58,23 @@ public class GLSMExtension implements BeforeAllCallback, BeforeEachCallback, Aft

    @Override
    public void beforeAll(ExtensionContext context) throws LWJGLException {
-        if (!started) {
-            started = true;
-
+        if (startFailure != null) {
+            throw new IllegalStateException("GLSMExtension context setup failed earlier in this JVM", startFailure);
+        }
+        if (started) return;
+        try {
            displayMode = new DisplayMode(800, 600);
+            final GLSMInitConfig config = GLSMInitConfig.builder().displaySize(displayMode.getWidth(), displayMode.getHeight()).build();
+            setMainThread(Thread.currentThread());
+
+            latchRenderSystemOnCoreContext(config);
+
            Display.setDisplayModeAndFullscreen(displayMode);
            Display.setResizable(false);
            Display.setFullscreen(false);
-            final PixelFormat format = new PixelFormat().withDepthBits(24).withStencilBits(8);
-            Display.create(format);
+            Display.create(new PixelFormat().withDepthBits(24).withStencilBits(8));

-            setMainThread(Thread.currentThread());
-
-            GLStateManager.initialize(GLSMInitConfig.builder()
-                .displaySize(displayMode.getWidth(), displayMode.getHeight())
-                .build());
+            GLStateManager.initialize(config);
            GLStateManager.setRunningSplash(false);
            GLStateManager.markSplashComplete();
            GLStateManager.BYPASS_CACHE = false;
@@ -81,6 +86,30 @@ public class GLSMExtension implements BeforeAllCallback, BeforeEachCallback, Aft
            System.out.println("OpenGL Vendor: " + glVendor);
            System.out.println("OpenGL Renderer: " + glRenderer);
            System.out.println("OpenGL Version: " + glVersion);
+
+            final int profileMask = GL11.glGetInteger(GL32.GL_CONTEXT_PROFILE_MASK);
+            if ((profileMask & GL32.GL_CONTEXT_COMPATIBILITY_PROFILE_BIT) == 0) {
+                throw new IllegalStateException("Expected a GL compatibility context, got profile mask 0x" + Integer.toHexString(profileMask) + " (" + glVersion + ")");
+            }
+            started = true;
+        } catch (LWJGLException | RuntimeException | Error e) {
+            startFailure = e;
+            throw e;
+        }
+    }
+
+
+    private static void latchRenderSystemOnCoreContext(GLSMInitConfig config) throws LWJGLException {
+        Display.setDisplayModeAndFullscreen(displayMode);
+        Display.setResizable(false);
+        Display.setFullscreen(false);
+        Display.create(
+            new PixelFormat().withDepthBits(24).withStencilBits(8),
+            new ContextAttribs(3, 3).withProfileCore(true).withForwardCompatible(true));
+        try {
+            GLStateManager.initialize(config);
+        } finally {
+            Display.destroy();
        }
    }

@@ -95,7 +124,7 @@ public class GLSMExtension implements BeforeAllCallback, BeforeEachCallback, Aft
        }
    }

-    private static void setMainThread(Thread thread) {
+    static void setMainThread(Thread thread) {
        try {
            final Field f = GLStateManager.class.getDeclaredField("MainThread");
            final Object base = theUnsafe.staticFieldBase(f);
@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.glsm;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL30;

@@ -16,7 +15,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 * Verifies that per-buffer blend operations (glEnablei/glDisablei) properly invalidate
 * the GLSM blend cache so subsequent global blend enable/disable calls are not skipped.
 */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class GLSM_BlendUnknownState_UnitTest {

    @BeforeEach
@@ -0,0 +1,105 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.lwjgl.opengl.GL11;
+
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@GLCoreTest
+public class GLSM_CoreRemovedCaps_GLTest {
+
+    static Stream<Arguments> removedCaps() {
+        return Stream.of(
+            cap("GL_LINE_STIPPLE", GL11.GL_LINE_STIPPLE),
+            cap("GL_POINT_SMOOTH", GL11.GL_POINT_SMOOTH),
+            cap("GL_POLYGON_STIPPLE", GL11.GL_POLYGON_STIPPLE),
+            cap("GL_INDEX_LOGIC_OP", GL11.GL_INDEX_LOGIC_OP),
+            cap("GL_AUTO_NORMAL", GL11.GL_AUTO_NORMAL),
+            cap("GL_MAP1_COLOR_4", GL11.GL_MAP1_COLOR_4),
+            cap("GL_MAP1_INDEX", GL11.GL_MAP1_INDEX),
+            cap("GL_MAP1_NORMAL", GL11.GL_MAP1_NORMAL),
+            cap("GL_MAP1_TEXTURE_COORD_1", GL11.GL_MAP1_TEXTURE_COORD_1),
+            cap("GL_MAP1_TEXTURE_COORD_2", GL11.GL_MAP1_TEXTURE_COORD_2),
+            cap("GL_MAP1_TEXTURE_COORD_3", GL11.GL_MAP1_TEXTURE_COORD_3),
+            cap("GL_MAP1_TEXTURE_COORD_4", GL11.GL_MAP1_TEXTURE_COORD_4),
+            cap("GL_MAP1_VERTEX_3", GL11.GL_MAP1_VERTEX_3),
+            cap("GL_MAP1_VERTEX_4", GL11.GL_MAP1_VERTEX_4),
+            cap("GL_MAP2_COLOR_4", GL11.GL_MAP2_COLOR_4),
+            cap("GL_MAP2_INDEX", GL11.GL_MAP2_INDEX),
+            cap("GL_MAP2_NORMAL", GL11.GL_MAP2_NORMAL),
+            cap("GL_MAP2_TEXTURE_COORD_1", GL11.GL_MAP2_TEXTURE_COORD_1),
+            cap("GL_MAP2_TEXTURE_COORD_2", GL11.GL_MAP2_TEXTURE_COORD_2),
+            cap("GL_MAP2_TEXTURE_COORD_3", GL11.GL_MAP2_TEXTURE_COORD_3),
+            cap("GL_MAP2_TEXTURE_COORD_4", GL11.GL_MAP2_TEXTURE_COORD_4),
+            cap("GL_MAP2_VERTEX_3", GL11.GL_MAP2_VERTEX_3),
+            cap("GL_MAP2_VERTEX_4", GL11.GL_MAP2_VERTEX_4));
+    }
+
+    private static Arguments cap(String name, int value) {
+        return Arguments.of(name, value);
+    }
+
+    private static void assertNoGlError(String what) {
+        final int error = GL11.glGetError();
+        assertEquals(GL11.GL_NO_ERROR, error, () -> what + " raised 0x" + Integer.toHexString(error));
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("removedCaps")
+    void enableDisableIsCacheOnly(String name, int cap) {
+        try {
+            GLStateManager.glEnable(cap);
+            assertNoGlError("glEnable(" + name + ")");
+            assertTrue(GLStateManager.glIsEnabled(cap), name + " must still round-trip through the cache");
+
+            GLStateManager.glDisable(cap);
+            assertNoGlError("glDisable(" + name + ")");
+            assertFalse(GLStateManager.glIsEnabled(cap));
+        } finally {
+            GLStateManager.glDisable(cap);
+            while (GL11.glGetError() != GL11.GL_NO_ERROR) {}
+        }
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("removedCaps")
+    void pushPopAttribIsCacheOnly(String name, int cap) {
+        try {
+            GLStateManager.glPushAttrib(GL11.GL_ENABLE_BIT);
+            GLStateManager.glEnable(cap);
+            GLStateManager.glPopAttrib();
+            assertNoGlError("glPushAttrib/glEnable(" + name + ")/glPopAttrib");
+            assertFalse(GLStateManager.glIsEnabled(cap));
+        } finally {
+            GLStateManager.glDisable(cap);
+            while (GL11.glGetError() != GL11.GL_NO_ERROR) {}
+        }
+    }
+
+    @Test
+    void displayListReplayIsCacheOnly() {
+        final int list = GLStateManager.glGenLists(1);
+        try {
+            GLStateManager.glNewList(list, GL11.GL_COMPILE);
+            GLStateManager.glEnable(GL11.GL_LINE_STIPPLE);
+            GLStateManager.glLineStipple(2, (short) 0xF0F0);
+            GLStateManager.glDisable(GL11.GL_LINE_STIPPLE);
+            GLStateManager.glEndList();
+            assertNoGlError("display list compile");
+
+            GLStateManager.glCallList(list);
+            assertNoGlError("display list replay");
+        } finally {
+            GLStateManager.glDeleteLists(list, 1);
+            GLStateManager.glDisable(GL11.GL_LINE_STIPPLE);
+            while (GL11.glGetError() != GL11.GL_NO_ERROR) {}
+        }
+    }
+}
@@ -0,0 +1,71 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import org.junit.jupiter.api.Test;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL15;
+import org.lwjgl.opengl.GL21;
+import org.lwjgl.opengl.GL30;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+/** Deleting a bound buffer must not strand an id in LWJGL2's StateTracker */
+@GLCompatTest
+public class GLSM_DeletedBufferBinding_GLTest {
+
+    private static int makeBoundBuffer(int target) {
+        final int buffer = GLStateManager.glGenBuffers();
+        GLStateManager.glBindBuffer(target, buffer);
+        GLStateManager.glBufferData(target, 64L, GL15.GL_STREAM_DRAW);
+        return buffer;
+    }
+
+    private static void assertUnboundAfterDelete(int target, int binding, int buffer) {
+        GLStateManager.glDeleteBuffers(buffer);
+        assertEquals(0, GL11.glGetInteger(binding), "GL unbinds a deleted buffer; the cache must not be the only place that knows");
+    }
+
+    @Test
+    void deletedPixelUnpackBufferDoesNotBlockTexImage2D() {
+        final int pbo = makeBoundBuffer(GL21.GL_PIXEL_UNPACK_BUFFER);
+        assertUnboundAfterDelete(GL21.GL_PIXEL_UNPACK_BUFFER, GL21.GL_PIXEL_UNPACK_BUFFER_BINDING, pbo);
+
+        final int tex = GLStateManager.glGenTextures();
+        try {
+            GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, tex);
+            GLStateManager.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, 1, 1, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, BufferUtils.createByteBuffer(4));
+        } finally {
+            GLStateManager.glDeleteTextures(tex);
+        }
+    }
+
+    @Test
+    void deletedPixelPackBufferDoesNotBlockReadPixels() {
+        final int pbo = makeBoundBuffer(GL21.GL_PIXEL_PACK_BUFFER);
+        assertUnboundAfterDelete(GL21.GL_PIXEL_PACK_BUFFER, GL21.GL_PIXEL_PACK_BUFFER_BINDING, pbo);
+
+        GL11.glReadPixels(0, 0, 1, 1, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, BufferUtils.createByteBuffer(4));
+    }
+
+    @Test
+    void deletedArrayBufferDoesNotBlockClientVertexPointer() {
+        final int vbo = makeBoundBuffer(GL15.GL_ARRAY_BUFFER);
+        assertUnboundAfterDelete(GL15.GL_ARRAY_BUFFER, GL15.GL_ARRAY_BUFFER_BINDING, vbo);
+
+        final int prevVao = GL11.glGetInteger(GL30.GL_VERTEX_ARRAY_BINDING);
+        GL30.glBindVertexArray(0);
+        try {
+            GL11.glVertexPointer(3, 0, BufferUtils.createFloatBuffer(9));
+        } finally {
+            GL30.glBindVertexArray(prevVao);
+        }
+    }
+
+    @Test
+    void deletedElementArrayBufferDoesNotBlockClientDrawElements() {
+        final int ebo = makeBoundBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER);
+        assertUnboundAfterDelete(GL15.GL_ELEMENT_ARRAY_BUFFER, GL15.GL_ELEMENT_ARRAY_BUFFER_BINDING, ebo);
+
+        GL11.glDrawElements(GL11.GL_TRIANGLES, BufferUtils.createIntBuffer(3));
+    }
+}
@@ -4,7 +4,6 @@ import org.joml.Vector4f;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL11;

 import java.nio.ByteBuffer;
@@ -13,7 +12,7 @@ import java.nio.FloatBuffer;

 import static org.junit.jupiter.api.Assertions.assertEquals;

-@ExtendWith(GLSMCoreExtension.class)
+@GLCoreTest
 public class GLSM_DirtyTracking_UnitTest {

    static final FloatBuffer f4b = ByteBuffer.allocateDirect(4 << 2).order(ByteOrder.nativeOrder()).asFloatBuffer();
@@ -6,13 +6,15 @@ import com.gtnewhorizons.angelica.glsm.recording.DisplayListVBO;
 import com.gtnewhorizons.angelica.glsm.recording.GLCommand;
 import it.unimi.dsi.fastutil.ints.Int2IntMap;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;

 import java.util.HashSet;
 import java.util.Set;

-import static com.gtnewhorizons.angelica.glsm.DisplayListTestHelper.*;
-import static org.junit.jupiter.api.Assertions.*;
+import static com.gtnewhorizons.angelica.glsm.DisplayListTestHelper.createColorDraw;
+import static com.gtnewhorizons.angelica.glsm.DisplayListTestHelper.createDisplayList;
+import static com.gtnewhorizons.angelica.glsm.DisplayListTestHelper.createSimpleDraw;
+import static com.gtnewhorizons.angelica.glsm.DisplayListTestHelper.createTextureDraw;
+import static org.junit.jupiter.api.Assertions.assertEquals;

 /**
 * Tests for display list format-based batching behavior.
@@ -24,7 +26,7 @@ import static org.junit.jupiter.api.Assertions.*;
 *   <li>Different formats produce separate VBOs</li>
 * </ul>
 */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class GLSM_DisplayList_Batching_Test {

    private static int getVBOCount(CompiledDisplayList compiledDisplayList) {
@@ -2,7 +2,6 @@ package com.gtnewhorizons.angelica.glsm;

 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL11;

 import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyState;
@@ -12,7 +11,7 @@ import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyState;
 * Verifies that display lists work correctly with different vertex attribute combinations
 * and that optimal formats are selected.
 */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class GLSM_DisplayList_FormatOptimization_Test {

    private int displayList = -1;
@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.glsm;
 import org.joml.Matrix4f;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;

@@ -15,7 +14,7 @@ import static org.junit.jupiter.api.Assertions.assertEquals;
 * Tests for nested display list execution.
 * Verifies that child display lists compose correctly with parent transforms.
 */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class GLSM_DisplayList_Nesting_Test {

    private int parentList = -1;
@@ -2,7 +2,6 @@ package com.gtnewhorizons.angelica.glsm;

 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL11;

 import java.nio.ByteBuffer;
@@ -10,7 +9,7 @@ import java.nio.ByteOrder;

 import static org.junit.jupiter.api.Assertions.assertEquals;

-@ExtendWith(GLSMCoreExtension.class)
+@GLCoreTest
 public class GLSM_DisplayList_PixelStore_Test {

    private static final int SRC = 8;
@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.glsm;
 import org.joml.Matrix4f;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;

@@ -23,7 +22,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 * need the full Minecraft environment. These tests focus on matrix
 * operations and display list lifecycle which work with raw GL calls.</p>
 */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class GLSM_DisplayList_Stress_Test {

    private final List<Integer> testLists = new ArrayList<>();
@@ -7,7 +7,6 @@ import it.unimi.dsi.fastutil.ints.IntList;
 import org.joml.Matrix4f;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;

@@ -18,7 +17,7 @@ import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;

 /** Tests for transform collapsing optimization in display lists. */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class GLSM_DisplayList_TransformCollapsing_Test {

    private int testList = -1;
@@ -1,14 +1,12 @@
 package com.gtnewhorizons.angelica.glsm;

-import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL11;

 import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyState;
 import static org.junit.jupiter.api.Assertions.assertEquals;

-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class GLSM_DisplayList_UnitTest {

    @Test
@@ -2,7 +2,6 @@ package com.gtnewhorizons.angelica.glsm;

 import org.joml.Matrix4f;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;

@@ -14,7 +13,7 @@ import static org.junit.jupiter.api.Assertions.assertTrue;
 /**
 * Tests that GLStateManager's GLU implementations produce the same matrices as the equivalent JOML operations.
 */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 public class GLSM_GLU_UnitTest {

    private static final FloatBuffer buffer = BufferUtils.createFloatBuffer(16);
@@ -1,7 +1,6 @@
 package com.gtnewhorizons.angelica.glsm;

 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;

@@ -10,10 +9,10 @@ import java.nio.ByteOrder;
 import java.nio.FloatBuffer;

 import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyLightState;
-import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyState;
 import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyMaterialState;
+import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyState;

-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 public class GLSM_Lighting_UnitTest {

    static final FloatBuffer f4b = ByteBuffer.allocateDirect(4 << 2).order(ByteOrder.nativeOrder()).asFloatBuffer();
@@ -0,0 +1,184 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement;
+import com.gtnewhorizons.angelica.glsm.states.ViewportState;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL15;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.function.IntPredicate;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@GLCoreTest
+public class GLSM_LineStipple_GLTest {
+
+    private static final int W = 32;
+
+    private static final int POSITION_LOC = VertexFormatElement.Usage.POSITION.getAttributeLocation();
+
+    private final ByteBuffer pixels = BufferUtils.createByteBuffer(W * 4);
+    private final ByteBuffer verts = ByteBuffer.allocateDirect(3 * 12).order(ByteOrder.nativeOrder());
+    private int savedX, savedY, savedW, savedH;
+    private int vao, vbo;
+
+    @BeforeEach
+    void setUp() {
+        final ViewportState vp = GLStateManager.getViewportState();
+        savedX = vp.x;
+        savedY = vp.y;
+        savedW = vp.width;
+        savedH = vp.height;
+
+        GLStateManager.glUseProgram(0);
+
+        vao = GLStateManager.glGenVertexArrays();
+        GLStateManager.glBindVertexArray(vao);
+        vbo = GLStateManager.glGenBuffers();
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
+        GLStateManager.glVertexAttribPointer(POSITION_LOC, 3, GL11.GL_FLOAT, false, 12, 0L);
+        GLStateManager.glEnableVertexAttribArray(POSITION_LOC);
+
+        GLStateManager.glViewport(0, 0, W, 1);
+        GLStateManager.glMatrixMode(GL11.GL_PROJECTION);
+        GLStateManager.glPushMatrix();
+        GLStateManager.glLoadIdentity();
+        GLStateManager.glOrtho(0, W, 0, 1, -1, 1);
+        GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+        GLStateManager.glPushMatrix();
+        GLStateManager.glLoadIdentity();
+        GLStateManager.glDisable(GL11.GL_DEPTH_TEST);
+        GLStateManager.glDisable(GL11.GL_BLEND);
+        GLStateManager.glDisable(GL11.GL_TEXTURE_2D);
+        GLStateManager.glColor4f(1f, 1f, 1f, 1f);
+    }
+
+    @AfterEach
+    void tearDown() {
+        GLStateManager.glDisable(GL11.GL_LINE_STIPPLE);
+        GLStateManager.glLineStipple(1, (short) 0xFFFF);
+        GLStateManager.glMatrixMode(GL11.GL_PROJECTION);
+        GLStateManager.glPopMatrix();
+        GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+        GLStateManager.glPopMatrix();
+        GLStateManager.glViewport(savedX, savedY, savedW, savedH);
+        GLStateManager.glBindVertexArray(0);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+        if (vbo != 0) GLStateManager.glDeleteBuffers(vbo);
+        if (vao != 0) GLStateManager.glDeleteVertexArrays(vao);
+        while (GL11.glGetError() != GL11.GL_NO_ERROR) {}
+    }
+
+    private boolean[] renderLine(float x0, float x1) {
+        clear();
+        drawLines(x0, x1);
+        return readCoverage();
+    }
+
+    private void drawLines(float... xs) {
+        verts.clear();
+        for (float x : xs) verts.putFloat(x).putFloat(0.5f).putFloat(0f);
+        verts.flip();
+        GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, verts, GL15.GL_STREAM_DRAW);
+        GLStateManager.glDrawArrays(xs.length == 2 ? GL11.GL_LINES : GL11.GL_LINE_STRIP, 0, xs.length);
+    }
+
+    private void clear() {
+        GLStateManager.glClearColor(0f, 0f, 0f, 1f);
+        GLStateManager.glClear(GL11.GL_COLOR_BUFFER_BIT);
+    }
+
+    private boolean[] readCoverage() {
+        pixels.clear();
+        GLStateManager.glReadPixels(0, 0, W, 1, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixels);
+        assertEquals(GL11.GL_NO_ERROR, GL11.glGetError(), "GL error during readback");
+
+        final boolean[] covered = new boolean[W];
+        for (int i = 0; i < W; i++) {
+            covered[i] = (pixels.get(i * 4) & 0xFF) > 127;
+        }
+        return covered;
+    }
+
+    private static boolean[] expected(IntPredicate on) {
+        final boolean[] e = new boolean[W];
+        for (int i = 0; i < W; i++) e[i] = on.test(i);
+        return e;
+    }
+
+    private static void stipple(int factor, int pattern) {
+        GLStateManager.glEnable(GL11.GL_LINE_STIPPLE);
+        GLStateManager.glLineStipple(factor, (short) pattern);
+    }
+
+    @Test
+    void solidPatternCoversEveryPixel() {
+        stipple(1, 0xFFFF);
+        assertArrayEquals(expected(i -> true), renderLine(0f, W));
+    }
+
+    @Test
+    void emptyPatternCoversNothing() {
+        stipple(1, 0x0000);
+        assertArrayEquals(expected(i -> false), renderLine(0f, W));
+    }
+
+    @Test
+    void alternatingPatternDashesEveryOtherPixel() {
+        stipple(1, 0xAAAA);
+        assertArrayEquals(expected(i -> (i & 1) == 1), renderLine(0f, W));
+    }
+
+    @Test
+    void factorStretchesEachBitAcrossThatManyPixels() {
+        stipple(2, 0xAAAA);
+        assertArrayEquals(expected(i -> ((i / 2) & 1) == 1), renderLine(0f, W));
+    }
+
+    @Test
+    void disabledStippleCoversEveryPixel() {
+        GLStateManager.glLineStipple(1, (short) 0xAAAA);
+        GLStateManager.glDisable(GL11.GL_LINE_STIPPLE);
+        assertArrayEquals(expected(i -> true), renderLine(0f, W));
+    }
+
+    @Test
+    void patternIsAnchoredAtTheSegmentStart() {
+        stipple(1, 0xAAAA);
+        final boolean[] covered = renderLine(8f, W);
+        for (int i = 8; i < W; i++) {
+            assertEquals(((i - 8) & 1) == 1, covered[i], "pixel " + i + " must be phased from x=8, not x=0");
+        }
+    }
+
+    @Test
+    void lineStripRestartsThePatternPerSegment() {
+        stipple(1, 0xAAAA);
+
+        clear();
+        drawLines(0f, 9f, W);
+
+        final boolean[] covered = readCoverage();
+        for (int i = 0; i < 9; i++) {
+            assertEquals((i & 1) == 1, covered[i], "segment 1 pixel " + i);
+        }
+        for (int i = 10; i < W; i++) {
+            assertEquals(((i - 9) & 1) == 1, covered[i], "segment 2 pixel " + i + " must restart the phase at x=9");
+        }
+    }
+
+    @Test
+    void nonStippleDrawAfterStippleIsUnaffected() {
+        stipple(1, 0xAAAA);
+        renderLine(0f, W);
+
+        GLStateManager.glDisable(GL11.GL_LINE_STIPPLE);
+        assertArrayEquals(expected(i -> true), renderLine(0f, W));
+    }
+}
@@ -2,7 +2,6 @@ package com.gtnewhorizons.angelica.glsm;

 import org.joml.Matrix4f;
 import org.joml.Matrix4fStack;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.EnumSource;
 import org.lwjgl.BufferUtils;
@@ -12,7 +11,7 @@ import java.nio.FloatBuffer;

 import static org.junit.jupiter.api.Assertions.assertTrue;

-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 public class GLSM_MatrixStack_UnitTest {

    final static FloatBuffer buffer = BufferUtils.createFloatBuffer(16);
@@ -4,7 +4,6 @@ import com.gtnewhorizons.angelica.util.GLBit;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 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.GL12;
@@ -21,7 +20,7 @@ import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyLightState;
 import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyState;
 import static org.junit.jupiter.api.Assertions.assertTrue;

-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class GLSM_PushPop_UnitTest {

    @BeforeEach
@@ -1132,4 +1131,52 @@ class GLSM_PushPop_UnitTest {
        GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
        GLStateManager.glDisable(GL11.GL_TEXTURE_2D);
    }
+
+    @Test
+    void testBlendFuncGL11AliasesMatchGL14() {
+        GLStateManager.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+        verifyState(GL11.GL_BLEND_SRC, GL11.GL_SRC_ALPHA, "Blend Source");
+        verifyState(GL14.GL_BLEND_SRC_RGB, GL11.GL_SRC_ALPHA, "Blend Source RGB");
+        verifyState(GL11.GL_BLEND_DST, GL11.GL_ONE_MINUS_SRC_ALPHA, "Blend Destination");
+        verifyState(GL14.GL_BLEND_DST_RGB, GL11.GL_ONE_MINUS_SRC_ALPHA, "Blend Destination RGB");
+
+        GLStateManager.glBlendFunc(GL11.GL_ONE, GL11.GL_ZERO);
+    }
+
+    @Test
+    void testBlendFuncSeparateGL11AliasesTrackRgb() {
+        GLStateManager.glBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, GL11.GL_ONE, GL11.GL_ZERO);
+
+        verifyState(GL11.GL_BLEND_SRC, GL11.GL_SRC_ALPHA, "Blend Source");
+        verifyState(GL11.GL_BLEND_DST, GL11.GL_ONE_MINUS_SRC_ALPHA, "Blend Destination");
+        verifyState(GL14.GL_BLEND_SRC_ALPHA, GL11.GL_ONE, "Blend Source Alpha");
+        verifyState(GL14.GL_BLEND_DST_ALPHA, GL11.GL_ZERO, "Blend Destination Alpha");
+
+        GLStateManager.glBlendFunc(GL11.GL_ONE, GL11.GL_ZERO);
+    }
+
+    @Test
+    void testPolygonStateReadBack() {
+        GLStateManager.glCullFace(GL11.GL_FRONT);
+        GLStateManager.glFrontFace(GL11.GL_CW);
+        GLStateManager.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_LINE);
+
+        verifyState(GL11.GL_CULL_FACE_MODE, GL11.GL_FRONT, "Cull Face Mode");
+        verifyState(GL11.GL_FRONT_FACE, GL11.GL_CW, "Front Face");
+        verifyState(GL11.GL_POLYGON_MODE, new int[] { GL11.GL_LINE, GL11.GL_LINE }, "Polygon Mode");
+
+        GLStateManager.glCullFace(GL11.GL_BACK);
+        GLStateManager.glFrontFace(GL11.GL_CCW);
+        GLStateManager.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
+    }
+
+    @Test
+    void testActiveTextureReadBack() {
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE1);
+        verifyState(GL13.GL_ACTIVE_TEXTURE, GL13.GL_TEXTURE1, "Active Texture");
+
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+        verifyState(GL13.GL_ACTIVE_TEXTURE, GL13.GL_TEXTURE0, "Active Texture - Reset");
+    }
 }
@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.glsm;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.LWJGLException;
 import org.lwjgl.opengl.Display;
 import org.lwjgl.opengl.GL11;
@@ -15,7 +14,10 @@ import java.nio.ByteBuffer;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;

-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;

 /**
 * Tests for server-side GL state synchronization between SharedDrawable and DrawableGL contexts.
@@ -24,7 +26,7 @@ import static org.junit.jupiter.api.Assertions.*;
 * be properly synchronized in the GLSM cache. Client-side state (texture bindings, active unit)
 * is per-context and should NOT be shared.
 */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 public class GLSM_ServerSideState_UnitTest {

    private SharedDrawable sharedDrawable;
@@ -3,20 +3,24 @@ package com.gtnewhorizons.angelica.glsm;
 import com.gtnewhorizons.angelica.glsm.texture.TextureInfo;
 import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.EXTTextureCompressionS3TC;
 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;

-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;

-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 public class GLSM_TextureInfoCache_UnitTest {

    @Test
@@ -5,7 +5,6 @@ import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
 import com.gtnewhorizons.angelica.util.GLSMUtil;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL13;
 import org.lwjgl.opengl.GL15;
@@ -13,7 +12,7 @@ import org.lwjgl.opengl.GL30;

 import static com.gtnewhorizons.angelica.util.GLSMUtil.verifyState;

-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 public class GLSM_VAO_UnitTest {

    @Test
@@ -0,0 +1,9 @@
+package com.gtnewhorizons.angelica.glsm;
+
+public final class GLTestTags {
+    public static final String COMPAT = "gl-compat";
+    public static final String CORE = "gl-core";
+    public static final String SHARED = "gl-shared";
+
+    private GLTestTags() {}
+}
@@ -0,0 +1,34 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class GLVersionParseTest {
+
+    @Test
+    void parseMajorMinor() {
+        assertEquals(43, RenderSystem.parseMajorMinor("4.3.0 - Build 20.19.15.4835"));
+        assertEquals(46, RenderSystem.parseMajorMinor("4.6.0 NVIDIA 551.61"));
+        assertEquals(41, RenderSystem.parseMajorMinor("4.1 Metal - 88"));
+        assertEquals(33, RenderSystem.parseMajorMinor("3.3"));
+        assertEquals(46, RenderSystem.parseMajorMinor("4.6 (Core Profile) Mesa 24.0.3"));
+        assertEquals(-1, RenderSystem.parseMajorMinor(null));
+        assertEquals(-1, RenderSystem.parseMajorMinor(""));
+        assertEquals(-1, RenderSystem.parseMajorMinor("garbage"));
+        assertEquals(-1, RenderSystem.parseMajorMinor("OpenGL ES 3.2"));
+    }
+
+    @Test
+    void isContextValid() {
+        assertTrue(RenderSystem.isContextValid(4, 4, 46, true));
+        assertTrue(RenderSystem.isContextValid(4, 4, 44, true));
+        assertFalse(RenderSystem.isContextValid(4, 4, 43, true));
+        assertFalse(RenderSystem.isContextValid(4, 4, 44, false));
+        assertTrue(RenderSystem.isContextValid(4, 4, -1, true));
+        assertFalse(RenderSystem.isContextValid(4, 4, -1, false));
+        assertTrue(RenderSystem.isContextValid(3, 3, 33, true));
+    }
+}
@@ -0,0 +1,82 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import org.joml.FrustumIntersection;
+import org.joml.Matrix4f;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class HugeFarPlaneFrustumTest {
+
+    private static final float SECTION_HALF = 8.0f + 1.0f + 0.125f;
+    private static final float DEGENERATE_FAR = 2.147483648e9f;
+
+    private static Matrix4f combined(float zFar) {
+        final Matrix4f proj = new Matrix4f().perspective((float) Math.toRadians(70.0), 854.0f / 480.0f, 0.05f, zFar);
+        final Matrix4f mv = new Matrix4f()
+            .rotate((float) Math.toRadians(25.0), 1, 0, 0)
+            .rotate((float) Math.toRadians(123.0), 0, 1, 0)
+            .translate(0.0f, -1.62f, 0.0f);
+        return new Matrix4f().set(proj).mul(mv);
+    }
+
+    private static boolean sectionVisible(FrustumIntersection f, int sx, int sy, int sz) {
+        final float cx = sx * 16.0f + 8.0f;
+        final float cy = sy * 16.0f + 8.0f;
+        final float cz = sz * 16.0f + 8.0f;
+        return f.testAab(cx - SECTION_HALF, cy - SECTION_HALF, cz - SECTION_HALF, cx + SECTION_HALF, cy + SECTION_HALF, cz + SECTION_HALF);
+    }
+
+    @Test
+    void unnormalizedFrustumMatchesNormalFarPlane() {
+        final FrustumIntersection normal = new FrustumIntersection(combined(512.0f), false);
+        final FrustumIntersection huge = new FrustumIntersection(combined(DEGENERATE_FAR), false);
+
+        int visible = 0;
+        int mismatches = 0;
+        for (int x = -12; x <= 12; x++) {
+            for (int y = -4; y <= 4; y++) {
+                for (int z = -12; z <= 12; z++) {
+                    final boolean vNormal = sectionVisible(normal, x, y, z);
+                    if (vNormal) visible++;
+                    if (vNormal != sectionVisible(huge, x, y, z)) mismatches++;
+                }
+            }
+        }
+        assertTrue(visible > 100, "sanity check broken: normal frustum accepted only " + visible + " sections");
+        assertEquals(0, mismatches, "sections culled differently under the degenerate far plane");
+    }
+
+    @Test
+    void normalizedSetCullsEverythingOnDegenerateFarPlane() {
+        final FrustumIntersection normalized = new FrustumIntersection();
+        normalized.set(combined(DEGENERATE_FAR));
+
+        int visible = 0;
+        for (int x = -12; x <= 12; x++) {
+            for (int y = -4; y <= 4; y++) {
+                for (int z = -12; z <= 12; z++) {
+                    if (sectionVisible(normalized, x, y, z)) visible++;
+                }
+            }
+        }
+        assertEquals(0, visible, "set(m) with a degenerate far plane no longer culls everything");
+    }
+
+    @Test
+    void identityFrustumOnlyPassesCameraSection() {
+        final FrustumIntersection identity = new FrustumIntersection(new Matrix4f());
+        assertTrue(sectionVisible(identity, 0, 0, 0), "identity frustum rejected the camera's own section");
+        int visible = 0;
+        for (int x = -12; x <= 12; x++) {
+            for (int y = -4; y <= 4; y++) {
+                for (int z = -12; z <= 12; z++) {
+                    if (Math.abs(x) <= 1 && Math.abs(y) <= 1 && Math.abs(z) <= 1) continue;
+                    if (sectionVisible(identity, x, y, z)) visible++;
+                }
+            }
+        }
+        assertEquals(0, visible, "non-adjacent sections accepted by the identity frustum");
+    }
+}
@@ -0,0 +1,124 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
+import com.gtnewhorizons.angelica.glsm.recording.CompiledDisplayList;
+import com.gtnewhorizons.angelica.glsm.recording.GLCommand;
+import com.gtnewhorizons.angelica.glsm.recording.ImmediateModeRecorder;
+import org.junit.jupiter.api.Test;
+import org.lwjgl.opengl.GL11;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@GLCoreTest
+class ImmediateModeThreadIsolationTest {
+
+    @Test
+    void backgroundThreadsGetDistinctTessellators() throws Exception {
+        final DirectTessellator mainTess = ImmediateModeRecorder.getInternalTessellator();
+        final AtomicReference<DirectTessellator> bg1 = new AtomicReference<>();
+        final AtomicReference<DirectTessellator> bg2 = new AtomicReference<>();
+
+        final Thread t1 = new Thread(() -> bg1.set(ImmediateModeRecorder.getInternalTessellator()), "iso-test-1");
+        final Thread t2 = new Thread(() -> bg2.set(ImmediateModeRecorder.getInternalTessellator()), "iso-test-2");
+        t1.start(); t2.start();
+        t1.join(); t2.join();
+
+        assertNotNull(bg1.get());
+        assertNotNull(bg2.get());
+        assertNotSame(mainTess, bg1.get(), "background thread must not share the main-thread tessellator");
+        assertNotSame(mainTess, bg2.get(), "background thread must not share the main-thread tessellator");
+        assertNotSame(bg1.get(), bg2.get(), "background threads must not share a tessellator");
+    }
+
+    @Test
+    void concurrentImmediateModeDoesNotCorruptRecording() throws Exception {
+        final List<Throwable> failures = new CopyOnWriteArrayList<>();
+        final CountDownLatch start = new CountDownLatch(1);
+        final AtomicBoolean stop = new AtomicBoolean(false);
+
+        final Runnable spam = () -> {
+            try {
+                start.await();
+                while (!stop.get()) {
+                    GLStateManager.glBegin(GL11.GL_QUADS);
+                    GLStateManager.glVertex3f(0, 0, 0);
+                    GLStateManager.glVertex3f(1, 0, 0);
+                    GLStateManager.glVertex3f(1, 1, 0);
+                    GLStateManager.glVertex3f(0, 1, 0);
+                    GLStateManager.glEnd();
+                }
+            } catch (Throwable t) {
+                failures.add(t);
+            }
+        };
+        final Thread t1 = new Thread(spam, "iso-spam-1");
+        final Thread t2 = new Thread(spam, "iso-spam-2");
+        t1.start(); t2.start();
+        start.countDown();
+
+        final List<Integer> lists = new ArrayList<>();
+        try {
+            for (int i = 0; i < 50; i++) {
+                final int list = GLStateManager.glGenLists(1);
+                GLStateManager.glNewList(list, GL11.GL_COMPILE);
+                GLStateManager.glBegin(GL11.GL_QUADS);
+                GLStateManager.glVertex3f(0, 0, 0);
+                GLStateManager.glVertex3f(1, 0, 0);
+                GLStateManager.glVertex3f(1, 1, 0);
+                GLStateManager.glVertex3f(0, 1, 0);
+                GLStateManager.glEnd();
+                GLStateManager.glEndList();
+                lists.add(list);
+            }
+        } finally {
+            stop.set(true);
+            t1.join(5000); t2.join(5000);
+        }
+
+        assertTrue(failures.isEmpty(), "background immediate mode threw: " + failures);
+        for (int list : lists) {
+            final CompiledDisplayList compiled = DisplayListManager.getDisplayList(list);
+            assertNotNull(compiled, "list " + list + " should be compiled");
+            assertEquals(1, compiled.getCommandCounts().getOrDefault(GLCommand.DRAW_RANGE, 0), "list " + list + " should contain exactly the main thread's draw");
+            GLStateManager.glDeleteLists(list, 1);
+        }
+    }
+
+    @Test
+    void sweepFreesDeadThreadTessellators() throws Exception {
+        final Thread t = new Thread(() -> ImmediateModeRecorder.getInternalTessellator(), "iso-sweep");
+        t.start();
+        t.join();
+        final int before = ImmediateModeRecorder.getThreadTessellatorCount();
+        assertTrue(before >= 1);
+        ImmediateModeRecorder.cleanupOrphanTessellators();
+        assertTrue(ImmediateModeRecorder.getThreadTessellatorCount() < before, "dead thread's tessellator should be swept");
+    }
+
+    @Test
+    void drawLockGatesOnSplashComplete() throws Exception {
+        assertFalse(GLStateManager.acquireDrawLock(), "post-splash acquire must be a no-op");
+
+        final Field f = GLStateManager.class.getDeclaredField("splashComplete");
+        f.setAccessible(true);
+        f.set(null, false);
+        try {
+            assertTrue(GLStateManager.acquireDrawLock(), "during splash the lock must engage");
+            GLStateManager.releaseDrawLock();
+        } finally {
+            f.set(null, true);
+        }
+    }
+}
@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.glsm;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 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.GL15;
@@ -15,7 +14,7 @@ import java.nio.IntBuffer;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;

-@ExtendWith(GLSMCoreExtension.class)
+@GLCoreTest
 class InstancedQuadDrawGLTest {

    private static final String VS = "#version 330 core\nlayout(location=0) in vec2 aPos;\nvoid main(){ gl_Position = vec4(aPos, 0.0, 1.0); }\n";
@@ -2,6 +2,7 @@ package com.gtnewhorizons.angelica.glsm;

 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Test;
 import org.lwjgl.LWJGLException;
 import org.lwjgl.opengl.ContextAttribs;
@@ -16,6 +17,7 @@ import org.lwjgl.opengl.SharedDrawable;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assumptions.assumeTrue;

+@Tag(GLTestTags.SHARED)
 class SharedDrawableVaoTest {

    private static final String VERT_330 = "#version 330 core\nvoid main() { gl_Position = vec4(0.0); }\n";
@@ -1,7 +1,6 @@
 package com.gtnewhorizons.angelica.glsm;

 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL13;
 import org.lwjgl.opengl.GL20;
@@ -10,7 +9,7 @@ import java.nio.FloatBuffer;

 import static org.junit.jupiter.api.Assertions.assertEquals;

-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class VertexAttribDefaultBridgeTest {

    private static final int COLOR_ATTRIB = 1;        // VertexFormatElement.Usage.COLOR
@@ -1,11 +1,10 @@
 package com.gtnewhorizons.angelica.glsm.ffp;

-import com.gtnewhorizons.angelica.glsm.GLSMExtension;
+import com.gtnewhorizons.angelica.glsm.GLCompatTest;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.states.TexEnvState;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
@@ -17,13 +16,16 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.stream.Stream;

-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.api.Assertions.fail;

 /**
 * Tests for FFP TexEnv COMBINE / multi-unit features:
 * TexEnvState tracking, FragmentKey packing, FragmentShaderGenerator COMBINE codegen, and glMultiTexCoord routing.
 */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class FFPCombineShaderTest {

    private final List<Integer> shadersToDelete = new ArrayList<>();
@@ -1,10 +1,9 @@
 package com.gtnewhorizons.angelica.glsm.ffp;

-import com.gtnewhorizons.angelica.glsm.GLSMCoreExtension;
+import com.gtnewhorizons.angelica.glsm.GLCoreTest;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL13;

@@ -14,7 +13,7 @@ import java.util.List;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertTrue;

-@ExtendWith(GLSMCoreExtension.class)
+@GLCoreTest
 class FFPUnboundTextureUnitTest {

    private final List<Integer> texturesToDelete = new ArrayList<>();
@@ -1,16 +1,15 @@
 package com.gtnewhorizons.angelica.glsm.ffp;

-import com.gtnewhorizons.angelica.glsm.GLSMCoreExtension;
+import com.gtnewhorizons.angelica.glsm.GLCoreTest;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL20;

 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;

-@ExtendWith(GLSMCoreExtension.class)
+@GLCoreTest
 class ProgramUniformTrackingTest {

    private static Program buildProgram(boolean hasColor) {
@@ -0,0 +1,189 @@
+package com.gtnewhorizons.angelica.glsm.ffp;
+
+import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
+import it.unimi.dsi.fastutil.ints.IntArrayList;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import java.util.Random;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class VAOManagerEboIndexTest {
+
+    private static final int DEFAULT_VAO = 0;
+    private static final int NO_VAO = -1;
+
+    private final Int2IntOpenHashMap expectedEbo = new Int2IntOpenHashMap();
+    private int currentVao;
+
+    @BeforeEach
+    void reset() {
+        drainManagerState();
+        expectedEbo.clear();
+        VAOManager.init(DEFAULT_VAO);
+        expectedEbo.put(DEFAULT_VAO, 0);
+        currentVao = DEFAULT_VAO;
+    }
+
+    @AfterEach
+    void drain() {
+        drainManagerState();
+    }
+
+    private static void drainManagerState() {
+        for (int vao : VAOManager.vaoMap.keySet().toIntArray()) {
+            VAOManager.onDeleteVertexArray(vao);
+        }
+        VAOManager.boundEBO = 0;
+        assertEquals(0, VAOManager.eboOwners.size(), "draining every VAO left entries in the index");
+    }
+
+    private void bindVao(int vao) {
+        if (currentVao != NO_VAO) expectedEbo.put(currentVao, VAOManager.boundEBO);
+        VAOManager.onBindVertexArrayPre(vao);
+        expectedEbo.putIfAbsent(vao, 0);
+        currentVao = vao;
+    }
+
+    private void bindEbo(int ebo) {
+        VAOManager.onBindEBO(ebo);
+    }
+
+    private int countOwners(int buffer) {
+        int owners = 0;
+        for (int vao : expectedEbo.keySet().toIntArray()) {
+            if (expectedEbo.get(vao) == buffer) owners++;
+        }
+        return owners;
+    }
+
+    private void deleteBuffer(int buffer) {
+        VAOManager.onDeleteBuffer(buffer);
+        for (int vao : expectedEbo.keySet().toIntArray()) {
+            if (expectedEbo.get(vao) == buffer) expectedEbo.put(vao, 0);
+        }
+    }
+
+    private void deleteVao(int vao) {
+        VAOManager.onDeleteVertexArray(vao);
+        expectedEbo.remove(vao);
+        if (vao == currentVao) currentVao = NO_VAO;
+    }
+
+    private void assertExpectedEbos(int op) {
+        for (var entry : VAOManager.vaoMap.int2ObjectEntrySet()) {
+            final int vao = entry.getIntKey();
+            if (vao == currentVao) continue;
+            assertEquals(expectedEbo.get(vao), entry.getValue().ebo, () -> "op " + op + ": vao " + vao + " ebo mismatch");
+        }
+    }
+
+    @Test
+    void everyVaoKeepsItsExpectedEboUnderRandomOps() {
+        final Random random = new Random(0xC0FFEE);
+        final IntArrayList liveVaos = new IntArrayList();
+        final IntArrayList liveBuffers = new IntArrayList();
+        int nextVao = 1;
+        int nextBuffer = 1;
+        int sharedEboDeletes = 0;
+
+        for (int op = 0; op < 200_000; op++) {
+            switch (random.nextInt(5)) {
+                case 0 -> {
+                    final int vao = nextVao++;
+                    liveVaos.add(vao);
+                    bindVao(vao);
+                }
+                case 1 -> {
+                    if (liveVaos.isEmpty()) break;
+                    bindVao(liveVaos.getInt(random.nextInt(liveVaos.size())));
+                }
+                case 2 -> {
+                    if (currentVao == NO_VAO) break;
+                    final int buffer = (random.nextBoolean() && nextBuffer > 8) ? 1 + random.nextInt(nextBuffer - 1) : nextBuffer++;
+                    liveBuffers.add(buffer);
+                    bindEbo(buffer);
+                }
+                case 3 -> {
+                    if (liveBuffers.isEmpty()) break;
+                    final int buffer = liveBuffers.removeInt(random.nextInt(liveBuffers.size()));
+                    if (countOwners(buffer) > 1) sharedEboDeletes++;
+                    deleteBuffer(buffer);
+                }
+                case 4 -> {
+                    if (liveVaos.isEmpty()) break;
+                    final int vao = liveVaos.removeInt(random.nextInt(liveVaos.size()));
+                    final boolean wasBound = vao == currentVao;
+                    deleteVao(vao);
+                    if (wasBound) bindVao(DEFAULT_VAO);
+                }
+            }
+            assertExpectedEbos(op);
+        }
+        assertTrue(sharedEboDeletes > 20, "op stream never freed a multi-owner EBO (hits: " + sharedEboDeletes + ")");
+    }
+
+    @Test
+    void sharedEboClearsEveryOwner() {
+        final int ebo = 77;
+        bindVao(1);
+        bindEbo(ebo);
+        bindVao(2);
+        bindEbo(ebo);
+        bindVao(3);
+        bindEbo(ebo);
+        bindVao(DEFAULT_VAO);
+
+        deleteBuffer(ebo);
+
+        assertEquals(0, VAOManager.vaoMap.get(1).ebo, "vao 1 kept a freed shared EBO");
+        assertEquals(0, VAOManager.vaoMap.get(2).ebo, "vao 2 kept a freed shared EBO");
+        assertEquals(0, VAOManager.vaoMap.get(3).ebo, "vao 3 kept a freed shared EBO");
+        assertFalse(VAOManager.eboOwners.containsKey(ebo), "index kept owners for a freed EBO");
+    }
+
+    @Test
+    void sharedEboEntryDropsOnlyAfterItsLastOwnerGoes() {
+        final int ebo = 88;
+        bindVao(1);
+        bindEbo(ebo);
+        bindVao(2);
+        bindEbo(ebo);
+        bindVao(DEFAULT_VAO);
+
+        deleteVao(1);
+        assertTrue(VAOManager.eboOwners.containsKey(ebo), "index dropped a still-live owner");
+        deleteVao(2);
+        assertFalse(VAOManager.eboOwners.containsKey(ebo), "index kept an entry after its last owner went away");
+    }
+
+    @Test
+    void deletingTheBoundVaoDoesNotOrphanAnIndexEntry() {
+        final int ebo = 99;
+        bindVao(1);
+        bindEbo(ebo);
+
+        deleteVao(1);
+        bindVao(DEFAULT_VAO);
+
+        assertFalse(VAOManager.eboOwners.containsKey(ebo), "deleting the bound VAO left an unreachable owner in the index");
+        assertEquals(0, VAOManager.eboOwners.size(), "index leaked an entry for a deleted VAO");
+    }
+
+    @Test
+    void indexEmptiesOutWhenEverythingIsDeleted() {
+        for (int vao = 1; vao <= 64; vao++) {
+            bindVao(vao);
+            bindEbo(1000 + vao);
+        }
+        bindVao(DEFAULT_VAO);
+        for (int vao = 1; vao <= 64; vao++) {
+            deleteVao(vao);
+        }
+        assertEquals(0, VAOManager.eboOwners.size(), "index leaked entries after every VAO was deleted");
+    }
+}
@@ -2,26 +2,24 @@ package com.gtnewhorizons.angelica.glsm.recording;

 import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
 import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
-import com.gtnewhorizons.angelica.glsm.GLSMExtension;
 import com.gtnewhorizons.angelica.glsm.DisplayListManager;
+import com.gtnewhorizons.angelica.glsm.GLCompatTest;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import it.unimi.dsi.fastutil.ints.Int2IntMap;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL11;

-import it.unimi.dsi.fastutil.ints.Int2IntMap;
-
-import java.nio.ByteBuffer;
-import java.util.Arrays;
-import java.util.List;
-
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;

 /**
 * Unit tests for display list recording data structures.
 */
-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class RecordingDataStructuresTest {

    private int testList = -1;
@@ -2,13 +2,12 @@ package com.gtnewhorizons.angelica.glsm.recording.support;

 import com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities;
 import com.gtnewhorizons.angelica.glsm.DisplayListManager;
-import com.gtnewhorizons.angelica.glsm.GLSMExtension;
+import com.gtnewhorizons.angelica.glsm.GLCompatTest;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.recording.CompiledDisplayList;
 import com.gtnewhorizons.angelica.glsm.recording.commands.BatchedIndexedDrawCmd;
 import com.gtnewhorizons.angelica.glsm.recording.commands.IndexedDrawBatch;
 import org.junit.jupiter.api.AfterEach;
-import org.junit.jupiter.api.extension.ExtendWith;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL15;
 import org.lwjgl.opengl.GL30;
@@ -20,7 +19,7 @@ import java.util.List;

 import static org.junit.jupiter.api.Assertions.assertNotNull;

-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 public abstract class DisplayListTestFixture {

    public static final float[] DEFAULT_QUAD_POSITIONS = {0f, 0f, 1f, 0f, 1f, 1f, 0f, 1f};
@@ -1,13 +1,12 @@
 package com.gtnewhorizons.angelica.glsm.streaming;

-import com.gtnewhorizons.angelica.glsm.GLSMExtension;
+import com.gtnewhorizons.angelica.glsm.GLCompatTest;
 import com.gtnewhorizons.angelica.glsm.RenderSystem;
+import com.gtnewhorizons.angelica.glsm.streaming.StreamingUploader.UploadStrategy;
 import org.junit.jupiter.api.Assumptions;
-import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.EnumSource;
-import com.gtnewhorizons.angelica.glsm.streaming.StreamingUploader.UploadStrategy;
-import org.junit.jupiter.api.Test;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL15;

@@ -15,9 +14,10 @@ import java.nio.ByteBuffer;

 import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAlloc;
 import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree;
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;

-@ExtendWith(GLSMExtension.class)
+@GLCompatTest
 class StreamingBufferTest {

    @ParameterizedTest
@@ -9,11 +9,13 @@ import org.lwjgl.opengl.GL13;
 import java.nio.ByteBuffer;
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
+import java.util.HashSet;
 import java.util.Set;
 import java.util.stream.IntStream;

 import static org.junit.jupiter.api.Assertions.assertAll;
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertNotEquals;

 public class GLSMUtil {
@@ -39,7 +41,10 @@ public class GLSMUtil {
        GL11.GL_MAP2_VERTEX_3, GL11.GL_MAP2_VERTEX_4
    };

-    private static final Set<Integer> FFP_ONLY_CAPS = Set.of(
+    private static final Set<Integer> FFP_ONLY_CAPS = ffpOnlyCaps();
+
+    private static Set<Integer> ffpOnlyCaps() {
+        final Set<Integer> caps = new HashSet<>(Set.of(
        // Enable/disable caps (BooleanState ffpStateOnly=true)
        GL11.GL_FOG, GL11.GL_ALPHA_TEST, GL11.GL_LIGHTING,
        GL12.GL_RESCALE_NORMAL, GL11.GL_NORMALIZE, GL11.GL_COLOR_MATERIAL,
@@ -68,8 +73,15 @@ public class GLSMUtil {
        // Fog params
        GL11.GL_FOG_COLOR, GL11.GL_FOG_DENSITY,
        GL11.GL_FOG_START, GL11.GL_FOG_END,
-        GL11.GL_FOG_MODE, GL11.GL_FOG_INDEX
-    );
+        GL11.GL_FOG_MODE, GL11.GL_FOG_INDEX,
+        // Also removed from core profile
+        GL11.GL_POINT_SMOOTH, GL11.GL_POLYGON_STIPPLE,
+        GL11.GL_INDEX_LOGIC_OP, GL11.GL_AUTO_NORMAL));
+
+        for (int cap : MAP1_STATES) caps.add(cap);
+        for (int cap : MAP2_STATES) caps.add(cap);
+        return caps;
+    }

    private static boolean isFFPOnly(int glCap) {
        return FFP_ONLY_CAPS.contains(glCap);
@@ -81,7 +93,10 @@ public class GLSMUtil {

    public static void verifyIsEnabled(int glCap, boolean expected, String message) {
        if (isFFPOnly(glCap)) {
-            assertEquals(expected, GLStateManager.glIsEnabled(glCap), message + " - GLSM State Mismatch");
+            assertAll(message,
+                () -> assertFalse(GL11.glIsEnabled(glCap), "GL State Mismatch - cache-only cap reached the driver"),
+                () -> assertEquals(expected, GLStateManager.glIsEnabled(glCap), "GLSM State Mismatch")
+            );
        } else {
            assertAll(message,
                () -> assertEquals(expected, GL11.glIsEnabled(glCap), "GL State Mismatch"),
@@ -96,7 +111,10 @@ public class GLSMUtil {

    public static void verifyState(int glCap, boolean expected, String message) {
        if (isFFPOnly(glCap)) {
-            assertEquals(expected, GLStateManager.glGetBoolean(glCap), message + " - GLSM State Mismatch");
+            assertAll(message,
+                () -> assertFalse(GL11.glGetBoolean(glCap), "GL State Mismatch - cache-only cap reached the driver"),
+                () -> assertEquals(expected, GLStateManager.glGetBoolean(glCap), "GLSM State Mismatch")
+            );
        } else {
            assertAll(message,
                () -> assertEquals(expected, GL11.glGetBoolean(glCap), "GL State Mismatch"),
@@ -61,7 +61,7 @@ dependencies {
    api(project(":glsm"))

    compileOnly("com.github.GTNewHorizons:lwjgl3ify:3.0.15:dev") { isTransitive = false }
-    compileOnly("org.embeddedt.celeritas:celeritas-common:2.5.3-GTNH") { isTransitive = false }
+    compileOnly("org.embeddedt.celeritas:celeritas-common:2.5.8-GTNH") { isTransitive = false }

    val osName = System.getProperty("os.name").lowercase()
    val osArch = System.getProperty("os.arch").lowercase()
@@ -659,6 +659,11 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
        GL11C.glGetTexImage(target, level, format, type, pixels);
    }

+    @Override
+    public void getTexImage(int target, int level, int format, int type, long pixelBufferOffset) {
+        GL11C.glGetTexImage(target, level, format, type, pixelBufferOffset);
+    }
+
    @Override
    public int getFramebufferAttachmentParameteri(int target, int attachment, int pname) {
        return GL30C.glGetFramebufferAttachmentParameteri(target, attachment, pname);
@@ -1096,6 +1101,11 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
        return GL30C.glMapBufferRange(target, offset, length, access);
    }

+    @Override
+    public void flushMappedBufferRange(int target, long offset, long length) {
+        GL30C.glFlushMappedBufferRange(target, offset, length);
+    }
+
    @Override
    public int genVertexArrays() {
        return GL30C.glGenVertexArrays();
@@ -1281,6 +1291,11 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
        return GL45C.glCreateBuffers();
    }

+    @Override
+    public void namedBufferData(int buffer, long size, int usage) {
+        GL45C.glNamedBufferData(buffer, size, usage);
+    }
+
    @Override
    public void namedBufferData(int buffer, ByteBuffer data, int usage) {
        GL45C.glNamedBufferData(buffer, data, usage);
@@ -0,0 +1,9 @@
+package com.gtnewhorizons.angelica.api;
+
+public interface ExtCeleritasRenderBlocks {
+
+    boolean angelica$shouldApplyCeleritasAO();
+
+    void angelica$setApplyingCeleritasAO(boolean val);
+
+}
@@ -327,6 +327,15 @@ public class BatchingFontRenderer {
    private int fontAAStrengthLast = -1;

    private void flushBatch() {
+        final boolean locked = GLStateManager.acquireDrawLock();
+        try {
+            flushBatchInner();
+        } finally {
+            if (locked) GLStateManager.releaseDrawLock();
+        }
+    }
+
+    private void flushBatchInner() {
        if (vertexDataPos == 0) {
            clearBatch();
            return;
@@ -2,17 +2,25 @@ package com.gtnewhorizons.angelica.client.font;

 import com.gtnewhorizons.angelica.config.FontConfig;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.resources.IReloadableResourceManager;
+import net.minecraft.client.resources.IResourceManager;
+import net.minecraft.client.resources.IResourceManagerReloadListener;
 import net.minecraft.util.ResourceLocation;

 import java.io.IOException;
 import java.io.InputStream;

-public final class FontProviderUnicode implements FontProvider {
+public final class FontProviderUnicode implements FontProvider, IResourceManagerReloadListener {

    private FontProviderUnicode() {
+        onResourceManagerReload(Minecraft.getMinecraft().getResourceManager());
+        ((IReloadableResourceManager) Minecraft.getMinecraft().getResourceManager()).registerReloadListener(this);
+    }
+
+    @Override
+    public void onResourceManagerReload(IResourceManager resourceManager) {
        try {
-            InputStream inputstream = Minecraft.getMinecraft().getResourceManager()
-                .getResource(new ResourceLocation("font/glyph_sizes.bin")).getInputStream();
+            InputStream inputstream = resourceManager.getResource(new ResourceLocation("font/glyph_sizes.bin")).getInputStream();
            //noinspection ResultOfMethodCallIgnored
            inputstream.read(this.glyphWidth);
        }
@@ -11,9 +11,13 @@ import net.minecraft.client.resources.DefaultResourcePack;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;

+import cpw.mods.fml.common.Loader;
+
 import java.awt.Font;
+import java.awt.FontFormatException;
 import java.awt.GraphicsEnvironment;
 import java.io.File;
+import java.io.IOException;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -27,13 +31,13 @@ public class FontStrategist {
    public static final Logger LOGGER = LogManager.getLogger("Angelica");

    static {
+        HashMap<String, Font> fontSet = new HashMap<>();
+
        if (GraphicsEnvironment.isHeadless()) {
-            LOGGER.warn("GraphicsEnvironment.isHeadless() returned true! Custom fonts will be unavailable. This is likely a MacOS issue.");
-            availableFonts = new Font[0];
+            LOGGER.warn("GraphicsEnvironment.isHeadless() returned true! Only bundled fonts will be available. This is likely a MacOS issue.");
        } else {
            // get available fonts without duplicates (250 copies of dialog.plain need not apply)
            Font[] availableFontsDirty = GraphicsEnvironment.getLocalGraphicsEnvironment().getAllFonts();
-            HashMap<String, Font> fontSet = new HashMap<>();
            HashMultiset<String> duplicates = HashMultiset.create(); // for debugging

            for (Font font : availableFontsDirty) {
@@ -57,11 +61,14 @@ public class FontStrategist {
                sb.append(". Some fonts may be missing from the font selection menu.");
                LOGGER.warn(sb.toString());
            }
-            availableFonts = fontSet.values().stream().sorted(Comparator.comparing(Font::getFontName)).toArray(Font[]::new);

-            LOGGER.info("Got {} fonts from GraphicsEnvironment ({} after deduplication)", availableFontsDirty.length, availableFonts.length);
+            LOGGER.info("Got {} fonts from GraphicsEnvironment ({} after deduplication)", availableFontsDirty.length, fontSet.size());
        }

+        loadBundledFonts(fontSet);
+
+        availableFonts = fontSet.values().stream().sorted(Comparator.comparing(Font::getFontName)).toArray(Font[]::new);
+
        // create and add the resource pack that provides fonts
        HashMap<String, File> packMap = new HashMap<>();
        for (int i = 0; i < FontProviderCustom.ATLAS_COUNT; i++) {
@@ -74,6 +81,44 @@ public class FontStrategist {
        defaultResourcePacks.add(fontResourcePack);
    }

+    // Load .ttf/.otf shipped with the pack so customFontName* can point at a font that isn't installed
+    // on the system. fontfiles/ is SmoothFont's folder, kept so packs built for it work unchanged.
+    private static void loadBundledFonts(HashMap<String, Font> fontSet) {
+        File configDir = Loader.instance().getConfigDir();
+        if (configDir == null) {
+            LOGGER.warn("Loader.instance().getConfigDir() returned null. Bundled fonts will not be loaded.");
+            return;
+        }
+        File parent = configDir.getParentFile();
+        File[] fontDirs = { new File(parent, "fontfiles"), new File(configDir, "angelica/fonts") };
+        GraphicsEnvironment ge = GraphicsEnvironment.isHeadless() ? null : GraphicsEnvironment.getLocalGraphicsEnvironment();
+        int loaded = 0;
+        for (File dir : fontDirs) {
+            File[] files = dir.listFiles((d, name) -> name.toLowerCase().endsWith(".ttf") || name.toLowerCase().endsWith(".otf"));
+            if (files == null) continue;
+            for (File file : files) {
+                try {
+                    Font font = Font.createFont(Font.TRUETYPE_FONT, file);
+                    String name = font.getFontName();
+                    if (fontSet.containsKey(name)) {
+                        String deduped = name;
+                        int n = 1;
+                        while (fontSet.containsKey(deduped)) deduped = name + "_" + n++;
+                        LOGGER.warn("Font name {} (from {}) is already registered; registering this one as {}", name, file.getName(), deduped);
+                        name = deduped;
+                    }
+                    if (ge != null) ge.registerFont(font);
+                    fontSet.put(name, font);
+                    loaded++;
+                    LOGGER.info("Loaded font {} from {}/{}", name, dir.getName(), file.getName());
+                } catch (FontFormatException | IOException e) {
+                    LOGGER.error("Couldn't load font {}", file.getPath(), e);
+                }
+            }
+        }
+        if (loaded > 0) LOGGER.info("Loaded {} bundled font(s) from the pack", loaded);
+    }
+
    /**
     Lets you get a FontProvider per char while respecting font priority and fallbacks, the unicode flag, whether
     SGA is on, if we're in a splash screen, if a font can even display a character in the first place, etc.
@@ -1,13 +1,14 @@
 package com.gtnewhorizons.angelica.compat;

+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import com.falsepattern.endlessids.config.GeneralConfig;
 import com.gtnewhorizons.angelica.compat.backhand.BackhandReflectionCompat;
 import com.gtnewhorizons.angelica.helpers.LoadControllerHelper;
+import com.gtnewhorizons.angelica.rendering.celeritas.CubeStatusEvents;
 import cpw.mods.fml.common.Loader;
 import cpw.mods.fml.common.versioning.DefaultArtifactVersion;
 import mods.battlegear2.Battlegear;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;

 public class ModStatus {
    public static final Logger LOGGER = LogManager.getLogger("ModCompat");
@@ -29,6 +30,7 @@ public class ModStatus {
    public static boolean isBaublesLoaded;
    public static boolean isCosmeticArmorReworkedLoaded;
    public static boolean isFluidLoggedLoaded;
+    public static boolean isCubicChunksLoaded;
    public static boolean isBOPLoaded;
    public static boolean isEtFuturumLoaded;

@@ -50,6 +52,7 @@ public class ModStatus {
        isBaublesLoaded = Loader.isModLoaded("Baubles");
        isCosmeticArmorReworkedLoaded = Loader.isModLoaded("cosmeticarmorreworked");
        isFluidLoggedLoaded = Loader.isModLoaded("fluidlogged");
+        isCubicChunksLoaded = Loader.isModLoaded("cubicchunks");
        isEtFuturumLoaded = Loader.isModLoaded("etfuturum");

        isHoloInventoryLoaded = Loader.isModLoaded("holoinventory");
@@ -71,6 +74,10 @@ public class ModStatus {
            }
        }

+        if (isCubicChunksLoaded) {
+            CubeStatusEvents.init();
+        }
+
        boolean eidBlockItemExtended = false;
        boolean eidBiomeExtended = false;
        if (isEIDLoaded) {
@@ -0,0 +1,44 @@
+package com.gtnewhorizons.angelica.compat.cubicchunks;
+
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.storage.ExtendedBlockStorage;
+
+import com.cardinalstar.cubicchunks.api.IColumn;
+import com.cardinalstar.cubicchunks.api.ICube;
+import com.cardinalstar.cubicchunks.world.ICubicWorld;
+import com.cardinalstar.cubicchunks.world.cube.Cube;
+import com.cardinalstar.cubicchunks.world.cube.ICubeProviderInternal;
+import com.gtnewhorizons.angelica.compat.mojang.ChunkSectionPos;
+
+public class CubicChunksAPI {
+
+    public static ExtendedBlockStorage getCubeStorage(World world, int x, int y, int z) {
+        Cube cube = ((ICubeProviderInternal) world.getChunkProvider()).getLoadedCube(x, y, z);
+
+        if (cube == null || cube.isEmpty()) return null;
+
+        return cube.getStorage();
+    }
+
+    public static int[] getLoadedCubeLevelsInColumn(World world, int chunkX, int chunkZ) {
+        IColumn column = (IColumn) world.getChunkFromChunkCoords(chunkX, chunkZ);
+
+        return column.getLoadedCubes().stream().mapToInt(ICube::getY).toArray();
+    }
+
+    public static int getMinHeight(World world) {
+        return ((ICubicWorld) world).getMinHeight();
+    }
+
+    public static int getMaxHeight(World world) {
+        return ((ICubicWorld) world).getMaxHeight();
+    }
+
+    public static int getMinSectionY(World world) {
+        return ChunkSectionPos.getSectionCoord(getMinHeight(world));
+    }
+
+    public static int getMaxSectionYExclusive(World world) {
+        return ChunkSectionPos.getSectionCoord(getMaxHeight(world) - 1) + 1;
+    }
+}
@@ -0,0 +1,30 @@
+package com.gtnewhorizons.angelica.compat.etfuturum;
+
+import cpw.mods.fml.common.Loader;
+import ganymedes01.etfuturum.api.client.EndFlashAPI;
+
+/**
+ * Use EFR to power End flash uniforms.
+ */
+public final class EndFlashCompat {
+
+    private static final boolean AVAILABLE = Loader.isModLoaded("etfuturum") && EndFlashCompat.class.getResource("/ganymedes01/etfuturum/api/client/EndFlashAPI.class") != null;
+
+    private EndFlashCompat() {}
+
+    public static boolean isAvailable() {
+        return AVAILABLE;
+    }
+
+    public static float getIntensity(float partialTicks) {
+        return AVAILABLE ? EndFlashAPI.getIntensity(partialTicks) : 0.0F;
+    }
+
+    public static float getXAngle() {
+        return AVAILABLE ? EndFlashAPI.getXAngle() : 0.0F;
+    }
+
+    public static float getYAngle() {
+        return AVAILABLE ? EndFlashAPI.getYAngle() : 0.0F;
+    }
+}
@@ -0,0 +1,22 @@
+package com.gtnewhorizons.angelica.compat.lotr;
+
+import net.minecraft.world.WorldProvider;
+
+public final class LOTRCompat {
+
+    private static final Class<?> LOTR_WORLD_PROVIDER_CLASS;
+
+    static {
+        Class<?> clazz = null;
+        try {
+            clazz = Class.forName("lotr.common.world.LOTRWorldProvider", false, LOTRCompat.class.getClassLoader());
+        } catch (ClassNotFoundException ignored) {}
+        LOTR_WORLD_PROVIDER_CLASS = clazz;
+    }
+
+    private LOTRCompat() {}
+
+    public static boolean isLotrProvider(WorldProvider provider) {
+        return LOTR_WORLD_PROVIDER_CLASS != null && LOTR_WORLD_PROVIDER_CLASS.isInstance(provider);
+    }
+}
@@ -1,8 +1,10 @@
 package com.gtnewhorizons.angelica.compat.mojang;

-import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
 import org.joml.Vector3i;

+import com.gtnewhorizon.gtnhlib.blockpos.BlockPos;
+import com.gtnewhorizon.gtnhlib.util.CoordinatePacker;
+
 // See if we can merge/mixin/extend ChunkPosition maybe?
 public class ChunkSectionPos extends Vector3i {

@@ -25,11 +27,8 @@ public class ChunkSectionPos extends Vector3i {
    }

    public static long asLong(int x, int y, int z) {
-        long l = 0L;
-        l |= ((long)x & 4194303L) << 42;
-        l |= ((long)y & 1048575L) << 0;
-        l |= ((long)z & 4194303L) << 20;
-        return l;
+        // Use CoordinatePacker so that cubic chunks can change the bit packing layout
+        return CoordinatePacker.pack(x, y, z);
    }

    public static int getLocalCoord(int coord) {
@@ -1,5 +1,9 @@
 package com.gtnewhorizons.angelica.compat.mojang;

+import net.minecraft.util.MathHelper;
+
+import com.gtnewhorizons.angelica.compat.ModStatus;
+
 public class CompatMathHelper {
    public static int smallestEncompassingPowerOfTwo(int value) {
        int j = value - 1;
@@ -24,4 +28,13 @@ public class CompatMathHelper {
            return k == 0 ? value : value + divisor - k;
        }
    }
+
+    public static int clampHeight(int y) {
+        if (ModStatus.isCubicChunksLoaded) {
+            // no clamping
+            return y;
+        } else {
+            return MathHelper.clamp_int(y, 0, 255);
+        }
+    }
 }
@@ -83,6 +83,13 @@ public enum Mixins implements IMixins {
            .addClientMixins("angelica.vbo.MixinRenderGlobal")
    ),

+    ANGELICA_VBO_CLOUDS_FAR_PLANE(
+        new MixinBuilder()
+            .setApplyIf(() -> AngelicaConfig.enableVBOClouds && !AngelicaConfig.enableNotFineFeatures)
+            .setPhase(Phase.EARLY)
+            .addClientMixins("notfine.clouds.MixinEntityRenderer")
+    ),
+
    ANGELICA_PANORAMA_BLUR(
        new MixinBuilder("Replace main menu panorama with modern equivalent")
            .setPhase(Phase.EARLY)
@@ -204,6 +211,8 @@ public enum Mixins implements IMixins {
        .addClientMixins(
            "rendering.MixinBlock"
            , "rendering.MixinBlockFluidBase"
+            , "rendering.MixinBlockLiquid"
+            , "rendering.BlockLiquidFlowInvoker"
            , "rendering.AccessorBiomeColorEvent"
            , "rendering.MixinBiomeGenBase"
            , "rendering.MixinChunk"
@@ -231,8 +240,7 @@ public enum Mixins implements IMixins {
        .setPhase(Phase.EARLY)
        .setApplyIf(() -> AngelicaConfig.enableCeleritas)
        .addClientMixins(
-              "celeritas.terrain.ChunkTrackerAccessor"
-            , "celeritas.terrain.MixinChunkProviderClient"
+              "celeritas.terrain.MixinChunkProviderClient"
            , "celeritas.terrain.MixinMinecraft_ChunkUpdates"
            , "celeritas.terrain.MixinRenderGlobal"
            , "celeritas.terrain.MixinRenderSectionManager"
@@ -242,7 +250,8 @@ public enum Mixins implements IMixins {
            , "celeritas.frustum.MixinFrustrum"
            , "celeritas.features.culling.MixinEffectRenderer"
            , "celeritas.features.mipmaps.MixinTextureAtlasSprite"
-            , "celeritas.features.mipmaps.MixinTextureUtil"
+            , "celeritas.features.mipmaps.MixinTextureMetadataSection"
+            , "celeritas.features.mipmaps.MixinTextureMetadataSectionSerializer"
            , "celeritas.features.textures.MixinTextureMap"
            , "celeritas.features.textures.MixinTextureAtlasSprite"
            , "celeritas.biome_blending.MixinBlockGrass"
@@ -299,6 +308,8 @@ public enum Mixins implements IMixins {
            , "shaders.MixinTileEntityRendererDispatcher"
            , "shaders.MixinGlProgram"
            , "shaders.MixinTextureManager_ReloadCount"
+            , "shaders.AccessorModelBox"
+            , "shaders.MixinModelBiped"
        )
    ),

@@ -407,6 +418,12 @@ public enum Mixins implements IMixins {
        .setApplyIf(() -> AngelicaConfig.removeUnicodeEvenScaling)
        .addClientMixins("angelica.bugfixes.MixinScaledResolution_UnicodeFix")),

+    FARSEEK_WORLDSLICE_COMPAT(new MixinBuilder("Let Farseek resolve celeritas' WorldSlice so Streams' water renders properly")
+        .setPhase(Phase.LATE)
+        .addRequiredMod(TargetedMod.FARSEEK)
+        .setApplyIf(() -> AngelicaConfig.enableCeleritas)
+        .addClientMixins("client.farseek.MixinFarseekIBlockAccessValue")),
+
    SECURITYCRAFT_COMPAT(new MixinBuilder("Fix reflection in SecurityCraft for compat with Angelica")
        .setPhase(Phase.LATE)
        .addRequiredMod(TargetedMod.SECURITYCRAFT)
@@ -473,7 +490,7 @@ public enum Mixins implements IMixins {
            "clouds.MixinEntityRenderer",
            "clouds.MixinGameSettings",
            //"clouds.MixinRenderGlobal",
-            "clouds.MixinWorldType",
+            "clouds.MixinWorldProvider",

            "fix.MixinRenderItem",

@@ -17,6 +17,7 @@ public enum TargetedMod implements ITargetMod {
    DRAGON_API("Reika.DragonAPI.Auxiliary.DragonAPIASMHandler", "DragonAPI"),
    ET_FUTURUM_REQUIEM(null, "etfuturum"),
    EXTRAUTILS(null, "ExtraUtilities"),
+    FARSEEK("farseek.core.FarseekCoreMod", "farseek"),
    FALSETWEAKS("com.falsepattern.falsetweaks.asm.CoreLoadingPlugin", "falsetweaks"),
    MINEFACTORY_RELOADED(null, "MineFactoryReloaded"),
    NTM_SPACE("com.hbm.dim.SolarSystem"),
@@ -1,12 +0,0 @@
-package com.gtnewhorizons.angelica.mixins.interfaces;
-
-import it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap;
-import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
-import it.unimi.dsi.fastutil.longs.LongSet;
-
-public interface ChunkTrackerAccessor {
-    Long2IntOpenHashMap angelica$getChunkStatus();
-    LongOpenHashSet angelica$getChunkReady();
-    LongSet angelica$getUnloadQueue();
-    LongSet angelica$getLoadQueue();
-}
@@ -1,8 +1,11 @@
 package com.gtnewhorizons.angelica.mixins.interfaces;

 import org.joml.FrustumIntersection;
+import org.joml.Matrix4fc;

 public interface ClippingHelperExt {
    FrustumIntersection celeritas$getFrustumIntersection();
    void celeritas$updateFrustumIntersection();
+
+    Matrix4fc celeritas$getCombinedMatrix();
 }
@@ -1,6 +1,10 @@
 package com.gtnewhorizons.angelica.mixins.interfaces;

 import com.gtnewhorizons.angelica.utils.ConcurrentTileEntityMap;
+import java.util.Map;
+
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.world.ChunkPosition;

 public interface IChunkTileEntityMapHolder {
    ConcurrentTileEntityMap angelica$getConcurrentTEMap();
@@ -0,0 +1,10 @@
+package com.gtnewhorizons.angelica.mixins.interfaces;
+
+import com.gtnewhorizons.angelica.utils.MipmapStrategy;
+
+public interface TextureMetadataExtension {
+
+    void angelica$setMipmapStrategy(MipmapStrategy strategy);
+
+    MipmapStrategy angelica$getMipmapStrategy();
+}
@@ -1,5 +1,35 @@
 package com.gtnewhorizons.angelica.proxy;

+import static com.gtnewhorizons.angelica.AngelicaMod.MOD_ID;
+
+import java.lang.management.ManagementFactory;
+import java.util.Locale;
+import java.util.concurrent.ConcurrentHashMap;
+
+import net.minecraft.block.Block;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiMainMenu;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.GuiVideoSettings;
+import net.minecraft.client.network.NetHandlerPlayClient;
+import net.minecraft.server.integrated.IntegratedServer;
+import net.minecraft.util.Direction;
+import net.minecraft.util.MathHelper;
+import net.minecraft.util.MovingObjectPosition;
+import net.minecraft.world.EnumSkyBlock;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraftforge.client.ClientCommandHandler;
+import net.minecraftforge.client.event.EntityViewRenderEvent;
+import net.minecraftforge.client.event.FOVUpdateEvent;
+import net.minecraftforge.client.event.GuiOpenEvent;
+import net.minecraftforge.client.event.GuiScreenEvent;
+import net.minecraftforge.client.event.RenderGameOverlayEvent;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.world.WorldEvent;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
 import biomesoplenty.api.content.BOPCBlocks;
 import com.google.common.base.Objects;
 import com.gtnewhorizon.gtnhlib.client.model.loading.ModelRegistry;
@@ -8,6 +38,7 @@ import com.gtnewhorizons.angelica.commands.AngelicaCommand;
 import com.gtnewhorizons.angelica.common.BlockError;
 import com.gtnewhorizons.angelica.compat.ModStatus;
 import com.gtnewhorizons.angelica.compat.bettercrashes.BetterCrashesCompat;
+import com.gtnewhorizons.angelica.compat.mojang.CompatMathHelper;
 import com.gtnewhorizons.angelica.config.AngelicaConfig;
 import com.gtnewhorizons.angelica.rendering.TileEntityRenderBoundsRegistry;
 import com.gtnewhorizons.angelica.config.CompatConfig;
@@ -53,34 +84,6 @@ import me.jellysquid.mods.sodium.client.gui.SodiumGameOptions;
 import me.jellysquid.mods.sodium.client.gui.SodiumOptionsGUI;
 import net.coderbot.iris.Iris;
 import net.coderbot.iris.client.IrisDebugScreenHandler;
-import net.minecraft.block.Block;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiMainMenu;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.gui.GuiVideoSettings;
-import net.minecraft.client.network.NetHandlerPlayClient;
-import net.minecraft.server.integrated.IntegratedServer;
-import net.minecraft.util.Direction;
-import net.minecraft.util.MathHelper;
-import net.minecraft.util.MovingObjectPosition;
-import net.minecraft.world.EnumSkyBlock;
-import net.minecraft.world.chunk.Chunk;
-import net.minecraftforge.client.ClientCommandHandler;
-import net.minecraftforge.client.event.EntityViewRenderEvent;
-import net.minecraftforge.client.event.FOVUpdateEvent;
-import net.minecraftforge.client.event.GuiOpenEvent;
-import net.minecraftforge.client.event.GuiScreenEvent;
-import net.minecraftforge.client.event.RenderGameOverlayEvent;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.event.world.WorldEvent;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import java.lang.management.ManagementFactory;
-import java.util.Locale;
-import java.util.concurrent.ConcurrentHashMap;
-
-import static com.gtnewhorizons.angelica.AngelicaMod.MOD_ID;

 public final class ClientProxy extends CommonProxy {

@@ -293,10 +296,10 @@ public final class ClientProxy extends CommonProxy {
                    event.left.set(i + 4, String.format(
                        "lc: %d b: %s bl: %d sl: %d rl: %d",
                        chunk.getTopFilledSegment() + 15,
-                        chunk.getBiomeGenForWorldCoords(bX & 15, bZ & 15, mc.theWorld.getWorldChunkManager()).biomeName,
-                        chunk.getSavedLightValue(EnumSkyBlock.Block, bX & 15, MathHelper.clamp_int(bY, 0, 255), bZ & 15),
-                        chunk.getSavedLightValue(EnumSkyBlock.Sky, bX & 15, MathHelper.clamp_int(bY, 0, 255), bZ & 15),
-                        chunk.getBlockLightValue(bX & 15, MathHelper.clamp_int(bY, 0, 255), bZ & 15, 0)));
+                        this.mc.theWorld.getBiomeGenForCoords(bX, bZ).biomeName,
+                        chunk.getSavedLightValue(EnumSkyBlock.Block, bX & 15, CompatMathHelper.clampHeight(bY), bZ & 15),
+                        chunk.getSavedLightValue(EnumSkyBlock.Sky, bX & 15, CompatMathHelper.clampHeight(bY), bZ & 15),
+                        chunk.getBlockLightValue(bX & 15, CompatMathHelper.clampHeight(bY), bZ & 15, 0)));
                }
            }
            // Draw a frametime graph
@@ -26,8 +26,12 @@ import com.gtnewhorizon.gtnhlib.client.renderer.vao.IVertexArrayObject;
 import com.gtnewhorizon.gtnhlib.client.renderer.vao.VertexBufferType;
 import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.states.FogState;
 import jss.notfine.core.Settings;
 import jss.notfine.gui.options.named.GraphicsQualityOff;
+import net.coderbot.iris.Iris;
+import net.coderbot.iris.pipeline.WorldRenderingPipeline;
+import net.coderbot.iris.shaderpack.CloudSetting;
 import net.irisshaders.iris.api.v0.IrisApi;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.EntityRenderer;
@@ -45,6 +49,7 @@ import org.embeddedt.embeddium.impl.gl.shader.ShaderType;
 import org.embeddedt.embeddium.impl.render.shader.ShaderLoader;
 import org.joml.Matrix4f;
 import org.joml.Matrix4fStack;
+import org.joml.Vector3d;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;
@@ -76,6 +81,8 @@ public class CloudRenderer implements IResourceManagerReloadListener {

    private static final float SCROLL_SPEED = 1.0f / 256.0f;
    private static final float EDGE_OVERLAP = 0.0001f;
+    private static final float INTERIOR_INSET = EDGE_OVERLAP * 8.0f;
+    private static final float MAX_FAR_PLANE_DISTANCE = 65536.0f;

    private static final boolean BIG_ENDIAN = ByteOrder.nativeOrder() == ByteOrder.BIG_ENDIAN;

@@ -103,11 +110,13 @@ public class CloudRenderer implements IResourceManagerReloadListener {
    private int anchorCellX = Integer.MIN_VALUE, anchorCellZ = Integer.MIN_VALUE;
    private int anchorMarginCells = 0;
    private int cachedEdgesGeneration = Integer.MIN_VALUE;
-    private boolean cachedEmitTopFace, cachedEmitBottomFace, cachedCameraInsideCloud;
+    private boolean cachedEmitTopFace, cachedEmitBottomFace;
    private int cachedRenderRadius = -1;
    private float cachedCloudInteriorHeight = Float.NaN;
+    private boolean geomBuilt;

    private int cloudMode = -1, renderDistance = -1, cloudElevation = -1, scaleMult = -1;
+    private boolean enabled;

    private ByteBuffer emitBuffer;
    private long emitBufferAddr;
@@ -136,6 +145,7 @@ public class CloudRenderer implements IResourceManagerReloadListener {

    private GlProgram<CloudUniforms> program;
    private final Matrix4f mvpScratch = new Matrix4f();
+    private final Matrix4f mvScratch = new Matrix4f();

    public CloudRenderer() {
        ((IReloadableResourceManager) mc.getResourceManager()).registerReloadListener(this);
@@ -160,10 +170,13 @@ public class CloudRenderer implements IResourceManagerReloadListener {
        final GraphicsQualityOff cloudGraphicsQuality = (GraphicsQualityOff) Settings.MODE_CLOUDS.option.getStore();
        final int cloudQualitySetting = cloudGraphicsQuality == GraphicsQualityOff.FANCY
            || cloudGraphicsQuality == GraphicsQualityOff.DEFAULT && mc.gameSettings.fancyGraphics ? 2 : 1;
+        final float dimCloudHeight = mc.theWorld == null ? 128.0f : mc.theWorld.provider.getCloudHeight();
+        final boolean finiteCloudHeight = Float.isFinite(dimCloudHeight);
        final boolean newEnabled = cloudGraphicsQuality != GraphicsQualityOff.OFF
            && mc.gameSettings.shouldRenderClouds()
            && mc.theWorld != null
-            && mc.theWorld.provider.isSurfaceWorld();
+            && mc.theWorld.provider.isSurfaceWorld()
+            && finiteCloudHeight;
        final int targetDistance = Math.max(mc.gameSettings.renderDistanceChunks, (int) Settings.RENDER_DISTANCE_CLOUDS.option.getStore());
        final int cloudScaleMult = (int) Settings.CLOUD_SCALE.option.getStore();

@@ -174,16 +187,32 @@ public class CloudRenderer implements IResourceManagerReloadListener {
            invalidateGeometry();
        }

+        enabled = newEnabled;
        cloudMode = cloudQualitySetting;
        renderDistance = targetDistance;
        scaleMult = cloudScaleMult;

-        cloudElevation = mc.theWorld == null ? 128 : (int) mc.theWorld.provider.getCloudHeight();
-        // Allows the setting to work with RFG and similar without hardcoding.
-        // The minimum height check is so stuff like Aether cloud height doesn't get messed up.
-        if (cloudElevation >= 96) {
-            cloudElevation = (int) Settings.CLOUD_HEIGHT.option.getStore();
+        cloudElevation = finiteCloudHeight ? (int) dimCloudHeight : 128;
+    }
+
+    /**
+     * Far-plane distance needed so none of the cloud geometry gets clipped.
+     */
+    public float getRequiredFarPlaneDistance() {
+        if (!enabled || scaleMult <= 0 || renderDistance <= 0) return 0.0f;
+        if (mc.theWorld == null) return 0.0f;
+        final float cloudInteriorWidth = 12.0f * scaleMult;
+        final int renderRadius = (int) Math.ceil(renderDistance * 64.0f / (CELLS_PER_CHUNK * cloudInteriorWidth));
+        final int marginCells = Math.max(CELLS_PER_CHUNK, renderRadius * CELLS_PER_CHUNK / 4);
+        final int marginChunks = (marginCells + CELLS_PER_CHUNK - 1) / CELLS_PER_CHUNK;
+        float radiusBlocks = (renderRadius + marginChunks) * CELLS_PER_CHUNK * cloudInteriorWidth;
+        if (cloudMode != 2) radiusBlocks *= (float) Math.sqrt(2);
+        float verticalSlack = cloudElevation;
+        final Entity view = mc.renderViewEntity;
+        if (view != null) {
+            verticalSlack = Math.abs(cloudElevation + 0.33f - (float) view.posY) + 4.0f * scaleMult;
        }
+        return Math.min(radiusBlocks + verticalSlack, MAX_FAR_PLANE_DISTANCE);
    }

    private void invalidateGeometry() {
@@ -193,6 +222,7 @@ public class CloudRenderer implements IResourceManagerReloadListener {
        cachedEdgesGeneration = Integer.MIN_VALUE;
        cachedCloudInteriorHeight = Float.NaN;
        cachedVertexCount = 0;
+        geomBuilt = false;
    }

    private void initProgram() {
@@ -215,23 +245,30 @@ public class CloudRenderer implements IResourceManagerReloadListener {
        program.unbind();
    }

-    private void uploadFogUniforms(float partialTicks, int renderRadius, float cloudInteriorWidth) {
+    private void uploadFogUniforms() {
        final CloudUniforms u = program.getInterface();
        final boolean fogEnabled = GLStateManager.getFogMode().isEnabled();
        u.setFogEnabled(fogEnabled);
-        if (fogEnabled) {
-            final float start = renderDistance * 16.0f;
-            final float end = renderRadius * CELLS_PER_CHUNK * cloudInteriorWidth;
-            final float range = end - start;
-            u.setFogParams(range != 0.0f ? -1.0f / range : 0.0f, range != 0.0f ? end / range : 1.0f);
-            final Vec3 sky = mc.theWorld.getSkyColor(mc.renderViewEntity, partialTicks);
-            u.setFogColor((float) sky.xCoord, (float) sky.yCoord, (float) sky.zCoord);
+        if (!fogEnabled) return;
+        final FogState fog = GLStateManager.getFogState();
+        final Vector3d color = fog.getFogColor();
+        u.setFogColor((float) color.x, (float) color.y, (float) color.z);
+        switch (fog.getFogMode()) {
+            case GL11.GL_LINEAR -> {
+                final float range = fog.getEnd() - fog.getStart();
+                u.setFogParams(range != 0.0f ? -1.0f / range : 0.0f, range != 0.0f ? fog.getEnd() / range : 1.0f, 0.0f, 0.0f);
+            }
+            case GL11.GL_EXP -> u.setFogParams(0.0f, 0.0f, fog.getDensity(), 1.0f);
+            default -> u.setFogParams(0.0f, 0.0f, fog.getDensity(), 2.0f);
        }
    }

    public boolean render(int cloudTicks, float partialTicks) {
        if (mc.theWorld == null || mc.renderViewEntity == null) return false;
-        if (cloudMode != 2 || scaleMult <= 0) return false;
+        if (!enabled || scaleMult <= 0) return false;
+
+        final WorldRenderingPipeline pipeline = Iris.getPipelineManager().getPipelineNullable();
+        if (pipeline != null && pipeline.getCloudSetting() == CloudSetting.OFF) return false;

        boolean textureSetupDone = false;
        if (edges == null) {
@@ -266,41 +303,45 @@ public class CloudRenderer implements IResourceManagerReloadListener {

        final boolean emitTopFace = cameraRelativeY + cloudInteriorHeight >= 0.0F;
        final boolean emitBottomFace = cameraRelativeY <= 0.0F;
-        final boolean cameraInsideY = cameraRelativeY <= 0.0F && cameraRelativeY + cloudInteriorHeight >= 0.0F;
-        final boolean cameraInsideCloud = cameraInsideY && edges.cellOpaque(anchorX, anchorZ);

        final int renderRadius = (int) Math.ceil(renderDistance * 64.0f / (CELLS_PER_CHUNK * cloudInteriorWidth));

-        final boolean anchorInRange = vao != null
-            && Math.abs(anchorX - anchorCellX) <= anchorMarginCells
-            && Math.abs(anchorZ - anchorCellZ) <= anchorMarginCells;
+        final boolean insideBand = cloudMode == 2 && emitTopFace && emitBottomFace;
+        final boolean anchorInRange = geomBuilt
+            && (insideBand
+                ? anchorX == anchorCellX && anchorZ == anchorCellZ
+                : Math.abs(anchorX - anchorCellX) <= anchorMarginCells
+                    && Math.abs(anchorZ - anchorCellZ) <= anchorMarginCells);
        final boolean geomCacheValid = anchorInRange
            && cachedEdgesGeneration == edgesGeneration
            && cachedEmitTopFace == emitTopFace
            && cachedEmitBottomFace == emitBottomFace
-            && cachedCameraInsideCloud == cameraInsideCloud
            && cachedRenderRadius == renderRadius
            && cachedCloudInteriorHeight == cloudInteriorHeight;

        if (!geomCacheValid) {
-            final int marginCells = cameraInsideCloud ? 0 : Math.max(CELLS_PER_CHUNK, renderRadius * CELLS_PER_CHUNK / 4);
-            rebuildGeometry(anchorX, anchorZ, renderRadius, cloudInteriorHeight, emitTopFace, emitBottomFace, cameraInsideCloud, marginCells);
+            final int marginCells = Math.max(CELLS_PER_CHUNK, renderRadius * CELLS_PER_CHUNK / 4);
+            rebuildGeometry(anchorX, anchorZ, renderRadius, cloudInteriorHeight, emitTopFace, emitBottomFace, marginCells);
            anchorCellX = anchorX;
            anchorCellZ = anchorZ;
            anchorMarginCells = marginCells;
            cachedEdgesGeneration = edgesGeneration;
            cachedEmitTopFace = emitTopFace;
            cachedEmitBottomFace = emitBottomFace;
-            cachedCameraInsideCloud = cameraInsideCloud;
            cachedRenderRadius = renderRadius;
            cachedCloudInteriorHeight = cloudInteriorHeight;
+            geomBuilt = true;
        }

        if (vao == null || cachedVertexCount == 0) return true;

        GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
-        mc.renderEngine.bindTexture(texture);
-        if (!textureSetupDone) setupCloudTexture();
+        if (cloudTexId != -1 && !textureSetupDone) {
+            GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, cloudTexId);
+        } else {
+            mc.renderEngine.bindTexture(texture);
+            if (!textureSetupDone) setupCloudTexture();
+        }

        final Vec3 color = mc.theWorld.getCloudColour(partialTicks);
        float r = (float) color.xCoord;
@@ -337,10 +378,12 @@ public class CloudRenderer implements IResourceManagerReloadListener {
            mv.pushMatrix();
            mv.scale(cloudInteriorWidth, 1.0f, cloudInteriorWidth);
            mv.translate(-(cameraRelativeX + anchorDriftX), cameraRelativeY, -(cameraRelativeZ + anchorDriftZ));
+            mvScratch.set(mv);
            GLStateManager.getProjectionMatrix().mul(mv, mvpScratch);
            mv.popMatrix();
            u.mvp.set(mvpScratch);
-            uploadFogUniforms(partialTicks, renderRadius, cloudInteriorWidth);
+            u.mv.set(mvScratch);
+            uploadFogUniforms();

            drawAllFactors(r, g, b, false);
            program.unbind();
@@ -362,15 +405,13 @@ public class CloudRenderer implements IResourceManagerReloadListener {
    private void drawAllFactors(float r, float g, float b, boolean shadersActive) {
        vao.bind();
        GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, eboId);
+        GLStateManager.disableCull();

        GLStateManager.disableBlend();
        GLStateManager.glDepthMask(true);
        GLStateManager.glColorMask(false, false, false, false);
-        // Depth prepass: alpha must match color pass so discard threshold writes same depth coverage.
        if (shadersActive) {
            GLStateManager.glColor4f(1.0f, 1.0f, 1.0f, CloudUniforms.ALPHA);
-        } else {
-            program.getInterface().setColorMult(1.0f, 1.0f, 1.0f);
        }
        final int totalQuads = cachedVertexCount / 4;
        GLStateManager.glDrawElements(GL11.GL_TRIANGLES, totalQuads * 6, GL11.GL_UNSIGNED_INT, 0L);
@@ -403,25 +444,32 @@ public class CloudRenderer implements IResourceManagerReloadListener {
        }

        vao.unbind();
+        GLStateManager.enableCull();
        GLStateManager.glDepthMask(true);
        GLStateManager.glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
        GLStateManager.disableBlend();
    }

-    private void rebuildGeometry(int anchorX, int anchorZ, int renderRadius, float cloudInteriorHeight, boolean emitTopFace, boolean emitBottomFace, boolean cameraInsideCloud, int marginCells) {
+    private void rebuildGeometry(int anchorX, int anchorZ, int renderRadius, float cloudInteriorHeight, boolean emitTopFace, boolean emitBottomFace, int marginCells) {
        prepareEmitBuffer();

        final int marginChunks = (marginCells + CELLS_PER_CHUNK - 1) / CELLS_PER_CHUNK;
-        final int chunkRange = cameraInsideCloud ? 0 : (renderRadius + marginChunks);
-        final int outerLo = cameraInsideCloud ? -1 : -chunkRange;
-        final int outerHi = cameraInsideCloud ? 0 : chunkRange;
+        final int chunkRange = renderRadius + marginChunks;
+        final int outerLo = -chunkRange;
+        final int outerHi = chunkRange;

-        final int radiusCellsWithMargin = cameraInsideCloud ? CELLS_PER_CHUNK : (chunkRange * CELLS_PER_CHUNK);
+        final int radiusCellsWithMargin = chunkRange * CELLS_PER_CHUNK;
        final int radiusCellsSq = radiusCellsWithMargin * radiusCellsWithMargin;

        final float scrollX = anchorX * SCROLL_SPEED;
        final float scrollZ = anchorZ * SCROLL_SPEED;

+        if (cloudMode != 2) {
+            emitFastLayer(chunkRange * CELLS_PER_CHUNK, scrollX, scrollZ);
+            finishGeometry();
+            return;
+        }
+
        final int rows = (outerHi - outerLo + 1) * CELLS_PER_CHUNK;
        final int lpr = (rows + 63) >>> 6;
        final int minX = outerLo * CELLS_PER_CHUNK;
@@ -446,7 +494,7 @@ public class CloudRenderer implements IResourceManagerReloadListener {

        for (int chunkX = outerLo; chunkX <= outerHi; chunkX++) {
            for (int chunkZ = outerLo; chunkZ <= outerHi; chunkZ++) {
-                emitChunk(chunkX, chunkZ, anchorX, anchorZ, radiusCellsSq, cameraInsideCloud, emitTopFace, emitBottomFace, y1, ye, scrollX, scrollZ);
+                emitChunk(chunkX, chunkZ, anchorX, anchorZ, radiusCellsSq, emitTopFace, emitBottomFace, y1, ye, scrollX, scrollZ);
            }
        }

@@ -454,6 +502,53 @@ public class CloudRenderer implements IResourceManagerReloadListener {
            emitTopBottomGlobalGreedy(emitTopFace, emitBottomFace, ye, scrollX, scrollZ);
        }

+        if (emitTopFace && emitBottomFace) {
+            emitInteriorFaces(anchorX, anchorZ, y1, scrollX, scrollZ);
+        }
+
+        finishGeometry();
+    }
+
+    private void emitInteriorFaces(int anchorX, int anchorZ, double y1, float scrollX, float scrollZ) {
+        for (int dz = -1; dz <= 1; dz++) {
+            for (int dx = -1; dx <= 1; dx++) {
+                if (!edges.cellOpaque(anchorX + dx, anchorZ + dz)) continue;
+                final double x0 = dx + INTERIOR_INSET;
+                final double x1 = dx + 1 - INTERIOR_INSET;
+                final double z0 = dz + INTERIOR_INSET;
+                final double z1 = dz + 1 - INTERIOR_INSET;
+                final double yb = INTERIOR_INSET;
+                final double yt = y1 - INTERIOR_INSET;
+                final float uL = dx * SCROLL_SPEED + scrollX;
+                final float uR = (dx + 1) * SCROLL_SPEED + scrollX;
+                final float uC = (dx + 0.5F) * SCROLL_SPEED + scrollX;
+                final float vN = dz * SCROLL_SPEED + scrollZ;
+                final float vS = (dz + 1) * SCROLL_SPEED + scrollZ;
+                final float vC = (dz + 0.5F) * SCROLL_SPEED + scrollZ;
+
+                ensureEmitCapacity(6 * QUAD_BYTES);
+                emitCloudQuad(x0, yb, z1, uL, vS, x1, yb, z1, uR, vS, x1, yb, z0, uR, vN, x0, yb, z0, uL, vN, F_TOP, N_POS_Y);
+                emitCloudQuad(x0, yt, z0, uL, vN, x1, yt, z0, uR, vN, x1, yt, z1, uR, vS, x0, yt, z1, uL, vS, F_BOTTOM, N_NEG_Y);
+                emitCloudQuad(x0, yb, z0, uC, vN, x0, yt, z0, uC, vN, x0, yt, z1, uC, vS, x0, yb, z1, uC, vS, F_X, N_POS_X);
+                emitCloudQuad(x1, yb, z1, uC, vS, x1, yt, z1, uC, vS, x1, yt, z0, uC, vN, x1, yb, z0, uC, vN, F_X, N_NEG_X);
+                emitCloudQuad(x0, yb, z0, uL, vC, x1, yb, z0, uR, vC, x1, yt, z0, uR, vC, x0, yt, z0, uL, vC, F_Z, N_POS_Z);
+                emitCloudQuad(x0, yt, z1, uL, vC, x1, yt, z1, uR, vC, x1, yb, z1, uR, vC, x0, yb, z1, uL, vC, F_Z, N_NEG_Z);
+            }
+        }
+    }
+
+    private void emitFastLayer(int radiusCells, float scrollX, float scrollZ) {
+        final double r0 = -radiusCells;
+        final double r1 = radiusCells;
+        final float u0 = -radiusCells * SCROLL_SPEED + scrollX;
+        final float u1 = radiusCells * SCROLL_SPEED + scrollX;
+        final float v0 = -radiusCells * SCROLL_SPEED + scrollZ;
+        final float v1 = radiusCells * SCROLL_SPEED + scrollZ;
+        ensureEmitCapacity(QUAD_BYTES);
+        emitCloudQuad(r0, 0.0, r0, u0, v0, r1, 0.0, r0, u1, v0, r1, 0.0, r1, u1, v1, r0, 0.0, r1, u0, v1, F_BOTTOM, N_POS_Y);
+    }
+
+    private void finishGeometry() {
        final int totalBytes = (int) (writeAddr - emitBufferAddr);
        final int vertexCount = totalBytes / VERTEX_STRIDE;
        if (vertexCount == 0) {
@@ -514,7 +609,7 @@ public class CloudRenderer implements IResourceManagerReloadListener {
        }
    }

-    private void emitChunk(int chunkX, int chunkZ, int anchorX, int anchorZ, int radiusCellsSq, boolean cameraInsideCloud, boolean emitTopFace, boolean emitBottomFace, double y1, double ye, float scrollX, float scrollZ) {
+    private void emitChunk(int chunkX, int chunkZ, int anchorX, int anchorZ, int radiusCellsSq, boolean emitTopFace, boolean emitBottomFace, double y1, double ye, float scrollX, float scrollZ) {
        final float chunkOffsetX = chunkX * (float) CELLS_PER_CHUNK;
        final float chunkOffsetZ = chunkZ * (float) CELLS_PER_CHUNK;
        final int baseU = chunkX * CELLS_PER_CHUNK + anchorX;
@@ -534,43 +629,11 @@ public class CloudRenderer implements IResourceManagerReloadListener {
                final int relX = chunkX * CELLS_PER_CHUNK + k;
                final int relZ = chunkZ * CELLS_PER_CHUNK + j;
                if (relX * relX + relZ * relZ > radiusCellsSq) continue;
-                if (cameraInsideCloud && (Math.abs(relX) > 1 || Math.abs(relZ) > 1)) continue;
                emittableBits |= 1L << (j * CELLS_PER_CHUNK + k);
            }
        }
        if (emittableBits == 0L) return;

-        if (cameraInsideCloud) {
-            long bits = emittableBits;
-            while (bits != 0L) {
-                final int bit = Long.numberOfTrailingZeros(bits);
-                bits &= bits - 1;
-                final int k = bit & 7;
-                final int j = bit >>> 3;
-                final double x0 = chunkOffsetX + k;
-                final double x1 = chunkOffsetX + k + 1;
-                final double z0 = chunkOffsetZ + j;
-                final double z1 = chunkOffsetZ + j + 1;
-                final double xe = x1 - EDGE_OVERLAP;
-                final double zs = z1 - EDGE_OVERLAP;
-                final float uC = (chunkOffsetX + k + 0.5F) * SCROLL_SPEED + scrollX;
-                final float vC = (chunkOffsetZ + j + 0.5F) * SCROLL_SPEED + scrollZ;
-                final float uL = (chunkOffsetX + k) * SCROLL_SPEED + scrollX;
-                final float uR = (chunkOffsetX + k + 1) * SCROLL_SPEED + scrollX;
-                final float vN = (chunkOffsetZ + j) * SCROLL_SPEED + scrollZ;
-                final float vS = (chunkOffsetZ + j + 1) * SCROLL_SPEED + scrollZ;
-
-                ensureEmitCapacity(6 * QUAD_BYTES);
-                emitCloudQuad(x0, 0.0, z1, uL, vS, x1, 0.0, z1, uR, vS, x1, 0.0, z0, uR, vN, x0, 0.0, z0, uL, vN, F_TOP, N_POS_Y);
-                emitCloudQuad(x0, ye, z0, uL, vN, x1, ye, z0, uR, vN, x1, ye, z1, uR, vS, x0, ye, z1, uL, vS, F_BOTTOM, N_NEG_Y);
-                emitCloudQuad(x0, 0.0, z0, uC, vN, x0, y1, z0, uC, vN, x0, y1, z1, uC, vS, x0, 0.0, z1, uC, vS, F_X, N_POS_X);
-                emitCloudQuad(xe, 0.0, z1, uC, vS, xe, y1, z1, uC, vS, xe, y1, z0, uC, vN, xe, 0.0, z0, uC, vN, F_X, N_NEG_X);
-                emitCloudQuad(x0, 0.0, z0, uL, vC, x1, 0.0, z0, uR, vC, x1, y1, z0, uR, vC, x0, y1, z0, uL, vC, F_Z, N_POS_Z);
-                emitCloudQuad(x0, y1, zs, uL, vC, x1, y1, zs, uR, vC, x1, 0.0, zs, uR, vC, x0, 0.0, zs, uL, vC, F_Z, N_NEG_Z);
-            }
-            return;
-        }
-
        if (emitTopFace || emitBottomFace) {
            final int globalColStart = chunkX * CELLS_PER_CHUNK - gridMinX;
            final int globalRowStart = chunkZ * CELLS_PER_CHUNK - gridMinZ;
@@ -9,6 +9,7 @@ final class CloudUniforms {
    static final float ALPHA = 0.8f;

    final GlUniformMatrix4f mvp;
+    final GlUniformMatrix4f mv;
    final GlUniformFloat4v colorMult;
    final GlUniformFloat4v fogParams;
    final GlUniformFloat4v fogColor;
@@ -18,11 +19,12 @@ final class CloudUniforms {
    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 float lastFogParamX = Float.NaN, lastFogParamY = Float.NaN, lastFogParamZ = Float.NaN, lastFogParamW = Float.NaN;
    private final float[] uploadBuf = new float[4];

    CloudUniforms(ShaderBindingContext ctx) {
        mvp = ctx.bindUniform("u_MVPMatrix", GlUniformMatrix4f::new);
+        mv = ctx.bindUniform("u_MVMatrix", GlUniformMatrix4f::new);
        colorMult = ctx.bindUniform("u_ColorMult", GlUniformFloat4v::new);
        fogParams = ctx.bindUniform("u_FogParams", GlUniformFloat4v::new);
        fogColor = ctx.bindUniform("u_FogColor", GlUniformFloat4v::new);
@@ -51,14 +53,16 @@ final class CloudUniforms {
        }
    }

-    void setFogParams(float x, float y) {
-        if (x != lastFogParamX || y != lastFogParamY) {
+    void setFogParams(float x, float y, float z, float w) {
+        if (x != lastFogParamX || y != lastFogParamY || z != lastFogParamZ || w != lastFogParamW) {
            lastFogParamX = x;
            lastFogParamY = y;
+            lastFogParamZ = z;
+            lastFogParamW = w;
            uploadBuf[0] = x;
            uploadBuf[1] = y;
-            uploadBuf[2] = 0f;
-            uploadBuf[3] = 0f;
+            uploadBuf[2] = z;
+            uploadBuf[3] = w;
            fogParams.set(uploadBuf);
        }
    }
@@ -7,8 +7,9 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.LockSupport;
 import java.util.function.BooleanSupplier;

+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+
 public class AngelicaRenderQueue {
-    private static final Thread MAIN_THREAD = Thread.currentThread();
    private static final Queue<Runnable> TASKS = new ConcurrentLinkedQueue<>();

    // Metrics
@@ -33,11 +34,11 @@ public class AngelicaRenderQueue {
    }

    private static final Executor EXECUTOR = (runnable) -> {
-        if(Thread.currentThread() == MAIN_THREAD) {
+        if(GLStateManager.isMainThread()) {
            runnable.run();
        } else {
            TASKS.add(runnable);
-            LockSupport.unpark(MAIN_THREAD);
+            LockSupport.unpark(GLStateManager.getMainThread());
        }
    };

@@ -45,6 +46,11 @@ public class AngelicaRenderQueue {
        return EXECUTOR;
    }

+    public static void submit(Runnable runnable) {
+        TASKS.add(runnable);
+        LockSupport.unpark(GLStateManager.getMainThread());
+    }
+
    public static int processTasks(int max) {
        int tasksRun = 0;
        while(tasksRun < max) {
@@ -0,0 +1,229 @@
+package com.gtnewhorizons.angelica.rendering;
+
+import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
+import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags;
+import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.QuadConverter;
+import com.gtnewhorizons.angelica.glsm.states.ColorMask;
+import com.gtnewhorizons.angelica.glsm.texture.TextureInfo;
+import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
+import lombok.Getter;
+import net.coderbot.iris.gl.image.GlImage;
+import net.minecraft.client.model.ModelBiped;
+import net.minecraft.client.renderer.entity.Render;
+import net.minecraft.client.renderer.entity.RenderManager;
+import net.minecraft.client.renderer.entity.RendererLivingEntity;
+import net.minecraft.entity.player.EntityPlayer;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL15;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAddress0;
+import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAlloc;
+import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree;
+
+/**
+ * Skins in 1.7.10 are 64x32 while modern has 64x64 textures. We have to address it here.
+ */
+public final class PlayerReflectionCapture {
+
+    public static final int VERTEX_COUNT = 288;
+    public static final int FLOATS_PER_VERTEX = 5; // x, y, z, u, v
+
+    private static final int RAW_INTS_PER_VERTEX = 8;
+
+    private static final int VERTEX_FLAGS = VertexFlags.convertToFlags(true, false, true, false);
+
+    private static boolean active;
+    private static boolean drawnThisCapture;
+    @Getter
+    private static Object target;
+
+    @Getter
+    private static EntityPlayer targetEntity;
+
+    private static int vbo;
+    private static int vao;
+
+    private static int[] rawData;
+    private static float[] vertexScratch;
+    private static int skin64Tex;
+    private static ByteBuffer skinPixels;
+    private static int lastCapturedSkin;
+    private static int lastUploadedAtlas;
+    private static int skinCopyWidth = 64;
+    private static int skinCopyHeight = 32;
+    private static ByteBuffer repackBuffer;
+    private static long repackAddress;
+    private static int repackCapacity;
+
+    private PlayerReflectionCapture() {}
+
+    public static void begin(EntityPlayer player) {
+        active = false;
+        drawnThisCapture = false;
+        target = null;
+        targetEntity = null;
+        if (player == null) return;
+
+        final Render render = RenderManager.instance.getEntityRenderObject(player);
+        if (render instanceof RendererLivingEntity living && living.mainModel instanceof ModelBiped model) {
+            target = model;
+            targetEntity = player;
+            active = true;
+        }
+    }
+
+    public static void end() {
+        active = false;
+        target = null;
+        targetEntity = null;
+    }
+
+    public static boolean shouldCapture() {
+        return active && !drawnThisCapture;
+    }
+
+    /**
+     * Emit the 288-vertex player batch VBO.
+     */
+    public static void drawPlayerCapture(float[] xyzuv) {
+        if (drawnThisCapture) return;
+        drawnThisCapture = true;
+        if (xyzuv == null || xyzuv.length < VERTEX_COUNT * FLOATS_PER_VERTEX) return;
+
+        // Build the Tessellator layout
+        if (rawData == null) rawData = new int[VERTEX_COUNT * RAW_INTS_PER_VERTEX];
+        final int[] raw = rawData;
+        for (int i = 0; i < VERTEX_COUNT; i++) {
+            final int s = i * FLOATS_PER_VERTEX;
+            final int d = i * RAW_INTS_PER_VERTEX;
+            raw[d]     = Float.floatToRawIntBits(xyzuv[s]);
+            raw[d + 1] = Float.floatToRawIntBits(xyzuv[s + 1]);
+            raw[d + 2] = Float.floatToRawIntBits(xyzuv[s + 2]);
+            raw[d + 3] = Float.floatToRawIntBits(xyzuv[s + 3]);
+            raw[d + 4] = Float.floatToRawIntBits(xyzuv[s + 4]);
+            raw[d + 5] = 0xFFFFFFFF;   // color
+            raw[d + 6] = 0x00008000;   // normal
+            raw[d + 7] = 0x00F000F0;   // light
+        }
+
+        // Pack into our own native buffer using the player model's vertex format
+        final VertexFormat format = DefaultVertexFormat.ALL_FORMATS[VERTEX_FLAGS];
+        ensureRepackCapacity(VERTEX_COUNT * format.getVertexSize());
+
+        final long writePtr = format.writeToBuffer0(repackAddress, raw, VERTEX_COUNT * RAW_INTS_PER_VERTEX);
+        repackBuffer.position(0);
+        repackBuffer.limit((int) (writePtr - repackAddress));
+
+        // Upload to our dedicated VBO at offset 0
+        ensureVAO(format);
+        GLStateManager.glBindVertexArray(vao);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
+        GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, repackBuffer, GL15.GL_STREAM_DRAW);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+
+        // Bind a 64x64 copy of the skin as `tex`
+        final int activeSkin = GLStateManager.getBoundTextureForServerState();
+        final boolean haveSkin = activeSkin != 0 && activeSkin != skin64Tex;
+        if (haveSkin) {
+            ensureSkin64Texture();
+
+            final GlImage atlas = GlImage.BY_NAME.get("playerAtlas_img");
+            final int atlasId = atlas != null ? atlas.getId() : 0;
+            final boolean skinChanged = activeSkin != lastCapturedSkin;
+
+            if (skinChanged) {
+                final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(activeSkin);
+                final int srcW = info.getWidth();
+                final int srcH = info.getHeight();
+                if (srcW > 0 && srcH > 0) {
+                    final int required = srcW * srcH * 4;
+                    if (skinPixels == null || skinPixels.capacity() < required) {
+                        skinPixels = ByteBuffer.allocateDirect(required).order(ByteOrder.nativeOrder());
+                    }
+                    // The 1.7.10 model UVs only address the top 64x32 region.
+                    skinCopyWidth = Math.min(64, srcW);
+                    skinCopyHeight = Math.min(32, srcH);
+
+                    skinPixels.clear();
+                    GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, activeSkin);
+                    GLStateManager.glGetTexImage(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, skinPixels);
+                    lastCapturedSkin = activeSkin;
+                }
+            }
+
+            if (skinPixels != null && (skinChanged || atlasId != lastUploadedAtlas)) {
+                skinPixels.rewind();
+                GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, skin64Tex);
+                GLStateManager.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, skinCopyWidth, skinCopyHeight, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, skinPixels);
+
+                if (atlas != null) {
+                    skinPixels.rewind();
+                    GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, atlasId);
+                    GLStateManager.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, skinCopyWidth, skinCopyHeight, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, skinPixels);
+                }
+                lastUploadedAtlas = atlasId;
+            }
+
+            GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, skin64Tex);
+        }
+
+        final ColorMask prevColor = GLStateManager.getColorMask();
+        final boolean pr = prevColor.red, pg = prevColor.green, pb = prevColor.blue, pa = prevColor.alpha;
+        final boolean prevDepthWrite = GLStateManager.getDepthState().isEnabled();
+
+        GLStateManager.glColorMask(false, false, false, false);
+        GLStateManager.glDepthMask(false);
+        QuadConverter.drawQuadsAsTriangles(0, VERTEX_COUNT);
+        GLStateManager.glDepthMask(prevDepthWrite);
+        GLStateManager.glColorMask(pr, pg, pb, pa);
+
+        if (haveSkin) {
+            GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, activeSkin);
+        }
+
+        GLStateManager.glBindVertexArray(0);
+    }
+
+    public static float[] vertexScratch() {
+        if (vertexScratch == null) vertexScratch = new float[VERTEX_COUNT * FLOATS_PER_VERTEX];
+        return vertexScratch;
+    }
+
+    private static void ensureVAO(VertexFormat format) {
+        if (vao != 0) return;
+        vbo = GLStateManager.glGenBuffers();
+        vao = GLStateManager.glGenVertexArrays();
+        GLStateManager.glBindVertexArray(vao);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
+        format.setupBufferState(0L);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+        GLStateManager.glBindVertexArray(0);
+    }
+
+    private static void ensureSkin64Texture() {
+        if (skin64Tex != 0) return;
+        final int prev = GLStateManager.getBoundTextureForServerState();
+        skin64Tex = GLStateManager.glGenTextures();
+        GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, skin64Tex);
+        final ByteBuffer zero = ByteBuffer.allocateDirect(64 * 64 * 4);
+        GLStateManager.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, 64, 64, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, zero);
+        GLStateManager.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_NEAREST);
+        GLStateManager.glTexParameteri(GL11.GL_TEXTURE_2D, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_NEAREST);
+        GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, prev);
+    }
+
+    private static void ensureRepackCapacity(int requiredBytes) {
+        if (repackBuffer != null && requiredBytes <= repackCapacity) return;
+        int newCapacity = Math.max(0x4000, repackCapacity);
+        while (newCapacity < requiredBytes) newCapacity *= 2;
+        if (repackBuffer != null) memFree(repackBuffer);
+        repackBuffer = memAlloc(newCapacity);
+        repackAddress = memAddress0(repackBuffer);
+        repackCapacity = newCapacity;
+    }
+}
@@ -48,19 +48,18 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
    private final WorldSlice worldSlice;
    @Getter
    private final BlockRenderContext blockRenderContext = new BlockRenderContext();
-
-    private List<IDynamicLightSource> chunkLightSources;
-    private DynamicLights dynamicLightsInstance;
-
    private final LightDataCache lightDataCache = new LightDataCache();
    private final SmoothLightPipeline smoothLightPipeline;
    private final FlatLightPipeline flatLightPipeline;
    private final QuadLightData quadLightData = new QuadLightData();
    private final VertexArrayQuadView quadView;
+    private final boolean hasColoredLight;
+    private final float[] tintResult = new float[3];
+    private List<IDynamicLightSource> chunkLightSources;
+    private DynamicLights dynamicLightsInstance;
    private boolean lightPipelineReady = false;
    private int originX, originY, originZ;
    private float cachedSkylightSubtracted;
-    private final boolean hasColoredLight;

    public AngelicaChunkBuildContext(RenderPassConfiguration<?> renderPassConfiguration, WorldClient world) {
        super(renderPassConfiguration);
@@ -98,19 +97,24 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
        }
    }

-    private Material selectMaterial(Material material, TextureAtlasSprite sprite, boolean isShaderPackOverride) {
+    private Material selectMaterial(Material material, TextureAtlasSprite sprite, boolean isShaderPackOverride,
+                                    boolean useRenderPassOptimization) {
        // Don't apply transparency-based optimization when shader pack explicitly overrides the material
-        if (!ClientProxy.options().performance.useRenderPassOptimization || isShaderPackOverride) {
+        if (isShaderPackOverride) {
            return material;
        }
-        if (sprite != null && sprite.getClass() == TextureAtlasSprite.class && !sprite.hasAnimationMetadata()) {
-            final var transparencyLevel = ((SpriteExtension)sprite).celeritas$getTransparencyLevel();
-            if (transparencyLevel == SpriteTransparencyLevel.OPAQUE && material == AngelicaRenderPassConfiguration.CUTOUT_MIPPED_MATERIAL) {
+
+        if (useRenderPassOptimization
+            && sprite != null && sprite.getClass() == TextureAtlasSprite.class && !sprite.hasAnimationMetadata()) {
+            final var transparencyLevel = ((SpriteExtension) sprite).celeritas$getTransparencyLevel();
+            if (transparencyLevel == SpriteTransparencyLevel.OPAQUE
+                && material == AngelicaRenderPassConfiguration.CUTOUT_MIPPED_MATERIAL) {
                return AngelicaRenderPassConfiguration.SOLID_MATERIAL;
            } else if (material == AngelicaRenderPassConfiguration.TRANSLUCENT_MATERIAL && transparencyLevel != SpriteTransparencyLevel.TRANSLUCENT) {
                return AngelicaRenderPassConfiguration.CUTOUT_MIPPED_MATERIAL;
            }
        }
+
        return material;
    }

@@ -123,7 +127,7 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
            return;
        }

-        final var animatedSprites = ((MinecraftBuiltRenderSectionData<TextureAtlasSprite, TileEntity>)buffers.getSectionContextBundle()).animatedSprites;
+        final var animatedSprites = ((MinecraftBuiltRenderSectionData<TextureAtlasSprite, TileEntity>) buffers.getSectionContextBundle()).animatedSprites;

        if ((vertexCount & 0x3) != 0) {
            throw new IllegalStateException("Only quads are supported, got: " + vertexCount);
@@ -132,6 +136,7 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
        final boolean hasDynamicLights = chunkLightSources != null && !chunkLightSources.isEmpty();
        final boolean separateAo = BlockRenderingSettings.INSTANCE.shouldUseSeparateAo();
        final boolean celeritasSmoothLighting = ClientProxy.options().quality.useCeleritasSmoothLighting;
+        final boolean useRenderPassOptimization = ClientProxy.options().performance.useRenderPassOptimization;
        final boolean shaderActive = IrisApi.getInstance().isShaderPackInUse();
        final boolean useAoCalculation = lightPipelineReady && (separateAo || celeritasSmoothLighting || shaderActive);
        final boolean shouldApplyDiffuse = !BlockRenderingSettings.INSTANCE.shouldDisableDirectionalShading();
@@ -150,7 +155,9 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
        final short originalBlockId = blockRenderContext.blockId;

        int stateIdx = 0;
-        int facesAtBaseMaterial = 0;
+        boolean hasCachedMaterial = false;
+        TextureAtlasSprite lastSprite = null;
+        Material lastMaterial = null;

        for (int quadIdx = 0; quadIdx < numQuads; quadIdx++) {
            float uSum = 0, vSum = 0;
@@ -243,16 +250,14 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
            // Apply RGB block light tint from provider
            applyBlockLightTint(worldX, worldY, worldZ, vertices);

-            final int faceBit = 1 << facing.ordinal();
            final Material correctMaterial;
-            if ((facesAtBaseMaterial & faceBit) != 0) {
-                // Face already has a non-demoted quad, skip selectMaterial entirely
-                correctMaterial = material;
+            if (hasCachedMaterial && sprite == lastSprite) {
+                correctMaterial = lastMaterial;
            } else {
-                correctMaterial = selectMaterial(material, sprite, isShaderPackOverride);
-                if (correctMaterial == material) {
-                    facesAtBaseMaterial |= faceBit;
-                }
+                correctMaterial = selectMaterial(material, sprite, isShaderPackOverride, useRenderPassOptimization);
+                lastSprite = sprite;
+                lastMaterial = correctMaterial;
+                hasCachedMaterial = true;
            }
            final var builder = buffers.get(correctMaterial);

@@ -267,8 +272,6 @@ public class AngelicaChunkBuildContext extends ChunkBuildContext {
        }
    }

-    private final float[] tintResult = new float[3];
-
    private void applyBlockLightTint(int x, int y, int z, ChunkVertexEncoder.Vertex[] vertices) {
        if (!hasColoredLight) return;
        final ExtQuadLightData ext = (ExtQuadLightData) quadLightData;
@@ -2,24 +2,43 @@ package com.gtnewhorizons.angelica.rendering.celeritas;

 import com.gtnewhorizons.angelica.AngelicaMod;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.RenderSystem;
 import com.gtnewhorizons.angelica.proxy.ClientProxy;
 import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider;
 import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder;
 import me.jellysquid.mods.sodium.client.gui.options.named.MultiDrawMode;
+import org.embeddedt.embeddium.impl.gl.device.CommandList;
 import org.embeddedt.embeddium.impl.gl.device.RenderDevice;
 import org.embeddedt.embeddium.impl.gl.shader.GlProgram;
+import org.embeddedt.embeddium.impl.gl.shader.GlShader;
+import org.embeddedt.embeddium.impl.gl.shader.ShaderConstants;
+import org.embeddedt.embeddium.impl.gl.shader.ShaderParser;
+import org.embeddedt.embeddium.impl.gl.shader.ShaderType;
 import org.embeddedt.embeddium.impl.render.chunk.DefaultChunkRenderer;
 import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration;
 import org.embeddedt.embeddium.impl.render.chunk.multidraw.DirectMultiDrawEmitter;
 import org.embeddedt.embeddium.impl.render.chunk.multidraw.IndirectMultiDrawEmitter;
 import org.embeddedt.embeddium.impl.render.chunk.multidraw.MultiDrawEmitter;
+import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderBindingPoints;
 import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderInterface;
+import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderOptions;
 import org.embeddedt.embeddium.impl.render.chunk.shader.ChunkShaderTextureSlot;
+import org.embeddedt.embeddium.impl.render.chunk.shader.DefaultChunkShaderInterface;
 import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass;
+import org.embeddedt.embeddium.impl.render.shader.ShaderLoader;
+import org.lwjgl.opengl.GL11;
+
+import java.util.ArrayList;
+import java.util.List;

 class AngelicaChunkRenderer extends DefaultChunkRenderer {
+    private static final int BLOCK_TEXTURE_UNIT = 0;
+
    private GlProgram<? extends ChunkShaderInterface> irisProgram;
    private boolean usingIrisProgram;
+    private int rgssSampler;
+    private boolean rgssSamplerResolved;
+    private boolean rgssSamplerBound;

    public AngelicaChunkRenderer(RenderDevice device, RenderPassConfiguration<?> renderPassConfiguration) {
        super(device, renderPassConfiguration, createEmitter());
@@ -48,6 +67,11 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
        };
    }

+    private static GlShader loadShader(ShaderType type, String path, ShaderConstants constants) {
+        final String source = ShaderParser.parseShader(ShaderLoader.getShaderSource(path), ShaderLoader::getShaderSource, constants);
+        return new GlShader(type, path, source);
+    }
+
    @Override
    protected void begin(TerrainRenderPass pass) {
        final IrisShaderProvider provider = IrisShaderProviderHolder.getProvider();
@@ -70,10 +94,13 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
        this.usingIrisProgram = false;
        this.irisProgram = null;
        super.begin(pass);
+        bindRgssSampler();
    }

    @Override
    protected void end(TerrainRenderPass pass) {
+        unbindRgssSampler();
+
        if (usingIrisProgram && irisProgram != null) {
            irisProgram.getInterface().restoreState();
            irisProgram.unbind();
@@ -87,6 +114,71 @@ class AngelicaChunkRenderer extends DefaultChunkRenderer {
        super.end(pass);
    }

+    private void bindRgssSampler() {
+        if (!AngelicaRenderPassConfiguration.isRgssEnabled()) {
+            return;
+        }
+
+        if (!rgssSamplerResolved) {
+            rgssSamplerResolved = true;
+            rgssSampler = RenderSystem.genSampler();
+            if (rgssSampler != 0) {
+                RenderSystem.samplerParameteri(rgssSampler, GL11.GL_TEXTURE_MIN_FILTER, GL11.GL_LINEAR_MIPMAP_LINEAR);
+                RenderSystem.samplerParameteri(rgssSampler, GL11.GL_TEXTURE_MAG_FILTER, GL11.GL_LINEAR);
+            } else {
+                AngelicaMod.LOGGER.warn("Sampler objects unavailable; RGSS terrain filtering will fall back to nearest sampling");
+            }
+        }
+
+        if (rgssSampler != 0) {
+            RenderSystem.bindSamplerToUnit(BLOCK_TEXTURE_UNIT, rgssSampler);
+            rgssSamplerBound = true;
+        }
+    }
+
+    private void unbindRgssSampler() {
+        if (rgssSamplerBound) {
+            RenderSystem.bindSamplerToUnit(BLOCK_TEXTURE_UNIT, 0);
+            rgssSamplerBound = false;
+        }
+    }
+
+    @Override
+    public void delete(CommandList commandList) {
+        super.delete(commandList);
+
+        unbindRgssSampler();
+        RenderSystem.destroySampler(rgssSampler);
+        rgssSampler = 0;
+        rgssSamplerResolved = false;
+    }
+
+    @Override
+    protected GlProgram<ChunkShaderInterface> createShader(String path, ChunkShaderOptions options) {
+        if (this.enableLegacyGLPatches) {
+            return super.createShader(path, options);
+        }
+
+        final ShaderConstants constants = options.constants();
+        final List<GlShader> loadedShaders = new ArrayList<>();
+
+        try {
+            loadedShaders.add(loadShader(ShaderType.VERTEX, "sodium:" + path + ".vsh", constants));
+            loadedShaders.add(loadShader(ShaderType.FRAGMENT, "angelica:" + path + ".fsh", constants));
+
+            final var builder = GlProgram.builder("sodium:chunk_shader");
+            loadedShaders.forEach(builder::attachShader);
+            int i = 0;
+            for (var attr : options.pass().vertexType().getVertexFormat().getAttributes()) {
+                builder.bindAttribute(attr.getName(), i++);
+            }
+            builder.bindFragmentData("fragColor", ChunkShaderBindingPoints.FRAG_COLOR);
+            return builder.link((shader) -> new DefaultChunkShaderInterface(shader, options));
+        } finally {
+            loadedShaders.forEach(GlShader::delete);
+        }
+    }
+
    @Override
    protected boolean useBlockFaceCulling() {
        return IrisShaderProviderHolder.shouldUseFaceCulling();
@@ -22,15 +22,14 @@

 package com.gtnewhorizons.angelica.rendering.celeritas;

-import com.gtnewhorizons.angelica.config.AngelicaConfig;
-import com.gtnewhorizons.angelica.mixins.interfaces.ChunkTrackerAccessor;
-import it.unimi.dsi.fastutil.longs.LongCollection;
-import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
-import it.unimi.dsi.fastutil.longs.LongSets;
+import org.embeddedt.embeddium.impl.render.chunk.RenderSectionManager;
 import org.embeddedt.embeddium.impl.render.chunk.map.ChunkStatus;
-import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTracker;
+import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTrackerImpl;
 import org.embeddedt.embeddium.impl.util.PositionUtil;

+import com.gtnewhorizons.angelica.config.AngelicaConfig;
+import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
+
 /**
 * Configurable chunk tracker supporting "fast" and "aggressive" loading modes.
 * Based on Beddium's SafeChunkTracker by Ven and FalsePattern.
@@ -41,109 +40,23 @@ import org.embeddedt.embeddium.impl.util.PositionUtil;
 *
 * Mode can be switched at runtime via options menu - triggers renderer reload.
 */
-public class AngelicaChunkTracker extends ChunkTracker {
-    private final LongOpenHashSet chunkReadyForced = new LongOpenHashSet();
+public class AngelicaChunkTracker extends ChunkTrackerImpl {

-    private ChunkTrackerAccessor self() {
-        return (ChunkTrackerAccessor) this;
+    @Override
+    public void forEachReady(RenderSectionManager sectionManager) {
+        if (this.isFastModeEnabled() != AngelicaConfig.useVanillaChunkTracking) {
+            setFastMode(AngelicaConfig.useVanillaChunkTracking);
+        }
+
+        super.forEachReady(sectionManager);
    }

    @Override
-    public void onChunkStatusAdded(int x, int z, int flags) {
-        final var key = PositionUtil.packChunk(x, z);
-        final var prev = self().angelica$getChunkStatus().get(key);
-        final var cur = prev | flags;
-
-        if (prev == cur) {
-            return;
+    public void forEachEvent(RenderSectionManager sectionManager) {
+        if (this.isFastModeEnabled() != AngelicaConfig.useVanillaChunkTracking) {
+            setFastMode(AngelicaConfig.useVanillaChunkTracking);
        }

-        self().angelica$getChunkStatus().put(key, cur);
-        this.updateNeighbors(x, z);
-    }
-
-    @Override
-    public void onChunkStatusRemoved(int x, int z, int flags) {
-        final var key = PositionUtil.packChunk(x, z);
-        final var prev = self().angelica$getChunkStatus().get(key);
-        final int cur = prev & ~flags;
-
-        if (prev == cur) {
-            return;
-        }
-
-        if (cur == self().angelica$getChunkStatus().defaultReturnValue()) {
-            self().angelica$getChunkStatus().remove(key);
-        } else {
-            self().angelica$getChunkStatus().put(key, cur);
-        }
-
-        this.updateNeighbors(x, z);
-    }
-
-    private void updateNeighbors(int x, int z) {
-        for (int ox = -1; ox <= 1; ox++) {
-            for (int oz = -1; oz <= 1; oz++) {
-                this.updateMerged(ox + x, oz + z);
-            }
-        }
-    }
-
-    private void updateMerged(int x, int z) {
-        final long key = PositionUtil.packChunk(x, z);
-        final int selfFlags = self().angelica$getChunkStatus().get(key);
-
-        // If self doesn't have FLAG_ALL, can't be ready at all
-        if (selfFlags != ChunkStatus.FLAG_ALL) {
-            // Remove from ready if present
-            final boolean wasReady = self().angelica$getChunkReady().remove(key) | this.chunkReadyForced.remove(key);
-            if (wasReady && !self().angelica$getLoadQueue().remove(key)) {
-                self().angelica$getUnloadQueue().add(key);
-            }
-            return;
-        }
-
-        // Check if all neighbors also have FLAG_ALL
-        int mergedFlags = selfFlags;
-        for (int ox = -1; ox <= 1; ox++) {
-            for (int oz = -1; oz <= 1; oz++) {
-                mergedFlags &= self().angelica$getChunkStatus().get(PositionUtil.packChunk(ox + x, oz + z));
-            }
-        }
-
-        if (mergedFlags == ChunkStatus.FLAG_ALL) {
-            // All neighbors ready - add to both sets -- Trigger load if newly added to chunkReadyForced (first time ready)
-            if ((this.chunkReadyForced.add(key) || self().angelica$getChunkReady().add(key)) && !self().angelica$getUnloadQueue().remove(key)) {
-                self().angelica$getLoadQueue().add(key);
-            }
-        } else {
-            // Self ready but neighbors not - add to forced, remove from proper
-            // Trigger load if state changed (moved from proper to forced, or newly forced)
-            if ((this.chunkReadyForced.add(key) || self().angelica$getChunkReady().remove(key)) && !self().angelica$getUnloadQueue().remove(key)) {
-                self().angelica$getLoadQueue().add(key);
-            }
-        }
-    }
-
-    @Override
-    public LongCollection getReadyChunks() {
-        if (AngelicaConfig.useVanillaChunkTracking) {
-            // Aggressive mode: return both ready sets
-            final LongOpenHashSet combined = new LongOpenHashSet(self().angelica$getChunkReady());
-            combined.addAll(this.chunkReadyForced);
-            return LongSets.unmodifiable(combined);
-        } else {
-            // Default mode: only return chunks with all neighbors ready
-            return LongSets.unmodifiable(self().angelica$getChunkReady());
-        }
-    }
-
-    @Override
-    public void forEachEvent(ChunkEventHandler loadEventHandler, ChunkEventHandler unloadEventHandler) {
-        ChunkTracker.forEachChunk(self().angelica$getUnloadQueue(), unloadEventHandler);
-        self().angelica$getUnloadQueue().clear();
-
-        ChunkTracker.forEachChunk(self().angelica$getLoadQueue(), loadEventHandler);
-        self().angelica$getLoadQueue().clear();
+        super.forEachEvent(sectionManager);
    }
 }
@@ -3,6 +3,9 @@ package com.gtnewhorizons.angelica.rendering.celeritas;
 import com.google.common.collect.ImmutableListMultimap;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
+import lombok.Getter;
+import me.jellysquid.mods.sodium.client.gui.SodiumGameOptions;
+import me.jellysquid.mods.sodium.client.gui.options.named.TextureFilterMode;
 import org.embeddedt.embeddium.impl.render.chunk.RenderPassConfiguration;
 import org.embeddedt.embeddium.impl.render.chunk.compile.sorting.QuadPrimitiveType;
 import org.embeddedt.embeddium.impl.render.chunk.terrain.TerrainRenderPass;
@@ -16,37 +19,27 @@ import java.util.Map;
 public class AngelicaRenderPassConfiguration {

    public static TerrainRenderPass SOLID_PASS, CUTOUT_MIPPED_PASS, TRANSLUCENT_PASS;
-    public static Material SOLID_MATERIAL, CUTOUT_MIPPED_MATERIAL, TRANSLUCENT_MATERIAL;
+    public static Material SOLID_MATERIAL, CUTOUT_MIPPED_MATERIAL, CUTOUT_MATERIAL, TRANSLUCENT_MATERIAL;

-    private record AngelicaPipelineState(int pass, boolean disableAlphaTest) implements TerrainRenderPass.PipelineState {
-        @Override
-        public void setup() {
-            GLStateManager.glDepthMask(true);
-
-            if (pass == 0) {
-                GLStateManager.glAlphaFunc(GL11.GL_GREATER, 0.1F);
-            }
-            if (disableAlphaTest) {
-                GLStateManager.disableAlphaTest();
-            }
-        }
-
-        @Override
-        public void clear() {
-            if (disableAlphaTest) {
-                GLStateManager.enableAlphaTest();
-            }
-        }
-    }
+    @Getter
+    private static boolean rgssEnabled;

    private static TerrainRenderPass.TerrainRenderPassBuilder builderForRenderType(int pass, boolean disableAlphaTest, ChunkVertexType vertexType) {
-        return TerrainRenderPass.builder()
+        final TerrainRenderPass.TerrainRenderPassBuilder builder = TerrainRenderPass.builder()
            .pipelineState(new AngelicaPipelineState(pass, disableAlphaTest))
            .vertexType(vertexType)
            .primitiveType(QuadPrimitiveType.TRIANGULATED);
+
+        if (rgssEnabled) {
+            builder.extraDefine("USE_RGSS", "");
+        }
+
+        return builder;
    }

    public static RenderPassConfiguration<BlockRenderLayer> build(ChunkVertexType vertexType) {
+        rgssEnabled = SodiumGameOptions.effectiveTextureFilterMode() == TextureFilterMode.RGSS;
+
        SOLID_PASS = builderForRenderType(0, true, vertexType)
            .name("solid")
            .fragmentDiscard(false)
@@ -68,7 +61,8 @@ public class AngelicaRenderPassConfiguration {

        TRANSLUCENT_MATERIAL = new Material(TRANSLUCENT_PASS, AlphaCutoffParameter.ZERO, true);
        SOLID_MATERIAL = new Material(SOLID_PASS, AlphaCutoffParameter.ZERO, true);
-        CUTOUT_MIPPED_MATERIAL = new Material(CUTOUT_MIPPED_PASS, AlphaCutoffParameter.ONE_TENTH, true);
+        CUTOUT_MIPPED_MATERIAL = new Material(CUTOUT_MIPPED_PASS, AlphaCutoffParameter.HALF, true);
+        CUTOUT_MATERIAL = new Material(CUTOUT_MIPPED_PASS, AlphaCutoffParameter.ONE_TENTH, false);

        final ImmutableListMultimap.Builder<BlockRenderLayer, TerrainRenderPass> vanillaRenderStages = ImmutableListMultimap.builder();
        vanillaRenderStages.put(BlockRenderLayer.SOLID, SOLID_PASS);
@@ -79,10 +73,47 @@ public class AngelicaRenderPassConfiguration {
        // Material lookup by terrain layer
        final Map<BlockRenderLayer, Material> renderTypeToMaterialMap = new Reference2ReferenceOpenHashMap<>(4, Reference2ReferenceOpenHashMap.VERY_FAST_LOAD_FACTOR);
        renderTypeToMaterialMap.put(BlockRenderLayer.SOLID, SOLID_MATERIAL);
-        renderTypeToMaterialMap.put(BlockRenderLayer.CUTOUT, CUTOUT_MIPPED_MATERIAL);
+        renderTypeToMaterialMap.put(BlockRenderLayer.CUTOUT, CUTOUT_MATERIAL);
        renderTypeToMaterialMap.put(BlockRenderLayer.CUTOUT_MIPPED, CUTOUT_MIPPED_MATERIAL);
        renderTypeToMaterialMap.put(BlockRenderLayer.TRANSLUCENT, TRANSLUCENT_MATERIAL);

        return new RenderPassConfiguration<>(renderTypeToMaterialMap, vanillaRenderStages.build().asMap(), CUTOUT_MIPPED_MATERIAL, CUTOUT_MIPPED_MATERIAL, TRANSLUCENT_MATERIAL);
    }
+
+    private static final class AngelicaPipelineState implements TerrainRenderPass.PipelineState {
+        private final int pass;
+        private final boolean disableAlphaTest;
+        private int savedAlphaFunction;
+        private float savedAlphaReference;
+
+        private AngelicaPipelineState(int pass, boolean disableAlphaTest) {
+            this.pass = pass;
+            this.disableAlphaTest = disableAlphaTest;
+        }
+
+        @Override
+        public void setup() {
+            GLStateManager.glDepthMask(true);
+
+            if (pass == 0) {
+                final var alphaState = GLStateManager.getAlphaState();
+                savedAlphaFunction = alphaState.getFunction();
+                savedAlphaReference = alphaState.getReference();
+                GLStateManager.glAlphaFunc(GL11.GL_GREATER, AlphaCutoffParameter.HALF.cutoff());
+            }
+            if (disableAlphaTest) {
+                GLStateManager.disableAlphaTest();
+            }
+        }
+
+        @Override
+        public void clear() {
+            if (pass == 0) {
+                GLStateManager.glAlphaFunc(savedAlphaFunction, savedAlphaReference);
+            }
+            if (disableAlphaTest) {
+                GLStateManager.enableAlphaTest();
+            }
+        }
+    }
 }
@@ -1,5 +1,8 @@
 package com.gtnewhorizons.angelica.rendering.celeritas;

+import com.cardinalstar.cubicchunks.world.ICubicWorld;
+import com.gtnewhorizons.angelica.compat.ModStatus;
+import com.gtnewhorizons.angelica.compat.cubicchunks.CubicChunksAPI;
 import com.gtnewhorizons.angelica.mixins.interfaces.RenderSectionManagerAccessor;
 import com.gtnewhorizons.angelica.proxy.ClientProxy;
 import com.gtnewhorizons.angelica.rendering.AngelicaRenderQueue;
@@ -53,7 +56,18 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {

    public static AngelicaRenderSectionManager create(ChunkVertexType vertexType, WorldClient world, int renderDistance, CommandList commandList) {
        final ChunkTaskProvider provider = ChunkTaskRegistry.getActiveProvider();
-        return new AngelicaRenderSectionManager(AngelicaRenderPassConfiguration.build(vertexType), world, renderDistance, commandList, 0, 16, provider.threadCount(), provider);
+        final int minSection;
+        final int maxSection;
+
+        if (ModStatus.isCubicChunksLoaded && world instanceof ICubicWorld) {
+            minSection = CubicChunksAPI.getMinSectionY(world);
+            maxSection = CubicChunksAPI.getMaxSectionYExclusive(world);
+        } else {
+            minSection = 0;
+            maxSection = 16;
+        }
+
+        return new AngelicaRenderSectionManager(AngelicaRenderPassConfiguration.build(vertexType), world, renderDistance, commandList, minSection, maxSection, provider.threadCount(), provider);
    }

    public void setCameraPosition(double x, double y, double z) {
@@ -125,6 +139,12 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
        if (chunk.isEmpty()) {
            return true;
        }
+
+        if (ModStatus.isCubicChunksLoaded) {
+            final var section = CubicChunksAPI.getCubeStorage(this.world, x, y, z);
+            return section == null || section.isEmpty();
+        }
+
        final var array = chunk.getBlockStorageArray();
        if (y < 0 || y >= array.length) {
            return true;
@@ -198,6 +218,12 @@ public class AngelicaRenderSectionManager extends RenderSectionManager {
        return IrisShaderProviderHolder.isShadowPass();
    }

+    public void markShadowGraphDirty() {
+        if (this.shadowRenderListManager != null) {
+            this.shadowRenderListManager.setNeedsUpdate(true);
+        }
+    }
+
    @Override
    public Collection<String> getDebugStrings() {
        List<String> list = new ArrayList<>(super.getDebugStrings());
@@ -1,15 +1,10 @@
 package com.gtnewhorizons.angelica.rendering.celeritas;

-import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
-import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightWorldRenderer;
-import com.gtnewhorizons.angelica.glsm.GLStateManager;
-import com.gtnewhorizons.angelica.mixins.interfaces.ITileEntityBoundingBoxCache;
-import com.gtnewhorizons.angelica.proxy.ClientProxy;
-import com.gtnewhorizons.angelica.rendering.RenderingState;
-import com.gtnewhorizons.angelica.rendering.TileEntityRenderBoundsRegistry;
-import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider;
-import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder;
-import net.coderbot.iris.pipeline.ShadowRenderer;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.multiplayer.WorldClient;
 import net.minecraft.client.renderer.tileentity.TileEntityRendererDispatcher;
@@ -17,6 +12,7 @@ import net.minecraft.entity.Entity;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.AxisAlignedBB;
 import net.minecraftforge.client.MinecraftForgeClient;
+
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.embeddedt.embeddium.impl.gl.device.CommandList;
@@ -32,10 +28,18 @@ import org.embeddedt.embeddium.impl.render.viewport.Viewport;
 import org.joml.Matrix4f;
 import org.lwjgl.opengl.GL11;

-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.Iterator;
-import java.util.List;
+import com.gtnewhorizons.angelica.compat.ModStatus;
+import com.gtnewhorizons.angelica.compat.cubicchunks.CubicChunksAPI;
+import com.gtnewhorizons.angelica.dynamiclights.DynamicLights;
+import com.gtnewhorizons.angelica.dynamiclights.IDynamicLightWorldRenderer;
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.mixins.interfaces.ITileEntityBoundingBoxCache;
+import com.gtnewhorizons.angelica.proxy.ClientProxy;
+import com.gtnewhorizons.angelica.rendering.RenderingState;
+import com.gtnewhorizons.angelica.rendering.TileEntityRenderBoundsRegistry;
+import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProvider;
+import com.gtnewhorizons.angelica.rendering.celeritas.api.IrisShaderProviderHolder;
+import net.coderbot.iris.pipeline.ShadowRenderer;

 public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, AngelicaRenderSectionManager, BlockRenderLayer, TileEntity, CeleritasWorldRenderer.TileEntityRenderContext> implements IDynamicLightWorldRenderer {
    private static final Logger LOGGER = LogManager.getLogger("Angelica");
@@ -110,12 +114,20 @@ public class CeleritasWorldRenderer extends SimpleWorldRenderer<WorldClient, Ang

    @Override
    public int getMinimumBuildHeight() {
-        return 0;
+        if (ModStatus.isCubicChunksLoaded) {
+            return CubicChunksAPI.getMinHeight(this.world);
+        } else {
+            return 0;
+        }
    }

    @Override
    public int getMaximumBuildHeight() {
-        return 256;
+        if (ModStatus.isCubicChunksLoaded) {
+            return CubicChunksAPI.getMaxHeight(this.world);
+        } else {
+            return 256;
+        }
    }

    @Override
@@ -0,0 +1,42 @@
+package com.gtnewhorizons.angelica.rendering.celeritas;
+
+import net.minecraft.client.Minecraft;
+import net.minecraftforge.common.MinecraftForge;
+
+import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTracker;
+import org.embeddedt.embeddium.impl.render.chunk.map.ChunkTrackerHolder;
+
+import com.cardinalstar.cubicchunks.api.event.CubeEvent;
+import com.cardinalstar.cubicchunks.util.CubePos;
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+
+public class CubeStatusEvents {
+
+    public static void init() {
+        MinecraftForge.EVENT_BUS.register(new CubeStatusEvents());
+    }
+
+    private ChunkTracker getTracker() {
+        return ChunkTrackerHolder.get(Minecraft.getMinecraft().theWorld);
+    }
+
+    @SubscribeEvent
+    public void onCubeLoaded(CubeEvent.Load event) {
+        if (!event.world.isRemote) return;
+
+        if (getTracker() instanceof CubeStatusTracker cubic) {
+            CubePos pos = event.pos;
+            cubic.onCubeLoaded(pos.getX(), pos.getY(), pos.getZ());
+        }
+    }
+
+    @SubscribeEvent
+    public void onCubeUnloaded(CubeEvent.Unload event) {
+        if (!event.world.isRemote) return;
+
+        if (getTracker() instanceof CubeStatusTracker cubic) {
+            CubePos pos = event.pos;
+            cubic.onCubeUnloaded(pos.getX(), pos.getY(), pos.getZ());
+        }
+    }
+}
Author	SHA1	Message	Date
Jason Mitchell	78562f12d9	Do less work (#1971 )	2026-07-28 15:24:36 -07:00
CRIMSTAL	031456f224	fix(DisplayListVBO): guard against null VAO and zero-count draw during display list replay (#1969 )	2026-07-28 13:28:59 -07:00
Jason Mitchell	ff35c684ca	Cache a few more things on glsm (#1970 )	2026-07-28 13:28:25 -07:00
Eclipse-Sol	5c4ef022d5	Make mipmap attribution hook not suck and thread-safe (#1967 )	2026-07-27 19:14:19 -07:00
Jason Mitchell	4eb837a2c0	Chunk -> world coords (#1966 )	2026-07-27 10:54:26 -07:00
Jason Mitchell	6570b6a0a5	Properly handle flags removed in core (#1965 )	2026-07-26 21:46:30 -07:00
Jason Mitchell	493b641d56	Switch to an offset based cloud adjustment for World Providers that adjust it (#1962 )	2026-07-25 15:35:40 -07:00
Eclipse-Sol	3f4995466c	Fix scrollbar not following mouse (#1961 ) * Fix scrollbar not following mouse * add /deobfName/	2026-07-24 21:50:46 -04:00
Eclipse-Sol	56d7568fd3	Attempt at making mipmaps better (#1952 )	2026-07-24 17:54:45 -07:00
Jason Mitchell	4910cfd6d3	Fix some CMEs and black screens seen during boot/splash. Should be minimal overhead after splash. (#1959 )	2026-07-23 19:33:01 -07:00
Jason Mitchell	d1c6677caf	Fix plascrete/cleanroom trophy rendering (#1957 )	2026-07-23 13:42:46 -07:00
Jason Mitchell	8cf0296284	Properly gate end flash (#1954 )	2026-07-23 09:34:41 -07:00
Jason Mitchell	4fd98e5026	Add some missing buffer redirects (#1953 )	2026-07-23 08:34:11 -07:00
SpacEagle17	8e293f13fb	Fix at_midBlock at high coordinates (#1949 )	2026-07-22 18:02:55 -07:00
Jason Mitchell	2db20ad866	Handle some Intel driver shenanigans (#1951 )	2026-07-21 08:05:46 -07:00
Eclipse-Sol	10a5b550f2	Add Uniforms for End Flashes (#1892 )	2026-07-18 06:42:57 -07:00
Eldrinn-Elantey	c1403dcf13	Reload unicode glyph widths on resource pack change (#1944 )	2026-07-18 05:58:45 -07:00
tiffit	5d1fabfca9	Add API for allowing other mods to have celeritas support (#1936 )	2026-07-16 09:54:55 -05:00
tiffit	555b2b7dd2	Fix typo in PR template (#1937 )	2026-07-14 00:10:41 -05:00
SuperSouprandJason Mitchell	7017786a7c	CTM integration improvements (#1931 ) Co-authored-by: Jason Mitchell <[email protected]>	2026-07-12 10:45:16 -05:00
Eclipse-Sol	1c49649685	Fix Streams not rendering correctly (#1932 )	2026-07-12 10:41:36 -05:00
Caedis	2bae79c4ee	Up default zoom speed to 20 (#1910 )	2026-07-09 21:34:03 -04:00
Jason Mitchell	c22935660a	Reenable compute shaders (#1918 )	2026-07-05 20:38:13 -07:00
tiffit	79c488102b	CTM: Fix "flipped" value not set to false in setFace() (#1913 )	2026-07-05 18:24:28 -07:00
Jason Mitchell	cc1353b73a	Fix infinite farplane causing incorrect culling in pdim with no clouds (#1917 )	2026-07-05 18:18:17 -07:00
Eclipse-Sol	d1e6dc8c94	Fix/bug fixes (#1905 )	2026-07-04 13:06:36 -07:00
GribanovIvan	ecbf8fea2f	font: load bundled .ttf/.otf fonts from fontfiles/ and config/angelia/fonts/ (#1904 )	2026-07-04 12:16:48 -07:00
tiffit	610209605f	Compact CTM: Decouple block face and rendered face (#1907 )	2026-07-04 03:22:04 +03:00
mist475andJason Mitchell	112aae3735	Fix lotr biome colours again (essentially copy of https://github.com/GTNewHorizons/Angelica/pull/25 ) (#1902 ) Co-authored-by: Jason Mitchell <[email protected]>	2026-07-03 14:21:05 -07:00
RecursivePineapple	5844b1b5c1	Cubic Chunks Compatibility (#1808 )	2026-07-03 12:41:04 -07:00
Jason Mitchell	05f01c17e6	No point continuously building clouds if we're not rendering them... (#1900 )	2026-06-29 20:17:06 -07:00
SpacEagle17	f07d96316a	Add shader setting search functionality and center selection (#1897 )	2026-06-29 19:36:55 -07:00