Stop stalls on some GPUs when closing the questbook (#2286 )

initial commit for gl-fences (#2285 )
Stop capping mailbox present mode to the refresh rate (#2279 )
2026-11-15 01:34:48 +00:00 · 2026-10-22 00:24:31 -07:00 · 2026-10-21 20:12:01 -07:00 · 2026-10-21 19:47:18 -07:00 · 2026-10-21 17:32:34 -07:00 · 2026-10-21 17:25:35 -07:00
754 changed files with 36044 additions and 19212 deletions
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+# usage: companion-version.sh <name> <catalog-key>; TAG is <name>-v<version>[-N] or unset
+set -euo pipefail
+
+name="${1:?name required}"
+key="${2:?catalog key required}"
+
+cd "$(dirname "${BASH_SOURCE[0]}")/../.."
+base="$(sed -nE "s/^$key = \"(.*)\"\$/\\1/p" gradle/libs.versions.toml)"
+[[ -n "$base" ]] || { echo "$key not found" >&2; exit 1; }
+
+tag="${TAG:-}"
+if [[ -z "$tag" ]]; then
+    echo "$base"
+    exit 0
+fi
+
+version="${tag#"$name"-v}"
+if [[ "$version" == "$tag" || ( "$version" != "$base" && ! "$version" =~ ^"$base"-[1-9][0-9]*$ ) ]]; then
+    echo "bad tag '$tag': want $name-v$base[-N]" >&2
+    exit 1
+fi
+echo "$version"
@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+# usage: release-companion-jar.sh <jar> <notes>; TAG is <name>-v<version>
+set -euo pipefail
+
+: "${TAG:?TAG required}"
+jar="${1:?jar required}"
+notes="${2:?notes required}"
+
+gh release create "$TAG" "$jar" --latest=false --title "angelica-${TAG%%-v*} ${TAG#*-v}" --notes "$notes"
@@ -10,4 +10,41 @@ on:
 jobs:
  build-and-test:
    uses: GTNewHorizons/GTNH-Actions-Workflows/.github/workflows/build-and-test.yml@master
+    with:
+      disable-spotless-pr: true
+      java-distribution: temurin
+      cache-rfg: true
    secrets: inherit
+
+  sdl-gpu-tests:
+    runs-on: ubuntu-24.04
+    timeout-minutes: 20
+    concurrency:
+      group: sdl-gpu-tests-${{ github.event.pull_request.number || github.ref }}
+      cancel-in-progress: true
+    steps:
+      - name: Install a software Vulkan driver
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y xvfb mesa-vulkan-drivers
+      - uses: actions/checkout@v5
+      - uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: |
+            21
+            25
+      - uses: gradle/actions/setup-gradle@v5
+      - name: Run SDL-GPU tests
+        run: xvfb-run -a --server-args="-screen 0 1366x768x24" ./gradlew --build-cache --stacktrace --continue :sdl-gpu:glsmSdlTest :sdl-gpu:sdlGpuDeviceTest
+      - name: Check LWJGL did not extract natives to the shared temp dir
+        run: test ! -e "/tmp/lwjgl_$USER"
+      - name: Attach SDL-GPU test results
+        if: ${{ !cancelled() }}
+        uses: actions/upload-artifact@v7
+        with:
+          name: sdl-gpu-test-results
+          path: |
+            sdl-gpu/build/test-results/
+            sdl-gpu/build/reports/tests/
+            sdl-gpu/hs_err_pid*.log
@@ -0,0 +1,53 @@
+name: Build angelica-moltenvk
+
+on:
+  push:
+    tags:
+      - "moltenvk-v*"
+  workflow_dispatch:
+    inputs:
+      publish:
+        description: Publish angelica-moltenvk.jar to the GTNH maven
+        type: boolean
+        required: false
+        default: false
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-java@v5
+        with:
+          distribution: temurin
+          java-version: 21
+      - uses: gradle/actions/setup-gradle@v4
+      - name: Compute version
+        shell: bash
+        env:
+          TAG: ${{ github.ref_type == 'tag' && github.ref_name || '' }}
+        run: |
+          version="$(bash .github/scripts/companion-version.sh moltenvk lwjgl3Release)"
+          echo "MOLTENVK_VERSION=$version" >> "$GITHUB_ENV"
+      - name: Build angelica-moltenvk.jar
+        run: ./gradlew -PmoltenvkVersion="$MOLTENVK_VERSION" :moltenvk:distJar
+      - uses: actions/upload-artifact@v4
+        with:
+          name: angelica-moltenvk
+          path: moltenvk/build/libs/angelica-moltenvk-*.jar
+          if-no-files-found: error
+      - name: Publish to GTNH maven
+        if: github.ref_type == 'tag' || inputs.publish
+        env:
+          MAVEN_USER: ${{ secrets.MAVEN_USER }}
+          MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
+        run: ./gradlew -PpublishMoltenVK=true -PmoltenvkVersion="$MOLTENVK_VERSION" :moltenvk:publish
+      - name: Create GitHub release
+        if: github.ref_type == 'tag'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ github.ref_name }}
+        run: bash .github/scripts/release-companion-jar.sh moltenvk/build/libs/angelica-moltenvk-*.jar "MoltenVK for the SDL GPU Vulkan driver on macOS."
@@ -12,6 +12,9 @@ on:
        required: false
        default: false

+permissions:
+  contents: write
+
 jobs:
  build:
    strategy:
@@ -66,8 +69,15 @@ jobs:
            cp "$d"/* "$dest/"
          done
          find tracy-client/src/main/resources/natives -type f
+      - name: Compute version
+        shell: bash
+        env:
+          TAG: ${{ github.ref_type == 'tag' && github.ref_name || '' }}
+        run: |
+          version="$(bash .github/scripts/companion-version.sh tracy tracy)"
+          echo "TRACY_JAR_VERSION=$version" >> "$GITHUB_ENV"
      - name: Build angelica-tracy.jar
-        run: ./gradlew :tracy-client:distJar
+        run: ./gradlew -PtracyJarVersion="$TRACY_JAR_VERSION" :tracy-client:distJar
      - uses: actions/upload-artifact@v4
        with:
          name: angelica-tracy
@@ -78,4 +88,10 @@ jobs:
        env:
          MAVEN_USER: ${{ secrets.MAVEN_USER }}
          MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
-        run: ./gradlew -PpublishTracy=true :tracy-client:publish
+        run: ./gradlew -PpublishTracy=true -PtracyJarVersion="$TRACY_JAR_VERSION" :tracy-client:publish
+      - name: Create GitHub release
+        if: github.ref_type == 'tag'
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          TAG: ${{ github.ref_name }}
+        run: bash .github/scripts/release-companion-jar.sh tracy-client/build/libs/angelica-tracy-*.jar "Tracy profiler backend for Angelica."
@@ -3,7 +3,7 @@ name: Release tagged build

 on:
  push:
-    tags: [ '*', '!tracy-v*' ]
+    tags: [ '*', '!tracy-v*', '!moltenvk-v*' ]

 permissions:
  contents: write
@@ -2,31 +2,59 @@

 <sup>**[CurseForge](https://www.curseforge.com/minecraft/mc-mods/angelica) | [Modrinth](https://modrinth.com/mod/angelica)**</sup>

-🌐 **Languages:** [English](README.MD) | [Українська](README_uk.MD)
-
 * The little Angle [sic] that supports shaders while saving your fps from a certain death -boubou
 * Is it obtuse, or accute? -Caedis
 * It's a cute angle -mitchej123
 * It's the angel that pulls you out of OptiFine's hell -Roadhog360

-## **Beta Quality - Here there be Dragons**
-* Shaders - Beta
+## What's in it
+* Shaders - Iris backport & enhancements
+* Terrain - Celeritas 2.5.12 with threaded chunk building and translucency sorting
+* GL 3.3 core profile with Java based fixed function pipeline emulation
+* Renderer selection - OpenGL, or SDL GPU for Vulkan/Metal/Direct3D 12
+* Batching and instancing for entities, tile entities, items, particles and weather
+* Dynamic lights
+* HUD caching
+* Custom fonts and text effects
+* MCPatcher - connected textures, custom item textures, custom colors, random mobs, better skies
+* Bundled NotFine, zoom, FPS reducer
+
+## Status
+* OpenGL + Celeritas terrain - Default
+* Shaders - Generally Available
   * Complementary + Euphoria Patches is the primary compatibility target
   * Sildurs, Seus, and any other shaders might work
+* SDL GPU renderer - Experimental
+* MCPatcher features - Alpha
+* HUD caching - Semi-stable
+
+## SDL GPU renderer
+Optional, OpenGL is the default
+* Vulkan, Metal (macOS) and Direct3D 12 (Windows) through SDL3
+* Needs [LWJGL3ify](https://github.com/GTNewHorizons/lwjgl3ify/releases/) 3.0.25+
+* Falls back to OpenGL when no device can be created
+* Vulkan on macOS via MoltenVK from the optional `angelica-moltenvk` jar

 ## Core Profile
 Targets GL 3.3+ core profile
 * FFP emulation via generated GLSL shaders
 * Display list emulation
 * Software matrix stacks and state management through GLSM
-* GL_QUADS → GL_TRIANGLES conversion
+* GL_QUADS -> GL_TRIANGLES conversion
 * Automatic transformation of mod shaders that use compat-only GLSL builtins (`gl_ModelViewMatrix`, `texture2D`, etc.)


 # Required Dependencies
 * [UniMixins](https://github.com/LegacyModdingMC/UniMixins/releases) >= 0.1.23
 * [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.
+* NOTE: Some mods are not required, but a specific version is required if present - see: `Minimum versions` below.
+
+# Minimum versions (if present)
+* [LWJGL3ify](https://github.com/GTNewHorizons/lwjgl3ify/releases/) 1.5.3+ (3.0.25+ for the SDL GPU renderer)
+* [Hodgepodge](https://github.com/GTNewHorizons/Hodgepodge/releases) 2.4.4+
+* [ArchaicFix](https://www.curseforge.com/minecraft/mc-mods/archaicfix/files/all?page=1&pageSize=20) 0.7.0+
+* [CodeChickenCore](https://github.com/GTNewHorizons/CodeChickenCore/releases) 1.2.0+ - Threading issues below that
+* [Amazing Trophies](https://github.com/GTNewHorizons/Amazing-Trophies/releases) 1.2.2+

 # Known (temporary) Incompatibilities
 * Forge Relocation - Currently non Thread Safe; safe if not in use
@@ -45,15 +73,15 @@ Targets GL 3.3+ core profile
 * FastCraft [Disabled, won't fix]
 * BetterFPS [Disabled, won't fix]
 * OptimizationsAndTweaks [Disabled, won't fix]
-* [Amazing Trophies 1.2.1 and below](https://github.com/GTNewHorizons/Amazing-Trophies/releases) - Use 1.2.2+
-* [LWJGL3ify 1.5.4 and below](https://github.com/GTNewHorizons/lwjgl3ify/releases/) - Use the latest version available, 1.5.7+
-* [ArchaicFix 0.6.2 and below](https://www.curseforge.com/minecraft/mc-mods/archaicfix/files/all?page=1&pageSize=20) - Use 0.7.0 or above
-* [Hodgepodge 2.4.3 and below](https://github.com/GTNewHorizons/Hodgepodge/releases) - Use 2.4.5 or above
-* CodeChicken[Core](https://github.com/GTNewHorizons/CodeChickenCore/releases)/[Lib](https://github.com/GTNewHorizons/CodeChickenLib/releases) <1.2.0 - Threading issues, use 1.3.0+
 * Neodymium - Untested, but unlikely to be compatible. (Chunk Meshing is definitely incompatible, other features might work depending on config)
 * SmoothFont - Equivalent functionality added
 * ClientFixer - Use a resource pack like [GTNH-FTI-Standard-Font](https://github.com/Eldrinn-Elantey/GTNH-FTI-Standard-Font)

+# Building
+* `./gradlew build`, `./gradlew test`
+* Subprojects: `glsm` (state manager, FFP emulation, backends), `lwjgl3-backend`, `sdl-gpu`, `tracy-client`, `moltenvk`
+* Read the [AI policy](AI_POLICY.md) before opening a PR
+
 # Credits
 * ShadersMod
  * Original ShadersMods: karyonix, sonic ether, id_miner, daxnitro
@@ -96,7 +124,7 @@ Targets GL 3.3+ core profile
  * FalsePattern for [FalseTweaks](https://github.com/falsepattern/falsetweaks) - Item Rendering Optimizations taken from FalseTweaks under the LGPL 3.0 license
 * Beddium
  * Venn and Falsepattern for [Beddium](https://github.com/vfx-dev/Beddium) - MinimapRenderer, SafeChunkTracker, and some debug commands adapted under the LGPL 3.0 License
-* [Mesa](https://gitlab.freedesktop.org/mesa/mesa) — Code ported and/or inspired from Mesa - under the MIT licensed
+* [Mesa](https://gitlab.freedesktop.org/mesa/mesa) - Code ported and/or inspired from Mesa - under the MIT license
  * Display list ID allocator ported from [util_idalloc](https://gitlab.freedesktop.org/mesa/mesa/-/blob/main/src/util/u_idalloc.c) (Copyright 2017 Valve Corporation)
  * FFP vertex shader generation inspired by ffvertex_prog.c (Copyright 2007 VMware, Inc.)
  * FFP fragment shader generation inspired by ff_fragment_shader.c (Copyright 2007, 2009 VMware, Inc. / 2010-2011 Intel Corporation)
@@ -6,6 +6,8 @@ plugins {
    id("com.gtnewhorizons.gtnhconvention")
 }

+apply(from = "gradle/mod-version.gradle.kts")
+
 val lwjglDebug = false
 val gpuHud = false
 val renderdoc = false
@@ -87,8 +89,11 @@ tasks.register<Copy>("copyDependencies") {
 val embedOnly: Configuration by configurations
 val shadowImplementation: Configuration by configurations

+val dependencyClasspath: FileCollection = sourceSets.main.get().runtimeClasspath - sourceSets.main.get().output
+
 val downgradeEmbedOnlyForTest by tasks.registering(DowngradeFiles::class) {
    inputCollection = embedOnly
+    classpath = dependencyClasspath
    outputs.dir(temporaryDir)
 }

@@ -102,6 +107,7 @@ val stripModuleInfoFromShadow by tasks.registering(Jar::class) {

 val downgradeShadowImplForTest by tasks.registering(DowngradeFiles::class) {
    inputCollection = files(stripModuleInfoFromShadow.map { it.archiveFile })
+    classpath = dependencyClasspath
    outputs.dir(temporaryDir)
 }

@@ -116,6 +122,7 @@ val glsmTestFixtures: Configuration by configurations.creating {

 val downgradeGlsmTestFixturesForTest by tasks.registering(DowngradeFiles::class) {
    inputCollection = glsmTestFixtures
+    classpath = dependencyClasspath
    outputs.dir(temporaryDir)
 }

@@ -146,9 +153,42 @@ fun Test.configureAngelicaJava8() {
    }
 }

+if (isMacOs && providers.gradleProperty("clientJvmVendor").isPresent) {
+    for (javaVersion in listOf(17, 21, 25)) {
+        tasks.named<JavaExec>("runClient$javaVersion") {
+            javaLauncher = javaToolchains.launcherFor {
+                languageVersion = JavaLanguageVersion.of(javaVersion)
+                vendor = JvmVendorSpec.matching(providers.gradleProperty("clientJvmVendor").get())
+            }
+        }
+    }
+}
+
+// Forge's asm-debug-all 5.0.3 cannot read the Java 25 class files ArchScan walks; this ASM has to resolve first.
+val archScanAsm: Configuration by configurations.creating {
+    isCanBeConsumed = false
+    isCanBeResolved = true
+}
+
+val glsmRedirectAgent: Configuration by configurations.creating {
+    isCanBeConsumed = false
+    isCanBeResolved = true
+}
+
+dependencies {
+    glsmRedirectAgent(project(":glsm", "redirectAgent"))
+    archScanAsm(libs.asm.tree.test)
+    archScanAsm(libs.asm.commons.test)
+}
+
+sourceSets.test {
+    compileClasspath = archScanAsm + compileClasspath
+}
+
 tasks.test {
    useJUnitPlatform { excludeTags = setOf("gl-core") }
    configureAngelicaJava8()
+    classpath = archScanAsm + classpath
    jvmArgs("-Dceleritas.lwjglService=org.taumc.celeritas.lwjgl.HeadlessTestLWJGLService")
    dependsOn(":glsm:classes", ":lwjgl3-backend:classes", ":sdl-gpu:classes")
 }
@@ -156,6 +196,13 @@ tasks.test {
 val downgradeRootMainClasses = tasks.named<DowngradeFiles>("downgradeMainClasses")
 val downgradeRootTestClasses = tasks.named<DowngradeFiles>("downgradeTestClasses")

+// JVMDowngrader only declares outputs for inputs that exist at configuration, so a clean tree has none.
+for (name in listOf("main", "mixin", "test")) {
+    tasks.named<DowngradeFiles>("downgrade${name.replaceFirstChar { it.uppercase() }}Classes") {
+        sourceSets[name].output.classesDirs.files.forEach { outputs.dir(temporaryDir.resolve(it.name)) }
+    }
+}
+
 val glCoreTest by tasks.registering(Test::class) {
    description = "Runs the gl-core tests in their own JVM with a real GL context."
    group = "verification"
@@ -171,11 +218,26 @@ val glCoreTest by tasks.registering(Test::class) {
        .plus(downgraded(downgradeRootMainClasses))
        .plus(sourceSets["test"].runtimeClasspath.minus(rawMain).minus(rawTest))

+    javaAgent(glsmRedirectAgent)
+
    configureAngelicaJava8()
-    mustRunAfter(tasks.test)
 }

-tasks.test { finalizedBy(glCoreTest) }
+val verifyTestsRan by tasks.registering
+listOf(tasks.test, glCoreTest).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()) { ":$name produced no TEST-*.xml in $dir - test task likely went NO-SOURCE" }
+        }
+    }
+    verifyTestsRan.configure { dependsOn(verify) }
+}
+tasks.check { dependsOn(verifyTestsRan) }

 apply(from = "gradle/angelica-shadow-common.gradle.kts")
 apply(from = "experimental-surround/surround.root.gradle.kts")
@@ -0,0 +1,8 @@
+import org.gradle.api.file.FileCollection
+import org.gradle.api.tasks.testing.Test
+import org.gradle.process.CommandLineArgumentProvider
+
+fun Test.javaAgent(jar: FileCollection) {
+    inputs.files(jar).withPropertyName("javaAgent")
+    jvmArgumentProviders.add(CommandLineArgumentProvider { listOf("-javaagent:${jar.singleFile.path}") })
+}
@@ -0,0 +1,32 @@
+import org.gradle.api.Project
+import org.gradle.api.file.ArchiveOperations
+import org.gradle.api.tasks.SourceSetContainer
+import org.gradle.api.tasks.Sync
+import org.gradle.api.tasks.TaskProvider
+import org.gradle.api.tasks.testing.Test
+import org.gradle.kotlin.dsl.get
+import org.gradle.kotlin.dsl.register
+import org.gradle.kotlin.dsl.the
+import javax.inject.Inject
+
+abstract class UnpackLwjgl3Natives : Sync() {
+    @get:Inject
+    abstract val archives: ArchiveOperations
+}
+
+// LWJGL extracts jar-packed natives to a shared temp dir with no cross-process safety; plain files it loads in place.
+fun Project.registerLwjgl3NativesUnpack(): TaskProvider<UnpackLwjgl3Natives> {
+    val jars = the<SourceSetContainer>()["test"].runtimeClasspath.filter {
+        it.name.startsWith("lwjgl") && it.name.contains("-natives-") && !it.name.startsWith("lwjgl-platform-")
+    }
+    return tasks.register<UnpackLwjgl3Natives>("unpackLwjgl3Natives") {
+        val archives = archives
+        from(jars.elements.map { files -> files.map { archives.zipTree(it) } })
+        exclude("META-INF/**")
+        into(layout.buildDirectory.dir("lwjgl3-natives"))
+    }
+}
+
+fun Test.loadLwjgl3NativesFrom(unpack: TaskProvider<UnpackLwjgl3Natives>) {
+    classpath = project.files(unpack) + classpath
+}
@@ -64,7 +64,7 @@ DependencyHandlerScope.of(dependencies).apply {
    runtimeOnlyNonPublishable("com.github.GTNewHorizons:BuildCraft:7.1.63:dev")
    runtimeOnlyNonPublishable("com.github.GTNewHorizons:Botania:1.13.32-GTNH:dev")
    runtimeOnlyNonPublishable("com.github.GTNewHorizons:LogisticsPipes:1.5.32-GTNH:dev")
-    runtimeOnlyNonPublishable("com.github.GTNewHorizons:OpenComputers:1.12.55-GTNH:dev")
+    runtimeOnlyNonPublishable("com.github.GTNewHorizons:OpenComputers:1.12.64-GTNH:dev")
    runtimeOnlyNonPublishable("com.github.GTNewHorizons:Mobs-Info:0.5.18-GTNH:dev")
    runtimeOnlyNonPublishable("com.github.GTNewHorizons:IguanaTweaksTConstruct:2.7.10:dev")
    runtimeOnlyNonPublishable("com.github.GTNewHorizons:OpenBlocks:1.12.18-GTNH:dev")
@@ -93,6 +93,9 @@ DependencyHandlerScope.of(dependencies).apply {
    shadowImplementation(project(":lwjgl3-backend")) { isTransitive = false }
    shadowImplementation(project(":sdl-gpu")) { isTransitive = false }
    runtimeOnlyNonPublishable(project(":tracy-client")) { isTransitive = false }
+    if (System.getProperty("os.name").lowercase().contains("mac")) {
+        runtimeOnlyNonPublishable(project(":moltenvk")) { isTransitive = false }
+    }
    devOnlyNonPublishable(libs.async.profiler)
    shadowImplementation(libs.eventbus)

@@ -201,7 +204,6 @@ afterEvaluate {
        testImplementation(libs.junit.platform.reporting)
        testImplementation(libs.junit.platform.launcher)

-        testImplementation(libs.archunit.junit5)
        testImplementation(libs.retrofuturabootstrap) { isTransitive = false }

        glsmTestFixtures(testFixtures(project(":glsm")) as ModuleDependency) { isTransitive = false }
@@ -48,6 +48,7 @@ repositories {
 }

 tasks.withType<DowngradeFiles>().configureEach {
+    outputs.cacheIf { true }
    downgradeTo.set(JavaVersion.VERSION_1_8)
    multiReleaseOriginal.set(false)
    multiReleaseVersions.set(emptySet())
@@ -183,6 +183,7 @@ dependencies {
 }

 tasks.withType<DowngradeFiles>().configureEach {
+    outputs.cacheIf { true }
    downgradeTo.set(JavaVersion.VERSION_1_8)
    multiReleaseOriginal.set(false)
    multiReleaseVersions.set(emptySet())
@@ -266,6 +267,22 @@ tasks.test {
    configureGlsmJava8()
 }

+val redirectAgentJar by tasks.registering(Jar::class) {
+    archiveClassifier = "redirect-agent"
+    manifest {
+        attributes("Premain-Class" to "com.gtnewhorizons.angelica.glsm.GlsmRedirectAgent")
+    }
+}
+
+val redirectAgent by configurations.creating {
+    isCanBeConsumed = true
+    isCanBeResolved = false
+}
+
+artifacts {
+    add(redirectAgent.name, redirectAgentJar)
+}
+
 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."
@@ -274,6 +291,7 @@ val glTestTasks = GL_TASK_TAGS.map { (taskName, tag) ->
            includeTags = setOf(tag)
        }
        configureGlsmJava8()
+        javaAgent(files(redirectAgentJar))
    }
 }

@@ -302,6 +320,8 @@ val verifyTestsRan by tasks.registering {
 }
 tasks.check { dependsOn(verifyTestsRan) }

+val unpackLwjgl3Natives = registerLwjgl3NativesUnpack()
+
 val spirvTest by tasks.registering(Test::class) {
    description = "Runs SpirvShaderTranslator* tests against native shaderc + spvc on Java 21."
    group = "verification"
@@ -330,6 +350,7 @@ val spirvTest by tasks.registering(Test::class) {
        "-Djava.library.path=${extractNatives3.get().property("destinationFolder").let { (it as DirectoryProperty).asFile.get().path }}",
        "--enable-native-access=ALL-UNNAMED"
    )
+    loadLwjgl3NativesFrom(unpackLwjgl3Natives)

    testLogging {
        showStandardStreams = true
@@ -17,7 +17,7 @@ public final class SystemProperties {

    // Backend selection
    public static final String KEY_USE_SDL_GPU = "angelica.sdlgpu.enable";
-    public static final boolean USE_SDL_GPU = Boolean.getBoolean(KEY_USE_SDL_GPU);
+    public static final Boolean SDL_GPU_OVERRIDE = parseBooleanOverride(KEY_USE_SDL_GPU);
    public static final String GL_PROFILE = System.getProperty("angelica.glProfile", "");
    public static final boolean DISABLE_NVIDIA_WORKAROUND = Boolean.getBoolean("angelica.disableNvidiaWorkaround");
    public static final boolean DISABLE_LTW_WORKAROUND = Boolean.getBoolean("angelica.disableLtwWorkaround");
@@ -28,7 +28,8 @@ public final class SystemProperties {

    // SDL-GPU
    public static final String KEY_SDL_GPU_DRIVER = "angelica.sdlgpu.driver";
-    public static final String SDL_GPU_DRIVER = System.getProperty(KEY_SDL_GPU_DRIVER, "");
+    public static final String SDL_GPU_DRIVER_OVERRIDE = parseStringOverride(KEY_SDL_GPU_DRIVER);
+    public static final String MOLTENVK_DIR = System.getProperty("angelica.moltenvk.dir", "angelica" + File.separator + "natives" + File.separator + "moltenvk");
    public static final boolean SDL_GPU_DEBUG = Boolean.getBoolean("angelica.sdlgpu.debug");
    private static final SdlAssertionMode ENCODER_ASSERTIONS = parseEnum("angelica.sdlgpu.encoderAssertions", SdlAssertionMode.OFF, SdlAssertionMode.WARN, SdlAssertionMode.class);
    public static final boolean SDL_ENCODER_ASSERTIONS = ENCODER_ASSERTIONS != SdlAssertionMode.OFF;
@@ -61,8 +62,10 @@ public final class SystemProperties {
    public static final long FLYBY_TIME_OF_DAY = Math.floorMod(Long.getLong("angelica.flyby.timeOfDay", 6000L), 24000L);
    public static final String FLYBY_COMMANDS = System.getProperty("angelica.flyby.commands", "");
    public static final String FLYBY_ORIGIN = System.getProperty("angelica.flyby.origin", "");
+    public static final Integer FLYBY_DIMENSION = Integer.getInteger("angelica.flyby.dimension");
    public static final FlybyPacing FLYBY_PACING = parseEnum("angelica.flyby.pacing", FlybyPacing.UNCAPPED, FlybyPacing.UNCAPPED, FlybyPacing.class);
    public static final FlybyWeather FLYBY_WEATHER = parseEnum("angelica.flyby.weather", FlybyWeather.CLEAR, FlybyWeather.CLEAR, FlybyWeather.class);
+    public static final FlybyCamera FLYBY_CAMERA = parseEnum("angelica.flyby.camera", FlybyCamera.FIRST_PERSON, FlybyCamera.FIRST_PERSON, FlybyCamera.class);
    public static final boolean FLYBY_JFR = Boolean.getBoolean("angelica.flyby.jfr");
    public static final float FLYBY_PITCH = parseFloat("angelica.flyby.pitch");
    public static final int FLYBY_SCREENSHOTS = Integer.getInteger("angelica.flyby.screenshots", 0);
@@ -131,6 +134,12 @@ public final class SystemProperties {
        CONFIGURED
    }

+    public enum FlybyCamera {
+        FIRST_PERSON,
+        THIRD_PERSON_BACK,
+        THIRD_PERSON_FRONT
+    }
+
    public enum FlybyWeather {
        CLEAR,
        RAIN,
@@ -158,7 +167,12 @@ public final class SystemProperties {

    private static Boolean parseBooleanOverride(String key) {
        final String raw = System.getProperty(key);
-        return raw == null ? null : Boolean.parseBoolean(raw);
+        return raw == null || raw.isEmpty() ? null : Boolean.parseBoolean(raw);
+    }
+
+    private static String parseStringOverride(String key) {
+        final String raw = System.getProperty(key);
+        return raw == null || raw.isEmpty() ? null : raw;
    }

    private static double parseDouble(String key) {
@@ -4,6 +4,7 @@ import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement.Usage
 import com.gtnewhorizons.angelica.config.SystemProperties;
 import com.gtnewhorizons.angelica.glsm.backend.RenderBackend;
 import com.gtnewhorizons.angelica.glsm.shader.ShaderDiskCache;
+import com.gtnewhorizons.angelica.glsm.shader.ShaderIndex;
 import com.gtnewhorizons.angelica.glsm.shader.SpirvShaderTranslator;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.TerminalNode;
@@ -456,12 +457,7 @@ public class CompatShaderTransformer {
                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) {
+            for (GLSLParser.Typeless_declarationContext d : ShaderIndex.declarators((GLSLParser.Init_declarator_listContext) decl.getParent())) {
                if (d.IDENTIFIER() == null) continue;
                final int slots = baseSlots(baseType) * typeArraySlots * arraySlots(d.array_specifier());
                final String arraySuffix = typeArray + arraySuffix(d.array_specifier());
@@ -1,5 +1,7 @@
 package com.gtnewhorizons.angelica.glsm;

+import com.gtnewhorizons.angelica.glsm.ffp.FragmentKey;
+import com.gtnewhorizons.angelica.glsm.ffp.Uniforms;
 import com.gtnewhorizons.angelica.glsm.stacks.FogStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.LightStateStack;
 import com.gtnewhorizons.angelica.glsm.states.ClipPlaneState;
@@ -66,7 +68,13 @@ public class CompatUniformManager {
    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
+    static final int LOC_FOG_MODE = LOC_IRIS_PROJECTION_INVERSE + 1; // 50
+    static final int LOC_FOG_PARAMS = LOC_FOG_MODE + 1; // 51
+    static final int LOC_FOG_DISTANCE_MODE = LOC_FOG_PARAMS + 1; // 52
+
+    static final int LOC_MODELVIEW_PROJECTION = LOC_FOG_DISTANCE_MODE + 1; // 53
+
+    static final int LOC_COUNT = LOC_MODELVIEW_PROJECTION + 1; // 54

    private static final String[] LIGHT_FIELD_NAMES = {
        "ambient", "diffuse", "specular", "position", "halfVector",
@@ -84,6 +92,7 @@ public class CompatUniformManager {
        UNIFORM_NAMES[LOC_MODELVIEW] = "angelica_ModelViewMatrix";
        UNIFORM_NAMES[LOC_MODELVIEW_INVERSE] = "angelica_ModelViewMatrixInverse";
        UNIFORM_NAMES[LOC_PROJECTION] = "angelica_ProjectionMatrix";
+        UNIFORM_NAMES[LOC_MODELVIEW_PROJECTION] = "angelica_ModelViewProjectionMatrix";
        UNIFORM_NAMES[LOC_PROJECTION_INVERSE] = "angelica_ProjectionMatrixInverse";
        UNIFORM_NAMES[LOC_NORMAL] = "angelica_NormalMatrix";
        UNIFORM_NAMES[LOC_LIGHTMAP_TEXTURE_MATRIX] = "angelica_LightmapTextureMatrix";
@@ -98,6 +107,9 @@ public class CompatUniformManager {
        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_FOG_MODE] = "angelica_FogMode";
+        UNIFORM_NAMES[LOC_FOG_PARAMS] = "angelica_FogParams";
+        UNIFORM_NAMES[LOC_FOG_DISTANCE_MODE] = "angelica_FogDistanceMode";
        UNIFORM_NAMES[LOC_ALPHA_TEST_REF] = "angelica_currentAlphaTest";
        UNIFORM_NAMES[LOC_SCENE_COLOR] = "angelica_SceneColor";
        UNIFORM_NAMES[LOC_CLIP_PLANES] = "angelica_ClipPlane[0]";
@@ -120,7 +132,14 @@ public class CompatUniformManager {
        GLContextState owner;
        int lastMvGen = -1, lastMvLinearGen = -1, lastProjGen = -1, lastTexMatGen = -1;
        int lastFragmentGen = -1, lastLightingGen = -1, lastClipPlaneGen = -1;
-        ProgramUniforms(int[] locs) { this.locs = locs; }
+        int lastFogMode = -1, lastFogDistanceMode = -1;
+        final boolean lights;
+        ProgramUniforms(int[] locs) {
+            this.locs = locs;
+            boolean any = false;
+            for (int i = LOC_LIGHT_BASE; i < LOC_MAT_BASE; i++) any |= locs[i] != -1;
+            this.lights = any;
+        }
    }

    // Reusable NIO buffers for upload
@@ -186,6 +205,7 @@ public class CompatUniformManager {
            pu.owner = glCtx;
            pu.lastMvGen = pu.lastMvLinearGen = pu.lastProjGen = pu.lastTexMatGen = -1;
            pu.lastFragmentGen = pu.lastLightingGen = pu.lastClipPlaneGen = -1;
+            pu.lastFogMode = pu.lastFogDistanceMode = -1;
        }

        // Matrix uniforms — skip if this program's storage already holds the current generation
@@ -212,12 +232,15 @@ public class CompatUniformManager {
            uploadFragmentUniforms(locs);
        }

+        pu.lastFogMode = uploadIfChanged(locs[LOC_FOG_MODE], FragmentKey.activeFogMode(glCtx), pu.lastFogMode);
+        pu.lastFogDistanceMode = uploadIfChanged(locs[LOC_FOG_DISTANCE_MODE], glCtx.fogState.getFogDistanceMode(), pu.lastFogDistanceMode);
+
        // Lighting-derived uniforms (scene color, light sources, material)
        final int litGen = glCtx.lightingGeneration;
        if (litGen != pu.lastLightingGen) {
            pu.lastLightingGen = litGen;
            if (locs[LOC_SCENE_COLOR] != -1) uploadSceneColor(locs);
-            uploadLightSources(locs);
+            if (pu.lights) uploadLightSources(locs);
            uploadMaterial(locs);
        }

@@ -262,6 +285,11 @@ public class CompatUniformManager {
            }
        }

+        if ((mvChanged || projChanged) && locs[LOC_MODELVIEW_PROJECTION] != -1) {
+            Uniforms.modelViewProjection(proj, mv, scratchMatrix).get(mat4Buf);
+            RENDER_BACKEND.uniformMatrix4(locs[LOC_MODELVIEW_PROJECTION], false, mat4Buf);
+        }
+
        if (mvLinearChanged) {
            // Normal Matrix (inverse-transpose of upper-left 3x3 of ModelView)
            if (locs[LOC_NORMAL] != -1 || locs[LOC_IRIS_NORMAL] != -1) {
@@ -324,6 +352,11 @@ public class CompatUniformManager {
        }
    }

+    private static int uploadIfChanged(int location, int value, int last) {
+        if (location != -1 && value != last) RENDER_BACKEND.uniform1i(location, value);
+        return value;
+    }
+
    private static void uploadFragmentUniforms(int[] locs) {
        // Fog uniforms
        FogStateStack fog = GLStateManager.getFogState();
@@ -336,6 +369,9 @@ public class CompatUniformManager {
        if (locs[LOC_FOG_END] != -1) {
            RENDER_BACKEND.uniform1f(locs[LOC_FOG_END], fog.getEnd());
        }
+        if (locs[LOC_FOG_PARAMS] != -1) {
+            RENDER_BACKEND.uniform4f(locs[LOC_FOG_PARAMS], fog.linearScale(), fog.linearBias(), fog.expScale(), fog.exp2Scale());
+        }
        if (locs[LOC_FOG_COLOR] != -1) {
            vec4Buf.clear();
            vec4Buf.put((float) fog.getFogColor().x).put((float) fog.getFogColor().y).put((float) fog.getFogColor().z).put(fog.getFogAlpha());
@@ -372,8 +408,6 @@ public class CompatUniformManager {
    }

    private static void uploadLightSources(int[] locs) {
-        // Early exit: if the first light field isn't present, no lighting uniforms exist
-        if (locs[LOC_LIGHT_BASE] == -1) return;
        final LightStateStack[] lights = GLStateManager.getLightDataStates();
        for (int li = 0; li < 2; li++) {
            final int base = LOC_LIGHT_BASE + li * LIGHT_FIELDS;
@@ -1025,7 +1025,7 @@ public class DisplayListManager {
                }

                final DisplayListCommand[] complexObjects = commandBuffer.getComplexObjects();
-                compiled = new CompiledDisplayList(commandBuffer.finish(), complexObjects, compiledBuffers, indexedBatches);
+                compiled = new CompiledDisplayList(commandBuffer.finish(), complexObjects, compiledBuffers, indexedBatches, GLStateManager.ctx());
                currentRecorder = null;
            } catch (Exception e) {
                GLStateManager.LOGGER.error("Encountered a fatal issue while trying to compile a display list.");
@@ -96,6 +96,7 @@ public class Feature {
            , GLStateManager.getSecondaryColor() // Current secondary color
            , ShaderManager.getNormalStack()    // Current normal vector
            , ShaderManager.getTexCoordStack()  // Current texture coordinates
+            , GLStateManager.getEdgeFlagState()
            // Current color index
            // Current raster position
            // GL_CURRENT_RASTER_POSITION_VALID flag
@@ -158,6 +159,8 @@ public class Feature {
            , GLStateManager.getPolygonOffsetPointState()
            , GLStateManager.getPolygonOffsetLineState()
            , GLStateManager.getPolygonOffsetFillState()
+            , GLStateManager.getPointSpriteState()
+            , GLStateManager.getVertexProgramTwoSideState()
            , GLStateManager.getPolygonSmoothState()
            , GLStateManager.getPolygonStippleState()
            , GLStateManager.getRescaleNormalState()
@@ -178,6 +181,7 @@ public class Feature {
            enableBits.add(GLStateManager.getTextures().getTexture1DStates(i));
            enableBits.add(GLStateManager.getTextures().getTextureUnitStates(i));
            enableBits.add(GLStateManager.getTextures().getTexture3DStates(i));
+            enableBits.add(GLStateManager.getTextures().getTextureCubeMapStates(i));
        }

        // Flags GL_TEXTURE_GEN_x where x is S, T, R, or Q
@@ -216,13 +220,7 @@ public class Feature {
                                       // ^^ GL_FOG_MODE value
        ));
        attribToFeatures.put(GL11.GL_HINT_BIT, ImmutableSet.of(
-            // GL_PERSPECTIVE_CORRECTION_HINT setting
-            // GL_POINT_SMOOTH_HINT setting
-            // GL_LINE_SMOOTH_HINT setting
-            // GL_POLYGON_SMOOTH_HINT setting
-            // GL_FOG_HINT setting
-            // GL_GENERATE_MIPMAP_HINT setting
-            // GL_TEXTURE_COMPRESSION_HINT setting
+            GLStateManager.getHintState()
        ));
        attribToFeatures.put(GL11.GL_LIGHTING_BIT, ImmutableSet.of(
            GLStateManager.getColorMaterial()
@@ -286,6 +284,7 @@ public class Feature {
        ));
        attribToFeatures.put(GL11.GL_POINT_BIT, ImmutableSet.of(
              GLStateManager.getPointSmoothState()
+            , GLStateManager.getPointSpriteState()
            , GLStateManager.getPointState()
        ));
        attribToFeatures.put(GL11.GL_POLYGON_BIT, ImmutableSet.of(
@@ -328,6 +327,10 @@ public class Feature {
        for(int i = 0 ; i < GLStateManager.MAX_TEXTURE_UNITS; i++) {
            textureAttribs.add(GLStateManager.getTextures().getTextureUnitBindings(i));
            textureAttribs.add(GLStateManager.getTextures().getTexEnvState(i));
+            textureAttribs.add(GLStateManager.getTextures().getTexture1DStates(i));
+            textureAttribs.add(GLStateManager.getTextures().getTextureUnitStates(i));
+            textureAttribs.add(GLStateManager.getTextures().getTexture3DStates(i));
+            textureAttribs.add(GLStateManager.getTextures().getTextureCubeMapStates(i));
        }

        // Enable bits GL_TEXTURE_GEN_x where x is S, T, R, or Q
@@ -1,5 +1,6 @@
 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.ViewportState;
 import org.joml.Matrix4f;
@@ -141,6 +142,7 @@ public class FeedbackManager {
    public static void processDrawArrays(int mode, int first, int count) {
        computeMVP();
        final GLContextState glCtx = GLStateManager.ctx();
+        if (!glCtx.vaos.isAttribEnabled(0)) return;
        final int stride = positionStride(glCtx);
        final long posOffset = positionOffset(glCtx);
        final int byteCount = count * stride;
@@ -154,6 +156,7 @@ public class FeedbackManager {
    public static void processDrawElements(int mode, int indexCount, int type, long eboOffset) {
        computeMVP();
        final GLContextState glCtx = GLStateManager.ctx();
+        if (!glCtx.vaos.isAttribEnabled(0)) return;
        final int stride = positionStride(glCtx);

        final int elementSize = GLTypes.sizeBytes(type);
@@ -210,6 +213,7 @@ public class FeedbackManager {
    private static void processDrawElementsImpl(int mode, int count, IndexReader reader) {
        computeMVP();
        final GLContextState glCtx = GLStateManager.ctx();
+        if (!glCtx.vaos.isAttribEnabled(0)) return;
        final int stride = positionStride(glCtx);

        int minIdx = Integer.MAX_VALUE, maxIdx = Integer.MIN_VALUE;
@@ -261,6 +265,14 @@ public class FeedbackManager {
    }

    private static void readPositionBuffer(long offset, ByteBuffer destination, GLContextState glCtx) {
+        final VAOManager.Attrib position = glCtx.vaos.attrib(0);
+        if (position != null && position.clientPointer != null) {
+            final ByteBuffer source = position.clientPointer.duplicate();
+            source.position(source.position() + (int) offset);
+            if (source.remaining() > destination.remaining()) source.limit(source.position() + destination.remaining());
+            destination.duplicate().put(source);
+            return;
+        }
        final int positionVbo = glCtx.vaos.attribVBO(0);
        final int previousVbo = glCtx.boundVBO;

@@ -3,6 +3,7 @@ package com.gtnewhorizons.angelica.glsm;
 import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
 import it.unimi.dsi.fastutil.ints.Int2IntMap;
 import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
+import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import com.gtnewhorizons.angelica.glsm.stacks.AlphaStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.BlendStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.BooleanStateStack;
@@ -21,6 +22,7 @@ import com.gtnewhorizons.angelica.glsm.stacks.MaterialStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.MatrixModeStack;
 import com.gtnewhorizons.angelica.glsm.stacks.PointStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.PolygonStateStack;
+import com.gtnewhorizons.angelica.glsm.stacks.RetainedState;
 import com.gtnewhorizons.angelica.glsm.stacks.ScissorStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.StackIdAllocator;
 import com.gtnewhorizons.angelica.glsm.stacks.StencilStateStack;
@@ -29,10 +31,11 @@ import com.gtnewhorizons.angelica.glsm.states.AlphaState;
 import com.gtnewhorizons.angelica.glsm.states.BlendState;
 import com.gtnewhorizons.angelica.glsm.states.ClipPlaneState;
 import com.gtnewhorizons.angelica.glsm.states.Color4;
-import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
+import com.gtnewhorizons.angelica.glsm.states.PixelStoreState;
 import com.gtnewhorizons.angelica.glsm.states.ImageUnitArray;
 import com.gtnewhorizons.angelica.glsm.states.SamplerUnitArray;
 import com.gtnewhorizons.angelica.glsm.states.TextureUnitArray;
+import com.gtnewhorizons.angelica.glsm.ffp.InstancedAttribs;
 import com.gtnewhorizons.angelica.glsm.ffp.Instancing;
 import com.gtnewhorizons.angelica.glsm.ffp.ShaderManager;
 import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
@@ -46,6 +49,7 @@ import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;
 import org.lwjgl.opengl.GL13;
 import org.lwjgl.opengl.GL14;
+import org.lwjgl.opengl.GL20;
 import org.lwjgl.opengl.GL30;

 import java.nio.DoubleBuffer;
@@ -102,10 +106,13 @@ public class GLContextState {
    public boolean dirtyNormalAttrib;
    public boolean dirtyTexCoordAttrib;
    public boolean dirtyLightmapAttrib = true;
+    public long entityIds = InstancedAttribs.DEFAULT_ENTITY_IDS;
+    public boolean dirtyEntityIdsAttrib = true;
    public boolean unit23TexCoordSetDuringDraw = false;
    public int maxBoundTextureUnit = 0;
    public int maxBoundImageUnit = 0;
    public final StateSet[] attribSets = new StateSet[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
+    public RetainedState retainedOwner;
    public int attribDepth = 0;

    public boolean savesState(int id) {
@@ -167,6 +174,9 @@ public class GLContextState {
    public final BooleanStateStack lineSmoothState = track(new BooleanStateStack(GL11.GL_LINE_SMOOTH));
    public final BooleanStateStack lineStippleState = track(new BooleanStateStack(GL11.GL_LINE_STIPPLE, false, true));
    public final BooleanStateStack pointSmoothState = track(new BooleanStateStack(GL11.GL_POINT_SMOOTH, false, true));
+    public final BooleanStateStack pointSpriteState = track(new BooleanStateStack(GL20.GL_POINT_SPRITE, false, true));
+    public final BooleanStateStack vertexProgramTwoSideState = track(new BooleanStateStack(GL20.GL_VERTEX_PROGRAM_TWO_SIDE, false, true));
+    public final BooleanStateStack edgeFlagState = track(new BooleanStateStack(GL11.GL_EDGE_FLAG, true, true));
    public final BooleanStateStack polygonSmoothState = track(new BooleanStateStack(GL11.GL_POLYGON_SMOOTH));
    public final BooleanStateStack polygonStippleState = track(new BooleanStateStack(GL11.GL_POLYGON_STIPPLE, false, true));
    public final BooleanStateStack multisampleState = track(new BooleanStateStack(GL13.GL_MULTISAMPLE, true));
@@ -180,6 +190,7 @@ public class GLContextState {
    public final BooleanStateStack polygonOffsetFillState = track(new BooleanStateStack(GL11.GL_POLYGON_OFFSET_FILL));
    public final LineStateStack lineState = member(new LineStateStack(StackIdAllocator.nextId()));
    public final PointStateStack pointState = member(new PointStateStack(StackIdAllocator.nextId()));
+    public final IntegerStateStack hintState = member(new IntegerStateStack(0, StackIdAllocator.nextId()).restoreBit(StateSet.R_HINT));
    public final PolygonStateStack polygonState = member(new PolygonStateStack(StackIdAllocator.nextId()));
    public final StencilStateStack stencilState = member(new StencilStateStack(StackIdAllocator.nextId()));
    public int stencilBitMask = 0xFFFFFFFF;
@@ -229,9 +240,16 @@ public class GLContextState {
    public int boundCopyReadBuffer;
    public int boundCopyWriteBuffer;
    public final Int2IntMap boundOtherBuffers = new Int2IntOpenHashMap();
-    public PixelUnpackState pixelUnpackState = PixelUnpackState.DEFAULT;
-    public final int[] clientAttribSavedTextureUnit = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
-    public final int[] clientAttribSavedVertexFlags = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
+    public final int[] uniformBufferBindings = new int[GLStateManager.INDEXED_BUFFER_SLOTS];
+    public final int[] storageBufferBindings = new int[GLStateManager.INDEXED_BUFFER_SLOTS];
+    public PixelStoreState pixelUnpackState = PixelStoreState.DEFAULT;
+    public PixelStoreState pixelPackState = PixelStoreState.DEFAULT;
+    public final int[] clientAttribSavedMask = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
+    public final PixelStoreState[] clientAttribSavedPixelUnpack = new PixelStoreState[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
+    public final PixelStoreState[] clientAttribSavedPixelPack = new PixelStoreState[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
+    public final int[] clientAttribSavedUnpackBuffer = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
+    public final int[] clientAttribSavedPackBuffer = new int[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
+    public final VAOManager.ClientArrays[] clientAttribSavedArrays = new VAOManager.ClientArrays[GLStateManager.CLIENT_ATTRIB_STACK_DEPTH];
    public int clientAttribStackPointer = 0;
    public int restoreChangedMask;
    public long restoreUnitChangedMask;
@@ -240,6 +258,7 @@ public class GLContextState {
    public boolean vanillaBlendEnabledBefore;
    public int drawFramebuffer = 0;
    public int readFramebuffer = 0;
+    public final Int2ObjectOpenHashMap<int[]> framebufferTextures = new Int2ObjectOpenHashMap<>();
    public int texGenGeneration;
    public int defaultVAO;
    public final VAOManager vaos = new VAOManager();
@@ -253,7 +272,7 @@ public class GLContextState {
    public int savedFilterMin = -1;
    public int savedFilterMag = -1;
    public float savedFilterAniso = -1.0f;
-    public boolean wideLineEmulationActive = false;
+    public boolean lineQuadsActive = false;
    public boolean lineStippleActive = false;
    public Instancing ffpInstancing = Instancing.NONE;
    public float lastBrightnessX;
@@ -1,21 +1,25 @@
 package com.gtnewhorizons.angelica.glsm;

+import org.antlr.v4.runtime.BailErrorStrategy;
 import org.antlr.v4.runtime.BufferedTokenStream;
 import org.antlr.v4.runtime.CharStreams;
 import org.antlr.v4.runtime.CommonToken;
 import org.antlr.v4.runtime.CommonTokenStream;
+import org.antlr.v4.runtime.DefaultErrorStrategy;
+import org.antlr.v4.runtime.Parser;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.WritableToken;
+import org.antlr.v4.runtime.atn.PredictionMode;
+import org.antlr.v4.runtime.misc.ParseCancellationException;
 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.grammar.GLSLPreParser;

-import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Set;
+import java.util.function.Function;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

@@ -72,6 +76,10 @@ public class GlslTransformUtils {
    }

    public static String renameReservedWords(String source, int targetVersion) {
+        if (!containsWholeWord(source, "sample") && !containsWholeWord(source, "new")
+            && (targetVersion < 400 || !containsWholeWord(source, "sampler"))) {
+            return source;
+        }
        for (var entry : VERSIONED_RESERVED_WORDS.entrySet()) {
            // Rename identifiers that become reserved words at or above this GLSL version
            if (targetVersion >= entry.getKey()) {
@@ -83,6 +91,23 @@ public class GlslTransformUtils {
        return source;
    }

+    static boolean containsWholeWord(String source, String word) {
+        int from = 0;
+        while (true) {
+            final int match = source.indexOf(word, from);
+            if (match < 0) return false;
+            final int end = match + word.length();
+            if ((match == 0 || !isAsciiWordChar(source.charAt(match - 1))) && (end == source.length() || !isAsciiWordChar(source.charAt(end)))) {
+                return true;
+            }
+            from = match + 1;
+        }
+    }
+
+    private static boolean isAsciiWordChar(char c) {
+        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_';
+    }
+
    public static String restoreReservedWords(String source) {
        source = source.replace(RENAMED_PREFIX + "texture", "texture");
        source = source.replace(RENAMED_PREFIX + "sampler", "sampler");
@@ -110,72 +135,35 @@ public class GlslTransformUtils {
    public record QuietParse(GLSLParser.Translation_unitContext full, GLSLPreParser.Translation_unitContext pre) {}

    public static GLSLParser.Translation_unitContext parseFullQuiet(String source) {
-        final GLSLLexer lexer = new GLSLLexer(CharStreams.fromString(source));
-        lexer.removeErrorListeners();
-        final GLSLParser parser = new GLSLParser(new CommonTokenStream(lexer));
-        parser.removeErrorListeners();
-        parser.setBuildParseTree(true);
-        return parser.translation_unit();
-    }
-
-    public static GLSLPreParser.Translation_unitContext parsePreQuiet(String source) {
-        final GLSLLexer lexer = new GLSLLexer(CharStreams.fromString(source));
-        lexer.removeErrorListeners();
-        final GLSLPreParser preParser = new GLSLPreParser(new CommonTokenStream(lexer, GLSLLexer.DIRECTIVES));
-        preParser.removeErrorListeners();
-        preParser.setBuildParseTree(true);
-        return preParser.translation_unit();
+        return parseQuiet(new GLSLParser(new CommonTokenStream(quietLexer(source))), GLSLParser::translation_unit);
    }

    public static QuietParse parseBothQuiet(String source) {
-        final GLSLLexer lexer = new GLSLLexer(CharStreams.fromString(source));
-        lexer.removeErrorListeners();
-        final GLSLPreParser preParser = new GLSLPreParser(new BufferedTokenStream(lexer));
-        preParser.removeErrorListeners();
-        preParser.setBuildParseTree(true);
-        final GLSLPreParser.Translation_unitContext pre = preParser.translation_unit();
+        final GLSLLexer lexer = quietLexer(source);
+        final GLSLPreParser.Translation_unitContext pre = parseQuiet(new GLSLPreParser(new BufferedTokenStream(lexer)), GLSLPreParser::translation_unit);
        lexer.reset();
-        final GLSLParser parser = new GLSLParser(new CommonTokenStream(lexer));
-        parser.removeErrorListeners();
-        parser.setBuildParseTree(true);
-        return new QuietParse(parser.translation_unit(), pre);
+        return new QuietParse(parseQuiet(new GLSLParser(new CommonTokenStream(lexer)), GLSLParser::translation_unit), pre);
    }

-    public static Set<String> identifiersInDirectiveText(String source) {
+    private static <P extends Parser, T> T parseQuiet(P parser, Function<P, T> rule) {
+        parser.removeErrorListeners();
+        parser.setErrorHandler(new BailErrorStrategy());
+        parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
+        try {
+            return rule.apply(parser);
+        } catch (ParseCancellationException e) {
+            // Rewinds the token stream, which keeps every token SLL already pulled from the lexer.
+            parser.reset();
+            parser.setErrorHandler(new DefaultErrorStrategy());
+            parser.getInterpreter().setPredictionMode(PredictionMode.LL);
+            return rule.apply(parser);
+        }
+    }
+
+    public static GLSLLexer quietLexer(String source) {
        final GLSLLexer lexer = new GLSLLexer(CharStreams.fromString(source));
        lexer.removeErrorListeners();
-        final BufferedTokenStream tokens = new BufferedTokenStream(lexer);
-        tokens.fill();
-
-        final Set<String> names = new HashSet<>();
-        for (Token token : tokens.getTokens()) {
-            switch (token.getType()) {
-                case GLSLLexer.PROGRAM_TEXT, GLSLLexer.MACRO_TEXT, GLSLLexer.CONSTANT_EXPRESSION -> collectIdentifiers(token.getText(), names);
-                default -> { }
-            }
-        }
-        return names;
-    }
-
-    private static void collectIdentifiers(String text, Set<String> out) {
-        if (text == null) return;
-        final int len = text.length();
-        int i = 0;
-        while (i < len) {
-            final char c = text.charAt(i);
-            if (c != '_' && !Character.isLetter(c)) {
-                i++;
-                continue;
-            }
-            int end = i + 1;
-            while (end < len) {
-                final char n = text.charAt(end);
-                if (n != '_' && !Character.isLetterOrDigit(n)) break;
-                end++;
-            }
-            out.add(text.substring(i, end));
-            i = end;
-        }
+        return lexer;
    }

    public static String getFormattedShader(ParseTree tree, String header) {
@@ -1,6 +1,6 @@
 package com.gtnewhorizons.angelica.glsm;

-import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
+import com.gtnewhorizons.angelica.glsm.states.PixelStoreState;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;
@@ -25,10 +25,10 @@ public final class LTWWorkaround {
            oneTexel = BufferUtils.createByteBuffer(4);
        }
        oneTexel.clear();
-        GLStateManager.forcePixelUnpackState(PixelUnpackState.DEFAULT);
+        GLStateManager.forcePixelUnpackState(PixelStoreState.DEFAULT);
        GLStateManager.suspendPixelUnpackBuffer();
        RENDER_BACKEND.texSubImage2D(target, level, 0, 0, 1, 1, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, oneTexel);
        GLStateManager.restorePixelUnpackBuffer();
-        GLStateManager.restorePixelUnpackState(PixelUnpackState.DEFAULT);
+        GLStateManager.restorePixelUnpackState(PixelStoreState.DEFAULT);
    }
 }
@@ -0,0 +1,167 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+import org.lwjgl.opengl.GL13;
+import org.lwjgl.opengl.GL14;
+import org.lwjgl.opengl.GL15;
+import org.lwjgl.opengl.GL20;
+
+import java.nio.ByteBuffer;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+
+final class LegacyQueries {
+
+    static final int BOOL = 1;
+    static final int INT = 2;
+    static final int FLOAT = 3;
+    static final int FLOATN = 4;
+
+    private static final int COUNT_SHIFT = 3;
+
+    private LegacyQueries() {}
+
+    static int desc(int pname) {
+        return switch (pname) {
+            case GL11.GL_ALPHA_TEST, GL11.GL_AUTO_NORMAL, GL11.GL_COLOR_MATERIAL, GL14.GL_COLOR_SUM, GL11.GL_FOG,
+                 GL11.GL_INDEX_LOGIC_OP, GL11.GL_LIGHTING, GL11.GL_LIGHT0, GL11.GL_LIGHT1, GL11.GL_LIGHT2, GL11.GL_LIGHT3,
+                 GL11.GL_LIGHT4, GL11.GL_LIGHT5, GL11.GL_LIGHT6, GL11.GL_LIGHT7, GL11.GL_LINE_STIPPLE, GL11.GL_MAP1_COLOR_4,
+                 GL11.GL_MAP1_INDEX, GL11.GL_MAP1_NORMAL, GL11.GL_MAP1_TEXTURE_COORD_1, GL11.GL_MAP1_TEXTURE_COORD_2,
+                 GL11.GL_MAP1_TEXTURE_COORD_3, GL11.GL_MAP1_TEXTURE_COORD_4, GL11.GL_MAP1_VERTEX_3, GL11.GL_MAP1_VERTEX_4,
+                 GL11.GL_MAP2_COLOR_4, GL11.GL_MAP2_INDEX, GL11.GL_MAP2_NORMAL, GL11.GL_MAP2_TEXTURE_COORD_1,
+                 GL11.GL_MAP2_TEXTURE_COORD_2, GL11.GL_MAP2_TEXTURE_COORD_3, GL11.GL_MAP2_TEXTURE_COORD_4,
+                 GL11.GL_MAP2_VERTEX_3, GL11.GL_MAP2_VERTEX_4, GL11.GL_NORMALIZE, GL11.GL_POINT_SMOOTH,
+                 GL11.GL_POLYGON_STIPPLE, GL12.GL_RESCALE_NORMAL, GL11.GL_TEXTURE_1D, GL12.GL_TEXTURE_3D,
+                 GL13.GL_TEXTURE_CUBE_MAP, GL11.GL_TEXTURE_GEN_S, GL11.GL_TEXTURE_GEN_T, GL11.GL_TEXTURE_GEN_R,
+                 GL11.GL_TEXTURE_GEN_Q, GL11.GL_LIGHT_MODEL_LOCAL_VIEWER, GL11.GL_LIGHT_MODEL_TWO_SIDE,
+                 GL11.GL_VERTEX_ARRAY, GL11.GL_NORMAL_ARRAY, GL11.GL_COLOR_ARRAY, GL11.GL_TEXTURE_COORD_ARRAY,
+                 GL11.GL_INDEX_ARRAY, GL11.GL_EDGE_FLAG_ARRAY, GL14.GL_SECONDARY_COLOR_ARRAY, GL14.GL_FOG_COORDINATE_ARRAY,
+                 GL11.GL_EDGE_FLAG, GL20.GL_POINT_SPRITE, GL20.GL_VERTEX_PROGRAM_TWO_SIDE -> BOOL;
+            case GL11.GL_ALPHA_TEST_FUNC, GL11.GL_LIST_BASE, GL11.GL_MATRIX_MODE, GL11.GL_SHADE_MODEL,
+                 GL11.GL_COLOR_MATERIAL_FACE, GL11.GL_COLOR_MATERIAL_PARAMETER, GL12.GL_LIGHT_MODEL_COLOR_CONTROL,
+                 GL11.GL_FOG_MODE, GL11.GL_LINE_STIPPLE_PATTERN, GL11.GL_LINE_STIPPLE_REPEAT, GL13.GL_CLIENT_ACTIVE_TEXTURE,
+                 GL20.GL_MAX_TEXTURE_COORDS, GL11.GL_RENDER_MODE, GL11.GL_FOG_HINT, GL11.GL_PERSPECTIVE_CORRECTION_HINT,
+                 GL11.GL_POINT_SMOOTH_HINT, GL14.GL_GENERATE_MIPMAP_HINT, GL11.GL_LINE_SMOOTH_HINT, GL11.GL_POLYGON_SMOOTH_HINT,
+                 GL13.GL_TEXTURE_COMPRESSION_HINT, GL20.GL_FRAGMENT_SHADER_DERIVATIVE_HINT, GL20.GL_POINT_SPRITE_COORD_ORIGIN,
+                 GL11.GL_VERTEX_ARRAY_SIZE, GL11.GL_VERTEX_ARRAY_TYPE, GL11.GL_VERTEX_ARRAY_STRIDE, GL15.GL_VERTEX_ARRAY_BUFFER_BINDING,
+                 GL11.GL_NORMAL_ARRAY_TYPE, GL11.GL_NORMAL_ARRAY_STRIDE, GL15.GL_NORMAL_ARRAY_BUFFER_BINDING,
+                 GL11.GL_COLOR_ARRAY_SIZE, GL11.GL_COLOR_ARRAY_TYPE, GL11.GL_COLOR_ARRAY_STRIDE, GL15.GL_COLOR_ARRAY_BUFFER_BINDING,
+                 GL11.GL_INDEX_ARRAY_TYPE, GL11.GL_INDEX_ARRAY_STRIDE, GL15.GL_INDEX_ARRAY_BUFFER_BINDING,
+                 GL11.GL_TEXTURE_COORD_ARRAY_SIZE, GL11.GL_TEXTURE_COORD_ARRAY_TYPE, GL11.GL_TEXTURE_COORD_ARRAY_STRIDE,
+                 GL15.GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING, GL11.GL_EDGE_FLAG_ARRAY_STRIDE, GL15.GL_EDGE_FLAG_ARRAY_BUFFER_BINDING,
+                 GL14.GL_SECONDARY_COLOR_ARRAY_SIZE, GL14.GL_SECONDARY_COLOR_ARRAY_TYPE, GL14.GL_SECONDARY_COLOR_ARRAY_STRIDE,
+                 GL15.GL_SECONDARY_COLOR_ARRAY_BUFFER_BINDING, GL14.GL_FOG_COORDINATE_ARRAY_TYPE, GL14.GL_FOG_COORDINATE_ARRAY_STRIDE,
+                 GL15.GL_FOG_COORDINATE_ARRAY_BUFFER_BINDING -> INT;
+            case GL11.GL_FOG_DENSITY, GL11.GL_FOG_START, GL11.GL_FOG_END, GL14.GL_POINT_SIZE_MIN, GL14.GL_POINT_SIZE_MAX,
+                 GL14.GL_POINT_FADE_THRESHOLD_SIZE -> FLOAT;
+            case GL11.GL_ALPHA_TEST_REF -> FLOATN;
+            case GL14.GL_POINT_DISTANCE_ATTENUATION -> FLOAT | 2 << COUNT_SHIFT;
+            case GL11.GL_CURRENT_TEXTURE_COORDS -> FLOAT | 3 << COUNT_SHIFT;
+            case GL11.GL_MODELVIEW_MATRIX, GL11.GL_PROJECTION_MATRIX, GL11.GL_TEXTURE_MATRIX -> FLOATN | 15 << COUNT_SHIFT;
+            case GL11.GL_CURRENT_NORMAL -> FLOATN | 2 << COUNT_SHIFT;
+            case GL11.GL_CURRENT_COLOR, GL14.GL_CURRENT_SECONDARY_COLOR, GL11.GL_FOG_COLOR, GL11.GL_LIGHT_MODEL_AMBIENT -> FLOATN | 3 << COUNT_SHIFT;
+            default -> 0;
+        };
+    }
+
+    static int type(int desc) {
+        return desc & 7;
+    }
+
+    static int count(int desc) {
+        return (desc >> COUNT_SHIFT) + 1;
+    }
+
+    static int floatToInt(float value) {
+        return (int) (2147483647.0 * value);
+    }
+
+    static int lround(float value) {
+        return value < 0 ? -Math.round(-value) : Math.round(value);
+    }
+
+    static int toInt(int type, float value) {
+        return type == FLOATN ? floatToInt(value) : lround(value);
+    }
+
+    private static FloatBuffer fillScratch(GLContextState glCtx, int pname) {
+        final FloatBuffer scratch = glCtx.queryScratch;
+        scratch.clear();
+        GLStateManager.glGetFloat(pname, scratch);
+        return scratch;
+    }
+
+    private static IllegalStateException uncached(int pname) {
+        return new IllegalStateException("Legacy pname 0x" + Integer.toHexString(pname) + " has no cached answer for its declared type");
+    }
+
+    static int getInteger(GLContextState glCtx, int pname, int desc) {
+        final int type = type(desc);
+        if (count(desc) > 1) {
+            return toInt(type, fillScratch(glCtx, pname).get(0));
+        }
+        return switch (type) {
+            case BOOL -> GLStateManager.glGetBoolean(glCtx, pname) ? GL11.GL_TRUE : GL11.GL_FALSE;
+            case FLOAT -> lround(GLStateManager.glGetFloat(glCtx, pname));
+            case FLOATN -> floatToInt(GLStateManager.glGetFloat(glCtx, pname));
+            default -> throw uncached(pname);
+        };
+    }
+
+    static float getFloat(GLContextState glCtx, int pname, int desc) {
+        if (count(desc) > 1) {
+            return fillScratch(glCtx, pname).get(0);
+        }
+        return switch (type(desc)) {
+            case BOOL -> GLStateManager.glGetBoolean(glCtx, pname) ? 1.0f : 0.0f;
+            case INT -> (float) GLStateManager.glGetInteger(glCtx, pname);
+            default -> throw uncached(pname);
+        };
+    }
+
+    static boolean getBoolean(GLContextState glCtx, int pname, int desc) {
+        if (count(desc) > 1) {
+            return fillScratch(glCtx, pname).get(0) != 0.0f;
+        }
+        return switch (type(desc)) {
+            case INT -> GLStateManager.glGetInteger(glCtx, pname) != 0;
+            case FLOAT, FLOATN -> GLStateManager.glGetFloat(glCtx, pname) != 0.0f;
+            default -> throw uncached(pname);
+        };
+    }
+
+    static boolean getIntegerv(GLContextState glCtx, int pname, IntBuffer params) {
+        final int desc = desc(pname);
+        if (desc == 0) return false;
+        final int pos = params.position();
+        final int type = type(desc);
+        final FloatBuffer scratch = fillScratch(glCtx, pname);
+        for (int i = 0, count = count(desc); i < count; i++) {
+            params.put(pos + i, toInt(type, scratch.get(i)));
+        }
+        return true;
+    }
+
+    static boolean getIntegerv(GLContextState glCtx, int pname, int[] params) {
+        final int desc = desc(pname);
+        if (desc == 0) return false;
+        final int type = type(desc);
+        final FloatBuffer scratch = fillScratch(glCtx, pname);
+        for (int i = 0, count = Math.min(count(desc), params.length); i < count; i++) {
+            params[i] = toInt(type, scratch.get(i));
+        }
+        return true;
+    }
+
+    static boolean getBooleanv(GLContextState glCtx, int pname, ByteBuffer params) {
+        final int desc = desc(pname);
+        if (desc == 0) return false;
+        final int pos = params.position();
+        final FloatBuffer scratch = fillScratch(glCtx, pname);
+        for (int i = 0, count = count(desc); i < count; i++) {
+            params.put(pos + i, (byte) (scratch.get(i) != 0.0f ? GL11.GL_TRUE : GL11.GL_FALSE));
+        }
+        return true;
+    }
+}
@@ -46,8 +46,11 @@ public class RenderSystem {
    private static boolean supportsMultiDrawIndirect;
    private static boolean supportsBufferStorage;
    private static boolean supportsClearTexture;
+    private static boolean supportsStencilTexturing;
+    private static boolean supportsTextureStorage;
    private static boolean supportsTesselation;
    private static boolean supportsSamplerObjects;
+    private static boolean supportsProgramBinary;
    private static int maxImageUnits;
    @Getter private static int maxCombinedTextureImageUnits;
    private static int maxSSBOBindings;
@@ -127,6 +130,8 @@ public class RenderSystem {
        supportsMultiDrawIndirect = GLStateManager.capabilities.OpenGL43 || GLStateManager.capabilities.GL_ARB_multi_draw_indirect;
        supportsBufferStorage = !isGLES && (GLStateManager.capabilities.OpenGL44 || GLStateManager.capabilities.GL_ARB_buffer_storage);
        supportsClearTexture = GLStateManager.capabilities.OpenGL44 || GLStateManager.capabilities.GL_ARB_clear_texture;
+        supportsStencilTexturing = GLStateManager.capabilities.OpenGL43 || GLStateManager.capabilities.GL_ARB_stencil_texturing;
+        supportsTextureStorage = isGLES ? glesVersion >= 300 : GLStateManager.capabilities.OpenGL42 || GLStateManager.capabilities.GL_ARB_texture_storage;
        hasClipCullDistance = !isGLES || hasExtension("GL_EXT_clip_cull_distance");

        // Cache maximum image units
@@ -159,6 +164,9 @@ public class RenderSystem {
            maxCombinedTextureImageUnits = RENDER_BACKEND.getInteger(GL20.GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS);
        }

+        supportsProgramBinary = RENDER_BACKEND.supportsProgramBinary();
+        GLStateManager.LOGGER.info("Program Binary: {}", supportsProgramBinary);
+
        maxGlslVersion = Integer.parseInt(parseGlVersionString(RENDER_BACKEND.getString(GL20.GL_SHADING_LANGUAGE_VERSION)));
        supportsGpuShader4 = GLStateManager.capabilities.GL_EXT_gpu_shader4;

@@ -263,6 +271,7 @@ public class RenderSystem {

    public static void copyTexSubImage2D(int destTexture, int target, int i, int i1, int i2, int i3, int i4, int width, int height) {
        dsaState.copyTexSubImage2D(destTexture, target, i, i1, i2, i3, i4, width, height);
+        if (i == 0) TextureInfoCache.INSTANCE.onContentsChanged(destTexture);
    }

    public static void texParameteri(int texture, int target, int pname, int param) {
@@ -277,35 +286,39 @@ public class RenderSystem {
        GLStateManager.suspendPixelUnpackBuffer();
        dsaState.textureImage2D(texture, target, level, internalformat, width, height, border, format, type, pixels);
        GLStateManager.restorePixelUnpackBuffer();
+        TextureInfoCache.INSTANCE.onTextureImage2D(texture, target, level, internalformat, width, height);
    }

    public static void textureImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, IntBuffer pixels) {
        GLStateManager.suspendPixelUnpackBuffer();
        dsaState.textureImage2D(texture, target, level, internalformat, width, height, border, format, type, pixels);
        GLStateManager.restorePixelUnpackBuffer();
+        TextureInfoCache.INSTANCE.onTextureImage2D(texture, target, level, internalformat, width, height);
    }

    public static void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, ByteBuffer pixels) {
        GLStateManager.suspendPixelUnpackBuffer();
        dsaState.textureSubImage2D(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
        GLStateManager.restorePixelUnpackBuffer();
+        if (level == 0) TextureInfoCache.INSTANCE.onContentsChanged(texture);
    }

    public static void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, IntBuffer pixels) {
        GLStateManager.suspendPixelUnpackBuffer();
        dsaState.textureSubImage2D(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
        GLStateManager.restorePixelUnpackBuffer();
+        if (level == 0) TextureInfoCache.INSTANCE.onContentsChanged(texture);
    }

    public static void texImage1D(int texture, int target, int level, int internalformat, int width, int border, int format, int type, ByteBuffer pixels) {
-        RENDER_BACKEND.bindTexture(target, texture);
+        GLStateManager.glBindTexture(target, texture);
        GLStateManager.suspendPixelUnpackBuffer();
        RENDER_BACKEND.texImage1D(target, level, internalformat, width, border, format, type, pixels);
        GLStateManager.restorePixelUnpackBuffer();
    }

    public static void texImage3D(int texture, int target, int level, int internalformat, int width, int height, int depth, int border, int format, int type, ByteBuffer pixels) {
-        RENDER_BACKEND.bindTexture(target, texture);
+        GLStateManager.glBindTexture(target, texture);
        GLStateManager.suspendPixelUnpackBuffer();
        RENDER_BACKEND.texImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
        GLStateManager.restorePixelUnpackBuffer();
@@ -449,6 +462,14 @@ public class RenderSystem {
        return supportsClearTexture;
    }

+    public static boolean supportsStencilTexturing() {
+        return supportsStencilTexturing;
+    }
+
+    public static boolean supportsTextureStorage() {
+        return supportsTextureStorage;
+    }
+
    public static int getMaxSSBOBindings() {
        return maxSSBOBindings;
    }
@@ -552,7 +573,7 @@ public class RenderSystem {
    }

    public static int getIndexedBufferBinding(int target, int index) {
-        return RENDER_BACKEND.getIndexedBufferBinding(target, index);
+        return GLStateManager.getIndexedBufferBinding(target, index);
    }

    public static void bindBufferBase(int target, int index, int buffer) {
@@ -611,6 +632,10 @@ public class RenderSystem {
        return supportsSamplerObjects;
    }

+    public static boolean supportsProgramBinary() {
+        return supportsProgramBinary;
+    }
+
    public static int genSampler() {
        if (!supportsSamplerObjects) return 0;
        return GLStateManager.glGenSamplers();
@@ -680,4 +705,12 @@ public class RenderSystem {
        if (actualVersion < 0) return true;
        return actualVersion >= requestedMajor * 10 + requestedMinor;
    }
+
+    public static final int MIN_CORE_VERSION = 33;
+
+    public static int probeCapAfterRejection(int requested, int actual) {
+        if (actual >= MIN_CORE_VERSION && actual < requested) return actual;
+        if (actual >= 0 && actual < MIN_CORE_VERSION && requested > MIN_CORE_VERSION) return MIN_CORE_VERSION;
+        return requested - 1;
+    }
 }
@@ -24,6 +24,7 @@ public final class StateSet {
    public static final int R_ACTIVE_UNIT = 1 << 13;
    public static final int R_PROGRAM = 1 << 14;
    public static final int R_SCISSOR = 1 << 15;
+    public static final int R_HINT = 1 << 16;

    public static final int B_FRAG_COLORBUF = 1;
    public static final int B_FRAG_TEXTURE = 1 << 1;
@@ -107,9 +108,11 @@ public final class StateSet {
                GLStateManager.getTextures().getTextureUnitBindings(0), GLStateManager.getTextures().getTextureUnitBindings(1),
                GLStateManager.getActiveTextureUnitStack(), GLStateManager.getProgramStack(),
                GLStateManager.getBlendMode(), GLStateManager.getAlphaTest(), GLStateManager.getDepthTest(),
-                GLStateManager.getTextures().getTextureUnitStates(0)
+                GLStateManager.getTextures().getTextureUnitStates(0),
+                GLStateManager.getColorMask(), GLStateManager.getCullState(),
+                GLStateManager.getPolygonState(), GLStateManager.getPolygonOffsetFillState()
            ),
-            R_BLEND | R_DEPTH | R_TEXTURE | R_ACTIVE_UNIT | R_PROGRAM,
+            R_BLEND | R_DEPTH | R_COLOR_MASK | R_TEXTURE | R_ACTIVE_UNIT | R_PROGRAM | R_POLYGON,
            0,
            true);
    }
@@ -121,9 +124,11 @@ public final class StateSet {
                GLStateManager.getTextures().getTextureUnitBindings(0), GLStateManager.getTextures().getTextureUnitBindings(1),
                GLStateManager.getActiveTextureUnitStack(),
                GLStateManager.getBlendMode(), GLStateManager.getAlphaTest(), GLStateManager.getDepthTest(),
-                GLStateManager.getTextures().getTextureUnitStates(0)
+                GLStateManager.getTextures().getTextureUnitStates(0),
+                GLStateManager.getColorMask(), GLStateManager.getCullState(),
+                GLStateManager.getPolygonState(), GLStateManager.getPolygonOffsetFillState()
            ),
-            R_BLEND | R_DEPTH | R_TEXTURE | R_ACTIVE_UNIT,
+            R_BLEND | R_DEPTH | R_COLOR_MASK | R_TEXTURE | R_ACTIVE_UNIT | R_POLYGON,
            0,
            true);
    }
@@ -220,6 +225,9 @@ public final class StateSet {
        if ((mask & GL11.GL_POINT_BIT) != 0) {
            restore |= R_POINT;
        }
+        if ((mask & GL11.GL_HINT_BIT) != 0) {
+            restore |= R_HINT;
+        }
        if ((mask & GL11.GL_POLYGON_BIT) != 0) {
            restore |= R_POLYGON;
        }
@@ -0,0 +1,42 @@
+package com.gtnewhorizons.angelica.glsm.backend;
+
+import com.gtnewhorizons.angelica.config.SystemProperties;
+
+public final class BackendOptions {
+
+    private static boolean configSdlGpu;
+    private static String configDriver = "";
+    private static int configGlVersion;
+
+    private BackendOptions() {}
+
+    public static void latch(boolean sdlGpu, String driver, int glVersion) {
+        configSdlGpu = sdlGpu;
+        configDriver = driver;
+        configGlVersion = glVersion;
+    }
+
+    public static boolean sdlGpuRequested() {
+        return SystemProperties.SDL_GPU_OVERRIDE != null ? SystemProperties.SDL_GPU_OVERRIDE : configSdlGpu;
+    }
+
+    public static String sdlGpuDriver() {
+        return sdlGpuDriver(configDriver);
+    }
+
+    public static String sdlGpuDriver(String driver) {
+        return SystemProperties.SDL_GPU_DRIVER_OVERRIDE != null ? SystemProperties.SDL_GPU_DRIVER_OVERRIDE : driver;
+    }
+
+    public static boolean configSdlGpu() {
+        return configSdlGpu;
+    }
+
+    public static String configDriver() {
+        return configDriver;
+    }
+
+    public static int configGlVersion() {
+        return configGlVersion;
+    }
+}
@@ -0,0 +1,96 @@
+package com.gtnewhorizons.angelica.glsm.backend;
+
+import com.google.common.primitives.Ints;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+
+public final class BackendStartGuard {
+
+    private static final Logger LOGGER = LogManager.getLogger("Angelica/BackendStartGuard");
+
+    static final int STRIKE_LIMIT = 3;
+
+    private static File marker;
+    private static File verified;
+    private static String key;
+    private static int strikes;
+    private static boolean pending;
+    private static boolean tripped;
+
+    private BackendStartGuard() {}
+
+    public static boolean begin(File dir, boolean sdlGpuConfigured, boolean flagForced, int requirementsRevision, String requestedDriver) {
+        marker = new File(dir, "sdlgpu-starting");
+        verified = new File(dir, "sdlgpu-verified");
+        key = requirementsRevision + "/" + requestedDriver;
+        pending = tripped = false;
+        if (flagForced) return false;
+        if (!sdlGpuConfigured) {
+            delete(marker);
+            return false;
+        }
+        if (key.equals(read(verified))) return false;
+        final String count = read(marker);
+        final Integer parsed = count == null ? null : Ints.tryParse(count.trim());
+        strikes = parsed == null ? 0 : parsed;
+        if (strikes >= STRIKE_LIMIT) {
+            LOGGER.warn("SDL GPU failed to bring up the device {} times in a row; resetting the render backend to OpenGL", strikes);
+            delete(marker);
+            tripped = true;
+            return true;
+        }
+        if (strikes == STRIKE_LIMIT - 1) {
+            LOGGER.warn("SDL GPU failed to bring up the device {} times in a row; one more and the render backend switches to OpenGL", strikes);
+        } else if (strikes > 0) {
+            LOGGER.info("The last start ended while bringing up the SDL GPU device");
+        }
+        pending = true;
+        return false;
+    }
+
+    public static void arm() {
+        if (pending) write(marker, Integer.toString(strikes + 1));
+    }
+
+    public static void disarm() {
+        if (pending) delete(marker);
+    }
+
+    public static void latch() {
+        if (!pending) return;
+        pending = false;
+        write(verified, key);
+        LOGGER.info("SDL GPU booted; the startup guard stays off until the requirements revision or driver changes");
+    }
+
+    public static boolean tripped() {
+        return tripped;
+    }
+
+    private static String read(File file) {
+        try {
+            return file.isFile() ? new String(Files.readAllBytes(file.toPath()), StandardCharsets.UTF_8) : null;
+        } catch (IOException e) {
+            LOGGER.warn("Could not read {}: {}", file, e.toString());
+            return null;
+        }
+    }
+
+    private static void write(File file, String content) {
+        try {
+            Files.createDirectories(file.toPath().getParent());
+            Files.write(file.toPath(), content.getBytes(StandardCharsets.UTF_8));
+        } catch (IOException e) {
+            LOGGER.warn("Could not write {}: {}", file, e.toString());
+        }
+    }
+
+    private static void delete(File file) {
+        if (file.isFile() && !file.delete()) LOGGER.warn("Could not delete {}", file);
+    }
+}
@@ -1,6 +1,7 @@
 package com.gtnewhorizons.angelica.glsm.backend;

 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.RenderSystem;
 import org.lwjgl.BufferUtils;
 import org.lwjgl.opengl.AMDDebugOutput;
 import org.lwjgl.opengl.AMDDebugOutputCallback;
@@ -23,6 +24,7 @@ import org.lwjgl.opengl.GL20;
 import org.lwjgl.opengl.GL30;
 import org.lwjgl.opengl.GL31;
 import org.lwjgl.opengl.GL40;
+import org.lwjgl.opengl.GL41;
 import org.lwjgl.opengl.GL32;
 import org.lwjgl.opengl.GL33;
 import org.lwjgl.opengl.GL42;
@@ -607,6 +609,21 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
        GL30.glFramebufferTexture2D(target, attachment, textarget, texture, level);
    }

+    @Override
+    public void framebufferTexture1D(int target, int attachment, int textarget, int texture, int level) {
+        GL30.glFramebufferTexture1D(target, attachment, textarget, texture, level);
+    }
+
+    @Override
+    public void framebufferTexture3D(int target, int attachment, int textarget, int texture, int level, int zoffset) {
+        GL30.glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
+    }
+
+    @Override
+    public void framebufferTextureLayer(int target, int attachment, int texture, int level, int layer) {
+        GL30.glFramebufferTextureLayer(target, attachment, texture, level, layer);
+    }
+
    @Override
    public void framebufferTexture(int target, int attachment, int texture, int level) {
        GL32.glFramebufferTexture(target, attachment, texture, level);
@@ -807,6 +824,28 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
        return GL20.glIsProgram(obj);
    }

+    @Override
+    public boolean supportsProgramBinary() {
+        final ContextCapabilities caps = GLStateManager.capabilities;
+        return !RenderSystem.isGLES() && (caps.OpenGL41 || caps.GL_ARB_get_program_binary)
+            && GL11.glGetInteger(GL41.GL_NUM_PROGRAM_BINARY_FORMATS) > 0;
+    }
+
+    @Override
+    public void programParameteri(int program, int pname, int value) {
+        GL41.glProgramParameteri(program, pname, value);
+    }
+
+    @Override
+    public void getProgramBinary(int program, IntBuffer length, IntBuffer binaryFormat, ByteBuffer binary) {
+        GL41.glGetProgramBinary(program, length, binaryFormat, binary);
+    }
+
+    @Override
+    public void programBinary(int program, int binaryFormat, ByteBuffer binary) {
+        GL41.glProgramBinary(program, binaryFormat, binary);
+    }
+
    @Override
    public void validateProgram(int program) {
        GL20.glValidateProgram(program);
@@ -0,0 +1,125 @@
+package com.gtnewhorizons.angelica.glsm.backend;
+
+import com.gtnewhorizons.angelica.config.SystemProperties;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.Arrays;
+
+public final class MoltenVK {
+
+    public enum Source {
+        ENV,
+        JAR,
+        SYSTEM,
+        NONE
+    }
+
+    public static final String ENV_VULKAN_LIBRARY = "SDL_VULKAN_LIBRARY";
+    public static final String JAR_NAME = "angelica-moltenvk";
+
+    private static final Logger LOGGER = LogManager.getLogger("Angelica/MoltenVK");
+    private static final String LIB_NAME = "libMoltenVK.dylib";
+    private static final String[] SYSTEM_PATHS = { "/opt/homebrew/lib/" + LIB_NAME, "/usr/local/lib/" + LIB_NAME };
+    private static final String ARCH = archName(System.getProperty("os.arch", ""));
+
+    private static Source source;
+    private static String path;
+    private static boolean located;
+
+    private MoltenVK() {}
+
+    public static synchronized Source source() {
+        if (source == null) {
+            final boolean macos = System.getProperty("os.name", "").toLowerCase().contains("mac");
+            source = detect(macos, System.getenv(ENV_VULKAN_LIBRARY), MoltenVK.class.getResource(bundledResource(ARCH)) != null, SYSTEM_PATHS);
+        }
+        return source;
+    }
+
+    public static synchronized String locate() {
+        if (!located) {
+            path = resolve(source(), System.getenv(ENV_VULKAN_LIBRARY), bundledResource(ARCH), new File(SystemProperties.MOLTENVK_DIR), ARCH, SYSTEM_PATHS);
+            located = true;
+        }
+        return path;
+    }
+
+    static String archName(String osArch) {
+        final String arch = osArch.toLowerCase();
+        return arch.contains("aarch64") || arch.contains("arm64") ? "arm64" : "x64";
+    }
+
+    static String bundledResource(String arch) {
+        return "/macos/" + arch + "/org/lwjgl/vulkan/" + LIB_NAME;
+    }
+
+    static Source detect(boolean macos, String env, boolean bundled, String[] systemPaths) {
+        if (!macos) return Source.NONE;
+        if (env != null && !env.isEmpty()) return Source.ENV;
+        if (bundled) return Source.JAR;
+        return systemPath(systemPaths) != null ? Source.SYSTEM : Source.NONE;
+    }
+
+    static String resolve(Source source, String env, String resource, File dir, String arch, String[] systemPaths) {
+        return switch (source) {
+            case ENV -> env;
+            case JAR -> {
+                final String extracted = extract(resource, dir, arch);
+                yield extracted != null ? extracted : systemPath(systemPaths);
+            }
+            case SYSTEM -> systemPath(systemPaths);
+            case NONE -> null;
+        };
+    }
+
+    private static String systemPath(String[] systemPaths) {
+        for (final String candidate : systemPaths) {
+            if (new File(candidate).isFile()) return candidate;
+        }
+        return null;
+    }
+
+    private static String extract(String resource, File dir, String arch) {
+        final byte[] lib;
+        try (InputStream in = MoltenVK.class.getResourceAsStream(resource)) {
+            if (in == null) return null;
+            lib = readAll(in);
+        } catch (IOException e) {
+            LOGGER.warn("MoltenVK: failed reading {}: {}", resource, e.toString());
+            return null;
+        }
+
+        final File target = new File(dir, "libMoltenVK-" + arch + ".dylib");
+        File tmp = null;
+        try {
+            if (!target.isFile() || target.length() != lib.length || !Arrays.equals(Files.readAllBytes(target.toPath()), lib)) {
+                if (!dir.isDirectory() && !dir.mkdirs()) throw new IOException("cannot create " + dir);
+                tmp = File.createTempFile("libMoltenVK", ".dylib", dir);
+                Files.write(tmp.toPath(), lib);
+                Files.move(tmp.toPath(), target.toPath(), StandardCopyOption.REPLACE_EXISTING);
+            }
+        } catch (IOException e) {
+            LOGGER.warn("MoltenVK: failed extracting to {}: {}", target, e.toString());
+            if (tmp != null) tmp.delete();
+            return null;
+        }
+        return target.getAbsolutePath();
+    }
+
+    private static byte[] readAll(InputStream in) throws IOException {
+        final ByteArrayOutputStream out = new ByteArrayOutputStream(1 << 20);
+        final byte[] buf = new byte[16384];
+        int n;
+        while ((n = in.read(buf)) != -1) {
+            out.write(buf, 0, n);
+        }
+        return out.toByteArray();
+    }
+}
@@ -36,6 +36,9 @@ public abstract class RenderBackend {
    /** Returns true if the current thread has a valid render context. */
    public abstract boolean hasContext();

+    /** Returns true if the calling thread may issue render commands. */
+    public boolean hasContextOnThread() { return hasContext(); }
+
    /** Returns true if the calling thread owns the "GL Context" */
    public abstract boolean isCurrent();

@@ -56,6 +59,7 @@ public abstract class RenderBackend {

    public boolean framebufferCompletenessIsMeaningful() { return true; }
    public void onPersistentBufferWrite(int glId, long offset, long size) {}
+    public boolean isBufferImmutable(int glId) { return false; }

    public boolean isAnisotropicSupported() { return true; }

@@ -95,7 +99,7 @@ public abstract class RenderBackend {

    static VSyncMode resolveTearFreeMode(VSyncMode preferred, Predicate<VSyncMode> supported) {
        if (preferred != null && preferred.tearFree() && supported.test(preferred)) return preferred;
-        return supported.test(VSyncMode.MAILBOX) ? VSyncMode.MAILBOX : VSyncMode.ON;
+        return VSyncMode.ON;
    }

    protected abstract VSyncMode applyVSyncMode(VSyncMode preferred);
@@ -272,6 +276,12 @@ public abstract class RenderBackend {
    public void voxelizeRegion(long pass, boolean rebindVertexBuffer, float x, float y, float z, int rangeBase, int rangeCount, int vertexTotal) {}
    public void endVoxelizationBatch(long pass) {}

+    public void setVertexWriteReplay(int graphicsProgram, VertexWriteReplaySetup setup) {}
+
+    public boolean supportsComputeImageAtomics() { return true; }
+
+    public boolean supportsComputeImageAtomics(int width, int height, int depth) { return supportsComputeImageAtomics(); }
+
    public abstract void enable(int cap);
    public abstract void enablei(int cap, int index);
    public abstract void disable(int cap);
@@ -447,6 +457,9 @@ public abstract class RenderBackend {
    public abstract void deleteFramebuffers(int framebuffer);
    public abstract void bindFramebuffer(int target, int framebuffer);
    public abstract void framebufferTexture2D(int target, int attachment, int textarget, int texture, int level);
+    public abstract void framebufferTexture1D(int target, int attachment, int textarget, int texture, int level);
+    public abstract void framebufferTexture3D(int target, int attachment, int textarget, int texture, int level, int zoffset);
+    public abstract void framebufferTextureLayer(int target, int attachment, int texture, int level, int layer);
    public abstract void framebufferTexture(int target, int attachment, int texture, int level);
    public abstract int genRenderbuffers();
    public abstract void deleteRenderbuffers(int renderbuffer);
@@ -504,6 +517,10 @@ public abstract class RenderBackend {
    public abstract int getUniformLocation(int program, ByteBuffer name);
    public boolean isShader(int obj) { return false; }
    public boolean isProgram(int obj) { return false; }
+    public boolean supportsProgramBinary() { return false; }
+    public void programParameteri(int program, int pname, int value) {}
+    public void getProgramBinary(int program, IntBuffer length, IntBuffer binaryFormat, ByteBuffer binary) {}
+    public void programBinary(int program, int binaryFormat, ByteBuffer binary) {}
    public void validateProgram(int program) {}
    public void getAttachedShaders(int program, IntBuffer count, IntBuffer shaders) {
        if (count != null) count.put(0, 0);
@@ -0,0 +1,23 @@
+package com.gtnewhorizons.angelica.glsm.backend;
+
+import java.util.function.IntSupplier;
+
+/**
+ * How to replay a graphics program's vertex-stage image writes.
+ *
+ * @param inputLocations    per input, the declared location or -1 for whatever the graphics program linked
+ * @param images            per image the replay uses, in binding order: the written ones, then the read-only ones
+ * @param writtenImageCount how many of {@code images} the replay writes
+ * @param samplerNames      samplers the graphics program may not have, because only the stripped writes read them
+ * @param samplerUnits      per sampler name, the texture unit it reads at each draw, or -1 to use samplerTextures
+ * @param samplerTextures   per sampler name, its texture when samplerUnits is -1
+ * @param samplerObjects    per sampler name, the GL sampler object to sample it with when samplerUnits is -1, or 0
+ * @param vertexBufferBinding storage buffer binding of the first vertex buffer the replay program declares
+ * @param vertexBufferCount   how many vertex buffers it declares, at consecutive bindings
+ * @param indexBufferBinding  storage buffer binding of its index buffer
+ */
+public record VertexWriteReplaySetup(int replayProgram, String[] inputNames, int[] inputLocations,
+                                     IntSupplier[] images, int writtenImageCount,
+                                     String[] samplerNames, int[] samplerUnits, IntSupplier[] samplerTextures, int[] samplerObjects,
+                                     int vertexBufferBinding, int vertexBufferCount, int indexBufferBinding) {
+}
@@ -128,16 +128,17 @@ public class DSAARB extends DSAUnsupported {

    @Override
    public void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels) {
-        RENDER_BACKEND.namedFramebufferTexture(fb, attachment, texture, levels);
+        GLStateManager.glNamedFramebufferTexture(fb, attachment, texture, levels);
    }

    @Override
    public int createFramebuffer() {
+        GLStateManager.requireContext("glCreateFramebuffers");
        return RENDER_BACKEND.createFramebuffers();
    }

    @Override
    public int createTexture(int target) {
-        return RENDER_BACKEND.createTextures(target);
+        return GLStateManager.glCreateTextures(target);
    }
 }
@@ -2,13 +2,12 @@ package com.gtnewhorizons.angelica.glsm.dsa;

 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.stacks.TextureBindingStack;
+import com.gtnewhorizons.angelica.glsm.texture.TextureTargets;
 import org.lwjgl.opengl.GL11;

 import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
-import org.lwjgl.opengl.GL12;
 import org.lwjgl.opengl.GL13;
 import org.lwjgl.opengl.GL30;
-import org.lwjgl.opengl.GL31;

 import java.nio.ByteBuffer;
 import java.nio.FloatBuffer;
@@ -153,7 +152,7 @@ public class DSAUnsupported implements DSAAccess {
    @Override
    public void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels) {
        GLStateManager.glBindFramebuffer(fbtarget, fb);
-        RENDER_BACKEND.framebufferTexture2D(fbtarget, attachment, target, texture, levels);
+        GLStateManager.glFramebufferTexture2D(fbtarget, attachment, target, texture, levels);
    }

    @Override
@@ -165,24 +164,13 @@ public class DSAUnsupported implements DSAAccess {

    @Override
    public int createTexture(int target) {
-        final int texture = RENDER_BACKEND.genTextures();
-        GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texture);
+        final int texture = GLStateManager.glGenTextures();
+        GLStateManager.glBindTexture(target, texture);
        return texture;
    }

-    private static int bindingQuery(int target) {
-        return switch (target) {
-            case GL11.GL_TEXTURE_1D -> GL11.GL_TEXTURE_BINDING_1D;
-            case GL12.GL_TEXTURE_3D -> GL12.GL_TEXTURE_BINDING_3D;
-            case GL13.GL_TEXTURE_CUBE_MAP -> GL13.GL_TEXTURE_BINDING_CUBE_MAP;
-            case GL30.GL_TEXTURE_2D_ARRAY -> GL30.GL_TEXTURE_BINDING_2D_ARRAY;
-            case GL31.GL_TEXTURE_RECTANGLE -> GL31.GL_TEXTURE_BINDING_RECTANGLE;
-            default -> GL11.GL_TEXTURE_BINDING_2D;
-        };
-    }
-
    private static int previousBinding(int target) {
-        return target == GL11.GL_TEXTURE_2D ? previous2D() : RENDER_BACKEND.getInteger(bindingQuery(target));
+        return target == GL11.GL_TEXTURE_2D ? previous2D() : RENDER_BACKEND.getInteger(TextureTargets.bindingQuery(target));
    }

    private static int previous2D() {
@@ -5,6 +5,7 @@ import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memPutFloat;
 public record CubeParams(float minX, float minY, float minZ, float spanX, float spanY, float spanZ, float u0, float v0, float uScaleX, float vScaleY, float uScaleZ, float vScaleZ) {

    private static final float MIN_SPAN = 1.0e-4f;
+    private static final float UV_EPSILON = 1.0e-5f;

    public CubeParams {
        if (!(spanX > MIN_SPAN && spanY > MIN_SPAN && spanZ > MIN_SPAN)) throw new IllegalArgumentException("degenerate cube span");
@@ -43,12 +44,25 @@ public record CubeParams(float minX, float minY, float minZ, float spanX, float
        }
    }

-    public void writeTexture(long ptr) {
-        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_LIGHTMAP_SCALE + 8, uScaleZ);
-        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_LIGHTMAP_SCALE + 12, vScaleZ);
-        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_CUBE_TEX, u0);
-        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_CUBE_TEX + 4, v0);
-        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_CUBE_TEX + 8, uScaleX);
-        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_CUBE_TEX + 12, vScaleY);
+    public boolean uvInsideTexture() {
+        final float u1 = u0 + 2.0f * (Math.abs(uScaleX) + uScaleZ);
+        final float v1 = v0 + vScaleY + vScaleZ;
+        return u0 >= 0.0f && v0 >= 0.0f && u1 <= 1.0f + UV_EPSILON && v1 <= 1.0f + UV_EPSILON;
+    }
+
+    public static boolean allInsideTexture(CubeParams[] cubes) {
+        for (CubeParams cube : cubes) {
+            if (!cube.uvInsideTexture()) return false;
+        }
+        return true;
+    }
+
+    public void writeTexture(long ptr, float regionU, float regionV, float regionW, float regionH) {
+        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_LIGHTMAP_SCALE + 8, uScaleZ * regionW);
+        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_LIGHTMAP_SCALE + 12, vScaleZ * regionH);
+        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_CUBE_TEX, regionU + u0 * regionW);
+        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_CUBE_TEX + 4, regionV + v0 * regionH);
+        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_CUBE_TEX + 8, uScaleX * regionW);
+        memPutFloat(ptr + CubeInstancedAttribs.OFFSET_CUBE_TEX + 12, vScaleY * regionH);
    }
 }
@@ -0,0 +1,32 @@
+package com.gtnewhorizons.angelica.glsm.ffp;
+
+import com.gtnewhorizons.angelica.glsm.states.FogState;
+
+public final class FfpGlsl {
+
+    private FfpGlsl() {}
+
+    // Mesa ffvertex_prog.c build_fog(): FDM_EYE_RADIAL/EYE_PLANE/EYE_PLANE_ABS
+    public static String fogDistance(int mode, String eye) {
+        return switch (mode) {
+            case FogState.DISTANCE_EYE_RADIAL -> "length(" + eye + ".xyz)";
+            case FogState.DISTANCE_EYE_PLANE -> eye + ".z";
+            default -> "abs(" + eye + ".z)";
+        };
+    }
+
+    public static void appendFogFactor(StringBuilder sb, String indent, int fogMode, String coord, String params) {
+        switch (fogMode) {
+            case FragmentKey.FOG_LINEAR -> sb.append(indent).append("f = ").append(coord).append(" * ").append(params).append(".x + ").append(params).append(".y;\n");
+            case FragmentKey.FOG_EXP -> sb.append(indent).append("f = exp2(-(").append(coord).append(" * ").append(params).append(".z));\n");
+            case FragmentKey.FOG_EXP2 -> {
+                sb.append(indent).append("float fogTmp = ").append(coord).append(" * ").append(params).append(".w;\n");
+                sb.append(indent).append("f = exp2(-(fogTmp * fogTmp));\n");
+            }
+        }
+    }
+
+    public static String quantizeAlpha(String alpha) {
+        return "round(" + alpha + " * 255.0)";
+    }
+}
@@ -65,6 +65,16 @@ public final class FragmentKey {
    public static final int FOG_EXP    = 2;
    public static final int FOG_EXP2   = 3;

+    public static int activeFogMode(GLContextState glCtx) {
+        if (!glCtx.fogMode.isEnabled()) return FOG_NONE;
+        return switch (glCtx.fogState.getFogMode()) {
+            case GL11.GL_LINEAR -> FOG_LINEAR;
+            case GL11.GL_EXP    -> FOG_EXP;
+            case GL11.GL_EXP2   -> FOG_EXP2;
+            default -> FOG_NONE;
+        };
+    }
+
    private static final int GLOBAL_BITS = 14;
    private static final int BIT_COMBINED_GLINT = 61;
    private static final int BIT_GLINT_REPLACE_ALPHA = 62;
@@ -117,15 +127,7 @@ public final class FragmentKey {
        if (CombinedGlint.replacesAlpha()) global |= 1L << BIT_GLINT_REPLACE_ALPHA;

        // Fog
-        if (glCtx.fogMode.isEnabled()) {
-            final int fogMode = switch (glCtx.fogState.getFogMode()) {
-                case GL11.GL_LINEAR -> FOG_LINEAR;
-                case GL11.GL_EXP    -> FOG_EXP;
-                case GL11.GL_EXP2   -> FOG_EXP2;
-                default -> FOG_NONE;
-            };
-            global |= (long) fogMode;
-        }
+        global |= activeFogMode(glCtx);

        // Alpha test
        if (glCtx.alphaTest.isEnabled()) {
@@ -305,7 +305,7 @@ public final class FragmentShaderGenerator {
        final int func = FragmentKey.decodeAlphaFunc(key.alphaTestFunc());


-        sb.append("  float qa = round(color.a * 255.0);\n");
+        sb.append("  float qa = ").append(FfpGlsl.quantizeAlpha("color.a")).append(";\n");
        switch (func) {
            case GL11.GL_NEVER ->
                sb.append("  discard;\n");
@@ -335,18 +335,7 @@ public final class FragmentShaderGenerator {

        sb.append("  // Fog\n");
        sb.append("  float f;\n");
-
-        switch (fogMode) {
-            case FragmentKey.FOG_LINEAR ->
-                sb.append("  f = v_FogCoord * u_FogParams.x + u_FogParams.y;\n");
-            case FragmentKey.FOG_EXP ->
-                sb.append("  f = exp2(-(v_FogCoord * u_FogParams.z));\n");
-            case FragmentKey.FOG_EXP2 -> {
-                sb.append("  float fogTmp = v_FogCoord * u_FogParams.w;\n");
-                sb.append("  f = exp2(-(fogTmp * fogTmp));\n");
-            }
-        }
-
+        FfpGlsl.appendFogFactor(sb, "  ", fogMode, "v_FogCoord", "u_FogParams");
        sb.append("  f = clamp(f, 0.0, 1.0);\n");
        sb.append("  color.rgb = mix(u_FogColor.rgb, color.rgb, f);\n");
    }
@@ -1,107 +0,0 @@
-package com.gtnewhorizons.angelica.glsm.ffp;
-
-/**
- * Generates GLSL 330 core geometry shaders for wide line emulation.
- */
-public final class GeometryShaderGenerator {
-
-    private GeometryShaderGenerator() {}
-
-    public static String generate(VertexKey key) {
-        final StringBuilder sb = new StringBuilder(1024);
-        sb.append("#version 330 core\n\n");
-
-        sb.append("layout(lines) in;\n");
-        sb.append("layout(triangle_strip, max_vertices = 4) out;\n\n");
-
-        sb.append(FFPUniformBlock.GLSL_DECL);
-        sb.append('\n');
-
-        sb.append("// Pass-through varyings\n");
-        sb.append("in vec4 v_Color_gs[];\n");
-        if (key.separateSpecular()) {
-            sb.append("in vec3 v_SpecularColor_gs[];\n");
-        }
-        if (key.unitTexCoordEnabled(0) || key.texGenEnabled()) sb.append("in vec4 v_TexCoord0_gs[];\n");
-        if (key.lightmapEnabled())            sb.append("in vec4 v_TexCoord1_gs[];\n");
-        if (key.unitTexCoordEnabled(2))       sb.append("in vec4 v_TexCoord2_gs[];\n");
-        if (key.unitTexCoordEnabled(3))       sb.append("in vec4 v_TexCoord3_gs[];\n");
-        if (key.fogEnabled()) {
-            sb.append("in float v_FogCoord_gs[];\n");
-        }
-        if (key.lineStipple()) {
-            sb.append("flat in vec2 v_LineStart_gs[];\n");
-        }
-        sb.append('\n');
-
-        sb.append("out vec4 v_Color;\n");
-        if (key.separateSpecular()) {
-            sb.append("out vec3 v_SpecularColor;\n");
-        }
-        if (key.unitTexCoordEnabled(0) || key.texGenEnabled()) sb.append("out vec4 v_TexCoord0;\n");
-        if (key.lightmapEnabled())            sb.append("out vec4 v_TexCoord1;\n");
-        if (key.unitTexCoordEnabled(2))       sb.append("out vec4 v_TexCoord2;\n");
-        if (key.unitTexCoordEnabled(3))       sb.append("out vec4 v_TexCoord3;\n");
-        if (key.fogEnabled()) {
-            sb.append("out float v_FogCoord;\n");
-        }
-        if (key.lineStipple()) {
-            sb.append("flat out vec2 v_LineStart;\n");
-        }
-        sb.append('\n');
-
-        sb.append("void main() {\n");
-        sb.append("    vec4 c0 = gl_in[0].gl_Position;\n");
-        sb.append("    vec4 c1 = gl_in[1].gl_Position;\n\n");
-
-        sb.append("    // NDC positions\n");
-        sb.append("    vec2 n0 = c0.xy / c0.w;\n");
-        sb.append("    vec2 n1 = c1.xy / c1.w;\n\n");
-
-        sb.append("    // Screen-space direction and perpendicular\n");
-        sb.append("    vec2 dir = normalize((n1 - n0) * u_ViewportSize);\n");
-        sb.append("    vec2 offset = vec2(-dir.y, dir.x) * u_LineWidth / u_ViewportSize;\n\n");
-
-        emitVertex(sb, key, 0, "+offset");
-        emitVertex(sb, key, 0, "-offset");
-        emitVertex(sb, key, 1, "+offset");
-        emitVertex(sb, key, 1, "-offset");
-
-        sb.append("    EndPrimitive();\n");
-        sb.append("}\n");
-
-        return sb.toString();
-    }
-
-    private static void emitVertex(StringBuilder sb, VertexKey key, int endpointIdx, String offsetExpr) {
-        final String ci = "c" + endpointIdx;
-        final String ni = "n" + endpointIdx;
-        final String idx = "[" + endpointIdx + "]";
-
-        sb.append("    // Endpoint ").append(endpointIdx).append(' ').append(offsetExpr).append('\n');
-
-        sb.append("    v_Color = v_Color_gs").append(idx).append(";\n");
-        if (key.separateSpecular()) {
-            sb.append("    v_SpecularColor = v_SpecularColor_gs").append(idx).append(";\n");
-        }
-        if (key.unitTexCoordEnabled(0) || key.texGenEnabled()) sb.append("    v_TexCoord0 = v_TexCoord0_gs").append(idx).append(";\n");
-        if (key.lightmapEnabled())            sb.append("    v_TexCoord1 = v_TexCoord1_gs").append(idx).append(";\n");
-        if (key.unitTexCoordEnabled(2))       sb.append("    v_TexCoord2 = v_TexCoord2_gs").append(idx).append(";\n");
-        if (key.unitTexCoordEnabled(3))       sb.append("    v_TexCoord3 = v_TexCoord3_gs").append(idx).append(";\n");
-        if (key.fogEnabled()) {
-            sb.append("    v_FogCoord = v_FogCoord_gs").append(idx).append(";\n");
-        }
-        if (key.lineStipple()) {
-            sb.append("    v_LineStart = v_LineStart_gs[0];\n");
-        }
-
-        if (key.clipPlanesEnabled()) {
-            for (int i = 0; i < 8; i++) {
-                sb.append("    gl_ClipDistance[").append(i).append("] = gl_in").append(idx).append(".gl_ClipDistance[").append(i).append("];\n");
-            }
-        }
-
-        sb.append("    gl_Position = vec4((").append(ni).append(' ').append(offsetExpr).append(") * ").append(ci).append(".w, ").append(ci).append(".z, ").append(ci).append(".w);\n");
-        sb.append("    EmitVertex();\n\n");
-    }
-}
@@ -25,6 +25,8 @@ public final class InstancedAttribs {
    public static final int OFFSET_LIGHTMAP = HEAD_SIZE;
    public static final int STRIDE = 72;

+    public static final long DEFAULT_ENTITY_IDS = packEntityInfo(-1, 0, -1);
+
    public static void writeHead(long ptr, float[] colMajor, int off, int colorABGR, int overlayABGR, long entityInfo) {
        writeRows(ptr, colMajor, off);
        writeTail(ptr, colorABGR, overlayABGR, entityInfo);
@@ -60,13 +62,21 @@ public final class InstancedAttribs {
        return id == 0xFFFF ? -1 : id;
    }

+    public static float normalizedId(long info, int shift) {
+        return ((info >>> shift) & 0xFFFF) / 65535.0f;
+    }
+
    public static void pointHead(long base, int stride) {
        for (int r = 0; r < 3; r++) {
            GLStateManager.glVertexAttribPointer(LOC_ROW0 + r, 4, GL11.GL_FLOAT, false, stride, base + OFFSET_ROWS + r * 16L);
        }
        GLStateManager.glVertexAttribPointer(LOC_COLOR, 4, GL11.GL_UNSIGNED_BYTE, true, stride, base + OFFSET_COLOR);
        GLStateManager.glVertexAttribPointer(LOC_OVERLAY, 4, GL11.GL_UNSIGNED_BYTE, true, stride, base + OFFSET_OVERLAY);
-        GLStateManager.glVertexAttribIPointer(LOC_ENTITY, 4, GL11.GL_UNSIGNED_SHORT, stride, base + OFFSET_ENTITY);
+        pointEntityIds(LOC_ENTITY, stride, base + OFFSET_ENTITY);
+    }
+
+    public static void pointEntityIds(int location, int stride, long offset) {
+        GLStateManager.glVertexAttribPointer(location, 4, GL11.GL_UNSIGNED_SHORT, true, stride, offset);
    }

    public static void pointTemplate(long base) {
@@ -23,7 +23,7 @@ import java.util.concurrent.atomic.AtomicInteger;
 import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;

 /**
- * A compiled and linked FFP emulation program (vertex + fragment + optional geometry shaders). Owns the GL program handle and caches uniform locations.
+ * A compiled and linked FFP emulation program (vertex + fragment shaders). Owns the GL program handle and caches uniform locations.
 */
 public class Program {

@@ -49,23 +49,19 @@ public class Program {
    }

    /**
-     * Compile vertex + fragment + optional geometry shaders, link into a program, and return the FFPProgram.
+     * Compile vertex + fragment shaders, link into a program, and return the FFPProgram.
     */
-    static Program create(VertexKey vk, FragmentKey fk, String vertSrc, String fragSrc, String geomSrc) {
+    static Program create(VertexKey vk, FragmentKey fk, String vertSrc, String fragSrc) {
        final RenderBackend backend = RENDER_BACKEND;
        final int id = PROGRAM_COUNTER.getAndIncrement();
        final String vkHex = Long.toHexString(vk.pack());
-        final boolean hasGeom = geomSrc != null;

        int shaderCount = 0;
-        final int[] shaders = new int[5]; // vertex, fragment, geometry, tess control, tess evaluation
+        final int[] shaders = new int[2];
        int program = 0;
        try {
            shaders[shaderCount++] = compileShader(GL20.GL_VERTEX_SHADER, vertSrc, "ffp_v_" + vkHex);
            shaders[shaderCount++] = compileShader(GL20.GL_FRAGMENT_SHADER, fragSrc, "ffp_f_" + id);
-            if (geomSrc != null) {
-                shaders[shaderCount++] = compileShader(GL32.GL_GEOMETRY_SHADER, geomSrc, "ffp_g_" + id);
-            }

            program = backend.createProgram();
            for (int i = 0; i < shaderCount; i++) backend.attachShader(program, shaders[i]);
@@ -80,7 +76,7 @@ public class Program {
                throw new RuntimeException("FFP shader link failed (vk=0x" + vkHex + ", fk=" + fk + "): " + log);
            }

-            final String debugName = "FFP(v=0x" + vkHex + ",f=" + id + (hasGeom ? ",g" : "") + ")";
+            final String debugName = "FFP(v=0x" + vkHex + ",f=" + id + ")";
            GLDebug.nameObject(KHRDebug.GL_PROGRAM, program, debugName);

            // Detach and delete individual shaders - they're linked into the program
@@ -32,7 +32,6 @@ public class ShaderCache {
    private static final long EMPTY_MARKER = 0L; // slot [1] == 0 means empty (fkLen >= 1 guarantees nonzero)

    private final Long2ObjectOpenHashMap<String> vertexSourceCache = new Long2ObjectOpenHashMap<>();
-    private final Long2ObjectOpenHashMap<String> geometrySourceCache = new Long2ObjectOpenHashMap<>();

    // Open-addressed table — parallel arrays
    private long[] keys;
@@ -103,7 +102,6 @@ public class ShaderCache {
        final FragmentKey fk = FragmentKey.fromPacked(fkPacked, fkLen);
        final String vertSrc;
        String fragSrc;
-        final String geomSrc;
        final Program program;
        if (Tracy.ENABLED) Tracy.beginZone(Z_FFP_SHADER_GEN);
        try {
@@ -113,8 +111,7 @@ public class ShaderCache {
                fragSrc = FragmentShaderGenerator.generate(fk);
                uniqueFragCount++;
            }
-            geomSrc = vk.wideLineEmulation() ? getOrGenerateGeometry(vk) : null;
-            program = Program.create(vk, fk, vertSrc, fragSrc, geomSrc);
+            program = Program.create(vk, fk, vertSrc, fragSrc);
        } finally {
            if (Tracy.ENABLED) Tracy.endZone();
        }
@@ -135,9 +132,6 @@ public class ShaderCache {
        if (dumpDir != null) {
            dumpShader(Long.toHexString(vkPacked), ".vert.glsl", vertSrc);
            dumpShader("frag_" + fragmentDumpCounter++, ".frag.glsl", fragSrc);
-            if (geomSrc != null) {
-                dumpShader(Long.toHexString(vkPacked), ".geom.glsl", geomSrc);
-            }
        }

        return program;
@@ -228,10 +222,6 @@ public class ShaderCache {
        return vertexSourceCache.computeIfAbsent(vk.pack(), k -> VertexShaderGenerator.generate(vk));
    }

-    private String getOrGenerateGeometry(VertexKey vk) {
-        return geometrySourceCache.computeIfAbsent(vk.pack(), k -> GeometryShaderGenerator.generate(vk));
-    }
-
    private void dumpShader(String name, String suffix, String source) {
        if (dumpDir == null) return;
        try {
@@ -260,11 +250,8 @@ public class ShaderCache {
                    dumpShader("frag_" + idx, ".frag.glsl", fragSources[i]);
                }
            }
-            for (var entry : geometrySourceCache.entrySet()) {
-                dumpShader(Long.toHexString(entry.getKey()), ".geom.glsl", entry.getValue());
-            }
-            GLStateManager.LOGGER.info("Dumped {} vertex, {} geometry, and {} fragment FFP shader sources to {}",
-                vertexSourceCache.size(), geometrySourceCache.size(), seen.size(), outputDir);
+            GLStateManager.LOGGER.info("Dumped {} vertex and {} fragment FFP shader sources to {}",
+                vertexSourceCache.size(), seen.size(), outputDir);
        } catch (IOException e) {
            GLStateManager.LOGGER.warn("Failed to dump FFP shaders: {}", e.getMessage());
        }
@@ -100,7 +100,6 @@ public final class ShaderManager {
            VertexShaderGenerator.generate(VertexKey.fromPacked(VertexKey.withInstancing(vkPacked, Instancing.CUBE)));
            VertexShaderGenerator.generate(VertexKey.fromPacked(VertexKey.withInstancing(vkPacked, Instancing.PARTICLE)));
            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();
@@ -140,6 +139,7 @@ public final class ShaderManager {
        GLSMHooks.resolvePendingProgram();
        final DeferredBlendHandler bh = GLSMHooks.blendHandler;
        if (bh != null) bh.flushDeferredBlend();
+        GLStateManager.flushEntityIds(glCtx);

        // Handle FFP & Iris uniforms
        final int currentProgramId = glCtx.activeProgram;
@@ -80,9 +80,6 @@ public class Uniforms {
    private final Vector3f tempVec3 = new Vector3f();
    private final FloatBuffer clipPlaneBuf = memAllocFloat(32); // 8 planes * vec4

-    private static final double LN2 = java.lang.Math.log(2.0);
-    private static final double SQRT_LN2 = java.lang.Math.sqrt(LN2);
-
    public void upload(GLContextState glCtx) {
        boolean dirty = false;
        contentChanged = false;
@@ -233,8 +230,11 @@ public class Uniforms {
        if (projChanged) {
            putMat4(FFPUniformBlock.PROJECTION_MATRIX, proj);
        }
-        proj.mul(mv, mvpMatrix);
-        putMat4(FFPUniformBlock.MVP_MATRIX, mvpMatrix);
+        putMat4(FFPUniformBlock.MVP_MATRIX, modelViewProjection(proj, mv, mvpMatrix));
+    }
+
+    public static Matrix4f modelViewProjection(Matrix4f proj, Matrix4f mv, Matrix4f dest) {
+        return proj.mul(mv, dest);
    }

    private void stageNormalMatrix(GLContextState glCtx) {
@@ -343,17 +343,8 @@ public class Uniforms {
        final var secondary = glCtx.secondaryColor;
        putVec3(FFPUniformBlock.SECONDARY_COLOR, secondary.getRed(), secondary.getGreen(), secondary.getBlue());

-        // Mesa STATE_FOG_PARAMS_OPTIMIZED
        final FogState fog = glCtx.fogState;
-        final float start = fog.getStart();
-        final float end = fog.getEnd();
-        final float density = fog.getDensity();
-        final float range = end - start;
-        putVec4(FFPUniformBlock.FOG_PARAMS,
-            range != 0.0f ? -1.0f / range : 0.0f,
-            range != 0.0f ? end / range : 1.0f,
-            (float) (density / LN2),
-            (float) (density / SQRT_LN2));
+        putVec4(FFPUniformBlock.FOG_PARAMS, fog.linearScale(), fog.linearBias(), fog.expScale(), fog.exp2Scale());
        putVec4(FFPUniformBlock.FOG_COLOR,
            (float) fog.getFogColor().x, (float) fog.getFogColor().y, (float) fog.getFogColor().z,
            fog.getFogAlpha());
@@ -420,6 +411,7 @@ public class Uniforms {
        if (ring != null) {
            ring.endFrame();
        }
+        invalidateBinding();
        lastFrameBlockWrites = blockWrites;
        lastFrameBlockSkips = blockSkips;
        lastFrameStagedMatrices = stagedMatrices;
@@ -1,13 +1,20 @@
 package com.gtnewhorizons.angelica.glsm.ffp;

+import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement.Usage;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.GLTypes;
+import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
 import org.lwjgl.opengl.GL15;
+import org.lwjgl.opengl.GL30;
+import org.lwjgl.opengl.GL33;
+import org.lwjgl.opengl.GL41;

 import javax.annotation.Nullable;
 import java.nio.ByteBuffer;
+import java.util.Arrays;

 import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;

@@ -19,12 +26,116 @@ public final class VAOManager {
    final Int2ObjectOpenHashMap<VAOData> eboOwners = new Int2ObjectOpenHashMap<>();

    private VAOData current = null;
+    public static final int CONV_POSITION = 0;
+    public static final int CONV_NORMAL = 1;
+    public static final int CONV_COLOR = 2;
+    public static final int CONV_SECONDARY_COLOR = 3;
+    public static final int CONV_FOG_COORD = 4;
+    public static final int CONV_INDEX = 5;
+    public static final int CONV_EDGE_FLAG = 6;
+    public static final int CONV_TEX0 = 7;
+    public static final int TEX_COORD_UNITS = 8;
+    public static final int CONV_COUNT = CONV_TEX0 + TEX_COORD_UNITS;
+
+    private static final int[] CONV_LOCATION = new int[CONV_COUNT];
+    private static final int[] LOCATION_CONV = new int[MAX_ATTRIBS];
+    static {
+        Arrays.fill(CONV_LOCATION, -1);
+        Arrays.fill(LOCATION_CONV, -1);
+        mapConventional(CONV_POSITION, Usage.POSITION);
+        mapConventional(CONV_NORMAL, Usage.NORMAL);
+        mapConventional(CONV_COLOR, Usage.COLOR);
+        mapConventional(CONV_TEX0, Usage.PRIMARY_UV);
+        mapConventional(CONV_TEX0 + 1, Usage.SECONDARY_UV);
+    }
+
+    private static void mapConventional(int conv, Usage usage) {
+        final int location = usage.getAttributeLocation();
+        CONV_LOCATION[conv] = location;
+        LOCATION_CONV[location] = conv;
+    }
+
+    public static int conventionalLocation(int conv) {
+        return CONV_LOCATION[conv];
+    }
+
+    private static final int T_BYTE = 1, T_UBYTE = 1 << 1, T_SHORT = 1 << 2, T_USHORT = 1 << 3, T_INT = 1 << 4, T_UINT = 1 << 5, T_FLOAT = 1 << 6;
+    private static final int T_DOUBLE = 1 << 10, T_HALF = 1 << 11, T_FIXED = 1 << 12, T_PACKED = 1 << 13, T_PACKED_FLOAT = 1 << 14;
+    private static final int T_INTEGER = T_BYTE | T_UBYTE | T_SHORT | T_USHORT | T_INT | T_UINT;
+    private static final int T_COLOR = T_INTEGER | T_HALF | T_FLOAT | T_DOUBLE | T_PACKED;
+    private static final int T_GENERIC = T_COLOR | T_FIXED | T_PACKED_FLOAT;
+    private static final int[] LEGAL_TYPES = new int[CONV_COUNT];
+    private static final int[] MIN_SIZE = new int[CONV_COUNT];
+    private static final int[] MAX_SIZE = new int[CONV_COUNT];
+    static {
+        legal(CONV_POSITION, T_SHORT | T_INT | T_FLOAT | T_DOUBLE | T_HALF | T_PACKED, 2, 4);
+        legal(CONV_NORMAL, T_BYTE | T_SHORT | T_INT | T_HALF | T_FLOAT | T_DOUBLE | T_PACKED, 3, 3);
+        legal(CONV_COLOR, T_COLOR, 3, 4);
+        legal(CONV_SECONDARY_COLOR, T_COLOR, 3, 4);
+        legal(CONV_FOG_COORD, T_HALF | T_FLOAT | T_DOUBLE, 1, 1);
+        legal(CONV_INDEX, T_UBYTE | T_SHORT | T_INT | T_FLOAT | T_DOUBLE, 1, 1);
+        legal(CONV_EDGE_FLAG, T_UBYTE, 1, 1);
+        for (int unit = 0; unit < TEX_COORD_UNITS; unit++) {
+            legal(CONV_TEX0 + unit, T_SHORT | T_INT | T_HALF | T_FLOAT | T_DOUBLE | T_PACKED, 1, 4);
+        }
+    }
+
+    private static void legal(int conv, int types, int minSize, int maxSize) {
+        LEGAL_TYPES[conv] = types;
+        MIN_SIZE[conv] = minSize;
+        MAX_SIZE[conv] = maxSize;
+    }
+
+    private static int typeBit(int type) {
+        if (type >= GL11.GL_BYTE && type <= GL30.GL_HALF_FLOAT) return 1 << type - GL11.GL_BYTE;
+        return switch (type) {
+            case GL41.GL_FIXED -> T_FIXED;
+            case GL12.GL_UNSIGNED_INT_2_10_10_10_REV, GL33.GL_INT_2_10_10_10_REV -> T_PACKED;
+            case GL30.GL_UNSIGNED_INT_10F_11F_11F_REV -> T_PACKED_FLOAT;
+            default -> 0;
+        };
+    }
+
+    private static boolean isLegal(int types, int minSize, int maxSize, boolean bgra, int size, int type) {
+        final int bit = typeBit(type);
+        if ((types & bit) == 0) return false;
+        if (size == GL12.GL_BGRA) return bgra && (bit & (T_UBYTE | T_PACKED)) != 0;
+        return size >= minSize && size <= maxSize;
+    }
+
+    public static boolean isLegalConventional(int conv, int size, int type) {
+        return isLegal(LEGAL_TYPES[conv], MIN_SIZE[conv], MAX_SIZE[conv], conv == CONV_COLOR || conv == CONV_SECONDARY_COLOR, size, type);
+    }
+
+    public static boolean isLegalGeneric(int index, int size, int type, boolean integer) {
+        return index >= 0 && index < MAX_ATTRIBS && isLegal(integer ? T_INTEGER : T_GENERIC, 1, 4, !integer, size, type);
+    }
+
    private int currentVertexFlags = 0;
+    private int genericEnabled = 0;
+    private int conventionalEnabled = 0;
    private Attrib[] currentAttribs = null;
+    private Attrib[] currentGeneric = null;
+    private Attrib[] currentConventional = null;
    public int boundEBO = 0;

    private int clientSideEnabledCount = 0;
+    private int arrayVersion = 0;
+    private int versionClock = 0;
+    private int bufferEpoch = 0;
+    private final Int2IntOpenHashMap bufferDeletedAt = new Int2IntOpenHashMap();

+    private void touch() {
+        arrayVersion = ++versionClock;
+    }
+
+    private boolean isBufferLive(int buffer, int sinceEpoch) {
+        return bufferDeletedAt.get(buffer) <= sinceEpoch;
+    }
+
+    public boolean isBufferLive(Attrib a) {
+        return isBufferLive(a.vboId, a.epoch);
+    }

    public void init(int defaultVAO) {
        final VAOData data = new VAOData();
@@ -45,6 +156,10 @@ public final class VAOManager {
        // Save old VAO data
        if (current != null) {
            current.vertexFlags = currentVertexFlags;
+            current.genericEnabled = genericEnabled;
+            current.conventionalEnabled = conventionalEnabled;
+            current.generic = currentGeneric;
+            current.conventional = currentConventional;
            if (current.ebo != boundEBO) {
                removeEboOwner(current.ebo, current);
                current.ebo = boundEBO;
@@ -52,6 +167,7 @@ public final class VAOManager {
            }
            current.attribs = currentAttribs;
            current.clientSideEnabledCount = clientSideEnabledCount;
+            current.arrayVersion = arrayVersion;
        }

        VAOData data = vaoMap.get(vaoId);
@@ -61,9 +177,14 @@ public final class VAOManager {
        }
        current = data;
        currentVertexFlags = data.vertexFlags;
+        genericEnabled = data.genericEnabled;
+        conventionalEnabled = data.conventionalEnabled;
        currentAttribs = data.attribs;
+        currentGeneric = data.generic;
+        currentConventional = data.conventional;
        boundEBO = data.ebo;
        clientSideEnabledCount = data.clientSideEnabledCount;
+        arrayVersion = data.arrayVersion;
    }

    public void onDeleteVertexArray(int vaoId) {
@@ -73,8 +194,25 @@ public final class VAOManager {
        if (data == current) current = null;
    }

+    private static boolean detach(Attrib[] slots, int buffer) {
+        boolean detached = false;
+        for (final Attrib a : slots) {
+            if (a != null && a.vboId == buffer) {
+                a.vboId = 0;
+                detached = true;
+            }
+        }
+        return detached;
+    }
+
    public void onDeleteBuffer(int buffer) {
        if (buffer == 0) return;
+        bufferDeletedAt.put(buffer, ++bufferEpoch);
+        if (currentAttribs != null) {
+            boolean detached = detach(currentGeneric != null ? currentGeneric : currentAttribs, buffer);
+            if (currentConventional != null) detached |= detach(currentConventional, buffer);
+            if (detached) touch();
+        }
        VAOData owner = eboOwners.remove(buffer);
        while (owner != null) {
            final VAOData next = owner.nextEboOwner;
@@ -112,14 +250,19 @@ public final class VAOManager {
    public void enableClientVertexFlag(int flag) { currentVertexFlags |= flag; }
    public void disableClientVertexFlag(int flag) { currentVertexFlags &= ~flag; }
    public int getVertexFlags() { return currentVertexFlags; }
-    public void setVertexFlags(int flags) { currentVertexFlags = flags; }
+    public boolean isConventionalEnabled(int conv) { return (conventionalEnabled >> conv & 1) != 0; }
    public static void setCurrentVertexFlags(int flags) { GLStateManager.ctx().vaos.currentVertexFlags = flags; }

    public static final class VAOData {
        public Attrib[] attribs;
        public int vertexFlags;
+        public int genericEnabled;
+        public int conventionalEnabled;
+        public Attrib[] generic;
+        public Attrib[] conventional;
        public int ebo;
        public int clientSideEnabledCount;
+        int arrayVersion;
        private VAOData nextEboOwner;

        public VAOData() {
@@ -127,92 +270,307 @@ public final class VAOManager {
        }
    }

-    public 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;
+    public boolean setAttribute(int index, int size, int type, boolean normalized, int stride, long offset, int vboId) {
+        return setGeneric(index, size, type, normalized, false, stride, offset, vboId, null);
+    }
+
+    public boolean setAttribute(int index, int size, int type, boolean normalized, int stride, ByteBuffer pointer) {
+        return setGeneric(index, size, type, normalized, false, stride, 0, 0, pointer);
+    }
+
+    public boolean setIntegerAttribute(int index, int size, int type, int stride, long offset, int vboId) {
+        return setGeneric(index, size, type, false, true, stride, offset, vboId, null);
+    }
+
+    public boolean setIntegerAttribute(int index, int size, int type, int stride, ByteBuffer pointer) {
+        return setGeneric(index, size, type, false, true, stride, 0, 0, pointer);
+    }
+
+    public boolean setConventional(int conv, int size, int type, boolean normalized, int stride, long offset, int vboId) {
+        return setConventional(conv, size, type, normalized, stride, offset, vboId, null);
+    }
+
+    public boolean setConventional(int conv, int size, int type, boolean normalized, int stride, ByteBuffer pointer) {
+        return setConventional(conv, size, type, normalized, stride, 0, 0, pointer);
+    }
+
+    private boolean setGeneric(int index, int size, int type, boolean normalized, boolean integer, int stride, long offset, int vboId, ByteBuffer pointer) {
+        if (index < 0 || index >= MAX_ATTRIBS) return false;
+        final Attrib g = genericSlot(index);
+        store(g, size, type, normalized, integer, stride, offset, vboId, pointer);
+        if (currentAttribs[index] == g) return true;
+        if (!isGenericEnabled(index) && isLocationConventionalEnabled(index)) return false;
+        apply(index, g);
+        return true;
+    }
+
+    private boolean setConventional(int conv, int size, int type, boolean normalized, int stride, long offset, int vboId, ByteBuffer pointer) {
+        if (conv < 0 || conv >= CONV_COUNT) return false;
+        final Attrib c = conventionalSlot(conv);
+        store(c, size, type, normalized, false, stride, offset, vboId, pointer);
+        final int index = CONV_LOCATION[conv];
+        if (index < 0) return false;
+        if (currentAttribs[index] == c) return true;
+        if (isGenericEnabled(index)) return false;
+        apply(index, c);
+        return true;
+    }
+
+    private void store(Attrib a, int size, int type, boolean normalized, boolean integer, int stride, long offset, int vboId, ByteBuffer pointer) {
+        final boolean wasClient = a.isClientSide();
        a.size = size;
        a.type = type;
        a.normalized = normalized;
+        a.integer = integer;
        a.stride = stride;
        a.offset = offset;
        a.vboId = vboId;
-        a.clientPointer = null;
-        a.genericPointer = true;
-        if (wasClient && a.enabled) {
-            clientSideEnabledCount--;
-        }
-    }
-
-    public 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.epoch = bufferEpoch;
        a.clientPointer = pointer;
-        a.genericPointer = true;
-        if (!wasClient && a.enabled) {
-            clientSideEnabledCount++;
+        if (wasClient != a.isClientSide()) clientSideEnabledCount += wasClient ? -1 : 1;
+        touch();
+    }
+
+    private void apply(int index, Attrib source) {
+        final Attrib old = currentAttribs[index];
+        if (old != null) {
+            if (old.isClientSide()) clientSideEnabledCount--;
+            source.enabled = old.enabled;
+            old.enabled = false;
+            if (source.isClientSide()) clientSideEnabledCount++;
+        }
+        currentAttribs[index] = source;
+    }
+
+    private boolean isGenericEnabled(int index) {
+        return (genericEnabled >> index & 1) != 0;
+    }
+
+    private boolean isLocationConventionalEnabled(int index) {
+        final int conv = LOCATION_CONV[index];
+        return conv >= 0 && isConventionalEnabled(conv);
+    }
+
+    private Attrib generic(int index) {
+        return (currentGeneric != null ? currentGeneric : currentAttribs)[index];
+    }
+
+    private Attrib genericSlot(int index) {
+        final Attrib[] slots = currentGeneric != null ? currentGeneric : currentAttribs;
+        Attrib g = slots[index];
+        if (g == null) {
+            g = new Attrib();
+            g.genericPointer = true;
+            slots[index] = g;
+            if (currentAttribs[index] == null) currentAttribs[index] = g;
+        }
+        return g;
+    }
+
+    private Attrib conventionalSlot(int conv) {
+        if (currentConventional == null) {
+            currentConventional = new Attrib[CONV_COUNT];
+            currentGeneric = currentAttribs.clone();
+        }
+        Attrib c = currentConventional[conv];
+        if (c == null) {
+            c = new Attrib();
+            currentConventional[conv] = c;
+        }
+        return c;
+    }
+
+    private boolean refresh(int index) {
+        touch();
+        boolean repoint = false;
+        final boolean conventional = isLocationConventionalEnabled(index);
+        final Attrib winner = isGenericEnabled(index) ? genericSlot(index) : conventional ? currentConventional[LOCATION_CONV[index]] : null;
+        if (winner != null && winner != currentAttribs[index]) {
+            apply(index, winner);
+            repoint = true;
+        }
+        final boolean enabled = winner != null;
+        Attrib e = currentAttribs[index];
+        if (e == null) {
+            if (!enabled) return repoint;
+            e = genericSlot(index);
+        }
+        if (e.enabled != enabled) {
+            if (e.clientPointer != null) clientSideEnabledCount += enabled ? 1 : -1;
+            e.enabled = enabled;
+        }
+        return repoint;
+    }
+
+    public boolean enableAttribute(int index) {
+        if (index < 0 || index >= MAX_ATTRIBS) return false;
+        genericEnabled |= 1 << index;
+        return refresh(index);
+    }
+
+    public boolean disableAttribute(int index) {
+        if (index < 0 || index >= MAX_ATTRIBS) return false;
+        genericEnabled &= ~(1 << index);
+        return refresh(index);
+    }
+
+    public boolean setConventionalEnabled(int conv, boolean enabled) {
+        if (conv < 0 || conv >= CONV_COUNT) return false;
+        conventionalSlot(conv);
+        if (enabled) {
+            conventionalEnabled |= 1 << conv;
+        } else {
+            conventionalEnabled &= ~(1 << conv);
+        }
+        final int index = CONV_LOCATION[conv];
+        if (index >= 0) return refresh(index);
+        touch();
+        return false;
+    }
+
+    public boolean setDivisor(int index, int divisor) {
+        if (index < 0 || index >= MAX_ATTRIBS) return true;
+        final Attrib g = genericSlot(index);
+        g.divisor = divisor;
+        touch();
+        return currentAttribs[index] == g;
+    }
+
+    public @Nullable Attrib conventional(int conv) {
+        return conv >= 0 && currentConventional != null ? currentConventional[conv] : null;
+    }
+
+    public static final class ClientArrays {
+        public int boundVAO;
+        public int boundVBO;
+        public int boundEBO;
+        public int clientActiveTextureUnit;
+        int arrayVersion;
+        int bufferEpoch;
+        int vertexFlags;
+        int genericEnabled;
+        int conventionalEnabled;
+        int genericPresent;
+        int conventionalPresent;
+        int effectiveGeneric;
+        final Attrib[] generic = new Attrib[MAX_ATTRIBS];
+        final Attrib[] conventional = new Attrib[CONV_COUNT];
+    }
+
+    private static void saveSlot(Attrib[] saved, int i, Attrib source) {
+        if (saved[i] == null) saved[i] = new Attrib();
+        saved[i].copyPointer(source);
+    }
+
+    public boolean isBufferLive(int buffer, ClientArrays saved) {
+        return isBufferLive(buffer, saved.bufferEpoch);
+    }
+
+    public void saveClientArrays(ClientArrays out) {
+        out.arrayVersion = arrayVersion;
+        out.bufferEpoch = bufferEpoch;
+        out.vertexFlags = currentVertexFlags;
+        out.genericEnabled = genericEnabled;
+        out.conventionalEnabled = conventionalEnabled;
+        out.genericPresent = 0;
+        out.conventionalPresent = 0;
+        out.effectiveGeneric = 0;
+        for (int i = 0; i < MAX_ATTRIBS; i++) {
+            final Attrib g = generic(i);
+            if (g != null) {
+                out.genericPresent |= 1 << i;
+                saveSlot(out.generic, i, g);
+            }
+            final Attrib e = currentAttribs[i];
+            if (e != null && e.genericPointer) out.effectiveGeneric |= 1 << i;
+        }
+        if (currentConventional == null) return;
+        for (int i = 0; i < CONV_COUNT; i++) {
+            final Attrib c = currentConventional[i];
+            if (c != null) {
+                out.conventionalPresent |= 1 << i;
+                saveSlot(out.conventional, i, c);
+            }
        }
    }

-    public boolean isGenericPointerEnabled(int index) {
+    private final Attrib[] restoreBefore = new Attrib[MAX_ATTRIBS];
+
+    public int restoreClientArrays(ClientArrays in) {
+        currentVertexFlags = in.vertexFlags;
+        if (arrayVersion == in.arrayVersion) return 0;
+        for (int i = 0; i < MAX_ATTRIBS; i++) {
+            if (restoreBefore[i] == null) restoreBefore[i] = new Attrib();
+            final Attrib e = currentAttribs[i];
+            if (e == null) {
+                restoreBefore[i].clearPointer();
+                restoreBefore[i].enabled = false;
+            } else {
+                restoreBefore[i].copyPointer(e);
+                restoreBefore[i].enabled = e.enabled;
+            }
+        }
+        genericEnabled = in.genericEnabled;
+        conventionalEnabled = in.conventionalEnabled;
+        for (int i = 0; i < MAX_ATTRIBS; i++) {
+            if ((in.genericPresent >> i & 1) != 0) {
+                genericSlot(i).copyPointer(in.generic[i]);
+            } else {
+                final Attrib g = generic(i);
+                if (g != null) g.clearPointer();
+            }
+        }
+        if (currentConventional != null || in.conventionalPresent != 0) {
+            for (int i = 0; i < CONV_COUNT; i++) {
+                if ((in.conventionalPresent >> i & 1) != 0) {
+                    conventionalSlot(i).copyPointer(in.conventional[i]);
+                } else if (currentConventional != null && currentConventional[i] != null) {
+                    currentConventional[i].clearPointer();
+                }
+            }
+        }
+        clientSideEnabledCount = 0;
+        for (int i = 0; i < MAX_ATTRIBS; i++) {
+            final int conv = LOCATION_CONV[i];
+            final Attrib g = generic(i);
+            final Attrib c = conventional(conv);
+            final boolean conventional = isLocationConventionalEnabled(i);
+            Attrib e;
+            if (isGenericEnabled(i)) {
+                e = genericSlot(i);
+            } else if (conventional) {
+                e = conventionalSlot(conv);
+            } else {
+                e = c == null || (in.effectiveGeneric >> i & 1) != 0 ? g : c;
+            }
+            if (g != null) g.enabled = false;
+            if (c != null) c.enabled = false;
+            currentAttribs[i] = e;
+            if (e != null) {
+                e.enabled = isGenericEnabled(i) || conventional;
+                if (e.isClientSide()) clientSideEnabledCount++;
+            }
+        }
+        int changed = 0;
+        for (int i = 0; i < MAX_ATTRIBS; i++) {
+            final Attrib e = currentAttribs[i];
+            final Attrib before = restoreBefore[i];
+            if (e == null) {
+                if (before.enabled) changed |= 0x10000 << i;
+            } else {
+                if (e.enabled != before.enabled) changed |= 0x10000 << i;
+                if (!e.samePointer(before)) changed |= 1 << i;
+            }
+            before.clientPointer = null;
+        }
+        arrayVersion = in.arrayVersion;
+        return changed;
+    }
+
+    public boolean isAttribEnabled(int index) {
        if (index < 0 || index >= MAX_ATTRIBS) return false;
        final Attrib a = currentAttribs[index];
-        return a != null && a.genericPointer && a.enabled;
-    }
-
-    public void markConventional(int index) {
-        if (index < 0 || index >= MAX_ATTRIBS) return;
-        final Attrib a = currentAttribs[index];
-        if (a != null) a.genericPointer = false;
-    }
-
-    public 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 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 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 Attrib getAttrib(int index) {
-        Attrib a = currentAttribs[index];
-        if (a == null) {
-            a = new Attrib();
-            currentAttribs[index] = a;
-        }
-        return a;
-    }
-
-    public boolean isClientSideAttrib(int index) {
-        final Attrib attrib = currentAttribs[index];
-        return attrib != null && attrib.isClientSide();
+        return a != null && a.enabled;
    }

    public Attrib attrib(int index) {
@@ -286,7 +644,11 @@ public final class VAOManager {
            if (clientArraysVBOOffsets[i] < 0) continue;
            final VAOManager.Attrib a = currentAttribs[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]);
+            if (a.integer) {
+                RENDER_BACKEND.vertexAttribIPointer(i, a.size, a.type, a.stride, (long) clientArraysVBOOffsets[i]);
+            } else {
+                RENDER_BACKEND.vertexAttribPointer(i, a.size, a.type, a.normalized, a.stride, (long) clientArraysVBOOffsets[i]);
+            }
        }

        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, savedVBO);
@@ -298,9 +660,12 @@ public final class VAOManager {
        public int size;
        public int type;
        public boolean normalized;
+        public boolean integer;
        public int stride;
        public long offset;
        public int vboId;
+        public int divisor;
+        int epoch;
        public ByteBuffer clientPointer;
        public boolean genericPointer;

@@ -308,16 +673,35 @@ public final class VAOManager {
            return enabled && clientPointer != null;
        }

-        public void reset() {
-            enabled = false;
+        void copyPointer(Attrib source) {
+            size = source.size;
+            type = source.type;
+            normalized = source.normalized;
+            integer = source.integer;
+            stride = source.stride;
+            offset = source.offset;
+            vboId = source.vboId;
+            divisor = source.divisor;
+            epoch = source.epoch;
+            clientPointer = source.clientPointer;
+        }
+
+        boolean samePointer(Attrib other) {
+            return size == other.size && type == other.type && normalized == other.normalized && integer == other.integer
+                && stride == other.stride && offset == other.offset && vboId == other.vboId && divisor == other.divisor
+                && clientPointer == other.clientPointer;
+        }
+
+        void clearPointer() {
            size = 0;
            type = 0;
            normalized = false;
+            integer = false;
            stride = 0;
            offset = 0;
            vboId = 0;
+            divisor = 0;
            clientPointer = null;
-            genericPointer = false;
        }

        public int effectiveStride() {
@@ -46,8 +46,8 @@ public final class VertexKey {
    private static final int BIT_TEXGEN_R            = BIT_TEXGEN_T + 3;
    private static final int BIT_TEXGEN_Q            = BIT_TEXGEN_R + 3;
    private static final int BIT_CLIP_PLANES         = BIT_TEXGEN_Q + 3;
-    private static final int BIT_WIDE_LINE           = BIT_CLIP_PLANES + 1;
-    private static final int BIT_UNIT_TEXMAT_BASE    = BIT_WIDE_LINE + 1;
+    private static final int BIT_LINE_QUADS          = BIT_CLIP_PLANES + 1;
+    private static final int BIT_UNIT_TEXMAT_BASE    = BIT_LINE_QUADS + 1;
    private static final int BIT_UNIT23_UV_FROM_UNIT0 = BIT_UNIT_TEXMAT_BASE + MAX_UNITS;
    private static final int BIT_LINE_STIPPLE        = BIT_UNIT23_UV_FROM_UNIT0 + 1;
    private static final int BIT_INSTANCING          = BIT_LINE_STIPPLE + 1;
@@ -103,8 +103,8 @@ public final class VertexKey {
    public int texGenModeQ()              { return (int)((packed >> BIT_TEXGEN_Q) & 0x7); }
    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 lineQuads()            { return bit(BIT_LINE_QUADS); }
    public Instancing instancing()         { return Instancing.VALUES[(int) ((packed >> BIT_INSTANCING) & INSTANCING_MASK)]; }

    public boolean cmReplacesAmbient()    { final int m = colorMaterialMode(); return m == CM_AMBIENT || m == CM_AMBIENT_AND_DIFFUSE; }
@@ -226,7 +226,7 @@ public final class VertexKey {

        // Vertex format flags
        if (hasColor) bits |= (1L << BIT_HAS_VERTEX_COLOR);
-        if (hasNormal) bits |= (1L << BIT_HAS_VERTEX_NORMAL);
+        if (hasNormal && !glCtx.lineQuadsActive) bits |= (1L << BIT_HAS_VERTEX_NORMAL);
        if (hasTexCoord) bits |= (1L << BIT_HAS_VERTEX_TEX);
        if (hasLightmap) bits |= (1L << BIT_HAS_VERTEX_LIGHTMAP);

@@ -238,14 +238,14 @@ public final class VertexKey {
            bits |= (1L << BIT_CLIP_PLANES);
        }

-        if (glCtx.wideLineEmulationActive) {
-            bits |= (1L << BIT_WIDE_LINE);
-        }
-
        if (glCtx.lineStippleActive) {
            bits |= (1L << BIT_LINE_STIPPLE);
        }

+        if (glCtx.lineQuadsActive) {
+            bits |= (1L << BIT_LINE_QUADS);
+        }
+
        bits |= (long) glCtx.ffpInstancing.ordinal() << BIT_INSTANCING;

        return bits;
@@ -277,6 +277,6 @@ public final class VertexKey {

    @Override
    public String toString() {
-        return String.format("FFPVertexKey[0x%011X: lit=%b l0=%b l1=%b cm=%b fog=%b tex=%d%d%d%d texmat=%d%d%d%d col=%b nrm=%b vtex=%b vlm=%b tg=%d/%d/%d/%d clip=%b wline=%b inst=%s]", packed,lightingEnabled(), lightEnabled(0), lightEnabled(1), colorMaterialEnabled(), fogEnabled(), unitTexCoordEnabled(0)?1:0, unitTexCoordEnabled(1)?1:0, unitTexCoordEnabled(2)?1:0, unitTexCoordEnabled(3)?1:0, unitTexMatEnabled(0)?1:0, unitTexMatEnabled(1)?1:0, unitTexMatEnabled(2)?1:0, unitTexMatEnabled(3)?1:0, hasVertexColor(), hasVertexNormal(), hasVertexTexCoord(), hasVertexLightmap(), texGenModeS(), texGenModeT(), texGenModeR(), texGenModeQ(), clipPlanesEnabled(), wideLineEmulation(), instancing());
+        return String.format("FFPVertexKey[0x%012X: lit=%b l0=%b l1=%b cm=%b fog=%b tex=%d%d%d%d texmat=%d%d%d%d col=%b nrm=%b vtex=%b vlm=%b tg=%d/%d/%d/%d clip=%b lquads=%b inst=%s]", packed,lightingEnabled(), lightEnabled(0), lightEnabled(1), colorMaterialEnabled(), fogEnabled(), unitTexCoordEnabled(0)?1:0, unitTexCoordEnabled(1)?1:0, unitTexCoordEnabled(2)?1:0, unitTexCoordEnabled(3)?1:0, unitTexMatEnabled(0)?1:0, unitTexMatEnabled(1)?1:0, unitTexMatEnabled(2)?1:0, unitTexMatEnabled(3)?1:0, hasVertexColor(), hasVertexNormal(), hasVertexTexCoord(), hasVertexLightmap(), texGenModeS(), texGenModeT(), texGenModeR(), texGenModeQ(), clipPlanesEnabled(), lineQuads(), instancing());
    }
 }
@@ -34,28 +34,16 @@ public final class VertexShaderGenerator {
        }
        emitTexCoordPassthrough(sb, key);
        if (key.lineStipple()) {
-            emitLineStart(sb);
+            emitLineStart(sb, key.lineQuads() ? "lineCenter" : "gl_Position");
        }
        if (key.fogEnabled()) {
            emitFogDistance(sb, key);
        }
        if (key.clipPlanesEnabled()) {
-            emitClipDistances(sb);
+            emitClipDistances(sb, key);
        }
        sb.append("}\n");
-
-        String source = sb.toString();
-        if (key.wideLineEmulation()) {
-            source = source.replace("v_SpecularColor", "v_SpecularColor_gs")
-                           .replace("v_TexCoord0", "v_TexCoord0_gs")
-                           .replace("v_TexCoord1", "v_TexCoord1_gs")
-                           .replace("v_TexCoord2", "v_TexCoord2_gs")
-                           .replace("v_TexCoord3", "v_TexCoord3_gs")
-                           .replace("v_FogCoord", "v_FogCoord_gs")
-                           .replace("v_LineStart", "v_LineStart_gs")
-                           .replace("v_Color", "v_Color_gs");
-        }
-        return source;
+        return sb.toString();
    }

    private static void emitAttributes(StringBuilder sb, VertexKey key) {
@@ -78,6 +66,8 @@ public final class VertexShaderGenerator {
            }
            if (key.hasVertexNormal() || kind == Instancing.CUBE) {
                sb.append("layout(location = ").append(VertexFormatElement.Usage.NORMAL.getAttributeLocation()).append(") in vec3 a_Normal;\n");
+            } else if (key.lineQuads()) {
+                sb.append("layout(location = ").append(VertexFormatElement.Usage.NORMAL.getAttributeLocation()).append(") in vec3 a_LineOtherEnd;\n");
            }
        }
        for (String d : InstancedGlslHelpers.attributeDecls("a_", kind)) {
@@ -97,8 +87,8 @@ public final class VertexShaderGenerator {
        };
    }

-    private static void emitLineStart(StringBuilder sb) {
-        sb.append("  vec2 ndc = gl_Position.xy / gl_Position.w;\n");
+    private static void emitLineStart(StringBuilder sb, String clipPosition) {
+        sb.append("  vec2 ndc = ").append(clipPosition).append(".xy / ").append(clipPosition).append(".w;\n");
        sb.append("  v_LineStart = u_Viewport.xy + (ndc * 0.5 + 0.5) * u_Viewport.zw;\n\n");
    }

@@ -110,9 +100,9 @@ public final class VertexShaderGenerator {
    private static void emitOutputs(StringBuilder sb, VertexKey key) {
        sb.append("// Outputs\n");
        sb.append("out vec4 v_Color;\n");
+        sb.append("invariant gl_Position;\n");
        if (key.instancing().hasInstanceHead()) {
            sb.append("out vec4 v_Overlay;\n");
-            sb.append("invariant gl_Position;\n");
        }
        if (key.lineStipple()) {
            sb.append("flat out vec2 v_LineStart;\n");
@@ -151,15 +141,59 @@ public final class VertexShaderGenerator {
            sb.append("  v_Overlay = a_InstOverlay;\n");
        } else {
            sb.append("  gl_Position = u_MVPMatrix * pos4;\n");
+            if (key.lineQuads()) {
+                emitLineQuadWidening(sb);
+            }

            // Eye position needed for lighting, fog, EYE_LINEAR texgen, and clip planes
            if (key.lightingEnabled() || key.fogEnabled() || texGenNeedsEyePos(key) || key.clipPlanesEnabled()) {
                sb.append("  vec4 eyePos = u_ModelViewMatrix * pos4;\n");
            }
+            if (key.lineQuads() && (key.fogEnabled() || key.clipPlanesEnabled())) {
+                sb.append("  vec4 lineEyeOther = u_ModelViewMatrix * vec4(a_LineOtherEnd, 1.0);\n");
+            }
        }
        sb.append('\n');
    }

+    private static void emitLineQuadWidening(StringBuilder sb) {
+        sb.append("  int lineCorner = gl_VertexID % 6;\n");
+        sb.append("  bool lineStart = lineCorner == 0 || lineCorner == 1 || lineCorner == 3;\n");
+        sb.append("  vec4 lineOther = u_MVPMatrix * vec4(a_LineOtherEnd, 1.0);\n");
+        sb.append("  vec4 lineC0 = lineStart ? gl_Position : lineOther;\n");
+        sb.append("  vec4 lineC1 = lineStart ? lineOther : gl_Position;\n");
+        sb.append("  vec4 lineCenter = lineC0;\n");
+        sb.append("  float lineT = 0.0;\n");
+        sb.append("  float lineD0 = lineC0.z + lineC0.w;\n");
+        sb.append("  float lineD1 = lineC1.z + lineC1.w;\n");
+        sb.append("  if (lineD0 < 0.0 && lineD1 < 0.0) {\n");
+        sb.append("    gl_Position = vec4(0.0, 0.0, 2.0, 1.0);\n");
+        sb.append("  } else {\n");
+        sb.append("    float lineT0 = lineD0 < 0.0 ? lineD0 / (lineD0 - lineD1) : 0.0;\n");
+        sb.append("    float lineT1 = lineD1 < 0.0 ? lineD0 / (lineD0 - lineD1) : 1.0;\n");
+        sb.append("    lineT = lineStart ? lineT0 : lineT1;\n");
+        sb.append("    vec4 lineP0 = mix(lineC0, lineC1, lineT0);\n");
+        sb.append("    vec4 lineP1 = mix(lineC0, lineC1, lineT1);\n");
+        sb.append("    vec2 lineN0 = lineP0.xy / lineP0.w;\n");
+        sb.append("    vec2 lineN1 = lineP1.xy / lineP1.w;\n");
+        sb.append("    vec2 linePixel = 2.0 / u_ViewportSize;\n");
+        sb.append("    float lineHalfWidth = 0.5 * u_LineWidth;\n");
+        sb.append("    vec2 lineOffset;\n");
+        sb.append("    vec2 lineShift;\n");
+        sb.append("    vec2 lineSpan = abs(lineN1 - lineN0) * u_ViewportSize;\n");
+        sb.append("    if (lineSpan.x > lineSpan.y) {\n");
+        sb.append("      lineOffset = vec2(0.0, lineHalfWidth * linePixel.y);\n");
+        sb.append("      lineShift = vec2(lineN0.x < lineN1.x ? -0.5 : 0.5, -0.125) * linePixel;\n");
+        sb.append("    } else {\n");
+        sb.append("      lineOffset = vec2(lineHalfWidth * linePixel.x, 0.0);\n");
+        sb.append("      lineShift = vec2(0.125, lineN0.y < lineN1.y ? -0.5 : 0.5) * linePixel;\n");
+        sb.append("    }\n");
+        sb.append("    vec4 lineP = lineStart ? lineP0 : lineP1;\n");
+        sb.append("    vec2 lineN = lineStart ? lineN0 : lineN1;\n");
+        sb.append("    gl_Position = vec4((lineN + (lineCorner % 2 == 0 ? lineOffset : -lineOffset) + lineShift) * lineP.w, lineP.z, lineP.w);\n");
+        sb.append("  }\n");
+    }
+
    private static void emitNormalTransform(StringBuilder sb, VertexKey key) {
        sb.append("  // Normal transform\n");
        final String srcNormal = key.hasVertexNormal() && key.instancing() != Instancing.PARTICLE ? "a_Normal" : "u_CurrentNormal";
@@ -380,24 +414,21 @@ public final class VertexShaderGenerator {

    private static void emitFogDistance(StringBuilder sb, VertexKey key) {
        sb.append("  // Fog distance\n");
-        // Mesa ffvertex_prog.c build_fog(): FDM_EYE_RADIAL/EYE_PLANE/EYE_PLANE_ABS
-        final int fogDistMode = key.fogDistanceMode();
-        switch (fogDistMode) {
-            case 0 -> // FDM_EYE_RADIAL: Euclidean distance
-                sb.append("  v_FogCoord = length(eyePos.xyz);\n");
-            case 1 -> // FDM_EYE_PLANE: raw Z (can be negative, clamped by fog factor)
-                sb.append("  v_FogCoord = eyePos.z;\n");
-            case 2 -> // FDM_EYE_PLANE_ABS: absolute Z
-                sb.append("  v_FogCoord = abs(eyePos.z);\n");
-            default ->
-                sb.append("  v_FogCoord = abs(eyePos.z);\n");
+        final String own = FfpGlsl.fogDistance(key.fogDistanceMode(), "eyePos");
+        final String fog = key.lineQuads() ? acrossLine(own, FfpGlsl.fogDistance(key.fogDistanceMode(), "lineEyeOther")) : own;
+        sb.append("  v_FogCoord = ").append(fog).append(";\n");
+    }
+
+    private static void emitClipDistances(StringBuilder sb, VertexKey key) {
+        sb.append("  // Clip distances\n");
+        for (int i = 0; i < 8; i++) {
+            final String own = "dot(u_ClipPlane[" + i + "], eyePos)";
+            final String distance = key.lineQuads() ? acrossLine(own, "dot(u_ClipPlane[" + i + "], lineEyeOther)") : own;
+            sb.append("  gl_ClipDistance[").append(i).append("] = ").append(distance).append(";\n");
        }
    }

-    private static void emitClipDistances(StringBuilder sb) {
-        sb.append("  // Clip distances\n");
-        for (int i = 0; i < 8; i++) {
-            sb.append("  gl_ClipDistance[").append(i).append("] = dot(u_ClipPlane[").append(i).append("], eyePos);\n");
-        }
+    private static String acrossLine(String own, String other) {
+        return "mix(lineStart ? " + own + " : " + other + ", lineStart ? " + other + " : " + own + ", lineT)";
    }
 }
@@ -26,6 +26,7 @@ public final class FrameHooks {
    }

    public static void frameEnd() {
+        GLStateManager.onFrameEnd();
        popFrameGroup();
        RENDER_BACKEND.onFrameEnd();
    }
@@ -11,6 +11,7 @@ public final class GLSMHooks {
    public static DeferredDepthColorHandler depthColorHandler;
    public static GlintColorHandler glintColorHandler;
    public static ImmediateExtendedAttribHandler immediateExtendedHandler;
+    public static LineDrawHandler lineDrawHandler;
    public static ShaderTransformPostProcessor postTransformProcessor;
    public static PerFrameUniformBlock perFrameUniformBlock;
    public static PerFrameUniformBlock perPassUniformBlock;
@@ -3,15 +3,18 @@ package com.gtnewhorizons.angelica.glsm.hooks;
 import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
 import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.ffp.InstancedAttribs;
 import org.lwjgl.opengl.GL11;

 public interface ImmediateExtendedAttribHandler {

    int EXT_STRIDE = 12;
+    int ENTITY_IDS_STRIDE = 8;
    int LOC_MC_ENTITY = 11;
    int LOC_MID_TEX = 12;
    int LOC_TANGENT = 13;
    int LOC_MIDBLOCK = 14;
+    int LOC_ENTITY_IDS = 15;

    int RAW_NORMAL_INDEX = 6;

@@ -19,6 +22,8 @@ public interface ImmediateExtendedAttribHandler {

    boolean wantsTangent();

+    boolean wantsEntityIds();
+
    boolean wantsExtendedCapture();

    boolean wantsFaceNormals();
@@ -65,4 +70,9 @@ public interface ImmediateExtendedAttribHandler {
        GLStateManager.glEnableVertexAttribArray(LOC_TANGENT);
        GLStateManager.glVertexAttribPointer(LOC_TANGENT, 4, GL11.GL_BYTE, true, stride, baseOffset + 8);
    }
+
+    static void setupEntityIdsPointer(long offset, int stride) {
+        GLStateManager.glEnableVertexAttribArray(LOC_ENTITY_IDS);
+        InstancedAttribs.pointEntityIds(LOC_ENTITY_IDS, stride, offset);
+    }
 }
@@ -0,0 +1,8 @@
+package com.gtnewhorizons.angelica.glsm.hooks;
+
+public interface LineDrawHandler {
+
+    boolean bindLineProgram();
+
+    void restoreProgram();
+}
@@ -85,6 +85,11 @@ public final class EcosystemNarrowRules {
            "com.tihyo.legends.management.asm.AbstractTransformer",
            "com.tihyo.legends.management.asm.ASMHelper",
            "com.tihyo.legends.management.asm.Transformer"
+        )),
+
+        new NarrowRule("PowerConverters", "covers1624.powerconverters.", List.of(
+            "covers1624.powerconverters.asm",
+            "covers1624.powerconverters.randomdebugshit.CoFHDevEnvHacks"
        ))
    );

@@ -525,8 +525,9 @@ public final class CommandBufferExecutor {
                    ptr += 4;
                }
                case GLCommand.BIND_VAO -> {
-                    GLStateManager.glBindVertexArray(memGetInt(ptr));
+                    final int vao = memGetInt(ptr);
                    ptr += 4;
+                    if (compiledDisplayList.replaysVertexArrayBind(vao)) GLStateManager.glBindVertexArray(vao);
                }

                // === Complex object reference ===
@@ -1,6 +1,7 @@
 package com.gtnewhorizons.angelica.glsm.recording;

 import com.gtnewhorizons.angelica.glsm.DisplayListManager;
+import com.gtnewhorizons.angelica.glsm.GLContextState;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
 import com.gtnewhorizons.angelica.glsm.recording.commands.IndexedDrawBatch;
@@ -30,12 +31,13 @@ public final class CompiledDisplayList {
     * Empty display list singleton. Per OpenGL spec, an empty list is still valid.
     * This instance does nothing when rendered and is never deleted (shared singleton).
     */
-    public static final CompiledDisplayList EMPTY = new CompiledDisplayList(null, null, null, Collections.emptyList());
+    public static final CompiledDisplayList EMPTY = new CompiledDisplayList(null, null, null, Collections.emptyList(), null);

    private final ByteBuffer commandBuffer;     // Off-heap command storage, must be freed
    private final DisplayListCommand[] complexObjects;      // Complex commands (TexImage2D, etc.)
    private final DisplayListVBO ownedVbos;     // GPU resources referenced by index
    private final List<IndexedDrawBatch> indexedBatches; // Shared VAO/VBO/EBO triples per layout group
+    private GLContextState compileCtx;
    private Int2IntMap replayPrograms;
    private long programLifetimeGeneration = -1;

@@ -55,11 +57,16 @@ public final class CompiledDisplayList {
        return valid ? program : 0;
    }

-    public CompiledDisplayList(ByteBuffer commandBuffer, DisplayListCommand[] complexObjects, DisplayListVBO ownedVbos, List<IndexedDrawBatch> indexedBatches) {
+    public CompiledDisplayList(ByteBuffer commandBuffer, DisplayListCommand[] complexObjects, DisplayListVBO ownedVbos, List<IndexedDrawBatch> indexedBatches, GLContextState compileCtx) {
        this.commandBuffer = commandBuffer;
        this.complexObjects = complexObjects;
        this.ownedVbos = ownedVbos;
        this.indexedBatches = indexedBatches;
+        this.compileCtx = compileCtx;
+    }
+
+    boolean replaysVertexArrayBind(int vao) {
+        return vao == 0 || compileCtx == GLStateManager.ctx();
    }

    /**
@@ -101,6 +108,7 @@ public final class CompiledDisplayList {
        if (commandBuffer != null) {
            memFree(commandBuffer);
        }
+        compileCtx = null;
    }

    /**
@@ -1,8 +1,11 @@
 package com.gtnewhorizons.angelica.glsm.recording;

 import com.gtnewhorizon.gtnhlib.client.renderer.vao.IVertexArrayObject;
+import com.gtnewhorizons.angelica.glsm.GLContextState;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.hooks.ImmediateExtendedAttribHandler;
+import com.gtnewhorizons.angelica.glsm.streaming.LineQuads;
+import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL15;
 import com.gtnewhorizons.angelica.glsm.ffp.FfpExtendedAttribs;
 import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
@@ -55,9 +58,20 @@ public final class DisplayListVBO {
        private final int count;
        private final int vertexFlags;
        private int pendingExtVbo = 0;
+        private IVertexArrayObject lineQuads;
+        private int lineQuadStart;
+        private int lineQuadCount;
+        private int lineQuadFlags;

        void setPendingExtVbo(int extVbo) { this.pendingExtVbo = extVbo; }

+        void setLineQuads(IVertexArrayObject quads, int start, int count, int flags) {
+            this.lineQuads = quads;
+            this.lineQuadStart = start;
+            this.lineQuadCount = count;
+            this.lineQuadFlags = flags;
+        }
+
        public SubVBO(IVertexArrayObject vao, int drawMode, int start, int count, int vertexFlags) {
            this.vao = vao;
            this.drawMode = drawMode;
@@ -80,10 +94,15 @@ public final class DisplayListVBO {

        public void delete() {
            vao.delete();
+            if (lineQuads != null) lineQuads.delete();
        }

        public void render() {
            if (vao == null) return;
+            if (lineQuads != null && GLStateManager.ffpWidensLineQuads()) {
+                renderLineQuads();
+                return;
+            }
            vao.bind();
            if (pendingExtVbo != 0) {
                GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, pendingExtVbo);
@@ -102,6 +121,22 @@ public final class DisplayListVBO {
            vao.unbind();
        }

+        private void renderLineQuads() {
+            final GLContextState glCtx = GLStateManager.ctx();
+            lineQuads.bind();
+            VAOManager.setCurrentVertexFlags(lineQuadFlags);
+            final boolean culled = LineQuads.disableCulling();
+            glCtx.lineQuadsActive = true;
+            FfpExtendedAttribs.beginInternalDraw();
+            try {
+                lineQuads.draw(GL11.GL_TRIANGLES, lineQuadStart, lineQuadCount);
+            } finally {
+                FfpExtendedAttribs.endInternalDraw();
+                glCtx.lineQuadsActive = false;
+                LineQuads.restoreCulling(culled);
+            }
+            lineQuads.unbind();
+        }

        public IVertexArrayObject getVAO() {
            return vao;
@@ -13,6 +13,7 @@ import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.hooks.GLSMConfig;
 import com.gtnewhorizons.angelica.glsm.hooks.GLSMHooks;
 import com.gtnewhorizons.angelica.glsm.hooks.ImmediateExtendedAttribHandler;
+import com.gtnewhorizons.angelica.glsm.streaming.LineQuads;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL15;
@@ -78,6 +79,8 @@ public final class DisplayListVBOBuilder {
            final IntArrayList extStarts = wantExt ? new IntArrayList() : null;
            final IntArrayList extCounts = wantExt ? new IntArrayList() : null;
            final IntArrayList extPrims = wantExt ? new IntArrayList() : null;
+            // drawIndex, start, vertexCount, drawMode for each line draw
+            final IntArrayList lineDraws = GLStateManager.wideLineEmulationEnabled ? new IntArrayList() : null;

            for (FormatData data : formatData) {
                int vertexCount;
@@ -123,6 +126,12 @@ public final class DisplayListVBOBuilder {
                    vbos[data.drawIndex] = new DisplayListVBO.SubVBO(vao, GL11.GL_TRIANGLE_FAN, start, vertexCount, flags);
                } else {
                    vbos[data.drawIndex] = new DisplayListVBO.SubVBO(vao, data.drawMode, start, vertexCount, flags);
+                    if (lineDraws != null && LineQuads.segmentCount(data.drawMode, vertexCount) > 0) {
+                        lineDraws.add(data.drawIndex);
+                        lineDraws.add(start);
+                        lineDraws.add(vertexCount);
+                        lineDraws.add(data.drawMode);
+                    }
                }


@@ -130,6 +139,9 @@ public final class DisplayListVBOBuilder {
            }
            ByteBuffer bigBuffer = mergeAndDelete(allBuffers);
            vbo.allocate(bigBuffer, start);
+            if (lineDraws != null && !lineDraws.isEmpty()) {
+                attachLineQuads(vbos, format, bigBuffer, lineDraws);
+            }

            if (wantExt && !extDrawIndexes.isEmpty()) {
                final int extVbo = buildExt(extHandler, format, bigBuffer, extStarts, extCounts, extPrims);
@@ -148,6 +160,34 @@ public final class DisplayListVBOBuilder {
        return new DisplayListVBO(vbos, extVbos.toIntArray());
    }

+    // The line width is only known at playback, so lines keep their own draw and also get quads to widen
+    private static void attachLineQuads(DisplayListVBO.SubVBO[] vbos, VertexFormat format, ByteBuffer vertices, IntArrayList lineDraws) {
+        final VertexFormat quadFormat = LineQuads.quadFormat(format);
+        final int quadSize = quadFormat.getVertexSize();
+        int quadVertices = 0;
+        for (int i = 0; i < lineDraws.size(); i += 4) {
+            quadVertices += LineQuads.segmentCount(lineDraws.getInt(i + 3), lineDraws.getInt(i + 2)) * LineQuads.VERTICES_PER_SEGMENT;
+        }
+
+        final ByteBuffer quads = memAlloc(quadVertices * quadSize);
+        final long src = memAddress0(vertices);
+        final long dst = memAddress0(quads);
+        final int stride = format.getVertexSize();
+        final IVertexArrayObject quadVao = VAOManager.createStorageVAO(quadFormat, -1, 0);
+        int quadStart = 0;
+        for (int i = 0; i < lineDraws.size(); i += 4) {
+            final int start = lineDraws.getInt(i + 1);
+            final int count = lineDraws.getInt(i + 2);
+            final int mode = lineDraws.getInt(i + 3);
+            final int corners = LineQuads.segmentCount(mode, count) * LineQuads.VERTICES_PER_SEGMENT;
+            LineQuads.expandWithOtherEnd(src + (long) start * stride, format, mode, count, dst + (long) quadStart * quadSize);
+            vbos[lineDraws.getInt(i)].setLineQuads(quadVao, quadStart, corners, quadFormat.getVertexFlags());
+            quadStart += corners;
+        }
+        quadVao.getVBO().allocate(quads, quadVertices);
+        memFree(quads);
+    }
+
    private static int buildExt(ImmediateExtendedAttribHandler handler, VertexFormat format, ByteBuffer bigBuffer,
                                IntArrayList extStarts, IntArrayList extCounts, IntArrayList extPrims) {
        final int extStride = ImmediateExtendedAttribHandler.EXT_STRIDE;
@@ -5,6 +5,8 @@ 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.GLTypes;
+import com.gtnewhorizons.angelica.glsm.QuadConverter;
 import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
 import org.lwjgl.opengl.GL11;

@@ -13,6 +15,10 @@ import java.util.Arrays;
 import java.util.Queue;
 import java.util.concurrent.ConcurrentLinkedQueue;

+import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetByte;
+import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt;
+import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetShort;
+
 /**
 * Records immediate mode GL calls (glBegin/glEnd/glVertex) via {@link DirectTessellator}.
 * Used both during display list compilation and for live immediate mode emulation in core profile.
@@ -213,6 +219,34 @@ public final class ImmediateModeRecorder {
        }
    }

+    public static DirectTessellator processDrawElementsFromAttribs(int mode, int count, int indexType, long indices) {
+        final long minMax = QuadConverter.scanMinMaxIndex(indices, indexType, count);
+        if (minMax == -1L) return null;
+        final int minVertex = (int) (minMax & 0xFFFFFFFFL);
+        final int maxVertex = (int) (minMax >>> 32);
+        final AttribSnapshot snap = AttribSnapshot.snapshot(minVertex, maxVertex - minVertex + 1);
+        if (snap == null) return null;
+        try {
+            prepareReaders(snap);
+            if (positionReaderIndex < 0) return null;
+            begin(mode);
+            final DirectTessellator t = tessellator();
+            final int indexSize = GLTypes.sizeBytes(indexType);
+            for (int i = 0; i < count; i++) {
+                final long at = indices + (long) i * indexSize;
+                final int vertex = switch (indexType) {
+                    case GL11.GL_UNSIGNED_BYTE -> memGetByte(at) & 0xFF;
+                    case GL11.GL_UNSIGNED_SHORT -> memGetShort(at) & 0xFFFF;
+                    default -> memGetInt(at);
+                };
+                readVertexFromBuffer(t, vertex);
+            }
+            return end();
+        } finally {
+            snap.free();
+        }
+    }
+
    private static void prepareReaders(AttribSnapshot snap) {
        nonPositionCount = 0;
        positionReaderIndex = -1;
@@ -3,21 +3,20 @@ package com.gtnewhorizons.angelica.glsm.recording.commands;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;

 public final class BatchedIndexedDrawCmd implements DisplayListCommand {
-    private int sharedVAO;
+    private IndexedDrawBatch batch;
    private int drawMode;
    private int indexCount;
    private int indexType;
    private long indexByteOffset;

-    public void fill(int sharedVAO, int drawMode, int indexCount, int indexType, long indexByteOffset) {
-        this.sharedVAO = sharedVAO;
+    public void fill(IndexedDrawBatch batch, int drawMode, int indexCount, int indexType, long indexByteOffset) {
+        this.batch = batch;
        this.drawMode = drawMode;
        this.indexCount = indexCount;
        this.indexType = indexType;
        this.indexByteOffset = indexByteOffset;
    }

-    public int getSharedVAO() { return sharedVAO; }
    public int getDrawMode() { return drawMode; }
    public int getIndexCount() { return indexCount; }
    public int getIndexType() { return indexType; }
@@ -25,13 +24,13 @@ public final class BatchedIndexedDrawCmd implements DisplayListCommand {

    @Override
    public void execute() {
-        if (sharedVAO == 0) return;
-        GLStateManager.glBindVertexArray(sharedVAO);
+        if (batch == null) return;
+        batch.bind();
        GLStateManager.glDrawElements(drawMode, indexCount, indexType, indexByteOffset);
    }

    @Override
    public String toString() {
-        return "BatchedIndexedDrawCmd(vao=" + sharedVAO + ", mode=" + drawMode + ", count=" + indexCount + ", type=" + indexType + ", offset=" + indexByteOffset + ")";
+        return "BatchedIndexedDrawCmd(batch=" + batch + ", mode=" + drawMode + ", count=" + indexCount + ", type=" + indexType + ", offset=" + indexByteOffset + ")";
    }
 }
@@ -1,34 +1,60 @@
 package com.gtnewhorizons.angelica.glsm.recording.commands;

+import com.gtnewhorizons.angelica.glsm.GLContextState;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import org.lwjgl.opengl.GL15;

 public final class IndexedDrawBatch {
-    private int sharedVAO;
+    private final AttribLayoutKey layout;
    private int sharedVBO;
    private int sharedEBO;
+    private int vao;
+    private GLContextState vaoCtx;
    private boolean deleted;

-    public IndexedDrawBatch(int sharedVAO, int sharedVBO, int sharedEBO) {
-        this.sharedVAO = sharedVAO;
+    public IndexedDrawBatch(AttribLayoutKey layout, int sharedVBO, int sharedEBO) {
+        this.layout = layout;
        this.sharedVBO = sharedVBO;
        this.sharedEBO = sharedEBO;
    }

-    public int getSharedVAO() { return sharedVAO; }
    public int getSharedVBO() { return sharedVBO; }
    public int getSharedEBO() { return sharedEBO; }

+    public void bind() {
+        final GLContextState glCtx = GLStateManager.ctx();
+        if (vaoCtx == glCtx) {
+            GLStateManager.glBindVertexArray(vao);
+            return;
+        }
+        final int prevVBO = GLStateManager.getBoundVBO();
+        final int v = GLStateManager.glGenVertexArrays();
+        GLStateManager.glBindVertexArray(v);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, sharedVBO);
+        final int stride = layout.stride();
+        for (int i = 0; i < layout.locations.length; i++) {
+            final int loc = layout.locations[i];
+            GLStateManager.glVertexAttribPointer(loc, layout.sizes[i], layout.types[i], layout.normalized[i], stride, layout.offset(i));
+            GLStateManager.glEnableVertexAttribArray(loc);
+        }
+        GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, sharedEBO);
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, prevVBO);
+        vao = v;
+        vaoCtx = glCtx;
+    }
+
    public void delete() {
        if (deleted) return;
        deleted = true;
-        if (sharedVAO != 0) GLStateManager.glDeleteVertexArrays(sharedVAO);
+        if (vaoCtx == GLStateManager.ctx()) GLStateManager.glDeleteVertexArrays(vao);
        if (sharedVBO != 0) GLStateManager.glDeleteBuffers(sharedVBO);
        if (sharedEBO != 0) GLStateManager.glDeleteBuffers(sharedEBO);
-        sharedVAO = sharedVBO = sharedEBO = 0;
+        vao = sharedVBO = sharedEBO = 0;
+        vaoCtx = null;
    }

    @Override
    public String toString() {
-        return "IndexedDrawBatch(vao=" + sharedVAO + ", vbo=" + sharedVBO + ", ebo=" + sharedEBO + ")";
+        return "IndexedDrawBatch(vao=" + vao + ", vbo=" + sharedVBO + ", ebo=" + sharedEBO + ")";
    }
 }
@@ -35,7 +35,6 @@ public final class IndexedDrawBatchBuilder {
        final List<IndexedDrawBatch> out = new ArrayList<>();
        if (captures.isEmpty()) return out;

-        final int prevVAO = GLStateManager.getBoundVAO();
        final int prevVBO = GLStateManager.getBoundVBO();
        final int prevEBO = GLStateManager.getBoundEBO();

@@ -58,7 +57,6 @@ public final class IndexedDrawBatchBuilder {
            if (!success) {
                for (GroupResult r : results) r.batch.delete();
            }
-            GLStateManager.glBindVertexArray(prevVAO);
            GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEBO);
            GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, prevVBO);
        }
@@ -69,9 +67,8 @@ public final class IndexedDrawBatchBuilder {
    private record GroupResult(IndexedDrawBatch batch, List<IndexedDrawCapture> captures,
                               int[] drawModes, int[] indexCounts, long[] indexOffsets) {
        void commit() {
-            final int sharedVAO = batch.getSharedVAO();
            for (int i = 0; i < captures.size(); i++) {
-                captures.get(i).placeholder.fill(sharedVAO, drawModes[i], indexCounts[i], GL11.GL_UNSIGNED_INT, indexOffsets[i]);
+                captures.get(i).placeholder.fill(batch, drawModes[i], indexCounts[i], GL11.GL_UNSIGNED_INT, indexOffsets[i]);
            }
        }
    }
@@ -87,7 +84,6 @@ public final class IndexedDrawBatchBuilder {
            throw new IllegalStateException("batch exceeds 2GiB — split needed");
        }

-        int sharedVAO = 0;
        int sharedVBO = 0;
        int sharedEBO = 0;
        ByteBuffer eboData = null;
@@ -99,12 +95,10 @@ public final class IndexedDrawBatchBuilder {
        final long[] indexOffsets = new long[n];

        try {
-            sharedVAO = GLStateManager.glGenVertexArrays();
            sharedVBO = GLStateManager.glGenBuffers();
            sharedEBO = GLStateManager.glGenBuffers();
            eboData = MemoryUtilities.memAlloc((int) totalIndexBytes);

-            GLStateManager.glBindVertexArray(sharedVAO);
            GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, sharedVBO);
            GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, totalVertexBytes, GL15.GL_STATIC_DRAW);

@@ -146,23 +140,12 @@ public final class IndexedDrawBatchBuilder {
            GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, sharedEBO);
            GLStateManager.glBufferData(GL15.GL_ELEMENT_ARRAY_BUFFER, eboData, GL15.GL_STATIC_DRAW);

-            final AttribLayoutKey layout = group.get(0).layoutKey;
-            final int stride = layout.stride();
-            for (int i = 0; i < layout.locations.length; i++) {
-                final int loc = layout.locations[i];
-                final int size = layout.sizes[i];
-                final int type = layout.types[i];
-                GLStateManager.glVertexAttribPointer(loc, size, type, layout.normalized[i], stride, layout.offset(i));
-                GLStateManager.glEnableVertexAttribArray(loc);
-            }
-
            success = true;
-            return new GroupResult(new IndexedDrawBatch(sharedVAO, sharedVBO, sharedEBO),
+            return new GroupResult(new IndexedDrawBatch(group.get(0).layoutKey, sharedVBO, sharedEBO),
                group, drawModes, indexCounts, indexOffsets);
        } finally {
            if (eboData != null) MemoryUtilities.memFree(eboData);
            if (!success) {
-                if (sharedVAO != 0) GLStateManager.glDeleteVertexArrays(sharedVAO);
                if (sharedVBO != 0) GLStateManager.glDeleteBuffers(sharedVBO);
                if (sharedEBO != 0) GLStateManager.glDeleteBuffers(sharedEBO);
            }
@@ -3,7 +3,7 @@ package com.gtnewhorizons.angelica.glsm.recording.commands;
 import com.gtnewhorizons.angelica.glsm.GLDebug;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.GLTypes;
-import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
+import com.gtnewhorizons.angelica.glsm.states.PixelStoreState;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

@@ -28,7 +28,7 @@ public record TexImage2DCmd(
    int format,
    int type,
    @Nullable ByteBuffer pixels,
-    @Nullable PixelUnpackState unpack
+    @Nullable PixelStoreState unpack
 ) implements DisplayListCommand {

    public TexImage2DCmd {
@@ -37,19 +37,19 @@ public record TexImage2DCmd(
        }
    }

-    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) {
+    public static TexImage2DCmd fromIntBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable IntBuffer pixels, PixelStoreState unpack) {
        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

-    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) {
+    public static TexImage2DCmd fromFloatBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable FloatBuffer pixels, PixelStoreState unpack) {
        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

-    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) {
+    public static TexImage2DCmd fromDoubleBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable DoubleBuffer pixels, PixelStoreState 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) {
+    public static TexImage2DCmd fromByteBuffer(int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable ByteBuffer pixels, PixelStoreState unpack) {
        return new TexImage2DCmd(target, level, internalformat, width, height, border, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

@@ -3,7 +3,7 @@ package com.gtnewhorizons.angelica.glsm.recording.commands;
 import com.gtnewhorizons.angelica.glsm.GLDebug;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.GLTypes;
-import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
+import com.gtnewhorizons.angelica.glsm.states.PixelStoreState;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

@@ -28,7 +28,7 @@ public record TexSubImage2DCmd(
    int format,
    int type,
    @Nullable ByteBuffer pixels,
-    @Nullable PixelUnpackState unpack
+    @Nullable PixelStoreState unpack
 ) implements DisplayListCommand {

    public TexSubImage2DCmd {
@@ -37,19 +37,19 @@ public record TexSubImage2DCmd(
        }
    }

-    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) {
+    public static TexSubImage2DCmd fromIntBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable IntBuffer pixels, PixelStoreState unpack) {
        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

-    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) {
+    public static TexSubImage2DCmd fromFloatBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable FloatBuffer pixels, PixelStoreState unpack) {
        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

-    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) {
+    public static TexSubImage2DCmd fromDoubleBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable DoubleBuffer pixels, PixelStoreState 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) {
+    public static TexSubImage2DCmd fromByteBuffer(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @Nullable ByteBuffer pixels, PixelStoreState unpack) {
        return new TexSubImage2DCmd(target, level, xoffset, yoffset, width, height, format, type, PixelDataSnapshot.copy(pixels), unpack);
    }

@@ -143,6 +143,7 @@ public class GLSMRedirector {
    private static final String OpenGlHelper = "net/minecraft/client/renderer/OpenGlHelper";
    private static final String EXTBlendFunc = "org/lwjgl/opengl/EXTBlendFuncSeparate";
    private static final String EXTSecondaryColor = "org/lwjgl/opengl/EXTSecondaryColor";
+    private static final String EXTFogCoord = "org/lwjgl/opengl/EXTFogCoord";
    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";
@@ -166,6 +167,14 @@ public class GLSMRedirector {
    private static final String EXTTimerQuery = "org/lwjgl/opengl/EXTTimerQuery";
    private static final String ARBSamplerObjects = "org/lwjgl/opengl/ARBSamplerObjects";
    private static final String ARBMultiBind = "org/lwjgl/opengl/ARBMultiBind";
+    private static final String ARBDirectStateAccess = "org/lwjgl/opengl/ARBDirectStateAccess";
+    private static final String ARBGeometryShader4 = "org/lwjgl/opengl/ARBGeometryShader4";
+    private static final String EXTGeometryShader4 = "org/lwjgl/opengl/EXTGeometryShader4";
+    private static final String NVGeometryProgram4 = "org/lwjgl/opengl/NVGeometryProgram4";
+    private static final String EXTTextureArray = "org/lwjgl/opengl/EXTTextureArray";
+    private static final String EXTDirectStateAccess = "org/lwjgl/opengl/EXTDirectStateAccess";
+    private static final String ARBShaderImageLoadStore = "org/lwjgl/opengl/ARBShaderImageLoadStore";
+    private static final String EXTShaderImageLoadStore = "org/lwjgl/opengl/EXTShaderImageLoadStore";

    // Redirect VAO related calls from NHLib
    private static final String UniversalVAO = "com/gtnewhorizon/gtnhlib/client/opengl/UniversalVAO";
@@ -378,6 +387,8 @@ public class GLSMRedirector {
            .add("glEnableClientState")
            .add("glDisableClientState")
            .add("glInterleavedArrays")
+            .add("glEdgeFlagPointer")
+            .add("glGetPointer")
            .add("glPushClientAttrib")
            .add("glPopClientAttrib")
            .add("glViewport")
@@ -408,11 +419,16 @@ public class GLSMRedirector {
            .add("glMultiDrawArrays")
            .add("glPointParameterf")
            .add("glPointParameteri")
+            .add("glPointParameter")
+            .add("glPointParameterfv", "glPointParameter")
+            .add("glPointParameteriv", "glPointParameter")
            // Removed in core profile - emulated by the FFP shaders, calling through would abort the JVM
            .add("glSecondaryColor3f")
            .add("glSecondaryColor3d")
            .add("glSecondaryColor3b")
-            .add("glSecondaryColor3ub");
+            .add("glSecondaryColor3ub")
+            .add("glSecondaryColorPointer")
+            .add("glFogCoordPointer");
        final var gl15 = RedirectMap.newMap()
            .add("glGenBuffers")
            .add("glBindBuffer")
@@ -505,7 +521,10 @@ public class GLSMRedirector {
            .add("glDeleteFramebuffers")
            .add("glGenFramebuffers")
            .add("glCheckFramebufferStatus")
+            .add("glFramebufferTexture1D")
            .add("glFramebufferTexture2D")
+            .add("glFramebufferTexture3D")
+            .add("glFramebufferTextureLayer")
            .add("glVertexAttribIPointer")
            .add("glGenerateMipmap")
            .add("glGetFramebufferAttachmentParameteri")
@@ -559,11 +578,18 @@ public class GLSMRedirector {
        final var gl44 = RedirectMap.newMap()
            .add("glBufferStorage")
            .add("glBindSamplers")
-            .add("glClearTexImage");
+            .add("glClearTexImage")
+            .add("glBindTextures")
+            .add("glBindImageTextures");
        final var gl45 = RedirectMap.newMap()
            .add("glCreateBuffers")
            .add("glNamedBufferData")
-            .add("glNamedBufferSubData");
+            .add("glNamedBufferSubData")
+            .add("glNamedFramebufferTexture")
+            .add("glNamedFramebufferTextureLayer")
+            .add("glNamedFramebufferRenderbuffer")
+            .add("glCreateTextures")
+            .add("glBindTextureUnit");
        final var gl46 = RedirectMap.newMap()
            .add("glPolygonOffsetClamp")
            .add("glMultiDrawArraysIndirectCount")
@@ -604,7 +630,9 @@ public class GLSMRedirector {
            .add("glSecondaryColor3bEXT", "glSecondaryColor3b")
            .add("glSecondaryColor3fEXT", "glSecondaryColor3f")
            .add("glSecondaryColor3dEXT", "glSecondaryColor3d")
-            .add("glSecondaryColor3ubEXT", "glSecondaryColor3ub"));
+            .add("glSecondaryColor3ubEXT", "glSecondaryColor3ub")
+            .add("glSecondaryColorPointerEXT", "glSecondaryColorPointer"));
+        methodRedirects.put(EXTFogCoord, RedirectMap.newMap().add("glFogCoordPointerEXT", "glFogCoordPointer"));

        // ARB
        methodRedirects.put(ARBMultiTexture, RedirectMap.newMap()
@@ -620,24 +648,31 @@ public class GLSMRedirector {
            .add("glDeleteFramebuffers")
            .add("glGenFramebuffers")
            .add("glCheckFramebufferStatus")
+            .add("glFramebufferTexture1D")
            .add("glFramebufferTexture2D")
+            .add("glFramebufferTexture3D")
+            .add("glFramebufferTextureLayer")
            .add("glBindRenderbuffer")
            .add("glDeleteRenderbuffers")
            .add("glGenRenderbuffers")
            .add("glRenderbufferStorage")
            .add("glFramebufferRenderbuffer")
+            .add("glGenerateMipmap")
        );
        methodRedirects.put(EXTFramebufferObject, RedirectMap.newMap()
            .add("glBindFramebufferEXT", "glBindFramebuffer")
            .add("glDeleteFramebuffersEXT", "glDeleteFramebuffers")
            .add("glGenFramebuffersEXT", "glGenFramebuffers")
            .add("glCheckFramebufferStatusEXT", "glCheckFramebufferStatus")
+            .add("glFramebufferTexture1DEXT", "glFramebufferTexture1D")
            .add("glFramebufferTexture2DEXT", "glFramebufferTexture2D")
+            .add("glFramebufferTexture3DEXT", "glFramebufferTexture3D")
            .add("glBindRenderbufferEXT", "glBindRenderbuffer")
            .add("glDeleteRenderbuffersEXT", "glDeleteRenderbuffers")
            .add("glGenRenderbuffersEXT", "glGenRenderbuffers")
            .add("glRenderbufferStorageEXT", "glRenderbufferStorage")
            .add("glFramebufferRenderbufferEXT", "glFramebufferRenderbuffer")
+            .add("glGenerateMipmapEXT", "glGenerateMipmap")
        );
        methodRedirects.put(ARBOcclusionQuery, RedirectMap.newMap()
            .add("glGenQueriesARB", "glGenQueries")
@@ -781,6 +816,45 @@ public class GLSMRedirector {
        );
        methodRedirects.put(ARBMultiBind, RedirectMap.newMap()
            .add("glBindSamplers")
+            .add("glBindTextures")
+            .add("glBindImageTextures")
+        );
+        methodRedirects.put(ARBDirectStateAccess, RedirectMap.newMap()
+            .add("glNamedFramebufferTexture")
+            .add("glNamedFramebufferTextureLayer")
+            .add("glNamedFramebufferRenderbuffer")
+            .add("glCreateTextures")
+            .add("glBindTextureUnit")
+        );
+        methodRedirects.put(ARBGeometryShader4, RedirectMap.newMap()
+            .add("glFramebufferTextureARB", "glFramebufferTexture")
+            .add("glFramebufferTextureLayerARB", "glFramebufferTextureLayer")
+            .add("glFramebufferTextureFaceARB", "glFramebufferTextureFace")
+        );
+        final var geometryShader4 = RedirectMap.newMap()
+            .add("glFramebufferTextureEXT", "glFramebufferTexture")
+            .add("glFramebufferTextureLayerEXT", "glFramebufferTextureLayer")
+            .add("glFramebufferTextureFaceEXT", "glFramebufferTextureFace");
+        methodRedirects.put(EXTGeometryShader4, geometryShader4);
+        methodRedirects.put(NVGeometryProgram4, geometryShader4);
+        methodRedirects.put(EXTTextureArray, RedirectMap.newMap()
+            .add("glFramebufferTextureLayerEXT", "glFramebufferTextureLayer")
+        );
+        methodRedirects.put(EXTDirectStateAccess, RedirectMap.newMap()
+            .add("glNamedFramebufferTexture1DEXT")
+            .add("glNamedFramebufferTexture2DEXT")
+            .add("glNamedFramebufferTexture3DEXT")
+            .add("glNamedFramebufferTextureEXT")
+            .add("glNamedFramebufferTextureLayerEXT", "glNamedFramebufferTextureLayer")
+            .add("glNamedFramebufferTextureFaceEXT")
+            .add("glNamedFramebufferRenderbufferEXT", "glNamedFramebufferRenderbuffer")
+            .add("glBindMultiTextureEXT")
+        );
+        methodRedirects.put(ARBShaderImageLoadStore, RedirectMap.newMap()
+            .add("glBindImageTexture")
+        );
+        methodRedirects.put(EXTShaderImageLoadStore, RedirectMap.newMap()
+            .add("glBindImageTextureEXT", "glBindImageTexture")
        );

        // APPLE
@@ -1,20 +1,17 @@
 package com.gtnewhorizons.angelica.glsm.shader;

 import com.gtnewhorizons.angelica.glsm.GlslTransformUtils;
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
 import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
 import org.antlr.v4.runtime.ParserRuleContext;
 import org.antlr.v4.runtime.Token;
-import org.antlr.v4.runtime.tree.ParseTree;
-import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.antlr.v4.runtime.tree.TerminalNode;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.jetbrains.annotations.Nullable;
 import org.lwjgl.opengl.GL20;
-import org.taumc.glsl.grammar.GLSLLexer;
 import org.taumc.glsl.grammar.GLSLParser;
-import org.taumc.glsl.grammar.GLSLPreParser;
-import org.taumc.glsl.grammar.GLSLParserBaseListener;

 import java.util.ArrayList;
 import java.util.Comparator;
@@ -37,6 +34,17 @@ public final class GlslVulkanPreprocess {
        "const_cast", "dynamic_cast", "reinterpret_cast", "static_cast", "export",
        "and", "or", "xor", "bitand", "bitor", "compl", "and_eq", "or_eq", "xor_eq", "not_eq");

+    private static final Object2ObjectLinkedOpenHashMap<String, String> IDENTIFIER_RENAMES = identifierRenames();
+
+    private static Object2ObjectLinkedOpenHashMap<String, String> identifierRenames() {
+        final Object2ObjectLinkedOpenHashMap<String, String> renames = new Object2ObjectLinkedOpenHashMap<>();
+        renames.put("sampler", SAMPLER_RENAMED);
+        renames.put("gl_VertexID", "gl_VertexIndex");
+        renames.put("gl_InstanceID", "gl_InstanceIndex");
+        for (String reserved : TARGET_RESERVED) renames.put(reserved, RESERVED_RENAMED_PREFIX + reserved);
+        return renames;
+    }
+
    public static final String SAMPLERLESS_EXTENSION = "#extension GL_EXT_samplerless_texture_functions : require";

    private static final int MAX_VS_INPUT_LOCATIONS = 16;
@@ -99,7 +107,7 @@ public final class GlslVulkanPreprocess {
        }

        final List<Edit> edits = new ArrayList<>();
-        final Metadata meta = collectEdits(source, root, glShaderType, debugName, separateReadOnlyImages, edits);
+        final Metadata meta = collectEdits(new ShaderIndex(root, source), glShaderType, debugName, separateReadOnlyImages, edits);

        final Result out = new Result(applyEdits(source, edits), meta.boolUniforms(), meta.explicitVsInputs());
        synchronized (CACHE) {
@@ -111,129 +119,99 @@ public final class GlslVulkanPreprocess {

    public record Metadata(Set<String> boolUniforms, Set<String> explicitVsInputs, boolean needsSamplerless) {}

-    public static Metadata collectEdits(String source, GLSLParser.Translation_unitContext root, int glShaderType, String debugName, boolean separateReadOnlyImages, List<Edit> edits) {
+    public static Metadata collectEdits(ShaderIndex index, int glShaderType, String debugName, boolean separateReadOnlyImages, List<Edit> edits) {
        final boolean isVertex = glShaderType == GL20.GL_VERTEX_SHADER;
        final Set<String> bools = new HashSet<>();
        final Set<String> explicitInputs = new HashSet<>();
        final Set<String> readOnlyImages = new HashSet<>();
-        final boolean[] needsSamplerless = { false };
+        boolean needsSamplerless = false;

-        final int[] maxExplicitLoc = { -1 };
+        int maxExplicitLoc = -1;
        final List<Integer> unlocatedVsInputStarts = new ArrayList<>();

-        ParseTreeWalker.DEFAULT.walk(new GLSLParserBaseListener() {
-            @Override
-            public void enterInit_declarator_list(GLSLParser.Init_declarator_listContext ctx) {
-                final GLSLParser.Single_declarationContext single = ctx.single_declaration();
-                if (single == null || single.fully_specified_type() == null) return;
+        for (GLSLParser.DeclarationContext declaration : index.globalDeclarations()) {
+            final GLSLParser.Init_declarator_listContext list = declaration.init_declarator_list();
+            if (list == null) continue;
+            final GLSLParser.Single_declarationContext single = list.single_declaration();
+            if (single == null || single.fully_specified_type() == null) continue;

-                final GLSLParser.Fully_specified_typeContext fst = single.fully_specified_type();
-                final GLSLParser.Type_qualifierContext tq = fst.type_qualifier();
-                if (tq == null) return;
+            final GLSLParser.Fully_specified_typeContext fst = single.fully_specified_type();
+            final GLSLParser.Type_qualifierContext tq = fst.type_qualifier();
+            if (tq == null) continue;

-                boolean hasUniform = false, hasIn = false, hasLocation = false, hasReadonly = false;
-                int locValue = -1;
-                int bindingValue = -1;
-                for (GLSLParser.Single_type_qualifierContext stq : tq.single_type_qualifier()) {
-                    if (stq.storage_qualifier() != null) {
-                        final String s = stq.storage_qualifier().getText();
-                        if ("uniform".equals(s)) hasUniform = true;
-                        else if ("in".equals(s)) hasIn = true;
-                        else if ("readonly".equals(s)) hasReadonly = true;
-                    } else if (stq.layout_qualifier() != null) {
-                        for (GLSLParser.Layout_qualifier_idContext id : stq.layout_qualifier().layout_qualifier_id_list().layout_qualifier_id()) {
-                            if (id.IDENTIFIER() == null) continue;
-                            final String qualifier = id.IDENTIFIER().getText();
-                            if ("location".equals(qualifier)) {
-                                hasLocation = true;
-                                if (id.constant_expression() != null) {
-                                    try { locValue = Integer.parseInt(id.constant_expression().getText()); } catch (NumberFormatException ignored) {}
-                                }
-                            } else if ("binding".equals(qualifier) && id.constant_expression() != null) {
-                                try { bindingValue = Integer.parseInt(id.constant_expression().getText()); } catch (NumberFormatException ignored) {}
+            boolean hasUniform = false, hasIn = false, hasLocation = false, hasReadonly = false;
+            int locValue = -1;
+            int bindingValue = -1;
+            for (GLSLParser.Single_type_qualifierContext stq : tq.single_type_qualifier()) {
+                if (stq.storage_qualifier() != null) {
+                    final String s = stq.storage_qualifier().getText();
+                    if ("uniform".equals(s)) hasUniform = true;
+                    else if ("in".equals(s)) hasIn = true;
+                    else if ("readonly".equals(s)) hasReadonly = true;
+                } else if (stq.layout_qualifier() != null) {
+                    for (GLSLParser.Layout_qualifier_idContext id : stq.layout_qualifier().layout_qualifier_id_list().layout_qualifier_id()) {
+                        if (id.IDENTIFIER() == null) continue;
+                        final String qualifier = id.IDENTIFIER().getText();
+                        if ("location".equals(qualifier)) {
+                            hasLocation = true;
+                            if (id.constant_expression() != null) {
+                                try { locValue = Integer.parseInt(id.constant_expression().getText()); } catch (NumberFormatException ignored) {}
                            }
+                        } else if ("binding".equals(qualifier) && id.constant_expression() != null) {
+                            try { bindingValue = Integer.parseInt(id.constant_expression().getText()); } catch (NumberFormatException ignored) {}
                        }
                    }
                }
+            }

-                final boolean boolDecl = hasUniform && isBool(fst);
-                final boolean explicitInputDecl = isVertex && hasIn && hasLocation;
+            final boolean boolDecl = hasUniform && isBool(fst);
+            final boolean explicitInputDecl = isVertex && hasIn && hasLocation;
+            final List<GLSLParser.Typeless_declarationContext> declarators = ShaderIndex.declarators(list);
+            for (GLSLParser.Typeless_declarationContext td : declarators) {
+                handleDeclarator(td, hasUniform, boolDecl, explicitInputDecl, bools, explicitInputs, edits);
+            }

-                if (single.typeless_declaration() != null) {
-                    handleDeclarator(single.typeless_declaration(), hasUniform, boolDecl, explicitInputDecl, bools, explicitInputs, edits);
-                }
-                for (GLSLParser.Typeless_declarationContext td : ctx.typeless_declaration()) {
-                    handleDeclarator(td, hasUniform, boolDecl, explicitInputDecl, bools, explicitInputs, edits);
-                }
-
-                if (separateReadOnlyImages && hasUniform && fst.type_specifier() != null) {
-                    final String typeText = fst.type_specifier().getText();
-                    if (separateTextureType(typeText) != null) {
-                        needsSamplerless[0] = true;
-                    } else if (hasReadonly) {
-                        final String asTexture = separateTextureTypeForImage(typeText);
-                        if (asTexture != null) {
-                            needsSamplerless[0] = true;
-                            collectDeclaredNames(single, ctx, readOnlyImages);
-                            final String binding = bindingValue >= 0 ? "layout(binding = " + bindingValue + ") " : "";
-                            edits.add(new Edit(startIdx(fst), stopIdx(fst), binding + "uniform " + asTexture));
+            if (separateReadOnlyImages && hasUniform && fst.type_specifier() != null) {
+                final String typeText = fst.type_specifier().getText();
+                if (separateTextureType(typeText) != null) {
+                    needsSamplerless = true;
+                } else if (hasReadonly) {
+                    final String asTexture = separateTextureTypeForImage(typeText);
+                    if (asTexture != null) {
+                        needsSamplerless = true;
+                        for (GLSLParser.Typeless_declarationContext td : declarators) {
+                            if (td.IDENTIFIER() != null) readOnlyImages.add(td.IDENTIFIER().getText());
                        }
-                    }
-                }
-
-                if (isVertex && hasIn) {
-                    if (hasLocation && locValue >= 0) {
-                        if (locValue > maxExplicitLoc[0]) maxExplicitLoc[0] = locValue;
-                    } else if (!hasLocation) {
-                        unlocatedVsInputStarts.add(ctx.getStart().getStartIndex());
+                        final String binding = bindingValue >= 0 ? "layout(binding = " + bindingValue + ") " : "";
+                        edits.add(new Edit(startIdx(fst), stopIdx(fst), binding + "uniform " + asTexture));
                    }
                }
            }

-            @Override
-            public void enterPostfix_expression(GLSLParser.Postfix_expressionContext ctx) {
-                if (readOnlyImages.isEmpty() || ctx.LEFT_PAREN() == null || ctx.RIGHT_PAREN() == null) return;
-                final GLSLParser.Function_call_parametersContext params = ctx.function_call_parameters();
-                if (params == null || params.assignment_expression() == null || params.assignment_expression().isEmpty()) return;
-                if (!readOnlyImages.contains(params.assignment_expression(0).getText())) return;
-
-                final ParseTree callee = ctx.getChild(0);
-                if (!(callee instanceof ParserRuleContext calleeCtx)) return;
-                final String replacement = switch (calleeCtx.getText()) {
-                    case "imageLoad" -> "texelFetch";
-                    case "imageSize" -> "textureSize";
-                    default -> null;
-                };
-                if (replacement == null) return;
-
-                edits.add(new Edit(startIdx(calleeCtx), stopIdx(calleeCtx), replacement));
-                final int rparen = ctx.RIGHT_PAREN().getSymbol().getStartIndex();
-                edits.add(new Edit(rparen, rparen - 1, ", 0"));
-            }
-
-            @Override
-            public void visitTerminal(TerminalNode node) {
-                final Token tok = node.getSymbol();
-                if (tok.getType() != GLSLLexer.IDENTIFIER) return;
-                final String text = tok.getText();
-                switch (text) {
-                    case "sampler" -> edits.add(new Edit(tok.getStartIndex(), tok.getStopIndex(), SAMPLER_RENAMED));
-                    case "gl_VertexID" -> edits.add(new Edit(tok.getStartIndex(), tok.getStopIndex(), "gl_VertexIndex"));
-                    case "gl_InstanceID" -> edits.add(new Edit(tok.getStartIndex(), tok.getStopIndex(), "gl_InstanceIndex"));
-                    default -> {
-                        if (TARGET_RESERVED.contains(text)) edits.add(new Edit(tok.getStartIndex(), tok.getStopIndex(), RESERVED_RENAMED_PREFIX + text));
-                    }
+            if (isVertex && hasIn) {
+                if (hasLocation && locValue >= 0) {
+                    if (locValue > maxExplicitLoc) maxExplicitLoc = locValue;
+                } else if (!hasLocation) {
+                    unlocatedVsInputStarts.add(list.getStart().getStartIndex());
                }
            }
-        }, root);
-
-        if (needsSamplerless[0] && source != null) {
-            final int at = versionDirectiveEnd(source);
-            if (at >= 0) edits.add(new Edit(at, at - 1, "\n" + SAMPLERLESS_EXTENSION));
        }

-        if (maxExplicitLoc[0] >= 0 && !unlocatedVsInputStarts.isEmpty()) {
-            int next = maxExplicitLoc[0] + 1;
+        if (!readOnlyImages.isEmpty()) {
+            rewriteReadOnlyImageCalls(index.callsTo("imageLoad"), "texelFetch", readOnlyImages, edits);
+            rewriteReadOnlyImageCalls(index.callsTo("imageSize"), "textureSize", readOnlyImages, edits);
+        }
+        if (needsSamplerless) {
+            addSamplerlessExtension(index, edits);
+        }
+
+        for (var it = IDENTIFIER_RENAMES.object2ObjectEntrySet().fastIterator(); it.hasNext(); ) {
+            final var rename = it.next();
+            rename(index, rename.getKey(), rename.getValue(), edits);
+        }
+
+        if (maxExplicitLoc >= 0 && !unlocatedVsInputStarts.isEmpty()) {
+            int next = maxExplicitLoc + 1;
            int dropped = 0;
            for (int start : unlocatedVsInputStarts) {
                if (next >= MAX_VS_INPUT_LOCATIONS) { dropped++; continue; }
@@ -245,22 +223,74 @@ public final class GlslVulkanPreprocess {
            }
        }

-        return new Metadata(bools, explicitInputs, needsSamplerless[0]);
+        return new Metadata(bools, explicitInputs, needsSamplerless);
+    }
+
+    public static boolean renamesIdentifier(String name) {
+        return IDENTIFIER_RENAMES.containsKey(name);
+    }
+
+    public static void addSamplerlessExtension(ShaderIndex index, List<Edit> edits) {
+        final int versionEnd = index.directives().versionEnd();
+        if (versionEnd >= 0) edits.add(new Edit(versionEnd, versionEnd - 1, "\n" + SAMPLERLESS_EXTENSION));
+    }
+
+    private static void rename(ShaderIndex index, String name, String replacement, List<Edit> edits) {
+        for (Token tok : index.occurrences(name)) edits.add(new Edit(tok.getStartIndex(), tok.getStopIndex(), replacement));
+    }
+
+    static @Nullable String renameUserFunctions(String source) {
+        final GLSLParser.Translation_unitContext root;
+        try {
+            root = GlslTransformUtils.parseFullQuiet(source);
+        } catch (Exception e) {
+            return null;
+        }
+
+        Object2IntOpenHashMap<String> prototypes = null;
+        for (GLSLParser.External_declarationContext external : root.external_declaration()) {
+            final GLSLParser.Function_definitionContext function = external.function_definition();
+            final GLSLParser.DeclarationContext declaration = function == null ? external.declaration() : null;
+            final GLSLParser.Function_prototypeContext prototype = function != null ? function.function_prototype() : declaration != null ? declaration.function_prototype() : null;
+            final TerminalNode identifier = prototype == null ? null : prototype.IDENTIFIER();
+            if (identifier == null) continue;
+            final String name = identifier.getText();
+            if ("main".equals(name)) continue;
+            if (prototypes == null) prototypes = new Object2IntOpenHashMap<>();
+            prototypes.addTo(name, 1);
+        }
+        if (prototypes == null) return null;
+
+        final ShaderIndex index = new ShaderIndex(root, source);
+        final Set<String> inDirectives = index.directives().identifiers();
+        final List<Edit> edits = new ArrayList<>();
+        for (Object2IntMap.Entry<String> prototype : prototypes.object2IntEntrySet()) {
+            final String name = prototype.getKey();
+            if (inDirectives.contains(name)) continue;
+            if (index.occurrences(name).size() != prototype.getIntValue() + index.callsTo(name).size()) continue;
+            rename(index, name, RESERVED_RENAMED_PREFIX + name, edits);
+        }
+        return edits.isEmpty() ? null : applyEdits(source, edits);
+    }
+
+    private static void rewriteReadOnlyImageCalls(List<GLSLParser.Postfix_expressionContext> calls, String replacement, Set<String> readOnlyImages, List<Edit> edits) {
+        for (GLSLParser.Postfix_expressionContext call : calls) {
+            if (call.RIGHT_PAREN() == null) continue;
+            final GLSLParser.Function_call_parametersContext params = call.function_call_parameters();
+            if (params == null || params.assignment_expression().isEmpty()) continue;
+            if (!readOnlyImages.contains(params.assignment_expression(0).getText())) continue;
+
+            final ParserRuleContext callee = (ParserRuleContext) call.getChild(0);
+            edits.add(new Edit(startIdx(callee), stopIdx(callee), replacement));
+            final int rparen = call.RIGHT_PAREN().getSymbol().getStartIndex();
+            edits.add(new Edit(rparen, rparen - 1, ", 0"));
+        }
    }

    public static void clearCache() {
        synchronized (CACHE) { CACHE.clear(); }
    }

-    private static void collectDeclaredNames(GLSLParser.Single_declarationContext single, GLSLParser.Init_declarator_listContext ctx, Set<String> out) {
-        if (single.typeless_declaration() != null && single.typeless_declaration().IDENTIFIER() != null) {
-            out.add(single.typeless_declaration().IDENTIFIER().getText());
-        }
-        for (GLSLParser.Typeless_declarationContext td : ctx.typeless_declaration()) {
-            if (td.IDENTIFIER() != null) out.add(td.IDENTIFIER().getText());
-        }
-    }
-
    private static @Nullable String separateTextureTypeForImage(String typeText) {
        final String dim = switch (typeText) {
            case "image1D", "iimage1D", "uimage1D" -> "1D";
@@ -281,26 +311,6 @@ public final class GlslVulkanPreprocess {
        };
    }

-    private static int versionDirectiveEnd(String source) {
-        final GLSLPreParser.Translation_unitContext pre;
-        try {
-            pre = GlslTransformUtils.parsePreQuiet(source);
-        } catch (Exception e) {
-            return -1;
-        }
-        final GLSLPreParser.Version_directiveContext ctx = firstVersionDirective(pre);
-        return ctx == null || ctx.getStop() == null ? -1 : ctx.getStop().getStopIndex() + 1;
-    }
-
-    private static GLSLPreParser.@Nullable Version_directiveContext firstVersionDirective(ParseTree node) {
-        if (node instanceof GLSLPreParser.Version_directiveContext v) return v;
-        for (int i = 0; i < node.getChildCount(); i++) {
-            final GLSLPreParser.Version_directiveContext found = firstVersionDirective(node.getChild(i));
-            if (found != null) return found;
-        }
-        return null;
-    }
-
    private static void handleDeclarator(GLSLParser.Typeless_declarationContext td, boolean hasUniform, boolean asBool, boolean asInput, Set<String> bools, Set<String> inputs, List<Edit> edits) {
        if (td.IDENTIFIER() == null) return;
        final String name = td.IDENTIFIER().getText();
@@ -0,0 +1,255 @@
+package com.gtnewhorizons.angelica.glsm.shader;
+
+import com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities;
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.RenderSystem;
+import com.gtnewhorizons.angelica.glsm.ffp.ShaderManager;
+import com.gtnewhorizons.angelica.glsm.threading.AngelicaWorkers;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.Nullable;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL20;
+import org.lwjgl.opengl.GL41;
+
+import java.nio.ByteBuffer;
+import java.nio.IntBuffer;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
+
+/**
+ * Saves linked GL programs to disk and loads them back with glProgramBinary, skipping compile and link.
+ */
+public final class ProgramBinaryCache {
+    private static final Logger LOGGER = LogManager.getLogger("ProgramBinaryCache");
+    static final String LAYER = "gl-program";
+    private static final int PACKS_KEPT = 3;
+
+    private static volatile boolean enabled;
+    private static volatile String packLayer;
+    private static String driverId;
+    private static String fullCompileLayer;
+    private static Set<String> keysInUse;
+    private static List<CompletableFuture<Boolean>> fullCompileWrites;
+    private static Object fullCompileGeneration;
+    private static final AtomicBoolean rejectWarned = new AtomicBoolean();
+    private static final Object WRITE_LOCK = new Object();
+    private static final Map<String, Object> compileGenerations = new HashMap<>();
+    private static int deleteCount;
+
+    private ProgramBinaryCache() {}
+
+    public static void setEnabled(boolean value) {
+        enabled = value;
+    }
+
+    public static boolean isEnabled() {
+        return enabled && packLayer != null && RenderSystem.supportsProgramBinary() && ShaderDiskCache.isEnabled();
+    }
+
+    public static void usePack(String packName) {
+        if (packName == null) {
+            packLayer = null;
+            return;
+        }
+        final String layer = LAYER + '/' + folderName(packName);
+        packLayer = layer;
+        if (!enabled) return;
+        ShaderDiskCache.touchLayer(layer);
+        AngelicaWorkers.run(() -> ShaderDiskCache.keepNewestSubLayers(LAYER, PACKS_KEPT));
+    }
+
+    public static Key key() {
+        return new Key(ShaderDiskCache.key(packLayer).str(driverId()).b(ShaderManager.isEnabled()));
+    }
+
+    public static void markRetrievable(int program) {
+        GLStateManager.glProgramParameteri(program, GL41.GL_PROGRAM_BINARY_RETRIEVABLE_HINT, GL11.GL_TRUE);
+    }
+
+    public static int load(Key key) {
+        final ShaderDiskCache.Key diskKey = key.diskKey;
+        final ShaderDiskCache.Blob blob = ShaderDiskCache.getBlob(diskKey);
+        if (blob == null) return 0;
+        final int format;
+        try {
+            format = Integer.parseInt(blob.tag());
+        } catch (NumberFormatException e) {
+            ShaderDiskCache.remove(diskKey);
+            return 0;
+        }
+        final int program = GLStateManager.glCreateProgram();
+        final ByteBuffer data = MemoryUtilities.memAlloc(blob.data().length);
+        try {
+            data.put(blob.data()).flip();
+            GLStateManager.glProgramBinary(program, format, data);
+        } finally {
+            MemoryUtilities.memFree(data);
+        }
+        if (GLStateManager.glGetProgrami(program, GL20.GL_LINK_STATUS) != GL11.GL_TRUE) {
+            GLStateManager.glDeleteProgram(program);
+            ShaderDiskCache.remove(diskKey);
+            if (rejectWarned.compareAndSet(false, true)) LOGGER.error("Driver rejected a saved shader program!! Recompiling rejected programs from source");
+            return 0;
+        }
+        keep(diskKey);
+        return program;
+    }
+
+    public static void save(Key key, int program) {
+        if (!saveBinary(key, program) && fullCompileWrites != null) {
+            fullCompileWrites.add(CompletableFuture.completedFuture(false));
+        }
+    }
+
+    private static boolean saveBinary(Key key, int program) {
+        final int length = GLStateManager.glGetProgrami(program, GL41.GL_PROGRAM_BINARY_LENGTH);
+        if (length <= 0) return false;
+        final ByteBuffer data = MemoryUtilities.memAlloc(length);
+        final IntBuffer written = MemoryUtilities.memAllocInt(1);
+        final IntBuffer format = MemoryUtilities.memAllocInt(1);
+        try {
+            GLStateManager.glGetProgramBinary(program, written, format, data);
+            if (written.get(0) <= 0) return false;
+            data.limit(written.get(0));
+            final byte[] binary = ShaderCacheIO.toHeap(data);
+            final String formatTag = Integer.toString(format.get(0));
+            final ShaderDiskCache.Key diskKey = key.diskKey;
+            keep(diskKey);
+            final int deletesBefore;
+            synchronized (WRITE_LOCK) {
+                deletesBefore = deleteCount;
+            }
+            final CompletableFuture<Boolean> write = AngelicaWorkers.submit(() -> {
+                synchronized (WRITE_LOCK) {
+                    return deletesBefore == deleteCount && ShaderDiskCache.putBlob(diskKey, formatTag, binary);
+                }
+            });
+            final List<CompletableFuture<Boolean>> writes = fullCompileWrites;
+            if (writes != null) writes.add(write);
+            return true;
+        } finally {
+            MemoryUtilities.memFree(data);
+            MemoryUtilities.memFree(written);
+            MemoryUtilities.memFree(format);
+        }
+    }
+
+    public static boolean isFullCompileRunning() {
+        return keysInUse != null;
+    }
+
+    public static boolean saveRetained(Key key, int program) {
+        if (ShaderDiskCache.getBlob(key.diskKey) != null) {
+            keep(key.diskKey);
+            return true;
+        }
+        return saveBinary(key, program);
+    }
+
+    public static void beginFullCompile() {
+        fullCompileLayer = packLayer;
+        keysInUse = new HashSet<>();
+        fullCompileWrites = new ArrayList<>();
+        synchronized (WRITE_LOCK) {
+            fullCompileGeneration = new Object();
+            if (fullCompileLayer != null) compileGenerations.put(fullCompileLayer, fullCompileGeneration);
+        }
+    }
+    public static void finishFullCompile(@Nullable String completedSettings) {
+        final String layer = fullCompileLayer;
+        final Set<String> used = keysInUse;
+        final List<CompletableFuture<Boolean>> writes = fullCompileWrites;
+        final Object generation = fullCompileGeneration;
+        fullCompileLayer = null;
+        keysInUse = null;
+        fullCompileWrites = null;
+        fullCompileGeneration = null;
+        if (layer == null || used == null || writes == null) return;
+
+        final ShaderDiskCache.Key marker = completedSettings != null ? compiledSettingsKey(layer, completedSettings) : null;
+        final String markerHex = marker != null ? marker.hex() : null;
+        CompletableFuture.allOf(writes.toArray(new CompletableFuture<?>[0])).whenComplete((ignored, failure) -> {
+            synchronized (WRITE_LOCK) {
+                if (compileGenerations.get(layer) != generation) return;
+                if (marker == null || failure != null) return;
+                for (CompletableFuture<Boolean> write : writes) {
+                    if (!write.join()) return;
+                }
+                ShaderDiskCache.retainLayer(layer, used);
+                ShaderDiskCache.retainLayer(layer + "/settings", Collections.singleton(markerHex));
+                ShaderDiskCache.putString(marker, "");
+            }
+        });
+    }
+
+    public static void deleteAll() {
+        synchronized (WRITE_LOCK) {
+            deleteCount++;
+            compileGenerations.clear();
+            ShaderDiskCache.deleteLayer(LAYER);
+        }
+    }
+
+    public static boolean wasCompiledFor(String settings) {
+        final String layer = packLayer;
+        return layer != null && ShaderDiskCache.getString(compiledSettingsKey(layer, settings)) != null;
+    }
+
+    private static ShaderDiskCache.Key compiledSettingsKey(String layer, String settings) {
+        return ShaderDiskCache.key(layer + "/settings").str(driverId()).b(ShaderManager.isEnabled()).str(settings);
+    }
+
+    private static String folderName(String packName) {
+        final StringBuilder name = new StringBuilder(Math.min(packName.length(), 64));
+        for (int i = 0; i < packName.length() && name.length() < 64; i++) {
+            final char c = packName.charAt(i);
+            name.append(c < 128 && (Character.isLetterOrDigit(c) || c == '.' || c == '-' || c == '_') ? c : '_');
+        }
+        return name.toString();
+    }
+
+    private static void keep(ShaderDiskCache.Key diskKey) {
+        final String hex = diskKey.hex();
+        final Set<String> used = keysInUse;
+        if (used != null) used.add(hex);
+    }
+
+    private static String driverId() {
+        String id = driverId;
+        if (id == null) {
+            id = RENDER_BACKEND.getString(GL11.GL_VENDOR) + '|' + RENDER_BACKEND.getString(GL11.GL_RENDERER) + '|'
+                + RENDER_BACKEND.getString(GL11.GL_VERSION) + '|' + RENDER_BACKEND.getString(GL20.GL_SHADING_LANGUAGE_VERSION) + '|'
+                + RenderSystem.isGLES() + '|' + RENDER_BACKEND.getMinGLSLVersion();
+            driverId = id;
+        }
+        return id;
+    }
+
+    public static final class Key {
+        private final ShaderDiskCache.Key diskKey;
+
+        private Key(ShaderDiskCache.Key diskKey) {
+            this.diskKey = diskKey;
+        }
+
+        public Key stage(int shaderType, String source) {
+            diskKey.str("stage").i(shaderType).str(source);
+            return this;
+        }
+
+        public Key attribute(String name, int index) {
+            diskKey.str("attribute").str(name).i(index);
+            return this;
+        }
+    }
+}
@@ -19,14 +19,18 @@ import java.nio.file.SimpleFileVisitor;
 import java.nio.file.StandardCopyOption;
 import java.nio.file.StandardOpenOption;
 import java.nio.file.attribute.BasicFileAttributes;
+import java.nio.file.attribute.FileTime;
 import java.security.MessageDigest;
 import java.security.NoSuchAlgorithmException;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Stream;
@@ -49,7 +53,10 @@ public final class ShaderDiskCache {

    private ShaderDiskCache() {}

-    public static void configure(Path dir, String salt) {
+    private static String configuredSalt;
+
+    public static synchronized void configure(Path dir, String salt) {
+        if (dir.equals(root) && salt.equals(configuredSalt)) return;
        try {
            Files.createDirectories(dir);
            final Path saltFile = dir.resolve("salt");
@@ -59,6 +66,7 @@ public final class ShaderDiskCache {
                Files.write(saltFile, salt.getBytes(StandardCharsets.UTF_8));
            }
            root = dir;
+            configuredSalt = salt;
            AngelicaWorkers.run(() -> enforceCap(dir, MAX_BYTES));
            LOGGER.info("Shader disk cache at {}", dir);
        } catch (IOException | RuntimeException e) {
@@ -116,9 +124,9 @@ public final class ShaderDiskCache {
        }
    }

-    public static void put(Key key, byte[] payload) {
+    public static boolean put(Key key, byte[] payload) {
        final Path r = root;
-        if (r == null) return;
+        if (r == null) return false;
        final Path target = key.path(r);
        final Path tmp = target.resolveSibling(key.hex() + '.' + TMP_SEQ.getAndIncrement() + ".tmp");
        try {
@@ -129,11 +137,13 @@ public final class ShaderDiskCache {
                write(tmp, payload);
            }
            Files.move(tmp, target, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+            return true;
        } catch (IOException e) {
            try {
                Files.deleteIfExists(tmp);
            } catch (IOException ignored) {}
            if (writeWarned.compareAndSet(false, true)) LOGGER.warn("Shader disk cache write failed for {}", target, e);
+            return false;
        }
    }

@@ -202,7 +212,7 @@ public final class ShaderDiskCache {
        }
    }

-    public static void putBlob(Key key, String tag, byte[] data) {
+    public static boolean putBlob(Key key, String tag, byte[] data) {
        final ByteArrayOutputStream bytes = new ByteArrayOutputStream(data.length + 64);
        try (DataOutputStream out = new DataOutputStream(bytes)) {
            writeStr(out, tag);
@@ -210,11 +220,101 @@ public final class ShaderDiskCache {
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
-        put(key, bytes.toByteArray());
+        return put(key, bytes.toByteArray());
    }

    public record Blob(String tag, byte[] data) {}

+    public static void remove(Key key) {
+        final Path r = root;
+        if (r == null) return;
+        try {
+            Files.deleteIfExists(key.path(r));
+        } catch (IOException ignored) {}
+    }
+
+    public static void retainLayer(String layer, Set<String> keep) {
+        final Path r = root;
+        if (r == null) return;
+        final Path dir = r.resolve(layer);
+        if (!Files.isDirectory(dir)) return;
+        final List<Path> files = new ArrayList<>();
+        try (Stream<Path> list = Files.list(dir)) {
+            list.forEach(files::add);
+        } catch (IOException e) {
+            LOGGER.warn("Shader disk cache could not list {}", dir, e);
+            return;
+        }
+        for (Path p : files) {
+            final String name = p.getFileName().toString();
+            if (!name.endsWith(".bin")) continue; // in-flight writes are still .tmp
+            if (keep != null && keep.contains(name.substring(0, name.length() - 4))) continue;
+            try {
+                Files.deleteIfExists(p);
+            } catch (IOException ignored) {}
+        }
+    }
+
+    public static void touchLayer(String layer) {
+        final Path r = root;
+        if (r == null) return;
+        final Path dir = r.resolve(layer);
+        try {
+            Files.createDirectories(dir);
+            Files.setLastModifiedTime(dir, FileTime.fromMillis(System.currentTimeMillis()));
+        } catch (IOException e) {
+            LOGGER.warn("Shader disk cache could not mark {} as used", dir, e);
+        }
+    }
+
+    public static void keepNewestSubLayers(String layer, int keep) {
+        final Path r = root;
+        if (r == null) return;
+        final Path dir = r.resolve(layer);
+        if (!Files.isDirectory(dir)) return;
+        final List<Path> subLayers = new ArrayList<>();
+        try (Stream<Path> list = Files.list(dir)) {
+            list.filter(Files::isDirectory).forEach(subLayers::add);
+        } catch (IOException e) {
+            LOGGER.warn("Shader disk cache could not list {}", dir, e);
+            return;
+        }
+        subLayers.sort(Comparator.comparingLong(ShaderDiskCache::lastModifiedMillis).reversed());
+        for (int i = keep; i < subLayers.size(); i++) {
+            deleteRecursively(subLayers.get(i));
+        }
+    }
+
+    public static void deleteLayer(String layer) {
+        final Path r = root;
+        if (r != null) deleteRecursively(r.resolve(layer));
+    }
+
+    private static long lastModifiedMillis(Path path) {
+        try {
+            return Files.getLastModifiedTime(path).toMillis();
+        } catch (IOException e) {
+            return 0L;
+        }
+    }
+
+    private static void deleteRecursively(Path dir) {
+        if (!Files.exists(dir)) return;
+        final List<Path> paths = new ArrayList<>();
+        try (Stream<Path> walk = Files.walk(dir)) {
+            walk.forEach(paths::add);
+        } catch (IOException e) {
+            LOGGER.warn("Shader disk cache could not list {}", dir, e);
+            return;
+        }
+        Collections.reverse(paths);
+        for (Path p : paths) {
+            try {
+                Files.deleteIfExists(p);
+            } catch (IOException ignored) {}
+        }
+    }
+
    static void enforceCap(Path dir, long maxBytes) {
        try {
            final long[] total = {0};
@@ -0,0 +1,160 @@
+package com.gtnewhorizons.angelica.glsm.shader;
+
+import com.gtnewhorizons.angelica.glsm.GlslTransformUtils;
+import org.antlr.v4.runtime.ParserRuleContext;
+import org.antlr.v4.runtime.Token;
+import org.antlr.v4.runtime.tree.ParseTree;
+import org.antlr.v4.runtime.tree.TerminalNode;
+import org.jetbrains.annotations.Nullable;
+import org.taumc.glsl.grammar.GLSLLexer;
+import org.taumc.glsl.grammar.GLSLParser;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * What the source passes look up in a parsed shader.
+ */
+public final class ShaderIndex {
+
+    public record Directives(Set<String> identifiers, Set<String> definedMacros, boolean hasConditionalOrMacro, int versionEnd) {
+        private static final Directives NONE = new Directives(Set.of(), Set.of(), false, -1);
+    }
+
+    private final GLSLParser.Translation_unitContext root;
+    private final String source;
+    private final Map<String, List<Token>> identifiers = new HashMap<>();
+    private final Map<String, List<GLSLParser.Postfix_expressionContext>> calls = new HashMap<>();
+    private final List<GLSLParser.DeclarationContext> globalDeclarations = new ArrayList<>();
+    private @Nullable Directives directives;
+
+    public ShaderIndex(GLSLParser.Translation_unitContext root, String source) {
+        this.root = root;
+        this.source = source;
+        collect(root);
+        for (GLSLParser.External_declarationContext external : root.external_declaration()) {
+            if (external.declaration() != null) globalDeclarations.add(external.declaration());
+        }
+    }
+
+    private void collect(ParseTree node) {
+        if (node instanceof TerminalNode terminal) {
+            final Token token = terminal.getSymbol();
+            if (token.getType() == GLSLLexer.IDENTIFIER) identifiers.computeIfAbsent(token.getText(), k -> new ArrayList<>(2)).add(token);
+            return;
+        }
+        if (node instanceof GLSLParser.Postfix_expressionContext p && p.LEFT_PAREN() != null) {
+            calls.computeIfAbsent(calleeName(p), k -> new ArrayList<>(2)).add(p);
+        }
+        for (int i = 0, n = node.getChildCount(); i < n; i++) collect(node.getChild(i));
+    }
+
+    public GLSLParser.Translation_unitContext root() {
+        return root;
+    }
+
+    public String source() {
+        return source;
+    }
+
+    public List<Token> occurrences(String name) {
+        return identifiers.getOrDefault(name, List.of());
+    }
+
+    public List<GLSLParser.Postfix_expressionContext> callsTo(String name) {
+        return calls.getOrDefault(name, List.of());
+    }
+
+    public List<GLSLParser.DeclarationContext> globalDeclarations() {
+        return globalDeclarations;
+    }
+
+    /** Lexes the source on first use. */
+    public Directives directives() {
+        if (directives == null) directives = scanDirectives(source);
+        return directives;
+    }
+
+    private static Directives scanDirectives(String source) {
+        if (source.indexOf('#') < 0) return Directives.NONE;
+        final GLSLLexer lexer = GlslTransformUtils.quietLexer(source);
+        final Set<String> names = new HashSet<>();
+        final Set<String> macros = new HashSet<>();
+        boolean conditionalOrMacro = false;
+        int versionEnd = -1;
+        boolean inVersion = false;
+        for (Token token = lexer.nextToken(); token.getType() != Token.EOF; token = lexer.nextToken()) {
+            final int type = token.getType();
+            if (type == GLSLLexer.VERSION_DIRECTIVE && versionEnd < 0) {
+                inVersion = true;
+                versionEnd = token.getStopIndex() + 1;
+                continue;
+            }
+            if (inVersion && (type == GLSLLexer.NUMBER || type == GLSLLexer.PROFILE)) {
+                versionEnd = token.getStopIndex() + 1;
+                continue;
+            }
+            inVersion = false;
+            switch (type) {
+                case GLSLLexer.PROGRAM_TEXT, GLSLLexer.MACRO_TEXT, GLSLLexer.CONSTANT_EXPRESSION -> collectIdentifiers(token.getText(), names);
+                case GLSLLexer.MACRO_NAME -> macros.add(leadingIdentifier(token.getText()));
+                case GLSLLexer.IF_DIRECTIVE, GLSLLexer.IFDEF_DIRECTIVE, GLSLLexer.IFNDEF_DIRECTIVE, GLSLLexer.DEFINE_DIRECTIVE -> conditionalOrMacro = true;
+                default -> { }
+            }
+        }
+        return new Directives(names, macros, conditionalOrMacro, versionEnd);
+    }
+
+    private static String leadingIdentifier(String text) {
+        final int args = text.indexOf('(');
+        return args < 0 ? text : text.substring(0, args);
+    }
+
+    private static void collectIdentifiers(String text, Set<String> out) {
+        if (text == null) return;
+        final int len = text.length();
+        int i = 0;
+        while (i < len) {
+            final char c = text.charAt(i);
+            if (c != '_' && !Character.isLetter(c)) {
+                i++;
+                continue;
+            }
+            int end = i + 1;
+            while (end < len) {
+                final char n = text.charAt(end);
+                if (n != '_' && !Character.isLetterOrDigit(n)) break;
+                end++;
+            }
+            out.add(text.substring(i, end));
+            i = end;
+        }
+    }
+
+    public static String calleeName(GLSLParser.Postfix_expressionContext call) {
+        final ParseTree callee = call.getChild(0);
+        return callee instanceof ParserRuleContext ? callee.getText() : "";
+    }
+
+    public static List<GLSLParser.Typeless_declarationContext> declarators(GLSLParser.Init_declarator_listContext list) {
+        final GLSLParser.Single_declarationContext single = list.single_declaration();
+        final List<GLSLParser.Typeless_declarationContext> rest = list.typeless_declaration();
+        if (single == null || single.typeless_declaration() == null) return rest;
+        final List<GLSLParser.Typeless_declarationContext> all = new ArrayList<>(rest.size() + 1);
+        all.add(single.typeless_declaration());
+        all.addAll(rest);
+        return all;
+    }
+
+    public static boolean hasStorageQualifier(@Nullable GLSLParser.Type_qualifierContext qualifier, String keyword) {
+        if (qualifier == null) return false;
+        for (GLSLParser.Single_type_qualifierContext q : qualifier.single_type_qualifier()) {
+            if (q.storage_qualifier() != null && keyword.equals(q.storage_qualifier().getText())) return true;
+        }
+        return false;
+    }
+}
@@ -81,7 +81,16 @@ public final class SpirvCompiler {
            }
        }

-        final Result result = compileUncached(cleanSrc, shaderKind, debugName, opts);
+        Result result = compileUncached(cleanSrc, shaderKind, debugName, opts);
+        if (result.spirv() == null) {
+            final String renamed = GlslVulkanPreprocess.renameUserFunctions(cleanSrc);
+            final Result retry = renamed == null ? null : compileUncached(renamed, shaderKind, debugName, opts);
+            if (retry == null || retry.spirv() == null) {
+                return new Result(null, result.error(), writeFailureDump(debugName, shaderKind, result.error(), cleanSrc));
+            }
+            LOGGER.info("'{}' compiled after renaming its functions; shaderc rejected the original: {}", debugName, result.error());
+            result = retry;
+        }
        final ByteBuffer spirv = result.spirv();
        if (spirv != null) {
            final byte[] heap = ShaderCacheIO.toHeap(spirv);
@@ -121,8 +130,7 @@ public final class SpirvCompiler {
                final int status = Shaderc.shaderc_result_get_compilation_status(result);
                if (status != Shaderc.shaderc_compilation_status_success) {
                    final String msg = Shaderc.shaderc_result_get_error_message(result);
-                    final Path dumpPath = writeFailureDump(debugName, shaderKind, msg, cleanSrc);
-                    return new Result(null, msg == null ? "(no error message)" : msg, dumpPath);
+                    return new Result(null, msg == null ? "(no error message)" : msg, null);
                }
                final ByteBuffer spirv = Shaderc.shaderc_result_get_bytes(result);
                if (spirv == null || spirv.remaining() == 0) {
@@ -47,14 +47,6 @@ public final class SpirvShaderTranslator {
    private SpirvShaderTranslator() {}

    public static @Nullable String glslToGlslEs(String source, int glShaderType, String debugName) {
-        return glslToGlslEsImpl(source, glShaderType, debugName, false);
-    }
-
-    static @Nullable String glslToGlslEsRawForTest(String source, int glShaderType, String debugName) {
-        return glslToGlslEsImpl(source, glShaderType, debugName, true);
-    }
-
-    private static @Nullable String glslToGlslEsImpl(String source, int glShaderType, String debugName, boolean rawOutput) {
        final int shaderKind = shaderKindForGlType(glShaderType);
        if (shaderKind < 0) {
            LOGGER.warn("Unknown GL shader type 0x{} for '{}' - skipping SPIR-V translation", Integer.toHexString(glShaderType), debugName);
@@ -67,14 +59,13 @@ public final class SpirvShaderTranslator {
        final SpirvCompiler.Result cr = SpirvCompiler.compile(pre.rewrittenSource(), shaderKind, debugName, SpirvCompiler.Options.vulkanRelaxed());
        if (cr.spirv() == null) {
            final String firstErr = cr.error() == null ? "(no error)" : cr.error().split("\\R", 2)[0];
-            LOGGER.error("shaderc failed for '{}' (kind=0x{}): {} (dumped to {})",
-                    debugName, Integer.toHexString(shaderKind), firstErr, cr.dumpPath() == null ? "<dump failed>" : cr.dumpPath());
+            LOGGER.error("shaderc failed for '{}' (kind=0x{}): {} (dumped to {})", debugName, Integer.toHexString(shaderKind), firstErr, cr.dumpPath() == null ? "<dump failed>" : cr.dumpPath());
            return null;
        }
        try {
            final String emitted = emitGlslEs(cr.spirv(), debugName, glShaderType, pre.explicitVsInputs());
            if (emitted == null) return null;
-            return rawOutput ? emitted : postProcessEsOutput(emitted, pre.boolUniforms());
+            return postProcessEsOutput(emitted, pre.boolUniforms());
        } finally {
            memFree(cr.spirv());
        }
@@ -163,16 +154,7 @@ public final class SpirvShaderTranslator {
            final GLSLParser.Single_declarationContext single = ctx.single_declaration();
            if (single == null || single.typeless_declaration() == null) return;
            final GLSLParser.Fully_specified_typeContext fst = single.fully_specified_type();
-            if (fst == null || fst.type_qualifier() == null) return;
-
-            boolean isUniform = false;
-            for (GLSLParser.Single_type_qualifierContext stq : fst.type_qualifier().single_type_qualifier()) {
-                if (stq.storage_qualifier() != null && "uniform".equals(stq.storage_qualifier().getText())) {
-                    isUniform = true;
-                    break;
-                }
-            }
-            if (!isUniform) return;
+            if (fst == null || !ShaderIndex.hasStorageQualifier(fst.type_qualifier(), "uniform")) return;

            if (fst.type_specifier() == null || fst.type_specifier().type_specifier_nonarray() == null) return;
            final GLSLParser.Type_specifier_nonarrayContext ts = fst.type_specifier().type_specifier_nonarray();
@@ -14,8 +14,8 @@ public final class AlphaStateStack extends AlphaState implements CowStateStack<A

    public AlphaStateStack(int id) {
        cow.id = id;
-        stack = new AlphaState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new AlphaState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new AlphaState();
        }
    }
@@ -25,6 +25,11 @@ public final class AlphaStateStack extends AlphaState implements CowStateStack<A
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return VanillaStateLayer.isHeld(vanillaLayer) || !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        VanillaStateLayer.capture(vanillaLayer, stack[s].set(this));
@@ -17,8 +17,8 @@ public final class BlendStateStack extends BlendState implements CowStateStack<B

    public BlendStateStack(int id) {
        cow.id = id;
-        stack = new BlendState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new BlendState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new BlendState();
        }
    }
@@ -28,6 +28,11 @@ public final class BlendStateStack extends BlendState implements CowStateStack<B
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return funcUnknown || VanillaStateLayer.isHeld(vanillaLayer) || !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        VanillaStateLayer.capture(vanillaLayer, stack[s].set(this));
@@ -44,7 +44,7 @@ public class BooleanStateStack extends BooleanState implements CowStateStack<Boo
    public BooleanStateStack(int glCap, boolean initialState, boolean ffpStateOnly) {
        super(glCap, ffpStateOnly);
        this.enabled = initialState;
-        stack = new boolean[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
+        stack = new boolean[GLStateManager.STATE_SLOTS];
    }

    @Override
@@ -52,6 +52,11 @@ public class BooleanStateStack extends BooleanState implements CowStateStack<Boo
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return stateUnknown || (vanillaLayer != null && vanillaLayer.isOverrideHeld()) || enabled != stack[slot];
+    }
+
    @Override
    public void captureSlot(int slot) {
        stack[slot] = vanillaValue();
@@ -10,8 +10,8 @@ public final class Color4Stack extends Color4 implements CowStateStack<Color4Sta

    public Color4Stack(int id) {
        cow.id = id;
-        stack = new Color4[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new Color4[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new Color4();
        }
    }
@@ -33,6 +33,11 @@ public final class Color4Stack extends Color4 implements CowStateStack<Color4Sta
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -15,8 +15,8 @@ public final class ColorMaskStack extends ColorMask implements CowStateStack<Col

    public ColorMaskStack(int id) {
        cow.id = id;
-        stack = new ColorMask[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new ColorMask[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new ColorMask();
        }
    }
@@ -26,6 +26,11 @@ public final class ColorMaskStack extends ColorMask implements CowStateStack<Col
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return VanillaStateLayer.isHeld(vanillaLayer) || !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        VanillaStateLayer.capture(vanillaLayer, stack[s].set(this));
@@ -101,6 +101,36 @@ public final class CowDispatch {
        };
    }

+    public static boolean slotChanged(byte kind, CowStateStack<?> s, int slot) {
+        return switch (kind) {
+            case BLEND -> ((BlendStateStack) s).slotChanged(slot);
+            case BOOLEAN -> ((BooleanStateStack) s).slotChanged(slot);
+            case CLIP_PLANE_BOOLEAN -> ((ClipPlaneBooleanState) s).slotChanged(slot);
+            case TEXTURE_UNIT_BOOLEAN -> ((TextureUnitBooleanStateStack) s).slotChanged(slot);
+            case COLOR_MASK -> ((ColorMaskStack) s).slotChanged(slot);
+            case LIGHT_STATE -> ((LightStateStack) s).slotChanged(slot);
+            case MATERIAL -> ((MaterialStateStack) s).slotChanged(slot);
+            case STENCIL -> ((StencilStateStack) s).slotChanged(slot);
+            case MATRIX_MODE -> ((MatrixModeStack) s).slotChanged(slot);
+            case LIGHT_MODEL -> ((LightModelStateStack) s).slotChanged(slot);
+            case ALPHA -> ((AlphaStateStack) s).slotChanged(slot);
+            case POINT -> ((PointStateStack) s).slotChanged(slot);
+            case FOG -> ((FogStateStack) s).slotChanged(slot);
+            case VEC4F -> ((Vec4fStack) s).slotChanged(slot);
+            case VEC3F -> ((Vec3fStack) s).slotChanged(slot);
+            case INTEGER -> ((IntegerStateStack) s).slotChanged(slot);
+            case DEPTH -> ((DepthStateStack) s).slotChanged(slot);
+            case VIEWPORT -> ((ViewPortStateStack) s).slotChanged(slot);
+            case POLYGON -> ((PolygonStateStack) s).slotChanged(slot);
+            case COLOR4 -> ((Color4Stack) s).slotChanged(slot);
+            case LINE -> ((LineStateStack) s).slotChanged(slot);
+            case TEXTURE_BINDING -> ((TextureBindingStack) s).slotChanged(slot);
+            case TEX_ENV -> ((TexEnvState) s).slotChanged(slot);
+            case SCISSOR -> ((ScissorStateStack) s).slotChanged(slot);
+            default -> throw new IllegalStateException("Unknown kind: " + kind);
+        };
+    }
+
    public static void restoreSlot(byte kind, CowStateStack<?> s, int slot) {
        switch (kind) {
            case BLEND -> ((BlendStateStack) s).restoreSlot(slot);
@@ -20,6 +20,8 @@ public interface CowStateStack<T> extends IStateStack<T> {

    void restoreSlot(int slot);

+    boolean slotChanged(int slot);
+
    default int stackId() {
        return cowDepths().id;
    }
@@ -17,8 +17,8 @@ public final class DepthStateStack extends DepthState implements CowStateStack<D

    public DepthStateStack(int id) {
        cow.id = id;
-        stack = new DepthState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new DepthState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new DepthState();
        }
    }
@@ -28,6 +28,11 @@ public final class DepthStateStack extends DepthState implements CowStateStack<D
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return VanillaStateLayer.isHeld(vanillaLayer) || !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        VanillaStateLayer.capture(vanillaLayer, stack[s].set(this));
@@ -10,8 +10,8 @@ public final class FogStateStack extends FogState implements CowStateStack<FogSt

    public FogStateStack(int id) {
        cow.id = id;
-        stack = new FogState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new FogState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new FogState();
        }
    }
@@ -21,6 +21,11 @@ public final class FogStateStack extends FogState implements CowStateStack<FogSt
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class IntegerStateStack extends IntegerState implements CowStateSta
    public IntegerStateStack(int val, int id) {
        cow.id = id;
        setValue(val);
-        stack = new IntegerState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new IntegerState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new IntegerState();
            stack[i].setValue(val);
        }
@@ -30,6 +30,11 @@ public final class IntegerStateStack extends IntegerState implements CowStateSta
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class LightModelStateStack extends LightModelState implements CowSt
    public LightModelStateStack(int id) {
        super();
        cow.id = id;
-        stack = new LightModelState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new LightModelState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new LightModelState();
        }
    }
@@ -22,6 +22,11 @@ public final class LightModelStateStack extends LightModelState implements CowSt
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class LightStateStack extends LightState implements CowStateStack<L
    public LightStateStack(int light, int id) {
        super(light);
        cow.id = id;
-        stack = new LightState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new LightState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new LightState(light);
        }
    }
@@ -22,6 +22,11 @@ public final class LightStateStack extends LightState implements CowStateStack<L
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class LineStateStack extends LineState implements CowStateStack<Lin

    public LineStateStack(int id) {
        cow.id = id;
-        stack = new LineState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new LineState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new LineState();
        }
    }
@@ -22,6 +22,11 @@ public final class LineStateStack extends LineState implements CowStateStack<Lin
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class MaterialStateStack extends MaterialState implements CowStateS
    public MaterialStateStack(int face, int id) {
        super(face);
        cow.id = id;
-        stack = new MaterialState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new MaterialState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new MaterialState(face);
        }
    }
@@ -22,6 +22,11 @@ public final class MaterialStateStack extends MaterialState implements CowStateS
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -10,8 +10,8 @@ public final class MatrixModeStack extends MatrixMode implements CowStateStack<M

    public MatrixModeStack(int id) {
        cow.id = id;
-        stack = new MatrixMode[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new MatrixMode[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new MatrixMode();
        }
    }
@@ -21,6 +21,11 @@ public final class MatrixModeStack extends MatrixMode implements CowStateStack<M
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class PointStateStack extends PointState implements CowStateStack<P

    public PointStateStack(int id) {
        cow.id = id;
-        stack = new PointState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new PointState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new PointState();
        }
    }
@@ -22,6 +22,11 @@ public final class PointStateStack extends PointState implements CowStateStack<P
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class PolygonStateStack extends PolygonState implements CowStateSta

    public PolygonStateStack(int id) {
        cow.id = id;
-        stack = new PolygonState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new PolygonState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new PolygonState();
        }
    }
@@ -22,6 +22,11 @@ public final class PolygonStateStack extends PolygonState implements CowStateSta
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -0,0 +1,12 @@
+package com.gtnewhorizons.angelica.glsm.stacks;
+
+public final class RetainedState {
+    public int[] ids = new int[64];
+    public int count;
+    public int program;
+    public long programGen;
+
+    public void ensureCapacity(int capacity) {
+        if (ids.length < capacity) ids = new int[capacity];
+    }
+}
@@ -11,8 +11,8 @@ public final class ScissorStateStack extends ScissorState implements CowStateSta

    public ScissorStateStack(int id) {
        cow.id = id;
-        stack = new ScissorState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new ScissorState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new ScissorState();
        }
    }
@@ -22,6 +22,11 @@ public final class ScissorStateStack extends ScissorState implements CowStateSta
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -11,8 +11,8 @@ public final class StencilStateStack extends StencilState implements CowStateSta

    public StencilStateStack(int id) {
        cow.id = id;
-        stack = new StencilState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new StencilState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new StencilState();
        }
    }
@@ -22,6 +22,11 @@ public final class StencilStateStack extends StencilState implements CowStateSta
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -12,8 +12,8 @@ public final class TextureBindingStack extends TextureBinding implements CowStat
    public TextureBindingStack(int id, int unit) {
        cow = new CowDepths(StateSet.R_TEXTURE, unit);
        cow.id = id;
-        stack = new TextureBinding[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new TextureBinding[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new TextureBinding();
        }
    }
@@ -23,6 +23,11 @@ public final class TextureBindingStack extends TextureBinding implements CowStat
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -15,7 +15,7 @@ public final class Vec3fStack implements CowStateStack<Vec3fStack> {
    public Vec3fStack(Vector3f value, int id) {
        this.value = value;
        cow.id = id;
-        stack = new float[GLStateManager.MAX_ATTRIB_STACK_DEPTH][3];
+        stack = new float[GLStateManager.STATE_SLOTS][3];
    }

    @Override
@@ -23,6 +23,11 @@ public final class Vec3fStack implements CowStateStack<Vec3fStack> {
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return value.x != stack[slot][0] || value.y != stack[slot][1] || value.z != stack[slot][2];
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s][0] = value.x;
@@ -15,7 +15,7 @@ public final class Vec4fStack implements CowStateStack<Vec4fStack> {
    public Vec4fStack(Vector4f value, int id) {
        this.value = value;
        cow.id = id;
-        stack = new float[GLStateManager.MAX_ATTRIB_STACK_DEPTH][4];
+        stack = new float[GLStateManager.STATE_SLOTS][4];
    }

    @Override
@@ -23,6 +23,11 @@ public final class Vec4fStack implements CowStateStack<Vec4fStack> {
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return value.x != stack[slot][0] || value.y != stack[slot][1] || value.z != stack[slot][2] || value.w != stack[slot][3];
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s][0] = value.x;
@@ -11,8 +11,8 @@ public final class ViewPortStateStack extends ViewportState implements CowStateS

    public ViewPortStateStack(int id) {
        cow.id = id;
-        stack = new ViewportState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+        stack = new ViewportState[GLStateManager.STATE_SLOTS];
+        for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
            stack[i] = new ViewportState();
        }
    }
@@ -22,6 +22,11 @@ public final class ViewPortStateStack extends ViewportState implements CowStateS
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].set(this);
@@ -9,6 +9,13 @@ import java.nio.FloatBuffer;

@Getter @Setter
 public class FogState implements ISettableState<FogState> {
+    public static final int DISTANCE_EYE_RADIAL = 0;
+    public static final int DISTANCE_EYE_PLANE = 1;
+    public static final int DISTANCE_EYE_PLANE_ABS = 2;
+
+    private static final double LN2 = Math.log(2.0);
+    private static final double SQRT_LN2 = Math.sqrt(LN2);
+
    protected int fogMode = GL11.GL_EXP;
    protected final Vector3d fogColor = new Vector3d(0.0F, 0.0F, 0.0F);
    protected float fogAlpha = 1.0F;
@@ -16,8 +23,26 @@ public class FogState implements ISettableState<FogState> {
    protected float density = 1.0F;
    protected float start;
    protected float end = 1.0F;
-    /** Fog distance computation mode: 0=EYE_RADIAL, 1=EYE_PLANE, 2=EYE_PLANE_ABS */
-    protected int fogDistanceMode = 2;
+    protected int fogDistanceMode = DISTANCE_EYE_PLANE_ABS;
+
+    // Mesa STATE_FOG_PARAMS_OPTIMIZED
+    public float linearScale() {
+        final float range = end - start;
+        return range != 0.0f ? -1.0f / range : 0.0f;
+    }
+
+    public float linearBias() {
+        final float range = end - start;
+        return range != 0.0f ? end / range : 1.0f;
+    }
+
+    public float expScale() {
+        return (float) (density / LN2);
+    }
+
+    public float exp2Scale() {
+        return (float) (density / SQRT_LN2);
+    }

    @Override
    public FogState set(FogState state) {
@@ -1,14 +1,16 @@
 package com.gtnewhorizons.angelica.glsm.states;

 import lombok.Getter;
+import org.lwjgl.opengl.GL15;
+import org.lwjgl.opengl.GL30;

 public class ImageUnitBinding implements ISettableState<ImageUnitBinding> {
    @Getter protected int texture;
    @Getter protected int level;
    @Getter protected boolean layered;
    @Getter protected int layer;
-    @Getter protected int access;
-    @Getter protected int format;
+    @Getter protected int access = GL15.GL_READ_ONLY;
+    @Getter protected int format = GL30.GL_R8;

    public void setBinding(int texture, int level, boolean layered, int layer, int access, int format) {
        this.texture = texture;
@@ -19,6 +21,10 @@ public class ImageUnitBinding implements ISettableState<ImageUnitBinding> {
        this.format = format;
    }

+    public void reset() {
+        setBinding(0, 0, false, 0, GL15.GL_READ_ONLY, GL30.GL_R8);
+    }
+
    @Override
    public ImageUnitBinding set(ImageUnitBinding state) {
        this.texture = state.texture;
@@ -0,0 +1,57 @@
+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;
+
+public record PixelStoreState(
+    int alignment,
+    int rowLength,
+    int skipRows,
+    int skipPixels,
+    int imageHeight,
+    int skipImages,
+    boolean swapBytes,
+    boolean lsbFirst
+) {
+    public static final PixelStoreState DEFAULT = new PixelStoreState(4, 0, 0, 0, 0, 0, false, false);
+
+    public boolean isDefault() {
+        return this.equals(DEFAULT);
+    }
+
+    public static boolean isPack(int pname) {
+        return switch (pname) {
+            case GL11.GL_PACK_ALIGNMENT, GL11.GL_PACK_ROW_LENGTH, GL11.GL_PACK_SKIP_ROWS, GL11.GL_PACK_SKIP_PIXELS,
+                 GL12.GL_PACK_IMAGE_HEIGHT, GL12.GL_PACK_SKIP_IMAGES, GL11.GL_PACK_SWAP_BYTES, GL11.GL_PACK_LSB_FIRST -> true;
+            default -> false;
+        };
+    }
+
+    public PixelStoreState with(int pname, int param) {
+        return switch (pname) {
+            case GL11.GL_UNPACK_ALIGNMENT, GL11.GL_PACK_ALIGNMENT -> (param == alignment || (param != 1 && param != 2 && param != 4 && param != 8)) ? this : new PixelStoreState(param, rowLength, skipRows, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst);
+            case GL11.GL_UNPACK_ROW_LENGTH, GL11.GL_PACK_ROW_LENGTH -> (param == rowLength || param < 0) ? this : new PixelStoreState(alignment, param, skipRows, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst);
+            case GL11.GL_UNPACK_SKIP_ROWS, GL11.GL_PACK_SKIP_ROWS -> (param == skipRows || param < 0) ? this : new PixelStoreState(alignment, rowLength, param, skipPixels, imageHeight, skipImages, swapBytes, lsbFirst);
+            case GL11.GL_UNPACK_SKIP_PIXELS, GL11.GL_PACK_SKIP_PIXELS -> (param == skipPixels || param < 0) ? this : new PixelStoreState(alignment, rowLength, skipRows, param, imageHeight, skipImages, swapBytes, lsbFirst);
+            case GL12.GL_UNPACK_IMAGE_HEIGHT, GL12.GL_PACK_IMAGE_HEIGHT -> (param == imageHeight || param < 0) ? this : new PixelStoreState(alignment, rowLength, skipRows, skipPixels, param, skipImages, swapBytes, lsbFirst);
+            case GL12.GL_UNPACK_SKIP_IMAGES, GL12.GL_PACK_SKIP_IMAGES -> (param == skipImages || param < 0) ? this : new PixelStoreState(alignment, rowLength, skipRows, skipPixels, imageHeight, param, swapBytes, lsbFirst);
+            case GL11.GL_UNPACK_SWAP_BYTES, GL11.GL_PACK_SWAP_BYTES -> (param != 0) == swapBytes ? this : new PixelStoreState(alignment, rowLength, skipRows, skipPixels, imageHeight, skipImages, param != 0, lsbFirst);
+            case GL11.GL_UNPACK_LSB_FIRST, GL11.GL_PACK_LSB_FIRST -> (param != 0) == lsbFirst ? this : new PixelStoreState(alignment, rowLength, skipRows, skipPixels, imageHeight, skipImages, swapBytes, param != 0);
+            default -> this;
+        };
+    }
+
+    public static void applyDiff(PixelStoreState from, PixelStoreState to, boolean pack) {
+        if (from == to) return;
+        if (from.alignment != to.alignment) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_ALIGNMENT : GL11.GL_UNPACK_ALIGNMENT, to.alignment);
+        if (from.rowLength != to.rowLength) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_ROW_LENGTH : GL11.GL_UNPACK_ROW_LENGTH, to.rowLength);
+        if (from.skipRows != to.skipRows) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_SKIP_ROWS : GL11.GL_UNPACK_SKIP_ROWS, to.skipRows);
+        if (from.skipPixels != to.skipPixels) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_SKIP_PIXELS : GL11.GL_UNPACK_SKIP_PIXELS, to.skipPixels);
+        if (from.imageHeight != to.imageHeight) RENDER_BACKEND.pixelStorei(pack ? GL12.GL_PACK_IMAGE_HEIGHT : GL12.GL_UNPACK_IMAGE_HEIGHT, to.imageHeight);
+        if (from.skipImages != to.skipImages) RENDER_BACKEND.pixelStorei(pack ? GL12.GL_PACK_SKIP_IMAGES : GL12.GL_UNPACK_SKIP_IMAGES, to.skipImages);
+        if (from.swapBytes != to.swapBytes) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_SWAP_BYTES : GL11.GL_UNPACK_SWAP_BYTES, to.swapBytes ? 1 : 0);
+        if (from.lsbFirst != to.lsbFirst) RENDER_BACKEND.pixelStorei(pack ? GL11.GL_PACK_LSB_FIRST : GL11.GL_UNPACK_LSB_FIRST, to.lsbFirst ? 1 : 0);
+    }
+}
@@ -1,51 +0,0 @@
-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);
-    }
-}
@@ -2,6 +2,7 @@ package com.gtnewhorizons.angelica.glsm.states;

 import lombok.Getter;
 import lombok.Setter;
+import org.lwjgl.opengl.GL20;

 /**
 * Tracks GL point state: size.
@@ -10,10 +11,24 @@ import lombok.Setter;
@Getter @Setter
 public class PointState implements ISettableState<PointState> {
    private float size = 1.0f;
+    private float minSize = 0.0f;
+    private float maxSize = Float.NaN;
+    private float fadeThreshold = 1.0f;
+    private float attenuationConstant = 1.0f;
+    private float attenuationLinear = 0.0f;
+    private float attenuationQuadratic = 0.0f;
+    private int spriteCoordOrigin = GL20.GL_UPPER_LEFT;

    @Override
    public PointState set(PointState state) {
        this.size = state.size;
+        this.minSize = state.minSize;
+        this.maxSize = state.maxSize;
+        this.fadeThreshold = state.fadeThreshold;
+        this.attenuationConstant = state.attenuationConstant;
+        this.attenuationLinear = state.attenuationLinear;
+        this.attenuationQuadratic = state.attenuationQuadratic;
+        this.spriteCoordOrigin = state.spriteCoordOrigin;
        return this;
    }

@@ -21,7 +36,14 @@ public class PointState implements ISettableState<PointState> {
    public boolean sameAs(Object state) {
        if (this == state) return true;
        if (!(state instanceof PointState pointState)) return false;
-        return Float.compare(size, pointState.size) == 0;
+        return Float.compare(size, pointState.size) == 0
+            && Float.compare(minSize, pointState.minSize) == 0
+            && Float.compare(maxSize, pointState.maxSize) == 0
+            && Float.compare(fadeThreshold, pointState.fadeThreshold) == 0
+            && Float.compare(attenuationConstant, pointState.attenuationConstant) == 0
+            && Float.compare(attenuationLinear, pointState.attenuationLinear) == 0
+            && Float.compare(attenuationQuadratic, pointState.attenuationQuadratic) == 0
+            && spriteCoordOrigin == pointState.spriteCoordOrigin;
    }

    @Override
@@ -6,6 +6,8 @@ import com.gtnewhorizons.angelica.glsm.stacks.CowStateStack;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL13;

+import java.util.Arrays;
+
 /**
 * Per-texture-unit GL_TEXTURE_ENV state for FFP emulation. Tracks the simple texenv mode and all GL_COMBINE sub-parameters.
 */
@@ -45,8 +47,8 @@ public final class TexEnvState implements CowStateStack<TexEnvState> {
            stack = null;
            cow = null;
        } else {
-            stack = new TexEnvState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
-            for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
+            stack = new TexEnvState[GLStateManager.STATE_SLOTS];
+            for (int i = 0; i < GLStateManager.STATE_SLOTS; i++) {
                stack[i] = new TexEnvState(true);
            }
            cow = new CowDepths();
@@ -70,6 +72,14 @@ public final class TexEnvState implements CowStateStack<TexEnvState> {
        this.envColorA = other.envColorA;
    }

+    private boolean sameAs(TexEnvState other) {
+        return mode == other.mode && combineRgb == other.combineRgb && combineAlpha == other.combineAlpha
+            && Arrays.equals(sourceRgb, other.sourceRgb) && Arrays.equals(sourceAlpha, other.sourceAlpha)
+            && Arrays.equals(operandRgb, other.operandRgb) && Arrays.equals(operandAlpha, other.operandAlpha)
+            && scaleRgb == other.scaleRgb && scaleAlpha == other.scaleAlpha
+            && envColorR == other.envColorR && envColorG == other.envColorG && envColorB == other.envColorB && envColorA == other.envColorA;
+    }
+
    public void reset() {
        mode = GL11.GL_MODULATE;
        combineRgb = GL11.GL_MODULATE;
@@ -89,6 +99,11 @@ public final class TexEnvState implements CowStateStack<TexEnvState> {
        return cow;
    }

+    @Override
+    public boolean slotChanged(int slot) {
+        return !sameAs(stack[slot]);
+    }
+
    @Override
    public void captureSlot(int s) {
        stack[s].copyFrom(this);
@@ -9,6 +9,7 @@ import lombok.Getter;
 import org.joml.Matrix4fStack;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;
+import org.lwjgl.opengl.GL13;

 import java.util.ArrayList;
 import java.util.List;
@@ -19,6 +20,7 @@ public class TextureUnitArray {
    private final TextureUnitBooleanStateStack[] states;
    private final TextureUnitBooleanStateStack[] texture1DStates;
    private final TextureUnitBooleanStateStack[] texture3DStates;
+    private final TextureUnitBooleanStateStack[] textureCubeMapStates;
    private final TextureUnitBooleanStateStack[] texGenSStates;
    private final TextureUnitBooleanStateStack[] texGenTStates;
    private final TextureUnitBooleanStateStack[] texGenRStates;
@@ -36,6 +38,7 @@ public class TextureUnitArray {
        states = new TextureUnitBooleanStateStack[GLStateManager.MAX_TEXTURE_UNITS];
        texture1DStates = new TextureUnitBooleanStateStack[GLStateManager.MAX_TEXTURE_UNITS];
        texture3DStates = new TextureUnitBooleanStateStack[GLStateManager.MAX_TEXTURE_UNITS];
+        textureCubeMapStates = new TextureUnitBooleanStateStack[GLStateManager.MAX_TEXTURE_UNITS];
        texGenSStates = new TextureUnitBooleanStateStack[GLStateManager.MAX_TEXTURE_UNITS];
        texGenTStates = new TextureUnitBooleanStateStack[GLStateManager.MAX_TEXTURE_UNITS];
        texGenRStates = new TextureUnitBooleanStateStack[GLStateManager.MAX_TEXTURE_UNITS];
@@ -49,6 +52,7 @@ public class TextureUnitArray {
            states[i] = track(new TextureUnitBooleanStateStack(GL11.GL_TEXTURE_2D, i));
            texture1DStates[i] = track(new TextureUnitBooleanStateStack(GL11.GL_TEXTURE_1D, i));
            texture3DStates[i] = track(new TextureUnitBooleanStateStack(GL12.GL_TEXTURE_3D, i));
+            textureCubeMapStates[i] = track(new TextureUnitBooleanStateStack(GL13.GL_TEXTURE_CUBE_MAP, i));
            texGenSStates[i] = track(new TextureUnitBooleanStateStack(GL11.GL_TEXTURE_GEN_S, i));
            texGenTStates[i] = track(new TextureUnitBooleanStateStack(GL11.GL_TEXTURE_GEN_T, i));
            texGenRStates[i] = track(new TextureUnitBooleanStateStack(GL11.GL_TEXTURE_GEN_R, i));
@@ -90,6 +94,10 @@ public class TextureUnitArray {
        return texture3DStates[index];
    }

+    public TextureUnitBooleanStateStack getTextureCubeMapStates(int index) {
+        return textureCubeMapStates[index];
+    }
+
    public TextureUnitBooleanStateStack getTexGenSStates(int index) {
        return texGenSStates[index];
    }
@@ -127,6 +135,7 @@ public class TextureUnitArray {
            if (!states[i].sameAs(textureUnitArray.states[i])) return false;
            if (!texture1DStates[i].sameAs(textureUnitArray.texture1DStates[i])) return false;
            if (!texture3DStates[i].sameAs(textureUnitArray.texture3DStates[i])) return false;
+            if (!textureCubeMapStates[i].sameAs(textureUnitArray.textureCubeMapStates[i])) return false;
            if (!texGenSStates[i].sameAs(textureUnitArray.texGenSStates[i])) return false;
            if (!texGenTStates[i].sameAs(textureUnitArray.texGenTStates[i])) return false;
            if (!texGenRStates[i].sameAs(textureUnitArray.texGenRStates[i])) return false;
Author	SHA1	Message	Date
Jason Mitchell	e84c8c8d7a	Stop stalls on some GPUs when closing the questbook (#2286 )	2026-10-22 00:24:31 -07:00
Eclipse-Sol	73d61d385c	initial commit for gl-fences (#2285 )	2026-10-21 20:12:01 -07:00
Wackypocket	69124e3f2f	Stop capping mailbox present mode to the refresh rate (#2279 )	2026-10-21 19:47:18 -07:00
VortexSo4andVortexSo4	98703a11be	Read only the mcmeta in the interpolated icon check (#2284 ) Co-authored-by: VortexSo4 <[email protected]>	2026-10-21 17:32:34 -07:00
brandyn	67ca46a220	why min 16 (#2278 )	2026-10-21 17:25:35 -07:00
Jason Mitchell	a037a96fa4	Update to Celeritas 2.5.13-GTNH (#2283 )	2026-10-21 15:36:58 -07:00
Jason Mitchell	ed260a34c4	Fix tests & SDL-GPU framebuffers losing attachments on resize or texture delete (#2282 )	2026-10-21 15:12:32 -07:00
Jason Mitchell	e98c927a93	Reduce test duplication (#2276 )	2026-10-19 00:43:29 -07:00
Jason Mitchell	b446968e66	Instance animated TESRs and let mods register shaders for batched TESRs (#2275 )	2026-10-18 23:59:55 -07:00
Jason Mitchell	32f8eef15b	Fixes a startup CME when BLS (#2274 )	2026-10-18 20:40:14 -07:00
Eclipse-Sol	2d9d1a45b7	initial commit for entity-atlases (#2272 )	2026-10-18 19:31:16 -07:00
Jason Mitchell	fa8842a64b	Fix birch and spruce leaves showing the oak biome color with fancy biome blending (#2273 )	2026-10-18 17:06:35 -07:00
gorbit99	69019b9a62	Implement metadata checking into the NBT path of block.properties parsing (#2267 )	2026-10-17 18:39:12 -07:00
Jason Mitchell	482dece0f7	Expand SDL-GPU's GLSM redirector to GLSM and remove unredirected GL workarounds and move action back to master (#2268 )	2026-10-17 17:58:50 -07:00
Eclipse-Sol	ab3bf17696	Set entity, block entity and item IDs per vertex (#2265 )	2026-10-16 21:47:40 -07:00
Eclipse-Sol	cfc6e12e00	Minor Compute Cull Optimizations (#2263 )	2026-10-16 21:34:59 -07:00
Eclipse-Sol	8537835d0c	Fix Player Capture for EP in SDL-GPU (#2262 )	2026-10-16 21:34:16 -07:00
Jason Mitchell	8e1809622c	Stop resetting SDL GPU to OpenGL on unrelated crashes (#2266 )	2026-10-16 21:33:06 -07:00
HariboApfel	f81ee4b03a	fixed some osx metal compability with Distant horizon 1.7.10 backport (#2261 )	2026-10-15 09:59:28 -07:00
Eclipse-Sol	49db8e111d	Allow Iris to use "more" Samplers on SDL-GPU (#2256 ) * Initial commit for sdl-over-16-samplers * Fix WSR not working on SDL	2026-10-14 16:10:54 -07:00
Eclipse-Sol	bd9a3c3c5c	initial commit for witchery-cauldron-not-drawing-base (#2260 )	2026-10-14 16:09:57 -07:00
Ruling-0	01ff612d1d	Make animation interpolation respect alpha (#2258 )	2026-10-14 15:44:18 -07:00
Jason Mitchell	0cae2be1f6	Fix Chisel energised voidstone missing its border corners (#2254 ) Fixes #2246	2026-10-12 18:48:33 -07:00
Jason Mitchell	85d0641a73	Speed up tests and run SDL-GPU device tests on CI (#2253 ) * Speed up tests and run SDL-GPU device tests on CI * Arch rules share one ASM scan instead of ArchUnit * Tests needing an SDL GPU device fail without one instead of skipping * Replace checkstyle's wildcard-import check with a test * Use the runner's preinstalled Temurin JDKs * Cache build/rfg so the Minecraft decompile chain can be skipped * Unpack LWJGL natives before tests * Pin the shared workflow commit	2026-10-12 13:26:28 -07:00
Jason Mitchell	46f8157087	New workflow (#2252 )	2026-10-11 16:11:14 -07:00
Jason Mitchell	d3dee841e8	Skip zero-size buffer uploads and readbacks on SDL-GPU (#2249 )	2026-10-11 09:41:28 -07:00
Jason Mitchell	3d3d0f9e18	Angelica side fix to RC Lantern rendering. Works with or without a patched RC (#2251 )	2026-10-11 09:27:53 -07:00
Jason Mitchell	23aa04361d	Fix crash replaying display lists compiled during the splash screen (#2250 )	2026-10-10 20:38:35 -07:00
DarkShadow44	69428c12f6	Fix MixinRendererLivingEntity_GlintClock expected count (#2248 )	2026-10-10 18:06:45 -07:00
Jason Mitchell	3978be161d	Answer legacy GL queries from tracked state (#2247 )	2026-10-10 17:31:02 -07:00
Jason Mitchell	2ed838acf1	Fix shaders that redefine a GLSL built-in failing on SDL-GPU and GLES (#2245 ) * Retry a rejected compile with the shader's own functions renamed	2026-10-10 14:05:33 -07:00
Eclipse-Sol	d29a8278cd	Make API functions for enderstorage to use (#2244 ) * Make API functions for enderstorage to use * move it into its own package	2026-10-10 16:54:21 -04:00
Eclipse-Sol	2f1f380e8e	Bug Cleanup after 2.9RC2 (#2239 )	2026-10-10 13:22:49 -07:00
Jason Mitchell	990dadc03f	Reject non 3.3 core with a more clear message (#2243 )	2026-10-10 12:58:51 -07:00
Ancalagon	1946c2ad65	Fix dark AE2 cables when shaders enabled (#2223 )	2026-10-08 23:27:24 -07:00
Jason Mitchell	bfb66d84ee	Fix interop with Serene Seasons and other similar mods (#2240 )	2026-10-08 23:09:34 -07:00
DarkShadow44	cae4fea2bb	Fix Little Tiles rendering issues (#2238 )	2026-10-08 17:13:36 -07:00
Jason Mitchell	78abc05711	Update Readme	2026-10-07 20:34:33 -07:00
Eclipse-Sol	159f7ff8cc	Fix NaNs on EP (#2231 ) * Fix NaNs on EP * Also add hidden writes handling * optimize this mess * Another optimization pass	2026-10-07 17:59:21 -04:00
Ranzu	0d959c2b90	Add Darkmode Transformer target (#2221 )	2026-10-07 13:55:18 -07:00
Alexdoru	ce2462cad3	Fix server thread leak in ThreadedBlockData (#2230 )	2026-10-07 12:30:09 -07:00
Death Fuel	5457df5369	Marginal improvements (#2222 )	2026-10-07 12:23:32 -07:00
Eclipse-Sol	acedba4eac	Modern Font Sheets (#2225 ) * Initial commit for modern-font-sheets * Fix dev env error log * Fix private use characters still using their own unifont character	2026-10-07 11:19:19 -04:00
Alexdoru	21a054a4db	fix world client leak in CloudRenderer (#2227 )	2026-10-06 06:22:08 -07:00
Jason Mitchell	d056bf6fa7	Run image atomics natively on Metal where the runtime allows (#2226 )	2026-10-05 22:57:30 -07:00
Eclipse-Sol	5ed1c92590	SDL Vertex Replay + Dragon API (#2224 )	2026-10-05 20:23:36 -07:00
Eclipse-Sol	3389b952d0	Fix SDL compile failure when an image atomic's result is used (#2218 )	2026-10-04 18:56:12 -07:00
Jason Mitchell	b49d37d827	Ignore additional tags when deriving the mod version (#2219 )	2026-10-04 18:33:06 -07:00
Jason Mitchell	12857006c6	Harden SDL-GPU buffer mapping lifetime (#2217 )	2026-10-04 16:31:48 -07:00
Eclipse-Sol	38af64f10c	Initial commit for shader-loading-optimizations (#2213 )	2026-10-04 15:36:50 -07:00
Jason Mitchell	10922edca3	Include missed scripts (#2216 )	2026-10-04 15:22:09 -07:00
Jason Mitchell	2a8c8756d3	Add renderer selection to video settings - (#2215 )	2026-10-04 15:16:51 -07:00
Jason Mitchell	23e36f2b76	Narrow overly broad transformer exclusions for PowerConverters (#2214 )	2026-10-04 14:27:43 -07:00
Jason Mitchell	fcf8ad064a	Fix terrain disappearing at screen edges with compute culling (#2212 )	2026-10-04 13:05:14 -07:00
Jason Mitchell	6dfb0312b1	Answer legacy stack and client state queries from GLSM (#2211 )	2026-10-04 11:43:56 -07:00
Eclipse-Sol	0a4d48964e	Cache Iris Shaders (#2206 )	2026-10-03 20:06:39 -07:00
Ranzu	231a2ab216	Add Darkmode Transformer target (#2205 )	2026-10-03 15:28:37 -07:00
Jason Mitchell	61bb779dea	Fix crash when mods measure text off-thread with a custom font (#2204 )	2026-10-03 15:28:15 -07:00
Jason Mitchell	7cd97d1216	Fix HUD caching flicker and match non-cached GL state (#2201 )	2026-10-03 13:19:29 -07:00
Eclipse-Sol	fe82cd320a	Plenty of fixes for GTNH (#2202 )	2026-10-03 13:19:15 -07:00
Li Xiangrong	c7a0f3a208	Default raw custom textures to bilinear filtering and clamping (#2198 )	2026-10-03 11:57:30 -07:00
Matt Van Horn	338d94197c	Settle frame pacing after an inconsistent vsync gate (#2197 )	2026-10-03 11:51:30 -07:00
Death Fuel	75a0278138	Fix splash issues (#2200 )	2026-10-03 11:42:57 -07:00