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
148 changed files with 3808 additions and 703 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.5-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")
@@ -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,7 +40,11 @@ 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;
        }
@@ -56,7 +62,46 @@ public final class VAOManager {
    }

    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; }
@@ -69,6 +114,7 @@ public final class VAOManager {
        public int vertexFlags;
        public int ebo;
        public int clientSideEnabledCount;
+        private VAOData nextEboOwner;

        public VAOData() {
            attribs = new Attrib[MAX_ATTRIBS];
@@ -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.5-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);
        }
@@ -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;
+    }
+}
@@ -211,6 +211,8 @@ public enum Mixins implements IMixins {
        .addClientMixins(
            "rendering.MixinBlock"
            , "rendering.MixinBlockFluidBase"
+            , "rendering.MixinBlockLiquid"
+            , "rendering.BlockLiquidFlowInvoker"
            , "rendering.AccessorBiomeColorEvent"
            , "rendering.MixinBiomeGenBase"
            , "rendering.MixinChunk"
@@ -248,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"
@@ -415,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)
@@ -481,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"),
@@ -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();
+}
@@ -296,7 +296,7 @@ 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,
-                        this.mc.theWorld.getBiomeGenForCoords(bX & 15, bZ & 15).biomeName,
+                        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)));
@@ -82,6 +82,7 @@ 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;

@@ -169,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();

@@ -188,12 +192,7 @@ public class CloudRenderer implements IResourceManagerReloadListener {
        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;
    }

    /**
@@ -213,7 +212,7 @@ public class CloudRenderer implements IResourceManagerReloadListener {
        if (view != null) {
            verticalSlack = Math.abs(cloudElevation + 0.33f - (float) view.posY) + 4.0f * scaleMult;
        }
-        return radiusBlocks + verticalSlack;
+        return Math.min(radiusBlocks + verticalSlack, MAX_FAR_PLANE_DISTANCE);
    }

    private void invalidateGeometry() {
@@ -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();
@@ -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,6 @@
 package com.gtnewhorizons.angelica.rendering.celeritas;

+import com.gtnewhorizons.angelica.utils.MipmapStrategy;
 import org.embeddedt.embeddium.impl.render.chunk.sprite.SpriteTransparencyLevel;

 public interface SpriteExtension {
@@ -10,4 +11,5 @@ public interface SpriteExtension {

    /** One-shot: returns true if marked, then resets. */
    boolean celeritas$shouldUpdate();
+    void celeritas$setMipmapStrategy(MipmapStrategy strategy, boolean explicit, int textureType);
 }
@@ -0,0 +1,294 @@
+package com.gtnewhorizons.angelica.utils;
+
+import it.unimi.dsi.fastutil.ints.IntArrayFIFOQueue;
+import org.embeddedt.embeddium.api.util.ColorARGB;
+import org.embeddedt.embeddium.impl.texture.MipmapHelper;
+
+/**
+ * Mipmap downsampling for atlas sprites, replacing vanilla's {@code TextureUtil.generateMipmapData}.
+ */
+public final class MipmapGenerator {
+
+    private static final float CUTOUT_ALPHA_REF = 0.5f;
+    private static final float STRICT_COVERAGE_TARGET = 0.35f;
+    private static final float ALPHA_BIAS = 0.025f;
+
+    private MipmapGenerator() {
+    }
+
+    private static MipmapStrategy resolve(MipmapStrategy strategy, boolean hasTransparentPixel) {
+        if (strategy == null || strategy == MipmapStrategy.AUTO) {
+            return hasTransparentPixel ? MipmapStrategy.CUTOUT : MipmapStrategy.MEAN;
+        }
+        return strategy;
+    }
+
+    static boolean isCutoutStrategy(MipmapStrategy strategy, boolean hasTransparentPixel) {
+        final MipmapStrategy resolved = resolve(strategy, hasTransparentPixel);
+        return resolved == MipmapStrategy.CUTOUT
+            || resolved == MipmapStrategy.STRICT_CUTOUT
+            || resolved == MipmapStrategy.DARK_CUTOUT;
+    }
+
+    static void solidify(int[] image, int width, int height) {
+        final int size = Math.min(width * height, image.length);
+        if (size <= 0) {
+            return;
+        }
+
+        boolean hasTransparent = false;
+        for (int i = 0; i < size; i++) {
+            if (ColorARGB.unpackAlpha(image[i]) == 0) {
+                hasTransparent = true;
+                break;
+            }
+        }
+        if (!hasTransparent) {
+            return;
+        }
+
+        final int[] color = new int[size];
+        final IntArrayFIFOQueue queue = new IntArrayFIFOQueue(64);
+
+        for (int i = 0; i < size; i++) {
+            final int pixel = image[i];
+            if (ColorARGB.unpackAlpha(pixel) == 0) {
+                continue;
+            }
+            color[i] = pixel;
+            if (hasTransparentNeighbour(image, i, width, size)) {
+                queue.enqueue(i);
+            }
+        }
+
+        if (queue.isEmpty()) {
+            return;
+        }
+
+        while (!queue.isEmpty()) {
+            final int index = queue.dequeueInt();
+            final int x = index % width;
+            final int source = color[index];
+
+            if (x > 0) {
+                fill(index - 1, source, color, queue);
+            }
+            if (x < width - 1) {
+                fill(index + 1, source, color, queue);
+            }
+            if (index >= width) {
+                fill(index - width, source, color, queue);
+            }
+            if (index + width < size) {
+                fill(index + width, source, color, queue);
+            }
+        }
+
+        for (int i = 0; i < size; i++) {
+            if (ColorARGB.unpackAlpha(image[i]) == 0) {
+                image[i] = color[i] & 0x00FFFFFF;
+            }
+        }
+    }
+
+    private static boolean hasTransparentNeighbour(int[] image, int index, int width, int size) {
+        final int x = index % width;
+        return (x > 0 && ColorARGB.unpackAlpha(image[index - 1]) == 0)
+            || (x < width - 1 && ColorARGB.unpackAlpha(image[index + 1]) == 0)
+            || (index >= width && ColorARGB.unpackAlpha(image[index - width]) == 0)
+            || (index + width < size && ColorARGB.unpackAlpha(image[index + width]) == 0);
+    }
+
+    private static void fill(int neighbour, int source, int[] color, IntArrayFIFOQueue queue) {
+        if (color[neighbour] == 0) {
+            color[neighbour] = source;
+            queue.enqueue(neighbour);
+        }
+    }
+
+    static void fillEmptyAreasWithDarkColor(int[] image) {
+        int darkest = ColorARGB.pack(255, 255, 255, 255);
+        int darkestSum = 255 * 3;
+
+        for (final int pixel : image) {
+            if (ColorARGB.unpackAlpha(pixel) == 0) {
+                continue;
+            }
+            final int sum = ColorARGB.unpackRed(pixel) + ColorARGB.unpackGreen(pixel) + ColorARGB.unpackBlue(pixel);
+            if (sum < darkestSum) {
+                darkestSum = sum;
+                darkest = pixel;
+            }
+        }
+
+        final int fill = ColorARGB.pack(3 * ColorARGB.unpackRed(darkest) / 4,
+            3 * ColorARGB.unpackGreen(darkest) / 4, 3 * ColorARGB.unpackBlue(darkest) / 4, 0);
+
+        for (int i = 0; i < image.length; i++) {
+            if (ColorARGB.unpackAlpha(image[i]) == 0) {
+                image[i] = fill;
+            }
+        }
+    }
+
+    /**
+     * Estimates the fraction of the image that survives, with bilinear filtering modeled by
+     * supersampling each texel quad on a 4x4 interior grid.
+     */
+    static float alphaTestCoverage(int[] image, int width, float alphaRef, float alphaScale, int border) {
+        final int height = image.length / width;
+        final float alphaFactor = alphaScale / 255.0f;
+        float total = 0.0f;
+        int quads = 0;
+
+        for (int y = border; y < height - border - 1; y++) {
+            for (int x = border; x < width - border - 1; x++) {
+                final int i = x + y * width;
+                final float a00 = scaledAlpha(image[i], alphaFactor);
+                final float a10 = scaledAlpha(image[i + 1], alphaFactor);
+                final float a01 = scaledAlpha(image[i + width], alphaFactor);
+                final float a11 = scaledAlpha(image[i + width + 1], alphaFactor);
+
+                final float lo = Math.min(Math.min(a00, a10), Math.min(a01, a11));
+                if (lo > alphaRef) {
+                    total += 1.0f;
+                    quads++;
+                    continue;
+                }
+                final float hi = Math.max(Math.max(a00, a10), Math.max(a01, a11));
+                if (hi <= alphaRef) {
+                    quads++;
+                    continue;
+                }
+
+                int hits = 0;
+                for (int sy = 0; sy < 4; sy++) {
+                    final float fy = (sy + 0.5f) / 4.0f;
+                    for (int sx = 0; sx < 4; sx++) {
+                        final float fx = (sx + 0.5f) / 4.0f;
+                        final float top = a00 + (a10 - a00) * fx;
+                        final float bottom = a01 + (a11 - a01) * fx;
+                        if (top + (bottom - top) * fy > alphaRef) {
+                            hits++;
+                        }
+                    }
+                }
+                total += hits / 16.0f;
+                quads++;
+            }
+        }
+
+        if (quads == 0) {
+            return scaledAlpha(image[0], alphaFactor) > alphaRef ? 1.0f : 0.0f;
+        }
+        return total / quads;
+    }
+
+    private static float scaledAlpha(int color, float alphaFactor) {
+        return clamp01(ColorARGB.unpackAlpha(color) * alphaFactor);
+    }
+
+    private static float clamp01(float value) {
+        return value < 0.0f ? 0.0f : Math.min(value, 1.0f);
+    }
+
+    static void scaleAlphaToCoverage(int[] image, int width, float desiredCoverage, float alphaRef, int border) {
+        float min = 0.0f;
+        float max = 4.0f;
+        float scale = 1.0f;
+        float bestScale = 1.0f;
+        float bestError = Float.POSITIVE_INFINITY;
+
+        for (int i = 0; i < 5; i++) {
+            final float coverage = alphaTestCoverage(image, width, alphaRef, scale, border);
+            final float error = Math.abs(coverage - desiredCoverage);
+            if (error < bestError) {
+                bestError = error;
+                bestScale = scale;
+            }
+
+            if (coverage < desiredCoverage) {
+                min = scale;
+            } else if (!(coverage > desiredCoverage)) {
+                break;
+            } else {
+                max = scale;
+            }
+            scale = (min + max) / 2.0f;
+        }
+
+        for (int i = 0; i < image.length; i++) {
+            final int color = image[i];
+            final int rawAlpha = ColorARGB.unpackAlpha(color);
+            final float bias = rawAlpha > 0 ? ALPHA_BIAS : 0.0f;
+            final int alpha = (int) Math.floor(clamp01(rawAlpha / 255.0f * bestScale + bias) * 255.0f);
+            image[i] = ColorARGB.withAlpha(color, alpha);
+        }
+    }
+
+    public static int[][] generateMipLevels(int mipLevel, int width, int[][] currentMips,
+                                            MipmapStrategy strategy, boolean hasTransparentPixel, int border) {
+
+        final MipmapStrategy resolved = resolve(strategy, hasTransparentPixel);
+        final boolean isCutout = isCutoutStrategy(strategy, hasTransparentPixel);
+        final boolean darkCutout = resolved == MipmapStrategy.DARK_CUTOUT;
+
+        final int[][] result = new int[mipLevel + 1][];
+        final int[] base = currentMips[0];
+
+        if (mipLevel > 0 && (currentMips.length == 1 || currentMips[1] == null)) {
+            if (darkCutout) {
+                fillEmptyAreasWithDarkColor(base);
+            } else {
+                solidify(base, width, base.length / width);
+            }
+        }
+
+        result[0] = base;
+        if (mipLevel <= 0) {
+            return result;
+        }
+
+        final boolean autoResolved = strategy == null || strategy == MipmapStrategy.AUTO;
+        final boolean strictCoverage = resolved == MipmapStrategy.STRICT_CUTOUT;
+        final float alphaRef = CUTOUT_ALPHA_REF;
+        float originalCoverage = 0.0f;
+        if (isCutout) {
+            originalCoverage = alphaTestCoverage(base, width, alphaRef, 1.0f, border);
+            if (strictCoverage || (autoResolved && originalCoverage < STRICT_COVERAGE_TARGET)) {
+                originalCoverage = Math.max(originalCoverage, STRICT_COVERAGE_TARGET);
+            }
+        }
+
+        for (int level = 1; level <= mipLevel; level++) {
+            final int levelWidth = width >> level;
+            final int[] provided = level < currentMips.length ? currentMips[level] : null;
+
+            if (provided != null) {
+                result[level] = provided;
+            } else {
+                final int[] input = result[level - 1];
+                final int prevWidth = width >> (level - 1);
+                final int prevHeight = input.length / prevWidth;
+                final int levelHeight = prevHeight >> 1;
+                final int[] output = new int[levelWidth * levelHeight];
+
+                for (int y = 0; y < levelHeight; y++) {
+                    for (int x = 0; x < levelWidth; x++) {
+                        final int i = x * 2 + y * 2 * prevWidth;
+                        output[x + y * levelWidth] = MipmapHelper.weightedAverageColor(
+                            MipmapHelper.weightedAverageColor(input[i], input[i + 1]),
+                            MipmapHelper.weightedAverageColor(input[i + prevWidth], input[i + prevWidth + 1]));
+                    }
+                }
+                result[level] = output;
+            }
+
+            if (isCutout) {
+                scaleAlphaToCoverage(result[level], levelWidth, originalCoverage, alphaRef, border >> level);
+            }
+        }
+
+        return result;
+    }
+}
@@ -0,0 +1,85 @@
+package com.gtnewhorizons.angelica.utils;
+
+import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockFlower;
+import net.minecraft.block.BlockGlass;
+import net.minecraft.block.BlockLeaves;
+import net.minecraft.block.BlockMushroom;
+import net.minecraft.block.BlockRedstoneWire;
+
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Fallback {@link MipmapStrategy} assignments for sprites that carry no metadata.
+ */
+public final class MipmapStrategies {
+
+    private static final Map<Class<?>, MipmapStrategy> CLASS_RULES = new Object2ObjectOpenHashMap<>();
+    private static final Map<String, MipmapStrategy> SPRITE_RULES = new ConcurrentHashMap<>();
+    private static final ThreadLocal<Deque<MipmapStrategy>> STRATEGY_STACK = ThreadLocal.withInitial(LinkedList::new);
+
+    static {
+        CLASS_RULES.put(BlockLeaves.class, MipmapStrategy.DARK_CUTOUT);
+        CLASS_RULES.put(BlockFlower.class, MipmapStrategy.STRICT_CUTOUT);
+        CLASS_RULES.put(BlockMushroom.class, MipmapStrategy.STRICT_CUTOUT);
+        CLASS_RULES.put(BlockGlass.class, MipmapStrategy.MEAN);
+        CLASS_RULES.put(BlockRedstoneWire.class, MipmapStrategy.MEAN);
+    }
+
+    private MipmapStrategies() {
+    }
+
+    public static void reset() {
+        SPRITE_RULES.clear();
+        STRATEGY_STACK.remove();
+    }
+
+    public static void beginBlock(Block block) {
+        STRATEGY_STACK.get().push(resolve(block.getClass()));
+    }
+
+    public static void endBlock() {
+        final Deque<MipmapStrategy> stack = STRATEGY_STACK.get();
+        if (!stack.isEmpty()) {
+            stack.pop();
+        }
+    }
+
+    public static void recordSprite(int textureType, String iconName) {
+        if (iconName == null) {
+            return;
+        }
+
+        MipmapStrategy strategy = STRATEGY_STACK.get().peek();
+        if (strategy == null && textureType == 0 && iconName.contains("leaves")) {
+            strategy = MipmapStrategy.DARK_CUTOUT;
+        }
+        if (strategy == null) {
+            return;
+        }
+
+        SPRITE_RULES.merge(iconName, strategy,
+            (existing, incoming) -> incoming.conflictPrecedence() > existing.conflictPrecedence() ? incoming : existing);
+    }
+
+    public static MipmapStrategy inheritedFor(int textureType, String iconName) {
+        if (iconName == null || textureType != 0) {
+            return null;
+        }
+        return SPRITE_RULES.get(iconName);
+    }
+
+    private static MipmapStrategy resolve(Class<?> type) {
+        for (Class<?> c = type; c != null; c = c.getSuperclass()) {
+            final MipmapStrategy rule = CLASS_RULES.get(c);
+            if (rule != null) {
+                return rule;
+            }
+        }
+        return null;
+    }
+}
@@ -0,0 +1,33 @@
+package com.gtnewhorizons.angelica.utils;
+
+public enum MipmapStrategy {
+    AUTO,
+    MEAN,
+    CUTOUT,
+    STRICT_CUTOUT,
+    DARK_CUTOUT;
+
+    private static final MipmapStrategy[] VALUES = values();
+
+    public static MipmapStrategy byName(String name) {
+        if (name == null) {
+            return null;
+        }
+        for (MipmapStrategy strategy : VALUES) {
+            if (strategy.name().equalsIgnoreCase(name)) {
+                return strategy;
+            }
+        }
+        return null;
+    }
+
+    public int conflictPrecedence() {
+        return switch (this) {
+            case MEAN -> 4;
+            case DARK_CUTOUT -> 3;
+            case STRICT_CUTOUT -> 2;
+            case CUTOUT -> 1;
+            case AUTO -> 0;
+        };
+    }
+}
@@ -40,6 +40,7 @@ final class BlockOrientation extends RenderBlockState {
    private int altMetadata;
    private int metadataBits;
    private int renderType;
+    private boolean iCtmBlock;

    private int blockFace;
    private int textureFace;
@@ -76,6 +77,11 @@ final class BlockOrientation extends RenderBlockState {
        return z;
    }

+    @Override
+    public int getMetadata() {
+        return metadata;
+    }
+
    @Override
    public int getBlockFace() {
        return blockFace;
@@ -156,8 +162,8 @@ final class BlockOrientation extends RenderBlockState {

    @Override
    public boolean shouldConnectByBlock(Block neighbor, int neighborX, int neighborY, int neighborZ) {
-        return block == neighbor
-            && (metadataBits & (1 << blockAccess.getBlockMetadata(neighborX, neighborY, neighborZ))) != 0;
+        return iCtmBlock ? ((ICTMBlock) block).shouldConnectByBlock(this, neighbor, neighborX, neighborY, neighborZ)
+            : block == neighbor && (metadataBits & (1 << blockAccess.getBlockMetadata(neighborX, neighborY, neighborZ))) != 0;
    }

    @Override
@@ -175,6 +181,7 @@ final class BlockOrientation extends RenderBlockState {
        copy.altMetadata = altMetadata;
        copy.metadataBits = metadataBits;
        copy.renderType = renderType;
+        copy.iCtmBlock = iCtmBlock;
        copy.blockFace = blockFace;
        copy.textureFace = textureFace;
        copy.textureFaceOrig = textureFaceOrig;
@@ -203,6 +210,7 @@ final class BlockOrientation extends RenderBlockState {
        this.z = z;
        renderType = block.getRenderType();
        metadata = altMetadata = blockAccess.getBlockMetadata(x, y, z);
+        iCtmBlock = block instanceof ICTMBlock;
        offsetsComputed = false;
    }

@@ -212,7 +220,7 @@ final class BlockOrientation extends RenderBlockState {
        rotateUV = 0;
        textureFace = blockFaceToTextureFace(blockFace);
        metadataBits = (1 << metadata) | (1 << altMetadata);
-        if(!fixedBottomFaceUV && blockFace == ForgeDirection.DOWN.ordinal()) flipped = true;
+        flipped = !fixedBottomFaceUV && blockFace == ForgeDirection.DOWN.ordinal();
    }

    void setBlockMetadata(Block block, int metadata, int face) {
@@ -223,6 +231,7 @@ final class BlockOrientation extends RenderBlockState {
        renderType = block.getRenderType();
        blockFace = textureFace = textureFaceOrig = face;
        this.metadata = metadata;
+        iCtmBlock = block instanceof ICTMBlock;
        metadataBits = 1 << metadata;
        dx = dy = dz = 0;
        rotateUV = 0;
@@ -9,6 +9,7 @@ import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.locks.StampedLock;
+import java.util.function.Consumer;

 import com.github.bsideup.jabel.Desugar;
 import net.minecraft.block.Block;
@@ -34,10 +35,22 @@ public class CTMUtils {

    public static final MCLogger logger = MCLogger.getLogger(MCLogger.Category.CONNECTED_TEXTURES, "CTM");

-    private static class Overrides {
+    public static class Overrides {
        private final List<TileOverride> all = new ArrayList<>();
        private final Map<Block, List<BlockStateMatcher>> block = new IdentityHashMap<>();
        private final Map<String, List<TileOverride>> tile = new HashMap<>();
+
+        public List<TileOverride> getAll() {
+            return all;
+        }
+
+        public Map<Block, List<BlockStateMatcher>> getBlock() {
+            return block;
+        }
+
+        public Map<String, List<TileOverride>> getTile() {
+            return tile;
+        }
    }

    private static Overrides overrides = new Overrides();
@@ -82,6 +95,8 @@ public class CTMUtils {

    private static final AtomicInteger texturePackChangeCounter = new AtomicInteger(0);

+    private static final ArrayList<Consumer<Overrides>> ctmRegistrationCallbacks = new ArrayList<>();
+
    static {
        try {
            Class.forName(MCPatcherUtils.RENDER_PASS_CLASS)
@@ -117,6 +132,9 @@ public class CTMUtils {
                            .listResources(TexturePackAPI.MCPATCHER_SUBDIR + "ctm", ".properties", true)) {
                            registerOverrideWithoutLock(newOverrides, TileOverride.create(resource, tileLoader));
                        }
+                        for (Consumer<Overrides> callback : ctmRegistrationCallbacks) {
+                            callback.accept(newOverrides);
+                        }
                    }
                    for (ResourceLocation resource : BlendMethod.getAllBlankResources()) {
                        tileLoader.preloadTile(resource, false);
@@ -257,7 +275,7 @@ public class CTMUtils {
        return RenderPassAPI.instance.skipDefaultRendering(block);
    }

-    private static void registerOverrideWithoutLock(Overrides overrides, TileOverride override) {
+    public static void registerOverrideWithoutLock(Overrides overrides, TileOverride override) {
        if (override != null && !override.isDisabled()) {
            boolean registered = false;
            List<BlockStateMatcher> matchingBlocks = override.getMatchingBlocks();
@@ -308,4 +326,8 @@ public class CTMUtils {
    private static TileOverrideIterator.Metadata newMetadataIterator() {
        return new TileOverrideIterator.Metadata(overrides.block, overrides.tile);
    }
+
+    public static void addCtmRegistrationCallback(Consumer<Overrides> consumer) {
+        ctmRegistrationCallbacks.add(consumer);
+    }
 }
@@ -0,0 +1,10 @@
+package com.prupe.mcpatcher.ctm;
+
+import net.minecraft.block.Block;
+
+/**
+ * Implement this interface on blocks that support connected textures to allow them to control if they connect to neighbors or not
+ */
+public interface ICTMBlock {
+    boolean shouldConnectByBlock(RenderBlockState renderBlockState, Block neighbor, int neighborX, int neighborY, int neighborZ);
+}
@@ -109,6 +109,8 @@ abstract public class RenderBlockState {

    abstract public int getZ();

+    abstract public int getMetadata();
+
    abstract public int getBlockFace();

    abstract public int getTextureFace();
@@ -33,7 +33,7 @@ public abstract class TileOverride implements Comparable<TileOverride> {

    private static final MCLogger logger = MCLogger.getLogger(MCLogger.Category.CONNECTED_TEXTURES, "CTM");

-    protected final PropertiesFile properties;
+    public final PropertiesFile properties;
    private final String baseFilename;
    protected final TileLoader tileLoader;
    protected final int renderPass;
@@ -79,7 +79,10 @@ public abstract class TileOverride implements Comparable<TileOverride> {
        if (properties == null) {
            return null;
        }
+        return create(properties, tileLoader);
+    }

+    public static TileOverride create(PropertiesFile properties, TileLoader tileLoader) {
        String method = properties.getString("method", "default")
            .toLowerCase();
        TileOverride override = null;
@@ -211,7 +214,7 @@ public abstract class TileOverride implements Comparable<TileOverride> {
            for (int i = 0;; i++) {
                ResourceLocation resource = TileLoader
                    .parseTileAddress(properties.getResource(), String.valueOf(i), blankResource);
-                if (!TexturePackAPI.hasResource(resource)) {
+                if (!TexturePackAPI.hasResource(resource) && !tileLoader.ignoreMissingTextures()) {
                    break;
                }
                if (!addIcon(resource)) {
@@ -237,7 +240,7 @@ public abstract class TileOverride implements Comparable<TileOverride> {
                        .parseTileAddress(properties.getResource(), token, blankResource);
                    if (resource == null) {
                        tileNames.add(null);
-                    } else if (TexturePackAPI.hasResource(resource)) {
+                    } else if (TexturePackAPI.hasResource(resource) || tileLoader.ignoreMissingTextures()) {
                        addIcon(resource);
                    } else {
                        properties.warning("could not find image %s", resource);
@@ -252,7 +255,7 @@ public abstract class TileOverride implements Comparable<TileOverride> {
        for (int i = from; i <= to; i++) {
            ResourceLocation resource = TileLoader
                .parseTileAddress(properties.getResource(), String.valueOf(i), blankResource);
-            if (TexturePackAPI.hasResource(resource)) {
+            if (TexturePackAPI.hasResource(resource) || tileLoader.ignoreMissingTextures()) {
                addIcon(resource);
            } else {
                properties.warning("could not find image %s", resource);
@@ -9,12 +9,12 @@ import net.minecraft.util.ResourceLocation;
 import com.prupe.mcpatcher.MCLogger;
 import com.prupe.mcpatcher.MCPatcherUtils;

-final public class PropertiesFile {
+public class PropertiesFile {

-    private final MCLogger logger;
-    private final ResourceLocation resource;
-    private final String prefix;
-    private final Properties properties;
+    protected final MCLogger logger;
+    protected final ResourceLocation resource;
+    protected final String prefix;
+    protected final Properties properties;
    private int errorCount;

    public static PropertiesFile get(MCLogger logger, ResourceLocation resource) {
@@ -147,4 +147,16 @@ final public class PropertiesFile {
            return resource.equals(((PropertiesFile) that).resource);
        }
    }
+
+    public MCLogger getLogger() {
+        return logger;
+    }
+
+    public String getPrefix() {
+        return prefix;
+    }
+
+    public Properties getProperties() {
+        return properties;
+    }
 }
@@ -275,7 +275,7 @@ public class TileLoader {
        return false;
    }

-    private boolean registerOneIcon(TextureMap textureMap, String mapName, Map<String, TextureAtlasSprite> map) {
+    protected boolean registerOneIcon(TextureMap textureMap, String mapName, Map<String, TextureAtlasSprite> map) {
        ResourceLocation resource = tilesToRegister.iterator()
            .next();
        String name = resource.toString();
@@ -304,6 +304,16 @@ public class TileLoader {
                return false;
            }
        }
+        TextureAtlasSprite icon = registerIconToMap(textureMap, resource, name);
+        map.put(name, icon);
+        iconMap.put(name, icon);
+        String extra = (width == height ? "" : ", " + (height / width) + " frames");
+        subLogger.finer("%s -> %s icon %dx%d%s", name, mapName, width, width, extra);
+        tilesToRegister.remove(resource);
+        return true;
+    }
+
+    protected TextureAtlasSprite registerIconToMap(TextureMap textureMap, ResourceLocation resource, String name) {
        TextureAtlasSprite icon;
        if(generatedTiles.contains(resource)){
            icon = new GeneratedCTMAtlasSprite(this, textureMap.anisotropicFiltering > 1, name);
@@ -311,12 +321,7 @@ public class TileLoader {
        }else{
            icon = (TextureAtlasSprite)textureMap.registerIcon(name);
        }
-        map.put(name, icon);
-        iconMap.put(name, icon);
-        String extra = (width == height ? "" : ", " + (height / width) + " frames");
-        subLogger.finer("%s -> %s icon %dx%d%s", name, mapName, width, width, extra);
-        tilesToRegister.remove(resource);
-        return true;
+        return icon;
    }

    public void finish() {
@@ -339,4 +344,8 @@ public class TileLoader {
    public IIcon getIcon(ResourceLocation resource) {
        return resource == null ? null : getIcon(resource.toString());
    }
+
+    public boolean ignoreMissingTextures() {
+        return false;
+    }
 }
@@ -176,7 +176,7 @@ public enum Settings {
    },
    VOID_FOG(new NotFineOptionTickBox(false, OptionImpact.LOW)),
    ZOOM_SMOOTH(new NotFineOptionTickBox(true, OptionImpact.LOW)),
-    ZOOM_SMOOTH_SPEED(new NotFineOptionSlider(14, 1, 30, 1, OptionImpact.LOW));
+    ZOOM_SMOOTH_SPEED(new NotFineOptionSlider(20, 1, 30, 1, OptionImpact.LOW));

    public final NotFineOption<?> option;

@@ -24,8 +24,11 @@ public class SettingsManager {
        new File(Launch.minecraftHome + File.separator + "optionsnf.txt")
    );

+    public static final float VANILLA_CLOUD_HEIGHT = 128.0f;
+
    public static int minimumFarPlaneDistance;
-    public static double cloudTranslucencyCheck;
+    public static float cloudHeightOffset;
+    public static AlwaysNever cloudTranslucencyMode = AlwaysNever.DEFAULT;
    public static boolean shadows;
    public static boolean droppedItemDetail;
    public static boolean leavesOpaque;
@@ -41,19 +44,27 @@ public class SettingsManager {
    }

    public static void cloudsUpdated() {
+        cloudHeightOffset = (int)Settings.CLOUD_HEIGHT.option.getStore() - VANILLA_CLOUD_HEIGHT;
        if(Settings.MODE_CLOUDS.option.getStore() != GraphicsQualityOff.OFF) {
            minimumFarPlaneDistance = 32 * ((int)Settings.RENDER_DISTANCE_CLOUDS.option.getStore());
-            minimumFarPlaneDistance += (int)Settings.CLOUD_HEIGHT.option.getStore();
            mc.gameSettings.clouds = true;
        } else {
            minimumFarPlaneDistance = 128;
            mc.gameSettings.clouds = false;
        }
-        switch((AlwaysNever)Settings.MODE_CLOUD_TRANSLUCENCY.option.getStore()) {
-            case DEFAULT -> cloudTranslucencyCheck = (int)Settings.CLOUD_HEIGHT.option.getStore();
-            case ALWAYS -> cloudTranslucencyCheck = Double.NEGATIVE_INFINITY;
-            case NEVER -> cloudTranslucencyCheck = Double.POSITIVE_INFINITY;
-        }
+        cloudTranslucencyMode = (AlwaysNever)Settings.MODE_CLOUD_TRANSLUCENCY.option.getStore();
+    }
+
+    public static float currentCloudHeight() {
+        return mc.theWorld == null ? VANILLA_CLOUD_HEIGHT : mc.theWorld.provider.getCloudHeight();
+    }
+
+    public static double cloudRenderOrderHeight() {
+        return switch(cloudTranslucencyMode) {
+            case ALWAYS -> Double.NEGATIVE_INFINITY;
+            case NEVER -> Double.POSITIVE_INFINITY;
+            default -> currentCloudHeight();
+        };
    }

    public static void downfallDistanceUpdated() {
@@ -6,7 +6,8 @@ import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import jss.notfine.config.NotFineConfig;
 import jss.notfine.core.Settings;
 import jss.notfine.core.SettingsManager;
-import jss.notfine.gui.options.control.NotFineControlValueFormatter;
+import me.jellysquid.mods.sodium.client.gui.SodiumGameOptionPages;
+import me.jellysquid.mods.sodium.client.gui.SodiumGameOptions;
 import me.jellysquid.mods.sodium.client.gui.options.OptionFlag;
 import me.jellysquid.mods.sodium.client.gui.options.OptionGroup;
 import me.jellysquid.mods.sodium.client.gui.options.OptionImpact;
@@ -20,6 +21,7 @@ import me.jellysquid.mods.sodium.client.gui.options.named.GraphicsMode;
 import me.jellysquid.mods.sodium.client.gui.options.named.GraphicsQuality;
 import me.jellysquid.mods.sodium.client.gui.options.named.LightingQuality;
 import me.jellysquid.mods.sodium.client.gui.options.named.ParticleMode;
+import me.jellysquid.mods.sodium.client.gui.options.named.TextureFilterMode;
 import me.jellysquid.mods.sodium.client.gui.options.storage.MinecraftOptionsStorage;
 import me.jellysquid.mods.sodium.client.gui.options.storage.SodiumOptionsStorage;
 import net.coderbot.iris.Iris;
@@ -55,7 +57,7 @@ public class NotFineGameOptionPages {
            .add(OptionImpl.createBuilder(int.class, vanillaOpts)
                .setName(I18n.format("options.renderDistance"))
                .setTooltip(I18n.format("sodium.options.view_distance.tooltip"))
-                .setControl(option -> new SliderControl(option, 2, (int)GameSettings.Options.RENDER_DISTANCE.getValueMax(), 1, ControlValueFormatter.quantity("options.chunks")))
+                .setControl(option -> new SliderControl(option, 2, (int) GameSettings.Options.RENDER_DISTANCE.getValueMax(), 1, ControlValueFormatter.quantity("options.chunks")))
                .setBinding((options, value) -> options.renderDistanceChunks = value, options -> options.renderDistanceChunks)
                .setImpact(OptionImpact.HIGH)
                .setFlags(OptionFlag.REQUIRES_RENDERER_RELOAD)
@@ -95,6 +97,29 @@ public class NotFineGameOptionPages {
                .build())
            .build());

+        final OptionImpl<GameSettings, Integer> mipmapLevels = OptionImpl.createBuilder(int.class, vanillaOpts)
+            .setName(I18n.format("options.mipmapLevels"))
+            .setTooltip(I18n.format("sodium.options.mipmap_levels.tooltip"))
+            .setControl(option -> new SliderControl(option, 0, 4, 1, ControlValueFormatter.multiplier()))
+            .setBinding((opts, value) -> opts.mipmapLevels = value, opts -> opts.mipmapLevels)
+            .setImpact(OptionImpact.MEDIUM)
+            .setFlags(OptionFlag.REQUIRES_ASSET_RELOAD)
+            .build();
+
+        final OptionImpl<SodiumGameOptions, TextureFilterMode> textureFilterMode =
+            OptionImpl.createBuilder(TextureFilterMode.class, sodiumOpts)
+                .setName(I18n.format("sodium.options.texture_filtering.name"))
+                .setTooltip(I18n.format("sodium.options.texture_filtering.tooltip"))
+                .setControl(option -> new CyclingControl<>(option, TextureFilterMode.class,
+                    TextureFilterMode.selectableValues(SodiumGameOptions.anisotropySupported())))
+                .setBinding((opts, value) -> opts.quality.textureFilterMode = value,
+                    opts -> SodiumGameOptions.resolveFilterMode(opts.quality.textureFilterMode))
+                .setImpact(OptionImpact.MEDIUM)
+                .setFlags(OptionFlag.REQUIRES_ASSET_RELOAD, OptionFlag.REQUIRES_RENDERER_RELOAD)
+                .build();
+
+        textureFilterMode.iris$dynamicallyEnable(() -> mipmapLevels.getValue() > 0);
+
        int maxGuiScale = Math.max(3, Math.min(Minecraft.getMinecraft().displayWidth / 320, Minecraft.getMinecraft().displayHeight / 240));
        groups.add(OptionGroup.createBuilder()
            .add(OptionImpl.createBuilder(int.class, vanillaOpts)
@@ -125,29 +150,16 @@ public class NotFineGameOptionPages {
                .build())
            .add(Settings.MODE_LIGHT_FLICKER.option)
            .add(Settings.DYNAMIC_FOV.option)
-            .add(OptionImpl.createBuilder(int.class, vanillaOpts)
-                .setName(I18n.format("options.mipmapLevels"))
-                .setTooltip(I18n.format("sodium.options.mipmap_levels.tooltip"))
-                .setControl(option -> new SliderControl(option, 0, 4, 1, ControlValueFormatter.multiplier()))
-                //mc.getTextureMapBlocks().setMipmapLevels(this.mipmapLevels); ?
-                .setBinding((opts, value) -> opts.mipmapLevels = value, opts -> opts.mipmapLevels)
-                .setImpact(OptionImpact.MEDIUM)
-                .setFlags(OptionFlag.REQUIRES_ASSET_RELOAD)
-                .build())
-            .add(OptionImpl.createBuilder(int.class, vanillaOpts)
-                .setName(I18n.format("options.anisotropicFiltering"))
-                .setTooltip(I18n.format("sodium.options.anisotropic_filtering.tooltip"))
-                .setControl(option -> new SliderControl(option, 0, 4, 1, NotFineControlValueFormatter.powerOfTwo()))
-                .setBinding(
-                    //mc.getTextureMapBlocks().setAnisotropicFiltering(this.anisotropicFiltering); ?
-                    (opts, value) -> opts.anisotropicFiltering = value == 0 ? 1 : (int)Math.pow(2, value),
-                    (opts) -> opts.anisotropicFiltering == 1 ? 0 : (int)(Math.log(opts.anisotropicFiltering) / Math.log(2)))
-                .setImpact(OptionImpact.MEDIUM)
-                .setFlags(OptionFlag.REQUIRES_ASSET_RELOAD)
-                .build())
+            .add(mipmapLevels)
+            .add(textureFilterMode)
+            .add(SodiumGameOptionPages.anisotropicFilteringSlider(
+                vanillaOpts,
+                textureFilterMode::getValue,
+                mipmapLevels::getValue),
+                SodiumGameOptions.anisotropySupported())
            .build());

-        if(Iris.enabled) {
+        if (Iris.enabled) {
            final OptionImpl<GameSettings, Integer> maxShadowDistanceSlider = OptionImpl.createBuilder(int.class, vanillaOpts)
                .setName(I18n.format("options.iris.shadowDistance"))
                .setTooltip(I18n.format("options.iris.shadowDistance.sodium_tooltip"))
@@ -200,7 +212,7 @@ public class NotFineGameOptionPages {
            .add(Settings.MODE_DROPPED_ITEMS.option)
            .add(Settings.MODE_GLINT_WORLD.option)
            .add(Settings.MODE_GLINT_INV.option)
-        .build());
+            .build());
        return new OptionPage(I18n.format("options.button.detail"), ImmutableList.copyOf(groups));
    }

@@ -219,7 +231,7 @@ public class NotFineGameOptionPages {
            .add(Settings.HORIZON.option)
            .add(Settings.TERRAIN_FOG.option)
            .add(Settings.FOG_NEAR_DISTANCE.option)
-        .build());
+            .build());
        return new OptionPage(I18n.format("options.button.sky"), ImmutableList.copyOf(groups));
    }

@@ -235,7 +247,7 @@ public class NotFineGameOptionPages {
                .build())
            .add(Settings.PARTICLES_VOID.option)
            .add(Settings.PARTICLES_ENC_TABLE.option)
-        .build());
+            .build());
        return new OptionPage(I18n.format("options.button.particle"), ImmutableList.copyOf(groups));
    }

@@ -274,11 +286,11 @@ public class NotFineGameOptionPages {
                .setBinding((opts, value) -> opts.showCape = value, opts -> opts.showCape)
                .build())
            .add(Settings.MODE_GUI_BACKGROUND.option)
-        .build());
+            .build());

        groups.add(OptionGroup.createBuilder()
            .add(Settings.GUI_BACKGROUND.option)
-        .build());
+            .build());

        groups.add(OptionGroup.createBuilder()
            .add(OptionImpl.createBuilder(boolean.class, sodiumOpts)
@@ -25,7 +25,7 @@ public class CyclingControlElement<T extends Enum<T>> extends NotFineControlElem
    @Override
    public String getLabel() {
        Enum<T> value = option.getValue();
-        return super.getLabel() + names[value.ordinal()];
+        return super.getLabel() + formatValue(names[value.ordinal()]);
    }

    @Override
@@ -1,6 +1,7 @@
 package jss.notfine.gui.options.control.element;

 import jss.notfine.gui.GuiCustomMenu;
+import me.jellysquid.mods.sodium.client.gui.SodiumGameOptions;
 import me.jellysquid.mods.sodium.client.gui.options.Option;
 import me.jellysquid.mods.sodium.client.gui.options.OptionFlag;
 import me.jellysquid.mods.sodium.client.gui.options.control.ControlElement;
@@ -22,6 +23,10 @@ public class NotFineControlElement<T> extends GuiButton implements ControlElemen
        enabled = option.isAvailable();
    }

+    private static String disabledStyle() {
+        return String.valueOf(EnumChatFormatting.GRAY) + EnumChatFormatting.STRIKETHROUGH;
+    }
+
    @Override
    public void drawButton(Minecraft mc, int mouseX, int mouseY) {
        displayString = getLabel();
@@ -34,7 +39,9 @@ public class NotFineControlElement<T> extends GuiButton implements ControlElemen
        String name = option.getName();
        String label;
        enabled = option.isAvailable();
-        if(enabled && option.hasChanged()) {
+        if (!enabled) {
+            label = disabledStyle() + name;
+        } else if (option.hasChanged()) {
            label = EnumChatFormatting.ITALIC + name;
        } else {
            label = name;
@@ -43,17 +50,20 @@ public class NotFineControlElement<T> extends GuiButton implements ControlElemen
        return label;
    }

+    protected String formatValue(String value) {
+        return option.isAvailable() ? value : disabledStyle() + value;
+    }
+
    protected void onOptionValueChanged() {
        option.applyChanges();

        Collection<OptionFlag> flags = option.getFlags();
        Minecraft mc = Minecraft.getMinecraft();
-        if(flags.contains(OptionFlag.REQUIRES_RENDERER_RELOAD)) {
-            mc.renderGlobal.loadRenderers();
-        }
-        if(flags.contains(OptionFlag.REQUIRES_ASSET_RELOAD)) {
-            mc.getTextureMapBlocks().setMipmapLevels(mc.gameSettings.mipmapLevels);
+        if (flags.contains(OptionFlag.REQUIRES_ASSET_RELOAD)) {
+            SodiumGameOptions.applyAtlasSettings();
            mc.refreshResources();
+        } else if (flags.contains(OptionFlag.REQUIRES_RENDERER_RELOAD)) {
+            mc.renderGlobal.loadRenderers();
        }
        GuiCustomMenu.dirtyStorages.add(option.getStorage());
    }
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