Properly handle flags removed in core (#1965)

* Fix scrollbar not following mouse

* add /*deobfName*/

.github/PULL_REQUEST_TEMPLATE.md

@@ -0,0 +1,14 @@
+# 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? -->
+
+<!-- Add a screenshot or a video demonstration for new features -->
+
+<details open><summary>Template</summary> <!-- OPEN is intentional -->
+
+### Before submitting a *pull request* make sure you have:
+- [ ] Read the [AI Contribution Policy](https://github.com/GTNewHorizons/Angelica/blob/master/AI_POLICY.md)
+- [ ] At least [skimmed](https://github.com/GTNewHorizons/Angelica/search?q=is%3Apr&type=Issues) the tracker for similar pull requests
+
+</details>

.github/scripts/announce-release.sh

@@ -0,0 +1,40 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+: "${REPO:?REPO required}"
+: "${TAG:?TAG required}"
+
+if [ -z "${DISCORD_WEBHOOK_URL:-}" ]; then
+  echo "DISCORD_WEBHOOK_URL not set, skipping"
+  exit 0
+fi
+
+if ! release_json=$(gh release view "$TAG" --repo "$REPO" --json body,url,publishedAt 2>&1); then
+  echo "Could not read release $TAG in $REPO; skipping:"
+  printf '%s\n' "$release_json"
+  exit 0
+fi
+body=$(jq -r '.body // ""' <<<"$release_json")
+url=$(jq -r '.url' <<<"$release_json")
+ts=$(jq -r '.publishedAt // ""' <<<"$release_json")
+[ -n "$ts" ] || ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+payload=$(jq -n \
+  --arg title "$TAG" \
+  --arg url "$url" \
+  --arg desc "$body" \
+  --arg ts "$ts" \
+  '{
+    embeds: [{
+      title: ("Angelica " + $title + " released"),
+      url: $url,
+      description: (if ($desc | length) > 3900
+                    then $desc[0:3900] + "\n\n...[full changelog](" + $url + ")"
+                    else $desc end),
+      color: 3066993,
+      footer: { text: "GitHub Releases" },
+      timestamp: $ts
+    }]
+  }')
+
+curl -fsS -X POST -H "Content-Type: application/json" -d "$payload" "$DISCORD_WEBHOOK_URL"

.github/workflows/release-tags.yml

@@ -12,3 +12,22 @@ jobs:
   release-tags:
     uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/release-tags.yml@master
     secrets: inherit
+
+  notify-discord:
+    needs: [release-tags]
+    runs-on: ubuntu-24.04
+    if: >-
+      ${{ !endsWith(github.ref_name, '-snapshot')
+          && !contains(github.event.head_commit.message, '[snapshot]')
+          && !endsWith(github.ref_name, '-pre') }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+      - name: Announce release to Discord
+        shell: bash
+        env:
+          DISCORD_WEBHOOK_URL: ${{ secrets.DISCORD_RELEASE_WEBHOOK_URL }}
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          REPO: ${{ github.repository }}
+          TAG: ${{ github.ref_name }}
+        run: bash .github/scripts/announce-release.sh

.gitignore

@@ -12,6 +12,7 @@ build/
 /config/
 /crash-reports/
 /logs/
+tmp/
 options.txt
 /saves/
 usernamecache.json

AI_POLICY.md

@@ -0,0 +1,55 @@
+# AI Usage Policy
+
+This project has strict rules for AI usage:
+
+* **The human-in-the-loop must fully understand all code.** If you
+can't explain what your changes do and how they interact with the
+greater system without the aid of AI tools, do not contribute
+those changes.
+
+* **Issues and discussions can use AI assistance but must have a full
+human-in-the-loop.** This means that any content generated with AI
+must have been reviewed *and edited* by a human before submission.
+The author must do their research and trim this down.
+
+* **No AI-generated media is allowed (textures, videos, audio, etc.).**
+Text and code are the only acceptable AI-generated content, per the
+other rules in this policy.
+
+* **Commit messages, PR descriptions must read in your own voice.**
+No AI-authored or AI co-authored commits, including Co-authored-by AI tags.
+
+* **Only contribute fixes for bugs you have personally hit in-game.**
+If you haven’t experienced or reproduced a bug firsthand, and don’t
+already know the relevant code well, don’t throw AI at it and forward it to us.
+Patches written for problems the author never actually experienced themselves
+tend to fix the wrong thing and/or produce another.
+
+* **The voice and intent of written content must be yours.**
+For documentation and especially quests, the tone and the point you're trying to make
+has to come from you, not an AI. Use AI to help with phrasing or cleanup if you like,
+but if the substance and voice aren't yours, don't contribute it.
+
+* **Bad AI use may be blocked.** People who produce bad contributions
+that are clearly AI (slop) may be blocked from making future contributions.
+We love to help junior developers learn and grow, but if you're interested
+in that, don't use AI and we'll help you. We're sorry that bad AI
+users have ruined this for you.
+
+
+## There are Humans Here
+
+Please remember that this project is maintained by humans.
+
+Every discussion, issue, and pull request is read and reviewed by
+humans (and sometimes machines, too). It is a boundary point at which
+people interact with each other and work is done. It is rude and
+disrespectful to approach this boundary with low-effort, unqualified
+work, since it puts the burden of validation on the maintainer.
+
+In a perfect world, AI would produce high-quality, accurate work
+every time. But today, that reality depends on the user of the AI.
+And today, many users of AI do not use it well. So, until that
+changes, we need to have strict rules to protect maintainers.
+
+Based on https://github.com/ghostty-org/ghostty/blob/main/AI_POLICY.md

README.MD

@@ -23,7 +23,7 @@ Targets GL 3.3+ core profile
 
 # Required Dependencies
 * [UniMixins](https://github.com/LegacyModdingMC/UniMixins/releases) >= 0.1.23
-* [GTNHLib](https://github.com/GTNewHorizons/GTNHLib/releases) >= 0.9.0
+* [GTNHLib](https://github.com/GTNewHorizons/GTNHLib/releases) >= 0.11.19
 * NOTE: Some mods are not required, but a specific version is required if present - see: `Permanent Incompatibilities` below.
 
 # Known (temporary) Incompatibilities

dependencies.gradle

@@ -76,27 +76,31 @@ dependencies {
 
     // Iris Shaders
     compileOnly('org.jetbrains:annotations:26.0.2')
-    api("com.github.GTNewHorizons:GTNHLib:0.11.4:dev")
+    api("com.github.GTNewHorizons:GTNHLib:0.11.19:dev")
 
     shadowImplementation(project(":glsm")) { transitive = false }
     shadowImplementation(project(":lwjgl3-backend")) { transitive = false }
     shadowImplementation("net.minecraftforge:eventbus:7.0-beta.15")
 
     shadowImplementation("org.anarres:jcpp:1.4.14") // Apache 2.0
-    shadowImplementation("org.taumc:glsl-transformation-lib:0.2.0-32.g7dd88a4-GTNH") {
+    shadowImplementation("org.taumc:glsl-transformation-lib:0.2.0-33.g3ec381e") {
         exclude module: "antlr4" // we only want to shadow the runtime module
     }
     shadowImplementation("org.antlr:antlr4-runtime:4.13.2")
     compileOnly "org.apache.ant:ant:1.8.2"
 
     // Celeritas (transitive=false: deps provided by GTNHLib/runtime)
-    embedOnly("org.embeddedt.celeritas:celeritas-common:2.5.4-GTNH") { transitive = false }
+    embedOnly("org.embeddedt.celeritas:celeritas-common:2.5.8-GTNH") { transitive = false }
     embedOnly("org.embeddedt.celeritas:celeritas-lwjgl2-service:2.5.3-GTNH") { transitive = false }
 
     // Because who doesn't want NEI
     devOnlyNonPublishable('com.github.GTNewHorizons:NotEnoughItems:2.8.35-GTNH:dev')
     devOnlyNonPublishable('com.github.GTNewHorizons:CodeChickenCore:1.4.7:dev')
 
+    // BQ Testing
+//    devOnlyNonPublishable("com.github.GTNewHorizons:BetterQuesting:3.8.74-GTNH:dev")
+
+
     // Display List Testing
     /*
     runtimeOnlyNonPublishable("com.github.GTNewHorizons:Applied-Energistics-2-Unofficial:rv3-beta-749-GTNH:dev")
@@ -144,7 +148,7 @@ dependencies {
     compileOnly(rfg.deobf("curse.maven:campfirebackport-387444:4611675"))
     compileOnly(rfg.deobf("curse.maven:xaeros-minimap-263420:5060684"))
     compileOnly(rfg.deobf("curse.maven:security-craft-64760:2818228"))
-    compileOnly(rfg.deobf("curse.maven:et-futurum-requiem-441392:5873837"))
+    compileOnly("ganymedes01.etfuturum:Et-Futurum-Requiem:2.6.49-GTNH:dev")
     compileOnly(rfg.deobf("curse.maven:biomes-o-plenty-220318:2499612"))
 
     devOnlyNonPublishable("com.github.GTNewHorizons:CosmeticArmorReworked:1.0.3-GTNH:dev")
@@ -173,8 +177,13 @@ dependencies {
             testImplementation('org.junit.platform:junit-platform-launcher')
 
             testImplementation('com.tngtech.archunit:archunit-junit5:1.4.1')
+
+            testRuntimeOnly("it.unimi.dsi:fastutil:8.5.18")
+            testRuntimeOnly("org.joml:joml:1.10.8")
         }
     }
 
     compileOnly("mega:fluidlogged-mc1.7.10:0.1.2")
+
+    compileOnly("com.cardinalstar.cubicchunks:CubicChunks1710:v0.1.5-alpha:dev") { transitive = false }
 }

glsm/build.gradle.kts

@@ -96,6 +96,8 @@ dependencies {
     // Deps (normally from MC) - compile only, but needed at test runtime
     compileOnly("com.google.guava:guava:${property("guavaVersion")}")
     testRuntimeOnly("com.google.guava:guava:${property("guavaVersion")}")
+    testRuntimeOnly("it.unimi.dsi:fastutil:${property("fastutilVersion")}")
+    testRuntimeOnly("org.joml:joml:${property("jomlVersion")}") { isTransitive = false }
 
     // Test
     testImplementation(sourceSets["stubs"].output)
@@ -144,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")
@@ -169,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) }
 

glsm/gradle.properties

@@ -1,10 +1,12 @@
 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
-gtnhlibVersion = 0.10.0
+gtnhlibVersion = 0.11.19
+fastutilVersion = 8.5.18
+jomlVersion = 1.10.8
 glslTransformLibVersion = 0.2.0-26.g5ee7d96-GTNH
 antlr4RuntimeVersion = 4.13.2
 jcppVersion = 1.4.14

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

@@ -1,5 +1,10 @@
 package com.gtnewhorizons.angelica.glsm;
 
+import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement.Usage;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.TerminalNode;
+import org.taumc.glsl.grammar.GLSLLexer;
+import org.taumc.glsl.grammar.GLSLParser;
 import org.taumc.glsl.ShaderParser;
 import org.taumc.glsl.Transformer;
 
@@ -8,9 +13,11 @@ import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.LinkedHashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -182,8 +189,9 @@ public class CompatShaderTransformer {
             transformer.rename("gl_FrontColor", "angelica_FrontColor");
             transformer.prependMain("angelica_FrontColor = vec4(1.0);");
 
-            // Vertex attributes — replaces removed FFP vertex inputs with explicit in declarations
-            transformVertexAttributes(transformer, source);
+            final FFPInputs ffp = FFPInputs.detect(source);
+            assignVertexInputLocations(transformer, ffp);
+            transformVertexAttributes(transformer, source, ffp);
         } else {
             if (source.contains("gl_Color")) {
                 transformer.injectVariable("in vec4 angelica_FrontColor;");
@@ -310,25 +318,25 @@ public class CompatShaderTransformer {
     /**
      * Replace removed FFP vertex attributes with explicit {@code in} declarations at core profile attribute locations.
      */
-    private static void transformVertexAttributes(Transformer transformer, String source) {
-        if (source.contains("gl_Vertex") || source.contains("ftransform")) {
+    private static void transformVertexAttributes(Transformer transformer, String source, FFPInputs ffp) {
+        if (ffp.position()) {
             transformer.injectVariable("layout(location = 0) in vec4 angelica_Vertex;");
             transformer.rename("gl_Vertex", "angelica_Vertex");
         }
         // gl_Color in vertex shaders is the per-vertex color attribute, distinct from the fragment gl_Color (interpolated gl_FrontColor) handled above
-        if (source.contains("gl_Color")) {
+        if (ffp.color()) {
             transformer.injectVariable("layout(location = 1) in vec4 angelica_Color;");
             transformer.rename("gl_Color", "angelica_Color");
         }
-        if (source.contains("gl_MultiTexCoord0")) {
+        if (ffp.uv0()) {
             transformer.injectVariable("layout(location = 2) in vec4 angelica_MultiTexCoord0;");
             transformer.rename("gl_MultiTexCoord0", "angelica_MultiTexCoord0");
         }
-        if (source.contains("gl_MultiTexCoord1")) {
+        if (ffp.uv1()) {
             transformer.injectVariable("layout(location = 3) in vec4 angelica_MultiTexCoord1;");
             transformer.rename("gl_MultiTexCoord1", "angelica_MultiTexCoord1");
         }
-        if (source.contains("gl_Normal")) {
+        if (ffp.normal()) {
             transformer.injectVariable("layout(location = 4) in vec3 angelica_Normal;");
             transformer.rename("gl_Normal", "angelica_Normal");
         }
@@ -337,6 +345,145 @@ public class CompatShaderTransformer {
         }
     }
 
+    private static final int MAX_VERTEX_ATTRIBS = 16;
+
+    private record FFPInputs(boolean position, boolean color, boolean uv0, boolean uv1, boolean normal) {
+        static FFPInputs detect(String source) {
+            return new FFPInputs(
+                source.contains("gl_Vertex") || source.contains("ftransform"),
+                source.contains("gl_Color"),
+                source.contains("gl_MultiTexCoord0"),
+                source.contains("gl_MultiTexCoord1"),
+                source.contains("gl_Normal"));
+        }
+    }
+
+    /** Adaptation of Mesa's assign_attribute_or_color_locations */
+    private static void assignVertexInputLocations(Transformer transformer, FFPInputs ffp) {
+        int used = 0;
+        if (ffp.position()) used |= 1 << Usage.POSITION.getAttributeLocation();
+        if (ffp.color()) used |= 1 << Usage.COLOR.getAttributeLocation();
+        if (ffp.uv0()) used |= 1 << Usage.PRIMARY_UV.getAttributeLocation();
+        if (ffp.uv1()) used |= 1 << Usage.SECONDARY_UV.getAttributeLocation();
+        if (ffp.normal()) used |= 1 << Usage.NORMAL.getAttributeLocation();
+
+        record Input(String name, String baseType, String arraySuffix, int slots, int index) {}
+        final List<Input> toAssign = new ArrayList<>();
+        int index = 0;
+
+        for (TerminalNode storage : transformer.collectStorage()) {
+            final int tokenType = storage.getSymbol().getType();
+            if (tokenType != GLSLLexer.ATTRIBUTE && tokenType != GLSLLexer.IN) continue;
+
+            ParseTree node = storage.getParent();
+            while (node != null && !(node instanceof GLSLParser.Single_declarationContext)) {
+                node = node.getParent();
+            }
+            if (!(node instanceof GLSLParser.Single_declarationContext decl)) continue;
+            if (decl.typeless_declaration() == null) continue;
+
+            final GLSLParser.Type_specifierContext typeSpec = decl.fully_specified_type().type_specifier();
+            final String baseType = GlslTransformUtils.getFormattedShader(typeSpec.type_specifier_nonarray(), "").trim();
+            final int typeArraySlots = arraySlots(typeSpec.array_specifier());
+            final String typeArray = arraySuffix(typeSpec.array_specifier());
+
+            if (hasLayoutQualifier(decl)) {
+                final int loc = explicitLocation(decl);
+                final int slots = baseSlots(baseType) * typeArraySlots * arraySlots(decl.typeless_declaration().array_specifier());
+                if (loc >= 0) used |= slotMask(slots) << loc;
+                continue;
+            }
+
+            final List<GLSLParser.Typeless_declarationContext> declarators = new ArrayList<>();
+            declarators.add(decl.typeless_declaration());
+            if (decl.getParent() instanceof GLSLParser.Init_declarator_listContext list) {
+                declarators.addAll(list.typeless_declaration());
+            }
+            for (GLSLParser.Typeless_declarationContext d : declarators) {
+                if (d.IDENTIFIER() == null) continue;
+                final int slots = baseSlots(baseType) * typeArraySlots * arraySlots(d.array_specifier());
+                final String arraySuffix = typeArray + arraySuffix(d.array_specifier());
+                toAssign.add(new Input(d.IDENTIFIER().getText(), baseType, arraySuffix, slots, index++));
+            }
+        }
+
+        toAssign.sort((a, b) -> a.slots() != b.slots() ? b.slots() - a.slots() : a.index() - b.index());
+
+        for (Input in : toAssign) {
+            final int loc = findAvailableSlots(used, in.slots());
+            if (loc < 0) continue;
+            used |= slotMask(in.slots()) << loc;
+            transformer.removeVariable(in.name());
+            transformer.variable = null;
+            transformer.injectVariable("layout(location = " + loc + ") in " + in.baseType() + " " + in.name() + in.arraySuffix() + ";");
+        }
+    }
+
+    private static String arraySuffix(GLSLParser.Array_specifierContext arraySpec) {
+        return arraySpec != null ? GlslTransformUtils.getFormattedShader(arraySpec, "").trim() : "";
+    }
+
+    private static int arraySlots(GLSLParser.Array_specifierContext arraySpec) {
+        if (arraySpec == null) return 1;
+        int product = 1;
+        for (GLSLParser.DimensionContext dim : arraySpec.dimension()) {
+            if (dim.constant_expression() == null) continue;
+            try {
+                product *= Integer.decode(GlslTransformUtils.getFormattedShader(dim.constant_expression(), "").trim());
+            } catch (NumberFormatException ignored) {}
+        }
+        return product;
+    }
+
+    private static int baseSlots(String type) {
+        final String dims = type.startsWith("dmat") ? type.substring(4) : type.startsWith("mat") ? type.substring(3) : null;
+        if (dims != null && !dims.isEmpty() && Character.isDigit(dims.charAt(0))) {
+            return dims.charAt(0) - '0';
+        }
+        return 1;
+    }
+
+    private static int slotMask(int slots) {
+        return (slots >= 32) ? -1 : (1 << slots) - 1;
+    }
+
+    private static int findAvailableSlots(int used, int needed) {
+        if (needed <= 0) return -1;
+        final int mask = slotMask(needed);
+        for (int i = 0; i <= MAX_VERTEX_ATTRIBS - needed; i++) {
+            if (((mask << i) & ~used) == (mask << i)) return i;
+        }
+        return -1;
+    }
+
+    private static int explicitLocation(GLSLParser.Single_declarationContext decl) {
+        final GLSLParser.Type_qualifierContext qualifier = decl.fully_specified_type().type_qualifier();
+        if (qualifier == null) return -1;
+        for (GLSLParser.Single_type_qualifierContext single : qualifier.single_type_qualifier()) {
+            final GLSLParser.Layout_qualifierContext layout = single.layout_qualifier();
+            if (layout == null) continue;
+            for (GLSLParser.Layout_qualifier_idContext id : layout.layout_qualifier_id_list().layout_qualifier_id()) {
+                if (id.IDENTIFIER() != null && "location".equals(id.IDENTIFIER().getText()) && id.constant_expression() != null) {
+                    try {
+                        return Integer.decode(GlslTransformUtils.getFormattedShader(id.constant_expression(), "").trim());
+                    } catch (NumberFormatException ignored) {
+                        return -1;
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+
+    private static boolean hasLayoutQualifier(GLSLParser.Single_declarationContext decl) {
+        final GLSLParser.Type_qualifierContext qualifier = decl.fully_specified_type().type_qualifier();
+        if (qualifier == null) return false;
+        for (GLSLParser.Single_type_qualifierContext single : qualifier.single_type_qualifier()) {
+            if (single.layout_qualifier() != null) return true;
+        }
+        return false;
+    }
+
     private static void dumpShader(String original, String transformed, boolean isFragment, boolean wasTransformed) {
         if (DUMP_DIR == null) return;
         final int id = dumpCounter.getAndIncrement();

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

@@ -59,7 +59,10 @@ public class CompatUniformManager {
     static final int MAT_FIELDS = 5;
     static final int LOC_MAT_BASE = LOC_LIGHT_BASE + 2 * LIGHT_FIELDS; // 43
 
-    static final int LOC_COUNT = LOC_MAT_BASE + MAT_FIELDS; // 48
+    static final int LOC_IRIS_MODELVIEW_INVERSE = LOC_MAT_BASE + MAT_FIELDS; // 48
+    static final int LOC_IRIS_PROJECTION_INVERSE = LOC_IRIS_MODELVIEW_INVERSE + 1; // 49
+
+    static final int LOC_COUNT = LOC_IRIS_PROJECTION_INVERSE + 1; // 50
 
     private static final String[] LIGHT_FIELD_NAMES = {
         "ambient", "diffuse", "specular", "position", "halfVector",
@@ -89,6 +92,8 @@ public class CompatUniformManager {
         UNIFORM_NAMES[LOC_IRIS_NORMAL] = "iris_NormalMatrix";
         UNIFORM_NAMES[LOC_IRIS_LIGHTMAP_TEXTURE_MATRIX] = "iris_LightmapTextureMatrix";
         UNIFORM_NAMES[LOC_IRIS_TEXTURE_MATRIX] = "iris_TextureMatrix";
+        UNIFORM_NAMES[LOC_IRIS_MODELVIEW_INVERSE] = "iris_ModelViewMatrixInverse";
+        UNIFORM_NAMES[LOC_IRIS_PROJECTION_INVERSE] = "iris_ProjectionMatrixInverse";
         UNIFORM_NAMES[LOC_ALPHA_TEST_REF] = "angelica_currentAlphaTest";
         UNIFORM_NAMES[LOC_SCENE_COLOR] = "angelica_SceneColor";
         UNIFORM_NAMES[LOC_CLIP_PLANES] = "angelica_ClipPlane[0]";
@@ -229,10 +234,15 @@ public class CompatUniformManager {
             }
 
             // ModelView Inverse
-            if (locs[LOC_MODELVIEW_INVERSE] != -1) {
+            if (locs[LOC_MODELVIEW_INVERSE] != -1 || locs[LOC_IRIS_MODELVIEW_INVERSE] != -1) {
                 mv.invert(scratchMatrix);
                 scratchMatrix.get(mat4Buf);
-                RENDER_BACKEND.uniformMatrix4(locs[LOC_MODELVIEW_INVERSE], false, mat4Buf);
+                if (locs[LOC_MODELVIEW_INVERSE] != -1) {
+                    RENDER_BACKEND.uniformMatrix4(locs[LOC_MODELVIEW_INVERSE], false, mat4Buf);
+                }
+                if (locs[LOC_IRIS_MODELVIEW_INVERSE] != -1) {
+                    RENDER_BACKEND.uniformMatrix4(locs[LOC_IRIS_MODELVIEW_INVERSE], false, mat4Buf);
+                }
             }
         }
 
@@ -266,10 +276,15 @@ public class CompatUniformManager {
             }
 
             // Projection Inverse
-            if (locs[LOC_PROJECTION_INVERSE] != -1) {
+            if (locs[LOC_PROJECTION_INVERSE] != -1 || locs[LOC_IRIS_PROJECTION_INVERSE] != -1) {
                 proj.invert(scratchMatrix);
                 scratchMatrix.get(mat4Buf);
-                RENDER_BACKEND.uniformMatrix4(locs[LOC_PROJECTION_INVERSE], false, mat4Buf);
+                if (locs[LOC_PROJECTION_INVERSE] != -1) {
+                    RENDER_BACKEND.uniformMatrix4(locs[LOC_PROJECTION_INVERSE], false, mat4Buf);
+                }
+                if (locs[LOC_IRIS_PROJECTION_INVERSE] != -1) {
+                    RENDER_BACKEND.uniformMatrix4(locs[LOC_IRIS_PROJECTION_INVERSE], false, mat4Buf);
+                }
             }
         }
 

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

@@ -111,6 +111,7 @@ public class DisplayListManager {
         int listMode,
         CommandRecorder recorder,
         List<AccumulatedDraw> draws,
+        DisplayListCallback callback,
         StackTraceElement[] stackTrace,
 
         // Debug logging fields (only used when LOG_DISPLAY_LIST_COMPILATION)
@@ -131,6 +132,22 @@ public class DisplayListManager {
         return currentRecorder != null && Thread.currentThread() == recordingThread;
     }
 
+    public static UnsupportedOperationException unsupportedInList(String what) {
+        final UnsupportedOperationException e = new UnsupportedOperationException( what + " in display lists not yet implemented - if you see this, please report! " + describeCurrentCompilation());
+        GLStateManager.warnOnce("unsupported:" + what, "Aborting display list {} compilation: {} unsupported during recording", glListId, what);
+        abortCompilation();
+        return e;
+    }
+
+    public static String describeCurrentCompilation() {
+        if (currentRecorder == null) {
+            return "(not compiling)";
+        }
+        final String mode = glListMode == GL11.GL_COMPILE_AND_EXECUTE ? "GL_COMPILE_AND_EXECUTE" : "GL_COMPILE";
+        final int depth = compilationStack.size() + 1;
+        return "while compiling display list " + glListId + " (" + mode + (depth > 1 ? ", nesting depth " + depth : "") + ")";
+    }
+
     public static boolean isCompileAndExecute() {
         return glListMode == GL11.GL_COMPILE_AND_EXECUTE;
     }
@@ -159,7 +176,9 @@ public class DisplayListManager {
      * Only use this if you are 100% that the transforms will not be of any use after the display list draw call.
      */
     public static void discardMatrixTransforms() {
-        resetRelativeTransform();
+        if (isRecording()) {
+            resetRelativeTransform();
+        }
     }
 
     /**
@@ -748,7 +767,7 @@ public class DisplayListManager {
             // Nested display list compilation violates OpenGL spec, but some of our optimizations require it
             // Save current compilation context and start fresh for nested list
             final CompilationContext parentContext = new CompilationContext(
-                glListId, glListMode, currentRecorder, accumulatedDraws,
+                glListId, glListMode, currentRecorder, accumulatedDraws, transformCallback,
                 compilationStackTrace, pendingTransformOps, multMatrixSources, drawRangeSources
             );
             compilationStack.push(parentContext);
@@ -782,11 +801,24 @@ public class DisplayListManager {
      */
     public static void glEndList() {
         if (glListMode == 0) {
-            throw new RuntimeException("glEndList called outside of a display list!");
+            GLStateManager.warnOnce("endlist-outside", "glEndList called outside of a display list!");
+            return;
         }
+        try {
+            finishCurrentList();
+        } finally {
+            // Non-null here means finishCurrentList threw before transferring or releasing
+            // ownership of the recorder.
+            if (currentRecorder != null) {
+                currentRecorder.delete();
+            }
+            // Must always run, even when compilation fails - a leaked context leaves
+            // isRecording() true forever and every guarded GL call throws afterward.
+            popCompilationContext();
+        }
+    }
 
-        final boolean isNested = !compilationStack.isEmpty();
-
+    private static void finishCurrentList() {
         // Stop compiling mode (works for both root and nested lists now)
         TessellatorManager.stopCapturingDirect();
 
@@ -803,8 +835,9 @@ public class DisplayListManager {
         final boolean hasCommands = !commandBuffer.isEmpty();
 
         if (hasCommands) {
-            final DisplayListVBO compiledBuffers = new DisplayListVBOBuilder().addDraws(accumulatedDraws).build();
+            DisplayListVBO compiledBuffers = null;
             try {
+                compiledBuffers = new DisplayListVBOBuilder().addDraws(accumulatedDraws).build();
                 final IndexedDrawBatchBuilder indexedBuilder = commandBuffer.getIndexedDraws();
                 final List<IndexedDrawBatch> indexedBatches;
                 if (indexedBuilder.isEmpty()) {
@@ -824,28 +857,44 @@ public class DisplayListManager {
                     }
                 }
 
-                compiled = new CompiledDisplayList(commandBuffer.finish(), commandBuffer.getComplexObjects(), compiledBuffers, indexedBatches);
+                final DisplayListCommand[] complexObjects = commandBuffer.getComplexObjects();
+                compiled = new CompiledDisplayList(commandBuffer.finish(), complexObjects, compiledBuffers, indexedBatches);
+                currentRecorder = null;
             } catch (Exception e) {
                 GLStateManager.LOGGER.error("Encountered a fatal issue while trying to compile a display list.");
                 e.printStackTrace();
                 commandBuffer.delete();
+                currentRecorder = null;
+                if (compiledBuffers != null) {
+                    compiledBuffers.delete();
+                }
                 return;
             }
         } else {
             // Free the recorder even if empty
             commandBuffer.delete();
+            currentRecorder = null;
             // 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)
         if (LOG_DISPLAY_LIST_COMPILATION) {
             logCompiledDisplayList(glListId, compiled, compilationStackTrace);
         }
+    }
+
+    private static void popCompilationContext() {
+        final boolean isNested = !compilationStack.isEmpty();
 
         // Handle nested compilation - restore parent context
         if (isNested) {
@@ -856,6 +905,7 @@ public class DisplayListManager {
             glListMode = parentContext.listMode;
             currentRecorder = parentContext.recorder;
             accumulatedDraws = parentContext.draws;
+            transformCallback = parentContext.callback;
             compilationStackTrace = parentContext.stackTrace;
             pendingTransformOps = parentContext.pendingOps;
             multMatrixSources = parentContext.matrixSources;
@@ -865,16 +915,56 @@ public class DisplayListManager {
             // Parent's COMPILING callback is now active again
         } else {
             // Not nested - clear all compilation state
-            currentRecorder = null;
-            recordingThread = null;
-            accumulatedDraws = null;
-            pendingDraw = null;
-            compilationStackTrace = null;
-            pendingTransformOps = null;
-            multMatrixSources = null;
-            drawRangeSources = null;
-            glListId = -1;
-            glListMode = 0;
+            resetCompilationState();
+        }
+    }
+
+    /** Clear all root-level compilation state back to "not recording". */
+    private static void resetCompilationState() {
+        currentRecorder = null;
+        recordingThread = null;
+        accumulatedDraws = null;
+        pendingDraw = null;
+        transformCallback = null;
+        compilationStackTrace = null;
+        pendingTransformOps = null;
+        multMatrixSources = null;
+        drawRangeSources = null;
+        glListId = -1;
+        glListMode = 0;
+    }
+
+    public static void abortCompilation() {
+        if (glListMode == 0 && compilationStack.isEmpty()) {
+            return;
+        }
+
+        final int levels = compilationStack.size() + (glListMode != 0 ? 1 : 0);
+        for (int i = 0; i < levels; i++) {
+            try {
+                TessellatorManager.stopCapturingDirect();
+            } catch (IllegalStateException ignored) {
+                break;
+            }
+        }
+
+        if (currentRecorder != null) {
+            currentRecorder.delete();
+        }
+        for (CompilationContext ctx : compilationStack) {
+            if (ctx.recorder() != null) {
+                ctx.recorder().delete();
+            }
+        }
+        compilationStack.clear();
+
+        resetCompilationState();
+    }
+
+    public static void abortIfLeaked() {
+        if (glListMode != 0 || !compilationStack.isEmpty()) {
+            GLStateManager.warnOnce("frame-leak", "Display list {} left open across a frame boundary - aborting to recover", glListId);
+            abortCompilation();
         }
     }
 
@@ -927,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();
         }
     }
 

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

@@ -1,7 +1,7 @@
 package com.gtnewhorizons.angelica.glsm;
 
+import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
 import com.gtnewhorizons.angelica.glsm.recording.ImmediateModeRecorder;
-import com.gtnewhorizons.angelica.glsm.states.VertexAttribState;
 import com.gtnewhorizons.angelica.glsm.states.ViewportState;
 import org.joml.Matrix4f;
 import org.joml.Vector4f;
@@ -9,13 +9,13 @@ import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL15;
 
 import java.nio.ByteBuffer;
-
-import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
 import java.nio.ByteOrder;
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 import java.nio.ShortBuffer;
 
+import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
+
 /**
  * Software emulation of GL feedback mode
  */
@@ -127,12 +127,12 @@ public class FeedbackManager {
     }
 
     private static int positionStride() {
-        final int s = VertexAttribState.get(0).effectiveStride();
+        final int s = VAOManager.getAttribEffectiveStride(0);
         return (s != 0) ? s : 12;
     }
 
     private static long positionOffset() {
-        return VertexAttribState.get(0).offset;
+        return VAOManager.getAttribOffset(0);
     }
 
     public static void processDrawArrays(int mode, int first, int count) {
@@ -151,7 +151,7 @@ public class FeedbackManager {
         computeMVP();
         final int stride = positionStride();
 
-        final int elementSize = VertexAttribState.Attrib.glTypeSizeBytes(type);
+        final int elementSize = VAOManager.Attrib.glTypeSizeBytes(type);
         final int indexByteCount = indexCount * elementSize;
         ensureIndexReadbackCapacity(indexByteCount);
         indexReadbackBuf.clear().limit(indexByteCount);
@@ -255,7 +255,7 @@ public class FeedbackManager {
     }
 
     private static void readPositionBuffer(long offset, ByteBuffer destination) {
-        final int positionVbo = VertexAttribState.get(0).vboId;
+        final int positionVbo = VAOManager.getAttribVBO(0);
         final int previousVbo = GLStateManager.getBoundVBO();
 
         if (positionVbo != 0 && positionVbo != previousVbo) {

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

@@ -1,6 +1,6 @@
 package com.gtnewhorizons.angelica.glsm;
 
-import com.gtnewhorizons.angelica.glsm.states.VertexAttribState;
+import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL15;
 
@@ -9,7 +9,6 @@ import java.nio.IntBuffer;
 import java.nio.ShortBuffer;
 
 import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAddress0;
-import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
 import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAlloc;
 import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree;
 import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetByte;
@@ -17,6 +16,7 @@ import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt;
 import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetShort;
 import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutInt;
 import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutShort;
+import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
 
 /**
  * Shared quad-to-triangle EBO for core profile GL_QUADS emulation.
@@ -83,16 +83,34 @@ public final class QuadConverter {
      * @param vertexCount number of vertices (must be multiple of 4)
      */
     public static void drawQuadsAsTriangles(int first, int vertexCount) {
-        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;
-        RENDER_BACKEND.drawElements(GL11.GL_TRIANGLES, quadCount * 6, INDEX_TYPE, indexOffset);
-        RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEbo);
+        drawSharedQuadEbo(first, vertexCount, 1, false);
+    }
+
+    public static void drawQuadsAsTrianglesInstanced(int first, int vertexCount, int primcount) {
+        drawSharedQuadEbo(first, vertexCount, primcount, true);
+    }
+
+    private static void drawSharedQuadEbo(int first, int vertexCount, int primcount, boolean instanced) {
+        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();
+        }
     }
 
     /**
@@ -106,27 +124,41 @@ public final class QuadConverter {
      * @param bytesPerIndex  bytes per index element
      */
     private static void uploadAndDraw(ByteBuffer dst, int triIndexCount, int indexType, int bytesPerIndex) {
-        final int needed = triIndexCount * bytesPerIndex;
-        final int prevEbo = GLStateManager.getBoundEBO();
+        uploadAndDraw(dst, triIndexCount, indexType, bytesPerIndex, 1, false);
+    }
 
-        if (scratchEboId == 0) {
-            scratchEboId = RENDER_BACKEND.genBuffers();
+    private static void uploadAndDraw(ByteBuffer dst, int triIndexCount, int indexType, int bytesPerIndex, int primcount, boolean instanced) {
+        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();
+            }
+
+            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);
-
-        RENDER_BACKEND.drawElements(GL11.GL_TRIANGLES, triIndexCount, indexType, 0L);
-
-        RENDER_BACKEND.bindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEbo);
         memFree(dst);
     }
 
@@ -139,12 +171,20 @@ public final class QuadConverter {
      * @param offset     byte offset into the currently bound EBO
      */
     public static void drawQuadElementsAsTriangles(int indexCount, int type, long offset) {
+        drawQuadElementsFromEbo(indexCount, type, offset, 1, false);
+    }
+
+    public static void drawQuadElementsAsTrianglesInstanced(int indexCount, int type, long offset, int primcount) {
+        drawQuadElementsFromEbo(indexCount, type, offset, primcount, true);
+    }
+
+    private static void drawQuadElementsFromEbo(int indexCount, int type, long offset, int primcount, boolean instanced) {
         if (indexCount == 0) return;
         assert indexCount % 4 == 0 : "QuadConverter: indexCount must be multiple of 4";
         final int quadCount = indexCount / 4;
         final int triIndexCount = quadCount * 6;
 
-        final int bytesPerIndex = VertexAttribState.Attrib.glTypeSizeBytes(type);
+        final int bytesPerIndex = VAOManager.Attrib.glTypeSizeBytes(type);
 
         final ByteBuffer src = memAlloc(indexCount * bytesPerIndex);
         RENDER_BACKEND.getBufferSubData(GL15.GL_ELEMENT_ARRAY_BUFFER, offset, src);
@@ -153,7 +193,7 @@ public final class QuadConverter {
         triangulateQuads(memAddress0(src), type, memAddress0(dst), GL11.GL_UNSIGNED_INT, quadCount);
 
         memFree(src);
-        uploadAndDraw(dst, triIndexCount, GL11.GL_UNSIGNED_INT, 4);
+        uploadAndDraw(dst, triIndexCount, GL11.GL_UNSIGNED_INT, 4, primcount, instanced);
     }
 
     /**

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

@@ -7,7 +7,6 @@ import com.gtnewhorizons.angelica.glsm.dsa.DSACore;
 import com.gtnewhorizons.angelica.glsm.dsa.DSAEXT;
 import com.gtnewhorizons.angelica.glsm.dsa.DSAUnsupported;
 import com.gtnewhorizons.angelica.glsm.ffp.ShaderManager;
-import com.gtnewhorizons.angelica.glsm.hooks.GLSMInitConfig;
 import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
@@ -147,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.");
             }
         }
 
@@ -302,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) {
@@ -448,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) {
@@ -456,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) {
@@ -550,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()) {
@@ -562,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;
+    }
 }

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/backend/Lwjgl2GLRenderBackend.java

@@ -310,6 +310,16 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
         GL31.glDrawElementsInstanced(mode, count, type, indices, primcount);
     }
 
+    @Override
+    public void drawArraysInstanced(int mode, int first, int count, int primcount) {
+        GL31.glDrawArraysInstanced(mode, first, count, primcount);
+    }
+
+    @Override
+    public void provokingVertex(int provokeMode) {
+        GL32.glProvokingVertex(provokeMode);
+    }
+
     @Override
     public void multiDrawElementsIndirect(int mode, int type, long indirect, int drawcount, int stride) {
         org.lwjgl.opengl.GL43.glMultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
@@ -317,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
@@ -507,11 +517,6 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
         GL11.glPixelStorei(pname, param);
     }
 
-    @Override
-    public void pixelStoref(int pname, float param) {
-        GL11.glPixelStoref(pname, param);
-    }
-
     @Override
     public void sampleCoverage(float value, boolean invert) {
         GL13.glSampleCoverage(value, invert);
@@ -617,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);
@@ -817,6 +827,11 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
         GL20.glUniform4i(location, v0, v1, v2, v3);
     }
 
+    @Override
+    public void uniform2(int location, FloatBuffer value) {
+        GL20.glUniform2(location, value);
+    }
+
     @Override
     public void uniform3(int location, FloatBuffer value) {
         GL20.glUniform3(location, value);
@@ -827,6 +842,26 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
         GL20.glUniform4(location, value);
     }
 
+    @Override
+    public void uniform1iv(int location, IntBuffer value) {
+        GL20.glUniform1(location, value);
+    }
+
+    @Override
+    public void uniform2iv(int location, IntBuffer value) {
+        GL20.glUniform2(location, value);
+    }
+
+    @Override
+    public void uniform3iv(int location, IntBuffer value) {
+        GL20.glUniform3(location, value);
+    }
+
+    @Override
+    public void uniform4iv(int location, IntBuffer value) {
+        GL20.glUniform4(location, value);
+    }
+
     @Override
     public void uniformMatrix3(int location, boolean transpose, FloatBuffer value) {
         GL20.glUniformMatrix3(location, transpose, value);
@@ -1028,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();
@@ -1043,6 +1083,11 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
         GL30.glBindVertexArray(array);
     }
 
+    @Override
+    public boolean isVertexArray(int array) {
+        return GL30.glIsVertexArray(array);
+    }
+
     @Override
     public void vertexAttribPointer(int index, int size, int type, boolean normalized, int stride, long pointer) {
         GL20.glVertexAttribPointer(index, size, type, normalized, stride, pointer);
@@ -1214,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);

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/backend/RenderBackend.java

@@ -8,6 +8,8 @@ import java.nio.DoubleBuffer;
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 import java.nio.ShortBuffer;
+import java.util.Collections;
+import java.util.List;
 
 /**
  * Abstract rendering backend.
@@ -25,6 +27,14 @@ public abstract class RenderBackend {
     /** Higher priority backends are preferred. */
     public int getPriority() { return 0; }
 
+    public boolean supportsFileDrop() { return false; }
+
+    public void startFileDrop() {}
+
+    public void stopFileDrop() {}
+
+    public List<String> pollDroppedFiles() { return Collections.emptyList(); }
+
     public abstract int getMinGLSLVersion();
 
     public abstract void flush();
@@ -77,6 +87,8 @@ public abstract class RenderBackend {
     public abstract void multiDrawElementsIndirect(int mode, int type, long indirect, int drawcount, int stride);
     public abstract void copyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size);
     public abstract void drawElementsInstanced(int mode, int count, int type, long indices, int primcount);
+    public abstract void drawArraysInstanced(int mode, int first, int count, int primcount);
+    public void provokingVertex(int provokeMode) {}
     public abstract void drawElementsBaseVertex(int mode, int count, int type, long indices, int baseVertex);
     public abstract void multiDrawElementsBaseVertex(int mode, long pCount, int type, long pIndices, int drawcount, long pBaseVertex);
     public abstract void drawBuffer(int mode);
@@ -115,7 +127,6 @@ public abstract class RenderBackend {
     public abstract int getTexLevelParameteri(int target, int level, int pname);
     public abstract void generateMipmap(int target);
     public abstract void pixelStorei(int pname, int param);
-    public void pixelStoref(int pname, float param) {}
     public void sampleCoverage(float value, boolean invert) {}
 
 
@@ -140,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);
@@ -190,8 +202,13 @@ public abstract class RenderBackend {
     public abstract void uniform3i(int location, int v0, int v1, int v2);
     public abstract void uniform4f(int location, float v0, float v1, float v2, float v3);
     public abstract void uniform4i(int location, int v0, int v1, int v2, int v3);
+    public abstract void uniform2(int location, FloatBuffer value);
     public abstract void uniform3(int location, FloatBuffer value);
     public abstract void uniform4(int location, FloatBuffer value);
+    public abstract void uniform1iv(int location, IntBuffer value);
+    public abstract void uniform2iv(int location, IntBuffer value);
+    public abstract void uniform3iv(int location, IntBuffer value);
+    public abstract void uniform4iv(int location, IntBuffer value);
     public abstract void uniformMatrix3(int location, boolean transpose, FloatBuffer value);
     public abstract void uniformMatrix4(int location, boolean transpose, FloatBuffer value);
     public void uniformMatrix2(int location, boolean transpose, FloatBuffer matrices) {}
@@ -233,10 +250,12 @@ 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);
     public abstract void bindVertexArray(int array);
+    public abstract boolean isVertexArray(int array);
     public abstract void vertexAttribPointer(int index, int size, int type, boolean normalized, int stride, long pointer);
     public void vertexAttribPointer(int index, int size, int type, boolean normalized, int stride, ByteBuffer pointer) {
         vertexAttribPointer(index, size, type, normalized, stride, MemoryUtilities.memAddress0(pointer));
@@ -275,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);

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/dsa/DSAARB.java

@@ -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;
     }
 

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/dsa/DSAUnsupported.java

@@ -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;

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

@@ -12,7 +12,7 @@ import org.lwjgl.opengl.GL13;
  * Packed-long fragment shader permutation key for FFP emulation.
  *
  * Layout:
- *   long[0]: global bits (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) {
@@ -135,7 +140,8 @@ public final class FragmentKey {
         int highestEnabled = -1;
         long unit0Bits = 0;
         for (int i = 0; i < MAX_UNITS; i++) {
-            final boolean texEnabled = GLStateManager.getTextures().getTextureUnitStates(i).isEnabled();
+            // Per Mesa - an enabled unit with no complete texture bound counts as disabled.
+            final boolean texEnabled = GLStateManager.getTextures().getTextureUnitStates(i).isEnabled() && GLStateManager.getTextures().getTextureUnitBindings(i).getBinding() != 0;
             if (texEnabled) highestEnabled = i;
 
             final long unitBits = packUnit(i, texEnabled);
@@ -232,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; }
 

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

@@ -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)) {
@@ -78,7 +92,7 @@ public final class FragmentShaderGenerator {
     private static void emitTextureSampling(StringBuilder sb, FragmentKey key) {
         for (int i = 0; i < key.nrEnabledUnits(); i++) {
             if (!key.unitEnabled(i)) continue;
-            sb.append("  vec4 tex").append(i).append("Color = texture(u_Sampler").append(i).append(", v_TexCoord").append(i).append(".st);\n");
+            sb.append("  vec4 tex").append(i).append("Color = textureProj(u_Sampler").append(i).append(", v_TexCoord").append(i).append(");\n");
         }
     }
 

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

@@ -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++) {

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

@@ -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);

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

@@ -1,15 +1,15 @@
 package com.gtnewhorizons.angelica.glsm.ffp;
 
 import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags;
-import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
 import com.gtnewhorizons.angelica.glsm.CompatUniformManager;
 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 it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
-import com.gtnewhorizons.angelica.glsm.hooks.GLSMInitConfig;
+import com.gtnewhorizons.angelica.glsm.streaming.TessellatorStreamingDrawer;
 import lombok.Getter;
 import org.joml.Vector3f;
 import org.joml.Vector4f;
@@ -31,7 +31,6 @@ public final class ShaderManager {
 
     private final ShaderCache cache = new ShaderCache();
     private final Uniforms uniforms = new Uniforms();
-    private final Int2IntOpenHashMap vaoVertexFlags = new Int2IntOpenHashMap();
 
     @Getter
     private boolean active = false;
@@ -57,10 +56,8 @@ public final class ShaderManager {
     public static Vector4f getCurrentTexCoord() { return currentTexCoords[0]; }
     public static Vector4f getCurrentTexCoord(int unit) { return currentTexCoords[unit]; }
     @Getter private boolean enabled = false;
-    private int currentVertexFlags = VertexFlags.TEXTURE_BIT | VertexFlags.COLOR_BIT | VertexFlags.NORMAL_BIT;
 
     private ShaderManager() {
-        vaoVertexFlags.defaultReturnValue(-1);
         if (Boolean.parseBoolean(System.getProperty("angelica.dumpShaders", "false"))) {
             cache.setDumpDir(Paths.get("ffp_shaders"));
         }
@@ -71,17 +68,33 @@ public final class ShaderManager {
     }
 
     public void enable() {
+        warmUp();
         enabled = true;
 
-        VertexFormat.registerSetupBufferStateOverride((format, offset) -> {
-            currentVertexFlags = format.getVertexFlags();
-            vaoVertexFlags.put(GLStateManager.getBoundVAO(), currentVertexFlags);
-            return false;
-        });
-
         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;
     }
@@ -99,7 +112,7 @@ public final class ShaderManager {
         currentFKLen = 0;
     }
 
-    public void preDraw(boolean hasColor, boolean hasNormal, boolean hasTexCoord, boolean hasLightmap) {
+    public void preDraw() {
         final DeferredBlendHandler bh = GLSMHooks.blendHandler;
         if (bh != null) bh.flushDeferredBlend();
 
@@ -111,7 +124,12 @@ public final class ShaderManager {
             }
         }
 
-        GLStateManager.flushDeferredVertexAttribs(currentVertexFlags);
+        final int vertexFlags = VAOManager.getCurrentVertexFlags();
+        final boolean hasColor = (vertexFlags & VertexFlags.COLOR_BIT) != 0;
+        final boolean hasNormal =   (vertexFlags & VertexFlags.NORMAL_BIT) != 0;
+        final boolean hasTexCoord = (vertexFlags & VertexFlags.TEXTURE_BIT) != 0;
+        final boolean hasLightmap = (vertexFlags & VertexFlags.BRIGHTNESS_BIT) != 0;
+        GLStateManager.flushDeferredVertexAttribs(hasColor, hasNormal, hasTexCoord, hasLightmap);
 
         if (!active) return;
 
@@ -127,20 +145,6 @@ public final class ShaderManager {
         uploadUniforms();
     }
 
-    public void preDraw(int vertexFlags) {
-        currentVertexFlags = vertexFlags;
-        preDraw(
-            (vertexFlags & VertexFlags.COLOR_BIT) != 0,
-            (vertexFlags & VertexFlags.NORMAL_BIT) != 0,
-            (vertexFlags & VertexFlags.TEXTURE_BIT) != 0,
-            (vertexFlags & VertexFlags.BRIGHTNESS_BIT) != 0
-        );
-    }
-
-    public void preDraw() {
-        preDraw(currentVertexFlags);
-    }
-
     private void commitVariant(long vkPacked, int fkLen) {
         currentVertexKeyPacked = vkPacked;
         System.arraycopy(currentFKScratch, 0, currentFKPacked, 0, fkLen);
@@ -177,22 +181,6 @@ public final class ShaderManager {
     public static void bumpNormalGeneration() { normalGeneration++; }
     public static void bumpTexCoordGeneration() { texCoordGeneration++; }
 
-    public void enableClientVertexFlag(int flag) {currentVertexFlags |= flag;}
-    public void disableClientVertexFlag(int flag) {currentVertexFlags &= ~flag;}
-    public int getCurrentVertexFlags() {return currentVertexFlags;}
-    public void setCurrentVertexFlags(int flags) {currentVertexFlags = flags;}
-
-    public void onBindVertexArray(int vaoId) {
-        final int flags = vaoVertexFlags.get(vaoId);
-        if (flags != -1) {
-            currentVertexFlags = flags;
-        }
-    }
-
-    public void onDeleteVertexArray(int vaoId) {
-        vaoVertexFlags.remove(vaoId);
-    }
-
     public void destroy() {
         cache.destroy();
         uniforms.destroy();

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

@@ -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) {

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

@@ -0,0 +1,321 @@
+package com.gtnewhorizons.angelica.glsm.ffp;
+
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL15;
+
+import javax.annotation.Nullable;
+import java.nio.ByteBuffer;
+
+import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
+
+public final class VAOManager {
+    public static final int MAX_ATTRIBS = 16;
+
+    public static final Int2ObjectOpenHashMap<VAOData> vaoMap = new Int2ObjectOpenHashMap<>();
+
+    private static VAOData current = null;
+    private static int currentVertexFlags = 0;
+    private static Attrib[] currentAttribs = null;
+    public static int boundEBO = 0;
+
+    private static int clientSideEnabledCount = 0;
+
+
+    public static void init(int defaultVAO) {
+        final VAOData data = new VAOData();
+        current = data;
+        currentAttribs = data.attribs;
+        vaoMap.put(defaultVAO, data);
+    }
+
+    public static void onBindEBO(int ebo) {
+        boundEBO = ebo;
+    }
+
+    public static void onBindVertexArrayPre(int vaoId) {
+        // Save old VAO data
+        if (current != null) {
+            current.vertexFlags = currentVertexFlags;
+            current.ebo = boundEBO;
+            current.attribs = currentAttribs;
+            current.clientSideEnabledCount = clientSideEnabledCount;
+        }
+
+        VAOData data = vaoMap.get(vaoId);
+        if (data == null) {
+            data = new VAOData();
+            vaoMap.put(vaoId, data);
+        }
+        current = data;
+        currentVertexFlags = data.vertexFlags;
+        currentAttribs = data.attribs;
+        boundEBO = data.ebo;
+        clientSideEnabledCount = data.clientSideEnabledCount;
+    }
+
+    public static void onDeleteVertexArray(int vaoId) {
+        vaoMap.remove(vaoId);
+    }
+
+    public static void enableClientVertexFlag(int flag) { currentVertexFlags |= flag; }
+    public static void disableClientVertexFlag(int flag) { currentVertexFlags &= ~flag; }
+    public static int getCurrentVertexFlags() { return currentVertexFlags; }
+    public static void setCurrentVertexFlags(int flags) { currentVertexFlags = flags; }
+
+    public static final class VAOData {
+        public Attrib[] attribs;
+        public int vertexFlags;
+        public int ebo;
+        public int clientSideEnabledCount;
+
+        public VAOData() {
+            attribs = new Attrib[MAX_ATTRIBS];
+        }
+    }
+
+    public static void setAttribute(int index, int size, int type, boolean normalized, int stride, long offset, int vboId) {
+        if (index < 0 || index >= MAX_ATTRIBS) return;
+        final Attrib a = getAttrib(index);
+        final boolean wasClient = a.clientPointer != null;
+        a.size = size;
+        a.type = type;
+        a.normalized = normalized;
+        a.stride = stride;
+        a.offset = offset;
+        a.vboId = vboId;
+        a.clientPointer = null;
+        a.genericPointer = true;
+        if (wasClient && a.enabled) {
+            clientSideEnabledCount--;
+        }
+    }
+
+    public static void setAttribute(int index, int size, int type, boolean normalized, int stride, ByteBuffer pointer) {
+        if (index < 0 || index >= MAX_ATTRIBS) return;
+        final Attrib a = getAttrib(index);
+        final boolean wasClient = a.clientPointer != null;
+        a.size = size;
+        a.type = type;
+        a.normalized = normalized;
+        a.stride = stride;
+        a.offset = 0;
+        a.vboId = 0;
+        a.clientPointer = pointer;
+        a.genericPointer = true;
+        if (!wasClient && a.enabled) {
+            clientSideEnabledCount++;
+        }
+    }
+
+    public static boolean isGenericPointerEnabled(int index) {
+        if (index < 0 || index >= MAX_ATTRIBS) return false;
+        final Attrib a = currentAttribs[index];
+        return a != null && a.genericPointer && a.enabled;
+    }
+
+    public static void markConventional(int index) {
+        if (index < 0 || index >= MAX_ATTRIBS) return;
+        final Attrib a = currentAttribs[index];
+        if (a != null) a.genericPointer = false;
+    }
+
+    public static void setEnabled(int index, boolean enabled) {
+        if (index < 0 || index >= MAX_ATTRIBS) return;
+        final Attrib a = getAttrib(index);
+        if (a.clientPointer != null && a.enabled != enabled) {
+            clientSideEnabledCount += enabled ? 1 : -1;
+        }
+        a.enabled = enabled;
+    }
+
+    public static void enableAttribute(int index) {
+        if (index < 0 || index >= MAX_ATTRIBS) return;
+        final Attrib a = getAttrib(index);
+        if (a.clientPointer != null && !a.enabled) {
+            clientSideEnabledCount++;
+        }
+        a.enabled = true;
+    }
+
+    public static void disableAttribute(int index) {
+        if (index < 0 || index >= MAX_ATTRIBS) return;
+        final Attrib a = getAttrib(index);
+        if (a.clientPointer != null && a.enabled) {
+            clientSideEnabledCount--;
+        }
+        a.enabled = false;
+    }
+
+    // Lazily allocate each attrib. Most VAOs don't even have 4 attribs, let alone 16.
+    private static Attrib getAttrib(int index) {
+        Attrib a = currentAttribs[index];
+        if (a == null) {
+            a = new Attrib();
+            currentAttribs[index] = a;
+        }
+        return a;
+    }
+
+    public static boolean isClientSideAttrib(int index) {
+        final Attrib attrib = currentAttribs[index];
+        return attrib != null && attrib.isClientSide();
+    }
+
+    public static int getAttribEffectiveStride(int index) {
+        final Attrib attrib = currentAttribs[index];
+        return attrib != null ? attrib.effectiveStride() : 0;
+    }
+
+    public static long getAttribOffset(int index) {
+        final Attrib attrib = currentAttribs[index];
+        return attrib != null ? attrib.offset : 0;
+    }
+
+    public static int getAttribVBO(int index) {
+        final Attrib attrib = currentAttribs[index];
+        return attrib != null ? attrib.vboId : 0;
+    }
+
+    public static @Nullable Attrib get(int index) {
+        return currentAttribs[index];
+    }
+
+
+
+    /**
+     * Returns true if any currently enabled vertex attribute was registered without a VBO
+     * (i.e. as a client-side pointer). In core profile, such attribs are treated as null
+     * offsets into a non-existent buffer, causing a native crash at draw time.
+     */
+    public static boolean hasAnyClientSideEnabledAttrib() {
+        return clientSideEnabledCount > 0;
+    }
+
+    /**
+     * If any enabled vertex attribute uses a client-side pointer (no VBO), upload all such
+     * attribs into a shared stream VBO so the draw succeeds under core profile.
+     */
+    private static int clientArraysVBO = 0;
+    private static int clientArraysVBOCapacity = 0;
+    private static final int[] clientArraysVBOOffsets = new int[VAOManager.MAX_ATTRIBS];
+
+    public static void uploadClientArraysToVBO() {
+        int totalBytes = 0;
+        for (int i = 0; i < VAOManager.MAX_ATTRIBS; i++) {
+            clientArraysVBOOffsets[i] = -1;
+            final VAOManager.Attrib a = VAOManager.get(i);
+            if (a == null || !a.enabled || a.clientPointer == null) continue;
+            clientArraysVBOOffsets[i] = totalBytes;
+            totalBytes += a.clientPointer.remaining();
+        }
+        if (totalBytes == 0) return;
+
+        if (clientArraysVBO == 0) {
+            clientArraysVBO = RENDER_BACKEND.genBuffers();
+        }
+
+        final int savedVBO = GLStateManager.getBoundVBO();
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, clientArraysVBO);
+
+        if (totalBytes > clientArraysVBOCapacity) {
+            int newCap = Math.max(4096, clientArraysVBOCapacity);
+            while (newCap < totalBytes) newCap *= 2;
+            clientArraysVBOCapacity = newCap;
+        }
+        RENDER_BACKEND.bufferData(GL15.GL_ARRAY_BUFFER, clientArraysVBOCapacity, GL15.GL_STREAM_DRAW);
+
+        for (int i = 0; i < VAOManager.MAX_ATTRIBS; i++) {
+            if (clientArraysVBOOffsets[i] < 0) continue;
+            final VAOManager.Attrib a = VAOManager.get(i);
+            RENDER_BACKEND.bufferSubData(GL15.GL_ARRAY_BUFFER, clientArraysVBOOffsets[i], a.clientPointer.duplicate());
+            RENDER_BACKEND.vertexAttribPointer(i, a.size, a.type, a.normalized, a.stride, (long) clientArraysVBOOffsets[i]);
+        }
+
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, savedVBO);
+    }
+
+
+    public static final class Attrib {
+        public boolean enabled;
+        public int size;
+        public int type;
+        public boolean normalized;
+        public int stride;
+        public long offset;
+        public int vboId;
+        public ByteBuffer clientPointer;
+        public boolean genericPointer;
+
+        public boolean isClientSide() {
+            return enabled && clientPointer != null;
+        }
+
+        public void reset() {
+            enabled = false;
+            size = 0;
+            type = 0;
+            normalized = false;
+            stride = 0;
+            offset = 0;
+            vboId = 0;
+            clientPointer = null;
+            genericPointer = false;
+        }
+
+        public int effectiveStride() {
+            return (stride != 0) ? stride : size * typeSizeBytes();
+        }
+
+        public int typeSizeBytes() {
+            return glTypeSizeBytes(type);
+        }
+
+        public static int glTypeSizeBytes(int glType) {
+            return switch (glType) {
+                case GL11.GL_FLOAT, GL11.GL_INT, GL11.GL_UNSIGNED_INT -> 4;
+                case GL11.GL_DOUBLE -> 8;
+                case GL11.GL_SHORT, GL11.GL_UNSIGNED_SHORT -> 2;
+                case GL11.GL_BYTE, GL11.GL_UNSIGNED_BYTE -> 1;
+                default -> 4;
+            };
+        }
+
+        public float readComponent(ByteBuffer buf, int base, int component) {
+            return readComponent(type, normalized, buf, base, component);
+        }
+
+        public static float readComponent(int type, boolean normalized, ByteBuffer buf, int base, int component) {
+            return switch (type) {
+                case GL11.GL_FLOAT -> buf.getFloat(base + component * 4);
+                case GL11.GL_DOUBLE -> (float) buf.getDouble(base + component * 8);
+                case GL11.GL_INT -> {
+                    final int v = buf.getInt(base + component * 4);
+                    yield normalized ? v / (float) Integer.MAX_VALUE : (float) v;
+                }
+                case GL11.GL_UNSIGNED_INT -> {
+                    final int v = buf.getInt(base + component * 4);
+                    yield normalized ? (v & 0xFFFFFFFFL) / (float) 0xFFFFFFFFL : (float) (v & 0xFFFFFFFFL);
+                }
+                case GL11.GL_SHORT -> {
+                    final short v = buf.getShort(base + component * 2);
+                    yield normalized ? v / (float) Short.MAX_VALUE : (float) v;
+                }
+                case GL11.GL_UNSIGNED_SHORT -> {
+                    final int v = buf.getShort(base + component * 2) & 0xFFFF;
+                    yield normalized ? v / (float) 0xFFFF : (float) v;
+                }
+                case GL11.GL_BYTE -> {
+                    final byte v = buf.get(base + component);
+                    yield normalized ? v / 127.0f : (float) v;
+                }
+                case GL11.GL_UNSIGNED_BYTE -> {
+                    final int v = buf.get(base + component) & 0xFF;
+                    yield normalized ? v / 255.0f : (float) v;
+                }
+                default -> 0.0f;
+            };
+        }
+    }
+}

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

@@ -49,6 +49,8 @@ public final class VertexKey {
     private static final int BIT_WIDE_LINE           = 36;
     // Per-unit texmat enable: bits 37-40 (unit 0..3). Unit 1 is the lightmap matrix.
     private static final int BIT_UNIT_TEXMAT_BASE    = 37;
+    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;
@@ -85,6 +87,7 @@ public final class VertexKey {
     public boolean hasVertexNormal()       { return bit(BIT_HAS_VERTEX_NORMAL); }
     public boolean hasVertexTexCoord()     { return bit(BIT_HAS_VERTEX_TEX); }
     public boolean hasVertexLightmap()    { return bit(BIT_HAS_VERTEX_LIGHTMAP); }
+    public boolean unit23UvFromUnit0()     { return bit(BIT_UNIT23_UV_FROM_UNIT0); }
     /** Color material mode (CM_AMBIENT, CM_DIFFUSE, CM_SPECULAR, CM_EMISSION, CM_AMBIENT_AND_DIFFUSE). Only meaningful when colorMaterialEnabled(). */
     public int colorMaterialMode()        { return (int)((packed >> BIT_COLOR_MAT_MODE) & 0x7); }
 
@@ -96,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; }
@@ -213,6 +217,10 @@ public final class VertexKey {
         if (hasTexCoord) bits |= (1L << BIT_HAS_VERTEX_TEX);
         if (hasLightmap) bits |= (1L << BIT_HAS_VERTEX_LIGHTMAP);
 
+        if (GLStateManager.consumeUnit23TexCoordSetDuringDraw() && hasTexCoord) {
+            bits |= (1L << BIT_UNIT23_UV_FROM_UNIT0);
+        }
+
         if (GLStateManager.anyClipPlaneEnabled()) {
             bits |= (1L << BIT_CLIP_PLANES);
         }
@@ -221,6 +229,10 @@ public final class VertexKey {
             bits |= (1L << BIT_WIDE_LINE);
         }
 
+        if (GLStateManager.lineStippleActive) {
+            bits |= (1L << BIT_LINE_STIPPLE);
+        }
+
         return bits;
     }
 

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

@@ -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;
@@ -106,8 +118,8 @@ public final class VertexShaderGenerator {
         if (key.unitTexCoordEnabled(0) && !key.hasVertexTexCoord()) {
             sb.append("uniform vec4 u_CurrentTexCoord0;\n");
         }
-        if (key.unitTexCoordEnabled(2)) sb.append("uniform vec4 u_CurrentTexCoord2;\n");
-        if (key.unitTexCoordEnabled(3)) sb.append("uniform vec4 u_CurrentTexCoord3;\n");
+        if (key.unitTexCoordEnabled(2) && !key.unit23UvFromUnit0()) sb.append("uniform vec4 u_CurrentTexCoord2;\n");
+        if (key.unitTexCoordEnabled(3) && !key.unit23UvFromUnit0()) sb.append("uniform vec4 u_CurrentTexCoord3;\n");
 
         if (key.lightmapEnabled() && !key.hasVertexLightmap()) {
             sb.append("uniform vec2 u_CurrentLightmapCoord;\n");
@@ -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");
         }
@@ -363,8 +378,10 @@ public final class VertexShaderGenerator {
 
         for (int i = 2; i < VertexKey.MAX_UNITS; i++) {
             if (!key.unitTexCoordEnabled(i)) continue;
-            final String src = "u_CurrentTexCoord" + i;
-            if (key.unitTexMatEnabled(i)) {
+            final String src = key.unit23UvFromUnit0()
+                ? "vec4(a_TexCoord0, 0.0, 1.0)"
+                : "u_CurrentTexCoord" + i;
+            if (!key.unit23UvFromUnit0() && key.unitTexMatEnabled(i)) {
                 sb.append("  v_TexCoord").append(i).append(" = u_TextureMatrix").append(i).append(" * ").append(src).append(";\n");
             } else {
                 sb.append("  v_TexCoord").append(i).append(" = ").append(src).append(";\n");
@@ -383,7 +400,7 @@ public final class VertexShaderGenerator {
 
         emitTexGenComponent(sb, key.texGenModeS(), "s", "S", key);
         emitTexGenComponent(sb, key.texGenModeT(), "t", "T", key);
-        emitTexGenComponent(sb, key.texGenModeR(), "r", "R", key);
+        emitTexGenComponent(sb, key.texGenModeR(), "p", "R", key);
         emitTexGenComponent(sb, key.texGenModeQ(), "q", "Q", key);
 
         // Always apply texture matrix when texgen is active (forced on in VertexKey)

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

@@ -8,6 +8,7 @@ public final class GLSMHooks {
     public static DeferredBlendHandler blendHandler;
     public static DeferredAlphaHandler alphaHandler;
     public static DeferredDepthColorHandler depthColorHandler;
+    public static GlintColorHandler glintColorHandler;
 
     // EventBus instances
     public static final EventBus<TextureBindEvent> TEXTURE_BIND = EventBus.create(TextureBindEvent.class);

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

@@ -0,0 +1,5 @@
+package com.gtnewhorizons.angelica.glsm.hooks;
+
+public interface GlintColorHandler {
+    void onColorChanged(float red, float green, float blue, float alpha);
+}

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/loading/EcosystemNarrowRules.java

@@ -35,11 +35,30 @@ public final class EcosystemNarrowRules {
             "com.fiskmods.lightsabers.asm.transformers"
         )),
 
+        new NarrowRule("FiskHeroes", "com.fiskmods.heroes.asm", List.of(
+            "com.fiskmods.heroes.asm.SHLoadingPlugin",
+            "com.fiskmods.heroes.asm.transformers"
+        )),
+
         new NarrowRule("Ears", "com.unascribed.ears", List.of(
             "com.unascribed.ears.asm",
             "com.unascribed.ears.common.agent"
         )),
 
+        new NarrowRule("FoamFix", "pl.asie.foamfix", List.of(
+            "pl.asie.foamfix.bugfixmod",
+            "pl.asie.foamfix.coremod",
+            "pl.asie.foamfix.forkage",
+            "pl.asie.foamfix.ghostbuster",
+            "pl.asie.foamfix.FoamFixMod",
+            "pl.asie.foamfix.HackyMessageFactoryWrapper",
+            "pl.asie.foamfix.LaunchWrapperRuntimeFix",
+            "pl.asie.foamfix.ProxyClient",
+            "pl.asie.foamfix.ProxyCommon",
+            "pl.asie.foamfix.repack.com.unascribed.ears.asm",
+            "pl.asie.foamfix.repack.com.unascribed.ears.common.agent"
+        )),
+
         new NarrowRule("Alfheim", "alfheim.common.core.asm.hook", List.of(
             "alfheim.common.core.asm.hook.AlfheimFieldHookHandler",
             "alfheim.common.core.asm.hook.AlfheimHPHooks",

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

@@ -2,7 +2,7 @@ package com.gtnewhorizons.angelica.glsm.recording;
 
 import com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
-import com.gtnewhorizons.angelica.glsm.states.VertexAttribState;
+import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
 import it.unimi.dsi.fastutil.ints.Int2LongOpenHashMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import org.lwjgl.opengl.GL15;
@@ -15,11 +15,11 @@ public final class AttribSnapshot {
 
     public record AttribDesc(int location, int size, int type, boolean normalized, int stride, long offset, int sourceVboId, ByteBuffer readBuffer, long readBufferBaseOffset) {
         public int effectiveStride() {
-            return stride != 0 ? stride : size * VertexAttribState.Attrib.glTypeSizeBytes(type);
+            return stride != 0 ? stride : size * VAOManager.Attrib.glTypeSizeBytes(type);
         }
 
         public int typeSizeBytes() {
-            return VertexAttribState.Attrib.glTypeSizeBytes(type);
+            return VAOManager.Attrib.glTypeSizeBytes(type);
         }
     }
 
@@ -56,7 +56,7 @@ public final class AttribSnapshot {
      * allocating any hashmaps. A second distinct VBO promotes to the map-backed fallback.
      */
     public static AttribSnapshot snapshot(int firstVertex, int vertexCount) {
-        final AttribDesc[] out = new AttribDesc[VertexAttribState.MAX_ATTRIBS];
+        final AttribDesc[] out = new AttribDesc[VAOManager.MAX_ATTRIBS];
         final List<ByteBuffer> allocated = new ArrayList<>();
         final int prevVBO = GLStateManager.getBoundVBO();
 
@@ -67,11 +67,11 @@ public final class AttribSnapshot {
         Int2ObjectOpenHashMap<long[]> vboRanges = null;
 
         final long lastVtx = (long) firstVertex + vertexCount - 1;
-        for (int i = 0; i < VertexAttribState.MAX_ATTRIBS; i++) {
-            final VertexAttribState.Attrib a = VertexAttribState.get(i);
-            if (!a.enabled || a.vboId == 0) continue;
+        for (int i = 0; i < VAOManager.MAX_ATTRIBS; i++) {
+            final VAOManager.Attrib a = VAOManager.get(i);
+            if (a == null || !a.enabled || a.vboId == 0) continue;
             final int stride = a.effectiveStride();
-            final long typeBytes = (long) a.size * VertexAttribState.Attrib.glTypeSizeBytes(a.type);
+            final long typeBytes = (long) a.size * VAOManager.Attrib.glTypeSizeBytes(a.type);
             final long start = a.offset + (long) firstVertex * stride;
             final long end = a.offset + lastVtx * stride + typeBytes;
 
@@ -103,9 +103,9 @@ public final class AttribSnapshot {
         Int2LongOpenHashMap vboReadOffsets = null;
 
         try {
-            for (int i = 0; i < VertexAttribState.MAX_ATTRIBS; i++) {
-                final VertexAttribState.Attrib a = VertexAttribState.get(i);
-                if (!a.enabled) continue;
+            for (int i = 0; i < VAOManager.MAX_ATTRIBS; i++) {
+                final VAOManager.Attrib a = VAOManager.get(i);
+                if (a == null || !a.enabled) continue;
 
                 if (a.vboId != 0) {
                     ByteBuffer buf;

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

@@ -653,12 +653,19 @@ public final class CommandRecorder {
         for (IndexedDrawCapture c : indexedDraws.getCaptures()) {
             c.freeBuffers();
         }
-        memFree(buffer);
+        for (DisplayListCommand cmd : complexObjects) {
+            cmd.delete();
+        }
+        complexObjects.clear();
+        if (buffer != null) {
+            memFree(buffer);
+            buffer = null;
+        }
     }
 
     /**
      * Deletes every allocated object & returns a ByteBuffer with the capacity equal to its limit.
-     * This CommandRecorder object cannot be used after calling this anymore.
+     * This CommandRecorder object cannot be used after calling this anymore
      */
     public ByteBuffer finish() {
         for (IndexedDrawCapture c : indexedDraws.getCaptures()) {
@@ -666,7 +673,10 @@ public final class CommandRecorder {
         }
         final int size = size();
         buffer.limit(size);
-        return memRealloc(buffer, size);
+        final ByteBuffer out = memRealloc(buffer, size);
+        buffer = null;
+        complexObjects.clear();
+        return out;
     }
 
     public DisplayListCommand[] getComplexObjects() {

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

@@ -5,11 +5,13 @@ import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
 import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
 import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement.Usage;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
-import com.gtnewhorizons.angelica.glsm.states.VertexAttribState;
+import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
 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() {
@@ -293,7 +304,39 @@ public final class ImmediateModeRecorder {
     }
 
     private static float readComponent(AttribReader r, int base, int component) {
-        return VertexAttribState.Attrib.readComponent(r.type, r.normalized, r.data, base, component);
+        return VAOManager.Attrib.readComponent(r.type, r.normalized, r.data, base, component);
+    }
+
+    public static float readComponent(int type, boolean normalized, ByteBuffer buf, int base, int component) {
+        return switch (type) {
+            case GL11.GL_FLOAT -> buf.getFloat(base + component * 4);
+            case GL11.GL_DOUBLE -> (float) buf.getDouble(base + component * 8);
+            case GL11.GL_INT -> {
+                final int v = buf.getInt(base + component * 4);
+                yield normalized ? v / (float) Integer.MAX_VALUE : (float) v;
+            }
+            case GL11.GL_UNSIGNED_INT -> {
+                final int v = buf.getInt(base + component * 4);
+                yield normalized ? (v & 0xFFFFFFFFL) / (float) 0xFFFFFFFFL : (float) (v & 0xFFFFFFFFL);
+            }
+            case GL11.GL_SHORT -> {
+                final short v = buf.getShort(base + component * 2);
+                yield normalized ? v / (float) Short.MAX_VALUE : (float) v;
+            }
+            case GL11.GL_UNSIGNED_SHORT -> {
+                final int v = buf.getShort(base + component * 2) & 0xFFFF;
+                yield normalized ? v / (float) 0xFFFF : (float) v;
+            }
+            case GL11.GL_BYTE -> {
+                final byte v = buf.get(base + component);
+                yield normalized ? v / 127.0f : (float) v;
+            }
+            case GL11.GL_UNSIGNED_BYTE -> {
+                final int v = buf.get(base + component) & 0xFF;
+                yield normalized ? v / 255.0f : (float) v;
+            }
+            default -> 0.0f;
+        };
     }
 
 }

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/commands/AttribLayoutKey.java

@@ -1,6 +1,6 @@
 package com.gtnewhorizons.angelica.glsm.recording.commands;
 
-import com.gtnewhorizons.angelica.glsm.states.VertexAttribState;
+import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
 
 import java.util.Arrays;
 
@@ -24,7 +24,7 @@ public final class AttribLayoutKey {
         int base = 0;
         int maxAlign = 1;
         for (int i = 0; i < n; i++) {
-            final int typeSize = VertexAttribState.Attrib.glTypeSizeBytes(types[i]);
+            final int typeSize = VAOManager.Attrib.glTypeSizeBytes(types[i]);
             if (typeSize > maxAlign) maxAlign = typeSize;
             base = (base + typeSize - 1) & -typeSize;
             off[i] = base;

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/commands/IndexedDrawCapture.java

@@ -3,14 +3,12 @@ package com.gtnewhorizons.angelica.glsm.recording.commands;
 import com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.QuadConverter;
+import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
 import com.gtnewhorizons.angelica.glsm.recording.AttribSnapshot;
-import com.gtnewhorizons.angelica.glsm.states.VertexAttribState;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL15;
 
 import java.nio.ByteBuffer;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.Set;
 
 import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt;
 import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetLong;
@@ -52,51 +50,69 @@ public final class IndexedDrawCapture {
         return freed;
     }
 
-    private static final Set<String> WARN_ONCE = ConcurrentHashMap.newKeySet();
-
-    private static void warnOnce(String key, String fmt, Object... args) {
-        if (WARN_ONCE.add(key)) GLStateManager.LOGGER.warn(fmt, args);
-    }
-
     public static IndexedDrawCapture create(int mode, int indicesCount, int srcIndexType, long indicesOffset, int eboId) {
         if (indicesCount == 0) return null;
         if (eboId == 0) {
-            warnOnce("no-ebo", "[IndexedDrawCapture] glDrawElements in display list with no EBO bound — skipping (mode={} count={} offset={})", mode, indicesCount, indicesOffset);
+            GLStateManager.warnOnce("no-ebo", "[IndexedDrawCapture] glDrawElements in display list with no EBO bound — skipping (mode={} count={} offset={})", mode, indicesCount, indicesOffset);
             return null;
         }
         if (mode == GL11.GL_QUADS && (indicesCount % 4) != 0) {
-            warnOnce("quads-misaligned", "[IndexedDrawCapture] GL_QUADS with indicesCount={} not a multiple of 4 — skipping", indicesCount);
+            GLStateManager.warnOnce("quads-misaligned", "[IndexedDrawCapture] GL_QUADS with indicesCount={} not a multiple of 4 — skipping", indicesCount);
             return null;
         }
-        final int srcIndexSize = VertexAttribState.Attrib.glTypeSizeBytes(srcIndexType);
+        final int srcIndexSize = VAOManager.Attrib.glTypeSizeBytes(srcIndexType);
         if (srcIndexSize <= 0) return null;
 
         final int prevEBO = GLStateManager.getBoundEBO();
         final int prevVBO = GLStateManager.getBoundVBO();
         ByteBuffer eboSrc = null;
+        try {
+            GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, eboId);
+            final int eboBufferSize = GLStateManager.glGetBufferParameteri(GL15.GL_ELEMENT_ARRAY_BUFFER, GL15.GL_BUFFER_SIZE);
+            if (eboBufferSize <= 0) {
+                GLStateManager.warnOnce("ebo-size", "[IndexedDrawCapture] GL_BUFFER_SIZE={} for EBO {}", eboBufferSize, eboId);
+                return null;
+            }
+            final long eboReadSize = (long) indicesCount * srcIndexSize;
+            if (indicesOffset < 0 || indicesOffset + eboReadSize > eboBufferSize) {
+                GLStateManager.warnOnce("ebo-range", "[IndexedDrawCapture] EBO range {}+{} exceeds buffer size {} — skipping", indicesOffset, eboReadSize, eboBufferSize);
+                return null;
+            }
+            eboSrc = MemoryUtilities.memAlloc((int) eboReadSize);
+            GLStateManager.glGetBufferSubData(GL15.GL_ELEMENT_ARRAY_BUFFER, indicesOffset, eboSrc);
+            return bake(mode, indicesCount, srcIndexType, MemoryUtilities.memAddress0(eboSrc));
+        } finally {
+            if (eboSrc != null) MemoryUtilities.memFree(eboSrc);
+            GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEBO);
+            GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, prevVBO);
+        }
+    }
+
+    public static IndexedDrawCapture createFromClientIndices(int mode, int indicesCount, int srcIndexType, long indexSrcAddr, long srcByteLength) {
+        if (indicesCount == 0) return null;
+        if (indexSrcAddr == 0L) return null;
+        if (mode == GL11.GL_QUADS && (indicesCount % 4) != 0) {
+            GLStateManager.warnOnce("quads-misaligned", "[IndexedDrawCapture] GL_QUADS with indicesCount={} not a multiple of 4 - skipping", indicesCount);
+            return null;
+        }
+        final int idxSize = VAOManager.Attrib.glTypeSizeBytes(srcIndexType);
+        if (idxSize <= 0) return null;
+        if ((long) indicesCount * idxSize > srcByteLength) {
+            GLStateManager.warnOnce("client-idx-range", "[IndexedDrawCapture] index count {} ({} bytes) exceeds client buffer {} bytes - skipping", indicesCount, (long) indicesCount * idxSize, srcByteLength);
+            return null;
+        }
+        return bake(mode, indicesCount, srcIndexType, indexSrcAddr);
+    }
+
+    private static IndexedDrawCapture bake(int mode, int indicesCount, int srcIndexType, long indexSrcAddr) {
         AttribSnapshot snap = null;
         ByteBuffer vertexData = null;
         ByteBuffer indexData = null;
         boolean success = false;
         try {
-            GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, eboId);
-            final int eboBufferSize = GLStateManager.glGetBufferParameteri(GL15.GL_ELEMENT_ARRAY_BUFFER, GL15.GL_BUFFER_SIZE);
-            if (eboBufferSize <= 0) {
-                warnOnce("ebo-size", "[IndexedDrawCapture] GL_BUFFER_SIZE={} for EBO {}", eboBufferSize, eboId);
-                return null;
-            }
-            final long eboReadSize = (long) indicesCount * srcIndexSize;
-            if (indicesOffset < 0 || indicesOffset + eboReadSize > eboBufferSize) {
-                warnOnce("ebo-range", "[IndexedDrawCapture] EBO range {}+{} exceeds buffer size {} — skipping", indicesOffset, eboReadSize, eboBufferSize);
-                return null;
-            }
-            eboSrc = MemoryUtilities.memAlloc((int) eboReadSize);
-            GLStateManager.glGetBufferSubData(GL15.GL_ELEMENT_ARRAY_BUFFER, indicesOffset, eboSrc);
-            final long eboSrcAddr = MemoryUtilities.memAddress0(eboSrc);
-
-            final long minMax = QuadConverter.scanMinMaxIndex(eboSrcAddr, srcIndexType, indicesCount);
+            final long minMax = QuadConverter.scanMinMaxIndex(indexSrcAddr, srcIndexType, indicesCount);
             if (minMax == -1L) {
-                warnOnce("min-max", "[IndexedDrawCapture] failed to determine min/max vertex for indexType={}", srcIndexType);
+                GLStateManager.warnOnce("min-max", "[IndexedDrawCapture] failed to determine min/max vertex for indexType={}", srcIndexType);
                 return null;
             }
             final int minVtx = (int) (minMax & 0xFFFFFFFFL);
@@ -106,11 +122,11 @@ public final class IndexedDrawCapture {
             snap = AttribSnapshot.snapshot(minVtx, vertexCount);
 
             int enabledCount = 0;
-            for (int i = 0; i < VertexAttribState.MAX_ATTRIBS; i++) {
+            for (int i = 0; i < VAOManager.MAX_ATTRIBS; i++) {
                 if (snap.get(i) != null) enabledCount++;
             }
             if (enabledCount == 0) {
-                warnOnce("no-attribs", "[IndexedDrawCapture] no enabled attributes — skipping");
+                GLStateManager.warnOnce("no-attribs", "[IndexedDrawCapture] no enabled attributes — skipping");
                 return null;
             }
             final int[] locations = new int[enabledCount];
@@ -118,7 +134,7 @@ public final class IndexedDrawCapture {
             final int[] types = new int[enabledCount];
             final boolean[] normalized = new boolean[enabledCount];
             int k = 0;
-            for (int i = 0; i < VertexAttribState.MAX_ATTRIBS; i++) {
+            for (int i = 0; i < VAOManager.MAX_ATTRIBS; i++) {
                 final AttribSnapshot.AttribDesc d = snap.get(i);
                 if (d == null) continue;
                 locations[k] = i;
@@ -137,6 +153,13 @@ public final class IndexedDrawCapture {
             for (int a = 0; a < enabledCount; a++) {
                 final AttribSnapshot.AttribDesc d = snap.get(locations[a]);
                 final int relOffset = (int) (d.offset() - d.readBufferBaseOffset());
+
+                final long readStart = relOffset + (long) minVtx * d.effectiveStride();
+                final long readEnd = relOffset + (long) maxVtx * d.effectiveStride() + (long) d.size() * d.typeSizeBytes();
+                if (readStart < 0 || readEnd > d.readBuffer().capacity()) {
+                    GLStateManager.warnOnce("vtx-oob", "[IndexedDrawCapture] attrib {} read extent {} exceeds snapshot {} bytes - skipping", d.location(), readEnd, d.readBuffer().capacity());
+                    return null;
+                }
                 if (a == 0) {
                     sharedSrcBuffer = d.readBuffer();
                     sharedSrcStride = d.effectiveStride();
@@ -169,12 +192,12 @@ public final class IndexedDrawCapture {
                 final int quadCount = indicesCount / 4;
                 bakedIndexCount = quadCount * 6;
                 indexData = MemoryUtilities.memAlloc(bakedIndexCount * 4);
-                QuadConverter.triangulateQuads(eboSrcAddr, srcIndexType, MemoryUtilities.memAddress0(indexData), GL11.GL_UNSIGNED_INT, quadCount, minVtx);
+                QuadConverter.triangulateQuads(indexSrcAddr, srcIndexType, MemoryUtilities.memAddress0(indexData), GL11.GL_UNSIGNED_INT, quadCount, minVtx);
                 bakedDrawMode = GL11.GL_TRIANGLES;
             } else {
                 bakedIndexCount = indicesCount;
                 indexData = MemoryUtilities.memAlloc(bakedIndexCount * 4);
-                QuadConverter.widenIndices(eboSrcAddr, srcIndexType, MemoryUtilities.memAddress0(indexData), GL11.GL_UNSIGNED_INT, indicesCount, minVtx);
+                QuadConverter.widenIndices(indexSrcAddr, srcIndexType, MemoryUtilities.memAddress0(indexData), GL11.GL_UNSIGNED_INT, indicesCount, minVtx);
                 bakedDrawMode = mode;
             }
 
@@ -184,14 +207,11 @@ public final class IndexedDrawCapture {
             success = true;
             return out;
         } finally {
-            if (eboSrc != null) MemoryUtilities.memFree(eboSrc);
             if (snap != null) snap.free();
             if (!success) {
                 if (vertexData != null) MemoryUtilities.memFree(vertexData);
                 if (indexData != null) MemoryUtilities.memFree(indexData);
             }
-            GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEBO);
-            GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, prevVBO);
         }
     }
 

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/commands/PixelDataSnapshot.java

@@ -0,0 +1,52 @@
+package com.gtnewhorizons.angelica.glsm.recording.commands;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.DoubleBuffer;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+
+import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memAlloc;
+
+final class PixelDataSnapshot {
+    private PixelDataSnapshot() {}
+
+    static @Nullable ByteBuffer copy(@Nullable ByteBuffer pixels) {
+        if (pixels == null) return null;
+        final int pos = pixels.position();
+        final ByteBuffer out = memAlloc(pixels.remaining()).order(ByteOrder.nativeOrder());
+        out.put(pixels);
+        out.flip();
+        pixels.position(pos);
+        return out;
+    }
+
+    static @Nullable ByteBuffer copy(@Nullable IntBuffer pixels) {
+        if (pixels == null) return null;
+        final int pos = pixels.position();
+        final ByteBuffer out = memAlloc(pixels.remaining() * 4).order(ByteOrder.nativeOrder());
+        out.asIntBuffer().put(pixels);
+        pixels.position(pos);
+        return out;
+    }
+
+    static @Nullable ByteBuffer copy(@Nullable FloatBuffer pixels) {
+        if (pixels == null) return null;
+        final int pos = pixels.position();
+        final ByteBuffer out = memAlloc(pixels.remaining() * 4).order(ByteOrder.nativeOrder());
+        out.asFloatBuffer().put(pixels);
+        pixels.position(pos);
+        return out;
+    }
+
+    static @Nullable ByteBuffer copy(@Nullable DoubleBuffer pixels) {
+        if (pixels == null) return null;
+        final int pos = pixels.position();
+        final ByteBuffer out = memAlloc(pixels.remaining() * 8).order(ByteOrder.nativeOrder());
+        out.asDoubleBuffer().put(pixels);
+        pixels.position(pos);
+        return out;
+    }
+}

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/commands/TexImage2DCmd.java

@@ -2,15 +2,17 @@ package com.gtnewhorizons.angelica.glsm.recording.commands;
 
 import com.gtnewhorizons.angelica.glsm.GLDebug;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
 import java.nio.DoubleBuffer;
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 
+import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree;
+
 /**
  * Command: glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels)
  * Specifies a two-dimensional texture image during display list playback.
@@ -24,92 +26,58 @@ public record TexImage2DCmd(
     int border,
     int format,
     int type,
-    @Nullable byte[] pixelData
+    @Nullable ByteBuffer pixels,
+    @Nullable PixelUnpackState unpack
 ) implements DisplayListCommand {
 
-    /**
-     * Create command from IntBuffer
-     */
-    public static TexImage2DCmd fromIntBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable IntBuffer pixels) {
-        byte[] data = null;
-        if (pixels != null) {
-            int pos = pixels.position();
-            int limit = pixels.limit();
-            int size = (limit - pos) * 4; // 4 bytes per int
-            data = new byte[size];
-            ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
-            bb.asIntBuffer().put(pixels);
-            pixels.position(pos); // Restore position
+    public TexImage2DCmd {
+        if (pixels == null) {
+            unpack = null;
         }
-        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, data);
     }
 
-    /**
-     * Create command from FloatBuffer
-     */
-    public static TexImage2DCmd fromFloatBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable FloatBuffer pixels) {
-        byte[] data = null;
-        if (pixels != null) {
-            int pos = pixels.position();
-            int limit = pixels.limit();
-            int size = (limit - pos) * 4; // 4 bytes per float
-            data = new byte[size];
-            ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
-            bb.asFloatBuffer().put(pixels);
-            pixels.position(pos); // Restore position
-        }
-        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, data);
+    public static TexImage2DCmd fromIntBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable IntBuffer pixels, PixelUnpackState unpack) {
+        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, PixelDataSnapshot.copy(pixels), unpack);
     }
 
-    /**
-     * Create command from DoubleBuffer
-     */
-    public static TexImage2DCmd fromDoubleBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable DoubleBuffer pixels) {
-        byte[] data = null;
-        if (pixels != null) {
-            int pos = pixels.position();
-            int limit = pixels.limit();
-            int size = (limit - pos) * 8; // 8 bytes per double
-            data = new byte[size];
-            ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
-            bb.asDoubleBuffer().put(pixels);
-            pixels.position(pos); // Restore position
-        }
-        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, data);
+    public static TexImage2DCmd fromFloatBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable FloatBuffer pixels, PixelUnpackState unpack) {
+        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, PixelDataSnapshot.copy(pixels), unpack);
     }
 
-    /**
-     * Create command from ByteBuffer
-     */
-    public static TexImage2DCmd fromByteBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable ByteBuffer pixels) {
-        byte[] data = null;
-        if (pixels != null) {
-            int pos = pixels.position();
-            int limit = pixels.limit();
-            int size = limit - pos;
-            data = new byte[size];
-            pixels.get(data);
-            pixels.position(pos); // Restore position
-        }
-        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, data);
+    public static TexImage2DCmd fromDoubleBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable DoubleBuffer pixels, PixelUnpackState unpack) {
+        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, PixelDataSnapshot.copy(pixels), unpack);
+    }
+
+    public static TexImage2DCmd fromByteBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable ByteBuffer pixels, PixelUnpackState unpack) {
+        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, PixelDataSnapshot.copy(pixels), unpack);
     }
 
     @Override
     public void execute() {
-        ByteBuffer buffer = null;
-        if (pixelData != null) {
-            buffer = ByteBuffer.allocateDirect(pixelData.length).order(ByteOrder.nativeOrder());
-            buffer.put(pixelData);
-            buffer.flip();
+        if (pixels == null) {
+            GLStateManager.glTexImage2D(target, level, internalformat, width, height, border, format, type, (ByteBuffer) null);
+            return;
+        }
+        GLStateManager.forcePixelUnpackState(unpack);
+        try {
+            GLStateManager.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+        } finally {
+            GLStateManager.restorePixelUnpackState(unpack);
+        }
+    }
+
+    @Override
+    public void delete() {
+        if (pixels != null) {
+            memFree(pixels);
         }
-        GLStateManager.glTexImage2D(target, level, internalformat, width, height, border, format, type, buffer);
     }
 
     @Override
     public @NotNull String toString() {
-        String dataStr = pixelData != null ? (pixelData.length + " bytes") : "null";
-        return String.format("TexImage2D(target=%s, level=%d, internalformat=%s, %dx%d, border=%d, format=%s, type=%s, data=%s)",
+        String dataStr = pixels != null ? (pixels.remaining() + " bytes") : "null";
+        return String.format("TexImage2D(target=%s, level=%d, internalformat=%s, %dx%d, border=%d, format=%s, type=%s, data=%s, unpack=%s)",
             GLDebug.getTextureTargetName(target), level, GLDebug.getTextureFormatName(internalformat),
-            width, height, border, GLDebug.getTextureFormatName(format), GLDebug.getDataTypeName(type), dataStr);
+            width, height, border, GLDebug.getTextureFormatName(format), GLDebug.getDataTypeName(type), dataStr, unpack);
     }
 }

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/recording/commands/TexSubImage2DCmd.java

@@ -2,15 +2,17 @@ package com.gtnewhorizons.angelica.glsm.recording.commands;
 
 import com.gtnewhorizons.angelica.glsm.GLDebug;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.nio.ByteBuffer;
-import java.nio.ByteOrder;
 import java.nio.DoubleBuffer;
 import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 
+import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memFree;
+
 /**
  * Command: glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels)
  * Updates a portion of an existing two-dimensional texture image during display list playback.
@@ -24,92 +26,58 @@ public record TexSubImage2DCmd(
     int height,
     int format,
     int type,
-    @Nullable byte[] pixelData
+    @Nullable ByteBuffer pixels,
+    @Nullable PixelUnpackState unpack
 ) implements DisplayListCommand {
 
-    /**
-     * Create command from IntBuffer
-     */
-    public static TexSubImage2DCmd fromIntBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable IntBuffer pixels) {
-        byte[] data = null;
-        if (pixels != null) {
-            int pos = pixels.position();
-            int limit = pixels.limit();
-            int size = (limit - pos) * 4; // 4 bytes per int
-            data = new byte[size];
-            ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
-            bb.asIntBuffer().put(pixels);
-            pixels.position(pos); // Restore position
+    public TexSubImage2DCmd {
+        if (pixels == null) {
+            unpack = null;
         }
-        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, data);
     }
 
-    /**
-     * Create command from FloatBuffer
-     */
-    public static TexSubImage2DCmd fromFloatBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable FloatBuffer pixels) {
-        byte[] data = null;
-        if (pixels != null) {
-            int pos = pixels.position();
-            int limit = pixels.limit();
-            int size = (limit - pos) * 4; // 4 bytes per float
-            data = new byte[size];
-            ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
-            bb.asFloatBuffer().put(pixels);
-            pixels.position(pos); // Restore position
-        }
-        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, data);
+    public static TexSubImage2DCmd fromIntBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable IntBuffer pixels, PixelUnpackState unpack) {
+        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, PixelDataSnapshot.copy(pixels), unpack);
     }
 
-    /**
-     * Create command from DoubleBuffer
-     */
-    public static TexSubImage2DCmd fromDoubleBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable DoubleBuffer pixels) {
-        byte[] data = null;
-        if (pixels != null) {
-            int pos = pixels.position();
-            int limit = pixels.limit();
-            int size = (limit - pos) * 8; // 8 bytes per double
-            data = new byte[size];
-            ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.nativeOrder());
-            bb.asDoubleBuffer().put(pixels);
-            pixels.position(pos); // Restore position
-        }
-        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, data);
+    public static TexSubImage2DCmd fromFloatBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable FloatBuffer pixels, PixelUnpackState unpack) {
+        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, PixelDataSnapshot.copy(pixels), unpack);
     }
 
-    /**
-     * Create command from ByteBuffer
-     */
-    public static TexSubImage2DCmd fromByteBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable ByteBuffer pixels) {
-        byte[] data = null;
-        if (pixels != null) {
-            int pos = pixels.position();
-            int limit = pixels.limit();
-            int size = limit - pos;
-            data = new byte[size];
-            pixels.get(data);
-            pixels.position(pos); // Restore position
-        }
-        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, data);
+    public static TexSubImage2DCmd fromDoubleBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable DoubleBuffer pixels, PixelUnpackState unpack) {
+        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, PixelDataSnapshot.copy(pixels), unpack);
+    }
+
+    public static TexSubImage2DCmd fromByteBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable ByteBuffer pixels, PixelUnpackState unpack) {
+        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, PixelDataSnapshot.copy(pixels), unpack);
     }
 
     @Override
     public void execute() {
-        ByteBuffer buffer = null;
-        if (pixelData != null) {
-            buffer = ByteBuffer.allocateDirect(pixelData.length).order(ByteOrder.nativeOrder());
-            buffer.put(pixelData);
-            buffer.flip();
+        if (pixels == null) {
+            GLStateManager.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, (ByteBuffer) null);
+            return;
+        }
+        GLStateManager.forcePixelUnpackState(unpack);
+        try {
+            GLStateManager.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
+        } finally {
+            GLStateManager.restorePixelUnpackState(unpack);
+        }
+    }
+
+    @Override
+    public void delete() {
+        if (pixels != null) {
+            memFree(pixels);
         }
-        GLStateManager.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, buffer);
     }
 
     @Override
     public @NotNull String toString() {
-        String dataStr = pixelData != null ? (pixelData.length + " bytes") : "null";
-        return String.format("TexSubImage2D(target=%s, level=%d, offset=(%d,%d), %dx%d, format=%s, type=%s, data=%s)",
+        String dataStr = pixels != null ? (pixels.remaining() + " bytes") : "null";
+        return String.format("TexSubImage2D(target=%s, level=%d, offset=(%d,%d), %dx%d, format=%s, type=%s, data=%s, unpack=%s)",
             GLDebug.getTextureTargetName(target), level, xoffset, yoffset, width, height,
-            GLDebug.getTextureFormatName(format), GLDebug.getDataTypeName(type), dataStr);
+            GLDebug.getTextureFormatName(format), GLDebug.getDataTypeName(type), dataStr, unpack);
     }
 }

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

@@ -46,6 +46,13 @@ public class GLSMRedirector {
     private static final String ARBMultiTexture = "org/lwjgl/opengl/ARBMultitexture";
     private static final String ARBShaderObjects = "org/lwjgl/opengl/ARBShaderObjects";
     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";
@@ -126,6 +133,7 @@ public class GLSMRedirector {
             .add("glFrustum")
             .add("glGetBoolean")
             .add("glGetFloat")
+            .add("glGetFloatv", "glGetFloat")
             .add("glGetInteger")
             .add("glGetLight")
             .add("glGetMaterial")
@@ -282,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")
@@ -296,6 +309,7 @@ public class GLSMRedirector {
             .add("glStencilOpSeparate")
             .add("glUseProgram")
             .add("glShaderSource")
+            .add("nglShaderSource")
             .add("glLinkProgram")
             .add("glDeleteProgram")
             .add("glCreateShader")
@@ -321,6 +335,7 @@ public class GLSMRedirector {
             .add("glUniformMatrix2")
             .add("glUniformMatrix3")
             .add("glUniformMatrix4")
+            .add("glUniformMatrix4fv", "glUniformMatrix4")
             .add("glDeleteShader")
             .add("glGetShaderi")
             .add("glGetShaderInfoLog")
@@ -342,6 +357,7 @@ public class GLSMRedirector {
             .add("glGenVertexArrays")
             .add("glBindVertexArray")
             .add("glDeleteVertexArrays")
+            .add("glIsVertexArray")
             .add("glBindFramebuffer")
             .add("glDeleteFramebuffers")
             .add("glGenFramebuffers")
@@ -350,9 +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("glDrawElementsInstanced")
+            .add("glDrawArraysInstanced")
+            .add("glCopyBufferSubData");
         final var gl32 = RedirectMap.newMap()
             .add("glFramebufferTexture");
         final var gl33 = RedirectMap.newMap()
@@ -376,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);
@@ -391,6 +415,7 @@ public class GLSMRedirector {
         glMethodRedirects.putAll(gl42);
         glMethodRedirects.putAll(gl43);
         glMethodRedirects.putAll(gl44);
+        glMethodRedirects.putAll(gl45);
 
         // MINECRAFT
         methodRedirects.put(OpenGlHelper, RedirectMap.newMap()
@@ -455,6 +480,39 @@ public class GLSMRedirector {
         methodRedirects.put(ARBInstancedArrays, RedirectMap.newMap()
             .add("glVertexAttribDivisorARB")
         );
+        methodRedirects.put(ARBDrawInstanced, RedirectMap.newMap()
+            .add("glDrawArraysInstancedARB", "glDrawArraysInstanced")
+            .add("glDrawElementsInstancedARB", "glDrawElementsInstanced")
+        );
+        methodRedirects.put(EXTDrawInstanced, RedirectMap.newMap()
+            .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()
@@ -587,18 +645,16 @@ public class GLSMRedirector {
                         }
                     } else {
                         final Map<String, String> redirects = mNode.owner.startsWith(GL_PREFIX) ? glMethodRedirects : methodRedirects.get(mNode.owner);
-                        if (redirects != null) {
-                            final String glsmName = redirects.get(mNode.name);
-                            if (glsmName != null) {
-                                if (LOG_SPAM) {
-                                    final String shortOwner = mNode.owner.substring(mNode.owner.lastIndexOf("/") + 1);
-                                    LOGGER.info("Redirecting call in {} from {}.{}{} to GLStateManager.{}{}", transformedName, shortOwner, mNode.name, mNode.desc, glsmName, mNode.desc);
-                                }
-                                mNode.owner = GLStateManager;
-                                mNode.name = glsmName;
-                                changed = true;
-                                redirectInMethod = true;
+                        final String glsmName = redirects != null ? redirects.get(mNode.name) : null;
+                        if (glsmName != null) {
+                            if (LOG_SPAM) {
+                                final String shortOwner = mNode.owner.substring(mNode.owner.lastIndexOf("/") + 1);
+                                LOGGER.info("Redirecting call in {} from {}.{}{} to GLStateManager.{}{}", transformedName, shortOwner, mNode.name, mNode.desc, glsmName, mNode.desc);
                             }
+                            mNode.owner = GLStateManager;
+                            mNode.name = glsmName;
+                            changed = true;
+                            redirectInMethod = true;
                         }
                     }
                     // Redirect <init> calls for quadric classes
@@ -617,8 +673,7 @@ public class GLSMRedirector {
                     for (int i = 0; i < dynNode.bsmArgs.length; i++) {
                         if (!(dynNode.bsmArgs[i] instanceof Handle handle)) continue;
                         final Map<String, String> redirects = handle.getOwner().startsWith(GL_PREFIX) ? glMethodRedirects : methodRedirects.get(handle.getOwner());
-                        if (redirects == null) continue;
-                        final String glsmName = redirects.get(handle.getName());
+                        final String glsmName = redirects != null ? redirects.get(handle.getName()) : null;
                         if (glsmName == null) continue;
                         if (LOG_SPAM) {
                             final String shortOwner = handle.getOwner().substring(handle.getOwner().lastIndexOf("/") + 1);

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

@@ -0,0 +1,51 @@
+package com.gtnewhorizons.angelica.glsm.states;
+
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
+
+/**
+ * Immutable client-side pixel unpack state (glPixelStore UNPACK_* params)
+ */
+public record PixelUnpackState(
+    int alignment,
+    int rowLength,
+    int skipRows,
+    int skipPixels,
+    int imageHeight,
+    int skipImages,
+    boolean swapBytes,
+    boolean lsbFirst
+) {
+    public static final PixelUnpackState DEFAULT = new PixelUnpackState(4, 0, 0, 0, 0, 0, false, false);
+
+    public boolean isDefault() {
+        return this.equals(DEFAULT);
+    }
+
+    public PixelUnpackState with(int pname, int param) {
+        return switch (pname) {
+            case GL11.GL_UNPACK_ALIGNMENT -> (param == 1 || param == 2 || param == 4 || param == 8) ? new PixelUnpackState(param, rowLength, skipRows, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst) : this;
+            case GL11.GL_UNPACK_ROW_LENGTH -> param >= 0 ? new PixelUnpackState(alignment, param, skipRows, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst) : this;
+            case GL11.GL_UNPACK_SKIP_ROWS -> param >= 0 ? new PixelUnpackState(alignment, rowLength, param, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst) : this;
+            case GL11.GL_UNPACK_SKIP_PIXELS -> param >= 0 ? new PixelUnpackState(alignment, rowLength, skipRows, param, imageHeight, skipImages, swapBytes, lsbFirst) : this;
+            case GL12.GL_UNPACK_IMAGE_HEIGHT -> param >= 0 ? new PixelUnpackState(alignment, rowLength, skipRows, skipPixels, param, skipImages, swapBytes, lsbFirst) : this;
+            case GL12.GL_UNPACK_SKIP_IMAGES -> param >= 0 ? new PixelUnpackState(alignment, rowLength, skipRows, skipPixels, imageHeight, param, swapBytes, lsbFirst) : this;
+            case GL11.GL_UNPACK_SWAP_BYTES -> new PixelUnpackState(alignment, rowLength, skipRows, skipPixels, imageHeight, skipImages, param != 0, lsbFirst);
+            case GL11.GL_UNPACK_LSB_FIRST -> new PixelUnpackState(alignment, rowLength, skipRows, skipPixels, imageHeight, skipImages, swapBytes, param != 0);
+            default -> this;
+        };
+    }
+
+    public static void applyDiff(PixelUnpackState from, PixelUnpackState to) {
+        if (from.alignment != to.alignment) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_ALIGNMENT, to.alignment);
+        if (from.rowLength != to.rowLength) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_ROW_LENGTH, to.rowLength);
+        if (from.skipRows != to.skipRows) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_SKIP_ROWS, to.skipRows);
+        if (from.skipPixels != to.skipPixels) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_SKIP_PIXELS, to.skipPixels);
+        if (from.imageHeight != to.imageHeight) RENDER_BACKEND.pixelStorei(GL12.GL_UNPACK_IMAGE_HEIGHT, to.imageHeight);
+        if (from.skipImages != to.skipImages) RENDER_BACKEND.pixelStorei(GL12.GL_UNPACK_SKIP_IMAGES, to.skipImages);
+        if (from.swapBytes != to.swapBytes) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_SWAP_BYTES, to.swapBytes ? 1 : 0);
+        if (from.lsbFirst != to.lsbFirst) RENDER_BACKEND.pixelStorei(GL11.GL_UNPACK_LSB_FIRST, to.lsbFirst ? 1 : 0);
+    }
+}

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

@@ -1,198 +0,0 @@
-package com.gtnewhorizons.angelica.glsm.states;
-
-import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
-
-import org.lwjgl.opengl.GL11;
-
-import java.nio.ByteBuffer;
-import java.util.ArrayDeque;
-
-/**
- * Per-VAO vertex attribute pointer state tracking (Mesa-style).
- */
-public class VertexAttribState {
-    public static final int MAX_ATTRIBS = 16;
-
-    private static final Int2ObjectOpenHashMap<Attrib[]> vaoAttribs = new Int2ObjectOpenHashMap<>();
-    private static Attrib[] current;
-    private static final ArrayDeque<Attrib[]> pool = new ArrayDeque<>();
-    private static int clientSideEnabledCount;
-
-    public static void init(int defaultVAO) {
-        vaoAttribs.clear();
-        pool.clear();
-        current = allocAttribArray();
-        vaoAttribs.put(defaultVAO, current);
-        clientSideEnabledCount = 0;
-    }
-
-    public static void onBindVertexArray(int newVAO) {
-        current = vaoAttribs.computeIfAbsent(newVAO, k -> allocAttribArray());
-        recomputeClientSideCount();
-    }
-
-    public static void onDeleteVertexArray(int vaoId) {
-        final Attrib[] arr = vaoAttribs.remove(vaoId);
-        if (arr != null) {
-            pool.addLast(arr);
-        }
-    }
-
-    public static void reset() {
-        vaoAttribs.clear();
-        pool.clear();
-        current = null;
-        clientSideEnabledCount = 0;
-    }
-
-    private static Attrib[] allocAttribArray() {
-        Attrib[] arr = pool.pollFirst();
-        if (arr != null) {
-            for (Attrib a : arr) a.reset();
-            return arr;
-        }
-        arr = new Attrib[MAX_ATTRIBS];
-        for (int i = 0; i < MAX_ATTRIBS; i++) arr[i] = new Attrib();
-        return arr;
-    }
-
-    public static void set(int index, int size, int type, boolean normalized, int stride, long offset, int vboId) {
-        if (index < 0 || index >= MAX_ATTRIBS) return;
-        final Attrib a = current[index];
-        final boolean was = a.isClientSide();
-        a.size = size;
-        a.type = type;
-        a.normalized = normalized;
-        a.stride = stride;
-        a.offset = offset;
-        a.vboId = vboId;
-        a.clientPointer = null;
-        if (was) clientSideEnabledCount--;
-    }
-
-    public static void set(int index, int size, int type, boolean normalized, int stride, ByteBuffer pointer, int vboId) {
-        if (index < 0 || index >= MAX_ATTRIBS) return;
-        final Attrib a = current[index];
-        final boolean was = a.isClientSide();
-        a.size = size;
-        a.type = type;
-        a.normalized = normalized;
-        a.stride = stride;
-        a.offset = 0;
-        a.vboId = vboId;
-        a.clientPointer = (vboId == 0) ? pointer : null;
-        final boolean now = a.isClientSide();
-        if (was != now) clientSideEnabledCount += now ? 1 : -1;
-    }
-
-    public static void setEnabled(int index, boolean enabled) {
-        if (index < 0 || index >= MAX_ATTRIBS) return;
-        final Attrib a = current[index];
-        if (a.clientPointer != null && a.enabled != enabled) {
-            clientSideEnabledCount += enabled ? 1 : -1;
-        }
-        a.enabled = enabled;
-    }
-
-    public static Attrib get(int index) {
-        return current[index];
-    }
-
-
-
-    private static void recomputeClientSideCount() {
-        int count = 0;
-        for (int i = 0; i < MAX_ATTRIBS; i++) {
-            if (current[i].isClientSide()) count++;
-        }
-        clientSideEnabledCount = count;
-    }
-
-    /**
-     * Returns true if any currently enabled vertex attribute was registered without a VBO
-     * (i.e. as a client-side pointer). In core profile, such attribs are treated as null
-     * offsets into a non-existent buffer, causing a native crash at draw time.
-     */
-    public static boolean hasAnyClientSideEnabledAttrib() {
-        return clientSideEnabledCount > 0;
-    }
-    public static class Attrib {
-        public boolean enabled;
-        public int size;
-        public int type;
-        public boolean normalized;
-        public int stride;
-        public long offset;
-        public int vboId;
-        public ByteBuffer clientPointer;
-
-        public boolean isClientSide() {
-            return enabled && clientPointer != null;
-        }
-
-        public void reset() {
-            enabled = false;
-            size = 0;
-            type = 0;
-            normalized = false;
-            stride = 0;
-            offset = 0;
-            vboId = 0;
-            clientPointer = null;
-        }
-
-        public int effectiveStride() {
-            return (stride != 0) ? stride : size * typeSizeBytes();
-        }
-
-        public int typeSizeBytes() {
-            return glTypeSizeBytes(type);
-        }
-
-        public static int glTypeSizeBytes(int glType) {
-            return switch (glType) {
-                case GL11.GL_FLOAT, GL11.GL_INT, GL11.GL_UNSIGNED_INT -> 4;
-                case GL11.GL_DOUBLE -> 8;
-                case GL11.GL_SHORT, GL11.GL_UNSIGNED_SHORT -> 2;
-                case GL11.GL_BYTE, GL11.GL_UNSIGNED_BYTE -> 1;
-                default -> 4;
-            };
-        }
-
-        public float readComponent(ByteBuffer buf, int base, int component) {
-            return readComponent(type, normalized, buf, base, component);
-        }
-
-        public static float readComponent(int type, boolean normalized, ByteBuffer buf, int base, int component) {
-            return switch (type) {
-                case GL11.GL_FLOAT -> buf.getFloat(base + component * 4);
-                case GL11.GL_DOUBLE -> (float) buf.getDouble(base + component * 8);
-                case GL11.GL_INT -> {
-                    final int v = buf.getInt(base + component * 4);
-                    yield normalized ? v / (float) Integer.MAX_VALUE : (float) v;
-                }
-                case GL11.GL_UNSIGNED_INT -> {
-                    final int v = buf.getInt(base + component * 4);
-                    yield normalized ? (v & 0xFFFFFFFFL) / (float) 0xFFFFFFFFL : (float) (v & 0xFFFFFFFFL);
-                }
-                case GL11.GL_SHORT -> {
-                    final short v = buf.getShort(base + component * 2);
-                    yield normalized ? v / (float) Short.MAX_VALUE : (float) v;
-                }
-                case GL11.GL_UNSIGNED_SHORT -> {
-                    final int v = buf.getShort(base + component * 2) & 0xFFFF;
-                    yield normalized ? v / (float) 0xFFFF : (float) v;
-                }
-                case GL11.GL_BYTE -> {
-                    final byte v = buf.get(base + component);
-                    yield normalized ? v / 127.0f : (float) v;
-                }
-                case GL11.GL_UNSIGNED_BYTE -> {
-                    final int v = buf.get(base + component) & 0xFF;
-                    yield normalized ? v / 255.0f : (float) v;
-                }
-                default -> 0.0f;
-            };
-        }
-    }
-}

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/streaming/PersistentStreamingBuffer.java

@@ -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;

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/streaming/TessellatorStreamingDrawer.java

@@ -7,7 +7,6 @@ import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.QuadConverter;
 import com.gtnewhorizons.angelica.glsm.RenderSystem;
-import com.gtnewhorizons.angelica.glsm.ffp.ShaderManager;
 import net.minecraft.client.renderer.Tessellator;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -89,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)) {
@@ -188,30 +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;
-        }
-
-        GLStateManager.prepareWideLineEmulation(drawMode);
-        ShaderManager.getInstance().preDraw(flags);
-        drawWithQuadConversion(drawMode, firstVertex, vertexCount);
-        GLStateManager.glBindVertexArray(0);
-        GLStateManager.glDisableClientState(GL11.GL_VERTEX_ARRAY);
-        GLStateManager.glDisableClientState(GL11.GL_TEXTURE_COORD_ARRAY);
-        GLStateManager.glDisableClientState(GL11.GL_COLOR_ARRAY);
-        GLStateManager.glDisableClientState(GL11.GL_NORMAL_ARRAY);
     }
 
     private static void drawWithQuadConversion(int drawMode, int firstVertex, int vertexCount) {

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

@@ -17,6 +17,7 @@ public class TextureInfo {
     @Getter @Setter protected int magFilter = GL11.GL_LINEAR;
     @Getter @Setter protected int wrapS = GL11.GL_REPEAT;
     @Getter @Setter protected int wrapT = GL11.GL_REPEAT;
+    @Getter @Setter protected int baseLevel = 0;
     @Getter @Setter protected int maxLevel = 1000;
     @Getter @Setter protected int minLod = -1000;
     @Getter @Setter protected int maxLod = 1000;
@@ -24,6 +25,8 @@ public class TextureInfo {
 
     @Getter @Setter protected float maxAnisotropy = 1.0f;
 
+    @Getter @Setter protected boolean generateMipmap = false;
+
     protected TextureInfo(int id) {
         this.id = id;
     }

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

@@ -0,0 +1,102 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import org.junit.jupiter.api.Test;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL20;
+
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@GLCoreTest
+class ArrayUniformUploadGLTest {
+
+    private static int compile(int type, String src) {
+        final int s = GL20.glCreateShader(type);
+        GL20.glShaderSource(s, src);
+        GL20.glCompileShader(s);
+        assertEquals(GL11.GL_TRUE, GL20.glGetShaderi(s, GL20.GL_COMPILE_STATUS), () -> "shader compile failed: " + GL20.glGetShaderInfoLog(s, 4096));
+        return s;
+    }
+
+    private static int link(String vs, String fs) {
+        final int v = compile(GL20.GL_VERTEX_SHADER, vs);
+        final int f = compile(GL20.GL_FRAGMENT_SHADER, fs);
+        final int p = GL20.glCreateProgram();
+        GL20.glAttachShader(p, v);
+        GL20.glAttachShader(p, f);
+        GL20.glLinkProgram(p);
+        assertEquals(GL11.GL_TRUE, GL20.glGetProgrami(p, GL20.GL_LINK_STATUS), () -> "link failed: " + GL20.glGetProgramInfoLog(p, 4096));
+        GL20.glDeleteShader(v);
+        GL20.glDeleteShader(f);
+        return p;
+    }
+
+    private static final String VS = "#version 330 core\nvoid main(){ gl_Position = vec4(0.0); }\n";
+
+    @Test
+    void glUniform2FloatBufferUploadsWholeArray() {
+        // Runtime index keeps the whole array active so element locations stay queryable.
+        final String fs = "#version 330 core\n"
+            + "uniform vec2 cosmicuvs[10];\n"
+            + "uniform int idx;\n"
+            + "out vec4 o;\n"
+            + "void main(){ o = vec4(cosmicuvs[idx], cosmicuvs[(idx+1)%10]); }\n";
+        final int p = link(VS, fs);
+        try {
+            GL20.glUseProgram(p);
+
+            final FloatBuffer buf = BufferUtils.createFloatBuffer(20);
+            for (int i = 0; i < 20; i++) buf.put(i + 1.0f); // 1..20, all distinct, all non-zero
+            buf.flip();
+
+            GLStateManager.glUniform2(GL20.glGetUniformLocation(p, "cosmicuvs"), buf);
+
+            final FloatBuffer read = BufferUtils.createFloatBuffer(2);
+            for (int i = 0; i < 10; i++) {
+                final int loc = GL20.glGetUniformLocation(p, "cosmicuvs[" + i + "]");
+                assertTrue(loc >= 0, "element " + i + " optimized out");
+                read.clear();
+                GL20.glGetUniform(p, loc, read);
+                assertEquals(2 * i + 1.0f, read.get(0), 0.0f, "cosmicuvs[" + i + "].x");
+                assertEquals(2 * i + 2.0f, read.get(1), 0.0f, "cosmicuvs[" + i + "].y");
+            }
+        } finally {
+            GL20.glUseProgram(0);
+            GL20.glDeleteProgram(p);
+        }
+    }
+
+    @Test
+    void glUniform1IntBufferUploadsWholeArray() {
+        final String fs = "#version 330 core\n"
+            + "uniform int vals[4];\n"
+            + "uniform int idx;\n"
+            + "out vec4 o;\n"
+            + "void main(){ o = vec4(float(vals[idx])); }\n";
+        final int p = link(VS, fs);
+        try {
+            GL20.glUseProgram(p);
+
+            final IntBuffer buf = BufferUtils.createIntBuffer(4);
+            buf.put(11).put(22).put(33).put(44).flip();
+            GLStateManager.glUniform1(GL20.glGetUniformLocation(p, "vals"), buf);
+
+            final IntBuffer read = BufferUtils.createIntBuffer(1);
+            final int[] expect = {11, 22, 33, 44};
+            for (int i = 0; i < 4; i++) {
+                final int loc = GL20.glGetUniformLocation(p, "vals[" + i + "]");
+                assertTrue(loc >= 0, "element " + i + " optimized out");
+                read.clear();
+                GL20.glGetUniform(p, loc, read);
+                assertEquals(expect[i], read.get(0), "vals[" + i + "]");
+            }
+        } finally {
+            GL20.glUseProgram(0);
+            GL20.glDeleteProgram(p);
+        }
+    }
+}

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

@@ -1,6 +1,8 @@
 package com.gtnewhorizons.angelica.glsm;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -613,4 +615,239 @@ class CompatShaderTransformerTest {
         assertFalse(result.matches("(?s).*\\bnew\\b(?!\\s*\\().*"), "'new' as identifier must be renamed in core profile output\n\n" + result);
         assertTrue(result.contains("angelica_renamed_new"), "'new' should be renamed to angelica_renamed_new\n\n" + result);
     }
+
+    private static String compact(String s) {
+        return s.replaceAll("\\s+", "");
+    }
+
+    private static String core(String src) {
+        return compact(CompatShaderTransformer.transform(src, false));
+    }
+
+    private static void assertLoc(String c, int loc, String decl) {
+        assertTrue(c.contains(compact("layout(location=" + loc + ")in" + decl)), decl + " expected at location " + loc + "\n\n" + c);
+    }
+
+    private static void assertNoLoc(String c, int loc, String decl) {
+        assertFalse(c.contains(compact("layout(location=" + loc + ")in" + decl)), decl + " must not be at location " + loc + "\n\n" + c);
+    }
+
+    @Test
+    void testCustomPositionAttributePinnedToLocationZero() {
+        // Betweenlands blshader fix
+        String src = """
+            #version 120
+            attribute vec4 a_position;
+            uniform mat4 u_projMat;
+            uniform vec2 u_outSize;
+            varying vec2 v_texCoord;
+            void main(){
+                gl_Position = u_projMat * vec4(a_position.xy, 0.0, 1.0);
+                v_texCoord = a_position.xy / u_outSize;
+            }
+            """;
+
+        String result = CompatShaderTransformer.transform(src, false);
+        assertLoc(compact(result), 0, "vec4 a_position");
+        assertTrue(result.contains("#version 330 core"), result);
+    }
+
+    @Test
+    void testMultipleLocationlessInputsGetSequentialLocations() {
+        String c = core("""
+            #version 120
+            attribute vec4 a_pos;
+            attribute vec2 a_uv;
+            varying vec2 v_uv;
+            void main() {
+                v_uv = a_uv;
+                gl_Position = vec4(a_pos.xy, 0.0, 1.0);
+            }
+            """);
+        assertLoc(c, 0, "vec4 a_pos");
+        assertLoc(c, 1, "vec2 a_uv");
+    }
+
+    @Test
+    void testCustomInputReservesAroundGlVertex() {
+        String c = core("""
+            #version 120
+            attribute vec4 a_foo;
+            void main() {
+                gl_Position = ftransform() + a_foo;
+            }
+            """);
+        assertLoc(c, 0, "vec4 angelica_Vertex");
+        assertLoc(c, 1, "vec4 a_foo");
+    }
+
+    @Test
+    void testCustomInputSkipsFfpSlots() {
+        String c = core("""
+            #version 120
+            attribute vec4 a_foo;
+            void main() {
+                gl_Position = vec4(a_foo.xy, 0.0, 1.0) + gl_Color;
+            }
+            """);
+        assertLoc(c, 0, "vec4 a_foo");
+        assertLoc(c, 1, "vec4 angelica_Color");
+    }
+
+    @Test
+    void testExplicitLowLocationReserved() {
+        String c = core("""
+            #version 120
+            layout(location = 0) in vec4 a_x;
+            attribute vec4 a_y;
+            void main() {
+                gl_Position = a_x + a_y;
+            }
+            """);
+        assertLoc(c, 0, "vec4 a_x");
+        assertLoc(c, 1, "vec4 a_y");
+    }
+
+    @Test
+    void testMatrixInputSortedFirst() {
+        String c = core("""
+            #version 120
+            attribute vec4 a_a;
+            attribute mat4 a_m;
+            void main() {
+                gl_Position = a_m * a_a;
+            }
+            """);
+        assertLoc(c, 0, "mat4 a_m");   // 4-slot matrix sorted first
+        assertLoc(c, 4, "vec4 a_a");
+    }
+
+    @Test
+    void testInputNamedLocationStillPinned() {
+        assertLoc(core("""
+            #version 120
+            attribute vec4 a_location;
+            void main() {
+                gl_Position = vec4(a_location.xy, 0.0, 1.0);
+            }
+            """), 0, "vec4 a_location");
+    }
+
+    @Test
+    void testInputWithExplicitLayoutLeftAlone() {
+        String c = core("""
+            #version 120
+            layout(location = 3) in vec4 a_data;
+            attribute vec4 a_position;
+            varying vec2 v_uv;
+            void main() {
+                v_uv = a_data.xy;
+                gl_Position = vec4(a_position.xy, 0.0, 1.0);
+            }
+            """);
+        assertLoc(c, 0, "vec4 a_position");   // sole location-less input
+        assertLoc(c, 3, "vec4 a_data");       // explicit location preserved
+        assertNoLoc(c, 0, "vec4 a_data");
+    }
+
+    @Test
+    void testPinnedShaderRemainsWellFormed() {
+        String src = """
+            #version 120
+            attribute vec4 a_position;
+            void main() {
+                gl_FrontColor = gl_Color;
+                gl_TexCoord[0] = gl_MultiTexCoord0;
+                gl_Position = gl_ModelViewMatrix * vec4(a_position.xyz, 1.0);
+            }
+            """;
+
+        String result = CompatShaderTransformer.transform(src, false);
+        String c = compact(result);
+        assertLoc(c, 0, "vec4 a_position");
+        assertLoc(c, 1, "vec4 angelica_Color");
+        assertTrue(c.contains("uniformmat4angelica_ModelViewMatrix"), "matrix uniform injected\n\n" + result);
+        assertFalse(c.contains("gl_ModelViewMatrix"), "builtin rewritten (not fallback)\n\n" + result);
+
+        final int mainIdx = result.indexOf("void main");
+        assertTrue(mainIdx > 0, result);
+        assertTrue(result.indexOf("angelica_ModelViewMatrix") < mainIdx, "uniform before main\n\n" + result);
+        assertTrue(result.indexOf("a_position") < mainIdx, "pinned input before main\n\n" + result);
+    }
+
+    @Test
+    void testGlVertexShaderDoesNotPinCustomAttribute() {
+        String c = core("""
+            #version 120
+            attribute float activelights;
+            void main() {
+                gl_Position = ftransform();
+                float x = activelights;
+            }
+            """);
+        assertLoc(c, 0, "vec4 angelica_Vertex");
+        assertNoLoc(c, 0, "float activelights");
+    }
+
+    @ParameterizedTest   // array on the declarator (vec4 a[2]) and on the type (vec4[2] a) must both round-trip
+    @ValueSource(strings = {"attribute vec4 positions[2];", "attribute vec4[2] positions;"})
+    void testArrayAttributePreservedEitherSyntax(String decl) {
+        String c = core("""
+            #version 120
+            %s
+            attribute vec4 a_tail;
+            void main() {
+                gl_Position = positions[0] + positions[1] + a_tail;
+            }
+            """.formatted(decl));
+        assertLoc(c, 0, "vec4 positions[2]");   // 2-slot array pinned to 0..1
+        assertLoc(c, 2, "vec4 a_tail");
+    }
+
+    @Test
+    void testMultiDeclaratorSplitIntoSeparateLocations() {
+        String result = CompatShaderTransformer.transform("""
+            #version 120
+            attribute vec4 a, b;
+            void main() {
+                gl_Position = a + b;
+            }
+            """, false);
+        String c = compact(result);
+        assertLoc(c, 0, "vec4 a");
+        assertLoc(c, 1, "vec4 b");
+        assertFalse(result.matches("(?s).*\\battribute\\b.*"), "no deprecated 'attribute' keyword may survive\n\n" + result);
+        assertTrue(result.contains("#version 330 core"), result);
+    }
+
+    @Test
+    void testMultiDeclaratorWithMixedArray() {
+        String result = CompatShaderTransformer.transform("""
+            #version 120
+            attribute vec4 a, b[2];
+            void main() {
+                gl_Position = a + b[0] + b[1];
+            }
+            """, false);
+        String c = compact(result);
+        // b takes 2 slots; sorted before the 1-slot a, so b -> 0..1, a -> 2.
+        assertLoc(c, 0, "vec4 b[2]");
+        assertLoc(c, 2, "vec4 a");
+        assertFalse(result.matches("(?s).*\\battribute\\b.*"), "no deprecated 'attribute' keyword may survive\n\n" + result);
+    }
+
+    @Test
+    void testHexExplicitLocationReserved() {
+        String c = core("""
+            #version 120
+            layout(location = 0x1) in vec4 a_x;
+            attribute vec4 a_y;
+            void main() {
+                gl_Position = a_x + a_y;
+            }
+            """);
+        assertTrue(c.contains("layout(location=0x1)invec4a_x"), "hex explicit location preserved\n\n" + c);
+        assertNoLoc(c, 1, "vec4 a_y");   // must not collide with the hex-reserved slot
+        assertLoc(c, 0, "vec4 a_y");
+    }
 }

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

@@ -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;
@@ -21,7 +20,7 @@ class CompatUniformManagerTest {
     void cleanup() {
         if (program != 0) {
             GL20.glUseProgram(0);
-            GL20.glDeleteProgram(program);
+            GLStateManager.glDeleteProgram(program);
             program = 0;
         }
     }

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

@@ -3,19 +3,20 @@ 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.assertDoesNotThrow;
 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.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;
@@ -257,4 +258,30 @@ class DisplayListCompilationGLSMTest {
 
         GLStateManager.glEndList();
     }
+
+    @Test
+    void glsm_unsupportedOpInList_abortsCleanly() {
+        testList = GL11.glGenLists(1);
+        GLStateManager.glNewList(testList, GL11.GL_COMPILE);
+        assertTrue(DisplayListManager.isRecording(), "recording after glNewList");
+
+        assertThrows(UnsupportedOperationException.class, () -> GLStateManager.glReadBuffer(GL11.GL_FRONT));
+
+        assertFalse(DisplayListManager.isRecording(), "recording state must be reset after an in-list throw");
+        assertEquals(DisplayListManager.RecordMode.NONE, DisplayListManager.getRecordMode());
+
+        assertDoesNotThrow(() -> GLStateManager.glReadBuffer(GL11.GL_FRONT));
+        assertDoesNotThrow(GLStateManager::glEndList);
+    }
+
+    @Test
+    void glsm_abortIfLeaked_recoversOpenList() {
+        testList = GL11.glGenLists(1);
+        GLStateManager.glNewList(testList, GL11.GL_COMPILE);
+        assertTrue(DisplayListManager.isRecording());
+
+        DisplayListManager.abortIfLeaked();
+
+        assertFalse(DisplayListManager.isRecording(), "frame-begin backstop must clear a leaked open list");
+    }
 }

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

@@ -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;

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

@@ -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

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

@@ -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 {
+}

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

@@ -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 {
+}

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

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

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

@@ -1,7 +1,5 @@
 package com.gtnewhorizons.angelica.glsm;
 
-import com.gtnewhorizons.angelica.glsm.GLDebug;
-import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.hooks.GLSMInitConfig;
 import org.junit.jupiter.api.extension.AfterEachCallback;
 import org.junit.jupiter.api.extension.BeforeAllCallback;
@@ -10,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;
 
@@ -47,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;
@@ -57,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;
@@ -83,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();
         }
     }
 
@@ -97,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);

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

@@ -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

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

@@ -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) {}
+        }
+    }
+}

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

@@ -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));
+    }
+}

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

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

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

@@ -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) {

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

@@ -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;

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

@@ -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;

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

@@ -0,0 +1,214 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.lwjgl.opengl.GL11;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+@GLCoreTest
+public class GLSM_DisplayList_PixelStore_Test {
+
+    private static final int SRC = 8;
+    private static final int SUB = 4;
+
+    @AfterEach
+    void resetUnpackState() {
+        GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 4);
+        setUnpack(0, 0, 0);
+    }
+
+    private static void setUnpack(int rowLength, int skipRows, int skipPixels) {
+        GLStateManager.glPixelStorei(GL11.GL_UNPACK_ROW_LENGTH, rowLength);
+        GLStateManager.glPixelStorei(GL11.GL_UNPACK_SKIP_ROWS, skipRows);
+        GLStateManager.glPixelStorei(GL11.GL_UNPACK_SKIP_PIXELS, skipPixels);
+    }
+
+    private static void setStridedUnpack() {
+        setUnpack(SRC, 1, 2);
+    }
+
+    /** RGBA source; red channel = y*size+x, alpha = 255. */
+    private static ByteBuffer makeSource(int size) {
+        final ByteBuffer buf = ByteBuffer.allocateDirect(size * size * 4).order(ByteOrder.nativeOrder());
+        for (int i = 0; i < size * size; i++) {
+            buf.put((byte) i).put((byte) 0).put((byte) 0).put((byte) 255);
+        }
+        buf.flip();
+        return buf;
+    }
+
+    private static int makeTexture(int size, ByteBuffer pixels) {
+        final int tex = GLStateManager.glGenTextures();
+        GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, tex);
+        GLStateManager.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, size, size, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixels);
+        return tex;
+    }
+
+    private static ByteBuffer readback(int size) {
+        final ByteBuffer out = ByteBuffer.allocateDirect(size * size * 4).order(ByteOrder.nativeOrder());
+        GLStateManager.glGetTexImage(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, out);
+        return out;
+    }
+
+    private static int red(ByteBuffer pixels, int size, int x, int y) {
+        return pixels.get((y * size + x) * 4) & 0xFF;
+    }
+
+    private static void assertStridedSubImage(ByteBuffer pixels) {
+        for (int y = 0; y < SUB; y++) {
+            for (int x = 0; x < SUB; x++) {
+                assertEquals((y + 1) * SRC + (x + 2), red(pixels, SUB, x, y), "pixel (" + x + "," + y + ")");
+            }
+        }
+    }
+
+    private static void assertTightSubImage(ByteBuffer pixels) {
+        for (int y = 0; y < SUB; y++) {
+            for (int x = 0; x < SUB; x++) {
+                assertEquals(y * SUB + x, red(pixels, SUB, x, y), "pixel (" + x + "," + y + ")");
+            }
+        }
+    }
+
+    private static void assertUnpack(int rowLength, int skipRows, int skipPixels) {
+        assertEquals(rowLength, GL11.glGetInteger(GL11.GL_UNPACK_ROW_LENGTH));
+        assertEquals(skipRows, GL11.glGetInteger(GL11.GL_UNPACK_SKIP_ROWS));
+        assertEquals(skipPixels, GL11.glGetInteger(GL11.GL_UNPACK_SKIP_PIXELS));
+    }
+
+    @Test
+    void pixelStoreExecutesImmediatelyAndIsNotRecorded() {
+        final int list = GLStateManager.glGenLists(1);
+        GLStateManager.glNewList(list, GL11.GL_COMPILE);
+        GLStateManager.glPixelStorei(GL11.GL_UNPACK_ROW_LENGTH, 7);
+        assertEquals(7, GL11.glGetInteger(GL11.GL_UNPACK_ROW_LENGTH), "must execute immediately during recording");
+        GLStateManager.glEndList();
+        assertEquals(7, GL11.glGetInteger(GL11.GL_UNPACK_ROW_LENGTH), "must persist after glEndList");
+
+        GLStateManager.glPixelStorei(GL11.GL_UNPACK_ROW_LENGTH, 0);
+        GLStateManager.glCallList(list);
+        assertEquals(0, GL11.glGetInteger(GL11.GL_UNPACK_ROW_LENGTH), "must not have been recorded into the list");
+
+        GLStateManager.glDeleteLists(list, 1);
+    }
+
+    @Test
+    void stridedTexSubImage2DCompile() {
+        final int tex = makeTexture(SUB, ByteBuffer.allocateDirect(SUB * SUB * 4).order(ByteOrder.nativeOrder()));
+        final ByteBuffer src = makeSource(SRC);
+
+        setStridedUnpack();
+
+        final int list = GLStateManager.glGenLists(1);
+        GLStateManager.glNewList(list, GL11.GL_COMPILE);
+        GLStateManager.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, SUB, SUB, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, src);
+        GLStateManager.glEndList();
+
+        assertEquals(0, red(readback(SUB), SUB, 0, 0), "GL_COMPILE must not execute the upload");
+
+        setUnpack(0, 0, 0);
+
+        GLStateManager.glCallList(list);
+        assertStridedSubImage(readback(SUB));
+        assertUnpack(0, 0, 0);
+
+        GLStateManager.glDeleteLists(list, 1);
+        GLStateManager.glDeleteTextures(tex);
+    }
+
+    @Test
+    void stridedTexSubImage2DCompileAndExecute() {
+        final ByteBuffer zeros = ByteBuffer.allocateDirect(SUB * SUB * 4).order(ByteOrder.nativeOrder());
+        final int tex = makeTexture(SUB, zeros);
+        final ByteBuffer src = makeSource(SRC);
+
+        setStridedUnpack();
+
+        final int list = GLStateManager.glGenLists(1);
+        GLStateManager.glNewList(list, GL11.GL_COMPILE_AND_EXECUTE);
+        GLStateManager.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, SUB, SUB, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, src);
+        GLStateManager.glEndList();
+
+        assertStridedSubImage(readback(SUB));
+
+        setUnpack(0, 0, 0);
+        GLStateManager.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, SUB, SUB, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, zeros);
+
+        GLStateManager.glCallList(list);
+        assertStridedSubImage(readback(SUB));
+        assertUnpack(0, 0, 0);
+
+        GLStateManager.glDeleteLists(list, 1);
+        GLStateManager.glDeleteTextures(tex);
+    }
+
+    @Test
+    void stridedTexImage2DCompile() {
+        final int tex = makeTexture(SUB, ByteBuffer.allocateDirect(SUB * SUB * 4).order(ByteOrder.nativeOrder()));
+        final ByteBuffer src = makeSource(SRC);
+
+        setStridedUnpack();
+
+        final int list = GLStateManager.glGenLists(1);
+        GLStateManager.glNewList(list, GL11.GL_COMPILE);
+        GLStateManager.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, SUB, SUB, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, src);
+        GLStateManager.glEndList();
+
+        setUnpack(0, 0, 0);
+
+        GLStateManager.glCallList(list);
+        assertStridedSubImage(readback(SUB));
+        assertUnpack(0, 0, 0);
+
+        GLStateManager.glDeleteLists(list, 1);
+        GLStateManager.glDeleteTextures(tex);
+    }
+
+    @Test
+    void defaultRecordedTexSubImage2DReplaysWithDefaults() {
+        final int tex = makeTexture(SUB, ByteBuffer.allocateDirect(SUB * SUB * 4).order(ByteOrder.nativeOrder()));
+        final ByteBuffer src = makeSource(SUB);
+
+        final int list = GLStateManager.glGenLists(1);
+        GLStateManager.glNewList(list, GL11.GL_COMPILE);
+        GLStateManager.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, SUB, SUB, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, src);
+        GLStateManager.glEndList();
+
+        GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1);
+        setStridedUnpack();
+
+        GLStateManager.glCallList(list);
+        assertTightSubImage(readback(SUB));
+        assertEquals(1, GL11.glGetInteger(GL11.GL_UNPACK_ALIGNMENT), "live state must survive replay");
+        assertUnpack(SRC, 1, 2);
+
+        GLStateManager.glDeleteLists(list, 1);
+        GLStateManager.glDeleteTextures(tex);
+    }
+
+    @Test
+    void defaultRecordedTexImage2DReplaysWithDefaults() {
+        final int tex = makeTexture(SUB, ByteBuffer.allocateDirect(SUB * SUB * 4).order(ByteOrder.nativeOrder()));
+        final ByteBuffer src = makeSource(SUB);
+
+        final int list = GLStateManager.glGenLists(1);
+        GLStateManager.glNewList(list, GL11.GL_COMPILE);
+        GLStateManager.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, SUB, SUB, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, src);
+        GLStateManager.glEndList();
+
+        GLStateManager.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1);
+        setStridedUnpack();
+
+        GLStateManager.glCallList(list);
+        assertTightSubImage(readback(SUB));
+        assertEquals(1, GL11.glGetInteger(GL11.GL_UNPACK_ALIGNMENT), "live state must survive replay");
+        assertUnpack(SRC, 1, 2);
+
+        GLStateManager.glDeleteLists(list, 1);
+        GLStateManager.glDeleteTextures(tex);
+    }
+}

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

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

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

@@ -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;

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

@@ -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

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

@@ -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);

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

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

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

@@ -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));
+    }
+}

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

@@ -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);

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

@@ -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

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

@@ -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;

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

@@ -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

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

@@ -1,11 +1,10 @@
 package com.gtnewhorizons.angelica.glsm;
 
 import com.gtnewhorizon.gtnhlib.client.opengl.UniversalVAO;
-import com.gtnewhorizons.angelica.glsm.states.VertexAttribState;
+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
@@ -122,6 +121,68 @@ public class GLSM_VAO_UnitTest {
         UniversalVAO.deleteVertexArrays(vao);
     }
 
+    @Test
+    void testGenericAttributeSupersedesFfpConventional() {
+        final int vao = UniversalVAO.genVertexArrays();
+        glBindVertexArray(vao);
+        final int vbo = GL15.glGenBuffers();
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
+
+        GLStateManager.glVertexAttribPointer(0, 1, GL11.GL_FLOAT, false, 0, 0L);
+        GLStateManager.glEnableVertexAttribArray(0);
+        GLStateManager.glVertexPointer(3, GL11.GL_FLOAT, 0, 0L);
+
+        Assertions.assertEquals(1, VAOManager.get(0).size, "enabled generic attribute must supersede the FFP conventional array at the same location");
+        Assertions.assertTrue(VAOManager.get(0).genericPointer, "location must remain generic-sourced");
+
+        GLStateManager.glDisableVertexAttribArray(0);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+        glBindVertexArray(0);
+        GL15.glDeleteBuffers(vbo);
+        UniversalVAO.deleteVertexArrays(vao);
+    }
+
+    @Test
+    void testGenericAttributeWinsRegardlessOfOrder() {
+        final int vao = UniversalVAO.genVertexArrays();
+        glBindVertexArray(vao);
+        final int vbo = GL15.glGenBuffers();
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
+
+        GLStateManager.glVertexPointer(3, GL11.GL_FLOAT, 0, 0L);
+        GLStateManager.glVertexAttribPointer(0, 1, GL11.GL_FLOAT, false, 0, 0L);
+        GLStateManager.glEnableVertexAttribArray(0);
+
+        Assertions.assertEquals(1, VAOManager.get(0).size, "generic attribute set after the FFP conventional array must still win");
+        Assertions.assertTrue(VAOManager.get(0).genericPointer, "location must remain generic-sourced");
+
+        GLStateManager.glDisableVertexAttribArray(0);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+        glBindVertexArray(0);
+        GL15.glDeleteBuffers(vbo);
+        UniversalVAO.deleteVertexArrays(vao);
+    }
+
+    @Test
+    void testFfpConventionalAppliesWithoutGenericAttribute() {
+        final int vao = UniversalVAO.genVertexArrays();
+        glBindVertexArray(vao);
+        final int vbo = GL15.glGenBuffers();
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
+
+        GLStateManager.glVertexPointer(3, GL11.GL_FLOAT, 0, 0L);
+        GLStateManager.glEnableClientState(GL11.GL_VERTEX_ARRAY);
+
+        Assertions.assertEquals(3, VAOManager.get(0).size, "plain FFP conventional array must apply when no generic attribute occupies the location");
+        Assertions.assertFalse(VAOManager.get(0).genericPointer, "location must be conventional-sourced");
+
+        GLStateManager.glDisableClientState(GL11.GL_VERTEX_ARRAY);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+        glBindVertexArray(0);
+        GL15.glDeleteBuffers(vbo);
+        UniversalVAO.deleteVertexArrays(vao);
+    }
+
     private static void testClientStates() {
         verifyState(GL11.GL_VERTEX_ARRAY, false, "GL_VERTEX_ARRAY Default State");
         verifyState(GL11.GL_TEXTURE_COORD_ARRAY, false, "GL_TEXTURE_COORD_ARRAY Default State");
@@ -133,7 +194,7 @@ public class GLSM_VAO_UnitTest {
     private static void glBindVertexArray(int array) {
         if (array == 0) array = GLStateManager.getDefaultVAO();
         GLStateManager.boundVAO = array;
-        VertexAttribState.onBindVertexArray(array);
+        VAOManager.onBindVertexArrayPre(array);
         UniversalVAO.bindVertexArray(array);
     }
 }

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

@@ -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() {}
+}

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

@@ -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));
+    }
+}

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

@@ -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");
+    }
+}

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

@@ -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);
+        }
+    }
+}

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

@@ -0,0 +1,104 @@
+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.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL15;
+import org.lwjgl.opengl.GL20;
+
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+
+@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";
+    private static final String FS = "#version 330 core\nout vec4 o;\nvoid main(){ o = vec4(1.0); }\n";
+
+    private int program;
+    private int vbo;
+    private int ebo;
+
+    @BeforeEach
+    void setup() {
+        program = buildProgram();
+        GLStateManager.glUseProgram(program);
+
+        final FloatBuffer verts = BufferUtils.createFloatBuffer(8);
+        verts.put(new float[] {0, 0, 1, 0, 1, 1, 0, 1}).flip();
+        vbo = GLStateManager.glGenBuffers();
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
+        GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, verts, GL15.GL_STATIC_DRAW);
+        GLStateManager.glVertexAttribPointer(0, 2, GL11.GL_FLOAT, false, 0, 0L);
+        GLStateManager.glEnableVertexAttribArray(0);
+
+        final IntBuffer idx = BufferUtils.createIntBuffer(4);
+        idx.put(new int[] {0, 1, 2, 3}).flip();
+        ebo = GLStateManager.glGenBuffers();
+        GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, ebo);
+        GLStateManager.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, idx, GL15.GL_STATIC_DRAW);
+
+        drainErrors();
+    }
+
+    @AfterEach
+    void cleanup() {
+        GLStateManager.glUseProgram(0);
+        if (program != 0) GL20.glDeleteProgram(program);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+        GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
+        if (vbo != 0) GLStateManager.glDeleteBuffers(vbo);
+        if (ebo != 0) GLStateManager.glDeleteBuffers(ebo);
+        drainErrors();
+    }
+
+    @Test
+    void drawArraysInstanced_quads_noInvalidEnum() {
+        GLStateManager.glDrawArraysInstanced(GL11.GL_QUADS, 0, 4, 3);
+        assertEquals(GL11.GL_NO_ERROR, GL11.glGetError(), "GL_QUADS instanced array draw must be emulated, not rejected");
+    }
+
+    @Test
+    void drawArraysInstanced_triangles_fastPathClean() {
+        GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
+        GLStateManager.glDrawArraysInstanced(GL11.GL_TRIANGLES, 0, 3, 3);
+        assertEquals(GL11.GL_NO_ERROR, GL11.glGetError(), "non-quad instanced array draw passes through cleanly");
+    }
+
+    @Test
+    void drawElementsInstanced_quads_noInvalidEnum() {
+        GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, ebo);
+        GLStateManager.glDrawElementsInstanced(GL11.GL_QUADS, 4, GL11.GL_UNSIGNED_INT, 0L, 3);
+        assertEquals(GL11.GL_NO_ERROR, GL11.glGetError(), "GL_QUADS instanced element draw must be emulated, not rejected");
+    }
+
+    private static int buildProgram() {
+        final int vs = compile(GL20.GL_VERTEX_SHADER, VS);
+        final int fs = compile(GL20.GL_FRAGMENT_SHADER, FS);
+        final int p = GL20.glCreateProgram();
+        GL20.glAttachShader(p, vs);
+        GL20.glAttachShader(p, fs);
+        GL20.glLinkProgram(p);
+        assertNotEquals(0, GL20.glGetProgrami(p, GL20.GL_LINK_STATUS), "test shader must link: " + GL20.glGetProgramInfoLog(p, 1024));
+        GL20.glDeleteShader(vs);
+        GL20.glDeleteShader(fs);
+        return p;
+    }
+
+    private static int compile(int type, String src) {
+        final int s = GL20.glCreateShader(type);
+        GL20.glShaderSource(s, src);
+        GL20.glCompileShader(s);
+        assertNotEquals(0, GL20.glGetShaderi(s, GL20.GL_COMPILE_STATUS), "test shader must compile: " + GL20.glGetShaderInfoLog(s, 1024));
+        return s;
+    }
+
+    private static void drainErrors() {
+        while (GL11.glGetError() != GL11.GL_NO_ERROR) { /* clear */ }
+    }
+}

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

@@ -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";

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

@@ -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
@@ -28,7 +27,7 @@ class VertexAttribDefaultBridgeTest {
     @Test
     void testGlColor4fSetsVertexAttrib() {
         GLStateManager.glColor4f(0.5f, 0.25f, 0.75f, 0.8f);
-        GLStateManager.flushDeferredVertexAttribs(0);
+        GLStateManager.flushDeferredVertexAttribs(false, false, false, false);
 
         float[] color = getVertexAttrib4f(COLOR_ATTRIB);
         assertEquals(0.5f, color[0], EPSILON, "color.r");
@@ -40,7 +39,7 @@ class VertexAttribDefaultBridgeTest {
     @Test
     void testGlNormal3fSetsVertexAttrib() {
         GLStateManager.glNormal3f(0.0f, 1.0f, 0.0f);
-        GLStateManager.flushDeferredVertexAttribs(0);
+        GLStateManager.flushDeferredVertexAttribs(false, false, false, false);
 
         float[] normal = getVertexAttrib4f(NORMAL_ATTRIB);
         assertEquals(0.0f, normal[0], EPSILON, "normal.x");
@@ -51,7 +50,7 @@ class VertexAttribDefaultBridgeTest {
     @Test
     void testSetLightmapTextureCoordsOnUnit1SetsVertexAttrib() {
         GLStateManager.setLightmapTextureCoords(GL13.GL_TEXTURE1, 240.0f, 128.0f);
-        GLStateManager.flushDeferredVertexAttribs(0);
+        GLStateManager.flushDeferredVertexAttribs(false, false, false, false);
 
         float[] lm = getVertexAttrib4f(SECONDARY_UV_ATTRIB);
         assertEquals(240.0f, lm[0], EPSILON, "lightmap.s");
@@ -64,7 +63,7 @@ class VertexAttribDefaultBridgeTest {
     void testGlTexCoord2fSetsVertexAttrib() {
         // glTexCoord2f outside recording → sets default vertex attrib 2 (PRIMARY_UV)
         GLStateManager.glTexCoord2f(0.5f, 0.75f);
-        GLStateManager.flushDeferredVertexAttribs(0);
+        GLStateManager.flushDeferredVertexAttribs(false, false, false, false);
 
         float[] uv = getVertexAttrib4f(PRIMARY_UV_ATTRIB);
         assertEquals(0.5f, uv[0], EPSILON, "texcoord.s");
@@ -77,7 +76,7 @@ class VertexAttribDefaultBridgeTest {
         // Second call is a cache hit — changeColor not called.
         // Vertex attrib should still hold the correct value from the first call.
         GLStateManager.glColor4f(0.3f, 0.6f, 0.9f, 1.0f);
-        GLStateManager.flushDeferredVertexAttribs(0);
+        GLStateManager.flushDeferredVertexAttribs(false, false, false, false);
 
         float[] color = getVertexAttrib4f(COLOR_ATTRIB);
         assertEquals(0.3f, color[0], EPSILON, "color.r after dedup");
@@ -89,7 +88,7 @@ class VertexAttribDefaultBridgeTest {
     @Test
     void testCompileMode_DoesNotSetVertexAttrib() {
         GLStateManager.glColor4f(0.1f, 0.2f, 0.3f, 1.0f);
-        GLStateManager.flushDeferredVertexAttribs(0);
+        GLStateManager.flushDeferredVertexAttribs(false, false, false, false);
 
         int listId = GLStateManager.glGenLists(1);
         GLStateManager.glNewList(listId, org.lwjgl.opengl.GL11.GL_COMPILE);

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

@@ -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,17 +16,21 @@ 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<>();
     private final List<Integer> programsToDelete = new ArrayList<>();
+    private final List<Integer> texturesToDelete = new ArrayList<>();
 
     @AfterEach
     void cleanup() {
@@ -37,15 +40,25 @@ class FFPCombineShaderTest {
         programsToDelete.clear();
         shadersToDelete.clear();
 
-        // Reset texture units to defaults
+        // Reset texture units to defaults (unbind so a later test does not see a stale binding)
         for (int i = 3; i >= 0; i--) {
             GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + i);
+            GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, 0);
             GLStateManager.getTextures().getTexEnvState(i).reset();
             if (i > 0) {
                 GLStateManager.getTextures().getTextureUnitStates(i).disable();
             }
         }
         GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+        for (int t : texturesToDelete) GL11.glDeleteTextures(t);
+        texturesToDelete.clear();
+    }
+
+    private int bindUnitTexture() {
+        final int tex = GL11.glGenTextures();
+        texturesToDelete.add(tex);
+        GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, tex);
+        return tex;
     }
 
     @Test
@@ -113,6 +126,7 @@ class FFPCombineShaderTest {
     void testSingleUnitCombineCompiles() {
         GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
         GLStateManager.enableTexture();
+        bindUnitTexture();
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL13.GL_COMBINE);
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_RGB, GL11.GL_MODULATE);
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_ALPHA, GL11.GL_MODULATE);
@@ -169,6 +183,7 @@ class FFPCombineShaderTest {
     void testAllCombineFunctionsCompile(String name, int glFunc, int numArgs) {
         GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
         GLStateManager.enableTexture();
+        bindUnitTexture();
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL13.GL_COMBINE);
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_RGB, glFunc);
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_ALPHA, GL11.GL_REPLACE);
@@ -202,6 +217,7 @@ class FFPCombineShaderTest {
     void testCombineScopeDeclaresColorOutsideBlock() {
         GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
         GLStateManager.enableTexture();
+        bindUnitTexture();
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL13.GL_COMBINE);
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_RGB, GL11.GL_MODULATE);
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_ALPHA, GL11.GL_MODULATE);
@@ -258,6 +274,7 @@ class FFPCombineShaderTest {
         // Unit 0: COMBINE / SUBTRACT
         GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
         GLStateManager.enableTexture();
+        bindUnitTexture();
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL13.GL_COMBINE);
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_RGB, GL13.GL_SUBTRACT);
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_ALPHA, GL11.GL_REPLACE);
@@ -273,6 +290,7 @@ class FFPCombineShaderTest {
         // Unit 2: COMBINE / ADD
         GLStateManager.glActiveTexture(GL13.GL_TEXTURE2);
         GLStateManager.enableTexture();
+        bindUnitTexture();
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL13.GL_COMBINE);
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_RGB, GL11.GL_ADD);
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL13.GL_COMBINE_ALPHA, GL11.GL_REPLACE);
@@ -286,6 +304,7 @@ class FFPCombineShaderTest {
         // Unit 3: simple MODULATE
         GLStateManager.glActiveTexture(GL13.GL_TEXTURE3);
         GLStateManager.enableTexture();
+        bindUnitTexture();
         GLStateManager.glTexEnvi(GL11.GL_TEXTURE_ENV, GL11.GL_TEXTURE_ENV_MODE, GL11.GL_MODULATE);
 
         // Restore active unit

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

@@ -0,0 +1,71 @@
+package com.gtnewhorizons.angelica.glsm.ffp;
+
+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.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL13;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@GLCoreTest
+class FFPUnboundTextureUnitTest {
+
+    private final List<Integer> texturesToDelete = new ArrayList<>();
+
+    @AfterEach
+    void cleanup() {
+        for (int i = 3; i >= 0; i--) {
+            GLStateManager.glActiveTexture(GL13.GL_TEXTURE0 + i);
+            GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, 0);
+            if (i > 0) GLStateManager.getTextures().getTextureUnitStates(i).disable();
+        }
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+        for (int t : texturesToDelete) GL11.glDeleteTextures(t);
+        texturesToDelete.clear();
+    }
+
+    private void bindUnitTexture() {
+        final int tex = GL11.glGenTextures();
+        texturesToDelete.add(tex);
+        GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, tex);
+    }
+
+    @Test
+    void enabledUnitWithoutTextureIsExcluded() {
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+        GLStateManager.enableTexture();
+        bindUnitTexture();
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE2);
+        GLStateManager.enableTexture(); // enabled, nothing bound
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE3);
+        GLStateManager.enableTexture(); // enabled, nothing bound
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+
+        final FragmentKey fk = FragmentKey.fromState();
+        assertEquals(1, fk.nrEnabledUnits(), "units 2/3 have no texture bound -> excluded -> only unit 0");
+        assertEquals(0b0001, fk.enabledUnitMask(), "only unit 0 in the key; enabled-but-unbound units 2/3 excluded");
+        assertTrue(fk.unitEnabled(0), "unit 0 (texture bound) stays enabled");
+    }
+
+    @Test
+    void enabledUnitsWithTextureAreCounted() {
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+        GLStateManager.enableTexture();
+        bindUnitTexture();
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE2);
+        GLStateManager.enableTexture();
+        bindUnitTexture();
+        GLStateManager.glActiveTexture(GL13.GL_TEXTURE0);
+
+        final FragmentKey fk = FragmentKey.fromState();
+        assertTrue(fk.unitEnabled(0));
+        assertTrue(fk.unitEnabled(2), "unit 2 with a bound texture must be counted");
+        assertEquals(3, fk.nrEnabledUnits(), "highest enabled is unit 2 -> nrEnabledUnits=3");
+    }
+}

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

@@ -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) {

glsm/src/test/java/com/gtnewhorizons/angelica/glsm/recording/IndexedDrawBatchBuilderTest.java

@@ -3,12 +3,15 @@ package com.gtnewhorizons.angelica.glsm.recording;
 import com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities;
 import com.gtnewhorizons.angelica.glsm.DisplayListManager;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
 import com.gtnewhorizons.angelica.glsm.recording.commands.BatchedIndexedDrawCmd;
 import com.gtnewhorizons.angelica.glsm.recording.commands.IndexedDrawBatch;
 import com.gtnewhorizons.angelica.glsm.recording.support.DisplayListTestFixture;
-import com.gtnewhorizons.angelica.glsm.states.VertexAttribState;
 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.EnumSource;
+import org.junit.jupiter.params.provider.MethodSource;
 import org.junit.jupiter.params.provider.ValueSource;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;
@@ -17,7 +20,10 @@ import org.lwjgl.opengl.GL30;
 
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import java.nio.IntBuffer;
+import java.nio.ShortBuffer;
 import java.util.List;
+import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -25,6 +31,7 @@ import static org.junit.jupiter.api.Assertions.assertNotEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
 
 class IndexedDrawBatchBuilderTest extends DisplayListTestFixture {
 
@@ -307,10 +314,10 @@ class IndexedDrawBatchBuilderTest extends DisplayListTestFixture {
         GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
         final ByteBuffer colorSlice = clientData.duplicate().order(ByteOrder.nativeOrder());
         colorSlice.position(8);
-        VertexAttribState.set(0, 2, GL11.GL_FLOAT, false, POS_COLOR_STRIDE, clientData, 0);
-        VertexAttribState.setEnabled(0, true);
-        VertexAttribState.set(1, 4, GL11.GL_UNSIGNED_BYTE, true, POS_COLOR_STRIDE, colorSlice, 0);
-        VertexAttribState.setEnabled(1, true);
+        VAOManager.setAttribute(0, 2, GL11.GL_FLOAT, false, POS_COLOR_STRIDE, clientData);
+        VAOManager.enableAttribute(0);
+        VAOManager.setAttribute(1, 4, GL11.GL_UNSIGNED_BYTE, true, POS_COLOR_STRIDE, colorSlice);
+        VAOManager.enableAttribute(1);
         GLStateManager.glBindVertexArray(0);
 
         final int ebo = uploadEbo(GL11.GL_UNSIGNED_SHORT, 0, 1, 2);
@@ -521,7 +528,153 @@ class IndexedDrawBatchBuilderTest extends DisplayListTestFixture {
             "listBA: batch[1] must match the second-recorded layout");
     }
 
-    // === local helpers ===
+    private static Stream<Arguments> clientIndexedDrawCases() {
+        return Stream.of(
+            arguments("byte indices", GL11.GL_COMPILE, (Runnable) () -> {
+                final ByteBuffer idx = BufferUtils.createByteBuffer(3);
+                idx.put(new byte[]{0, 1, 2}).flip();
+                GLStateManager.glDrawElements(GL11.GL_TRIANGLES, idx);
+            }, GL11.GL_TRIANGLES, 3),
+            arguments("short indices", GL11.GL_COMPILE, (Runnable) () -> {
+                final ShortBuffer idx = BufferUtils.createShortBuffer(3);
+                idx.put(new short[]{0, 1, 2}).flip();
+                GLStateManager.glDrawElements(GL11.GL_TRIANGLES, idx);
+            }, GL11.GL_TRIANGLES, 3),
+            arguments("int indices", GL11.GL_COMPILE, (Runnable) () -> {
+                final IntBuffer idx = BufferUtils.createIntBuffer(3);
+                idx.put(new int[]{0, 1, 2}).flip();
+                GLStateManager.glDrawElements(GL11.GL_TRIANGLES, idx);
+            }, GL11.GL_TRIANGLES, 3),
+            arguments("explicit count+type", GL11.GL_COMPILE, (Runnable) () -> {
+                final ByteBuffer idx = BufferUtils.createByteBuffer(3 * 2).order(ByteOrder.nativeOrder());
+                idx.putShort((short) 0).putShort((short) 1).putShort((short) 2).flip();
+                GLStateManager.glDrawElements(GL11.GL_TRIANGLES, 3, GL11.GL_UNSIGNED_SHORT, idx);
+            }, GL11.GL_TRIANGLES, 3),
+            arguments("quads triangulate at record", GL11.GL_COMPILE, (Runnable) () -> {
+                final IntBuffer idx = BufferUtils.createIntBuffer(4);
+                idx.put(new int[]{0, 1, 2, 3}).flip();
+                GLStateManager.glDrawElements(GL11.GL_QUADS, idx);
+            }, GL11.GL_TRIANGLES, 6),
+            arguments("compile-and-execute fires live and bakes", GL11.GL_COMPILE_AND_EXECUTE, (Runnable) () -> {
+                final IntBuffer idx = BufferUtils.createIntBuffer(3);
+                idx.put(new int[]{0, 1, 2}).flip();
+                GLStateManager.glDrawElements(GL11.GL_TRIANGLES, idx);
+            }, GL11.GL_TRIANGLES, 3)
+        );
+    }
+
+    @ParameterizedTest(name = "{0}")
+    @MethodSource("clientIndexedDrawCases")
+    void clientIndexedDraw_capturedAndWidenedToUnsignedInt(String name, int listMode, Runnable draw, int expectedMode, int expectedCount) {
+        final int list = recordClientIndexDraw(listMode, draw);
+        final BatchedIndexedDrawCmd cmd = firstBatchedCmd(list);
+        assertNotNull(cmd);
+        assertEquals(expectedMode, cmd.getDrawMode());
+        assertEquals(expectedCount, cmd.getIndexCount());
+        assertEquals(GL11.GL_UNSIGNED_INT, cmd.getIndexType(), "client indices always widen to UNSIGNED_INT");
+    }
+
+    @Test
+    void clientVerticesAndIndices_pointersSetDuringRecording_bake() {
+        final float[][] verts = {{0f, 0f, 0f}, {1f, 0f, 0f}, {1f, 1f, 0f}, {0f, 1f, 0f}};
+        final ByteBuffer clientVerts = BufferUtils.createByteBuffer(verts.length * 12).order(ByteOrder.nativeOrder());
+        for (float[] v : verts) {
+            clientVerts.putFloat(v[0]);
+            clientVerts.putFloat(v[1]);
+            clientVerts.putFloat(v[2]);
+        }
+        clientVerts.flip();
+        final IntBuffer indices = BufferUtils.createIntBuffer(6);
+        indices.put(new int[]{0, 1, 2, 2, 3, 0}).flip();
+
+        final int vao = newVao();
+        final int list = newList();
+        GLStateManager.glNewList(list, GL11.GL_COMPILE);
+        GLStateManager.glBindVertexArray(vao);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, 0);
+
+        VAOManager.setAttribute(0, 3, GL11.GL_FLOAT, false, 0, clientVerts);
+        VAOManager.enableAttribute(0);
+        GLStateManager.glDrawElements(GL11.GL_TRIANGLES, indices);
+        GLStateManager.glBindVertexArray(0);
+        GLStateManager.glEndList();
+
+        final BatchedIndexedDrawCmd cmd = firstBatchedCmd(list);
+        assertNotNull(cmd);
+        assertEquals(GL11.GL_TRIANGLES, cmd.getDrawMode());
+        assertEquals(6, cmd.getIndexCount());
+        assertEquals(GL11.GL_UNSIGNED_INT, cmd.getIndexType());
+
+        final ByteBuffer owned = readBufferBytes(GL15.GL_ARRAY_BUFFER, firstBatch(list).getSharedVBO(), verts.length * 12);
+        for (int i = 0; i < verts.length; i++) {
+            assertEquals(verts[i][0], owned.getFloat(i * 12), 0f, "pos.x v=" + i);
+            assertEquals(verts[i][1], owned.getFloat(i * 12 + 4), 0f, "pos.y v=" + i);
+            assertEquals(verts[i][2], owned.getFloat(i * 12 + 8), 0f, "pos.z v=" + i);
+        }
+        MemoryUtilities.memFree(owned);
+    }
+
+    @Test
+    void quadOffsetDraw_compileAndExecute_doesNotPauseRecordingForRestOfList() {
+        final int vao = setupPosColorVao(defaultQuadVbo());
+        final int quadEbo = uploadEbo(GL11.GL_UNSIGNED_SHORT, 0, 1, 2, 3);
+        final int triEbo = uploadEbo(GL11.GL_UNSIGNED_SHORT, 0, 1, 2);
+
+        final int list = newList();
+        GLStateManager.glNewList(list, GL11.GL_COMPILE_AND_EXECUTE);
+        GLStateManager.glBindVertexArray(vao);
+        GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, quadEbo);
+        GLStateManager.glDrawElements(GL11.GL_QUADS, 4, GL11.GL_UNSIGNED_SHORT, 0L);
+        assertTrue(DisplayListManager.isRecording(), "recording must resume after a GL_QUADS offset draw");
+        GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, triEbo);
+        GLStateManager.glDrawElements(GL11.GL_TRIANGLES, 3, GL11.GL_UNSIGNED_SHORT, 0L);
+        GLStateManager.glBindVertexArray(0);
+        GLStateManager.glEndList();
+
+        assertEquals(2, allBatchedCmds(list).size(), "both the QUADS draw and the following triangle draw must be recorded");
+    }
+
+    private enum MalformedClientDraw { OVERSIZED_COUNT, INDEX_PAST_VERTEX_BUFFER }
+
+    @ParameterizedTest(name = "{0}")
+    @EnumSource(MalformedClientDraw.class)
+    void malformedClientDraw_skippedAndRecordingSurvives(MalformedClientDraw scenario) {
+        final int list = newList();
+        GLStateManager.glNewList(list, GL11.GL_COMPILE);
+        GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
+        switch (scenario) {
+            case OVERSIZED_COUNT -> {
+                GLStateManager.glBindVertexArray(setupPosColorVao(defaultQuadVbo()));
+                final ByteBuffer idx = BufferUtils.createByteBuffer(3 * 2).order(ByteOrder.nativeOrder());
+                idx.putShort((short) 0).putShort((short) 1).putShort((short) 2).flip();
+                GLStateManager.glDrawElements(GL11.GL_TRIANGLES, 100, GL11.GL_UNSIGNED_SHORT, idx);
+            }
+            case INDEX_PAST_VERTEX_BUFFER -> {
+                final int vbo = uploadPosColorVbo(new float[]{0f, 0f, 1f, 0f}, new byte[][]{{1, 1, 1, 1}, {2, 2, 2, 2}});
+                GLStateManager.glBindVertexArray(setupPosColorVao(vbo));
+                final IntBuffer idx = BufferUtils.createIntBuffer(4);
+                idx.put(new int[]{0, 1, 2, 3}).flip();
+                GLStateManager.glDrawElements(GL11.GL_TRIANGLES, idx);
+            }
+        }
+        assertTrue(DisplayListManager.isRecording(), "recording survives a skipped malformed draw");
+        GLStateManager.glBindVertexArray(0);
+        GLStateManager.glEndList();
+
+        assertNull(firstBatchedCmd(list), "malformed draw must be skipped, not captured or over-read");
+    }
+
+    private int recordClientIndexDraw(int listMode, Runnable draw) {
+        final int vao = setupPosColorVao(defaultQuadVbo());
+        final int list = newList();
+        GLStateManager.glNewList(list, listMode);
+        GLStateManager.glBindVertexArray(vao);
+        GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, 0);
+        draw.run();
+        GLStateManager.glBindVertexArray(0);
+        GLStateManager.glEndList();
+        return list;
+    }
 
     private static void assertUintIndices(ByteBuffer ib, int... expected) {
         for (int i = 0; i < expected.length; i++) {

glsm/src/test/java/com/gtnewhorizons/angelica/glsm/recording/RecordingDataStructuresTest.java

@@ -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;

glsm/src/test/java/com/gtnewhorizons/angelica/glsm/recording/support/DisplayListTestFixture.java

@@ -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};

glsm/src/test/java/com/gtnewhorizons/angelica/glsm/states/PixelUnpackStateTest.java

@@ -0,0 +1,61 @@
+package com.gtnewhorizons.angelica.glsm.states;
+
+import org.junit.jupiter.api.Test;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertSame;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class PixelUnpackStateTest {
+
+    @Test
+    void defaults() {
+        assertTrue(PixelUnpackState.DEFAULT.isDefault());
+        assertEquals(4, PixelUnpackState.DEFAULT.alignment());
+        assertEquals(0, PixelUnpackState.DEFAULT.rowLength());
+        assertFalse(PixelUnpackState.DEFAULT.swapBytes());
+        assertFalse(PixelUnpackState.DEFAULT.lsbFirst());
+    }
+
+    @Test
+    void withUpdatesUnpackParams() {
+        PixelUnpackState s = PixelUnpackState.DEFAULT
+            .with(GL11.GL_UNPACK_ALIGNMENT, 1)
+            .with(GL11.GL_UNPACK_ROW_LENGTH, 64)
+            .with(GL11.GL_UNPACK_SKIP_ROWS, 2)
+            .with(GL11.GL_UNPACK_SKIP_PIXELS, 3)
+            .with(GL12.GL_UNPACK_IMAGE_HEIGHT, 32)
+            .with(GL12.GL_UNPACK_SKIP_IMAGES, 1)
+            .with(GL11.GL_UNPACK_SWAP_BYTES, 1)
+            .with(GL11.GL_UNPACK_LSB_FIRST, 1);
+        assertEquals(new PixelUnpackState(1, 64, 2, 3, 32, 1, true, true), s);
+        assertFalse(s.isDefault());
+    }
+
+    @Test
+    void invalidValuesIgnored() {
+        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_ALIGNMENT, 3));
+        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_ALIGNMENT, 0));
+        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_ROW_LENGTH, -1));
+        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_SKIP_ROWS, -5));
+        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL12.GL_UNPACK_IMAGE_HEIGHT, -1));
+    }
+
+    @Test
+    void booleansAcceptAnyNonzero() {
+        assertTrue(PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_SWAP_BYTES, 2).swapBytes());
+        assertTrue(PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_LSB_FIRST, -1).lsbFirst());
+        PixelUnpackState on = PixelUnpackState.DEFAULT.with(GL11.GL_UNPACK_SWAP_BYTES, 1);
+        assertFalse(on.with(GL11.GL_UNPACK_SWAP_BYTES, 0).swapBytes());
+    }
+
+    @Test
+    void packAndUnknownPnamesIgnored() {
+        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_PACK_ALIGNMENT, 1));
+        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(GL11.GL_PACK_ROW_LENGTH, 16));
+        assertSame(PixelUnpackState.DEFAULT, PixelUnpackState.DEFAULT.with(0x1234, 1));
+    }
+}

glsm/src/test/java/com/gtnewhorizons/angelica/glsm/streaming/StreamingBufferTest.java

@@ -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

glsm/src/test/java/com/gtnewhorizons/angelica/util/GLSMUtil.java

@@ -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"),

lwjgl3-backend/build.gradle.kts

@@ -34,6 +34,10 @@ repositories {
         name = "GTNH Maven"
         url = uri("https://nexus.gtnewhorizons.com/repository/public/")
     }
+    maven {
+        name = "Minecraft Libraries"
+        url = uri("https://libraries.minecraft.net")
+    }
     maven {
         name = "Forge"
         url = uri("https://maven.minecraftforge.net/")
@@ -57,7 +61,7 @@ dependencies {
     api(project(":glsm"))
 
     compileOnly("com.github.GTNewHorizons:lwjgl3ify:3.0.15:dev") { isTransitive = false }
-    compileOnly("org.embeddedt.celeritas:celeritas-common:2.5.3-GTNH") { isTransitive = false }
+    compileOnly("org.embeddedt.celeritas:celeritas-common:2.5.8-GTNH") { isTransitive = false }
 
     val osName = System.getProperty("os.name").lowercase()
     val osArch = System.getProperty("os.arch").lowercase()

lwjgl3-backend/src/main/java/com/gtnewhorizons/angelica/lwjgl3/Lwjgl3GLRenderBackend.java

@@ -23,6 +23,9 @@ import org.lwjgl.opengl.GL44C;
 import org.lwjgl.opengl.GL45C;
 import org.lwjgl.opengl.GLCapabilities;
 import org.lwjgl.opengl.GLDebugMessageCallback;
+import org.lwjgl.sdl.SDL_DropEvent;
+import org.lwjgl.sdl.SDL_EventFilter;
+import org.lwjgl.sdl.SDLEvents;
 import org.lwjgl.system.MemoryStack;
 
 import java.nio.ByteBuffer;
@@ -31,6 +34,10 @@ import java.nio.FloatBuffer;
 import java.nio.IntBuffer;
 import java.nio.charset.StandardCharsets;
 import java.nio.ShortBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.ConcurrentLinkedQueue;
 
 /**
  * LWJGL3 GL implementation of {@link RenderBackend}.
@@ -43,6 +50,10 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
     private GLDebugMessageCallback debugCallback;
     private boolean debugOutputActive;
 
+    private SDL_EventFilter dropEventFilter;
+    private final ConcurrentLinkedQueue<String> droppedFiles = new ConcurrentLinkedQueue<>();
+    private volatile boolean watchingDrops;
+
     @Override
     public void init() {
         caps = GL.getCapabilities();
@@ -50,7 +61,49 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
 
     @Override
     public void shutdown() {
-        // no-op
+        stopFileDrop();
+    }
+
+    @Override
+    public boolean supportsFileDrop() {
+        return true;
+    }
+
+    @Override
+    public void startFileDrop() {
+        if (watchingDrops) return;
+        dropEventFilter = SDL_EventFilter.create((userData, eventPtr) -> {
+            if (SDL_DropEvent.ntype(eventPtr) == SDLEvents.SDL_EVENT_DROP_FILE) {
+                final String path = SDL_DropEvent.ndataString(eventPtr);
+                if (path != null && !path.isEmpty()) {
+                    droppedFiles.add(path);
+                }
+            }
+            return true;
+        });
+        SDLEvents.SDL_AddEventWatch(dropEventFilter, 0L);
+        watchingDrops = true;
+    }
+
+    @Override
+    public void stopFileDrop() {
+        if (!watchingDrops) return;
+        SDLEvents.SDL_RemoveEventWatch(dropEventFilter, 0L);
+        dropEventFilter.free();
+        dropEventFilter = null;
+        droppedFiles.clear();
+        watchingDrops = false;
+    }
+
+    @Override
+    public List<String> pollDroppedFiles() {
+        if (droppedFiles.isEmpty()) return Collections.emptyList();
+        final List<String> out = new ArrayList<>();
+        String p;
+        while ((p = droppedFiles.poll()) != null) {
+            out.add(p);
+        }
+        return out;
     }
 
     @Override
@@ -295,6 +348,16 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
         GL31C.glDrawElementsInstanced(mode, count, type, indices, primcount);
     }
 
+    @Override
+    public void drawArraysInstanced(int mode, int first, int count, int primcount) {
+        GL31C.glDrawArraysInstanced(mode, first, count, primcount);
+    }
+
+    @Override
+    public void provokingVertex(int provokeMode) {
+        GL32C.glProvokingVertex(provokeMode);
+    }
+
     @Override
     public void multiDrawElementsIndirect(int mode, int type, long indirect, int drawcount, int stride) {
         GL43C.glMultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
@@ -491,11 +554,6 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
         GL11C.glPixelStorei(pname, param);
     }
 
-    @Override
-    public void pixelStoref(int pname, float param) {
-        GL11C.glPixelStoref(pname, param);
-    }
-
     @Override
     public void sampleCoverage(float value, boolean invert) {
         GL13C.glSampleCoverage(value, invert);
@@ -601,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);
@@ -808,6 +871,11 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
         GL20C.glUniform4i(location, v0, v1, v2, v3);
     }
 
+    @Override
+    public void uniform2(int location, FloatBuffer value) {
+        GL20C.glUniform2fv(location, value);
+    }
+
     @Override
     public void uniform3(int location, FloatBuffer value) {
         GL20C.glUniform3fv(location, value);
@@ -818,6 +886,26 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
         GL20C.glUniform4fv(location, value);
     }
 
+    @Override
+    public void uniform1iv(int location, IntBuffer value) {
+        GL20C.glUniform1iv(location, value);
+    }
+
+    @Override
+    public void uniform2iv(int location, IntBuffer value) {
+        GL20C.glUniform2iv(location, value);
+    }
+
+    @Override
+    public void uniform3iv(int location, IntBuffer value) {
+        GL20C.glUniform3iv(location, value);
+    }
+
+    @Override
+    public void uniform4iv(int location, IntBuffer value) {
+        GL20C.glUniform4iv(location, value);
+    }
+
     @Override
     public void uniformMatrix3(int location, boolean transpose, FloatBuffer value) {
         GL20C.glUniformMatrix3fv(location, transpose, value);
@@ -1013,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();
@@ -1028,6 +1121,11 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
         GL30C.glBindVertexArray(array);
     }
 
+    @Override
+    public boolean isVertexArray(int array) {
+        return GL30C.glIsVertexArray(array);
+    }
+
     @Override
     public void vertexAttribPointer(int index, int size, int type, boolean normalized, int stride, long pointer) {
         GL20C.glVertexAttribPointer(index, size, type, normalized, stride, pointer);
@@ -1193,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);
@@ -1318,11 +1421,14 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
 
     @Override
     public boolean supportsDebugOutput() {
-        return caps != null && caps.OpenGL43;
+        return caps != null && (caps.OpenGL43 || caps.GL_KHR_debug);
     }
 
     @Override
     public int setupDebugOutput(DebugMessageHandler handler) {
+        if (caps == null || !(caps.OpenGL43 || caps.GL_KHR_debug)) {
+            return 0;
+        }
         debugCallback = GLDebugMessageCallback.create(
             (source, type, id, severity, length, message, userParam) -> {
                 final String msg = GLDebugMessageCallback.getMessage(length, message);
@@ -1350,6 +1456,9 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
 
     @Override
     public int disableDebugOutput() {
+        if (caps == null || !(caps.OpenGL43 || caps.GL_KHR_debug)) {
+            return 0;
+        }
         GL43C.glDebugMessageCallback(null, 0L);
         if (debugCallback != null) {
             debugCallback.free();

settings.gradle.kts

@@ -16,7 +16,7 @@ pluginManagement {
 }
 
 plugins {
-    id("com.gtnewhorizons.gtnhsettingsconvention") version ("2.0.25")
+    id("com.gtnewhorizons.gtnhsettingsconvention") version ("2.0.26")
 }
 
 include("glsm")

src/main/java/com/gtnewhorizons/angelica/AngelicaMod.java

@@ -16,7 +16,7 @@ import static com.gtnewhorizons.angelica.AngelicaMod.MOD_ID;
         name = "Angelica",
         version = Tags.VERSION,
         dependencies = """
-            required-after:gtnhlib@[0.8.21,);\
+            required-after:gtnhlib@[0.11.19,);\
             before:lwjgl3ify@[1.5.3,);\
             after:hodgepodge@[2.4.4,);\
             after:CodeChickenCore@[1.2.0,);\

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

@@ -0,0 +1,9 @@
+package com.gtnewhorizons.angelica.api;
+
+public interface ExtCeleritasRenderBlocks {
+
+    boolean angelica$shouldApplyCeleritasAO();
+
+    void angelica$setApplyingCeleritasAO(boolean val);
+
+}

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

@@ -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;

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

@@ -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);
         }

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

@@ -11,9 +11,13 @@ import net.minecraft.client.resources.DefaultResourcePack;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
+import cpw.mods.fml.common.Loader;
+
 import java.awt.Font;
+import java.awt.FontFormatException;
 import java.awt.GraphicsEnvironment;
 import java.io.File;
+import java.io.IOException;
 import java.util.Comparator;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -27,13 +31,13 @@ public class FontStrategist {
     public static final Logger LOGGER = LogManager.getLogger("Angelica");
 
     static {
+        HashMap<String, Font> fontSet = new HashMap<>();
+
         if (GraphicsEnvironment.isHeadless()) {
-            LOGGER.warn("GraphicsEnvironment.isHeadless() returned true! Custom fonts will be unavailable. This is likely a MacOS issue.");
-            availableFonts = new Font[0];
+            LOGGER.warn("GraphicsEnvironment.isHeadless() returned true! Only bundled fonts will be available. This is likely a MacOS issue.");
         } else {
             // get available fonts without duplicates (250 copies of dialog.plain need not apply)
             Font[] availableFontsDirty = GraphicsEnvironment.getLocalGraphicsEnvironment().getAllFonts();
-            HashMap<String, Font> fontSet = new HashMap<>();
             HashMultiset<String> duplicates = HashMultiset.create(); // for debugging
 
             for (Font font : availableFontsDirty) {
@@ -57,11 +61,14 @@ public class FontStrategist {
                 sb.append(". Some fonts may be missing from the font selection menu.");
                 LOGGER.warn(sb.toString());
             }
-            availableFonts = fontSet.values().stream().sorted(Comparator.comparing(Font::getFontName)).toArray(Font[]::new);
 
-            LOGGER.info("Got {} fonts from GraphicsEnvironment ({} after deduplication)", availableFontsDirty.length, availableFonts.length);
+            LOGGER.info("Got {} fonts from GraphicsEnvironment ({} after deduplication)", availableFontsDirty.length, fontSet.size());
         }
 
+        loadBundledFonts(fontSet);
+
+        availableFonts = fontSet.values().stream().sorted(Comparator.comparing(Font::getFontName)).toArray(Font[]::new);
+
         // create and add the resource pack that provides fonts
         HashMap<String, File> packMap = new HashMap<>();
         for (int i = 0; i < FontProviderCustom.ATLAS_COUNT; i++) {
@@ -74,6 +81,44 @@ public class FontStrategist {
         defaultResourcePacks.add(fontResourcePack);
     }
 
+    // Load .ttf/.otf shipped with the pack so customFontName* can point at a font that isn't installed
+    // on the system. fontfiles/ is SmoothFont's folder, kept so packs built for it work unchanged.
+    private static void loadBundledFonts(HashMap<String, Font> fontSet) {
+        File configDir = Loader.instance().getConfigDir();
+        if (configDir == null) {
+            LOGGER.warn("Loader.instance().getConfigDir() returned null. Bundled fonts will not be loaded.");
+            return;
+        }
+        File parent = configDir.getParentFile();
+        File[] fontDirs = { new File(parent, "fontfiles"), new File(configDir, "angelica/fonts") };
+        GraphicsEnvironment ge = GraphicsEnvironment.isHeadless() ? null : GraphicsEnvironment.getLocalGraphicsEnvironment();
+        int loaded = 0;
+        for (File dir : fontDirs) {
+            File[] files = dir.listFiles((d, name) -> name.toLowerCase().endsWith(".ttf") || name.toLowerCase().endsWith(".otf"));
+            if (files == null) continue;
+            for (File file : files) {
+                try {
+                    Font font = Font.createFont(Font.TRUETYPE_FONT, file);
+                    String name = font.getFontName();
+                    if (fontSet.containsKey(name)) {
+                        String deduped = name;
+                        int n = 1;
+                        while (fontSet.containsKey(deduped)) deduped = name + "_" + n++;
+                        LOGGER.warn("Font name {} (from {}) is already registered; registering this one as {}", name, file.getName(), deduped);
+                        name = deduped;
+                    }
+                    if (ge != null) ge.registerFont(font);
+                    fontSet.put(name, font);
+                    loaded++;
+                    LOGGER.info("Loaded font {} from {}/{}", name, dir.getName(), file.getName());
+                } catch (FontFormatException | IOException e) {
+                    LOGGER.error("Couldn't load font {}", file.getPath(), e);
+                }
+            }
+        }
+        if (loaded > 0) LOGGER.info("Loaded {} bundled font(s) from the pack", loaded);
+    }
+
     /**
      Lets you get a FontProvider per char while respecting font priority and fallbacks, the unicode flag, whether
      SGA is on, if we're in a splash screen, if a font can even display a character in the first place, etc.

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

@@ -25,6 +25,7 @@ public class DeferredDrawBatcher {
 
     @Getter private static boolean active = false;
     private static DeferredBatchTessellator batchTessellator;
+    private static long entryStateKey;
 
     private DeferredDrawBatcher() {}
 
@@ -41,13 +42,14 @@ public class DeferredDrawBatcher {
         batchTessellator.clearRanges();
         batchTessellator.setParentTessellator(Tessellator.instance);
         batchTessellator.snapshotDefaultModelview();
+        entryStateKey = captureStateKey();
         TessellatorManager.startCapturingDirect(batchTessellator);
     }
 
     /**
      * Exit deferred mode and flush all captured batches. Groups entries by state key
-     * and vertex format, issues one draw per unique group. Restores the GL state that
-     * was active for the last group so vanilla sees consistent state.
+     * and vertex format, issues one draw per unique group. Restores the bracket's entry
+     * state so the trailing vanilla Tessellator.draw() renders with the layer atlas.
      */
     public static void exitAndFlush() {
         active = false;
@@ -56,6 +58,7 @@ public class DeferredDrawBatcher {
         if (!ranges.isEmpty()) {
             ranges.sort(Comparator.comparingLong(DeferredBatchTessellator.DrawRange::stateKey));
             flushSorted(ranges);
+            applyStateKey(entryStateKey);
         }
 
         TessellatorManager.stopCapturingDirect();
@@ -147,7 +150,8 @@ public class DeferredDrawBatcher {
      * - fog state (mode, color, start/end — constant for the frame)
      */
     static long captureStateKey() {
-        final int textureId = GLStateManager.getTextures().getTextureUnitBindings(0).getBinding();
+        final int activeUnit = GLStateManager.getActiveTextureUnit();
+        final int textureId = GLStateManager.getTextures().getTextureUnitBindings(activeUnit).getBinding();
         final int srcRgb = GLStateManager.getBlendState().getSrcRgb();
         final int dstRgb = GLStateManager.getBlendState().getDstRgb();
         final boolean blendEnabled = GLStateManager.getBlendMode().isEnabled();