Add a flag to StateAwareTesselator for per-quad directional shading (#1989 )

* Add a flag for no directional shading * Mark StateAwareTessellator as an API * Reset internal state better
Avoid rescanning atlas for each CTM tile (#2029 )
2026-11-14 17:24:43 +00:00 · 2026-08-19 18:16:04 +00:00 · 2026-08-19 09:32:42 -07:00 · 2026-08-19 08:55:43 -07:00 · 2026-08-16 17:59:33 -07:00 · 2026-08-16 16:05:04 -07:00
248 changed files with 11099 additions and 1879 deletions
@@ -2,7 +2,8 @@
 # Builds the libTracyClient shared library for the tracy-client module.
 set -euo pipefail

-TRACY_VERSION="${TRACY_VERSION:-v0.13.1}"
+TRACY_VERSION="${TRACY_VERSION:-v0.14.0}"
+TRACY_VERSION_BARE="${TRACY_VERSION#v}"
 OUT_DIR="${OUT_DIR:-dist/tracy-natives}"
 TRACY_REPO="https://github.com/wolfpld/tracy"

@@ -16,7 +17,7 @@ case "$(uname -m)" in
    arm64|aarch64) PLAT_ARCH="arm64" ;;
    *) PLAT_ARCH="x64" ;;
 esac
-RES_DIR="${RES_DIR:-$REPO_ROOT/tracy-client/src/main/resources/natives/tracy/$PLAT_OS-$PLAT_ARCH}"
+RES_DIR="${RES_DIR:-$REPO_ROOT/tracy-client/src/main/resources/natives/tracy/$TRACY_VERSION_BARE/$PLAT_OS-$PLAT_ARCH}"

 WORK_DIR="$(mktemp -d)"
 trap 'rm -rf "$WORK_DIR"' EXIT
@@ -33,7 +34,8 @@ fi
 BUILD_DIR="$WORK_DIR/build"
 export MACOSX_DEPLOYMENT_TARGET="${MACOSX_DEPLOYMENT_TARGET:-11.0}"

-cmake -S "$SRC_DIR" -B "$BUILD_DIR" \
+cmake -S "$REPO_ROOT/tracy-client/src/main/native" -B "$BUILD_DIR" \
+    -DTRACY_SRC_DIR="$SRC_DIR" \
    -DCMAKE_BUILD_TYPE=Release \
    -DBUILD_SHARED_LIBS=ON \
    -DTRACY_STATIC=OFF \
@@ -6,10 +6,6 @@ on:
      - "tracy-v*"
  workflow_dispatch:
    inputs:
-      tracy-version:
-        description: Tracy git tag to build
-        required: false
-        default: v0.13.1
      publish:
        description: Publish angelica-tracy.jar to the GTNH maven
        type: boolean
@@ -20,25 +16,25 @@ jobs:
  build:
    strategy:
      matrix:
+        platform: [linux-x64, windows-x64, macos-x64, macos-arm64]
        include:
-          - os: ubuntu-22.04
-            platform: linux-x64
-          - os: windows-2025
-            platform: windows-x64
-          - os: macos-15-intel
-            platform: macos-x64
-          - os: macos-15
-            platform: macos-arm64
+          - platform: linux-x64
+            os: ubuntu-22.04
+          - platform: windows-x64
+            os: windows-2025
+          - platform: macos-x64
+            os: macos-15-intel
+          - platform: macos-arm64
+            os: macos-15
    runs-on: ${{ matrix.os }}
    steps:
      - uses: actions/checkout@v5
      - name: Build libTracyClient
        shell: bash
        env:
-          RAW_VERSION: ${{ github.ref_type == 'tag' && github.ref_name || inputs.tracy-version }}
          OUT_DIR: dist/tracy-natives
        run: |
-          export TRACY_VERSION="${RAW_VERSION#tracy-}"
+          export TRACY_VERSION="v$(sed -nE 's/^tracy = "(.*)"$/\1/p' gradle/libs.versions.toml)"
          bash .github/scripts/build-tracy-natives.sh
      - uses: actions/upload-artifact@v4
        with:
@@ -56,14 +52,6 @@ jobs:
          distribution: temurin
          java-version: 21
      - uses: gradle/actions/setup-gradle@v4
-      - name: Check tracy version matches the version catalog
-        shell: bash
-        env:
-          RAW_VERSION: ${{ github.ref_type == 'tag' && github.ref_name || inputs.tracy-version }}
-        run: |
-          ver="${RAW_VERSION#tracy-}"
-          grep -q "^tracy = \"${ver#v}\"$" gradle/libs.versions.toml \
-            || { echo "libs.versions.toml tracy does not match $ver" >&2; exit 1; }
      - uses: actions/download-artifact@v5
        with:
          pattern: tracy-natives-*
@@ -71,8 +59,9 @@ jobs:
      - name: Stage natives into tracy-client resources
        shell: bash
        run: |
+          version="$(sed -nE 's/^tracy = "(.*)"$/\1/p' gradle/libs.versions.toml)"
          for d in staging/tracy-natives-*; do
-            dest="tracy-client/src/main/resources/natives/tracy/${d#staging/tracy-natives-}"
+            dest="tracy-client/src/main/resources/natives/tracy/$version/${d#staging/tracy-natives-}"
            mkdir -p "$dest"
            cp "$d"/* "$dest/"
          done
@@ -89,4 +78,4 @@ jobs:
        env:
          MAVEN_USER: ${{ secrets.MAVEN_USER }}
          MAVEN_PASSWORD: ${{ secrets.MAVEN_PASSWORD }}
-        run: ./gradlew :tracy-client:publish
+        run: ./gradlew -PpublishTracy=true :tracy-client:publish
@@ -3,7 +3,7 @@ name: Release tagged build

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

 permissions:
  contents: write
@@ -40,5 +40,8 @@ addon.late.local.gradle
 addon.late.local.gradle.kts
 local/
 tracy-client/src/main/resources/natives/
+tracy-client/angelica/
 dist/tracy-natives/
 *.tracy
+
+tracy-client/angelica/
@@ -1,3 +1,4 @@
+import com.modrinth.minotaur.TaskModrinthUpload
 import net.darkhax.curseforgegradle.TaskPublishCurseForge
 import xyz.wagyourtail.jvmdg.gradle.flags.DowngradeFlags
 import xyz.wagyourtail.jvmdg.gradle.task.DowngradeJar
@@ -76,7 +77,7 @@ val isMacOs = org.gradle.internal.os.OperatingSystem.current().isMacOsX
 val isMacOsArm64 = isMacOs && System.getProperty("os.arch") == "aarch64"

 tasks.withType<JavaExec>().configureEach {
-    if (name.startsWith("runClient")) {
+    if (name.startsWith("runClient") && name != "runClient") {
        if (isMacOs) {
            // SDL3 / Cocoa / Metal must initialize on the JVM main thread.
            jvmArgs("-XstartOnFirstThread")
@@ -228,7 +229,6 @@ val glCoreTest by tasks.registering(Test::class) {
 }

 tasks.test { finalizedBy(glCoreTest) }
-tasks.check { dependsOn(glCoreTest) }

 tasks.shadowJar {
    dependsOn(embedOnly)
@@ -257,3 +257,7 @@ tasks.shadowJar {
 tasks.withType<TaskPublishCurseForge>().configureEach {
    uploadArtifacts.forEach { it.addGameVersion("Client") }
 }
+
+tasks.withType<TaskModrinthUpload>().configureEach {
+    setDependsOn(dependsOn.filterNot { it == "build" } + "assemble")
+}
@@ -52,8 +52,8 @@ configurations.configureEach {
 }

 DependencyHandlerScope.of(dependencies).apply {
-    compileOnly("com.github.GTNewHorizons:Hodgepodge:2.7.166:dev")
-    runtimeOnlyNonPublishable("com.github.GTNewHorizons:Hodgepodge:2.7.166:dev")
+    compileOnly("com.github.GTNewHorizons:Hodgepodge:2.7.187:dev")
+    runtimeOnlyNonPublishable("com.github.GTNewHorizons:Hodgepodge:2.7.187:dev")

    runtimeOnlyNonPublishable(rfg.deobf("curse.maven:biomes-o-plenty-220318:2499612"))

@@ -161,6 +161,8 @@ DependencyHandlerScope.of(dependencies).apply {
    compileOnly(rfg.deobf("curse.maven:xaeros-minimap-263420:5060684"))
    compileOnly(rfg.deobf("curse.maven:security-craft-64760:2818228"))
    compileOnly("ganymedes01.etfuturum:Et-Futurum-Requiem:2.6.49-GTNH:dev")
+    compileOnly("com.github.GTNewHorizons:OpenBlocks:1.12.19-GTNH:dev")
+    compileOnly("com.github.GTNewHorizons:Chisel:2.17.31-GTNH:dev")
    compileOnly(rfg.deobf("curse.maven:biomes-o-plenty-220318:2499612"))

    devOnlyNonPublishable("com.github.GTNewHorizons:CosmeticArmorReworked:1.0.6-GTNH:dev")
@@ -202,6 +204,7 @@ afterEvaluate {

        glsmTestFixtures(testFixtures(project(":glsm")) as ModuleDependency) { isTransitive = false }
        testCompileOnly(testFixtures(project(":glsm")))
+        testImplementation("mega:fluidlogged-mc1.7.10:0.1.2")

        testRuntimeOnly(libs.fastutil)
        testRuntimeOnly(libs.joml)
@@ -20,6 +20,7 @@ public final class SystemProperties {
    public static final boolean USE_SDL_GPU = Boolean.getBoolean(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");

    // Redirector
    public static final UnmappedGLMode UNMAPPED_GL = parseEnum("angelica.unmappedGL", UnmappedGLMode.WARN, UnmappedGLMode.WARN, UnmappedGLMode.class);
@@ -34,6 +35,8 @@ public final class SystemProperties {
    public static final boolean SDL_ENCODER_ASSERTIONS_FATAL = ENCODER_ASSERTIONS == SdlAssertionMode.FATAL;
    public static final boolean SDL_VERIFY_STATE_SYNC = Boolean.getBoolean("angelica.sdlgpu.verifyStateSync");
    public static final boolean SDL_VERIFY_PER_FRAME_UNIFORM_BLOCK = Boolean.getBoolean("angelica.sdlgpu.verifyPerFrameUniformBlock");
+    public static final int SDL_FRAMES_IN_FLIGHT = Integer.getInteger("angelica.sdlgpu.framesInFlight", 2);
+    public static final boolean DISABLE_SDL_PRESENTER_THREAD = Boolean.getBoolean("angelica.sdlgpu.disablePresenterThread");

    // Tracy
    public static final boolean TRACY = Boolean.getBoolean("angelica.tracy");
@@ -55,7 +58,7 @@ public final class SystemProperties {
    public static final boolean DEBUG_F3_DETAIL = Boolean.getBoolean("angelica.debug.f3Detail");
    public static final boolean ENABLE_TEST_BLOCKS = Boolean.getBoolean("angelica.debug.testBlocks");
    public static final boolean DUMP_CLASS = Boolean.getBoolean("angelica.debug.dumpClass");
-    public static final boolean DUMP_SHADERS = Boolean.getBoolean("angelica.debug.dumpShaders") || isDeobf();
+    private static final boolean DUMP_SHADERS_PROP = Boolean.getBoolean("angelica.debug.dumpShaders");
    public static final boolean REDIRECTOR_LOGSPAM = Boolean.getBoolean("angelica.debug.redirectorLogspam");
    public static final boolean DEBUG_DISPLAY_LISTS = Boolean.getBoolean("angelica.debug.displayLists");
    public static final boolean LOG_DISPLAY_LIST_COMPILATION = Boolean.getBoolean("angelica.debug.displayLists.compilation");
@@ -65,8 +68,12 @@ public final class SystemProperties {
    // Set by us, read by celeritas
    public static final String KEY_CELERITAS_ENABLE_GL_DEBUG = "celeritas.enableGLDebug";

+    public static boolean dumpShaders() {
+        return DUMP_SHADERS_PROP || isDeobf();
+    }
+
    public static Path shaderDumpDir(String phase) {
-        return DUMP_SHADERS ? Paths.get(SHADER_DUMP_ROOT, phase) : null;
+        return dumpShaders() ? Paths.get(SHADER_DUMP_ROOT, phase) : null;
    }

    public enum UnmappedGLMode {
@@ -115,7 +122,7 @@ public final class SystemProperties {
        }
    }

-    private static boolean isDeobf() {
+    public static boolean isDeobf() {
        return Launch.blackboard != null && Boolean.TRUE.equals(Launch.blackboard.get("fml.deobfuscatedEnvironment"));
    }

@@ -18,6 +18,7 @@ import com.gtnewhorizons.angelica.glsm.stacks.PointStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.PolygonStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.StencilStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.ViewPortStateStack;
+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;
@@ -181,6 +182,9 @@ class GLContextState {
    public int clientAttribStackPointer = 0;
    public final boolean[] restoreUnitChanged = new boolean[GLStateManager.MAX_TEXTURE_UNITS];
    public boolean restoreDepthChanged, restoreBlendChanged, restoreColorMaskChanged, restoreClearColorChanged, restoreDrawBufferChanged, restoreLogicOpChanged, restoreStencilChanged, restoreViewportChanged, restoreLineChanged, restorePointChanged, restorePolygonChanged, restoreActiveUnitChanged;
+    public final BlendState vanillaBlendBefore = new BlendState();
+    public final BlendState vanillaBlendAfter = new BlendState();
+    public boolean vanillaBlendEnabledBefore;
    public int drawFramebuffer = 0;
    public int readFramebuffer = 0;
    public int texGenGeneration;
@@ -10,9 +10,11 @@ import com.gtnewhorizons.angelica.config.SystemProperties;
 import com.gtnewhorizons.angelica.glsm.DisplayListManager.RecordMode;
 import com.gtnewhorizons.angelica.glsm.backend.BackendManager;
 import com.gtnewhorizons.angelica.glsm.backend.GLDebugMessageListener;
+import com.gtnewhorizons.angelica.glsm.backend.VSyncMode;
 import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
 import com.gtnewhorizons.angelica.glsm.ffp.ShaderManager;
 import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
+import com.gtnewhorizons.angelica.glsm.ffp.VertexKey;
 import com.gtnewhorizons.angelica.glsm.hooks.DeferredAlphaHandler;
 import com.gtnewhorizons.angelica.glsm.hooks.DeferredBlendHandler;
 import com.gtnewhorizons.angelica.glsm.hooks.DeferredDepthColorHandler;
@@ -43,6 +45,8 @@ import com.gtnewhorizons.angelica.glsm.stacks.PointStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.PolygonStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.StencilStateStack;
 import com.gtnewhorizons.angelica.glsm.stacks.ViewPortStateStack;
+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;
@@ -552,6 +556,9 @@ public class GLStateManager {
        // GL_STENCIL_BITS was removed in core profile; query via default FBO attachment
        final int stencilBits = RENDER_BACKEND.getFramebufferAttachmentParameteri(GL30.GL_DRAW_FRAMEBUFFER, GL11.GL_STENCIL, GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE);
        glCtx.stencilBitMask = stencilBits >= 32 ? 0xFFFFFFFF : (1 << stencilBits) - 1;
+        if (glCtx.stencilBitMask == 0) {
+            LOGGER.warn("Default framebuffer reports 0 stencil bits on backend {}; all stencil masks clamp to 0", RENDER_BACKEND.getClass().getSimpleName());
+        }

        // Initialize stencil masks from computed bit mask
        glCtx.stencilState.setValueMaskFront(glCtx.stencilBitMask);
@@ -1297,12 +1304,16 @@ public class GLStateManager {
                return;
            }
        }
+        final BooleanStateStack blend = ctx().blendMode;
+        final boolean wasEnabled = blend.isEffectivelyEnabled();
        final DeferredBlendHandler bh = GLSMHooks.blendHandler;
        if (bh != null && bh.isBlendLocked()) {
+            blend.beforeModify();
            bh.deferBlendModeToggle(true);
-            return;
+        } else {
+            blend.enable();
        }
-        ctx().blendMode.enable();
+        if (!wasEnabled && blend.isEffectivelyEnabled()) postVanillaBlendChange();
    }

    public static void disableBlend() {
@@ -1313,12 +1324,80 @@ public class GLStateManager {
                return;
            }
        }
+        final BooleanStateStack blend = ctx().blendMode;
+        final boolean wasEnabled = blend.isEffectivelyEnabled();
        final DeferredBlendHandler bh = GLSMHooks.blendHandler;
        if (bh != null && bh.isBlendLocked()) {
+            blend.beforeModify();
            bh.deferBlendModeToggle(false);
-            return;
+        } else {
+            blend.disable();
        }
-        ctx().blendMode.disable();
+        if (wasEnabled && !blend.isEffectivelyEnabled()) postVanillaBlendChange();
+    }
+
+    private static void postVanillaBlendChange() {
+        if (GLSMHooks.VANILLA_BLEND_CHANGE.hasListeners()) {
+            GLSMHooks.VANILLA_BLEND_CHANGE.post(GLSMHooks.vanillaBlendChangeEvent);
+        }
+    }
+
+    private static boolean snapshotVanillaBlendFunc() {
+        if (!GLSMHooks.VANILLA_BLEND_CHANGE.hasListeners()) return false;
+        final GLContextState glCtx = ctx();
+        glCtx.blendState.readEffective(glCtx.vanillaBlendBefore);
+        glCtx.vanillaBlendEnabledBefore = glCtx.blendMode.isEffectivelyEnabled();
+        return true;
+    }
+
+    private static void postVanillaBlendChangeIfMoved(boolean snapshotted) {
+        if (!snapshotted) return;
+        final GLContextState glCtx = ctx();
+        final BlendState before = glCtx.vanillaBlendBefore;
+        final BlendState after = glCtx.blendState.readEffective(glCtx.vanillaBlendAfter);
+        if (glCtx.blendMode.isEffectivelyEnabled() != glCtx.vanillaBlendEnabledBefore
+            || after.getSrcRgb() != before.getSrcRgb()
+            || after.getDstRgb() != before.getDstRgb()
+            || after.getSrcAlpha() != before.getSrcAlpha()
+            || after.getDstAlpha() != before.getDstAlpha()) {
+            postVanillaBlendChange();
+        }
+    }
+
+    public static boolean isEffectiveBlendEnabled() {
+        return ctx().blendMode.isEffectivelyEnabled();
+    }
+
+    public static BlendState getEffectiveBlendState(BlendState out) {
+        return ctx().blendState.readEffective(out);
+    }
+
+    public static boolean isEffectiveDepthMaskEnabled() {
+        return ctx().depthState.isEffectiveMaskEnabled();
+    }
+
+    public static boolean isEffectiveAlphaTestEnabled() {
+        return ctx().alphaTest.isEffectivelyEnabled();
+    }
+
+    public static AlphaState getEffectiveAlphaState(AlphaState out) {
+        return ctx().alphaState.readEffective(out);
+    }
+
+    private static int foreignDrawDepth;
+
+    public static void beginForeignDraw() {
+        foreignDrawDepth++;
+    }
+
+    public static void endForeignDraw() {
+        if (foreignDrawDepth > 0 && --foreignDrawDepth == 0 && GLSMHooks.FOREIGN_DRAW_END.hasListeners()) {
+            GLSMHooks.FOREIGN_DRAW_END.post(GLSMHooks.foreignDrawEndEvent);
+        }
+    }
+
+    public static boolean isForeignDraw() {
+        return foreignDrawDepth > 0;
    }

    public static void enableScissorTest() {
@@ -1352,9 +1431,11 @@ public class GLStateManager {
                return;
            }
        }
+        final boolean snapshotted = snapshotVanillaBlendFunc();
        final DeferredBlendHandler bh = GLSMHooks.blendHandler;
        if (bh != null && bh.isBlendLocked()) {
            bh.deferBlendFunc(srcFactor, dstFactor, srcFactor, dstFactor);
+            postVanillaBlendChangeIfMoved(snapshotted);
            return;
        }
        final boolean caching = isCachingEnabled();
@@ -1368,6 +1449,7 @@ public class GLStateManager {
                GLSMHooks.blendFuncChangeEvent.dstAlpha = GL11.GL_ONE_MINUS_SRC_ALPHA;
                GLSMHooks.BLEND_FUNC_CHANGE.post(GLSMHooks.blendFuncChangeEvent);
            }
+            postVanillaBlendChangeIfMoved(snapshotted);
            return;
        }
        final boolean bypass = !caching;
@@ -1386,6 +1468,7 @@ public class GLStateManager {
                GLSMHooks.BLEND_FUNC_CHANGE.post(GLSMHooks.blendFuncChangeEvent);
            }
        }
+        postVanillaBlendChangeIfMoved(snapshotted);
    }

    public static void glBlendEquation(int mode) {
@@ -1425,9 +1508,11 @@ public class GLStateManager {
                return;
            }
        }
+        final boolean snapshotted = snapshotVanillaBlendFunc();
        final DeferredBlendHandler bh = GLSMHooks.blendHandler;
        if (bh != null && bh.isBlendLocked()) {
            bh.deferBlendFunc(srcRgb, dstRgb, srcAlpha, dstAlpha);
+            postVanillaBlendChangeIfMoved(snapshotted);
            return;
        }
        if (GLSMConfig.hudCacheOverride && dstAlpha != GL11.GL_ONE_MINUS_SRC_ALPHA) {
@@ -1447,6 +1532,7 @@ public class GLStateManager {
                GLSMHooks.BLEND_FUNC_CHANGE.post(GLSMHooks.blendFuncChangeEvent);
            }
        }
+        postVanillaBlendChangeIfMoved(snapshotted);
    }

    public static void glBlendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
@@ -1741,6 +1827,7 @@ public class GLStateManager {
        }
        final DeferredAlphaHandler ah = GLSMHooks.alphaHandler;
        if (ah != null && ah.isAlphaTestLocked()) {
+            glCtx.alphaTest.beforeModify();
            ah.deferAlphaTestToggle(true);
            return;
        }
@@ -1762,6 +1849,7 @@ public class GLStateManager {
        }
        final DeferredAlphaHandler ah = GLSMHooks.alphaHandler;
        if (ah != null && ah.isAlphaTestLocked()) {
+            glCtx.alphaTest.beforeModify();
            ah.deferAlphaTestToggle(false);
            return;
        }
@@ -1965,6 +2053,7 @@ public class GLStateManager {
        suspendPixelUnpackBuffer();
        RENDER_BACKEND.texImage2D(target, level, internalformat, width, height, border, format, type, pixels);
        restorePixelUnpackBuffer();
+        if (mode == RecordMode.NONE && RenderSystem.isLTW()) LTWWorkaround.onTexImage2D(target, level, format, pixels != null);
        maybeGenerateMipmap(target, level);
    }

@@ -1983,6 +2072,7 @@ public class GLStateManager {
        suspendPixelUnpackBuffer();
        RENDER_BACKEND.texImage2D(target, level, internalformat, width, height, border, format, type, pixels);
        restorePixelUnpackBuffer();
+        if (mode == RecordMode.NONE && RenderSystem.isLTW()) LTWWorkaround.onTexImage2D(target, level, format, pixels != null);
        maybeGenerateMipmap(target, level);
    }

@@ -2001,6 +2091,7 @@ public class GLStateManager {
        suspendPixelUnpackBuffer();
        RENDER_BACKEND.texImage2D(target, level, internalformat, width, height, border, format, type, pixels);
        restorePixelUnpackBuffer();
+        if (mode == RecordMode.NONE && RenderSystem.isLTW()) LTWWorkaround.onTexImage2D(target, level, format, pixels != null);
        maybeGenerateMipmap(target, level);
    }

@@ -2019,6 +2110,7 @@ public class GLStateManager {
        suspendPixelUnpackBuffer();
        RENDER_BACKEND.texImage2D(target, level, internalformat, width, height, border, format, type, pixels);
        restorePixelUnpackBuffer();
+        if (mode == RecordMode.NONE && RenderSystem.isLTW()) LTWWorkaround.onTexImage2D(target, level, format, pixels != null);
        maybeGenerateMipmap(target, level);
    }

@@ -3049,9 +3141,15 @@ public class GLStateManager {
                return;
            }
        }
+        if (light >= VertexKey.FFP_LIGHT_COUNT && (warnedFfpLightMask & (1 << light)) == 0 && ShaderManager.getInstance().isEnabled()) {
+            warnedFfpLightMask |= (1 << light);
+            LOGGER.warn("GL_LIGHT{} enabled, but FFP shader emulation implements only GL_LIGHT0..{}", light, VertexKey.FFP_LIGHT_COUNT - 1, new Throwable("call site"));
+        }
        ctx().lightStates[light].enable();
    }

+    private static int warnedFfpLightMask = 0;
+
    public static void enableColorMaterial() {
        final RecordMode mode = DisplayListManager.getRecordMode();
        if (mode != RecordMode.NONE) {
@@ -3374,14 +3472,11 @@ public class GLStateManager {
    }

    public static boolean isCurrent() {
-        if (BackendManager.RENDER_BACKEND == null) {
-            return Thread.currentThread() == MainThread;
-        }
-        return BackendManager.RENDER_BACKEND.isCurrent();
+        return RENDER_BACKEND.isCurrent();
    }

    public static void swapBuffers() throws LWJGLException {
-        if (BackendManager.RENDER_BACKEND != null && BackendManager.RENDER_BACKEND.handleSwapBuffers()) {
+        if (RENDER_BACKEND.handleSwapBuffers()) {
            return;
        }
        Display.swapBuffers();
@@ -3397,7 +3492,14 @@ public class GLStateManager {
            if (processMessages) Display.processMessages();
            return;
        }
+        if (!RENDER_BACKEND.wantsDisplayUpdateGateTiming()) {
+            Display.update(processMessages);
+            return;
+        }
+        final long start = System.nanoTime();
        Display.update(processMessages);
+        final long end = System.nanoTime();
+        RENDER_BACKEND.recordFrameGate(end - start, end);
    }

    /**
@@ -3513,6 +3615,9 @@ public class GLStateManager {
        final int mask = glCtx.attribs.popInt();
        glCtx.attribDepth--;

+        // Snapshot before the stacks pop, so applyRestoredState can tell whether vanilla blend actually moved.
+        final boolean blendSnapshotted = (mask & (GL11.GL_COLOR_BUFFER_BIT | GL11.GL_ENABLE_BIT)) != 0 && snapshotVanillaBlendFunc();
+
        // First: restore BooleanStateStack states that were actually modified (fast path)
        // These use lazy copy-on-write with global depth tracking
        final List<IStateStack<?>> modified = glCtx.modifiedAtDepth[glCtx.attribDepth];
@@ -3531,7 +3636,12 @@ public class GLStateManager {

        // Third: apply restored state to the GL driver. BooleanStateStacks already issue GL calls via setEnabled(); non-boolean stacks are pure data
        // containers, so we must explicitly drive GL here.
-        applyRestoredState(mask);
+        applyRestoredState(mask, blendSnapshotted);
+    }
+
+    private static boolean isDepthColorOverridden() {
+        final DeferredDepthColorHandler dch = GLSMHooks.depthColorHandler;
+        return dch != null && dch.isOverrideHeld();
    }

    private static void captureRestoreChanges(int mask) {
@@ -3620,20 +3730,25 @@ public class GLStateManager {
    /**
     * After popping GLSM stacks, apply restored state to the GL driver.
     */
-    private static void applyRestoredState(int mask) {
+    private static void applyRestoredState(int mask, boolean blendSnapshotted) {
        final GLContextState glCtx = ctx();
        if ((mask & GL11.GL_DEPTH_BUFFER_BIT) != 0 && glCtx.restoreDepthChanged) {
            RENDER_BACKEND.depthFunc(glCtx.depthState.getFunc());
-            RENDER_BACKEND.depthMask(glCtx.depthState.isEnabled());
+            if (!isDepthColorOverridden()) {
+                RENDER_BACKEND.depthMask(glCtx.depthState.isEnabled());
+            }
            RENDER_BACKEND.clearDepth(glCtx.depthState.getClearValue());
        }
        if ((mask & GL11.GL_COLOR_BUFFER_BIT) != 0) {
            if (glCtx.restoreBlendChanged) {
-                RENDER_BACKEND.blendFuncSeparate(glCtx.blendState.getSrcRgb(), glCtx.blendState.getDstRgb(), glCtx.blendState.getSrcAlpha(), glCtx.blendState.getDstAlpha());
+                final DeferredBlendHandler restoreBlendHandler = GLSMHooks.blendHandler;
+                if (restoreBlendHandler == null || !restoreBlendHandler.isOverrideHeld()) {
+                    RENDER_BACKEND.blendFuncSeparate(glCtx.blendState.getSrcRgb(), glCtx.blendState.getDstRgb(), glCtx.blendState.getSrcAlpha(), glCtx.blendState.getDstAlpha());
+                }
                RENDER_BACKEND.blendEquationSeparate(glCtx.blendState.getEquationRgb(), glCtx.blendState.getEquationAlpha());
                RENDER_BACKEND.blendColor(glCtx.blendState.getBlendColorR(), glCtx.blendState.getBlendColorG(), glCtx.blendState.getBlendColorB(), glCtx.blendState.getBlendColorA());
            }
-            if (glCtx.restoreColorMaskChanged) {
+            if (glCtx.restoreColorMaskChanged && !isDepthColorOverridden()) {
                RENDER_BACKEND.colorMask(glCtx.colorMask.red, glCtx.colorMask.green, glCtx.colorMask.blue, glCtx.colorMask.alpha);
            }
            if (glCtx.restoreClearColorChanged) {
@@ -3718,6 +3833,8 @@ public class GLStateManager {
                glCtx.dirtyTexCoordAttrib = true;
            }
        }
+
+        postVanillaBlendChangeIfMoved(blendSnapshotted);
    }

    public static void glClear(int mask) {
@@ -4510,7 +4627,10 @@ public class GLStateManager {
        RENDER_BACKEND.readPixels(x, y, width, height, format, type, pixels);
        restorePixelPackBuffer();
    }
-    public static void glTexStorage2D(int target, int levels, int internalFormat, int width, int height) { RENDER_BACKEND.texStorage2D(target, levels, internalFormat, width, height); }
+    public static void glTexStorage2D(int target, int levels, int internalFormat, int width, int height) {
+        RENDER_BACKEND.texStorage2D(target, levels, internalFormat, width, height);
+        TextureInfoCache.INSTANCE.onTexStorage2D(target, internalFormat, width, height);
+    }
    public static void glClearTexImage(int texture, int level, int format, int type, ByteBuffer data) { RENDER_BACKEND.clearTexImage(texture, level, format, type); }

    public static int glGenSamplers() { return RENDER_BACKEND.genSamplers(); }
@@ -4903,16 +5023,22 @@ public class GLStateManager {
        final ShaderManager ffp = ShaderManager.getInstance();
        if (program == 0 && ffp.isEnabled()) {
            final int prev = glCtx.activeProgram;
-            final boolean caching = isCachingEnabled();
-            if (prev != 0) glCtx.programGeneration++;
+            final boolean changed = prev != 0;
+            if (changed) glCtx.programGeneration++;
            glCtx.activeProgram = 0; // Track that FFP was requested
-            if (GLSMHooks.PROGRAM_CHANGE.hasListeners()) {
+            if (changed && GLSMHooks.PROGRAM_CHANGE.hasListeners()) {
                GLSMHooks.programChangeEvent.previousProgram = prev;
                GLSMHooks.programChangeEvent.newProgram = 0;
                GLSMHooks.programChangeEvent.postBind = false;
                GLSMHooks.PROGRAM_CHANGE.post(GLSMHooks.programChangeEvent);
            }
            ffp.activate();
+            if (changed && GLSMHooks.PROGRAM_CHANGE.hasListeners()) {
+                GLSMHooks.programChangeEvent.previousProgram = prev;
+                GLSMHooks.programChangeEvent.newProgram = 0;
+                GLSMHooks.programChangeEvent.postBind = true;
+                GLSMHooks.PROGRAM_CHANGE.post(GLSMHooks.programChangeEvent);
+            }
            return;
        }

@@ -5039,6 +5165,54 @@ public class GLStateManager {
        RENDER_BACKEND.setVSyncEnabled(enabled);
    }

+    public static void setVSyncMode(VSyncMode mode) {
+        RENDER_BACKEND.setVSyncMode(mode);
+    }
+
+    public static void setVSyncPreference(VSyncMode mode) {
+        RENDER_BACKEND.setVSyncPreference(mode);
+    }
+
+    public static boolean supportsVSyncMode(VSyncMode mode) {
+        return RENDER_BACKEND.supportsVSyncMode(mode);
+    }
+
+    public static VSyncMode preferredTearFreeMode() {
+        return RENDER_BACKEND.preferredTearFreeMode();
+    }
+
+    public static String getRenderBackendName() {
+        return RENDER_BACKEND.getName();
+    }
+
+    public static VSyncMode getEffectiveVSyncMode() {
+        return RENDER_BACKEND.getEffectiveVSyncMode();
+    }
+
+    public static int getDisplayRefreshRateHz() {
+        return RENDER_BACKEND.getDisplayRefreshRateHz();
+    }
+
+    public static boolean gateAnchorsNextFrameStart() {
+        return RENDER_BACKEND.gateAnchorsNextFrameStart();
+    }
+
+    public static long lastFrameGateNanos() {
+        return RENDER_BACKEND.lastFrameGateNanos();
+    }
+
+    public static long lastFrameGateEndNanos() {
+        return RENDER_BACKEND.lastFrameGateEndNanos();
+    }
+
+    public static boolean hasSwapchainBackpressure() {
+        return RENDER_BACKEND.hasSwapchainBackpressure();
+    }
+
+    public static void pumpDisplayMessages() {
+        Display.processMessages();
+    }
+
    public static int glGetError() {
        if (!RENDER_BACKEND.hasContext()) return 0;
        if (initConfig.isNoErrorChecks()) return 0;
@@ -5119,6 +5293,7 @@ public class GLStateManager {
        suspendPixelUnpackBuffer();
        RENDER_BACKEND.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
        restorePixelUnpackBuffer();
+        TextureInfoCache.INSTANCE.onTexSubImage2D(target, level);
        maybeGenerateMipmap(target, level);
    }

@@ -5134,6 +5309,7 @@ public class GLStateManager {
        suspendPixelUnpackBuffer();
        RENDER_BACKEND.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
        restorePixelUnpackBuffer();
+        TextureInfoCache.INSTANCE.onTexSubImage2D(target, level);
        maybeGenerateMipmap(target, level);
    }

@@ -5143,6 +5319,7 @@ public class GLStateManager {
            throw DisplayListManager.unsupportedInList("glTexSubImage2D with buffer offset");
        }
        RENDER_BACKEND.texSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels_buffer_offset);
+        TextureInfoCache.INSTANCE.onTexSubImage2D(target, level);
        maybeGenerateMipmap(target, level);
    }

@@ -5183,6 +5360,7 @@ public class GLStateManager {
            throw DisplayListManager.unsupportedInList("glCopyTexSubImage2D");
        }
        RENDER_BACKEND.copyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
+        TextureInfoCache.INSTANCE.onTexSubImage2D(target, level);
        maybeGenerateMipmap(target, level);
    }

@@ -2,8 +2,10 @@ package com.gtnewhorizons.angelica.glsm;

 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.Token;
+import org.antlr.v4.runtime.WritableToken;
 import org.antlr.v4.runtime.tree.ParseTree;
 import org.antlr.v4.runtime.tree.TerminalNode;
 import org.taumc.glsl.grammar.GLSLLexer;
@@ -88,6 +90,23 @@ public class GlslTransformUtils {
        return source;
    }

+    public static void restoreReservedWordsInTree(ParseTree tree) {
+        if (tree instanceof TerminalNode terminal) {
+            final Token token = terminal.getSymbol();
+            final String text = token.getText();
+            if (text != null && text.startsWith(RENAMED_PREFIX) && token instanceof WritableToken writable) {
+                final String rest = text.substring(RENAMED_PREFIX.length());
+                if (rest.startsWith("texture") || rest.startsWith("sample")) {
+                    writable.setText(rest);
+                }
+            }
+            return;
+        }
+        for (int i = 0; i < tree.getChildCount(); i++) {
+            restoreReservedWordsInTree(tree.getChild(i));
+        }
+    }
+
    public record QuietParse(GLSLParser.Translation_unitContext full, GLSLPreParser.Translation_unitContext pre) {}

    public static GLSLParser.Translation_unitContext parseFullQuiet(String source) {
@@ -162,21 +181,32 @@ public class GlslTransformUtils {
    public static String getFormattedShader(ParseTree tree, String header) {
        final StringBuilder sb = new StringBuilder(header + "\n");
        final String[] tabHolder = {""};
-        getFormattedShader(tree, sb, tabHolder);
+        getFormattedShader(tree, sb, tabHolder, false);
        return sb.toString();
    }

-    private static void getFormattedShader(ParseTree tree, StringBuilder stringBuilder, String[] tabHolder) {
-        if (tree instanceof TerminalNode) {
+    public static String getFormattedShaderRebased(ParseTree tree, String header) {
+        final StringBuilder sb = new StringBuilder(header + "\n");
+        final String[] tabHolder = {""};
+        getFormattedShader(tree, sb, tabHolder, true);
+        return sb.toString();
+    }
+
+    private static void getFormattedShader(ParseTree tree, StringBuilder stringBuilder, String[] tabHolder, boolean rebaseOffsets) {
+        if (tree instanceof TerminalNode terminal) {
            final String text = tree.getText();
            if (text.equals("<EOF>")) {
                return;
            }
            if (text.equals("#")) {
                stringBuilder.append("\n#");
+                rebaseAt(terminal, stringBuilder.length() - 1, text, rebaseOffsets);
                return;
            }
            stringBuilder.append(text);
+            if (!text.equals("}")) {
+                rebaseAt(terminal, stringBuilder.length() - text.length(), text, rebaseOffsets);
+            }
            if (text.equals("{")) {
                stringBuilder.append(" \n\t");
                tabHolder[0] = "\t";
@@ -186,6 +216,7 @@ public class GlslTransformUtils {
                if (stringBuilder.length() >= 2) {
                    stringBuilder.deleteCharAt(stringBuilder.length() - 2);
                }
+                rebaseAt(terminal, stringBuilder.length() - 1, text, rebaseOffsets);
                tabHolder[0] = "";
                stringBuilder.append(" \n");
            } else {
@@ -193,8 +224,17 @@ public class GlslTransformUtils {
            }
        } else {
            for (int i = 0; i < tree.getChildCount(); ++i) {
-                getFormattedShader(tree.getChild(i), stringBuilder, tabHolder);
+                getFormattedShader(tree.getChild(i), stringBuilder, tabHolder, rebaseOffsets);
            }
        }
    }
+
+    private static void rebaseAt(TerminalNode terminal, int startIndex, String text, boolean rebaseOffsets) {
+        if (!rebaseOffsets) return;
+        if (terminal.getSymbol() instanceof CommonToken common) {
+            common.setText(text);
+            common.setStartIndex(startIndex);
+            common.setStopIndex(startIndex + text.length() - 1);
+        }
+    }
 }
@@ -0,0 +1,34 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import com.gtnewhorizons.angelica.glsm.states.PixelUnpackState;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+
+import java.nio.ByteBuffer;
+
+import static com.gtnewhorizons.angelica.glsm.backend.BackendManager.RENDER_BACKEND;
+
+public final class LTWWorkaround {
+
+    private LTWWorkaround() {}
+
+    private static ByteBuffer oneTexel;
+
+    public static boolean isLtwVersionString(String glVersion) {
+        return glVersion != null && glVersion.contains("LTW");
+    }
+
+    public static void onTexImage2D(int target, int level, int format, boolean hasPixels) {
+        if (target != GL11.GL_TEXTURE_2D || level != 0 || format != GL12.GL_BGRA || hasPixels) return;
+        if (oneTexel == null) {
+            oneTexel = BufferUtils.createByteBuffer(4);
+        }
+        oneTexel.clear();
+        GLStateManager.forcePixelUnpackState(PixelUnpackState.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);
+    }
+}
@@ -1,5 +1,6 @@
 package com.gtnewhorizons.angelica.glsm;

+import com.gtnewhorizons.angelica.config.SystemProperties;
 import com.gtnewhorizons.angelica.glsm.backend.BackendManager;
 import com.gtnewhorizons.angelica.glsm.dsa.DSAARB;
 import com.gtnewhorizons.angelica.glsm.dsa.DSAAccess;
@@ -8,6 +9,7 @@ import com.gtnewhorizons.angelica.glsm.dsa.DSAEXT;
 import com.gtnewhorizons.angelica.glsm.dsa.DSAUnsupported;
 import com.gtnewhorizons.angelica.glsm.ffp.ShaderManager;
 import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
+import com.mitchej123.lwjgl.LWJGLServiceProvider;
 import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 import org.joml.Matrix4f;
@@ -59,6 +61,9 @@ public class RenderSystem {
    private static volatile boolean glesDetected;
    private static volatile boolean hasClipCullDistance;

+    private static volatile boolean isLTW;
+    private static volatile boolean ltwDetected;
+
    // Sampler object state tracking (null if unsupported)
    private static int[] samplers;

@@ -107,6 +112,13 @@ public class RenderSystem {

        BackendManager.init();

+        try {
+            // Force init on client thread
+            GLStateManager.LOGGER.info("Celeritas LWJGL service: {}", LWJGLServiceProvider.LWJGL.getClass().getName());
+        } catch (Throwable t) {
+            GLStateManager.LOGGER.debug("Could not resolve the celeritas LWJGL service: {}", t.toString());
+        }
+
        supportsCompute = supportsCompute();
        supportsTesselation = GLStateManager.capabilities.GL_ARB_tessellation_shader || GLStateManager.capabilities.OpenGL40;

@@ -403,6 +415,26 @@ public class RenderSystem {
        }
    }

+    public static boolean isLTW() {
+        if (!ltwDetected) detectLTW();
+        return isLTW;
+    }
+
+    private static synchronized void detectLTW() {
+        if (ltwDetected) return;
+        if (SystemProperties.DISABLE_LTW_WORKAROUND) {
+            ltwDetected = true;
+            return;
+        }
+        try {
+            final String v = RENDER_BACKEND.getString(GL11.GL_VERSION);
+            if (v == null) return;
+            isLTW = LTWWorkaround.isLtwVersionString(v);
+            ltwDetected = true;
+        } catch (Throwable ignored) {
+        }
+    }
+
    public static boolean supportsSSBO() {
        return supportsSSBO;
    }
@@ -10,6 +10,7 @@ import org.lwjgl.opengl.ARBDebugOutputCallback;
 import org.lwjgl.opengl.ARBDirectStateAccess;
 import org.lwjgl.opengl.ARBTimerQuery;
 import org.lwjgl.opengl.ContextCapabilities;
+import org.lwjgl.opengl.DisplayMode;
 import org.lwjgl.opengl.EXTDirectStateAccess;
 import org.lwjgl.opengl.EXTShaderImageLoadStore;
 import org.lwjgl.opengl.GLContext;
@@ -114,7 +115,19 @@ public final class Lwjgl2GLRenderBackend extends RenderBackend {
    public int getMinGLSLVersion() {return 330;}

    @Override
-    public void setVSyncEnabled(boolean enabled) {Display.setVSyncEnabled(enabled);}
+    protected VSyncMode applyVSyncMode(VSyncMode preferred) {
+        final boolean enabled = preferred.tearFree();
+        Display.setVSyncEnabled(enabled);
+        return enabled ? VSyncMode.ON : VSyncMode.OFF;
+    }
+
+    @Override
+    protected int queryDisplayRefreshRateHz() {
+        final DisplayMode mode = Display.getDisplayMode();
+        if (mode != null && mode.getFrequency() > 0) return mode.getFrequency();
+        final DisplayMode desktop = Display.getDesktopDisplayMode();
+        return desktop == null ? 0 : desktop.getFrequency();
+    }

    @Override
    public boolean isAnisotropicSupported() {
@@ -12,6 +12,7 @@ import java.nio.IntBuffer;
 import java.nio.ShortBuffer;
 import java.util.Collections;
 import java.util.List;
+import java.util.function.Predicate;

 /**
 * Abstract rendering backend.
@@ -62,7 +63,77 @@ public abstract class RenderBackend {
    public abstract void flush();
    public abstract void finish();

-    public abstract void setVSyncEnabled(boolean enabled);
+    private VSyncMode effectiveVSyncMode = VSyncMode.ON;
+    private VSyncMode preferredTearFreeMode;
+
+    public final void setVSyncEnabled(boolean enabled) {
+        setVSyncMode(enabled ? preferredTearFreeMode() : VSyncMode.OFF);
+    }
+
+    public final void setVSyncMode(VSyncMode preferred) {
+        setVSyncPreference(preferred);
+        publishVSyncMode(applyVSyncMode(preferred));
+    }
+
+    public final void setVSyncPreference(VSyncMode preferred) {
+        if (preferred.tearFree()) preferredTearFreeMode = preferred;
+    }
+
+    public final VSyncMode preferredTearFreeMode() {
+        return resolveTearFreeMode(preferredTearFreeMode, this::supportsVSyncMode);
+    }
+
+    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;
+    }
+
+    protected abstract VSyncMode applyVSyncMode(VSyncMode preferred);
+
+    public boolean supportsVSyncMode(VSyncMode mode) { return mode != VSyncMode.MAILBOX; }
+
+    protected final void publishVSyncMode(VSyncMode mode) { effectiveVSyncMode = mode; }
+
+    public final VSyncMode getEffectiveVSyncMode() { return effectiveVSyncMode; }
+
+    private static final long REFRESH_POLL_NANOS = 1_000_000_000L;
+
+    private long refreshPollNanos;
+    private int cachedRefreshHz;
+
+    public final int getDisplayRefreshRateHz() {
+        final long now = System.nanoTime();
+        if (refreshPollNanos == 0L || now - refreshPollNanos >= REFRESH_POLL_NANOS) {
+            refreshPollNanos = now;
+            cachedRefreshHz = queryDisplayRefreshRateHz();
+        }
+        return cachedRefreshHz;
+    }
+
+    protected int queryDisplayRefreshRateHz() { return 0; }
+
+    public static int refreshHzFrom(int numerator, int denominator, float fallbackHz) {
+        if (numerator > 0 && denominator > 0) return (numerator + denominator - 1) / denominator;
+        return fallbackHz > 0.0f ? (int) Math.ceil(fallbackHz) : 0;
+    }
+
+    public boolean hasSwapchainBackpressure() { return false; }
+
+    private long frameGateNanos;
+    private long frameGateEndNanos;
+
+    public boolean gateAnchorsNextFrameStart() { return false; }
+
+    public boolean wantsDisplayUpdateGateTiming() { return true; }
+
+    public void recordFrameGate(long durationNanos, long endNanos) {
+        frameGateNanos = durationNanos;
+        frameGateEndNanos = endNanos;
+    }
+
+    public long lastFrameGateNanos() { return frameGateNanos; }
+
+    public long lastFrameGateEndNanos() { return frameGateEndNanos; }

    public void onFrameBegin() {
        if (GLStateManager.takeStateSeedPending()) {
@@ -0,0 +1,11 @@
+package com.gtnewhorizons.angelica.glsm.backend;
+
+public enum VSyncMode {
+    OFF,
+    ON,
+    MAILBOX;
+
+    public boolean tearFree() {
+        return this != OFF;
+    }
+}
@@ -0,0 +1,83 @@
+package com.gtnewhorizons.angelica.glsm.ffp;
+
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.states.LightState;
+import com.gtnewhorizons.angelica.glsm.states.MaterialState;
+import org.joml.Matrix3f;
+import org.joml.Vector3f;
+import org.joml.Vector4f;
+
+public final class FFPVertexLighting {
+
+    private static final Vector3f scratchNormal = new Vector3f();
+    private static final Vector3f scratchLightVec = new Vector3f();
+    private static final Vector4f scratchEyePos = new Vector4f();
+    private static final Matrix3f scratchNormalMat = new Matrix3f();
+    private static final Vector3f scratchVec = new Vector3f();
+
+    private FFPVertexLighting() {}
+
+    public static boolean modulatesVertexColor(Vector3f destFactor) {
+        destFactor.set(1.0f);
+
+        if (!GLStateManager.getLightingState().isEnabled()) return false;
+        if (!GLStateManager.getColorMaterial().isEnabled()) return false;
+        if (VertexKey.encodeColorMaterialMode(GLStateManager.getColorMaterialParameter().getValue()) != VertexKey.CM_AMBIENT_AND_DIFFUSE) return false;
+
+        final MaterialState material = GLStateManager.getFrontMaterial();
+        if (material.emission.x != 0.0f || material.emission.y != 0.0f || material.emission.z != 0.0f)
+            return false;
+
+        final boolean materialHasSpecular = material.shininess > 0.0f && (material.specular.x != 0.0f || material.specular.y != 0.0f || material.specular.z != 0.0f);
+
+        final Vector4f lightModelAmbient = GLStateManager.getLightModel().ambient;
+        float r = lightModelAmbient.x;
+        float g = lightModelAmbient.y;
+        float b = lightModelAmbient.z;
+
+        final var lightEnables = GLStateManager.getLightStates();
+        final var lightData = GLStateManager.getLightDataStates();
+        boolean normalReady = false;
+
+        for (int i = 0; i < VertexKey.FFP_LIGHT_COUNT; i++) {
+            if (!lightEnables[i].isEnabled()) continue;
+            final LightState light = lightData[i];
+            if (materialHasSpecular && (light.specular.x != 0.0f || light.specular.y != 0.0f || light.specular.z != 0.0f))
+                return false;
+            if (!normalReady) {
+                transformCurrentNormal();
+                normalReady = true;
+            }
+            final float nDotVP = Math.max(scratchNormal.dot(lightDirection(light)), 0.0f);
+            r += light.ambient.x + nDotVP * light.diffuse.x;
+            g += light.ambient.y + nDotVP * light.diffuse.y;
+            b += light.ambient.z + nDotVP * light.diffuse.z;
+        }
+
+        if (r == 1.0f && g == 1.0f && b == 1.0f) return false;
+        if (!Float.isFinite(r + g + b)) return false;
+        destFactor.set(r, g, b);
+        return true;
+    }
+
+    private static void transformCurrentNormal() {
+        GLStateManager.getModelViewMatrix().normal(scratchNormalMat);
+        scratchNormal.set(ShaderManager.getCurrentNormal());
+        scratchNormalMat.transform(scratchNormal);
+        if (GLStateManager.getNormalizeState().isEnabled()) {
+            scratchNormal.normalize();
+        } else if (GLStateManager.getRescaleNormalState().isEnabled()) {
+            scratchNormal.mul(Uniforms.rescaleFactor(scratchNormalMat, scratchVec));
+        }
+    }
+
+    private static Vector3f lightDirection(LightState light) {
+        if (light.position.w == 0.0f) {
+            scratchLightVec.set(light.position.x, light.position.y, light.position.z);
+        } else {
+            scratchEyePos.set(0.0f, 0.0f, 0.0f, 1.0f).mul(GLStateManager.getModelViewMatrix());
+            scratchLightVec.set(light.position.x - scratchEyePos.x, light.position.y - scratchEyePos.y, light.position.z - scratchEyePos.z);
+        }
+        return scratchLightVec.normalize();
+    }
+}
@@ -232,8 +232,12 @@ public class Uniforms {
    private void stageNormalMatrix() {
        GLStateManager.getModelViewMatrix().normal(normalMatrix);
        putMat3(FFPUniformBlock.NORMAL_MATRIX, normalMatrix);
-        final float scale = 1.0f / normalMatrix.getColumn(0, tempVec3).length();
-        putFloat(FFPUniformBlock.NORMAL_SCALE, scale);
+        putFloat(FFPUniformBlock.NORMAL_SCALE, rescaleFactor(normalMatrix, tempVec3));
+    }
+
+    static float rescaleFactor(Matrix3f normalMatrix, Vector3f scratch) {
+        final float f = normalMatrix.getColumn(2, scratch).lengthSquared();
+        return f > 1.0e-12f ? 1.0f / (float) Math.sqrt(f) : 1.0f;
    }

    private void stageTextureMatrices() {
@@ -20,38 +20,36 @@ public final class VertexKey {

    public static final int MAX_UNITS = 4;

+    public static final int FFP_LIGHT_COUNT = 2;
+
    private final long packed;

    private static final int BIT_LIGHTING            = 0;
-    private static final int BIT_LIGHT0              = 1;
-    private static final int BIT_LIGHT1              = 2;
-    private static final int BIT_LIGHT0_DIR          = 3;
-    private static final int BIT_LIGHT1_DIR          = 4;
-    private static final int BIT_COLOR_MATERIAL      = 5;
-    private static final int BIT_SEPARATE_SPECULAR   = 6;
-    private static final int BIT_FOG                 = 7;
-    private static final int BIT_FOG_DIST_MODE       = 8;  // 2 bits: 8-9
-    private static final int BIT_NORMALIZE           = 10;
-    private static final int BIT_RESCALE_NORMAL      = 11;
-    // Per-unit texcoord enable: bits 12-15 (unit 0..3). Unit 1 doubles as the lightmap flag.
-    private static final int BIT_UNIT_TEX_BASE       = 12;
-    private static final int BIT_HAS_VERTEX_COLOR    = 16;
-    private static final int BIT_HAS_VERTEX_NORMAL   = 17;
-    private static final int BIT_HAS_VERTEX_TEX      = 18;
-    private static final int BIT_HAS_VERTEX_LIGHTMAP = 19;
-    private static final int BIT_COLOR_MAT_MODE      = 20;  // 3 bits: 20-22
-    // TexGen modes (unit 0 only, for now): 3 bits each (0=NONE, 1=OBJ_LINEAR, 2=EYE_LINEAR).
-    private static final int BIT_TEXGEN_S            = 23;  // 3 bits: 23-25
-    private static final int BIT_TEXGEN_T            = 26;  // 3 bits: 26-28
-    private static final int BIT_TEXGEN_R            = 29;  // 3 bits: 29-31
-    private static final int BIT_TEXGEN_Q            = 32;  // 3 bits: 32-34
-    private static final int BIT_CLIP_PLANES         = 35;
-    private static final int BIT_WIDE_LINE           = 36;
-    // Per-unit texmat enable: bits 37-40 (unit 0..3). Unit 1 is the lightmap matrix.
-    private static final int BIT_UNIT_TEXMAT_BASE    = 37;
-    private static final int BIT_UNIT23_UV_FROM_UNIT0 = 41;
-    private static final int BIT_LINE_STIPPLE        = 42;
-    private static final int BIT_INSTANCED           = 44;
+    private static final int BIT_LIGHT_BASE          = BIT_LIGHTING + 1;
+    private static final int BIT_LIGHT_DIR_BASE      = BIT_LIGHT_BASE + FFP_LIGHT_COUNT;
+    private static final int BIT_COLOR_MATERIAL      = BIT_LIGHT_DIR_BASE + FFP_LIGHT_COUNT;
+    private static final int BIT_SEPARATE_SPECULAR   = BIT_COLOR_MATERIAL + 1;
+    private static final int BIT_FOG                 = BIT_SEPARATE_SPECULAR + 1;
+    private static final int BIT_FOG_DIST_MODE       = BIT_FOG + 1;
+    private static final int BIT_NORMALIZE           = BIT_FOG_DIST_MODE + 2;
+    private static final int BIT_RESCALE_NORMAL      = BIT_NORMALIZE + 1;
+    private static final int BIT_UNIT_TEX_BASE       = BIT_RESCALE_NORMAL + 1;
+    private static final int BIT_HAS_VERTEX_COLOR    = BIT_UNIT_TEX_BASE + MAX_UNITS;
+    private static final int BIT_HAS_VERTEX_NORMAL   = BIT_HAS_VERTEX_COLOR + 1;
+    private static final int BIT_HAS_VERTEX_TEX      = BIT_HAS_VERTEX_NORMAL + 1;
+    private static final int BIT_HAS_VERTEX_LIGHTMAP = BIT_HAS_VERTEX_TEX + 1;
+    private static final int BIT_COLOR_MAT_MODE      = BIT_HAS_VERTEX_LIGHTMAP + 1;
+    // TexGen modes are unit 0 only, for now.
+    private static final int BIT_TEXGEN_S            = BIT_COLOR_MAT_MODE + 3;
+    private static final int BIT_TEXGEN_T            = BIT_TEXGEN_S + 3;
+    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_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_INSTANCED           = BIT_LINE_STIPPLE + 1;

    public static final int TG_NONE                  = 0;
    public static final int TG_OBJ_LINEAR            = 1;
@@ -70,10 +68,8 @@ public final class VertexKey {
    public long pack() { return packed; }

    public boolean lightingEnabled()       { return bit(BIT_LIGHTING); }
-    public boolean light0Enabled()         { return bit(BIT_LIGHT0); }
-    public boolean light1Enabled()         { return bit(BIT_LIGHT1); }
-    public boolean light0Directional()     { return bit(BIT_LIGHT0_DIR); }
-    public boolean light1Directional()     { return bit(BIT_LIGHT1_DIR); }
+    public boolean lightEnabled(int light)     { return bit(BIT_LIGHT_BASE + light); }
+    public boolean lightDirectional(int light) { return bit(BIT_LIGHT_DIR_BASE + light); }
    public boolean colorMaterialEnabled()  { return bit(BIT_COLOR_MATERIAL); }
    public boolean separateSpecular()      { return bit(BIT_SEPARATE_SPECULAR); }
    public boolean fogEnabled()            { return bit(BIT_FOG); }
@@ -136,17 +132,12 @@ public final class VertexKey {
        if (lighting) {
            bits |= (1L << BIT_LIGHTING);

-            if (GLStateManager.getLightStates()[0].isEnabled()) {
-                bits |= (1L << BIT_LIGHT0);
+            for (int i = 0; i < FFP_LIGHT_COUNT; i++) {
+                if (!GLStateManager.getLightStates()[i].isEnabled()) continue;
+                bits |= (1L << (BIT_LIGHT_BASE + i));
                // position.w == 0 means directional
-                if (GLStateManager.getLightDataStates()[0].position.w == 0.0f) {
-                    bits |= (1L << BIT_LIGHT0_DIR);
-                }
-            }
-            if (GLStateManager.getLightStates()[1].isEnabled()) {
-                bits |= (1L << BIT_LIGHT1);
-                if (GLStateManager.getLightDataStates()[1].position.w == 0.0f) {
-                    bits |= (1L << BIT_LIGHT1_DIR);
+                if (GLStateManager.getLightDataStates()[i].position.w == 0.0f) {
+                    bits |= (1L << (BIT_LIGHT_DIR_BASE + i));
                }
            }

@@ -265,7 +256,7 @@ 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=%b]",
-            packed, lightingEnabled(), light0Enabled(), light1Enabled(),
+            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,
@@ -182,11 +182,10 @@ public final class VertexShaderGenerator {
        }

        // Per-light accumulation
-        if (key.light0Enabled()) {
-            emitLightContribution(sb, key, 0);
-        }
-        if (key.light1Enabled()) {
-            emitLightContribution(sb, key, 1);
+        for (int i = 0; i < VertexKey.FFP_LIGHT_COUNT; i++) {
+            if (key.lightEnabled(i)) {
+                emitLightContribution(sb, key, i);
+            }
        }

        sb.append("  v_Color = vec4(clamp(color0, 0.0, 1.0), outAlpha);\n");
@@ -198,7 +197,7 @@ public final class VertexShaderGenerator {

    private static void emitLightContribution(StringBuilder sb, VertexKey key, int lightIndex) {
        final String li = String.valueOf(lightIndex);
-        final boolean directional = (lightIndex == 0) ? key.light0Directional() : key.light1Directional();
+        final boolean directional = key.lightDirectional(lightIndex);
        final String posUniform = "u_Light" + li + "Position";

        sb.append("  { // Light ").append(li).append('\n');
@@ -2,6 +2,7 @@ package com.gtnewhorizons.angelica.glsm.hooks;

 public interface DeferredBlendHandler {
    boolean isBlendLocked();
+    boolean isOverrideHeld();
    void deferBlendModeToggle(boolean enabled);
    void deferBlendFunc(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha);
    void flushDeferredBlend();
@@ -2,6 +2,7 @@ package com.gtnewhorizons.angelica.glsm.hooks;

 public interface DeferredDepthColorHandler {
    boolean isDepthColorLocked();
+    boolean isOverrideHeld();
    void deferDepthEnable(boolean enabled);
    void deferColorMask(boolean r, boolean g, boolean b, boolean a);
 }
@@ -6,6 +6,14 @@ public final class GLSMConfig {
    public static float lastBrightnessX;
    public static float lastBrightnessY;

+    public static int packBrightness(float x, float y) {
+        return ((int) y << 16) | ((int) x & 0xFFFF);
+    }
+
+    public static int packedLastBrightness() {
+        return packBrightness(lastBrightnessX, lastBrightnessY);
+    }
+
    public static boolean hudCacheOverride;

    public static volatile boolean expandVertexFormats;
@@ -25,6 +25,8 @@ public final class GLSMHooks {
    public static final EventBus<LightmapCoordsEvent> LIGHTMAP_COORDS = EventBus.create(LightmapCoordsEvent.class);
    public static final EventBus<AlphaStateChangeEvent> ALPHA_STATE_CHANGE = EventBus.create(AlphaStateChangeEvent.class);
    public static final EventBus<ShaderColorChangeEvent> SHADER_COLOR_CHANGE = EventBus.create(ShaderColorChangeEvent.class);
+    public static final EventBus<ForeignDrawEndEvent> FOREIGN_DRAW_END = EventBus.create(ForeignDrawEndEvent.class);
+    public static final EventBus<VanillaBlendChangeEvent> VANILLA_BLEND_CHANGE = EventBus.create(VanillaBlendChangeEvent.class);
    public static final EventBus<LoadingCheckpointEvent> LOADING_CHECKPOINT = EventBus.create(LoadingCheckpointEvent.class);

    // Reusable event instances
@@ -38,6 +40,8 @@ public final class GLSMHooks {
    public static final LightmapCoordsEvent lightmapCoordsEvent = new LightmapCoordsEvent();
    public static final AlphaStateChangeEvent alphaStateChangeEvent = new AlphaStateChangeEvent();
    public static final ShaderColorChangeEvent shaderColorChangeEvent = new ShaderColorChangeEvent();
+    public static final ForeignDrawEndEvent foreignDrawEndEvent = new ForeignDrawEndEvent();
+    public static final VanillaBlendChangeEvent vanillaBlendChangeEvent = new VanillaBlendChangeEvent();
    public static final LoadingCheckpointEvent loadingCheckpointEvent = new LoadingCheckpointEvent();

    private GLSMHooks() {}
@@ -1,8 +1,13 @@
 package com.gtnewhorizons.angelica.glsm.hooks;

 import com.gtnewhorizons.angelica.glsm.shader.ShaderType;
+import org.taumc.glsl.grammar.GLSLParser;

@FunctionalInterface
 public interface ShaderTransformPostProcessor {
    void onTransformed(String transformedSource, ShaderType shaderType);
+
+    default void onTransformed(String transformedSource, GLSLParser.Translation_unitContext bodyTree, int headerLen, ShaderType shaderType) {
+        onTransformed(transformedSource, shaderType);
+    }
 }
@@ -0,0 +1,8 @@
+package com.gtnewhorizons.angelica.glsm.hooks;
+
+public interface VanillaBooleanLayer {
+
+    boolean isOverrideHeld();
+    boolean getVanilla();
+    void setVanilla(boolean enabled);
+}
@@ -0,0 +1,22 @@
+package com.gtnewhorizons.angelica.glsm.hooks;
+
+public interface VanillaStateLayer<T> {
+
+    boolean isOverrideHeld();
+    void readVanilla(T into);
+    void writeVanilla(T from);
+
+    static boolean isHeld(VanillaStateLayer<?> layer) {
+        return layer != null && layer.isOverrideHeld();
+    }
+
+    static <T> void capture(VanillaStateLayer<T> layer, T slot) {
+        if (isHeld(layer)) layer.readVanilla(slot);
+    }
+
+    static <T> boolean restore(VanillaStateLayer<T> layer, T saved) {
+        if (!isHeld(layer)) return false;
+        layer.writeVanilla(saved);
+        return true;
+    }
+}
@@ -0,0 +1,6 @@
+package com.gtnewhorizons.angelica.glsm.hooks.events;
+
+import net.minecraftforge.eventbus.api.event.MutableEvent;
+
+public final class ForeignDrawEndEvent extends MutableEvent {
+}
@@ -0,0 +1,6 @@
+package com.gtnewhorizons.angelica.glsm.hooks.events;
+
+import net.minecraftforge.eventbus.api.event.MutableEvent;
+
+public final class VanillaBlendChangeEvent extends MutableEvent {
+}
@@ -21,11 +21,11 @@ public final class EcosystemNarrowRules {
            "Reika.DragonAPI.ASM.StructureLootHooks"
        )),

-        new NarrowRule("Xaeros_common", "xaero.common.core", List.of(
+        new NarrowRule("Xaeros", "xaero.common.core", List.of(
            "xaero.common.core.transformer"
        )),

-        new NarrowRule("Xaeros_map", "xaero.map.core", List.of(
+        new NarrowRule("Xaeros", "xaero.map.core", List.of(
            "xaero.map.core.transformer"
        )),

@@ -78,6 +78,13 @@ public final class EcosystemNarrowRules {
            "alfheim.common.core.asm.hook.fixes.CorporeaInputFix",
            "alfheim.common.core.asm.hook.fixes.GodAttributesHooks",
            "alfheim.common.core.asm.hook.fixes.RecipeAncientWillsFix"
+        )),
+
+        new NarrowRule("LegendsMod", "com.tihyo.legends.management.asm", List.of(
+            "com.tihyo.legends.management.asm.LegendsLoadingPlugin",
+            "com.tihyo.legends.management.asm.AbstractTransformer",
+            "com.tihyo.legends.management.asm.ASMHelper",
+            "com.tihyo.legends.management.asm.Transformer"
        ))
    );

@@ -25,7 +25,7 @@ public final class TransformerNarrower {

    /**
     * A rule that replaces a broad transformer exclusion with narrower ones.
-     * @param name       Human-readable name for logging (e.g. "DragonAPI")
+     * @param name       Blackboard/config key suffix. (e.g. "DragonAPI").
     * @param broad      The broad exclusion to remove (e.g. "Reika.DragonAPI.ASM")
     * @param narrow     Narrower exclusions to add in its place
     */
@@ -0,0 +1,92 @@
+package com.gtnewhorizons.angelica.glsm.profiling;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class SectionRegistry {
+
+    public interface Emitter {
+        long enter(int category, String text);
+        void leave(long nativeId);
+        void setup(int category, String name);
+        boolean isConnected();
+    }
+
+    private static final class Category {
+        final int id;
+        final String name;
+
+        Category(int id, String name) {
+            this.id = id;
+            this.name = name;
+        }
+    }
+
+    private static final class Section {
+        final long token;
+        final int category;
+        final String text;
+        long nativeId;
+
+        Section(long token, int category, String text, long nativeId) {
+            this.token = token;
+            this.category = category;
+            this.text = text;
+            this.nativeId = nativeId;
+        }
+    }
+
+    private final Emitter emitter;
+    private final List<Category> categories = new ArrayList<>();
+    private final List<Section> open = new ArrayList<>();
+    private long nextToken;
+    private boolean connected;
+
+    public SectionRegistry(Emitter emitter) {
+        this.emitter = emitter;
+    }
+
+    public synchronized void registerCategory(int category, String name) {
+        categories.add(new Category(category, name));
+    }
+
+    public synchronized long enter(int category, String text) {
+        syncConnection();
+        final long token = ++nextToken;
+        open.add(new Section(token, category, text, emitter.enter(category, text)));
+        return token;
+    }
+
+    public synchronized void leave(long token) {
+        for (int i = 0; i < open.size(); i++) {
+            final Section section = open.get(i);
+            if (section.token == token) {
+                open.remove(i);
+                if (section.nativeId != 0L) emitter.leave(section.nativeId);
+                return;
+            }
+        }
+    }
+
+    public synchronized void poll() {
+        syncConnection();
+    }
+
+    private void syncConnection() {
+        final boolean now = emitter.isConnected();
+        if (now == connected) return;
+        connected = now;
+        if (now) replay();
+    }
+
+    private void replay() {
+        for (int i = 0; i < categories.size(); i++) {
+            final Category category = categories.get(i);
+            emitter.setup(category.id, category.name);
+        }
+        for (int i = 0; i < open.size(); i++) {
+            final Section section = open.get(i);
+            section.nativeId = emitter.enter(section.category, section.text);
+        }
+    }
+}
@@ -44,6 +44,18 @@ public final class Tracy {
    public static final int COLOR_IRIS = 0x9E862E; // gold
    public static final int COLOR_FFP = 0x7A4E9E; // purple

+    public static final int SECTION_WORLD = 1;
+    public static final int SECTION_SHADERS = 2;
+    public static final int SECTION_BENCHMARK = 3;
+    public static final int SECTION_UI = 4;
+
+    private static final SectionRegistry SECTIONS = new SectionRegistry(new SectionRegistry.Emitter() {
+        @Override public long enter(int category, String text) { return BACKEND.sectionEnter(category, text); }
+        @Override public void leave(long nativeId) { BACKEND.sectionLeave(nativeId); }
+        @Override public void setup(int category, String name) { BACKEND.sectionSetup(category, name); }
+        @Override public boolean isConnected() { return BACKEND.isConnected(); }
+    });
+
    private static final ThreadLocal<ZoneStack> STACK = new ThreadLocal<>() {
        @Override
        protected ZoneStack initialValue() {
@@ -62,6 +74,10 @@ public final class Tracy {
        FINE_ZONES = ENABLED && SystemProperties.TRACY_FINE_ZONES;
        if (ENABLED) {
            Runtime.getRuntime().addShutdownHook(new Thread(Tracy::shutdown, "Tracy-Shutdown"));
+            SECTIONS.registerCategory(SECTION_WORLD, "World");
+            SECTIONS.registerCategory(SECTION_SHADERS, "Shaders");
+            SECTIONS.registerCategory(SECTION_BENCHMARK, "Benchmark");
+            SECTIONS.registerCategory(SECTION_UI, "UI");
            LOGGER.info("Tracy profiling enabled");
        }
    }
@@ -95,6 +111,7 @@ public final class Tracy {
            LOGGER.warn("Tracy requested (-Dangelica.tracy=true) but no TracyBackend service present");
            return null;
        }
+        if (!implementsCurrentAbi(found)) return null;
        final TracyBackend backend = found;
        final CountDownLatch done = new CountDownLatch(1);
        final AtomicReference<Boolean> result = new AtomicReference<>();
@@ -120,10 +137,28 @@ public final class Tracy {
        return backend;
    }

+    private static final String ABI_SENTINEL = "sectionEnter";
+
+    private static boolean implementsCurrentAbi(TracyBackend backend) {
+        try {
+            backend.getClass().getMethod(ABI_SENTINEL, int.class, String.class);
+            return true;
+        } catch (NoSuchMethodException e) {
+            LOGGER.warn("Tracy backend {} was built against an older TracyBackend interface; profiling disabled", backend.getClass().getName());
+            return false;
+        }
+    }
+
    private record InitRunner(TracyBackend backend, CountDownLatch done, AtomicReference<Boolean> result) implements Runnable {
        @Override
        public void run() {
-            final boolean ok = backend.init();
+            boolean ok;
+            try {
+                ok = backend.init();
+            } catch (LinkageError e) {
+                LOGGER.warn("Tracy backend {} failed to link; profiling disabled: {}", backend.getClass().getName(), e);
+                ok = false;
+            }
            if (!result.compareAndSet(null, ok) && ok) {
                backend.shutdown();
            }
@@ -168,7 +203,7 @@ public final class Tracy {
            final String name = stack.poppedName();
            if (name != null && WARNED_LEAKS.add(name)) {
                LOGGER.warn("Tracy: unbalanced profiler section '{}' left open (leaked by its caller); closed at next root", name);
-                BACKEND.message("unbalanced profiler section '" + name + "' closed at root");
+                BACKEND.message("unbalanced profiler section '" + name + "' closed at root", TracyBackend.SEVERITY_WARNING);
            }
        }
    }
@@ -274,6 +309,7 @@ public final class Tracy {
            threadNameRefreshed = true;
            BACKEND.setCurrentThreadName(Thread.currentThread().getName());
        }
+        SECTIONS.poll();
        BACKEND.frameMark();
    }

@@ -330,8 +366,22 @@ public final class Tracy {
    }

    public static void message(String text) {
+        message(text, TracyBackend.SEVERITY_INFO);
+    }
+
+    public static void message(String text, int severity) {
        if (!ENABLED || SHUTTING_DOWN || !CaptureGate.markersThisFrame) return;
-        BACKEND.message(text);
+        BACKEND.message(text, severity);
+    }
+
+    public static long sectionEnter(int category, String text) {
+        if (!ENABLED || SHUTTING_DOWN) return 0L;
+        return SECTIONS.enter(category, text);
+    }
+
+    public static void sectionLeave(long token) {
+        if (token == 0L || !ENABLED || SHUTTING_DOWN) return;
+        SECTIONS.leave(token);
    }

    public static boolean isConnected() {
@@ -5,6 +5,13 @@ public interface TracyBackend {
    int PLOT_FORMAT_MEMORY = 1;
    int PLOT_FORMAT_PERCENTAGE = 2;

+    int SEVERITY_TRACE = 0;
+    int SEVERITY_DEBUG = 1;
+    int SEVERITY_INFO = 2;
+    int SEVERITY_WARNING = 3;
+    int SEVERITY_ERROR = 4;
+    int SEVERITY_FATAL = 5;
+
    boolean init();

    long internSrcLoc(String name, int color);
@@ -24,7 +31,14 @@ public interface TracyBackend {

    void plotInt(long namePtr, long value);
    void plot(long namePtr, double value);
-    void message(String text);
+
+    void message(String text, int severity);
+    default void message(String text) { message(text, SEVERITY_INFO); }
+
+    long sectionEnter(int category, String text);
+    void sectionLeave(long id);
+    void sectionSetup(int category, String name);
+
    void setCurrentThreadName(String name);
    boolean isConnected();
    void shutdown();
@@ -2,7 +2,7 @@ package com.gtnewhorizons.angelica.glsm.profiling;

 public final class ZoneStack {
    public static final long EMPTY = -1L;
-    static final int MAX_DEPTH = 512;
+    public static final int MAX_DEPTH = 512;

    private long[] stack = new long[64];
    private boolean[] gpu = new boolean[64];
@@ -162,6 +162,7 @@ public class GLSMRedirector {
    private static final String EXTGpuShader4 = "org/lwjgl/opengl/EXTGpuShader4";
    private static final String EXTGPUShader4 = "org/lwjgl/opengl/EXTGPUShader4";
    private static final String ARBTimerQuery = "org/lwjgl/opengl/ARBTimerQuery";
+    private static final String EXTTimerQuery = "org/lwjgl/opengl/EXTTimerQuery";

    // Redirect VAO related calls from NHLib
    private static final String UniversalVAO = "com/gtnewhorizon/gtnhlib/client/opengl/UniversalVAO";
@@ -632,6 +633,10 @@ public class GLSMRedirector {
            .add("glQueryCounter")
            .add("glGetQueryObjectui64")
        );
+        methodRedirects.put(EXTTimerQuery, RedirectMap.newMap()
+            .add("glGetQueryObjectuEXT", "glGetQueryObjectui64")
+            .add("glGetQueryObjectui64EXT", "glGetQueryObjectui64")
+        );

        glDescRedirects.put("org/lwjgl/opengl/GL32C glFenceSync(II)J", "glFenceSync");
        glDescRedirects.put("org/lwjgl/opengl/GL32C glClientWaitSync(JIJ)I", "glClientWaitSync");
@@ -100,7 +100,7 @@ public final class GlslVulkanPreprocess {
        return out;
    }

-    public record Metadata(Set<String> boolUniforms, Set<String> explicitVsInputs) {}
+    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) {
        final boolean isVertex = glShaderType == GL20.GL_VERTEX_SHADER;
@@ -216,7 +216,7 @@ public final class GlslVulkanPreprocess {
            }
        }, root);

-        if (needsSamplerless[0]) {
+        if (needsSamplerless[0] && source != null) {
            final int at = versionDirectiveEnd(source);
            if (at >= 0) edits.add(new Edit(at, at - 1, "\n" + SAMPLERLESS_EXTENSION));
        }
@@ -234,7 +234,7 @@ public final class GlslVulkanPreprocess {
            }
        }

-        return new Metadata(bools, explicitInputs);
+        return new Metadata(bools, explicitInputs, needsSamplerless[0]);
    }

    public static void clearCache() {
@@ -2,7 +2,9 @@ package com.gtnewhorizons.angelica.glsm.stacks;

 import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.hooks.VanillaStateLayer;
 import com.gtnewhorizons.angelica.glsm.states.AlphaState;
+import lombok.Setter;

 public class AlphaStateStack extends AlphaState implements IStateStack<AlphaState> {

@@ -10,6 +12,8 @@ public class AlphaStateStack extends AlphaState implements IStateStack<AlphaStat

    protected int pointer;

+    @Setter private VanillaStateLayer<AlphaState> vanillaLayer;
+
    public AlphaStateStack() {
        stack = new AlphaState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
@@ -22,7 +26,7 @@ public class AlphaStateStack extends AlphaState implements IStateStack<AlphaStat
            throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
        }

-        stack[pointer++].set(this);
+        VanillaStateLayer.capture(vanillaLayer, stack[pointer++].set(this));
        return this;
    }

@@ -31,10 +35,19 @@ public class AlphaStateStack extends AlphaState implements IStateStack<AlphaStat
            throw new IllegalStateException("Stack underflow");
        }

-        set(stack[--pointer]);
+        final AlphaState saved = stack[--pointer];
+        if (!VanillaStateLayer.restore(vanillaLayer, saved)) {
+            set(saved);
+        }
        return this;
    }

+    public AlphaState readEffective(AlphaState out) {
+        out.set(this);
+        VanillaStateLayer.capture(vanillaLayer, out);
+        return out;
+    }
+
    public boolean isEmpty() {
        return pointer == 0;
    }
@@ -2,7 +2,9 @@ package com.gtnewhorizons.angelica.glsm.stacks;

 import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.hooks.VanillaStateLayer;
 import com.gtnewhorizons.angelica.glsm.states.BlendState;
+import lombok.Setter;

 public class BlendStateStack extends BlendState implements IStateStack<BlendStateStack> {

@@ -10,6 +12,8 @@ public class BlendStateStack extends BlendState implements IStateStack<BlendStat

    protected int pointer;

+    @Setter private VanillaStateLayer<BlendState> vanillaLayer;
+
    public BlendStateStack() {
        stack = new BlendState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
@@ -22,7 +26,7 @@ public class BlendStateStack extends BlendState implements IStateStack<BlendStat
            throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
        }

-        stack[pointer++].set(this);
+        VanillaStateLayer.capture(vanillaLayer, stack[pointer++].set(this));
        return this;
    }

@@ -31,10 +35,21 @@ public class BlendStateStack extends BlendState implements IStateStack<BlendStat
            throw new IllegalStateException("Stack underflow");
        }

-        set(stack[--pointer]);
+        final BlendState saved = stack[--pointer];
+        if (VanillaStateLayer.restore(vanillaLayer, saved)) {
+            setExceptFunc(saved);
+        } else {
+            set(saved);
+        }
        return this;
    }

+    public BlendState readEffective(BlendState out) {
+        out.set(this);
+        VanillaStateLayer.capture(vanillaLayer, out);
+        return out;
+    }
+
    public boolean isEmpty() {
        return pointer == 0;
    }
@@ -2,7 +2,9 @@ package com.gtnewhorizons.angelica.glsm.stacks;

 import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.hooks.VanillaBooleanLayer;
 import com.gtnewhorizons.angelica.glsm.states.BooleanState;
+import lombok.Setter;

 /**
 * A stack for boolean GL state with lazy copy-on-write optimization.
@@ -14,6 +16,7 @@ import com.gtnewhorizons.angelica.glsm.states.BooleanState;
 public class BooleanStateStack extends BooleanState implements IStateStack<BooleanStateStack> {

    protected final boolean[] stack;
+    @Setter private VanillaBooleanLayer vanillaLayer;

    /**
     * The depth at which state has been saved. Compared against GLStateManager.getAttribDepth()
@@ -56,7 +59,7 @@ public class BooleanStateStack extends BooleanState implements IStateStack<Boole
        if (savedDepth >= stack.length) {
            throw new IllegalStateException("Stack overflow size " + (savedDepth + 1) + " reached");
        }
-        stack[savedDepth++] = enabled;
+        stack[savedDepth++] = vanillaValue();
        return this;
    }

@@ -65,12 +68,26 @@ public class BooleanStateStack extends BooleanState implements IStateStack<Boole
        if (savedDepth == 0) {
            throw new IllegalStateException("Stack underflow");
        }
-        final boolean oldValue = stack[--savedDepth];
-        // Call setEnabledDirect to avoid triggering beforeModify during restore
-        setEnabledDirect(oldValue);
+        restore(stack[--savedDepth]);
        return this;
    }

+    public boolean isEffectivelyEnabled() {
+        return (vanillaLayer != null && vanillaLayer.isOverrideHeld()) ? vanillaLayer.getVanilla() : enabled;
+    }
+
+    private boolean vanillaValue() {
+        return isEffectivelyEnabled();
+    }
+
+    private void restore(boolean value) {
+        if (vanillaLayer != null && vanillaLayer.isOverrideHeld()) {
+            vanillaLayer.setVanilla(value);
+        } else {
+            setEnabledDirect(value);
+        }
+    }
+
    @Override
    public boolean isEmpty() {
        return savedDepth == 0;
@@ -92,8 +109,7 @@ public class BooleanStateStack extends BooleanState implements IStateStack<Boole
    public BooleanStateStack popDepth() {
        // We're only called if we were modified, so savedDepth should match
        if (savedDepth > 0) {
-            final boolean oldValue = stack[--savedDepth];
-            setEnabledDirect(oldValue);
+            restore(stack[--savedDepth]);
        }
        return this;
    }
@@ -106,7 +122,7 @@ public class BooleanStateStack extends BooleanState implements IStateStack<Boole
    public void beforeModify() {
        final int globalDepth = GLStateManager.getAttribDepth();
        if (savedDepth < globalDepth) {
-            stack[savedDepth++] = enabled;
+            stack[savedDepth++] = vanillaValue();
            GLStateManager.registerModifiedState(this);
        }
    }
@@ -2,7 +2,9 @@ package com.gtnewhorizons.angelica.glsm.stacks;

 import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.hooks.VanillaStateLayer;
 import com.gtnewhorizons.angelica.glsm.states.ColorMask;
+import lombok.Setter;

 public class ColorMaskStack extends ColorMask implements IStateStack<ColorMaskStack> {

@@ -10,6 +12,8 @@ public class ColorMaskStack extends ColorMask implements IStateStack<ColorMaskSt

    protected int pointer;

+    @Setter private VanillaStateLayer<ColorMask> vanillaLayer;
+
    public ColorMaskStack() {
        stack = new ColorMask[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
@@ -22,7 +26,7 @@ public class ColorMaskStack extends ColorMask implements IStateStack<ColorMaskSt
            throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
        }

-        stack[pointer++].set(this);
+        VanillaStateLayer.capture(vanillaLayer, stack[pointer++].set(this));
        return this;
    }

@@ -31,7 +35,10 @@ public class ColorMaskStack extends ColorMask implements IStateStack<ColorMaskSt
            throw new IllegalStateException("Stack underflow");
        }

-        set(stack[--pointer]);
+        final ColorMask saved = stack[--pointer];
+        if (!VanillaStateLayer.restore(vanillaLayer, saved)) {
+            set(saved);
+        }
        return this;
    }

@@ -2,7 +2,9 @@ package com.gtnewhorizons.angelica.glsm.stacks;

 import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.hooks.VanillaStateLayer;
 import com.gtnewhorizons.angelica.glsm.states.DepthState;
+import lombok.Setter;

 public class DepthStateStack extends DepthState implements IStateStack<DepthStateStack> {

@@ -10,6 +12,10 @@ public class DepthStateStack extends DepthState implements IStateStack<DepthStat

    protected int pointer;

+    @Setter private VanillaStateLayer<DepthState> vanillaLayer;
+
+    private final DepthState effective = new DepthState();
+
    public DepthStateStack() {
        stack = new DepthState[GLStateManager.MAX_ATTRIB_STACK_DEPTH];
        for (int i = 0; i < GLStateManager.MAX_ATTRIB_STACK_DEPTH; i++) {
@@ -22,7 +28,7 @@ public class DepthStateStack extends DepthState implements IStateStack<DepthStat
            throw new IllegalStateException("Stack overflow size " + (pointer + 1) + " reached");
        }

-        stack[pointer++].set(this);
+        VanillaStateLayer.capture(vanillaLayer, stack[pointer++].set(this));
        return this;
    }

@@ -31,10 +37,21 @@ public class DepthStateStack extends DepthState implements IStateStack<DepthStat
            throw new IllegalStateException("Stack underflow");
        }

-        set(stack[--pointer]);
+        final DepthState saved = stack[--pointer];
+        if (VanillaStateLayer.restore(vanillaLayer, saved)) {
+            setExceptMask(saved);
+        } else {
+            set(saved);
+        }
        return this;
    }

+    public boolean isEffectiveMaskEnabled() {
+        if (!VanillaStateLayer.isHeld(vanillaLayer)) return isEnabled();
+        vanillaLayer.readVanilla(effective);
+        return effective.isEnabled();
+    }
+
    public boolean isEmpty() {
        return pointer == 0;
    }
@@ -55,6 +55,15 @@ public class BlendState implements ISettableState<BlendState> {
        return this;
    }

+    public void setExceptFunc(BlendState state) {
+        final int sRgb = srcRgb, dRgb = dstRgb, sAlpha = srcAlpha, dAlpha = dstAlpha;
+        set(state);
+        this.srcRgb = sRgb;
+        this.dstRgb = dRgb;
+        this.srcAlpha = sAlpha;
+        this.dstAlpha = dAlpha;
+    }
+
    @Override
    public boolean sameAs(Object state) {
        if (this == state) return true;
@@ -18,6 +18,12 @@ public class DepthState implements ISettableState<DepthState> {
        return this;
    }

+    public void setExceptMask(DepthState state) {
+        final boolean mask = enabled;
+        set(state);
+        this.enabled = mask;
+    }
+
    @Override
    public boolean sameAs(Object state) {
        if (this == state) return true;
@@ -108,7 +108,7 @@ public class TessellatorStreamingDrawer {

                final int defaultBrightness;
                if (!tess.hasBrightness) {
-                    defaultBrightness = ((int) GLSMConfig.lastBrightnessY << 16) | ((int) GLSMConfig.lastBrightnessX & 0xFFFF);
+                    defaultBrightness = GLSMConfig.packedLastBrightness();
                } else {
                    defaultBrightness = 0;
                }
@@ -36,6 +36,12 @@ public class TextureInfo {

    @Getter @Setter protected boolean generateMipmap = false;

+    @Getter protected int uploadGeneration;
+
+    void bumpUploadGeneration() {
+        uploadGeneration++;
+    }
+
    protected TextureInfo(int id) {
        this.id = id;
    }
@@ -53,6 +53,7 @@ public class TextureInfoCache {
            info.resolvedInternalFormat = isGenericCompressedInternalFormat(internalformat) ? -1 : internalformat;
            info.width = width;
            info.height = height;
+            info.bumpUploadGeneration();
        }
    }

@@ -65,9 +66,29 @@ public class TextureInfoCache {
            info.resolvedInternalFormat = isGenericCompressedInternalFormat(internalformat) ? -1 : internalformat;
            info.width = width;
            info.height = height;
+            info.bumpUploadGeneration();
        }
    }

+    public void onTexStorage2D(int target, int internalformat, int width, int height) {
+        if (!isTrackedTarget(target)) return;
+        final TextureInfo info = getInfo(GLStateManager.getBoundTextureForServerState());
+        if (info == null) return;
+        info.setTarget(target);
+        info.internalFormat = internalformat;
+        info.resolvedInternalFormat = isGenericCompressedInternalFormat(internalformat) ? -1 : internalformat;
+        info.width = width;
+        info.height = height;
+        info.bumpUploadGeneration();
+    }
+
+    public void onTexSubImage2D(int target, int level) {
+        if (!isTrackedTarget(target) || level != 0) return;
+        final TextureInfo info = getInfo(GLStateManager.getBoundTextureForServerState());
+        if (info == null) return;
+        info.bumpUploadGeneration();
+    }
+
    public static boolean isGenericCompressedInternalFormat(int internalFormat) {
        return switch (internalFormat) {
            case GL30.GL_COMPRESSED_RED,
@@ -0,0 +1,71 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import com.gtnewhorizons.angelica.glsm.texture.TextureInfo;
+import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
+import org.junit.jupiter.api.Test;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+
+import java.nio.ByteBuffer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNotSame;
+
+@GLCoreTest
+public class GLSM_TextureUploadGeneration_GLTest {
+
+    private static int allocate(int size) {
+        final int texId = GLStateManager.glGenTextures();
+        GLStateManager.glBindTexture(GL11.GL_TEXTURE_2D, texId);
+        GLStateManager.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, size, size, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, BufferUtils.createByteBuffer(size * size * 4));
+        return texId;
+    }
+
+    @Test
+    void anUploadLeavesANonZeroGeneration() {
+        final int texId = allocate(4);
+        try {
+            assertNotEquals(0, TextureInfoCache.INSTANCE.getInfo(texId).getUploadGeneration());
+        } finally {
+            GLStateManager.glDeleteTextures(texId);
+        }
+    }
+
+    @Test
+    void recreatingATextureAtAReusedIdYieldsAFreshInfo() {
+        final int texId = allocate(4);
+        try {
+            final TextureInfo first = TextureInfoCache.INSTANCE.getInfo(texId);
+            final int firstGeneration = first.getUploadGeneration();
+
+            TextureInfoCache.INSTANCE.onDeleteTexture(texId);
+            final ByteBuffer pixels = BufferUtils.createByteBuffer(4 * 4 * 4);
+            GLStateManager.glTexImage2D(GL11.GL_TEXTURE_2D, 0, GL11.GL_RGBA8, 4, 4, 0, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixels);
+
+            final TextureInfo second = TextureInfoCache.INSTANCE.getInfo(texId);
+            assertNotSame(first, second, "a deleted id drops its entry, so the replacement must be a distinct instance");
+            assertEquals(firstGeneration, second.getUploadGeneration(), "generations alias across a delete/recreate cycle, which is exactly why identity has to carry the distinction");
+        } finally {
+            GLStateManager.glDeleteTextures(texId);
+        }
+    }
+
+    @Test
+    void anInPlaceRewriteBumpsTheGeneration() {
+        final int texId = allocate(4);
+        try {
+            final TextureInfo info = TextureInfoCache.INSTANCE.getInfo(texId);
+            final int afterAlloc = info.getUploadGeneration();
+
+            GLStateManager.glTexSubImage2D(GL11.GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, BufferUtils.createByteBuffer(2 * 2 * 4));
+            assertNotEquals(afterAlloc, info.getUploadGeneration(), "content changed, so anything caching the pixels is stale");
+
+            final int afterSub = info.getUploadGeneration();
+            GLStateManager.glTexSubImage2D(GL11.GL_TEXTURE_2D, 1, 0, 0, 1, 1, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, BufferUtils.createByteBuffer(4));
+            assertEquals(afterSub, info.getUploadGeneration(), "only level 0 is tracked");
+        } finally {
+            GLStateManager.glDeleteTextures(texId);
+        }
+    }
+}
@@ -21,6 +21,18 @@ class GLVersionParseTest {
        assertEquals(-1, RenderSystem.parseMajorMinor("OpenGL ES 3.2"));
    }

+    @Test
+    void detectsLtwWrapper() {
+        assertTrue(LTWWorkaround.isLtwVersionString("3.3 OpenLTW (Built on: May 21 2026/12:38:14)"));
+        assertFalse(LTWWorkaround.isLtwVersionString(null));
+        assertFalse(LTWWorkaround.isLtwVersionString(""));
+        assertFalse(LTWWorkaround.isLtwVersionString("4.6.0 NVIDIA 551.61"));
+        assertFalse(LTWWorkaround.isLtwVersionString("4.6 (Core Profile) Mesa 24.0.3"));
+        assertFalse(LTWWorkaround.isLtwVersionString("4.1 Metal - 88"));
+        assertFalse(LTWWorkaround.isLtwVersionString("OpenGL ES 3.2 ANGLE (Vulkan)"));
+        assertFalse(LTWWorkaround.isLtwVersionString("2.1 gl4es wrapper"));
+    }
+
    @Test
    void isContextValid() {
        assertTrue(RenderSystem.isContextValid(4, 4, 46, true));
@@ -0,0 +1,67 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import org.junit.jupiter.api.Test;
+import org.taumc.glsl.grammar.GLSLParser;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ReservedWordRestoreTest {
+
+    private static void assertTreeRestoreMatchesStringRestore(String label, String renamedSource) {
+        final GLSLParser.Translation_unitContext treeA = GlslTransformUtils.parseFullQuiet(renamedSource);
+        final String legacy = GlslTransformUtils.restoreReservedWords(GlslTransformUtils.getFormattedShader(treeA, ""));
+
+        final GLSLParser.Translation_unitContext treeB = GlslTransformUtils.parseFullQuiet(renamedSource);
+        GlslTransformUtils.restoreReservedWordsInTree(treeB);
+        final String inTree = GlslTransformUtils.getFormattedShader(treeB, "");
+
+        assertEquals(legacy, inTree, "in-tree restore diverged from string restore for " + label);
+    }
+
+    @Test
+    void allThreeRenamesRestoreIdentically() {
+        final String src = "float angelica_renamed_sample = 1.0;\n"
+            + "uniform sampler2D angelica_renamed_sampler;\n"
+            + "vec4 angelica_renamed_texture = vec4(0.0);\n"
+            + "void main() {\n"
+            + "    vec4 c = angelica_renamed_texture + vec4(angelica_renamed_sample);\n"
+            + "}\n";
+        assertTreeRestoreMatchesStringRestore("all-three", src);
+    }
+
+    @Test
+    void renamedNewStaysRenamed() {
+        final String src = "float angelica_renamed_new = 2.0;\n"
+            + "void main() { float x = angelica_renamed_new; }\n";
+        assertTreeRestoreMatchesStringRestore("new-identifier", src);
+
+        final GLSLParser.Translation_unitContext tree = GlslTransformUtils.parseFullQuiet(src);
+        GlslTransformUtils.restoreReservedWordsInTree(tree);
+        final String out = GlslTransformUtils.getFormattedShader(tree, "");
+        assertTrue(out.contains("angelica_renamed_new"), "new is reserved in every GLSL version and must stay renamed");
+    }
+
+    @Test
+    void renamedTextureFunctionCallRestores() {
+        final String src = "uniform sampler2D tex;\n"
+            + "void main() {\n"
+            + "    vec4 c = angelica_renamed_texture2D(tex, vec2(0.5));\n"
+            + "}\n";
+        assertTreeRestoreMatchesStringRestore("texture2D-call", src);
+
+        final GLSLParser.Translation_unitContext tree = GlslTransformUtils.parseFullQuiet(src);
+        GlslTransformUtils.restoreReservedWordsInTree(tree);
+        final String out = GlslTransformUtils.getFormattedShader(tree, "");
+        assertTrue(out.contains("texture2D"), "suffixed rename must strip only the prefix");
+        assertFalse(out.contains("angelica_renamed_"), "no renamed remnants expected");
+    }
+
+    @Test
+    void untouchedSourcePrintsIdentically() {
+        final String src = "layout(location = 0) out vec4 fragColor;\n"
+            + "void main() { fragColor = vec4(1.0); }\n";
+        assertTreeRestoreMatchesStringRestore("no-renames", src);
+    }
+}
@@ -0,0 +1,65 @@
+package com.gtnewhorizons.angelica.glsm.backend;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.function.Predicate;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class BackendPolicyTest {
+
+    @Test
+    void onlyImmediateCanTear() {
+        assertTrue(VSyncMode.ON.tearFree());
+        assertTrue(VSyncMode.MAILBOX.tearFree());
+        assertFalse(VSyncMode.OFF.tearFree());
+    }
+
+    private static final Predicate<VSyncMode> NO_MAILBOX = mode -> mode != VSyncMode.MAILBOX;
+    private static final Predicate<VSyncMode> EVERYTHING = mode -> true;
+
+    @Test
+    void mailboxIsTakenWhenTheBackendOffersIt() {
+        assertEquals(VSyncMode.MAILBOX, RenderBackend.resolveTearFreeMode(null, EVERYTHING));
+    }
+
+    @Test
+    void vsyncIsTheFallbackWhenMailboxIsUnsupported() {
+        assertEquals(VSyncMode.ON, RenderBackend.resolveTearFreeMode(null, NO_MAILBOX));
+        assertEquals(VSyncMode.ON, RenderBackend.resolveTearFreeMode(VSyncMode.MAILBOX, NO_MAILBOX));
+    }
+
+    @Test
+    void anExplicitSupportedPreferenceWins() {
+        assertEquals(VSyncMode.ON, RenderBackend.resolveTearFreeMode(VSyncMode.ON, EVERYTHING));
+        assertEquals(VSyncMode.MAILBOX, RenderBackend.resolveTearFreeMode(VSyncMode.MAILBOX, EVERYTHING));
+    }
+
+    @Test
+    void offIsNeverATearFreePreference() {
+        assertEquals(VSyncMode.MAILBOX, RenderBackend.resolveTearFreeMode(VSyncMode.OFF, EVERYTHING));
+        assertEquals(VSyncMode.ON, RenderBackend.resolveTearFreeMode(VSyncMode.OFF, NO_MAILBOX));
+    }
+
+    @Test
+    void refreshPrefersTheExactRational() {
+        assertEquals(144, RenderBackend.refreshHzFrom(144, 1, 0.0f));
+        assertEquals(60, RenderBackend.refreshHzFrom(60000, 1001, 0.0f));
+    }
+
+    @Test
+    void refreshRoundsUp() {
+        assertEquals(144, RenderBackend.refreshHzFrom(0, 0, 143.98f));
+        assertEquals(60, RenderBackend.refreshHzFrom(0, 0, 59.94f));
+        assertEquals(60, RenderBackend.refreshHzFrom(0, 0, 60.0f));
+    }
+
+    @Test
+    void refreshIsZeroWhenUnknown() {
+        assertEquals(0, RenderBackend.refreshHzFrom(0, 0, 0.0f));
+        assertEquals(0, RenderBackend.refreshHzFrom(-1, -1, -1.0f));
+        assertEquals(0, RenderBackend.refreshHzFrom(144, 0, 0.0f));
+    }
+}
@@ -0,0 +1,241 @@
+package com.gtnewhorizons.angelica.glsm.ffp;
+
+import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement;
+import com.gtnewhorizons.angelica.glsm.GLCoreTest;
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import org.joml.Vector3f;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+import org.lwjgl.opengl.GL15;
+
+import java.nio.ByteBuffer;
+import java.nio.FloatBuffer;
+
+import static com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags.COLOR_BIT;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@GLCoreTest
+class FFPVertexLightingGLTest {
+
+    private static final int POSITION_LOC = VertexFormatElement.Usage.POSITION.getAttributeLocation();
+    private static final int COLOR_LOC = VertexFormatElement.Usage.COLOR.getAttributeLocation();
+    private static final int STRIDE = 16;
+
+    private static final int VERTEX_COLOR = 0xFF808080;
+    private static final float VERTEX_CHANNEL = 0x80 / 255.0f;
+
+    private static final Vector3f IDENTITY_FACTOR = new Vector3f(1.0f, 1.0f, 1.0f);
+
+    private final Vector3f factor = new Vector3f();
+
+    private int vao;
+    private int vbo;
+
+    @BeforeEach
+    void setUpState() {
+        GLStateManager.glMatrixMode(GL11.GL_PROJECTION);
+        GLStateManager.glLoadIdentity();
+        GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+        GLStateManager.glLoadIdentity();
+        GLStateManager.glViewport(0, 0, 800, 600);
+        GLStateManager.disableDepthTest();
+        GLStateManager.disableCull();
+        GLStateManager.disableBlend();
+        GLStateManager.disableTexture();
+        GLStateManager.glNormal3f(0.0f, 0.0f, 1.0f);
+        standardItemLighting();
+
+        GLStateManager.glMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_EMISSION, floats(0.0f, 0.0f, 0.0f, 1.0f));
+        GLStateManager.glMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_SPECULAR, floats(0.0f, 0.0f, 0.0f, 1.0f));
+        GLStateManager.glMaterialf(GL11.GL_FRONT_AND_BACK, GL11.GL_SHININESS, 0.0f);
+    }
+
+    @AfterEach
+    void cleanup() {
+        GLStateManager.glDisable(GL11.GL_NORMALIZE);
+        GLStateManager.glDisable(GL12.GL_RESCALE_NORMAL);
+        GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+        GLStateManager.glLoadIdentity();
+        GLStateManager.glDisable(GL11.GL_LIGHTING);
+        GLStateManager.glDisable(GL11.GL_LIGHT0);
+        GLStateManager.glDisable(GL11.GL_LIGHT1);
+        GLStateManager.glDisable(GL11.GL_LIGHT2);
+        GLStateManager.glDisable(GL11.GL_COLOR_MATERIAL);
+        final ShaderManager sm = ShaderManager.getInstance();
+        if (sm.isActive()) sm.deactivate();
+        sm.disable();
+        GLStateManager.glBindVertexArray(0);
+        if (vbo != 0) {
+            GLStateManager.glDeleteBuffers(vbo);
+            vbo = 0;
+        }
+        if (vao != 0) {
+            GLStateManager.glDeleteVertexArrays(vao);
+            vao = 0;
+        }
+    }
+
+    private static void standardItemLighting() {
+        GLStateManager.glEnable(GL11.GL_LIGHTING);
+        GLStateManager.glEnable(GL11.GL_LIGHT0);
+        GLStateManager.glEnable(GL11.GL_LIGHT1);
+        GLStateManager.glEnable(GL11.GL_COLOR_MATERIAL);
+        GLStateManager.glColorMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_AMBIENT_AND_DIFFUSE);
+        GLStateManager.glLightModel(GL11.GL_LIGHT_MODEL_AMBIENT, floats(0.4f, 0.4f, 0.4f, 1.0f));
+        light(GL11.GL_LIGHT0, 0.2f, 1.0f, -0.7f);
+        light(GL11.GL_LIGHT1, -0.2f, 1.0f, 0.7f);
+    }
+
+    private static void light(int light, float x, float y, float z) {
+        GLStateManager.glLight(light, GL11.GL_POSITION, floats(x, y, z, 0.0f));
+        GLStateManager.glLight(light, GL11.GL_DIFFUSE, floats(0.6f, 0.6f, 0.6f, 1.0f));
+        GLStateManager.glLight(light, GL11.GL_AMBIENT, floats(0.0f, 0.0f, 0.0f, 1.0f));
+        GLStateManager.glLight(light, GL11.GL_SPECULAR, floats(0.0f, 0.0f, 0.0f, 1.0f));
+    }
+
+    private static String gateState() {
+        final var material = GLStateManager.getFrontMaterial();
+        return "lighting=" + GLStateManager.getLightingState().isEnabled()
+            + " colorMaterial=" + GLStateManager.getColorMaterial().isEnabled()
+            + " cmParam=0x" + Integer.toHexString(GLStateManager.getColorMaterialParameter().getValue())
+            + " emission=" + material.emission
+            + " specular=" + material.specular
+            + " shininess=" + material.shininess
+            + " lmAmbient=" + GLStateManager.getLightModel().ambient
+            + " light0=" + GLStateManager.getLightStates()[0].isEnabled()
+            + " light1=" + GLStateManager.getLightStates()[1].isEnabled();
+    }
+
+    private static FloatBuffer floats(float... values) {
+        final FloatBuffer buf = BufferUtils.createFloatBuffer(values.length);
+        buf.put(values).flip();
+        return buf;
+    }
+
+    private void buildTriangle() {
+        vao = GLStateManager.glGenVertexArrays();
+        GLStateManager.glBindVertexArray(vao);
+
+        final ByteBuffer data = BufferUtils.createByteBuffer(3 * STRIDE);
+        putVertex(data, -0.9f, -0.9f);
+        putVertex(data, 0.9f, -0.9f);
+        putVertex(data, 0.0f, 0.9f);
+        data.flip();
+
+        vbo = GLStateManager.glGenBuffers();
+        GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, vbo);
+        GLStateManager.glBufferData(GL15.GL_ARRAY_BUFFER, data, GL15.GL_STATIC_DRAW);
+        GLStateManager.glEnableVertexAttribArray(POSITION_LOC);
+        GLStateManager.glVertexAttribPointer(POSITION_LOC, 3, GL11.GL_FLOAT, false, STRIDE, 0L);
+        GLStateManager.glEnableVertexAttribArray(COLOR_LOC);
+        GLStateManager.glVertexAttribPointer(COLOR_LOC, 4, GL11.GL_UNSIGNED_BYTE, true, STRIDE, 12L);
+        VAOManager.setCurrentVertexFlags(COLOR_BIT);
+    }
+
+    private static void putVertex(ByteBuffer buf, float x, float y) {
+        final int base = buf.position();
+        buf.putFloat(base, x).putFloat(base + 4, y).putFloat(base + 8, 0.0f);
+        buf.putInt(base + 12, VERTEX_COLOR);
+        buf.position(base + STRIDE);
+    }
+
+    private float[] drawAndReadCenter() {
+        buildTriangle();
+        final ShaderManager sm = ShaderManager.getInstance();
+        sm.enable();
+        sm.activate();
+
+        GLStateManager.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+        GLStateManager.glClear(GL11.GL_COLOR_BUFFER_BIT);
+        GLStateManager.glDrawArrays(GL11.GL_TRIANGLES, 0, 3);
+        assertEquals(GL11.GL_NO_ERROR, GL11.glGetError(), "FFP draw must not raise a GL error");
+
+        final ByteBuffer pixel = BufferUtils.createByteBuffer(4);
+        GL11.glReadPixels(400, 200, 1, 1, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, pixel);
+        return new float[] { (pixel.get(0) & 0xFF) / 255.0f, (pixel.get(1) & 0xFF) / 255.0f, (pixel.get(2) & 0xFF) / 255.0f };
+    }
+
+    private void assertSolverMatchesShader(String context) {
+        assertTrue(FFPVertexLighting.modulatesVertexColor(factor), context + ": expected a representable factor");
+        final float[] actual = drawAndReadCenter();
+        final float[] expected = { Math.min(1.0f, VERTEX_CHANNEL * factor.x), Math.min(1.0f, VERTEX_CHANNEL * factor.y), Math.min(1.0f, VERTEX_CHANNEL * factor.z) };
+        for (int c = 0; c < 3; c++) {
+            assertEquals(expected[c], actual[c], 2.0f / 255.0f, context + ": channel " + c + " solver=" + expected[c] + " shader=" + actual[c] + " factor=" + factor);
+        }
+    }
+
+    @Test
+    void faceOnNormalMatchesGeneratedShader() {
+        GLStateManager.glNormal3f(0.0f, 0.0f, 1.0f);
+        assertSolverMatchesShader("face-on normal");
+    }
+
+    @Test
+    void signNormalMatchesGeneratedShader() {
+        GLStateManager.glNormal3f(0.0f, 0.0f, -0.010416667f);
+        assertSolverMatchesShader("sign normal");
+        assertTrue(factor.x < 0.45f, "a 0.0104-long normal must stay at the 0.4 light model ambient floor rather than pick up 0.6 per light, got " + factor.x);
+    }
+
+    @Test
+    void tiltedNormalMatchesGeneratedShader() {
+        GLStateManager.glNormal3f(0.3f, 0.8f, 0.5f);
+        assertSolverMatchesShader("tilted normal");
+    }
+
+    @Test
+    void rescaleNormalMatchesGeneratedShader() {
+        GLStateManager.glEnable(GL12.GL_RESCALE_NORMAL);
+        GLStateManager.glScalef(1.0f, 2.0f, 1.0f);
+        GLStateManager.glNormal3f(0.0f, 1.0f, 0.0f);
+        assertSolverMatchesShader("rescale normal");
+    }
+
+    @Test
+    void normalizeMatchesGeneratedShader() {
+        GLStateManager.glEnable(GL11.GL_NORMALIZE);
+        GLStateManager.glScalef(1.0f, 2.0f, 1.0f);
+        GLStateManager.glNormal3f(0.0f, 1.0f, 0.0f);
+        assertSolverMatchesShader("normalize");
+        assertTrue(factor.x > 1.2f, "normalize restores the unit normal, which must pick up more diffuse than rescale's 0.5-long one, got " + factor.x);
+    }
+
+    @Test
+    void materialEmissionIsNotRepresentable() {
+        GLStateManager.glMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_EMISSION, floats(0.1f, 0.1f, 0.1f, 1.0f));
+        assertFalse(FFPVertexLighting.modulatesVertexColor(factor), "emission is additive, so the lit colour is not vertexColor * factor");
+        assertEquals(IDENTITY_FACTOR, factor, "a rejected solve must leave an identity factor");
+    }
+
+    @Test
+    void specularContributionIsNotRepresentable() {
+        GLStateManager.glMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_SPECULAR, floats(1.0f, 1.0f, 1.0f, 1.0f));
+        GLStateManager.glMaterialf(GL11.GL_FRONT_AND_BACK, GL11.GL_SHININESS, 16.0f);
+        GLStateManager.glLight(GL11.GL_LIGHT0, GL11.GL_SPECULAR, floats(1.0f, 1.0f, 1.0f, 1.0f));
+        assertFalse(FFPVertexLighting.modulatesVertexColor(factor), "specular is additive, so the lit colour is not vertexColor * factor");
+    }
+
+    @Test
+    void nonAmbientAndDiffuseColorMaterialIsNotRepresentable() {
+        GLStateManager.glColorMaterial(GL11.GL_FRONT_AND_BACK, GL11.GL_EMISSION);
+        assertFalse(FFPVertexLighting.modulatesVertexColor(factor), "only AMBIENT_AND_DIFFUSE makes the lit colour scale with the vertex colour");
+    }
+
+    @Test
+    void lightsBeyondTheFfpCountAreIgnored() {
+        assertTrue(FFPVertexLighting.modulatesVertexColor(factor), FFPVertexLightingGLTest::gateState);
+        final Vector3f twoLights = new Vector3f(factor);
+
+        light(GL11.GL_LIGHT2, 0.0f, 0.0f, 1.0f);
+        GLStateManager.glEnable(GL11.GL_LIGHT2);
+        assertTrue(FFPVertexLighting.modulatesVertexColor(factor), FFPVertexLightingGLTest::gateState);
+
+        assertEquals(twoLights, factor, "VertexShaderGenerator emits only GL_LIGHT0/GL_LIGHT1, so text must not see GL_LIGHT2 either");
+    }
+}
@@ -0,0 +1,32 @@
+package com.gtnewhorizons.angelica.glsm.ffp;
+
+import org.joml.Matrix3f;
+import org.joml.Matrix4f;
+import org.joml.Vector3f;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class UniformsRescaleTest {
+
+    private static float rescaleFactorFor(float sx, float sy, float sz) {
+        final Matrix3f normalMatrix = new Matrix3f();
+        new Matrix4f().rotateY(0.7f).scale(sx, sy, sz).normal(normalMatrix);
+        return Uniforms.rescaleFactor(normalMatrix, new Vector3f());
+    }
+
+    @Test
+    void rescaleFactorUsesTheInverseModelviewBottomRow() {
+        assertEquals(8.0f, rescaleFactorFor(4.0f, 2.0f, 8.0f), 1.0e-5f, "wrong normal matrix column");
+    }
+
+    @Test
+    void uniformScaleIsRowIndependent() {
+        assertEquals(2.0f, rescaleFactorFor(2.0f, 2.0f, 2.0f), 1.0e-5f);
+    }
+
+    @Test
+    void singularMatrixFallsBackToUnitScale() {
+        assertEquals(1.0f, rescaleFactorFor(1.0f, 1.0f, 0.0f), 1.0e-5f, "a degenerate normal matrix must not divide by zero");
+    }
+}
@@ -0,0 +1,92 @@
+package com.gtnewhorizons.angelica.glsm.loading;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class TransformerNarrowerTest {
+
+    private static final String LEGENDS_BROAD = "com.tihyo.legends.management.asm";
+    private static final String LEGENDS_HOOK = LEGENDS_BROAD + ".ASMClientMethods";
+
+    private static Set<String> exceptionsWith(String... entries) {
+        return new HashSet<>(Set.of(entries));
+    }
+
+    private static boolean isExcluded(Set<String> exceptions, String className) {
+        return exceptions.stream().anyMatch(className::startsWith);
+    }
+
+    private static int narrow(Set<String> exceptions, Map<String, Object> blackboard) {
+        return TransformerNarrower.narrow(exceptions, blackboard, "angelica", "Angelica", EcosystemNarrowRules.ALL);
+    }
+
+    @Test
+    void legendsHooksBecomeTransformableButTransformersDoNot() {
+        final Set<String> exceptions = exceptionsWith(LEGENDS_BROAD);
+        assertEquals(1, narrow(exceptions, new HashMap<>()));
+
+        assertFalse(isExcluded(exceptions, LEGENDS_HOOK));
+        assertFalse(isExcluded(exceptions, LEGENDS_BROAD + ".ASMMethods"));
+
+        assertTrue(isExcluded(exceptions, LEGENDS_BROAD + ".LegendsLoadingPlugin"));
+        assertTrue(isExcluded(exceptions, LEGENDS_BROAD + ".AbstractTransformer"));
+        assertTrue(isExcluded(exceptions, LEGENDS_BROAD + ".ASMHelper"));
+        assertTrue(isExcluded(exceptions, LEGENDS_BROAD + ".TransformerRenderPlayer"));
+        assertTrue(isExcluded(exceptions, LEGENDS_BROAD + ".TransformerEntityRenderer"));
+        assertTrue(isExcluded(exceptions, LEGENDS_BROAD + ".TransformerMethodProcess"));
+        assertTrue(isExcluded(exceptions, LEGENDS_BROAD + ".TransformerGuiInventory"));
+    }
+
+    @Test
+    void disabledRuleLeavesBroadExclusionIntact() {
+        final Set<String> exceptions = exceptionsWith(LEGENDS_BROAD);
+        final Map<String, Object> blackboard = new HashMap<>();
+        blackboard.put("angelica.narrow.LegendsMod", Boolean.FALSE);
+
+        assertEquals(0, narrow(exceptions, blackboard));
+        assertTrue(exceptions.contains(LEGENDS_BROAD));
+        assertTrue(isExcluded(exceptions, LEGENDS_HOOK));
+    }
+
+    @Test
+    void sharedXaerosKeyGovernsBothExclusions() {
+        final Set<String> enabled = exceptionsWith("xaero.common.core", "xaero.map.core");
+        assertEquals(2, narrow(enabled, new HashMap<>()));
+        assertFalse(isExcluded(enabled, "xaero.common.gui.GuiMap"));
+        assertFalse(isExcluded(enabled, "xaero.map.gui.GuiMap"));
+        assertTrue(isExcluded(enabled, "xaero.common.core.transformer.Foo"));
+        assertTrue(isExcluded(enabled, "xaero.map.core.transformer.Foo"));
+
+        final Set<String> disabled = exceptionsWith("xaero.common.core", "xaero.map.core");
+        final Map<String, Object> blackboard = new HashMap<>();
+        blackboard.put("angelica.narrow.Xaeros", Boolean.FALSE);
+        assertEquals(0, narrow(disabled, blackboard));
+        assertTrue(disabled.contains("xaero.common.core"));
+        assertTrue(disabled.contains("xaero.map.core"));
+    }
+
+    @Test
+    void narrowingIsIdempotent() {
+        final Set<String> exceptions = exceptionsWith(LEGENDS_BROAD);
+        assertEquals(1, narrow(exceptions, new HashMap<>()));
+
+        final Set<String> afterFirst = new HashSet<>(exceptions);
+        assertEquals(0, narrow(exceptions, new HashMap<>()));
+        assertEquals(afterFirst, exceptions);
+    }
+
+    @Test
+    void absentBroadExclusionIsNoOp() {
+        final Set<String> exceptions = exceptionsWith("some.unrelated.package");
+        assertEquals(0, narrow(exceptions, new HashMap<>()));
+        assertEquals(Set.of("some.unrelated.package"), exceptions);
+    }
+}
@@ -0,0 +1,113 @@
+package com.gtnewhorizons.angelica.glsm.profiling;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class SectionRegistryTest {
+
+    private static final class RecordingEmitter implements SectionRegistry.Emitter {
+        final List<String> setups = new ArrayList<>();
+        final List<String> enters = new ArrayList<>();
+        final List<Long> leaves = new ArrayList<>();
+        long nextId;
+        boolean connected;
+
+        @Override
+        public long enter(int category, String text) {
+            enters.add(category + ":" + text);
+            return connected ? ++nextId : 0L;
+        }
+
+        @Override
+        public void leave(long nativeId) {
+            leaves.add(nativeId);
+        }
+
+        @Override
+        public void setup(int category, String name) {
+            setups.add(category + ":" + name);
+        }
+
+        @Override
+        public boolean isConnected() {
+            return connected;
+        }
+    }
+
+    private final RecordingEmitter emitter = new RecordingEmitter();
+    private final SectionRegistry registry = new SectionRegistry(emitter);
+
+    private void reconnect() {
+        emitter.connected = false;
+        registry.poll();
+        emitter.connected = true;
+        registry.poll();
+    }
+
+    @Test
+    void tokensOutliveEveryReplayAndLeaveUsesTheNewestId() {
+        final long openedWhileDisconnected = registry.enter(1, "world");
+        assertNotEquals(0L, openedWhileDisconnected, "token must be valid while disconnected");
+        assertEquals(0L, emitter.nextId, "no native id while disconnected");
+
+        emitter.connected = true;
+        registry.poll();
+        final long openedWhileConnected = registry.enter(2, "shaders");
+        assertNotEquals(openedWhileDisconnected, openedWhileConnected);
+
+        reconnect();
+        emitter.leaves.clear();
+        registry.leave(openedWhileDisconnected);
+        registry.leave(openedWhileConnected);
+
+        assertEquals(List.of(3L, 4L), emitter.leaves, "leave must use the post-reconnect ids");
+    }
+
+    @Test
+    void aSectionEnteredOnTheConnectingFrameIsNotEnteredTwice() {
+        emitter.connected = true;
+        registry.enter(2, "shaders pack / Overworld");
+        registry.poll();
+
+        assertEquals(List.of("2:shaders pack / Overworld"), emitter.enters, "must not re-enter a section already live on this connection");
+    }
+
+    @Test
+    void reconnectReplaysEveryCategoryAndEveryOpenSection() {
+        registry.registerCategory(1, "World");
+        registry.registerCategory(4, "UI");
+        emitter.connected = true;
+        registry.poll();
+        registry.enter(1, "world");
+        registry.enter(4, "pause");
+        emitter.setups.clear();
+        emitter.enters.clear();
+
+        reconnect();
+
+        assertEquals(List.of("1:World", "4:UI"), emitter.setups, "all categories re-registered");
+        assertEquals(List.of("1:world", "4:pause"), emitter.enters, "all open sections re-entered");
+    }
+
+    @Test
+    void leftSectionsAreNotResurrectedByAReconnect() {
+        emitter.connected = true;
+        registry.poll();
+        final long token = registry.enter(1, "transient");
+        registry.leave(token);
+        emitter.enters.clear();
+        emitter.leaves.clear();
+
+        reconnect();
+        registry.leave(token);
+
+        assertTrue(emitter.enters.isEmpty(), "closed sections must not be re-entered");
+        assertTrue(emitter.leaves.isEmpty(), "closed tokens must not be left twice");
+    }
+}
@@ -331,6 +331,9 @@ class GLSMRedirectorTest {
    void phase2NameKeyedGapsRedirect() {
        assertRedirected("org/lwjgl/opengl/GL33C", "glQueryCounter", "(II)V", "glQueryCounter");
        assertRedirected("org/lwjgl/opengl/GL33C", "glGetQueryObjectui64", "(II)J", "glGetQueryObjectui64");
+        assertRedirected("org/lwjgl/opengl/ARBTimerQuery", "glGetQueryObjectui64", "(II)J", "glGetQueryObjectui64");
+        assertRedirected("org/lwjgl/opengl/EXTTimerQuery", "glGetQueryObjectuEXT", "(II)J", "glGetQueryObjectui64");
+        assertRedirected("org/lwjgl/opengl/EXTTimerQuery", "glGetQueryObjectui64EXT", "(II)J", "glGetQueryObjectui64");
        assertRedirected("org/lwjgl/opengl/GL30C", "glBindFragDataLocation", "(IILjava/lang/CharSequence;)V", "glBindFragDataLocation");
        assertRedirected("org/lwjgl/opengl/GL11C", "glGetIntegerv", "(I[I)V", "glGetInteger");
        assertRedirected("org/lwjgl/opengl/GL20C", "glUniform4fv", "(I[F)V", "glUniform4");
@@ -9,13 +9,13 @@ asmCompile = "5.0.3"
 lwjgl3 = "3.4.2-20260602.093430-9"
 lwjgl3ify = "3.0.31"

-celeritas = "2.5.9-GTNH"
+celeritas = "2.5.10-GTNH"
 gtnhlib = "0.11.36"
 eventbus = "7.0-beta.15"
 glslTransformLib = "0.2.0-33.g3ec381e"
 antlr4Runtime = "4.13.2"
 jcpp = "1.4.14"
-tracy = "0.13.1"
+tracy = "0.14.0"
 retroFuturaBootstrap = "1.1.0"

 lombok = "1.18.46"
@@ -5,6 +5,7 @@ import com.gtnewhorizons.angelica.glsm.GLESCaps;
 import com.gtnewhorizons.angelica.glsm.RenderSystem;
 import com.gtnewhorizons.angelica.glsm.backend.DebugMessageHandler;
 import com.gtnewhorizons.angelica.glsm.backend.RenderBackend;
+import com.gtnewhorizons.angelica.glsm.backend.VSyncMode;
 import me.eigenraven.lwjgl3ify.api.Lwjgl3Aware;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -32,6 +33,7 @@ import org.lwjgl.opengl.EXTPolygonOffsetClamp;
 import org.lwjgl.opengl.EXTShaderImageLoadStore;
 import org.lwjgl.opengl.GLCapabilities;
 import org.lwjgl.opengl.GLDebugMessageCallback;
+import org.lwjgl.sdl.SDL_DisplayMode;
 import org.lwjgl.sdl.SDL_DropEvent;
 import org.lwjgl.sdl.SDL_EventFilter;
 import org.lwjgl.sdl.SDLEvents;
@@ -39,6 +41,7 @@ import org.lwjgl.sdl.SDLVideo;
 import org.lwjgl.system.JNI;
 import org.lwjgl.system.MemoryStack;
 import org.lwjgl.system.MemoryUtil;
+import org.lwjglx.opengl.Display;

 import java.nio.Buffer;
 import java.nio.ByteBuffer;
@@ -169,7 +172,21 @@ public final class Lwjgl3GLRenderBackend extends RenderBackend {
    public int getMinGLSLVersion() {return 330;}

    @Override
-    public void setVSyncEnabled(boolean enabled) {SDLVideo.SDL_GL_SetSwapInterval(enabled ? 1 : 0);}
+    protected VSyncMode applyVSyncMode(VSyncMode preferred) {
+        final boolean enabled = preferred.tearFree();
+        SDLVideo.SDL_GL_SetSwapInterval(enabled ? 1 : 0);
+        return enabled ? VSyncMode.ON : VSyncMode.OFF;
+    }
+
+    @Override
+    protected int queryDisplayRefreshRateHz() {
+        final long window = Display.getWindow();
+        final int displayId = window == 0 ? SDLVideo.SDL_GetPrimaryDisplay() : SDLVideo.SDL_GetDisplayForWindow(window);
+        if (displayId == 0) return 0;
+        final SDL_DisplayMode mode = SDLVideo.SDL_GetCurrentDisplayMode(displayId);
+        if (mode == null) return 0;
+        return refreshHzFrom(mode.refresh_rate_numerator(), mode.refresh_rate_denominator(), mode.refresh_rate());
+    }

    @Override
    public boolean isAnisotropicSupported() {
@@ -59,6 +59,7 @@ dependencies {
    api(project(":glsm"))

    compileOnly(libs.lwjgl3ify) { artifact { classifier = "dev" }; isTransitive = false }
+    compileOnly(libs.retrofuturabootstrap) { isTransitive = false }
    compileOnly(libs.celeritas.common) { isTransitive = false }

    // GL enum constants (compileOnly -- no runtime GL dependency)
@@ -76,6 +77,7 @@ dependencies {
    testImplementation(platform(libs.junit.bom))
    testImplementation(libs.junit.jupiter)
    testImplementation(testFixtures(project(":glsm")))
+    testImplementation(libs.celeritas.common) { isTransitive = false }
    testImplementation(libs.lwjgl3.opengl)
    // GL.<clinit> loads liblwjgl_opengl.so. Test scope only: a root-level runtimeOnly collides with lwjgl3Bindings.
    testRuntimeOnly(libs.lwjgl3.opengl) { artifact { classifier = lwjglNatives } }
@@ -10,6 +10,7 @@ import com.gtnewhorizons.angelica.sdlgpu.shader.ShaderManager;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.lwjgl.sdl.SDLLog;
+import org.taumc.glsl.grammar.GLSLParser;
 import org.lwjgl.sdl.SDLProperties;
 import org.lwjgl.system.Platform;
 import org.lwjglx.Sys;
@@ -100,6 +101,11 @@ public final class SDLGPUGate {
        ShaderManager.prewarmSpirv(transformedSource, glShaderType);
    }

+    public static void prewarmSpirv(String transformedSource, GLSLParser.Translation_unitContext bodyTree, int headerLen, int glShaderType) {
+        if (!isActive()) return;
+        ShaderManager.prewarmSpirv(transformedSource, bodyTree, headerLen, glShaderType);
+    }
+
    public static void clearShaderPrewarmCache() {
        if (!isActive()) return;
        ShaderManager.clearPrewarmCache();
@@ -152,6 +158,9 @@ public final class SDLGPUGate {
    }

    public static void fallBackToGL() {
+        if (SDLGPULWJGLService.isOfferedAsAvailable()) {
+            throw new IllegalStateException("Celeritas already selected the SDL GPU LWJGL service; falling back to OpenGL would leave it bound to a dead backend");
+        }
        disarmed = true;
        engaged = false;
        deviceReady = false;
@@ -19,11 +19,17 @@ import java.util.Arrays;

 /** SDL GPU implementation of {@link LWJGLService} for Celeritas */
 public final class SDLGPULWJGLService extends LWJGLService {
+
+    private static volatile boolean offeredAsAvailable;
+
+    public static boolean isOfferedAsAvailable() { return offeredAsAvailable; }
+
    @Override public int getPriority() {
-        if (SystemProperties.USE_SDL_GPU && SDLGPUGate.isSDLGPUAvailable() && SDLGPUGate.isEngaged()) {
-            return 200;
+        if (!SystemProperties.USE_SDL_GPU || !SDLGPUGate.isSDLGPUAvailable() || !SDLGPUGate.isEngaged()) {
+            return PRIORITY_UNAVAILABLE;
        }
-        return Integer.MIN_VALUE;
+        offeredAsAvailable = true;
+        return 200;
    }

    @Override public boolean isOpenGLVersionSupported(int major, int minor) {
@@ -148,22 +154,30 @@ public final class SDLGPULWJGLService extends LWJGLService {
    }
    @Override public void glDeleteSync(long sync) { BackendManager.RENDER_BACKEND.deleteSync(sync); }

-    private long[] queryTimestamps = new long[64];
+    private long[] queryElapsed = new long[64];
+    private int activeQueryId = -1;
+    private long activeQueryStart;

    private void ensureQueryCapacity(int id) {
-        if (id >= queryTimestamps.length) {
-            queryTimestamps = Arrays.copyOf(queryTimestamps, Math.max(id + 1, queryTimestamps.length * 2));
+        if (id >= queryElapsed.length) {
+            queryElapsed = Arrays.copyOf(queryElapsed, Math.max(id + 1, queryElapsed.length * 2));
        }
    }

    @Override public int glGenQueries() { return BackendManager.RENDER_BACKEND.genQueries(); }
    @Override public void glDeleteQueries(int query) { }
-    @Override public void glQueryCounter(int id, int target) {
+    @Override public void glBeginQuery(int target, int id) {
        ensureQueryCapacity(id);
-        queryTimestamps[id] = System.nanoTime();
+        activeQueryId = id;
+        activeQueryStart = System.nanoTime();
+    }
+    @Override public void glEndQuery(int target) {
+        if (activeQueryId < 0) return;
+        queryElapsed[activeQueryId] = System.nanoTime() - activeQueryStart;
+        activeQueryId = -1;
    }
    @Override public long glGetQueryObjectui64(int id, int pname) {
-        if (id >= 0 && id < queryTimestamps.length) return queryTimestamps[id];
+        if (id >= 0 && id < queryElapsed.length) return queryElapsed[id];
        return 0;
    }

@@ -7,6 +7,7 @@ import com.gtnewhorizons.angelica.glsm.CaptureGate;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
 import com.gtnewhorizons.angelica.glsm.backend.GLDebugMessageListener;
+import com.gtnewhorizons.angelica.glsm.backend.VSyncMode;
 import com.gtnewhorizons.angelica.glsm.backend.RenderBackend;
 import com.gtnewhorizons.angelica.glsm.hooks.GLSMConfig;
 import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
@@ -17,6 +18,8 @@ import com.gtnewhorizons.angelica.sdlgpu.frame.ContextState;
 import com.gtnewhorizons.angelica.sdlgpu.frame.FenceTracker;
 import com.gtnewhorizons.angelica.sdlgpu.frame.FrameManager;
 import com.gtnewhorizons.angelica.sdlgpu.frame.FrameManager.FrameState;
+import com.gtnewhorizons.angelica.sdlgpu.frame.Presenter;
+import com.gtnewhorizons.retrofuturabootstrap.MainStartOnFirstThread;
 import com.gtnewhorizons.angelica.sdlgpu.pipeline.DrawDispatch;
 import com.gtnewhorizons.angelica.sdlgpu.pipeline.PipelineApplier;
 import com.gtnewhorizons.angelica.sdlgpu.pipeline.PipelineCache;
@@ -40,9 +43,10 @@ import com.gtnewhorizons.angelica.sdlgpu.sampler.StorageBufferBinder;
 import com.gtnewhorizons.angelica.sdlgpu.sampler.StorageTextureBinder;
 import com.gtnewhorizons.angelica.sdlgpu.shader.ShaderManager;
 import com.gtnewhorizons.angelica.sdlgpu.splash.SplashDispatcher;
-import com.gtnewhorizons.angelica.sdlgpu.splash.SplashOffscreenTarget;
+import com.gtnewhorizons.angelica.sdlgpu.frame.OffscreenTarget;
 import com.gtnewhorizons.angelica.sdlgpu.util.DebugLabels;
 import com.gtnewhorizons.angelica.sdlgpu.util.DebugMessageRelay;
+import com.gtnewhorizons.angelica.sdlgpu.util.ThreadRegistry;

 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
@@ -79,12 +83,11 @@ import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.BiConsumer;

 import org.lwjgl.sdl.SDLGPU;
-import org.lwjgl.sdl.SDLSurface;
 import org.lwjgl.sdl.SDL_GPUBlitInfo;
 import org.lwjgl.sdl.SDL_GPUBufferLocation;
 import org.lwjgl.sdl.SDL_GPUTextureLocation;
@@ -107,6 +110,7 @@ public class SDLGPURenderBackend extends RenderBackend {

    private final Device device = SDLGPUGate.device();
    private final FrameManager frameManager = new FrameManager(device);
+    private volatile Presenter presenter;
    private final ResourceManager resourceManager = new ResourceManager(device, frameManager);
    private final Image3DClear image3DClear = new Image3DClear();
    private final ShaderManager shaderManager = new ShaderManager(device);
@@ -150,33 +154,31 @@ public class SDLGPURenderBackend extends RenderBackend {

    private volatile boolean shutdown;

-    private SplashOffscreenTarget splashTarget;
+    private volatile OffscreenTarget splashTarget;
+    private volatile boolean splashTeardownPending;

-    private static final CopyOnWriteArrayList<ContextState> registeredStates = new CopyOnWriteArrayList<>();
-    private static final ThreadLocal<ContextState> tlState = ThreadLocal.withInitial(() -> {
+    private static final ThreadRegistry<ContextState> registeredStates = new ThreadRegistry<>(new ContextState[0]);
+    private static final ThreadLocal<ContextState> tlState = new ThreadLocal<>();
+
+    private static ContextState s() {
+        final ContextState sole = registeredStates.sole();
+        if (sole != null && sole.owner == Thread.currentThread()) return sole;
+        final ContextState st = tlState.get();
+        return st != null ? st : registerState();
+    }
+
+    private static ContextState registerState() {
        final ContextState st = new ContextState();
        for (int i = 0; i < ContextState.MAX_VERTEX_ATTRIBS; i++) st.attribDefaults[i * 4 + 3] = 1.0f;
        st.attribDefaults[4] = 1.0f; st.attribDefaults[5] = 1.0f;
        st.attribDefaults[6] = 1.0f;
+        tlState.set(st);
        registeredStates.add(st);
-        refreshSoleState();
        return st;
-    });
-
-    private static volatile ContextState soleState;
-
-    private static void refreshSoleState() {
-        soleState = registeredStates.size() == 1 ? registeredStates.get(0) : null;
-    }
-
-    private static ContextState s() {
-        final ContextState st = soleState;
-        if (st != null && st.owner == Thread.currentThread()) return st;
-        return tlState.get();
    }

    private void markAllPipelineInputDirty() {
-        for (ContextState st : registeredStates) st.pipeline.markInputDirty();
+        for (ContextState st : registeredStates.snapshot()) st.pipeline.markInputDirty();
    }

    public static final int CTR_SLOT_WRITES = 0;
@@ -188,7 +190,7 @@ public class SDLGPURenderBackend extends RenderBackend {

    public static void takeContextCounters(int[] out) {
        Arrays.fill(out, 0);
-        for (ContextState st : registeredStates) {
+        for (ContextState st : registeredStates.snapshot()) {
            out[CTR_SLOT_WRITES] += st.slotWrites;
            out[CTR_SLOT_WRITES_ELIDED] += st.slotWritesElided;
            out[CTR_SSBO_BINDS] += st.ssboBinds;
@@ -203,7 +205,7 @@ public class SDLGPURenderBackend extends RenderBackend {
    }

    private void releaseUniformStagingAllThreads(ShaderManager.ProgramObject prog) {
-        for (ContextState st : registeredStates) st.releaseUniformStaging(prog);
+        for (ContextState st : registeredStates.snapshot()) st.releaseUniformStaging(prog);
    }


@@ -239,16 +241,12 @@ public class SDLGPURenderBackend extends RenderBackend {
        });
        GLSMHooks.LOADING_CHECKPOINT
            .addListener(event -> {
-                if (Thread.currentThread() == GLStateManager.getMainThread()) {
-                    if (!GLStateManager.isSplashComplete()) {
-                        SplashDispatcher.tryDispatch(this, splashTarget);
-                    } else if (splashTarget != null) {
-                        SplashDispatcher.signalFrameReady();
-                        SplashDispatcher.tryDispatch(this, splashTarget);
-                        splashTarget.destroy(resourceManager);
-                        splashTarget = null;
-                        SplashDispatcher.reset();
+                if (!GLStateManager.isSplashComplete()) {
+                    if (Thread.currentThread() == GLStateManager.getMainThread()) {
+                        SplashDispatcher.tryDispatch(this, splashTarget, false);
                    }
+                } else if (splashTarget != null) {
+                    splashTeardownPending = true;
                }
                if (event.requiresSync) {
                    frameManager.requestSyncFlushOnAllRegisteredFrames();
@@ -289,13 +287,19 @@ public class SDLGPURenderBackend extends RenderBackend {
        resourceManager.setBufferLivenessListener(this::markAllPipelineInputDirty);
        shaderManager.setUniformReleaseListener(this::releaseUniformStagingAllThreads);
        fenceTracker.setUnresolvedFenceFlush(this::midFrameFenceFlush);
+        frameManager.setMainThread(GLStateManager.getMainThread());
+        if (!SystemProperties.DISABLE_SDL_PRESENTER_THREAD) {
+            presenter = new Presenter(frameManager, MainStartOnFirstThread.instance());
+            frameManager.setPresenter(presenter);
+            LOG.info("SDL presenter thread enabled: presents run on '{}'", device.getWindowThread() != null ? device.getWindowThread().getName() : "window thread");
+        }

        final int splashW = Math.max(1, Display.getWidth());
        final int splashH = Math.max(1, Display.getHeight());
        final int[] maxDesktop = device.getMaxDesktopSizePixels();
        final int splashTexW = Math.max(splashW, maxDesktop[0]);
        final int splashTexH = Math.max(splashH, maxDesktop[1]);
-        splashTarget = new SplashOffscreenTarget();
+        splashTarget = new OffscreenTarget();
        splashTarget.create(device, resourceManager, splashTexW, splashTexH, device.getSwapchainTextureFormat());
        SplashDispatcher.seedDrawnSize(splashW, splashH);
        LOG.info("Splash offscreen target {}x{} (window {}x{}, max desktop {}x{})", splashTexW, splashTexH, splashW, splashH, maxDesktop[0], maxDesktop[1]);
@@ -375,13 +379,50 @@ public class SDLGPURenderBackend extends RenderBackend {
        LOG.info("Populated GL capabilities for SDL GPU backend");
    }

-    @Override public void setVSyncEnabled(boolean enabled) {
-        device.setVSyncEnabled(enabled);
+    private final AtomicReference<VSyncMode> pendingVSync = new AtomicReference<>();
+
+    @Override protected VSyncMode applyVSyncMode(VSyncMode preferred) {
+        pendingVSync.set(preferred);
+        return device.chooseVSyncMode(preferred);
    }

+    @Override public boolean supportsVSyncMode(VSyncMode mode) {
+        return device.supportsVSyncMode(mode);
+    }
+
+    private void applyPendingVSync() {
+        final VSyncMode preferred = pendingVSync.getAndSet(null);
+        if (preferred != null) {
+            if (presenter != null) presenter.drain();
+            publishVSyncMode(device.applyVSync(preferred));
+        }
+    }
+
+    @Override protected int queryDisplayRefreshRateHz() {
+        return device.getDisplayRefreshRateHz();
+    }
+
+    @Override public boolean gateAnchorsNextFrameStart() { return true; }
+
+    @Override public boolean wantsDisplayUpdateGateTiming() { return false; }
+
+    @Override public long lastFrameGateNanos() {
+        if (presenter != null) return frameManager.windowFrame().lastFrameGateNanos;
+        return frameManager.lastFrameGateNanos();
+    }
+
+    @Override public long lastFrameGateEndNanos() {
+        if (presenter != null) return frameManager.windowFrame().lastFrameGateEndNanos;
+        return frameManager.lastFrameGateEndNanos();
+    }
+
+    @Override public boolean hasSwapchainBackpressure() { return true; }
+
    @Override public void shutdown() {
        if (shutdown) return;
        shutdown = true;
+        if (presenter != null) presenter.drain();
+        frameManager.destroyFinalTarget();
        if (splashTarget != null) {
            splashTarget.destroy(resourceManager);
            splashTarget = null;
@@ -404,7 +445,7 @@ public class SDLGPURenderBackend extends RenderBackend {
        fenceTracker.dispose();
        frameManager.releaseAllRegisteredFrames();
        resourceManager.shutdownTexSamplerStates();
-        for (ContextState st : registeredStates) {
+        for (ContextState st : registeredStates.snapshot()) {
            if (st.fanIndexBuffer != 0) {
                resourceManager.releaseBufferHandle(st.fanIndexBuffer);
                st.fanIndexBuffer = 0;
@@ -422,7 +463,6 @@ public class SDLGPURenderBackend extends RenderBackend {
            clearMappedState(st);
        }
        registeredStates.clear();
-        soleState = null;

        drawDispatch.clearWarnedState();
        pipelineStore.shutdown();
@@ -461,32 +501,35 @@ public class SDLGPURenderBackend extends RenderBackend {
    }

    @Override public void onRenderThreadReleased(Thread t) {
+        if (shutdown || t == GLStateManager.getMainThread()) return;
        if (frameManager.isFrameActive()) {
            frameManager.endFrame();
        }
        frameManager.releaseThreadState();
-        registeredStates.remove(tlState.get());
-        tlState.remove();
-        refreshSoleState();
+        final ContextState st = tlState.get();
+        if (st != null) {
+            tlState.remove();
+            registeredStates.remove(st);
+        }
    }

    @Override public boolean handleMakeCurrent(Object drawable) {
        if (!isSDLManagedDrawable(drawable)) return false;
        Lwjgl3GLCapabilitiesShim.installOnCurrentThread(advertisedCapabilities());
-        if (splashTarget != null && Thread.currentThread() != GLStateManager.getMainThread()) {
-            s().boundFboId = splashTarget.fboId();
+        final OffscreenTarget splash = splashTarget;
+        if (splash != null && Thread.currentThread() != GLStateManager.getMainThread()) {
+            s().boundFboId = splash.fboId();
            frameManager.frame().swapchainUnavailable = true;
        }
        return true;
    }

    @Override public boolean handleReleaseContext(Object drawable) {
-        if (isSDLManagedDrawable(drawable)) {
-            Lwjgl3GLCapabilitiesShim.clearOnCurrentThread();
-            onRenderThreadReleased(Thread.currentThread());
-            return true;
-        }
-        return false;
+        if (!isSDLManagedDrawable(drawable)) return false;
+        if (Thread.currentThread() == GLStateManager.getMainThread()) return true;
+        Lwjgl3GLCapabilitiesShim.clearOnCurrentThread();
+        onRenderThreadReleased(Thread.currentThread());
+        return true;
    }

    private static boolean isSDLManagedDrawable(Object drawable) {
@@ -496,7 +539,8 @@ public class SDLGPURenderBackend extends RenderBackend {
    }

    @Override public boolean handleSwapBuffers() {
-        if (splashTarget != null && splashTarget.isFor(s()) && Thread.currentThread() != GLStateManager.getMainThread()) {
+        final OffscreenTarget splash = splashTarget;
+        if (splash != null && splash.isFor(s()) && Thread.currentThread() != GLStateManager.getMainThread()) {
            endFrameUploadFlush();
            frameManager.endFrame();
            SplashDispatcher.signalFrameReady((int) s().viewportW, (int) s().viewportH);
@@ -509,33 +553,30 @@ public class SDLGPURenderBackend extends RenderBackend {
        return true;
    }

-    public void dispatchSplashBlit(SplashOffscreenTarget target) {
+    public void dispatchSplashBlit(OffscreenTarget target) {
        if (shutdown || target == null) return;
-        onFrameBegin();
-        final FrameManager.FrameState f = frameManager.frame();
-        if (!frameManager.ensureSwapchainAcquired(f)) {
-            onFrameEnd();
-            return;
-        }
-        frameManager.endCopyPassIfActive();
-        frameManager.endRenderPassIfActive();
        final long drawnSize = SplashDispatcher.getDrawnSize();
        final int srcW = Math.max(1, Math.min((int) (drawnSize >> 32), target.width()));
        final int srcH = Math.max(1, Math.min((int) drawnSize, target.height()));
-        try (var stack = MemoryStack.stackPush()) {
-            final var info = SDL_GPUBlitInfo.calloc(stack);
-            info.source(s -> s.texture(target.colorTexture()).x(0).y(0).w(srcW).h(srcH));
-            info.destination(d -> d.texture(f.swapchainTexture).x(0).y(0).w(f.swapchainWidth).h(f.swapchainHeight));
-            info.filter(SDL_GPU_FILTER_LINEAR);
-            info.flip_mode(SDLSurface.SDL_FLIP_VERTICAL);
-            SDL_BlitGPUTexture(f.commandBuffer, info);
-        }
-        f.swapchainUsedThisFrame = true;
-        onFrameEnd();
+        frameManager.presentSplash(target.colorTexture(), srcW, srcH);
+    }
+
+    private void finishSplash() {
+        splashTeardownPending = false;
+        final OffscreenTarget target = splashTarget;
+        if (target == null) return;
+        SplashDispatcher.signalFrameReady();
+        SplashDispatcher.tryDispatch(this, target, true);
+        if (presenter != null) presenter.drain();
+        splashTarget = null;
+        target.destroy(resourceManager);
+        SplashDispatcher.reset();
    }

    @Override public void onFrameBegin() {
        if (shutdown) return;
+        if (splashTeardownPending) finishSplash();
+        if (GLStateManager.isSplashComplete()) applyPendingVSync();
        frameManager.beginFrame();
        beginFrameInit();
    }
@@ -549,9 +590,13 @@ public class SDLGPURenderBackend extends RenderBackend {
        }
        ResourceManager.setSingleThreadedReads(GLStateManager.isSplashComplete());
        st.clearedTexturesThisFrame.clear();
+        st.clearedStencilTexturesThisFrame.clear();
        st.pendingColorTextures.clear();
        st.pendingDepthTextures.clear();
+        st.pendingStencilTextures.clear();
        st.pendingSwapchainClear = false;
+        st.pendingSwapchainDepthClear = false;
+        st.pendingSwapchainStencilClear = false;
        st.uniformBlocks[0].flushedThisFrame = false;
        st.uniformBlocks[1].flushedThisFrame = false;
        st.fanIndexBufferOffset = 0;
@@ -613,22 +658,24 @@ public class SDLGPURenderBackend extends RenderBackend {
        endFrameUploadFlushNoWait();

        final FrameState f = frameManager.frame();
-        if (f.frameActive && !f.swapchainUsedThisFrame) {
+        if (f.frameActive && !f.fbo0UsedThisFrame) {
            if (!emptyFrameWarned) {
                emptyFrameWarned = true;
-                LOG.info("Frame {} ended without drawing to the swapchain; skipping present (further occurrences counted in sdl.emptyFrames)", f.frameNumber);
+                LOG.info("Frame {} ended without drawing to FBO 0; presenting the previous contents (further occurrences counted in sdl.emptyFrames)", f.frameNumber);
            }
            frameManager.markFrameEmpty(f);
        }

        awaitUploadFlush();
        frameManager.endFrame();
+        frameManager.presentFinalTarget();
        fenceTracker.resolvePendingFences();
        resourceManager.flushDeferredReleases();
        resourceManager.recycleGpuBufferPool(frameManager.getFrameNumber());
    }

    @Override public void onPreSwapchainInvalidatingChange(Object change) {
+        if (presenter != null) presenter.drain();
        endFrameUploadFlush();
        if (frameManager.isFrameActive()) {
            frameManager.endFrame();
@@ -869,18 +916,19 @@ public class SDLGPURenderBackend extends RenderBackend {
    }

    @Override public void clearDepth(double depth) { s().depthClearValue = (float) depth; }
-    @Override public void clearStencil(int s) {}
+    @Override public void clearStencil(int s) { s().stencilClearValue = s & 0xFF; }

    @Override public void clear(int mask) {
        final ContextState cs = s();
        if (!frameManager.isFrameActive()) return;
        final boolean wantColor = (mask & GL11.GL_COLOR_BUFFER_BIT) != 0;
        final boolean wantDepth = (mask & GL11.GL_DEPTH_BUFFER_BIT) != 0;
-        if (!wantColor && !wantDepth) return;
+        final boolean wantStencil = (mask & GL11.GL_STENCIL_BUFFER_BIT) != 0;
+        if (!wantColor && !wantDepth && !wantStencil) return;

        final ContextState st = cs;

-        // Swapchain path: just record pending state; ensureSwapchainRenderPass consumes it lazily.
+        // FBO0 path: just record pending state; ensureFbo0RenderPass consumes it lazily.
        if (st.boundFboId == 0) {
            if (wantColor) {
                st.pendingSwapchainClear = true;
@@ -889,7 +937,15 @@ public class SDLGPURenderBackend extends RenderBackend {
                st.pendingSwapchainB = st.clearB;
                st.pendingSwapchainA = st.clearA;
            }
-            // swapchain has no depth attachment in this backend; ignore wantDepth
+            final int swapDepthFormat = resourceManager.getSwapchainDepthStencilFormat();
+            if (wantDepth && swapDepthFormat != 0) {
+                st.pendingSwapchainDepthClear = true;
+                st.pendingSwapchainDepth = st.depthClearValue;
+            }
+            if (wantStencil && PixelOps.isDepthStencilFormat(swapDepthFormat)) {
+                st.pendingSwapchainStencilClear = true;
+                st.pendingSwapchainStencil = st.stencilClearValue;
+            }
            return;
        }

@@ -914,6 +970,10 @@ public class SDLGPURenderBackend extends RenderBackend {
            FBOClearTracker.recordPendingDepthClear(st, fbo.depthTexture, cs.depthClearValue);
            if (passActive && fbo.depthTexture == activeDepth) affectsActivePass = true;
        }
+        if (wantStencil && fbo.depthTexture != 0 && PixelOps.isDepthStencilFormat(fbo.depthFormat)) {
+            FBOClearTracker.recordPendingStencilClear(st, fbo.depthTexture, cs.stencilClearValue);
+            if (passActive && fbo.depthTexture == activeDepth) affectsActivePass = true;
+        }

        if (affectsActivePass) {
            frameManager.endRenderPassIfActive();
@@ -1459,14 +1519,12 @@ public class SDLGPURenderBackend extends RenderBackend {
        if (framebuffer == 0) {
            cs.pipeline.setColorTargetFormats(cachedSwapchainFormatArray);
            cs.pipeline.setDrawBuffers(null);
-            cs.pipeline.hasDepthTarget = false;
-            cs.pipeline.depthTargetFormat = 0;
+            cs.pipeline.setDepthTargetFormat(resourceManager.getSwapchainDepthStencilFormat());
        } else {
            final FboState fbo = resourceManager.getFbo(framebuffer);
            if (fbo != null && fbo.getColorTexture() != 0) {
                fboClearTracker.updatePipelineCacheColorFormats(cs, fbo);
-                cs.pipeline.hasDepthTarget = fbo.depthTexture != 0;
-                cs.pipeline.depthTargetFormat = fbo.depthFormat;
+                cs.pipeline.setDepthTargetFormat(fbo.depthTexture != 0 ? fbo.depthFormat : 0);
            }
        }
        cs.pipeline.markOutputDirty();
@@ -1503,14 +1561,23 @@ public class SDLGPURenderBackend extends RenderBackend {
            fbo.cachedFormatsDirty = true;
            fboClearTracker.updatePipelineCacheColorFormats(cs, fbo);
            cs.pipeline.markOutputDirty();
-        } else if (attachment == GL30.GL_DEPTH_ATTACHMENT || attachment == GL30.GL_DEPTH_STENCIL_ATTACHMENT) {
+        } else if (attachment == GL30.GL_DEPTH_ATTACHMENT || attachment == GL30.GL_DEPTH_STENCIL_ATTACHMENT || attachment == GL30.GL_STENCIL_ATTACHMENT) {
+            final boolean stencilOnly = attachment == GL30.GL_STENCIL_ATTACHMENT;
            if (texture == 0) {
+                if (stencilOnly && fbo.depthGlId != 0) return;
                fbo.detachDepth();
                cs.pipeline.hasDepthTarget = false;
                cs.pipeline.depthTargetFormat = 0;
                cs.pipeline.markOutputDirty();
                return;
            }
+            if (stencilOnly && fbo.depthGlId != 0 && fbo.depthGlId != texture) {
+                if (!warnedSplitStencilAttachment) {
+                    warnedSplitStencilAttachment = true;
+                    LOG.warn("Separate stencil attachment (tex {}) on an FBO whose depth attachment is tex {}; SDL has no separate stencil aspect, keeping depth", texture, fbo.depthGlId);
+                }
+                return;
+            }
            final long handle = resourceManager.ensureTextureUsage(texture, SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET);
            final ResourceManager.TextureMeta meta = resourceManager.getTextureMeta(texture);
            fbo.depthTexture = handle;
@@ -1619,7 +1686,7 @@ public class SDLGPURenderBackend extends RenderBackend {
        final long texHandle;
        final int srcSdlFormat;
        if (cs.boundReadFboId == 0) {
-            texHandle = frameManager.getSwapchainTexture();
+            texHandle = frameManager.getFbo0Texture();
            srcSdlFormat = frameManager.getSwapchainFormat();
        } else {
            final FboState fbo = resourceManager.getFbo(cs.boundReadFboId);
@@ -1674,22 +1741,67 @@ public class SDLGPURenderBackend extends RenderBackend {
    }

    @Override public int getFramebufferAttachmentParameteri(int target, int attachment, int pname) {
-        final FboState fbo = resourceManager.getFbo(s().boundFboId);
+        final ContextState cs = s();
+        final int fboId = target == GL30.GL_READ_FRAMEBUFFER ? cs.boundReadFboId : cs.boundFboId;
+        if (fboId == 0) {
+            final int colorFormat = cachedSwapchainFormatArray != null ? cachedSwapchainFormatArray[0] : 0;
+            return defaultFramebufferAttachmentParameteri(attachment, pname, colorFormat, resourceManager.getSwapchainDepthStencilFormat());
+        }
+        return fboAttachmentParameteri(resourceManager.getFbo(fboId), attachment, pname);
+    }
+
+    static int fboAttachmentParameteri(FboState fbo, int attachment, int pname) {
        if (fbo == null) return 0;
        final int colorIdx = attachment - GL30.GL_COLOR_ATTACHMENT0;
        final boolean isColor = (colorIdx >= 0 && colorIdx < ContextState.MAX_COLOR_ATTACHMENTS);
-        final boolean isDepth = (attachment == GL30.GL_DEPTH_ATTACHMENT || attachment == GL30.GL_DEPTH_STENCIL_ATTACHMENT);
+        final boolean isDepth = (attachment == GL30.GL_DEPTH_ATTACHMENT || attachment == GL30.GL_DEPTH_STENCIL_ATTACHMENT || attachment == GL30.GL_STENCIL_ATTACHMENT || attachment == GL11.GL_DEPTH || attachment == GL11.GL_STENCIL);
+        final boolean colorPresent = isColor && fbo.colorGlIds[colorIdx] != 0;
+        final boolean depthPresent = isDepth && fbo.depthGlId != 0;
+
        if (pname == GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) {
-            return isColor ? fbo.colorGlIds[colorIdx] : isDepth ? fbo.depthGlId : 0;
+            return colorPresent ? fbo.colorGlIds[colorIdx] : depthPresent ? fbo.depthGlId : 0;
        }
        if (pname == GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE) {
-            if (isColor && fbo.colorGlIds[colorIdx] != 0) return GL11.GL_TEXTURE;
-            if (isDepth && fbo.depthGlId != 0) return GL11.GL_TEXTURE;
-            return GL11.GL_NONE;
+            return (colorPresent || depthPresent) ? GL11.GL_TEXTURE : GL11.GL_NONE;
        }
+        if (colorPresent) return colorAttachmentSize(fbo.colorFormats[colorIdx], pname);
+        if (depthPresent) return depthAttachmentSize(fbo.depthFormat, pname);
        return 0;
    }

+    static int defaultFramebufferAttachmentParameteri(int attachment, int pname, int colorFormat, int depthFormat) {
+        final boolean isDepth = attachment == GL11.GL_DEPTH || attachment == GL11.GL_STENCIL || attachment == GL30.GL_DEPTH_ATTACHMENT || attachment == GL30.GL_STENCIL_ATTACHMENT || attachment == GL30.GL_DEPTH_STENCIL_ATTACHMENT;
+        if (isDepth) {
+            if (depthFormat == 0) {
+                return pname == GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE ? GL11.GL_NONE : 0;
+            }
+            if (pname == GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE) return GL30.GL_FRAMEBUFFER_DEFAULT;
+            if (pname == GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) return 0;
+            return depthAttachmentSize(depthFormat, pname);
+        }
+        if (pname == GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE) return GL30.GL_FRAMEBUFFER_DEFAULT;
+        if (pname == GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME) return 0;
+        return colorAttachmentSize(colorFormat, pname);
+    }
+
+    private static int colorAttachmentSize(int sdlFormat, int pname) {
+        return switch (pname) {
+            case GL30.GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE -> PixelOps.colorChannelBits(sdlFormat, 0);
+            case GL30.GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE -> PixelOps.colorChannelBits(sdlFormat, 1);
+            case GL30.GL_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE -> PixelOps.colorChannelBits(sdlFormat, 2);
+            case GL30.GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE -> PixelOps.colorChannelBits(sdlFormat, 3);
+            default -> 0;
+        };
+    }
+
+    private static int depthAttachmentSize(int sdlFormat, int pname) {
+        return switch (pname) {
+            case GL30.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE -> PixelOps.depthBits(sdlFormat);
+            case GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE -> PixelOps.stencilBits(sdlFormat);
+            default -> 0;
+        };
+    }
+
    @Override public int createShader(int type) { return shaderManager.createShader(type); }
    @Override public void deleteShader(int shader) { shaderManager.deleteShader(shader); }
    @Override public void shaderSource(int shader, CharSequence source) { shaderManager.shaderSource(shader, source); }
@@ -3199,6 +3311,8 @@ public class SDLGPURenderBackend extends RenderBackend {
            case GL11.GL_DRAW_BUFFER -> drawBufferEnum(cs.boundFboId);
            case GL11.GL_READ_BUFFER -> readBufferEnum(cs.boundReadFboId);
            case GL11.GL_TEXTURE_BINDING_2D -> boundTextureOf(cs.activeTextureUnit, cs.boundTextures);
+            case GL11.GL_DEPTH_BITS -> getFramebufferAttachmentParameteri(GL30.GL_DRAW_FRAMEBUFFER, GL11.GL_DEPTH, GL30.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE);
+            case GL11.GL_STENCIL_BITS -> getFramebufferAttachmentParameteri(GL30.GL_DRAW_FRAMEBUFFER, GL11.GL_STENCIL, GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE);
            default -> {
                final int limit = deviceLimit(pname);
                yield limit >= 0 ? limit : unknownGetInteger(pname);
@@ -3646,6 +3760,7 @@ public class SDLGPURenderBackend extends RenderBackend {
    }

    private boolean warnedMSAARenderbuffer = false;
+    private boolean warnedSplitStencilAttachment = false;

    @Override
    public void renderbufferStorageMultisample(int target, int samples, int internalformat, int width, int height) {
@@ -1,6 +1,8 @@
 package com.gtnewhorizons.angelica.sdlgpu.device;

 import com.gtnewhorizons.angelica.config.SystemProperties;
+import com.gtnewhorizons.angelica.glsm.backend.VSyncMode;
+import com.gtnewhorizons.angelica.glsm.backend.RenderBackend;
 import com.gtnewhorizons.angelica.sdlgpu.util.DebugMessageRelay;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -18,6 +20,7 @@ import org.lwjgl.system.Platform;
 import org.lwjglx.opengl.Display;

 import java.nio.IntBuffer;
+import java.util.List;
 import java.util.function.Supplier;

 import static org.lwjgl.sdl.SDLGPU.*;
@@ -29,7 +32,11 @@ import static org.lwjgl.system.MemoryUtil.memUTF8;
 public final class Device {
    private static final Logger LOG = LogManager.getLogger("Angelica-SDLGPU");

-    public static final int FRAMES_IN_FLIGHT = 3;
+    public static final int MAX_FRAMES_IN_FLIGHT = 3;
+
+    private static final int FRAMES_IN_FLIGHT = Math.min(Math.max(SystemProperties.SDL_FRAMES_IN_FLIGHT, 1), MAX_FRAMES_IN_FLIGHT);
+
+    public static int framesInFlight() { return FRAMES_IN_FLIGHT; }

    private static final int REQUESTED_SHADER_FORMATS = SDL_GPU_SHADERFORMAT_SPIRV | SDL_GPU_SHADERFORMAT_MSL | SDL_GPU_SHADERFORMAT_DXBC | SDL_GPU_SHADERFORMAT_DXIL;

@@ -40,7 +47,8 @@ public final class Device {
    private String deviceName;
    private String driverVersion;
    private String driverInfo;
-    private int presentMode = SDL_GPU_PRESENTMODE_VSYNC;
+    private VSyncMode vsyncMode = VSyncMode.ON;
+    private volatile Thread windowThread;
    private SDL_LogOutputFunction logCallback; // prevent GC

    private volatile boolean lost;
@@ -146,12 +154,12 @@ public final class Device {
            throw new RuntimeException("Failed to claim window for SDL GPU device: " + SDLError.SDL_GetError());
        }
        claimed = true;
+        windowThread = Thread.currentThread();

-        final int n = FRAMES_IN_FLIGHT;
-        if (!SDL_SetGPUAllowedFramesInFlight(device, n)) {
-            LOG.warn("SDL_SetGPUAllowedFramesInFlight({}) failed: {}", n, SDLError.SDL_GetError());
+        if (!SDL_SetGPUAllowedFramesInFlight(device, FRAMES_IN_FLIGHT)) {
+            LOG.warn("SDL_SetGPUAllowedFramesInFlight({}) failed: {}", FRAMES_IN_FLIGHT, SDLError.SDL_GetError());
        } else {
-            LOG.info("SDL frames-in-flight set to {}", n);
+            LOG.info("SDL frames-in-flight set to {}", FRAMES_IN_FLIGHT);
        }

        logWindowDiagnostics(window);
@@ -260,6 +268,10 @@ public final class Device {
        return driverName;
    }

+    public Thread getWindowThread() {
+        return windowThread;
+    }
+
    public String getDeviceName() {
        return deviceName;
    }
@@ -288,22 +300,89 @@ public final class Device {
        return (supportedShaderFormats & SDL_GPU_SHADERFORMAT_DXBC) != 0;
    }

-    public void setVSyncEnabled(boolean enabled) {
+    private static final List<VSyncMode> ON_ORDER = List.of(VSyncMode.ON);
+    private static final List<VSyncMode> OFF_ORDER = List.of(VSyncMode.OFF, VSyncMode.ON);
+    private static final List<VSyncMode> MAILBOX_ORDER = List.of(VSyncMode.MAILBOX, VSyncMode.ON);
+
+    private static List<VSyncMode> presentModeOrder(VSyncMode preferred) {
+        return switch (preferred) {
+            case MAILBOX -> MAILBOX_ORDER;
+            case OFF -> OFF_ORDER;
+            default -> ON_ORDER;
+        };
+    }
+
+    public VSyncMode chooseVSyncMode(VSyncMode preferred) {
+        for (VSyncMode candidate : presentModeOrder(preferred)) {
+            if (supportsVSyncMode(candidate)) return candidate;
+        }
+        return vsyncMode;
+    }
+
+    public VSyncMode applyVSync(VSyncMode preferred) {
+        if (device == 0 || !claimed) return vsyncMode;
        final long window = Display.getWindow();
-        final int mode;
-        if (enabled) {
-            mode = SDL_GPU_PRESENTMODE_VSYNC;
-        } else if (SDL_WindowSupportsGPUPresentMode(device, window, SDL_GPU_PRESENTMODE_MAILBOX)) {
-            mode = SDL_GPU_PRESENTMODE_MAILBOX;
-        } else {
-            mode = SDL_GPU_PRESENTMODE_IMMEDIATE;
+        final List<VSyncMode> order = presentModeOrder(preferred);
+        for (VSyncMode candidate : order) {
+            final int sdlMode = toSdl(candidate);
+            if (!SDL_WindowSupportsGPUPresentMode(device, window, sdlMode)) continue;
+            if (!SDL_SetGPUSwapchainParameters(device, window, SDL_GPU_SWAPCHAINCOMPOSITION_SDR, sdlMode)) {
+                LOG.warn("Failed to set present mode {}: {}", candidate, SDLError.SDL_GetError());
+                continue;
+            }
+            if (candidate != order.get(0)) {
+                LOG.warn("Present mode {} is not supported by this window; using {} instead", order.get(0), candidate);
+            }
+            vsyncMode = candidate;
+            LOG.info("SDL present mode {} (preferred={}), refresh {}Hz, {}, video={}, framesInFlight={}, supported: vsync={} immediate={} mailbox={}",
+                candidate, preferred, getDisplayRefreshRateHz(),
+                (SDL_GetWindowFlags(window) & SDL_WINDOW_FULLSCREEN) != 0 ? "fullscreen" : "windowed",
+                SDL_GetCurrentVideoDriver(), FRAMES_IN_FLIGHT,
+                supportsVSyncMode(VSyncMode.ON), supportsVSyncMode(VSyncMode.OFF), supportsVSyncMode(VSyncMode.MAILBOX));
+            return candidate;
        }
-        if (!SDL_SetGPUSwapchainParameters(device, window, SDL_GPU_SWAPCHAINCOMPOSITION_SDR, mode)) {
-            LOG.warn("Failed to set present mode {}: {} (keeping prior mode {})", mode, SDLError.SDL_GetError(), presentMode);
-            return;
+        LOG.warn("No usable present mode for preference {}; keeping {}", preferred, vsyncMode);
+        return vsyncMode;
+    }
+
+    public boolean supportsVSyncMode(VSyncMode mode) {
+        return device != 0 && claimed && SDL_WindowSupportsGPUPresentMode(device, Display.getWindow(), toSdl(mode));
+    }
+
+    public long getClaimedWindow() {
+        return device != 0 && claimed ? Display.getWindow() : 0L;
+    }
+
+    public boolean wasWindowResized() {
+        return getClaimedWindow() != 0L && Display.wasResized();
+    }
+
+    public long getWindowSizeInPixels() {
+        final long window = getClaimedWindow();
+        if (window == 0) return 0L;
+        try (MemoryStack stack = MemoryStack.stackPush()) {
+            final IntBuffer w = stack.mallocInt(1);
+            final IntBuffer h = stack.mallocInt(1);
+            SDL_GetWindowSizeInPixels(window, w, h);
+            return ((long) w.get(0) << 32) | (h.get(0) & 0xFFFFFFFFL);
        }
-        presentMode = mode;
-        LOG.info("SDL present mode set to {}", mode);
+    }
+
+    private static int toSdl(VSyncMode mode) {
+        return switch (mode) {
+            case OFF -> SDL_GPU_PRESENTMODE_IMMEDIATE;
+            case MAILBOX -> SDL_GPU_PRESENTMODE_MAILBOX;
+            default -> SDL_GPU_PRESENTMODE_VSYNC;
+        };
+    }
+
+    public int getDisplayRefreshRateHz() {
+        final long window = Display.getWindow();
+        final int displayId = window == 0 ? SDL_GetPrimaryDisplay() : SDL_GetDisplayForWindow(window);
+        if (displayId == 0) return 0;
+        final SDL_DisplayMode mode = SDL_GetCurrentDisplayMode(displayId);
+        if (mode == null) return 0;
+        return RenderBackend.refreshHzFrom(mode.refresh_rate_numerator(), mode.refresh_rate_denominator(), mode.refresh_rate());
    }

    public int getSwapchainTextureFormat() {
@@ -7,6 +7,7 @@ import com.gtnewhorizons.angelica.sdlgpu.shader.UniformStaging;
 import it.unimi.dsi.fastutil.objects.Reference2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.longs.Long2FloatOpenHashMap;
+import it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap;
 import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
 import it.unimi.dsi.fastutil.longs.LongArrayList;
 import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
@@ -92,6 +93,7 @@ public final class ContextState {
    public float blendColorR, blendColorG, blendColorB, blendColorA;
    public int stencilRef;
    public float depthClearValue = 1.0f;
+    public int stencilClearValue;
    public boolean primitiveRestartEnabled;
    public int primitiveRestartSentinel;

@@ -292,13 +294,20 @@ public final class ContextState {
    public int boundReadFboId;

    public final LongOpenHashSet clearedTexturesThisFrame = new LongOpenHashSet();
+    public final LongOpenHashSet clearedStencilTexturesThisFrame = new LongOpenHashSet();

    public final LongOpenHashSet pendingColorTextures = new LongOpenHashSet();
    public final Long2ObjectOpenHashMap<float[]> pendingColorValues = new Long2ObjectOpenHashMap<>();
    public final LongOpenHashSet pendingDepthTextures = new LongOpenHashSet();
    public final Long2FloatOpenHashMap pendingDepthValues = new Long2FloatOpenHashMap();
+    public final LongOpenHashSet pendingStencilTextures = new LongOpenHashSet();
+    public final Long2IntOpenHashMap pendingStencilValues = new Long2IntOpenHashMap();
    public boolean pendingSwapchainClear;
    public float pendingSwapchainR, pendingSwapchainG, pendingSwapchainB, pendingSwapchainA;
+    public boolean pendingSwapchainDepthClear;
+    public boolean pendingSwapchainStencilClear;
+    public float pendingSwapchainDepth;
+    public int pendingSwapchainStencil;

    public final LongArrayList samplerFlushColorHandles = new LongArrayList();
    public final IntArrayList samplerFlushColorGlIds = new IntArrayList();
@@ -5,6 +5,7 @@ import com.gtnewhorizons.angelica.glsm.profiling.Tracy;
 import com.gtnewhorizons.angelica.sdlgpu.device.Device;
 import com.gtnewhorizons.angelica.sdlgpu.resource.ResourceManager;
 import com.gtnewhorizons.angelica.sdlgpu.util.MemoryAccess;
+import com.gtnewhorizons.angelica.sdlgpu.util.ThreadRegistry;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import com.gtnewhorizons.angelica.sdlgpu.resource.UploadArena;
@@ -16,16 +17,20 @@ import org.lwjgl.PointerBuffer;
 import org.lwjgl.system.MemoryStack;
 import org.lwjgl.sdl.SDLError;
 import org.lwjgl.sdl.SDL_FColor;
+import org.lwjgl.sdl.SDL_GPUBlitInfo;
+import org.lwjgl.sdl.SDL_GPUBlitRegion;
 import org.lwjgl.sdl.SDL_GPUColorTargetInfo;
 import org.lwjgl.sdl.SDL_GPUDepthStencilTargetInfo;
-import org.lwjglx.opengl.Display;

 import java.nio.ByteBuffer;
 import java.nio.IntBuffer;
 import java.util.Arrays;
-import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;

 import static org.lwjgl.sdl.SDLGPU.*;
+import static org.lwjgl.sdl.SDLSurface.SDL_FLIP_NONE;
+import static org.lwjgl.sdl.SDLSurface.SDL_FLIP_VERTICAL;
 import static org.lwjgl.system.MemoryStack.*;

 /**
@@ -37,7 +42,6 @@ public final class FrameManager {
    private static final Tracy.ZoneId Z_SDL_FENCE_WAIT = Tracy.zoneId("sdlFenceWait", Tracy.COLOR_SWAP);
    private static final Tracy.ZoneId Z_SDL_SUBMIT = Tracy.zoneId("sdlSubmit", Tracy.COLOR_SWAP);
    private static final Tracy.ZoneId Z_SDL_ACQUIRE_WAIT = Tracy.zoneId("sdlAcquireWait", Tracy.COLOR_SWAP);
-    private static final Tracy.ZoneId Z_SDL_SWAPCHAIN_WAIT = Tracy.zoneId("sdlSwapchainWait", Tracy.COLOR_SWAP);

    private final Device device;
    private ResourceManager resourceManager;
@@ -48,19 +52,16 @@ public final class FrameManager {
        public long renderPass;
        public long copyPass;
        public boolean computePassOpen;
-        public long swapchainTexture;
-        public int swapchainWidth;
-        public int swapchainHeight;
        public boolean frameActive;
        public long currentColorTarget;
        public long currentDepthTarget;
        public long activeLayoutHash;
        public long frameNumber;
        public boolean clearedThisFrame;
-        public boolean swapchainUsedThisFrame;
-        public boolean swapchainAcquiredThisFrame;
+        public boolean depthClearedThisFrame;
+        public boolean fbo0UsedThisFrame;
+        public boolean presentedThisFrame;
        public boolean swapchainUnavailable;
-        public boolean skipPresent;
        public long renderPassGeneration;

        public boolean wantFenceOnNextSubmit;
@@ -82,13 +83,17 @@ public final class FrameManager {
        public int batchBreakSamplerThisFrame;
        public int stateAppliesThisFrame;
        public long acquireWaitNanosThisFrame;
+        public volatile long lastFrameGateNanos;
+        public volatile long lastFrameGateEndNanos;
+        public int midFrameSubmitsThisFrame;
        public int mipGensThisFrame;
+        public int mipGenSubmitsThisFrame;
+        public int uploadFlushSubmitsThisFrame;
        public int blitsThisFrame;
        public int presentSkipsThisFrame;
        public int emptyFramesThisFrame;
        public int droppedDrawsThisFrame;
        public int computeBatchJoinsThisFrame;
-        public boolean drawableStarved;
        public int clearPassesThisFrame;
        public int swapchainPassesThisFrame;
        public int fboPassesThisFrame;
@@ -144,42 +149,53 @@ public final class FrameManager {

    private volatile boolean globalSyncAtNextBeginFrame;

-    private final CopyOnWriteArrayList<FrameState> registeredFrames = new CopyOnWriteArrayList<>();
+    private final ThreadRegistry<FrameState> registeredFrames = new ThreadRegistry<>(new FrameState[0]);

-     private volatile FrameState soleFrame;
-
-    private final ThreadLocal<FrameState> tlFrame = ThreadLocal.withInitial(() -> {
-        final FrameState f = new FrameState();
-        registeredFrames.add(f);
-        refreshSoleFrame();
-        return f;
-    });
-
-    private void refreshSoleFrame() {
-        soleFrame = registeredFrames.size() == 1 ? registeredFrames.get(0) : null;
-    }
+    private final ThreadLocal<FrameState> tlFrame = new ThreadLocal<>();

    public FrameState frame() {
-        final FrameState f = soleFrame;
-        if (f != null && f.owner == Thread.currentThread()) return f;
-        return tlFrame.get();
+        final FrameState sole = registeredFrames.sole();
+        if (sole != null && sole.owner == Thread.currentThread()) return sole;
+        final FrameState f = tlFrame.get();
+        return f != null ? f : registerFrame();
+    }
+
+    private FrameState registerFrame() {
+        final FrameState f = new FrameState();
+        tlFrame.set(f);
+        registeredFrames.add(f);
+        return f;
+    }
+
+    public int registeredFrameCount() {
+        return registeredFrames.size();
    }

    public FrameState busiestFrame() {
+        final FrameState[] frames = registeredFrames.snapshot();
        FrameState best = null;
-        for (final FrameState f : registeredFrames) {
+        for (final FrameState f : frames) {
            if (best == null || f.frameNumber > best.frameNumber) best = f;
        }
        return best != null ? best : frame();
    }

-    public static final long SWAPCHAIN_LAYOUT_HASH = 0x5CA1AB1E5CA1AB1EL;
+    public static final long FBO0_LAYOUT_HASH = 0x5CA1AB1E5CA1AB1EL;
+
+    private final OffscreenTarget finalTarget = new OffscreenTarget();
+
+    public OffscreenTarget finalTarget() { return finalTarget; }
+
+    public void destroyFinalTarget() {
+        if (resourceManager != null) finalTarget.destroy(resourceManager);
+    }

    public static final long MAX_PENDING_UPLOAD_BYTES = 16L * 1024L * 1024L;
    public static final int MAX_PENDING_UPLOAD_COMMANDS = 256;

    private Runnable beforeEndCopyPass;

+
    public FrameManager(Device device) {
        this.device = device;
    }
@@ -188,18 +204,12 @@ public final class FrameManager {
        this.resourceManager = resourceManager;
    }

-    private static volatile boolean threadLogged;
-
    public void beginFrame() {
        final FrameState f = frame();
        if (f.frameActive) {
            LOG.warn("beginFrame() called while frame already active on thread {}", Thread.currentThread().getName());
            return;
        }
-        if (!threadLogged) {
-            threadLogged = true;
-            LOG.info("First beginFrame() on thread={}; must match the SDL window-creating thread", Thread.currentThread().getName());
-        }

        flushPendingUploadCommandBuffer(f);
        if (globalSyncAtNextBeginFrame) {
@@ -209,23 +219,15 @@ public final class FrameManager {
            finally { Tracy.endZone(); }
        }

-        if (f.drawableStarved) {
-            f.drawableStarved = false;
-            Tracy.beginZone(Z_SDL_SWAPCHAIN_WAIT);
-            try { SDL_WaitForGPUSwapchain(device.getDevice(), Display.getWindow()); }
-            finally { Tracy.endZone(); }
-        }
-
        f.commandBuffer = SDL_AcquireGPUCommandBuffer(device.getDevice());
        if (f.commandBuffer == 0) {
            throw new RuntimeException("Failed to acquire GPU command buffer: " + SDLError.SDL_GetError());
        }

-        f.swapchainTexture = 0;
-        f.swapchainWidth = 0;
-        f.swapchainHeight = 0;
-        f.swapchainAcquiredThisFrame = false;
        f.swapchainUnavailable = false;
+        f.presentedThisFrame = false;
+
+        maintainFinalTarget();

        f.frameActive = true;
        f.renderPass = 0;
@@ -233,23 +235,72 @@ public final class FrameManager {
        f.currentDepthTarget = 0;
        f.frameNumber++;
        f.clearedThisFrame = false;
-        f.swapchainUsedThisFrame = false;
-        f.skipPresent = false;
+        f.depthClearedThisFrame = false;
+        f.fbo0UsedThisFrame = false;
+    }
+
+    private static final long FINAL_TARGET_SIZE_POLL_NANOS = 1_000_000_000L;
+
+    private long finalTargetPollNanos;
+    private volatile Thread mainThread;
+
+    public void setMainThread(Thread thread) {
+        this.mainThread = thread;
+    }
+
+    // Resizing releases a texture an in-flight present may still reference, so drain before ensureSize.
+    private void maintainFinalTarget() {
+        if (resourceManager == null) return;
+        final Thread owner = mainThread;
+        if (owner != null && Thread.currentThread() != owner) return;
+
+        final long now = System.nanoTime();
+        final boolean poll = finalTargetPollNanos == 0L || now - finalTargetPollNanos >= FINAL_TARGET_SIZE_POLL_NANOS;
+        if (!poll && !device.wasWindowResized() && finalTarget.isReady()) return;
+        if (poll) finalTargetPollNanos = now;
+
+        final long size = device.getWindowSizeInPixels();
+        if (size == 0L) return;
+        final int width = (int) (size >> 32);
+        final int height = (int) size;
+        if (finalTarget.isReady() && width == finalTarget.width() && height == finalTarget.height()) return;
+
+        if (presenter != null) presenter.drain();
+        finalTarget.ensureSize(device, resourceManager, width, height);
    }

    public void markFrameEmpty(FrameState f) {
-        f.skipPresent = true;
        f.emptyFramesThisFrame++;
    }

-    public void ensureSwapchainRenderPass(float clearR, float clearG, float clearB, float clearA, boolean clear) {
-        ensureSwapchainRenderPass(frame(), clearR, clearG, clearB, clearA, clear);
+    static boolean swapchainClearNeedsPassBreak(ContextState st, FrameState f) {
+        return (st.pendingSwapchainClear || st.pendingSwapchainDepthClear || st.pendingSwapchainStencilClear) && f.renderPass != 0 && f.activeLayoutHash == FBO0_LAYOUT_HASH;
    }

-    public void ensureSwapchainRenderPass(FrameState f, float clearR, float clearG, float clearB, float clearA, boolean clear) {
-        if (!ensureSwapchainAcquired(f)) return; // present-skip; don't bind tex=0
-        if (f.renderPass != 0 && f.currentColorTarget == f.swapchainTexture) {
-            return;
+    public boolean ensureFbo0RenderPass(FrameState f, ContextState st) {
+        final boolean clearColor = st.pendingSwapchainClear;
+        if (swapchainClearNeedsPassBreak(st, f)) {
+            endRenderPassIfActive(f);
+        }
+        final boolean applied = ensureFbo0RenderPass(f,
+            clearColor ? st.pendingSwapchainR : st.clearR,
+            clearColor ? st.pendingSwapchainG : st.clearG,
+            clearColor ? st.pendingSwapchainB : st.clearB,
+            clearColor ? st.pendingSwapchainA : st.clearA,
+            clearColor,
+            st.pendingSwapchainDepthClear, st.pendingSwapchainDepthClear ? st.pendingSwapchainDepth : st.depthClearValue,
+            st.pendingSwapchainStencilClear, st.pendingSwapchainStencilClear ? st.pendingSwapchainStencil : st.stencilClearValue);
+        if (!applied) return false;
+        st.pendingSwapchainClear = false;
+        st.pendingSwapchainDepthClear = false;
+        st.pendingSwapchainStencilClear = false;
+        return true;
+    }
+
+    private boolean ensureFbo0RenderPass(FrameState f, float clearR, float clearG, float clearB, float clearA, boolean clear, boolean clearDepth, float depthValue, boolean clearStencil, int stencilValue) {
+        if (!finalTarget.isReady() || f.commandBuffer == 0) return false;
+        if (f.renderPass != 0 && f.activeLayoutHash == FBO0_LAYOUT_HASH) {
+            return false;
        }

        endActiveEncoders(f);
@@ -258,10 +309,16 @@ public final class FrameManager {
            clear = true;
        }

+        final long depthTexture = resourceManager != null ? resourceManager.getOrCreateSwapchainDepthStencil(finalTarget.width(), finalTarget.height()) : 0L;
+        if (depthTexture != 0 && !f.depthClearedThisFrame) {
+            clearDepth = true;
+            clearStencil = true;
+        }
+
        try (var stack = stackPush()) {
            final SDL_GPUColorTargetInfo.Buffer colorTargets = SDL_GPUColorTargetInfo.calloc(1, stack);
            final long ctAddr = colorTargets.get(0).address();
-            MemoryAccess.putAddress(ctAddr + SDL_GPUColorTargetInfo.TEXTURE, f.swapchainTexture);
+            MemoryAccess.putAddress(ctAddr + SDL_GPUColorTargetInfo.TEXTURE, finalTarget.colorTexture());
            MemoryAccess.putInt(ctAddr + SDL_GPUColorTargetInfo.LOAD_OP, clear ? SDL_GPU_LOADOP_CLEAR : SDL_GPU_LOADOP_LOAD);
            MemoryAccess.putInt(ctAddr + SDL_GPUColorTargetInfo.STORE_OP, SDL_GPU_STOREOP_STORE);

@@ -274,19 +331,35 @@ public final class FrameManager {
                f.clearedThisFrame = true;
            }

+            SDL_GPUDepthStencilTargetInfo depthTarget = null;
+            if (depthTexture != 0) {
+                depthTarget = SDL_GPUDepthStencilTargetInfo.calloc(stack);
+                final long dtAddr = depthTarget.address();
+                MemoryAccess.putAddress(dtAddr + SDL_GPUDepthStencilTargetInfo.TEXTURE, depthTexture);
+                MemoryAccess.putInt(dtAddr + SDL_GPUDepthStencilTargetInfo.LOAD_OP, clearDepth ? SDL_GPU_LOADOP_CLEAR : SDL_GPU_LOADOP_LOAD);
+                MemoryAccess.putInt(dtAddr + SDL_GPUDepthStencilTargetInfo.STORE_OP, SDL_GPU_STOREOP_STORE);
+                MemoryAccess.putFloat(dtAddr + SDL_GPUDepthStencilTargetInfo.CLEAR_DEPTH, depthValue);
+                MemoryAccess.putInt(dtAddr + SDL_GPUDepthStencilTargetInfo.STENCIL_LOAD_OP, clearStencil ? SDL_GPU_LOADOP_CLEAR : SDL_GPU_LOADOP_LOAD);
+                MemoryAccess.putInt(dtAddr + SDL_GPUDepthStencilTargetInfo.STENCIL_STORE_OP, SDL_GPU_STOREOP_STORE);
+                MemoryAccess.putByte(dtAddr + SDL_GPUDepthStencilTargetInfo.CLEAR_STENCIL, (byte) stencilValue);
+                if (clearDepth && clearStencil) f.depthClearedThisFrame = true;
+            }
+
            if (preRenderPassHook != null) preRenderPassHook.run();
            assertNoEncoderActive(f, "SDL_BeginGPURenderPass(swapchain)");
-            f.renderPass = SDL_BeginGPURenderPass(f.commandBuffer, colorTargets, null);
+            f.renderPass = SDL_BeginGPURenderPass(f.commandBuffer, colorTargets, depthTarget);
            if (f.renderPass == 0) {
                throw new RuntimeException("Failed to begin render pass: " + SDLError.SDL_GetError());
            }
            f.renderPassGeneration++;
            f.swapchainPassesThisFrame++;
-            f.currentColorTarget = f.swapchainTexture;
-            f.currentDepthTarget = 0;
-            f.activeLayoutHash = SWAPCHAIN_LAYOUT_HASH;
-            f.swapchainUsedThisFrame = true;
+            f.currentColorTarget = finalTarget.colorTexture();
+            f.currentDepthTarget = depthTexture;
+            f.activeLayoutHash = FBO0_LAYOUT_HASH;
+            f.fbo0UsedThisFrame = true;
+            finalTarget.markContent();
        }
+        return true;
    }


@@ -336,6 +409,8 @@ public final class FrameManager {

    public void noteMipGen() { frame().mipGensThisFrame++; }

+    public void noteMipGenSubmit() { frame().mipGenSubmitsThisFrame++; }
+
    public void noteBlit() { frame().blitsThisFrame++; }

    public void noteClearPass() { frame().clearPassesThisFrame++; }
@@ -389,6 +464,20 @@ public final class FrameManager {
        }
    }

+    private volatile boolean acquireThreadReported;
+
+    private void checkAcquireOnWindowThread() {
+        if (acquireThreadReported) return;
+        final Thread self = Thread.currentThread();
+        final Thread window = device.getWindowThread();
+        if (window == null || window == self) return;
+        acquireThreadReported = true;
+
+        final String message = "Swapchain acquired on '" + self.getName() + "', window created on '" + window.getName() + "'";
+        if (SystemProperties.isDeobf() && !SystemProperties.DISABLE_SDL_PRESENTER_THREAD) throw new IllegalStateException(message);
+        LOG.warn(message);
+    }
+
    public long ensureCopyPass() {
        final FrameState f = frame();
        if (f.copyPass != 0) {
@@ -425,17 +514,14 @@ public final class FrameManager {
    }

    public void requestFlushOnAllRegisteredFrames() {
-        final int n = registeredFrames.size();
-        for (int i = 0; i < n; i++) {
-            registeredFrames.get(i).flushRequested = true;
+        for (final FrameState f : registeredFrames.snapshot()) {
+            f.flushRequested = true;
        }
    }

    public void requestSyncFlushOnAllRegisteredFrames() {
        globalSyncAtNextBeginFrame = true;
-        final int n = registeredFrames.size();
-        for (int i = 0; i < n; i++) {
-            final FrameState f = registeredFrames.get(i);
+        for (final FrameState f : registeredFrames.snapshot()) {
            f.flushRequested = true;
            f.syncOnNextFlush = true;
        }
@@ -462,10 +548,6 @@ public final class FrameManager {
        endCopyPassIfActive(f);
        endRenderPassIfActive(f);

-        if (!f.swapchainAcquiredThisFrame && !f.swapchainUnavailable && !f.skipPresent && f.commandBuffer != 0) {
-            ensureSwapchainAcquired(f);
-        }
-
        if (f.commandBuffer != 0) {
            Tracy.beginZone(Z_SDL_SUBMIT);
            try {
@@ -486,9 +568,14 @@ public final class FrameManager {
            f.commandBuffer = 0;
        }

-        f.drawableStarved = f.presentSkipsThisFrame > 0;
+        drainWindowPresentCounters(f);
+
+        if (Tracy.ENABLED && resourceManager != null) {
+            SdlFramePlots.emit(f, resourceManager);
+        }
+
+        f.midFrameSubmitsThisFrame = 0;

-        if (Tracy.ENABLED && resourceManager != null) SdlFramePlots.emit(f, resourceManager);
        f.lastPlottedRenderPassGen = f.renderPassGeneration;
        f.computePassesThisFrame = 0;
        f.submitsThisFrame = 0;
@@ -506,6 +593,8 @@ public final class FrameManager {
        f.stateAppliesThisFrame = 0;
        f.acquireWaitNanosThisFrame = 0;
        f.mipGensThisFrame = 0;
+        f.mipGenSubmitsThisFrame = 0;
+        f.uploadFlushSubmitsThisFrame = 0;
        f.blitsThisFrame = 0;
        f.clearPassesThisFrame = 0;
        f.swapchainPassesThisFrame = 0;
@@ -520,9 +609,6 @@ public final class FrameManager {
        f.computeBatchJoinsThisFrame = 0;

        f.frameActive = false;
-        f.swapchainTexture = 0;
-
-        if (afterPresent != null) afterPresent.run();
    }

    public void submitMidFrame() {
@@ -546,6 +632,7 @@ public final class FrameManager {
            Tracy.endZone();
        }
        f.submitsThisFrame++;
+        f.midFrameSubmitsThisFrame++;
        f.commandBuffer = 0;
        if (f.frameActive) {
            reacquireCommandBuffer();
@@ -557,6 +644,7 @@ public final class FrameManager {
        if (f.frameActive) {
            endFrame();
        }
+        presentFinalTarget();
        beginFrame();
    }

@@ -633,6 +721,7 @@ public final class FrameManager {
                device.reportGpuFailure("submit pending upload command buffer");
            }
            f.submitsThisFrame++;
+            f.uploadFlushSubmitsThisFrame++;
            f.pendingUploadCommandBuffer = 0;
            f.pendingUploadBytes = 0;
            f.pendingUploadCommands = 0;
@@ -667,22 +756,16 @@ public final class FrameManager {

    public long getActiveLayoutHash(FrameState f) { return f.activeLayoutHash; }

-    public long getSwapchainTexture() {
-        final FrameState f = frame();
-        ensureSwapchainAcquired(f);
-        return f.swapchainTexture;
+    public long getFbo0Texture() {
+        return finalTarget.colorTexture();
    }

-    public int getSwapchainWidth() {
-        final FrameState f = frame();
-        ensureSwapchainAcquired(f);
-        return f.swapchainWidth;
+    public int getFbo0Width() {
+        return finalTarget.width();
    }

-    public int getSwapchainHeight() {
-        final FrameState f = frame();
-        ensureSwapchainAcquired(f);
-        return f.swapchainHeight;
+    public int getFbo0Height() {
+        return finalTarget.height();
    }

    public int getSwapchainFormat() {
@@ -717,8 +800,8 @@ public final class FrameManager {
        return frame().frameNumber;
    }

-    public boolean isSwapchainUsedThisFrame() {
-        return frame().swapchainUsedThisFrame;
+    public boolean isFbo0UsedThisFrame() {
+        return frame().fbo0UsedThisFrame;
    }

    public void reacquireCommandBuffer() {
@@ -731,24 +814,18 @@ public final class FrameManager {
        f.currentDepthTarget = 0;

        if (f.frameActive) {
-            final boolean wasAcquired = f.swapchainAcquiredThisFrame;
-            f.swapchainAcquiredThisFrame = false;
-            f.swapchainTexture = 0;
-            if (wasAcquired && !ensureSwapchainAcquired(f)) {
-                LOG.warn("Failed to re-acquire swapchain after readback: {}", SDLError.SDL_GetError());
-            }
            f.clearedThisFrame = false;
        }
    }

    public void releaseThreadState() {
-        final FrameState f = frame();
+        final FrameState f = tlFrame.get();
+        if (f == null) return;
        if (resourceManager != null) resourceManager.flushUploadArena(f);
        flushPendingUploadCommandBuffer(f);
        releaseFrameStateResources(f);
-        registeredFrames.remove(f);
        tlFrame.remove();
-        refreshSoleFrame();
+        registeredFrames.remove(f);
    }

    private void releaseFrameStateResources(FrameState f) {
@@ -786,25 +863,97 @@ public final class FrameManager {
    }

    public void releaseAllRegisteredFrames() {
-        for (FrameState f : registeredFrames) {
+        for (final FrameState f : registeredFrames.snapshot()) {
            releaseFrameStateResources(f);
        }
        registeredFrames.clear();
-        soleFrame = null;
    }

-    public boolean ensureSwapchainAcquired() {
-        return ensureSwapchainAcquired(frame());
+    public long lastFrameGateNanos() {
+        return frame().lastFrameGateNanos;
    }

-    public boolean ensureSwapchainAcquired(FrameState f) {
-        if (f.swapchainAcquiredThisFrame) return true;
-        if (f.swapchainUnavailable) return false;
-        if (!f.frameActive || f.commandBuffer == 0) return false;
+    public long lastFrameGateEndNanos() {
+        return frame().lastFrameGateEndNanos;
+    }

-        endActiveEncoders(f);
+    private volatile Presenter presenter;

-        final long t0 = Tracy.ENABLED ? System.nanoTime() : 0L;
+    public void setPresenter(Presenter presenter) {
+        this.presenter = presenter;
+    }
+
+    private final FrameState windowFrame = new FrameState();
+
+    public FrameState windowFrame() {
+        return windowFrame;
+    }
+
+    public void presentFinalTarget() {
+        if (!finalTarget.hasContent()) return;
+        present(finalTarget.colorTexture(), finalTarget.width(), finalTarget.height(), SDL_FLIP_NONE, false);
+    }
+
+    public void presentSplash(long srcTexture, int srcW, int srcH) {
+        present(srcTexture, srcW, srcH, SDL_FLIP_VERTICAL, true);
+    }
+
+    private void present(long srcTexture, int srcW, int srcH, int flipMode, boolean splash) {
+        final FrameState f = frame();
+        if (f.presentedThisFrame) return;
+        final Presenter p = presenter;
+        if (p != null) {
+            f.presentedThisFrame = true;
+            p.requestPresent(srcTexture, srcW, srcH, flipMode);
+        } else {
+            presentBlit(f, srcTexture, srcW, srcH, flipMode);
+        }
+        if (splash) f.presentedThisFrame = false;
+    }
+
+    private final AtomicLong windowAcquireWaitNanos = new AtomicLong();
+    private final AtomicInteger windowPresentSkips = new AtomicInteger();
+
+    private void drainWindowPresentCounters(FrameState f) {
+        if (f == windowFrame) return;
+        final long acquire = windowAcquireWaitNanos.getAndSet(0L);
+        if (acquire != 0L) {
+            f.acquireWaitNanosThisFrame += acquire;
+            f.lastFrameGateNanos = windowFrame.lastFrameGateNanos;
+            f.lastFrameGateEndNanos = windowFrame.lastFrameGateEndNanos;
+        }
+        f.presentSkipsThisFrame += windowPresentSkips.getAndSet(0);
+    }
+
+    private void noteAcquireWait(FrameState f, long waitNanos) {
+        if (f == windowFrame) windowAcquireWaitNanos.addAndGet(waitNanos);
+        else f.acquireWaitNanosThisFrame += waitNanos;
+    }
+
+    private void notePresentSkip(FrameState f) {
+        if (f == windowFrame) windowPresentSkips.incrementAndGet();
+        else f.presentSkipsThisFrame++;
+    }
+
+    public void presentOnWindowThread(long srcTexture, int srcW, int srcH, int flipMode) {
+        presentBlit(windowFrame, srcTexture, srcW, srcH, flipMode);
+        windowFrame.presentedThisFrame = false;
+        windowFrame.swapchainUnavailable = false;
+    }
+
+    public boolean presentBlit(FrameState f, long srcTexture, int srcW, int srcH, int flipMode) {
+        if (srcTexture == 0 || srcW <= 0 || srcH <= 0) return false;
+        if (f.presentedThisFrame || f.swapchainUnavailable) return false;
+
+        checkAcquireOnWindowThread();
+
+        final long window = device.getClaimedWindow();
+        if (window == 0) return false;
+
+        final long cb = SDL_AcquireGPUCommandBuffer(device.getDevice());
+        if (cb == 0) return false;
+
+        final long t0 = System.nanoTime();
        final long tex;
        final int w;
        final int h;
@@ -815,7 +964,7 @@ public final class FrameManager {
            final IntBuffer pHeight = stack.ints(0);
            Tracy.beginZone(Z_SDL_ACQUIRE_WAIT);
            try {
-                callOk = SDL_AcquireGPUSwapchainTexture(f.commandBuffer, Display.getWindow(), pTexture, pWidth, pHeight);
+                callOk = SDL_WaitAndAcquireGPUSwapchainTexture(cb, window, pTexture, pWidth, pHeight);
            } finally {
                Tracy.endZone();
            }
@@ -823,25 +972,43 @@ public final class FrameManager {
            w = pWidth.get(0);
            h = pHeight.get(0);
        } catch (RuntimeException re) {
-            if (Tracy.ENABLED) f.acquireWaitNanosThisFrame += System.nanoTime() - t0;
+            SDL_CancelGPUCommandBuffer(cb);
            f.swapchainUnavailable = true;
            throw re;
        }
-        if (Tracy.ENABLED) f.acquireWaitNanosThisFrame += System.nanoTime() - t0;
+        final long tEnd = System.nanoTime();
+        f.lastFrameGateNanos = tEnd - t0;
+        f.lastFrameGateEndNanos = tEnd;
+        noteAcquireWait(f, tEnd - t0);

-        if (!callOk) {
+        if (!callOk || tex == 0) {
+            SDL_CancelGPUCommandBuffer(cb);
            f.swapchainUnavailable = true;
+            notePresentSkip(f);
            return false;
        }
-        if (tex == 0) {
-            f.swapchainUnavailable = true;
-            f.presentSkipsThisFrame++;
+
+        try (MemoryStack stack = stackPush()) {
+            final long info = stack.ncalloc(SDL_GPUBlitInfo.ALIGNOF, 1, SDL_GPUBlitInfo.SIZEOF);
+            writeBlitRegion(info + SDL_GPUBlitInfo.SOURCE, srcTexture, srcW, srcH);
+            writeBlitRegion(info + SDL_GPUBlitInfo.DESTINATION, tex, w, h);
+            MemoryAccess.putInt(info + SDL_GPUBlitInfo.FILTER, SDL_GPU_FILTER_LINEAR);
+            MemoryAccess.putInt(info + SDL_GPUBlitInfo.FLIP_MODE, flipMode);
+            nSDL_BlitGPUTexture(cb, info);
+        }
+
+        if (!SDL_SubmitGPUCommandBuffer(cb)) {
+            device.reportGpuFailure("submit present blit");
            return false;
        }
-        f.swapchainTexture = tex;
-        f.swapchainWidth = w;
-        f.swapchainHeight = h;
-        f.swapchainAcquiredThisFrame = true;
+        f.presentedThisFrame = true;
+        if (afterPresent != null) afterPresent.run();
        return true;
    }
+
+    private static void writeBlitRegion(long region, long texture, int w, int h) {
+        MemoryAccess.putAddress(region + SDL_GPUBlitRegion.TEXTURE, texture);
+        MemoryAccess.putInt(region + SDL_GPUBlitRegion.W, w);
+        MemoryAccess.putInt(region + SDL_GPUBlitRegion.H, h);
+    }
 }
@@ -1,7 +1,6 @@
-package com.gtnewhorizons.angelica.sdlgpu.splash;
+package com.gtnewhorizons.angelica.sdlgpu.frame;

 import com.gtnewhorizons.angelica.sdlgpu.device.Device;
-import com.gtnewhorizons.angelica.sdlgpu.frame.ContextState;
 import com.gtnewhorizons.angelica.sdlgpu.resource.FboState;
 import com.gtnewhorizons.angelica.sdlgpu.resource.ResourceManager;
 import org.lwjgl.opengl.GL11;
@@ -9,13 +8,14 @@ import org.lwjgl.opengl.GL11;
 import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREUSAGE_COLOR_TARGET;
 import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREUSAGE_SAMPLER;

-public final class SplashOffscreenTarget {
+public final class OffscreenTarget {

    private int fboGlId;
    private int colorTexGlId;
    private long colorTexHandle;
    private int width;
    private int height;
+    private boolean hasContent;

    public void create(Device device, ResourceManager rm, int width, int height, int swapchainSdlFormat) {
        this.width = width;
@@ -37,10 +37,20 @@ public final class SplashOffscreenTarget {
        fbo.cachedFormatsDirty = true;
    }

+    public void ensureSize(Device device, ResourceManager rm, int width, int height) {
+        if (width <= 0 || height <= 0) return;
+        if (colorTexHandle != 0 && width == this.width && height == this.height) return;
+        destroy(rm);
+        create(device, rm, width, height, device.getSwapchainTextureFormat());
+    }
+
    public int fboId() { return fboGlId; }
    public long colorTexture() { return colorTexHandle; }
    public int width() { return width; }
    public int height() { return height; }
+    public boolean isReady() { return colorTexHandle != 0; }
+    public boolean hasContent() { return hasContent; }
+    public void markContent() { hasContent = true; }

    public boolean isFor(ContextState st) {
        return fboGlId != 0 && st.boundFboId == fboGlId;
@@ -56,5 +66,6 @@ public final class SplashOffscreenTarget {
            colorTexGlId = 0;
            colorTexHandle = 0;
        }
+        hasContent = false;
    }
 }
@@ -0,0 +1,38 @@
+package com.gtnewhorizons.angelica.sdlgpu.frame;
+
+import java.util.concurrent.Executor;
+import java.util.concurrent.Semaphore;
+
+public final class Presenter {
+
+    private final FrameManager frameManager;
+    private final Executor windowThreadExecutor;
+    private final Semaphore pending = new Semaphore(1);
+
+    public Presenter(FrameManager frameManager, Executor windowThreadExecutor) {
+        this.frameManager = frameManager;
+        this.windowThreadExecutor = windowThreadExecutor;
+    }
+
+    public void requestPresent(long srcTexture, int srcW, int srcH, int flipMode) {
+        pending.acquireUninterruptibly();
+        boolean submitted = false;
+        try {
+            windowThreadExecutor.execute(() -> {
+                try {
+                    frameManager.presentOnWindowThread(srcTexture, srcW, srcH, flipMode);
+                } finally {
+                    pending.release();
+                }
+            });
+            submitted = true;
+        } finally {
+            if (!submitted) pending.release();
+        }
+    }
+
+    public void drain() {
+        pending.acquireUninterruptibly();
+        pending.release();
+    }
+}
@@ -40,6 +40,8 @@ final class SdlFramePlots {
    private static final long PLOT_PRESENT_TO_PRESENT_US = Tracy.plotHandle("sdl.presentToPresentUs");
    private static final long PLOT_FRAMES_IN_FLIGHT = Tracy.plotHandle("sdl.framesInFlight");
    private static final long PLOT_MIP_GENS = Tracy.plotHandle("sdl.mipGens");
+    private static final long PLOT_MIP_GEN_SUBMITS = Tracy.plotHandle("sdl.mipGenSubmits");
+    private static final long PLOT_UPLOAD_FLUSH_SUBMITS = Tracy.plotHandle("sdl.uploadFlushSubmits");
    private static final long PLOT_BLIT_FALLBACKS = Tracy.plotHandle("sdl.blitFallbacks");
    private static final long PLOT_PRESENT_SKIPS = Tracy.plotHandle("sdl.presentSkips");
    private static final long PLOT_EMPTY_FRAMES = Tracy.plotHandle("sdl.emptyFrames");
@@ -54,6 +56,7 @@ final class SdlFramePlots {
    private static final long PLOT_BUFFER_POOL_HITS = Tracy.plotHandle("sdl.bufferPoolHits");
    private static final long PLOT_PIPELINE_KEY_RECOMPUTES = Tracy.plotHandle("sdl.pipelineKeyRecomputes");
    private static final long PLOT_PIPELINE_FAST_PATH_HITS = Tracy.plotHandle("sdl.pipelineFastPathHits");
+    private static final long PLOT_MID_FRAME_SUBMITS = Tracy.plotHandle("sdl.midFrameSubmits");

    private static final int[] contextCounters = new int[SDLGPURenderBackend.CTR_COUNT];

@@ -97,11 +100,14 @@ final class SdlFramePlots {
        final long nowNanos = System.nanoTime();
        if (f.lastEndFrameNanos != 0) Tracy.plotInt(PLOT_PRESENT_TO_PRESENT_US, (nowNanos - f.lastEndFrameNanos) / 1000);
        f.lastEndFrameNanos = nowNanos;
-        Tracy.plotInt(PLOT_FRAMES_IN_FLIGHT, Device.FRAMES_IN_FLIGHT);
+        Tracy.plotInt(PLOT_FRAMES_IN_FLIGHT, Device.framesInFlight());
        Tracy.plotInt(PLOT_MIP_GENS, f.mipGensThisFrame);
+        Tracy.plotInt(PLOT_MIP_GEN_SUBMITS, f.mipGenSubmitsThisFrame);
+        Tracy.plotInt(PLOT_UPLOAD_FLUSH_SUBMITS, f.uploadFlushSubmitsThisFrame);
        Tracy.plotInt(PLOT_BLIT_FALLBACKS, f.blitsThisFrame);
        Tracy.plotInt(PLOT_PRESENT_SKIPS, f.presentSkipsThisFrame);
        Tracy.plotInt(PLOT_EMPTY_FRAMES, f.emptyFramesThisFrame);
        Tracy.plotInt(PLOT_DROPPED_DRAWS, f.droppedDrawsThisFrame);
+        Tracy.plotInt(PLOT_MID_FRAME_SUBMITS, f.midFrameSubmitsThisFrame);
    }
 }
@@ -20,6 +20,7 @@ import com.gtnewhorizons.angelica.sdlgpu.resource.FBOClearTracker;
 import com.gtnewhorizons.angelica.sdlgpu.resource.FboState;
 import com.gtnewhorizons.angelica.sdlgpu.resource.PersistentBufferSync;
 import com.gtnewhorizons.angelica.sdlgpu.resource.PersistentMapping;
+import com.gtnewhorizons.angelica.sdlgpu.resource.PixelOps;
 import com.gtnewhorizons.angelica.sdlgpu.resource.ResourceManager;
 import com.gtnewhorizons.angelica.sdlgpu.sampler.SamplerBinder;
 import com.gtnewhorizons.angelica.sdlgpu.sampler.StorageBufferBinder;
@@ -108,11 +109,8 @@ public final class PipelineApplier {
        }

        if (st.boundFboId == 0) {
-            if (st.pendingSwapchainClear) {
-                frameManager.ensureSwapchainRenderPass(f, st.pendingSwapchainR, st.pendingSwapchainG, st.pendingSwapchainB, st.pendingSwapchainA, true);
-                st.pendingSwapchainClear = false;
-            } else {
-                frameManager.ensureSwapchainRenderPass(f, st.clearR, st.clearG, st.clearB, st.clearA, false);
+            if (frameManager.ensureFbo0RenderPass(f, st)) {
+                st.pipeline.setDepthTargetFormat(resourceManager.getSwapchainDepthStencilFormat());
            }
            return;
        }
@@ -145,47 +143,50 @@ public final class PipelineApplier {
                tex = dummyTex;
            }
            final boolean pendingClear = tex != dummyTex && st.pendingColorTextures.contains(tex);
-            final boolean firstUse = !pendingClear && tex != dummyTex && !st.clearedTexturesThisFrame.contains(tex);
+            final boolean defined = tex != dummyTex && resourceManager.isTextureContentDefined(tex);
+            final boolean firstUse = !pendingClear && tex != dummyTex && !defined;
            if (pendingClear || firstUse) proposedClearOps |= 1 << i;
            layoutHash = Hashing.fmix64(layoutHash, tex);
            layoutHash = Hashing.fmix64(layoutHash, db);
+            if (pendingClear || firstUse) {
+                final float[] c = pendingClear ? st.pendingColorValues.get(tex) : null;
+                layoutHash = foldClearColor(layoutHash, c != null ? c[0] : st.clearR, c != null ? c[1] : st.clearG, c != null ? c[2] : st.clearB, c != null ? c[3] : st.clearA);
+            }
        }
        final boolean proposedDepthClear;
+        final boolean proposedStencilClear;
+        final boolean depthHasStencil = fbo.depthTexture != 0 && PixelOps.isDepthStencilFormat(fbo.depthFormat);
        if (fbo.depthTexture != 0) {
            final boolean pendingClear = st.pendingDepthTextures.contains(fbo.depthTexture);
            final boolean firstUse = !pendingClear && !st.clearedTexturesThisFrame.contains(fbo.depthTexture);
            proposedDepthClear = pendingClear || firstUse;
+            final boolean pendingStencil = depthHasStencil && st.pendingStencilTextures.contains(fbo.depthTexture);
+            if (depthHasStencil) {
+                final boolean firstStencilUse = !pendingStencil && !st.clearedStencilTexturesThisFrame.contains(fbo.depthTexture);
+                proposedStencilClear = pendingStencil || firstStencilUse;
+            } else {
+                proposedStencilClear = false;
+            }
            layoutHash = Hashing.fmix64(layoutHash, fbo.depthTexture);
+            if (proposedDepthClear) {
+                layoutHash = foldClearDepth(layoutHash, pendingClear ? st.pendingDepthValues.get(fbo.depthTexture) : st.depthClearValue);
+            }
+            if (proposedStencilClear) {
+                layoutHash = foldClearStencil(layoutHash, pendingStencil ? st.pendingStencilValues.get(fbo.depthTexture) : st.stencilClearValue);
+            }
        } else {
            proposedDepthClear = false;
+            proposedStencilClear = false;
        }
-        layoutHash = Hashing.fmix64(layoutHash, Float.floatToRawIntBits(st.clearR));
-        layoutHash = Hashing.fmix64(layoutHash, Float.floatToRawIntBits(st.clearG));
-        layoutHash = Hashing.fmix64(layoutHash, Float.floatToRawIntBits(st.clearB));
-        layoutHash = Hashing.fmix64(layoutHash, Float.floatToRawIntBits(st.clearA));
-        layoutHash = Hashing.fmix64(layoutHash, Float.floatToRawIntBits(st.depthClearValue));

        frameManager.endRenderPassIfActive(f);

-        final boolean reuse = fbo.cachedTargetsValid && fbo.cachedTargetsLayoutHash == layoutHash && fbo.cachedTargetsCount == totalTargets && fbo.cachedClearOpFlags == proposedClearOps && fbo.cachedDepthClearLast == proposedDepthClear;
+        final boolean reuse = fbo.cachedTargetsValid && fbo.cachedTargetsLayoutHash == layoutHash && fbo.cachedTargetsCount == totalTargets && fbo.cachedClearOpFlags == proposedClearOps && fbo.cachedDepthClearLast == proposedDepthClear && fbo.cachedStencilClearLast == proposedStencilClear;

        SDL_GPUColorTargetInfo.Buffer colorTargets = null;
        SDL_GPUDepthStencilTargetInfo depthTarget = null;

        if (reuse) {
-            for (int i = 0; i < totalTargets; i++) {
-                final int db = fbo.drawBuffers[i];
-                final long tex = (db >= 0 && db < ContextState.MAX_COLOR_ATTACHMENTS)
-                    ? fbo.colorTextures[db] : 0L;
-                if (tex != 0) {
-                    st.pendingColorTextures.remove(tex);
-                    if ((proposedClearOps & (1 << i)) != 0) st.clearedTexturesThisFrame.add(tex);
-                }
-            }
-            if (fbo.depthTexture != 0) {
-                st.pendingDepthTextures.remove(fbo.depthTexture);
-                if (proposedDepthClear) st.clearedTexturesThisFrame.add(fbo.depthTexture);
-            }
            if (totalTargets > 0) colorTargets = fbo.cachedColorTargets.position(0).limit(totalTargets);
            if (fbo.depthTexture != 0) depthTarget = fbo.cachedDepthTarget;
        } else {
@@ -199,9 +200,8 @@ public final class PipelineApplier {
                    } else {
                        tex = dummyTex;
                    }
-                    final boolean pendingClear = tex != dummyTex && st.pendingColorTextures.remove(tex);
-                    final boolean firstUse = !pendingClear && tex != dummyTex && !st.clearedTexturesThisFrame.contains(tex);
-                    final boolean clearThis = pendingClear || firstUse;
+                    final boolean pendingClear = tex != dummyTex && st.pendingColorTextures.contains(tex);
+                    final boolean clearThis = (proposedClearOps & (1 << i)) != 0;
                    final long ctAddr = colorTargets.address() + (long) i * SDL_GPUColorTargetInfo.SIZEOF;
                    MemoryAccess.putAddress(ctAddr + SDL_GPUColorTargetInfo.TEXTURE, tex);
                    MemoryAccess.putInt(ctAddr + SDL_GPUColorTargetInfo.LOAD_OP, clearThis ? SDL_GPU_LOADOP_CLEAR : SDL_GPU_LOADOP_LOAD);
@@ -220,36 +220,79 @@ public final class PipelineApplier {
                            MemoryAccess.putFloat(ccAddr + SDL_FColor.B, st.clearB);
                            MemoryAccess.putFloat(ccAddr + SDL_FColor.A, st.clearA);
                        }
-                        if (tex != dummyTex) st.clearedTexturesThisFrame.add(tex);
                    }
                }
            }
            if (fbo.depthTexture != 0) {
-                final boolean pendingClear = st.pendingDepthTextures.remove(fbo.depthTexture);
-                final boolean firstUse = !pendingClear && !st.clearedTexturesThisFrame.contains(fbo.depthTexture);
-                final boolean clearDepth = pendingClear || firstUse;
+                final boolean pendingClear = st.pendingDepthTextures.contains(fbo.depthTexture);
                depthTarget = fbo.cachedDepthTarget;
                final long dtAddr = depthTarget.address();
                MemoryAccess.putAddress(dtAddr + SDL_GPUDepthStencilTargetInfo.TEXTURE, fbo.depthTexture);
-                MemoryAccess.putInt(dtAddr + SDL_GPUDepthStencilTargetInfo.LOAD_OP, clearDepth ? SDL_GPU_LOADOP_CLEAR : SDL_GPU_LOADOP_LOAD);
+                MemoryAccess.putInt(dtAddr + SDL_GPUDepthStencilTargetInfo.LOAD_OP, proposedDepthClear ? SDL_GPU_LOADOP_CLEAR : SDL_GPU_LOADOP_LOAD);
                MemoryAccess.putInt(dtAddr + SDL_GPUDepthStencilTargetInfo.STORE_OP, SDL_GPU_STOREOP_STORE);
-                if (clearDepth) {
+                if (proposedDepthClear) {
                    final float dv = pendingClear ? st.pendingDepthValues.get(fbo.depthTexture) : st.depthClearValue;
                    MemoryAccess.putFloat(dtAddr + SDL_GPUDepthStencilTargetInfo.CLEAR_DEPTH, dv);
-                    st.clearedTexturesThisFrame.add(fbo.depthTexture);
+                }
+                if (depthHasStencil) {
+                    final boolean pendingStencil = st.pendingStencilTextures.contains(fbo.depthTexture);
+                    MemoryAccess.putInt(dtAddr + SDL_GPUDepthStencilTargetInfo.STENCIL_LOAD_OP, proposedStencilClear ? SDL_GPU_LOADOP_CLEAR : SDL_GPU_LOADOP_LOAD);
+                    MemoryAccess.putInt(dtAddr + SDL_GPUDepthStencilTargetInfo.STENCIL_STORE_OP, SDL_GPU_STOREOP_STORE);
+                    if (proposedStencilClear) {
+                        final int sv = pendingStencil ? st.pendingStencilValues.get(fbo.depthTexture) : st.stencilClearValue;
+                        MemoryAccess.putByte(dtAddr + SDL_GPUDepthStencilTargetInfo.CLEAR_STENCIL, (byte) sv);
+                    }
+                } else {
+                    MemoryAccess.putInt(dtAddr + SDL_GPUDepthStencilTargetInfo.STENCIL_LOAD_OP, SDL_GPU_LOADOP_LOAD);
+                    MemoryAccess.putInt(dtAddr + SDL_GPUDepthStencilTargetInfo.STENCIL_STORE_OP, SDL_GPU_STOREOP_STORE);
                }
            }
            fbo.cachedTargetsLayoutHash = layoutHash;
            fbo.cachedTargetsCount = totalTargets;
            fbo.cachedClearOpFlags = proposedClearOps;
            fbo.cachedDepthClearLast = proposedDepthClear;
+            fbo.cachedStencilClearLast = proposedStencilClear;
            fbo.cachedTargetsValid = true;
        }

+        consumeClears(resourceManager, st, fbo, dummyTex, proposedClearOps, proposedDepthClear, proposedStencilClear, depthHasStencil);
+
        frameManager.beginRenderPass(colorTargets, depthTarget);
        frameManager.setActiveLayoutHash(fbo.structuralLayoutHash);
    }

+    static void consumeClears(ResourceManager rm, ContextState st, FboState fbo, long dummyTex, int clearOps, boolean depthClear, boolean stencilClear, boolean depthHasStencil) {
+        for (int i = 0, n = fbo.drawBuffers.length; i < n; i++) {
+            final int db = fbo.drawBuffers[i];
+            final long tex = (db >= 0 && db < ContextState.MAX_COLOR_ATTACHMENTS) ? fbo.colorTextures[db] : 0L;
+            if (tex == 0 || tex == dummyTex) continue;
+            st.pendingColorTextures.remove(tex);
+            if ((clearOps & (1 << i)) != 0) rm.markTextureContentDefined(tex);
+        }
+        if (fbo.depthTexture == 0) return;
+        st.pendingDepthTextures.remove(fbo.depthTexture);
+        if (depthClear) st.clearedTexturesThisFrame.add(fbo.depthTexture);
+        if (depthHasStencil) {
+            st.pendingStencilTextures.remove(fbo.depthTexture);
+            if (stencilClear) st.clearedStencilTexturesThisFrame.add(fbo.depthTexture);
+        }
+    }
+
+    static long foldClearColor(long h, float r, float g, float b, float a) {
+        h = Hashing.fmix64(h, Float.floatToRawIntBits(r));
+        h = Hashing.fmix64(h, Float.floatToRawIntBits(g));
+        h = Hashing.fmix64(h, Float.floatToRawIntBits(b));
+        return Hashing.fmix64(h, Float.floatToRawIntBits(a));
+    }
+
+    static long foldClearDepth(long h, float depth) {
+        return Hashing.fmix64(h, Float.floatToRawIntBits(depth));
+    }
+
+    static long foldClearStencil(long h, int stencil) {
+        return Hashing.fmix64(h, stencil);
+    }
+
    private static final int RING_BLOCK_BYTES = ContextState.MAX_VERTEX_ATTRIBS * 16;
    private static final int RING_CHUNK_BYTES = ResourceManager.ATTRIB_RING_CHUNK_BLOCKS * RING_BLOCK_BYTES;

@@ -86,6 +86,17 @@ public final class PipelineCache {
    public int stencilCompareMask = 0xFF;
    public int stencilWriteMask = 0xFF;

+    private static final LongOpenHashSet loggedStencilMaskLost = new LongOpenHashSet();
+
+    private void warnOnceOnStencilMaskLost() {
+        if (!stencilTestEnabled || effectiveStencilTestEnabled()) return;
+        if (stencilFrontCompareOp == SDL_GPU_COMPAREOP_ALWAYS && stencilBackCompareOp == SDL_GPU_COMPAREOP_ALWAYS && stencilFrontPassOp == SDL_GPU_STENCILOP_KEEP && stencilBackPassOp == SDL_GPU_STENCILOP_KEEP)
+            return;
+        if (!loggedStencilMaskLost.add(Hashing.packHiLo(programId, debugFboId))) return;
+        LOG.warn("Stencil mask dropped: bound target has no stencil aspect. fbo={} depthFormat={} program={} frontCmp={} frontPass={} writeMask=0x{}",
+            debugFboId, textureFormatName(depthTargetFormat), programId, stencilFrontCompareOp, stencilFrontPassOp, Integer.toHexString(stencilWriteMask));
+    }
+
    public boolean cullEnabled = false;
    public int cullFaceMode = SDL_GPU_CULLMODE_BACK;
    public int frontFace = SDL_GPU_FRONTFACE_COUNTER_CLOCKWISE;
@@ -141,6 +152,14 @@ public final class PipelineCache {
        this.drawBuffers = drawBuffers;
    }

+    public boolean setDepthTargetFormat(int sdlFormat) {
+        if (depthTargetFormat == sdlFormat && hasDepthTarget == (sdlFormat != 0)) return false;
+        hasDepthTarget = sdlFormat != 0;
+        depthTargetFormat = sdlFormat;
+        markOutputDirty();
+        return true;
+    }
+
    private int attachmentForSlot(int slot) {
        final int[] db = drawBuffers;
        if (db == null || slot < 0 || slot >= db.length) return 0;
@@ -340,7 +359,7 @@ public final class PipelineCache {
    private void warnOnceOnUnconsumedFragOutput(int numColorTargets) {
        if (maxFragOutputLocation < numColorTargets) return;
        if (!loggedUnconsumedFragOutput.add(Hashing.packHiLo(programId, numColorTargets))) return;
-        LOG.warn("[PipelineCache] program {} declares fragment output location {} but framebuffer {} ({} colour attachment(s)) has {} draw buffer(s) {}; writes past location {} are discarded", programId, maxFragOutputLocation, debugFboId, debugFboAttachments, numColorTargets, Arrays.toString(drawBuffers), numColorTargets - 1);
+        LOG.warn("[PipelineCache] program {} declares fragment output location {} but framebuffer {} ({} color attachment(s)) has {} draw buffer(s) {}; writes past location {} are discarded", programId, maxFragOutputLocation, debugFboId, debugFboAttachments, numColorTargets, Arrays.toString(drawBuffers), numColorTargets - 1);
    }

    private long createPipeline(PipelineStore store, ContextState cs) {
@@ -360,6 +379,7 @@ public final class PipelineCache {
        try (var stack = stackPush()) {
            final int numColorTargets = colorTargetFormats().length;
            warnOnceOnUnconsumedFragOutput(numColorTargets);
+            warnOnceOnStencilMaskLost();
            final SDL_GPUColorTargetDescription.Buffer colorDesc = SDL_GPUColorTargetDescription.calloc(numColorTargets, stack);
            for (int i = 0; i < numColorTargets; i++) {
                final var desc = colorDesc.get(i);
@@ -49,8 +49,19 @@ public final class FBOClearTracker {
        st.clearedTexturesThisFrame.remove(tex);
    }

+    public static void recordPendingStencilClear(ContextState st, long tex, int value) {
+        st.pendingStencilValues.put(tex, value);
+        if (st.pendingStencilTextures.add(tex)) {
+            st.pendingMutationGen++;
+        }
+        st.clearedStencilTexturesThisFrame.remove(tex);
+    }
+
    public static boolean fboHasPendingClear(ContextState st, FboState fbo) {
-        if (fbo.depthTexture != 0 && st.pendingDepthTextures.contains(fbo.depthTexture)) return true;
+        if (fbo.depthTexture != 0
+            && (st.pendingDepthTextures.contains(fbo.depthTexture) || st.pendingStencilTextures.contains(fbo.depthTexture))) {
+            return true;
+        }
        if (st.pendingColorTextures.isEmpty()) return false;
        for (int db : fbo.drawBuffers) {
            if (db < 0 || db >= ContextState.MAX_COLOR_ATTACHMENTS) continue;
@@ -67,7 +78,7 @@ public final class FBOClearTracker {
    }

    public void flushPendingClearsForBoundSamplers(ContextState st) {
-        if (st.pendingColorTextures.isEmpty() && st.pendingDepthTextures.isEmpty()) return;
+        if (st.pendingColorTextures.isEmpty() && st.pendingDepthTextures.isEmpty() && st.pendingStencilTextures.isEmpty()) return;

        if (st.lastFlushedSamplerBindGen == st.samplerBindGen && st.lastFlushedProgram == st.boundProgram && st.lastFlushedPendingMutationGen == st.pendingMutationGen) {
            return;
@@ -115,7 +126,7 @@ public final class FBOClearTracker {
            if (st.pendingColorTextures.remove(handle)) {
                colorHandles.add(handle);
                colorGlIds.add(glTexId);
-            } else if (st.pendingDepthTextures.remove(handle)) {
+            } else if (st.pendingDepthTextures.contains(handle) || st.pendingStencilTextures.contains(handle)) {
                depthHandles.add(handle);
                depthGlIds.add(glTexId);
            }
@@ -169,6 +180,7 @@ public final class FBOClearTracker {
                    MemoryAccess.putFloat(ccAddr + SDL_FColor.B, color[2]);
                    MemoryAccess.putFloat(ccAddr + SDL_FColor.A, color[3]);
                    st.clearedTexturesThisFrame.add(handle);
+                    resourceManager.markTextureContentDefined(handle);
                    consumed[idx] = true;
                }
                frameManager.noteClearPass();
@@ -180,19 +192,38 @@ public final class FBOClearTracker {
        final int dn = depthHandles.size();
        for (int i = 0; i < dn; i++) {
            final long handle = depthHandles.getLong(i);
-            final float val = st.pendingDepthValues.get(handle);
-            try (var stack = MemoryStack.stackPush()) {
-                final SDL_GPUDepthStencilTargetInfo dt = SDL_GPUDepthStencilTargetInfo.calloc(stack);
-                final long addr = dt.address();
-                MemoryAccess.putAddress(addr + SDL_GPUDepthStencilTargetInfo.TEXTURE, handle);
-                MemoryAccess.putInt(addr + SDL_GPUDepthStencilTargetInfo.LOAD_OP, SDL_GPU_LOADOP_CLEAR);
-                MemoryAccess.putInt(addr + SDL_GPUDepthStencilTargetInfo.STORE_OP, SDL_GPU_STOREOP_STORE);
-                MemoryAccess.putFloat(addr + SDL_GPUDepthStencilTargetInfo.CLEAR_DEPTH, val);
-                frameManager.noteClearPass();
-                frameManager.beginRenderPass(null, dt);
-                frameManager.endRenderPassIfActive();
-                st.clearedTexturesThisFrame.add(handle);
+            emitDepthStencilClearPass(st, handle, st.pendingDepthTextures.remove(handle), st.pendingStencilTextures.remove(handle), false);
+        }
+    }
+
+    private void emitDepthStencilClearPass(ContextState st, long handle, boolean clearDepth, boolean clearStencil, boolean materialized) {
+        if (!clearDepth && !clearStencil) return;
+        try (var stack = MemoryStack.stackPush()) {
+            final SDL_GPUDepthStencilTargetInfo dt = SDL_GPUDepthStencilTargetInfo.calloc(stack);
+            final long addr = dt.address();
+            MemoryAccess.putAddress(addr + SDL_GPUDepthStencilTargetInfo.TEXTURE, handle);
+            MemoryAccess.putInt(addr + SDL_GPUDepthStencilTargetInfo.LOAD_OP, clearDepth ? SDL_GPU_LOADOP_CLEAR : SDL_GPU_LOADOP_LOAD);
+            MemoryAccess.putInt(addr + SDL_GPUDepthStencilTargetInfo.STORE_OP, SDL_GPU_STOREOP_STORE);
+            if (clearDepth) {
+                MemoryAccess.putFloat(addr + SDL_GPUDepthStencilTargetInfo.CLEAR_DEPTH, st.pendingDepthValues.get(handle));
            }
+            if (clearStencil) {
+                MemoryAccess.putInt(addr + SDL_GPUDepthStencilTargetInfo.STENCIL_LOAD_OP, SDL_GPU_LOADOP_CLEAR);
+                MemoryAccess.putInt(addr + SDL_GPUDepthStencilTargetInfo.STENCIL_STORE_OP, SDL_GPU_STOREOP_STORE);
+                MemoryAccess.putByte(addr + SDL_GPUDepthStencilTargetInfo.CLEAR_STENCIL, (byte) st.pendingStencilValues.get(handle));
+            }
+            frameManager.noteClearPass();
+            if (materialized) frameManager.noteMaterializedClearPass();
+            frameManager.beginRenderPass(null, dt);
+            frameManager.endRenderPassIfActive();
+        }
+        if (clearDepth) {
+            st.pendingDepthValues.remove(handle);
+            st.clearedTexturesThisFrame.add(handle);
+        }
+        if (clearStencil) {
+            st.pendingStencilValues.remove(handle);
+            st.clearedStencilTexturesThisFrame.add(handle);
        }
    }

@@ -206,28 +237,18 @@ public final class FBOClearTracker {
        if (depth) st.pendingDepthValues.remove(handle);
        else st.pendingColorValues.remove(handle);
        st.clearedTexturesThisFrame.add(handle);
+        resourceManager.markTextureContentDefined(handle);
        st.pendingMutationGen++;
        return true;
    }

    public void materializePendingClearForTexture(ContextState st, long handle) {
        if (handle == 0) return;
-        if (st.pendingDepthTextures.remove(handle)) {
-            final float val = st.pendingDepthValues.remove(handle);
+        final boolean depthPending = st.pendingDepthTextures.remove(handle);
+        final boolean stencilPending = st.pendingStencilTextures.remove(handle);
+        if (depthPending || stencilPending) {
            frameManager.endRenderPassIfActive();
-            try (var stack = MemoryStack.stackPush()) {
-                final SDL_GPUDepthStencilTargetInfo dt = SDL_GPUDepthStencilTargetInfo.calloc(stack);
-                final long addr = dt.address();
-                MemoryAccess.putAddress(addr + SDL_GPUDepthStencilTargetInfo.TEXTURE, handle);
-                MemoryAccess.putInt(addr + SDL_GPUDepthStencilTargetInfo.LOAD_OP, SDL_GPU_LOADOP_CLEAR);
-                MemoryAccess.putInt(addr + SDL_GPUDepthStencilTargetInfo.STORE_OP, SDL_GPU_STOREOP_STORE);
-                MemoryAccess.putFloat(addr + SDL_GPUDepthStencilTargetInfo.CLEAR_DEPTH, val);
-                frameManager.noteClearPass();
-                frameManager.noteMaterializedClearPass();
-                frameManager.beginRenderPass(null, dt);
-                frameManager.endRenderPassIfActive();
-                st.clearedTexturesThisFrame.add(handle);
-            }
+            emitDepthStencilClearPass(st, handle, depthPending, stencilPending, true);
            st.pendingMutationGen++;
            return;
        }
@@ -250,6 +271,7 @@ public final class FBOClearTracker {
                frameManager.beginRenderPass(targets, null);
                frameManager.endRenderPassIfActive();
                st.clearedTexturesThisFrame.add(handle);
+                resourceManager.markTextureContentDefined(handle);
            }
            st.pendingMutationGen++;
        }
@@ -262,7 +284,10 @@ public final class FBOClearTracker {
        st.pendingColorValues.remove(handle);
        st.pendingDepthTextures.remove(handle);
        st.pendingDepthValues.remove(handle);
+        st.pendingStencilTextures.remove(handle);
+        st.pendingStencilValues.remove(handle);
        st.clearedTexturesThisFrame.remove(handle);
+        st.clearedStencilTexturesThisFrame.remove(handle);
    }

    public boolean fbosHaveSameAttachments(ContextState st, int a, int b) {
@@ -35,6 +35,7 @@ public final class FboState {
    public int cachedTargetsCount = -1;
    public int cachedClearOpFlags;
    public boolean cachedDepthClearLast;
+    public boolean cachedStencilClearLast;
    public boolean cachedTargetsValid;

    public long getColorTexture() { return colorTextures[0]; }
@@ -63,7 +64,7 @@ public final class FboState {
            h = Hashing.fmix64(h, db);
        }
        h = Hashing.fmix64(h, depthTexture);
-        if (h == 0L || h == FrameManager.SWAPCHAIN_LAYOUT_HASH) h = 0xD1CE5EEDL;
+        if (h == 0L || h == FrameManager.FBO0_LAYOUT_HASH) h = 0xD1CE5EEDL;
        structuralLayoutHash = h;
    }

@@ -34,6 +34,85 @@ public final class PixelOps {
        return sdlFormat == SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT || sdlFormat == SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
    }

+    public static int depthBits(int sdlFormat) {
+        return switch (sdlFormat) {
+            case SDL_GPU_TEXTUREFORMAT_D16_UNORM -> 16;
+            case SDL_GPU_TEXTUREFORMAT_D24_UNORM, SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT -> 24;
+            case SDL_GPU_TEXTUREFORMAT_D32_FLOAT, SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT -> 32;
+            default -> 0;
+        };
+    }
+
+    public static int stencilBits(int sdlFormat) {
+        return isDepthStencilFormat(sdlFormat) ? 8 : 0;
+    }
+
+    public static int colorChannelBits(int sdlFormat, int channel) {
+        if (channel < 0 || channel > 3) return 0;
+        return switch (sdlFormat) {
+            case SDL_GPU_TEXTUREFORMAT_A8_UNORM -> channel == 3 ? 8 : 0;
+            case SDL_GPU_TEXTUREFORMAT_R10G10B10A2_UNORM -> channel == 3 ? 2 : 10;
+            case SDL_GPU_TEXTUREFORMAT_R11G11B10_UFLOAT -> switch (channel) {
+                case 0, 1 -> 11;
+                case 2 -> 10;
+                default -> 0;
+            };
+            case SDL_GPU_TEXTUREFORMAT_B5G6R5_UNORM -> switch (channel) {
+                case 0, 2 -> 5;
+                case 1 -> 6;
+                default -> 0;
+            };
+            case SDL_GPU_TEXTUREFORMAT_B5G5R5A1_UNORM -> channel == 3 ? 1 : 5;
+            case SDL_GPU_TEXTUREFORMAT_B4G4R4A4_UNORM -> 4;
+            default -> channel < sdlFormatColorComponents(sdlFormat) ? uniformChannelBits(sdlFormat) : 0;
+        };
+    }
+
+    private static int uniformChannelBits(int sdlFormat) {
+        return switch (sdlFormat) {
+            case SDL_GPU_TEXTUREFORMAT_R8_UNORM, SDL_GPU_TEXTUREFORMAT_R8_SNORM,
+                 SDL_GPU_TEXTUREFORMAT_R8_UINT, SDL_GPU_TEXTUREFORMAT_R8_INT,
+                 SDL_GPU_TEXTUREFORMAT_R8G8_UNORM, SDL_GPU_TEXTUREFORMAT_R8G8_SNORM,
+                 SDL_GPU_TEXTUREFORMAT_R8G8_UINT, SDL_GPU_TEXTUREFORMAT_R8G8_INT,
+                 SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM, SDL_GPU_TEXTUREFORMAT_R8G8B8A8_SNORM,
+                 SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM_SRGB, SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UINT,
+                 SDL_GPU_TEXTUREFORMAT_R8G8B8A8_INT, SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM,
+                 SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM_SRGB -> 8;
+            case SDL_GPU_TEXTUREFORMAT_R16_UNORM, SDL_GPU_TEXTUREFORMAT_R16_SNORM,
+                 SDL_GPU_TEXTUREFORMAT_R16_FLOAT, SDL_GPU_TEXTUREFORMAT_R16_UINT,
+                 SDL_GPU_TEXTUREFORMAT_R16_INT, SDL_GPU_TEXTUREFORMAT_R16G16_UNORM,
+                 SDL_GPU_TEXTUREFORMAT_R16G16_SNORM, SDL_GPU_TEXTUREFORMAT_R16G16_FLOAT,
+                 SDL_GPU_TEXTUREFORMAT_R16G16_UINT, SDL_GPU_TEXTUREFORMAT_R16G16_INT,
+                 SDL_GPU_TEXTUREFORMAT_R16G16B16A16_UNORM, SDL_GPU_TEXTUREFORMAT_R16G16B16A16_SNORM,
+                 SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT, SDL_GPU_TEXTUREFORMAT_R16G16B16A16_UINT,
+                 SDL_GPU_TEXTUREFORMAT_R16G16B16A16_INT -> 16;
+            case SDL_GPU_TEXTUREFORMAT_R32_FLOAT, SDL_GPU_TEXTUREFORMAT_R32_UINT,
+                 SDL_GPU_TEXTUREFORMAT_R32_INT, SDL_GPU_TEXTUREFORMAT_R32G32_FLOAT,
+                 SDL_GPU_TEXTUREFORMAT_R32G32_UINT, SDL_GPU_TEXTUREFORMAT_R32G32_INT,
+                 SDL_GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT, SDL_GPU_TEXTUREFORMAT_R32G32B32A32_UINT,
+                 SDL_GPU_TEXTUREFORMAT_R32G32B32A32_INT -> 32;
+            default -> 0;
+        };
+    }
+
+    private static int sdlFormatColorComponents(int sdlFormat) {
+        return switch (sdlFormat) {
+            case SDL_GPU_TEXTUREFORMAT_R8_UNORM, SDL_GPU_TEXTUREFORMAT_R8_SNORM,
+                 SDL_GPU_TEXTUREFORMAT_R8_UINT, SDL_GPU_TEXTUREFORMAT_R8_INT,
+                 SDL_GPU_TEXTUREFORMAT_R16_UNORM, SDL_GPU_TEXTUREFORMAT_R16_SNORM,
+                 SDL_GPU_TEXTUREFORMAT_R16_FLOAT, SDL_GPU_TEXTUREFORMAT_R16_UINT,
+                 SDL_GPU_TEXTUREFORMAT_R16_INT, SDL_GPU_TEXTUREFORMAT_R32_FLOAT,
+                 SDL_GPU_TEXTUREFORMAT_R32_UINT, SDL_GPU_TEXTUREFORMAT_R32_INT -> 1;
+            case SDL_GPU_TEXTUREFORMAT_R8G8_UNORM, SDL_GPU_TEXTUREFORMAT_R8G8_SNORM,
+                 SDL_GPU_TEXTUREFORMAT_R8G8_UINT, SDL_GPU_TEXTUREFORMAT_R8G8_INT,
+                 SDL_GPU_TEXTUREFORMAT_R16G16_UNORM, SDL_GPU_TEXTUREFORMAT_R16G16_SNORM,
+                 SDL_GPU_TEXTUREFORMAT_R16G16_FLOAT, SDL_GPU_TEXTUREFORMAT_R16G16_UINT,
+                 SDL_GPU_TEXTUREFORMAT_R16G16_INT, SDL_GPU_TEXTUREFORMAT_R32G32_FLOAT,
+                 SDL_GPU_TEXTUREFORMAT_R32G32_UINT, SDL_GPU_TEXTUREFORMAT_R32G32_INT -> 2;
+            default -> 4;
+        };
+    }
+
    public static int glPixelSize(int format, int type) {
        final int packed = GLTypes.packedTexelBytes(type);
        if (packed != 0) return packed;
@@ -127,6 +127,10 @@ public final class ResourceManager {

    private int preferredD24 = SDL_GPU_TEXTUREFORMAT_D24_UNORM;
    private int preferredD24S8 = SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT;
+    private volatile int swapchainDepthStencilFormat = SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT;
+    private long swapchainDepthStencil;
+    private int swapchainDepthStencilWidth;
+    private int swapchainDepthStencilHeight;

    private static final Supplier<ContextState.VAOState> VAO_FACTORY = ContextState.VAOState::new;
    private static final Supplier<TextureSamplerState> TEX_SAMPLER_FACTORY = TextureSamplerState::new;
@@ -154,6 +158,21 @@ public final class ResourceManager {
            preferredD24S8 = SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
            LOG.info("D24_UNORM_S8_UINT not supported for depth+sampler, using D32_FLOAT_S8_UINT");
        }
+
+        swapchainDepthStencilFormat = preferredD24S8;
+        if (!SDL_GPUTextureSupportsFormat(dev, swapchainDepthStencilFormat, texType, SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET)) {
+            final int alt = swapchainDepthStencilFormat == SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT ? SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT : SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT;
+            if (SDL_GPUTextureSupportsFormat(dev, alt, texType, SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET)) {
+                swapchainDepthStencilFormat = alt;
+            } else {
+                swapchainDepthStencilFormat = 0;
+                LOG.warn("No depth+stencil format usable as a render target; default framebuffer will have no depth or stencil");
+            }
+        }
+    }
+
+    public int getSwapchainDepthStencilFormat() {
+        return swapchainDepthStencilFormat;
    }

    public int genTexture() {
@@ -292,7 +311,7 @@ public final class ResourceManager {
        } finally {
            wLock.unlock();
        }
-        releaseTextureHandle(handle);
+        releaseTextureHandleAfterPendingUploads(handle);
    }

    public void releaseTextureHandleForRealloc(int glId) {
@@ -304,9 +323,24 @@ public final class ResourceManager {
        } finally {
            wLock.unlock();
        }
+        releaseTextureHandleAfterPendingUploads(handle);
+    }
+
+    private void releaseTextureHandleAfterPendingUploads(long handle) {
+        if (handle == 0) return;
+        if (shouldDeferTextureRelease()) {
+            releaseTextureDeferred(handle);
+            return;
+        }
        releaseTextureHandle(handle);
    }

+    boolean shouldDeferTextureRelease() {
+        final TransferThread tt = transferThread;
+        if (tt != null && tt.getSubmittedSeq() < lastTextureUploadSeq) return true;
+        return hasBatchedUploads();
+    }
+
    public void trackBufferHandle(long handle) {
        if (handle == 0) return;
        wLock.lock();
@@ -319,6 +353,40 @@ public final class ResourceManager {
        try { liveTextureHandles.add(handle); } finally { wLock.unlock(); }
    }

+    private final LongOpenHashSet definedContentTextures = new LongOpenHashSet();
+
+    public boolean isTextureContentDefined(long handle) {
+        if (handle == 0) return false;
+        if (fastRead()) return definedContentTextures.contains(handle);
+        rLock.lock();
+        try { return definedContentTextures.contains(handle); } finally { rLock.unlock(); }
+    }
+
+    public void markTextureContentDefined(long handle) {
+        if (handle == 0) return;
+        wLock.lock();
+        try { definedContentTextures.add(handle); } finally { wLock.unlock(); }
+    }
+
+    void markTextureContentsDefined(LongArrayList handles) {
+        if (handles.isEmpty()) return;
+        wLock.lock();
+        try {
+            for (int i = 0, n = handles.size(); i < n; i++) {
+                final long handle = handles.getLong(i);
+                if (handle != 0) definedContentTextures.add(handle);
+            }
+        } finally {
+            wLock.unlock();
+        }
+    }
+
+    public void markTextureContentUndefined(long handle) {
+        if (handle == 0) return;
+        wLock.lock();
+        try { definedContentTextures.remove(handle); } finally { wLock.unlock(); }
+    }
+
    public void releaseBufferHandle(long handle) {
        if (handle == 0) return;
        final boolean live;
@@ -338,6 +406,8 @@ public final class ResourceManager {

    public void releaseTextureHandle(long handle) {
        if (handle == 0) return;
+        dropBatchedUploadsTargeting(handle);
+        markTextureContentUndefined(handle);
        final boolean live;
        wLock.lock();
        try {
@@ -517,7 +587,7 @@ public final class ResourceManager {
        final GpuBucket b = gpuBufferPool.get(Hashing.packHiLo(usage, bucket));
        if (b == null || b.handles.isEmpty()) return 0;
        for (int i = 0, n = b.handles.size(); i < n; i++) {
-            if (gpuPoolCurrentFrame - b.frames.getLong(i) >= Device.FRAMES_IN_FLIGHT) {
+            if (gpuPoolCurrentFrame - b.frames.getLong(i) >= Device.MAX_FRAMES_IN_FLIGHT) {
                final long handle = b.handles.getLong(i);
                final int last = n - 1;
                if (i != last) {
@@ -620,6 +690,7 @@ public final class ResourceManager {

    private final LongArrayList deferredBufferReleases = new LongArrayList();
    private final LongArrayList deferredTextureReleases = new LongArrayList();
+    private volatile long lastTextureUploadSeq;

    public void deleteBuffer(int glId) {
        final ByteBuffer droppedPboStaging;
@@ -1305,7 +1376,7 @@ public final class ResourceManager {
            for (int i = 0; i < n; i += 2) {
                final long handle = batchSegmentPending.getLong(i);
                final long stamp = batchSegmentPending.getLong(i + 1);
-                if (currentFrame - stamp >= Device.FRAMES_IN_FLIGHT) {
+                if (currentFrame - stamp >= Device.MAX_FRAMES_IN_FLIGHT) {
                    batchSegmentFree.enqueue(handle);
                } else {
                    batchSegmentPending.set(w, handle);
@@ -1560,12 +1631,16 @@ public final class ResourceManager {
            f.batchMapped = null;
        }

+        markTextureContentsDefined(f.pendingTexHandles);
+
        try (var stack = stackPush()) {
            final SDL_GPUTextureTransferInfo src = SDL_GPUTextureTransferInfo.calloc(stack);
            final SDL_GPUTextureRegion dst = SDL_GPUTextureRegion.calloc(stack);
            for (int i = 0; i < n; i++) {
+                final long texture = f.pendingTexHandles.getLong(i);
+                if (texture == 0) continue;
                src.transfer_buffer(f.batchXfer).offset(f.pendingTexOffsets.getInt(i));
-                dst.texture(f.pendingTexHandles.getLong(i)).mip_level(f.pendingTexLevels.getInt(i))
+                dst.texture(texture).mip_level(f.pendingTexLevels.getInt(i))
                    .x(f.pendingTexX.getInt(i)).y(f.pendingTexY.getInt(i)).z(0)
                    .w(f.pendingTexW.getInt(i)).h(f.pendingTexH.getInt(i)).d(1);
                SDL_UploadToGPUTexture(copyPass, src, dst, false);
@@ -1586,6 +1661,14 @@ public final class ResourceManager {
        frameManager.recordUploadCommands(totalBytes, n);
    }

+    void dropBatchedUploadsTargeting(long handle) {
+        final LongArrayList handles = frameManager.frame().pendingTexHandles;
+        if (handles.isEmpty()) return;
+        for (int i = 0, n = handles.size(); i < n; i++) {
+            if (handles.getLong(i) == handle) handles.set(i, 0L);
+        }
+    }
+
    public boolean hasBatchedUploads() {
        return !frameManager.frame().pendingTexHandles.isEmpty();
    }
@@ -1616,6 +1699,7 @@ public final class ResourceManager {
                .w(w).h(h).d(d);
            SDL_UploadToGPUTexture(copyPass, src, dst, false);
        }
+        markTextureContentDefined(gpuTexture);

        frameManager.recordUploadCommands(size, 1);
        returnTransferBuffer(xfer, size);
@@ -1649,6 +1733,7 @@ public final class ResourceManager {

            SDL_UploadToGPUTexture(copyPass, src, dst, false);
        }
+        markTextureContentDefined(gpuTexture);

        frameManager.recordUploadCommands(size, 1);
        returnTransferBuffer(xfer, size);
@@ -1670,6 +1755,8 @@ public final class ResourceManager {
        SDL_UnmapGPUTransferBuffer(device.getDevice(), xfer);
        final long seq = TransferThread.nextSeq();
        st.frameHighestEnqueuedSeq = seq;
+        lastTextureUploadSeq = seq;
+        markTextureContentDefined(texHandle);
        tt.enqueue(TransferThread.TextureRegionUpload.acquire(xfer, texHandle, x, y, w, h, level, size, seq));
        tt.wake();
        return true;
@@ -1999,8 +2086,36 @@ public final class ResourceManager {
        return dummyColorTarget;
    }

+    public long getOrCreateSwapchainDepthStencil(int width, int height) {
+        if (swapchainDepthStencilFormat == 0 || width <= 0 || height <= 0) return 0;
+        if (swapchainDepthStencil != 0 && swapchainDepthStencilWidth == width && swapchainDepthStencilHeight == height) {
+            return swapchainDepthStencil;
+        }
+        if (swapchainDepthStencil != 0) {
+            releaseTextureDeferred(swapchainDepthStencil);
+            swapchainDepthStencil = 0;
+        }
+        try (var stack = stackPush()) {
+            final SDL_GPUTextureCreateInfo ci = SDL_GPUTextureCreateInfo.calloc(stack)
+                .type(SDL_GPU_TEXTURETYPE_2D)
+                .format(swapchainDepthStencilFormat)
+                .usage(SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET)
+                .width(width).height(height).layer_count_or_depth(1).num_levels(1);
+            swapchainDepthStencil = SDL_CreateGPUTexture(device.getDevice(), ci);
+        }
+        if (swapchainDepthStencil == 0) {
+            swapchainDepthStencilFormat = 0;
+            LOG.warn("Failed to create the default framebuffer depth+stencil target ({}x{}); it will have neither", width, height);
+            return 0;
+        }
+        trackTextureHandle(swapchainDepthStencil);
+        swapchainDepthStencilWidth = width;
+        swapchainDepthStencilHeight = height;
+        return swapchainDepthStencil;
+    }
+
    private static final int DUMMY_VBO_SIZE = 16 * 16;
-    public static final int ATTRIB_RING_BLOCKS = 2048 * Device.FRAMES_IN_FLIGHT;
+    public static final int ATTRIB_RING_BLOCKS = 2048 * Device.MAX_FRAMES_IN_FLIGHT;
    public static final int ATTRIB_RING_CHUNK_BLOCKS = 64;
    private static final int ATTRIB_RING_CHUNKS = ATTRIB_RING_BLOCKS / ATTRIB_RING_CHUNK_BLOCKS;
    private final AtomicLong attribRingCounter = new AtomicLong();
@@ -2114,6 +2229,8 @@ public final class ResourceManager {
            case GL14.GL_DEPTH_COMPONENT32, GL30.GL_DEPTH_COMPONENT32F -> SDL_GPU_TEXTUREFORMAT_D32_FLOAT;
            case GL30.GL_DEPTH24_STENCIL8 -> preferredD24S8;
            case GL30.GL_DEPTH32F_STENCIL8 -> SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
+            case GL11.GL_STENCIL_INDEX, GL30.GL_STENCIL_INDEX1, GL30.GL_STENCIL_INDEX4,
+                 GL30.GL_STENCIL_INDEX8, GL30.GL_STENCIL_INDEX16 -> preferredD24S8;
            case GL30.GL_R8UI -> SDL_GPU_TEXTUREFORMAT_R8_UINT;
            case GL30.GL_R16UI -> SDL_GPU_TEXTUREFORMAT_R16_UINT;
            case GL30.GL_R32UI -> SDL_GPU_TEXTUREFORMAT_R32_UINT;
@@ -2233,6 +2350,12 @@ public final class ResourceManager {
            releaseTextureHandle(dummyColorTarget);
            dummyColorTarget = 0;
        }
+        if (swapchainDepthStencil != 0) {
+            releaseTextureHandle(swapchainDepthStencil);
+            swapchainDepthStencil = 0;
+            swapchainDepthStencilWidth = 0;
+            swapchainDepthStencilHeight = 0;
+        }
        if (fallbackStorageTexture3D != 0) {
            releaseTextureHandle(fallbackStorageTexture3D);
            fallbackStorageTexture3D = 0;
@@ -101,19 +101,11 @@ public final class TextureOps {

    public void readbackTexture(long texHandle, int x, int y, int w, int h, int level, ByteBuffer output) {
        if (texHandle == 0 || output == null) return;
-        frameManager.endCopyPassIfActive();
-        frameManager.endRenderPassIfActive();
+        frameManager.submitMidFrame();

-        if (texHandle == frameManager.getSwapchainTexture()) {
-            final long cb = frameManager.getCommandBuffer();
-            if (cb == 0) return;
-            resourceManager.downloadFromTexture(cb, texHandle, x, y, w, h, level, output);
-            frameManager.reacquireCommandBuffer();
-        } else {
-            final long cb = SDL_AcquireGPUCommandBuffer(device.getDevice());
-            if (cb == 0) return;
-            resourceManager.downloadFromTexture(cb, texHandle, x, y, w, h, level, output);
-        }
+        final long cb = SDL_AcquireGPUCommandBuffer(device.getDevice());
+        if (cb == 0) return;
+        resourceManager.downloadFromTexture(cb, texHandle, x, y, w, h, level, output);
    }

    public void copyTexSubImageImpl(ContextState st, int destGlId, int level, int xoffset, int yoffset, int x, int y, int width, int height) {
@@ -210,6 +202,7 @@ public final class TextureOps {
        if (!SDL_SubmitGPUCommandBuffer(uploadCb)) {
            device.reportGpuFailure("submit mipmap generation CB");
        }
+        frameManager.noteMipGenSubmit();

        if (f.commandBuffer == uploadCb) {
            f.commandBuffer = 0;
@@ -34,6 +34,7 @@ public final class TransferThread {
    private static final Tracy.ZoneId Z_SDL_UPLOAD = Tracy.zoneId("sdlUpload", Tracy.COLOR_WORKER);

    private static final Logger LOG = LogManager.getLogger("Angelica-SDLGPU-Transfer");
+    private boolean warnedNullTextureUpload;

    private static final AtomicLong SEQ = new AtomicLong();

@@ -214,6 +215,19 @@ public final class TransferThread {
        return flushRequestedSeq > submittedSeq || openBytes >= FLUSH_COALESCE_BYTES || openCount >= FLUSH_COALESCE_COMMANDS;
    }

+    static boolean shouldPublishRetired(boolean hasOpenCB, long openHighestSeq, long submittedSeq) {
+        return !hasOpenCB && openHighestSeq > submittedSeq;
+    }
+
+    private void publishSubmittedSeq() {
+        if (openHighestSeq <= submittedSeq) return;
+        synchronized (submittedLock) {
+            submittedSeq = openHighestSeq;
+            submittedLock.notifyAll();
+        }
+        drainDuePendingFrees();
+    }
+
    private void run() {
        LOG.info("Transfer thread started");
        try {
@@ -230,6 +244,9 @@ public final class TransferThread {

                if (shouldFlush(openCB != 0, flushRequestedSeq, submittedSeq, openBytes, openCount)) {
                    flushOpenCB();
+                } else if (shouldPublishRetired(openCB != 0, openHighestSeq, submittedSeq)) {
+                    publishSubmittedSeq();
+                    openHighestSeq = 0;
                }

                if (Tracy.ENABLED) pendingActiveNanos += System.nanoTime() - workStart;
@@ -315,10 +332,18 @@ public final class TransferThread {
        return true;
    }

+    private void retireSeq(long seq) {
+        openHighestSeq = Math.max(openHighestSeq, seq);
+    }
+
    private void recordBufferUpload(long transferBuffer, long size, long dstGpuBuffer, long dstOffset, long seq, boolean cycle) {
-        if (transferBuffer == 0) return;
+        if (transferBuffer == 0) {
+            retireSeq(seq);
+            return;
+        }
        if (!ensureOpenCB()) {
            resourceManager.returnTransferBufferThreadSafe(transferBuffer, size);
+            retireSeq(seq);
            return;
        }
        srcLoc.transfer_buffer(transferBuffer).offset(0);
@@ -333,7 +358,10 @@ public final class TransferThread {
    }

    private void recordGpuCopy(long srcHandle, long dstHandle, long readOffset, long writeOffset, long size, long seq) {
-        if (!ensureOpenCB()) return;
+        if (!ensureOpenCB()) {
+            retireSeq(seq);
+            return;
+        }
        srcBufLoc.buffer(srcHandle).offset((int) readOffset);
        dstBufLoc.buffer(dstHandle).offset((int) writeOffset);
        SDL_CopyGPUBufferToBuffer(openCopyPass, srcBufLoc, dstBufLoc, (int) size, false);
@@ -344,9 +372,22 @@ public final class TransferThread {
    }

    private void recordTextureUpload(long transferBuffer, long texHandle, int x, int y, int w, int h, int level, long size, long seq) {
-        if (transferBuffer == 0) return;
+        if (transferBuffer == 0) {
+            retireSeq(seq);
+            return;
+        }
+        if (texHandle == 0) {
+            if (!warnedNullTextureUpload) {
+                warnedNullTextureUpload = true;
+                LOG.warn("Deferred texture upload with no destination texture; dropped (level={} {}x{} at {},{})", level, w, h, x, y);
+            }
+            resourceManager.returnTransferBufferThreadSafe(transferBuffer, size);
+            retireSeq(seq);
+            return;
+        }
        if (!ensureOpenCB()) {
            resourceManager.returnTransferBufferThreadSafe(transferBuffer, size);
+            retireSeq(seq);
            return;
        }
        texXferInfo.transfer_buffer(transferBuffer).offset(0);
@@ -368,12 +409,7 @@ public final class TransferThread {
            device.reportGpuFailure("submit transfer command buffer");
        }

-        synchronized (submittedLock) {
-            submittedSeq = openHighestSeq;
-            submittedLock.notifyAll();
-        }
-
-        drainDuePendingFrees();
+        publishSubmittedSeq();

        for (int i = 0, n = pendingReturnHandles.size(); i < n; i++) {
            resourceManager.returnTransferBufferThreadSafe(pendingReturnHandles.getLong(i), pendingReturnSizes.getLong(i));
@@ -31,11 +31,6 @@ public final class PerFrameBlockInjector {
    private PerFrameBlockInjector() {}

    public static String inject(String source, PerFrameUniformBlock perFrame, PerFrameUniformBlock perPass) {
-        final PerFrameUniformBlock[] blocks = new PerFrameUniformBlock[ShaderManager.BLOCK_COUNT];
-        blocks[ShaderManager.BLOCK_PER_FRAME] = normalize(perFrame);
-        blocks[ShaderManager.BLOCK_PER_PASS] = normalize(perPass);
-        if (blocks[0] == null && blocks[1] == null) return source;
-
        final GLSLParser.Translation_unitContext root;
        try {
            root = GlslTransformUtils.parseFullQuiet(source);
@@ -43,8 +38,19 @@ public final class PerFrameBlockInjector {
            return source;
        }

+        final List<Edit> edits = new ArrayList<>();
+        collectEdits(root, perFrame, perPass, edits);
+        return edits.isEmpty() ? source : applyEdits(source, edits);
+    }
+
+    public static void collectEdits(GLSLParser.Translation_unitContext root, PerFrameUniformBlock perFrame, PerFrameUniformBlock perPass, List<Edit> out) {
+        final PerFrameUniformBlock[] blocks = new PerFrameUniformBlock[ShaderManager.BLOCK_COUNT];
+        blocks[ShaderManager.BLOCK_PER_FRAME] = normalize(perFrame);
+        blocks[ShaderManager.BLOCK_PER_PASS] = normalize(perPass);
+        if (blocks[0] == null && blocks[1] == null) return;
+
        final int insertAt = firstDeclarationStart(root);
-        if (insertAt < 0) return source;
+        if (insertAt < 0) return;

        final Map<String, String> memberTypes = new LinkedHashMap<>();
        final Object2IntOpenHashMap<String> memberBlock = new Object2IntOpenHashMap<>();
@@ -71,18 +77,16 @@ public final class PerFrameBlockInjector {
                if (referenced.contains(m.name())) { injected[b] = true; anyInjected = true; break; }
            }
        }
-        if (!anyInjected) return source;
+        if (!anyInjected) return;

-        final List<Edit> edits = new ArrayList<>(stripEdits.size() + 2);
        final StringBuilder blockDecls = new StringBuilder(128);
        for (int b = 0; b < blocks.length; b++) {
            if (injected[b]) appendBlockText(blockDecls, b, blocks[b].members(), shadowed);
        }
-        edits.add(new Edit(insertAt, insertAt - 1, blockDecls.toString()));
+        out.add(new Edit(insertAt, insertAt - 1, blockDecls.toString()));
        for (int i = 0; i < stripEdits.size(); i++) {
-            if (injected[stripBlocks.getInt(i)]) edits.add(stripEdits.get(i));
+            if (injected[stripBlocks.getInt(i)]) out.add(stripEdits.get(i));
        }
-        return applyEdits(source, edits);
    }

    private static PerFrameUniformBlock normalize(PerFrameUniformBlock block) {
@@ -188,19 +188,46 @@ public final class ShaderManager {
            return new PrewarmTransformResult(transformedSource, Set.of());
        }
        final List<Edit> edits = new ArrayList<>();
+        if (glShaderType == GL20.GL_VERTEX_SHADER || glShaderType == GL20.GL_FRAGMENT_SHADER) {
+            PerFrameBlockInjector.collectEdits(root, GLSMHooks.perFrameUniformBlock, GLSMHooks.perPassUniformBlock, edits);
+        }
        final GlslVulkanPreprocess.Metadata meta = GlslVulkanPreprocess.collectEdits(transformedSource, root, glShaderType, "prewarm", true, edits);
        if (glShaderType == GL20.GL_VERTEX_SHADER) {
            ClipZRemap.collectEdits(root, edits);
        }
        SamplerStripper.collectEdits(root, transformedSource, edits);
-        String s = edits.isEmpty() ? transformedSource : GlslVulkanPreprocess.applyEdits(transformedSource, edits);
-        if (glShaderType == GL20.GL_VERTEX_SHADER || glShaderType == GL20.GL_FRAGMENT_SHADER) {
-            s = PerFrameBlockInjector.inject(s, GLSMHooks.perFrameUniformBlock, GLSMHooks.perPassUniformBlock);
-        }
+        final String s = edits.isEmpty() ? transformedSource : GlslVulkanPreprocess.applyEdits(transformedSource, edits);
        return new PrewarmTransformResult(s, meta.boolUniforms());
    }

+    public static PrewarmTransformResult applyPrewarmTransformsFull(String finalSource, GLSLParser.Translation_unitContext bodyTree, int headerLen, int glShaderType) {
+        final String header = finalSource.substring(0, headerLen);
+        final String body = finalSource.substring(headerLen);
+        final List<Edit> edits = new ArrayList<>();
+        if (glShaderType == GL20.GL_VERTEX_SHADER || glShaderType == GL20.GL_FRAGMENT_SHADER) {
+            PerFrameBlockInjector.collectEdits(bodyTree, GLSMHooks.perFrameUniformBlock, GLSMHooks.perPassUniformBlock, edits);
+        }
+        final GlslVulkanPreprocess.Metadata meta = GlslVulkanPreprocess.collectEdits(null, bodyTree, glShaderType, "prewarm", true, edits);
+        if (glShaderType == GL20.GL_VERTEX_SHADER) {
+            ClipZRemap.collectEdits(bodyTree, edits);
+        }
+        SamplerStripper.collectEdits(bodyTree, body, edits);
+        String outHeader = header;
+        if (meta.needsSamplerless()) {
+            final int nl = header.indexOf('\n');
+            outHeader = header.substring(0, nl) + "\n" + GlslVulkanPreprocess.SAMPLERLESS_EXTENSION + header.substring(nl);
+        }
+        if (edits.isEmpty() && outHeader == header) {
+            return new PrewarmTransformResult(finalSource, meta.boolUniforms());
+        }
+        return new PrewarmTransformResult(outHeader + GlslVulkanPreprocess.applyEdits(body, edits), meta.boolUniforms());
+    }
+
    public static void prewarmSpirv(String transformedSource, int glShaderType) {
+        prewarmSpirv(transformedSource, null, 0, glShaderType);
+    }
+
+    public static void prewarmSpirv(String transformedSource, GLSLParser.Translation_unitContext bodyTree, int headerLen, int glShaderType) {
        if (glShaderType != GL20.GL_VERTEX_SHADER && glShaderType != GL20.GL_FRAGMENT_SHADER
            && glShaderType != GL43.GL_COMPUTE_SHADER && glShaderType != GL32.GL_GEOMETRY_SHADER) {
            return;
@@ -211,7 +238,9 @@ public final class ShaderManager {
            if (PREWARM_CACHE.containsKey(key)) return;
        }

-        final PrewarmTransformResult pre = applyPrewarmTransformsFull(transformedSource, glShaderType);
+        final PrewarmTransformResult pre = bodyTree != null
+            ? applyPrewarmTransformsFull(transformedSource, bodyTree, headerLen, glShaderType)
+            : applyPrewarmTransformsFull(transformedSource, glShaderType);

        final SpirvCompiler.Result r = SpirvCompiler.compile(pre.source(), shaderKindFor(glShaderType), "prewarm", SpirvCompiler.Options.vulkanForced460Core());
        if (r.spirv() == null) return;
@@ -652,7 +681,7 @@ public final class ShaderManager {
                return null;
            }
            LOG.info("Vertex attribute conversion: program {} converted {}", program, attribs);
-            if (SystemProperties.DUMP_SHADERS) dumpVariantSource(program, src);
+            if (SystemProperties.dumpShaders()) dumpVariantSource(program, src);
            return v;
        } finally {
            memFree(r.spirv());
@@ -2,6 +2,7 @@ package com.gtnewhorizons.angelica.sdlgpu.shader;

 import com.gtnewhorizons.angelica.glsm.GlslTransformUtils;
 import com.gtnewhorizons.angelica.glsm.shader.GlslVulkanPreprocess.Edit;
+import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
 import org.antlr.v4.runtime.Token;
 import org.antlr.v4.runtime.tree.ParseTreeWalker;
 import org.taumc.glsl.grammar.GLSLParser;
@@ -18,11 +19,29 @@ public final class UscaledRetype {

    public record Attrib(String name, int location, int declVecSize, int boundVecSize, boolean signed) {}

+    private record RetypeKey(String source, List<Attrib> attribs) {}
+
+    private static final int CACHE_MAX = 64;
+    private static final Object2ObjectLinkedOpenHashMap<RetypeKey, String> CACHE = new Object2ObjectLinkedOpenHashMap<>();
+
    private UscaledRetype() {}

    public static String retype(String source, List<Attrib> attribs) {
        if (attribs.isEmpty()) return source;

+        final RetypeKey key = new RetypeKey(source, List.copyOf(attribs));
+        synchronized (CACHE) {
+            if (CACHE.containsKey(key)) return CACHE.getAndMoveToFirst(key);
+        }
+        final String result = retypeUncached(source, attribs);
+        synchronized (CACHE) {
+            CACHE.putAndMoveToFirst(key, result);
+            while (CACHE.size() > CACHE_MAX) CACHE.removeLast();
+        }
+        return result;
+    }
+
+    private static String retypeUncached(String source, List<Attrib> attribs) {
        final GLSLParser.Translation_unitContext root;
        try {
            root = GlslTransformUtils.parseFullQuiet(source);
@@ -80,7 +80,7 @@ public final class DxbcCrossCompile {
            return new Output(copy, cached.entrypoint);
        }

-        final int dumpId = SystemProperties.DUMP_SHADERS ? CrossCompileUtil.SHADER_DUMP_COUNTER.getAndIncrement() : -1;
+        final int dumpId = SystemProperties.dumpShaders() ? CrossCompileUtil.SHADER_DUMP_COUNTER.getAndIncrement() : -1;
        if (dumpId >= 0) CrossCompileUtil.dumpSpirv(spirv, dumpId, glShaderType);

        final String hlsl = compileToHlsl(spirv, glShaderType);
@@ -87,7 +87,7 @@ public final class MslCrossCompile {
            return new Output(copy, cached.entrypoint);
        }

-        final int dumpId = SystemProperties.DUMP_SHADERS ? CrossCompileUtil.SHADER_DUMP_COUNTER.getAndIncrement() : -1;
+        final int dumpId = SystemProperties.dumpShaders() ? CrossCompileUtil.SHADER_DUMP_COUNTER.getAndIncrement() : -1;
        if (dumpId >= 0) CrossCompileUtil.dumpSpirv(spirv, dumpId, glShaderType);

        try (MemoryStack stack = stackPush()) {
@@ -1,6 +1,7 @@
 package com.gtnewhorizons.angelica.sdlgpu.splash;

 import com.gtnewhorizons.angelica.sdlgpu.SDLGPURenderBackend;
+import com.gtnewhorizons.angelica.sdlgpu.frame.OffscreenTarget;

 public final class SplashDispatcher {

@@ -32,10 +33,10 @@ public final class SplashDispatcher {
        return (long) w << 32 | (h & 0xffffffffL);
    }

-    public static void tryDispatch(SDLGPURenderBackend backend, SplashOffscreenTarget target) {
+    public static void tryDispatch(SDLGPURenderBackend backend, OffscreenTarget target, boolean force) {
        if (!frameReady || target == null) return;
        final long now = System.nanoTime();
-        if (now - lastBlitNanos < MIN_INTERVAL_NS) return;
+        if (!force && now - lastBlitNanos < MIN_INTERVAL_NS) return;
        lastBlitNanos = now;
        frameReady = false;
        backend.dispatchSplashBlit(target);
@@ -0,0 +1,67 @@
+package com.gtnewhorizons.angelica.sdlgpu.util;
+
+import java.util.Arrays;
+
+public final class ThreadRegistry<T> {
+
+    private final T[] empty;
+    private final Object lock = new Object();
+
+    private volatile T[] entries;
+    private volatile T sole;
+
+    public ThreadRegistry(T[] empty) {
+        this.empty = empty;
+        this.entries = empty;
+    }
+
+    public T sole() {
+        return sole;
+    }
+
+    public T[] snapshot() {
+        return entries;
+    }
+
+    public int size() {
+        return entries.length;
+    }
+
+    public void add(T entry) {
+        synchronized (lock) {
+            final T[] prev = entries;
+            final T[] next = Arrays.copyOf(prev, prev.length + 1);
+            next[prev.length] = entry;
+            publish(next);
+        }
+    }
+
+    public boolean remove(T entry) {
+        synchronized (lock) {
+            final T[] prev = entries;
+            int idx = -1;
+            for (int i = 0; i < prev.length; i++) {
+                if (prev[i] == entry) {
+                    idx = i;
+                    break;
+                }
+            }
+            if (idx < 0) return false;
+            final T[] next = Arrays.copyOf(prev, prev.length - 1);
+            System.arraycopy(prev, idx + 1, next, idx, prev.length - idx - 1);
+            publish(next);
+        }
+        return true;
+    }
+
+    public void clear() {
+        synchronized (lock) {
+            publish(empty);
+        }
+    }
+
+    private void publish(T[] next) {
+        entries = next;
+        sole = next.length == 1 ? next[0] : null;
+    }
+}
@@ -0,0 +1,92 @@
+package com.gtnewhorizons.angelica.sdlgpu;
+
+import com.gtnewhorizons.angelica.sdlgpu.resource.FboState;
+import org.junit.jupiter.api.Test;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL30;
+
+import static com.gtnewhorizons.angelica.sdlgpu.SDLGPURenderBackend.defaultFramebufferAttachmentParameteri;
+import static com.gtnewhorizons.angelica.sdlgpu.SDLGPURenderBackend.fboAttachmentParameteri;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_D24_UNORM;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+
+class FramebufferAttachmentQueryTest {
+
+    private static final int COLOR = SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM;
+
+    private static int defaultFb(int attachment, int pname, int depthFormat) {
+        return defaultFramebufferAttachmentParameteri(attachment, pname, COLOR, depthFormat);
+    }
+
+    @Test
+    void defaultFramebufferReportsEightStencilBits() {
+        assertEquals(8, defaultFb(GL11.GL_STENCIL, GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT));
+        assertEquals(8, defaultFb(GL11.GL_STENCIL, GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT));
+    }
+
+    @Test
+    void defaultFramebufferReportsDepthAndColorSizes() {
+        assertEquals(24, defaultFb(GL11.GL_DEPTH, GL30.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT));
+        assertEquals(32, defaultFb(GL11.GL_DEPTH, GL30.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT));
+        assertEquals(8, defaultFb(GL11.GL_BACK_LEFT, GL30.GL_FRAMEBUFFER_ATTACHMENT_RED_SIZE, SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT));
+        assertEquals(8, defaultFb(GL11.GL_BACK_LEFT, GL30.GL_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE, SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT));
+    }
+
+    @Test
+    void defaultFramebufferWithoutDepthReportsNone() {
+        assertEquals(0, defaultFb(GL11.GL_STENCIL, GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE, 0));
+        assertEquals(0, defaultFb(GL11.GL_DEPTH, GL30.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE, 0));
+        assertEquals(GL11.GL_NONE, defaultFb(GL11.GL_DEPTH, GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, 0));
+        assertEquals(GL30.GL_FRAMEBUFFER_DEFAULT, defaultFb(GL11.GL_BACK_LEFT, GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, 0));
+    }
+
+    @Test
+    void packedDepthStencilAttachmentReportsBothAspects() {
+        final FboState fbo = new FboState();
+        fbo.depthGlId = 42;
+        fbo.depthTexture = 0xDDDDL;
+        fbo.depthFormat = SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT;
+
+        for (int attachment : new int[]{ GL30.GL_DEPTH_ATTACHMENT, GL30.GL_STENCIL_ATTACHMENT, GL30.GL_DEPTH_STENCIL_ATTACHMENT, GL11.GL_STENCIL }) {
+            assertEquals(8, fboAttachmentParameteri(fbo, attachment, GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE), "attachment " + attachment);
+        }
+        assertEquals(24, fboAttachmentParameteri(fbo, GL30.GL_DEPTH_ATTACHMENT, GL30.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE));
+        assertEquals(42, fboAttachmentParameteri(fbo, GL30.GL_DEPTH_ATTACHMENT, GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME));
+        assertEquals(GL11.GL_TEXTURE, fboAttachmentParameteri(fbo, GL30.GL_DEPTH_ATTACHMENT, GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE));
+    }
+
+    @Test
+    void depthOnlyAttachmentReportsNoStencil() {
+        final FboState fbo = new FboState();
+        fbo.depthGlId = 7;
+        fbo.depthTexture = 0xDDDDL;
+        fbo.depthFormat = SDL_GPU_TEXTUREFORMAT_D24_UNORM;
+
+        assertEquals(0, fboAttachmentParameteri(fbo, GL11.GL_STENCIL, GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE));
+        assertEquals(24, fboAttachmentParameteri(fbo, GL11.GL_DEPTH, GL30.GL_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE));
+    }
+
+    @Test
+    void missingAttachmentReportsNone() {
+        final FboState fbo = new FboState();
+        assertEquals(GL11.GL_NONE, fboAttachmentParameteri(fbo, GL30.GL_DEPTH_ATTACHMENT, GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE));
+        assertEquals(0, fboAttachmentParameteri(fbo, GL30.GL_DEPTH_ATTACHMENT, GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE));
+        assertEquals(0, fboAttachmentParameteri(null, GL30.GL_DEPTH_ATTACHMENT, GL30.GL_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE));
+    }
+
+    @Test
+    void colorAttachmentReportsChannelSizes() {
+        final FboState fbo = new FboState();
+        fbo.colorGlIds[1] = 11;
+        fbo.colorTextures[1] = 0xCCCCL;
+        fbo.colorFormats[1] = SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+
+        assertEquals(8, fboAttachmentParameteri(fbo, GL30.GL_COLOR_ATTACHMENT0 + 1, GL30.GL_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE));
+        assertEquals(11, fboAttachmentParameteri(fbo, GL30.GL_COLOR_ATTACHMENT0 + 1, GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME));
+        assertEquals(GL11.GL_NONE, fboAttachmentParameteri(fbo, GL30.GL_COLOR_ATTACHMENT0, GL30.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE));
+    }
+}
@@ -7,7 +7,6 @@ import org.lwjgl.opengl.GL15;
 import org.lwjgl.opengl.GL30;
 import org.lwjgl.opengl.GL42;

-import java.lang.reflect.Field;

 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
@@ -15,17 +14,11 @@ import static org.junit.jupiter.api.Assertions.assertTrue;

 class ImageUnitBindingStateTest {

-    @SuppressWarnings("unchecked")
-    private static ContextState state() throws Exception {
-        final Field f = SDLGPURenderBackend.class.getDeclaredField("tlState");
-        f.setAccessible(true);
-        return ((ThreadLocal<ContextState>) f.get(null)).get();
-    }

    @Test
-    void bindImageTextureRecordsTheFullTuple() throws Exception {
+    void bindImageTextureRecordsTheFullTuple() {
        final SDLGPURenderBackend backend = new SDLGPURenderBackend();
-        final ContextState st = state();
+        final ContextState st = SdlTestRig.contextState();

        backend.bindImageTexture(2, 77, 3, true, 5, GL15.GL_READ_WRITE, GL30.GL_R32UI);

@@ -38,7 +31,7 @@ class ImageUnitBindingStateTest {
    }

    @Test
-    void getIntegerIndexedAnswersImageBindingsFromState() throws Exception {
+    void getIntegerIndexedAnswersImageBindingsFromState() {
        final SDLGPURenderBackend backend = new SDLGPURenderBackend();

        backend.bindImageTexture(1, 42, 2, false, 4, GL15.GL_READ_ONLY, GL30.GL_RGBA32UI);
@@ -52,9 +45,9 @@ class ImageUnitBindingStateTest {
    }

    @Test
-    void outOfRangeUnitIsIgnored() throws Exception {
+    void outOfRangeUnitIsIgnored() {
        final SDLGPURenderBackend backend = new SDLGPURenderBackend();
-        final ContextState st = state();
+        final ContextState st = SdlTestRig.contextState();

        backend.bindImageTexture(0, 11, 0, true, 0, GL15.GL_READ_ONLY, GL30.GL_R32UI);
        backend.bindImageTexture(ContextState.MAX_IMAGE_UNITS, 99, 0, true, 0, GL15.GL_READ_ONLY, GL30.GL_R32UI);
@@ -0,0 +1,17 @@
+package com.gtnewhorizons.angelica.sdlgpu;
+
+import com.mitchej123.lwjgl.LWJGLService;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+
+class SDLGPULWJGLServiceGatingTest {
+
+    @Test
+    void anUnengagedSdlDeclinesAndNeverArmsTheFallbackTripwire() {
+        assertFalse(SDLGPUGate.isEngaged(), "test JVM must not have an engaged SDL GPU device");
+        assertEquals(LWJGLService.PRIORITY_UNAVAILABLE, new SDLGPULWJGLService().getPriority());
+        assertFalse(SDLGPULWJGLService.isOfferedAsAvailable(), "declining must leave fallBackToGL() usable");
+    }
+}
@@ -1,6 +1,8 @@
 package com.gtnewhorizons.angelica.sdlgpu;

+import com.gtnewhorizons.angelica.glsm.testutil.Reflect;
 import com.gtnewhorizons.angelica.sdlgpu.device.Device;
+import com.gtnewhorizons.angelica.sdlgpu.frame.ContextState;
 import com.gtnewhorizons.angelica.sdlgpu.frame.FrameManager;
 import com.gtnewhorizons.angelica.sdlgpu.resource.ResourceManager;
 import org.lwjgl.sdl.SDLError;
@@ -57,6 +59,10 @@ public final class SdlTestRig {
        return create().frameManager;
    }

+    public static ContextState contextState() {
+        return Reflect.invokeStatic(SDLGPURenderBackend.class, "s", new Class<?>[0]);
+    }
+
    private static long realSdlDevice;

    private static final int SHADER_FORMATS = SDL_GPU_SHADERFORMAT_SPIRV | SDL_GPU_SHADERFORMAT_MSL | SDL_GPU_SHADERFORMAT_DXBC | SDL_GPU_SHADERFORMAT_DXIL;
@@ -48,13 +48,6 @@ class UniformNegativeLocationTest {
        st.releaseUniformStaging(prog);
    }

-    @SuppressWarnings("unchecked")
-    private static ContextState threadState() throws Exception {
-        final Field f = SDLGPURenderBackend.class.getDeclaredField("tlState");
-        f.setAccessible(true);
-        return ((ThreadLocal<ContextState>) f.get(null)).get();
-    }
-
    private static void clearApplier(SDLGPURenderBackend backend) throws Exception {
        final Field f = SDLGPURenderBackend.class.getDeclaredField("pipelineApplier");
        f.setAccessible(true);
@@ -66,7 +59,7 @@ class UniformNegativeLocationTest {
    void scalarAndVectorEntryPointsNeverReachTheApplier() throws Exception {
        final SDLGPURenderBackend backend = new SDLGPURenderBackend();
        clearApplier(backend);
-        threadState().boundProgramObj = null;
+        SdlTestRig.contextState().boundProgramObj = null;

        final IntBuffer iv = MemoryUtil.memAllocInt(4);
        try {
@@ -6,13 +6,13 @@ import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;

-import java.util.List;
+import com.gtnewhorizons.angelica.sdlgpu.util.ThreadRegistry;

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

 class ContextCounterAggregationTest {

-    private List<ContextState> registered;
+    private ThreadRegistry<ContextState> registered;
    private ContextState a;
    private ContextState b;

@@ -0,0 +1,113 @@
+package com.gtnewhorizons.angelica.sdlgpu.frame;
+
+import com.gtnewhorizons.angelica.sdlgpu.device.Device;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.concurrent.Executor;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.lwjgl.sdl.SDLSurface.SDL_FLIP_NONE;
+
+@Timeout(10)
+class PresenterTest {
+
+    private static final class DeferredExecutor implements Executor {
+        final Deque<Runnable> tasks = new ArrayDeque<>();
+
+        @Override
+        public void execute(Runnable command) {
+            tasks.add(command);
+        }
+
+        void runNext() {
+            tasks.removeFirst().run();
+        }
+    }
+
+    private static Presenter presenter(DeferredExecutor executor) {
+        return new Presenter(new FrameManager(new Device()), executor);
+    }
+
+    private static void awaitWaiting(Thread t) throws InterruptedException {
+        while (t.getState() != Thread.State.WAITING && t.getState() != Thread.State.TIMED_WAITING) {
+            assertTrue(t.isAlive(), "thread died instead of blocking");
+            Thread.onSpinWait();
+        }
+    }
+
+    @Test
+    void aSecondRequestBlocksUntilTheFirstPresentRuns() throws Exception {
+        final DeferredExecutor executor = new DeferredExecutor();
+        final Presenter p = presenter(executor);
+
+        p.requestPresent(1L, 10, 10, SDL_FLIP_NONE);
+        assertEquals(1, executor.tasks.size());
+
+        final Thread second = new Thread(() -> p.requestPresent(2L, 10, 10, SDL_FLIP_NONE));
+        second.start();
+        awaitWaiting(second);
+        assertEquals(1, executor.tasks.size(), "second present must not enqueue while the first is in flight");
+
+        executor.runNext();
+        second.join();
+        assertEquals(1, executor.tasks.size(), "second present enqueues only after the first released the slot");
+    }
+
+    @Test
+    void drainBlocksUntilThePendingPresentCompletes() throws Exception {
+        final DeferredExecutor executor = new DeferredExecutor();
+        final Presenter p = presenter(executor);
+
+        p.requestPresent(1L, 10, 10, SDL_FLIP_NONE);
+
+        final Thread drainer = new Thread(p::drain);
+        drainer.start();
+        awaitWaiting(drainer);
+
+        executor.runNext();
+        drainer.join();
+    }
+
+    @Test
+    void anInlineExecutorReleasesTheSlotImmediately() {
+        final Presenter p = new Presenter(new FrameManager(new Device()), Runnable::run);
+        p.requestPresent(1L, 10, 10, SDL_FLIP_NONE);
+        p.requestPresent(2L, 10, 10, SDL_FLIP_NONE);
+        p.drain();
+    }
+
+    @Test
+    void presentingDoesNotEnterTheFrameRegistry() throws Exception {
+        final DeferredExecutor executor = new DeferredExecutor();
+        final FrameManager fm = new FrameManager(new Device());
+        final Presenter p = new Presenter(fm, executor);
+        fm.frame();
+        final int before = fm.registeredFrameCount();
+
+        p.requestPresent(1L, 10, 10, SDL_FLIP_NONE);
+
+        final Thread windowThread = new Thread(executor::runNext, "window-thread");
+        windowThread.start();
+        windowThread.join();
+
+        assertEquals(before, fm.registeredFrameCount(), "the window thread must stay out of the frame registry");
+    }
+
+    @Test
+    void theSplashPresentGoesThroughTheWindowThreadToo() {
+        final DeferredExecutor executor = new DeferredExecutor();
+        final FrameManager fm = new FrameManager(new Device());
+        fm.setPresenter(new Presenter(fm, executor));
+        fm.frame();
+        final int before = fm.registeredFrameCount();
+
+        fm.presentSplash(1L, 10, 10);
+
+        assertEquals(1, executor.tasks.size(), "the splash blit must be enqueued on the window thread");
+        assertEquals(before, fm.registeredFrameCount(), "the splash present must not touch the calling thread's frame");
+    }
+}
@@ -0,0 +1,60 @@
+package com.gtnewhorizons.angelica.sdlgpu.frame;
+
+import org.junit.jupiter.api.Test;
+
+import static com.gtnewhorizons.angelica.sdlgpu.frame.FrameManager.swapchainClearNeedsPassBreak;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class SwapchainClearPassBreakTest {
+
+    private static FrameManager.FrameState activeFbo0Pass() {
+        final FrameManager.FrameState f = new FrameManager.FrameState();
+        f.renderPass = 0xBEEFL;
+        f.activeLayoutHash = FrameManager.FBO0_LAYOUT_HASH;
+        return f;
+    }
+
+    @Test
+    void aPendingColorClearBreaksTheActivePass() {
+        final ContextState st = new ContextState();
+        st.pendingSwapchainClear = true;
+        assertTrue(swapchainClearNeedsPassBreak(st, activeFbo0Pass()), "otherwise the clear is deferred to the next pass and wipes what this one drew");
+    }
+
+    @Test
+    void aPendingDepthOrStencilClearBreaksTheActivePass() {
+        final ContextState depth = new ContextState();
+        depth.pendingSwapchainDepthClear = true;
+        assertTrue(swapchainClearNeedsPassBreak(depth, activeFbo0Pass()));
+
+        final ContextState stencil = new ContextState();
+        stencil.pendingSwapchainStencilClear = true;
+        assertTrue(swapchainClearNeedsPassBreak(stencil, activeFbo0Pass()));
+    }
+
+    @Test
+    void nothingPendingLeavesThePassAlone() {
+        assertFalse(swapchainClearNeedsPassBreak(new ContextState(), activeFbo0Pass()));
+    }
+
+    @Test
+    void aClearWithNoActivePassNeedsNoBreak() {
+        final ContextState st = new ContextState();
+        st.pendingSwapchainClear = true;
+
+        final FrameManager.FrameState f = activeFbo0Pass();
+        f.renderPass = 0;
+        assertFalse(swapchainClearNeedsPassBreak(st, f));
+    }
+
+    @Test
+    void aPassBoundToAnFboIsNotTheFbo0Pass() {
+        final ContextState st = new ContextState();
+        st.pendingSwapchainClear = true;
+
+        final FrameManager.FrameState f = activeFbo0Pass();
+        f.activeLayoutHash = 0xF80L;
+        assertFalse(swapchainClearNeedsPassBreak(st, f));
+    }
+}
@@ -0,0 +1,112 @@
+package com.gtnewhorizons.angelica.sdlgpu.pipeline;
+
+import com.gtnewhorizons.angelica.sdlgpu.SdlTestRig;
+import com.gtnewhorizons.angelica.sdlgpu.frame.ContextState;
+import com.gtnewhorizons.angelica.sdlgpu.resource.FBOClearTracker;
+import com.gtnewhorizons.angelica.sdlgpu.resource.FboState;
+import com.gtnewhorizons.angelica.sdlgpu.resource.ResourceManager;
+import org.junit.jupiter.api.Test;
+
+import static com.gtnewhorizons.angelica.sdlgpu.pipeline.PipelineApplier.consumeClears;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_D24_UNORM;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT;
+
+class ClearConsumptionTest {
+
+    private static final long COLOR = 0xC010L;
+    private static final long DEPTH = 0xD00DL;
+    private static final long DUMMY = 0xD04DL;
+
+    private static FboState fbo(int depthFormat) {
+        final FboState fbo = new FboState();
+        fbo.colorTextures[0] = COLOR;
+        fbo.colorGlIds[0] = 3;
+        if (depthFormat != 0) {
+            fbo.depthTexture = DEPTH;
+            fbo.depthGlId = 5;
+            fbo.depthFormat = depthFormat;
+        }
+        fbo.recomputeTargets();
+        return fbo;
+    }
+
+    private static ResourceManager rm() {
+        return SdlTestRig.resourceManager();
+    }
+
+    @Test
+    void aClearedColorTargetBecomesContentDefined() {
+        final ResourceManager rm = rm();
+        final ContextState st = new ContextState();
+        final FboState fbo = fbo(0);
+        FBOClearTracker.recordPendingColorClear(st, COLOR, 0f, 0f, 0f, 1f);
+
+        consumeClears(rm, st, fbo, DUMMY, 0b1, false, false, false);
+
+        assertFalse(st.pendingColorTextures.contains(COLOR), "the pass applied the clear, so it is no longer pending");
+        assertTrue(rm.isTextureContentDefined(COLOR), "a later frame must not clear it again");
+    }
+
+    @Test
+    void anUnclearedColorTargetIsNotMarkedDefined() {
+        final ResourceManager rm = rm();
+        final ContextState st = new ContextState();
+
+        consumeClears(rm, st, fbo(0), DUMMY, 0, false, false, false);
+
+        assertFalse(rm.isTextureContentDefined(COLOR));
+    }
+
+    @Test
+    void theDummyTargetIsNeverTracked() {
+        final ResourceManager rm = rm();
+        final ContextState st = new ContextState();
+        final FboState fbo = fbo(0);
+        fbo.colorTextures[0] = DUMMY;
+        fbo.recomputeTargets();
+
+        consumeClears(rm, st, fbo, DUMMY, 0b1, false, false, false);
+
+        assertFalse(rm.isTextureContentDefined(DUMMY), "the shared stand-in target has no per-FBO content");
+    }
+
+    @Test
+    void depthAndStencilAreConsumedIndependently() {
+        final ContextState st = new ContextState();
+        FBOClearTracker.recordPendingDepthClear(st, DEPTH, 1f);
+        FBOClearTracker.recordPendingStencilClear(st, DEPTH, 0);
+
+        consumeClears(rm(), st, fbo(SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT), DUMMY, 0, true, true, true);
+
+        assertFalse(st.pendingDepthTextures.contains(DEPTH));
+        assertFalse(st.pendingStencilTextures.contains(DEPTH));
+        assertTrue(st.clearedTexturesThisFrame.contains(DEPTH));
+        assertTrue(st.clearedStencilTexturesThisFrame.contains(DEPTH));
+    }
+
+    @Test
+    void aDepthOnlyTargetLeavesStencilStateAlone() {
+        final ContextState st = new ContextState();
+        FBOClearTracker.recordPendingDepthClear(st, DEPTH, 1f);
+        FBOClearTracker.recordPendingStencilClear(st, DEPTH, 0);
+
+        consumeClears(rm(), st, fbo(SDL_GPU_TEXTUREFORMAT_D24_UNORM), DUMMY, 0, true, false, false);
+
+        assertFalse(st.pendingDepthTextures.contains(DEPTH));
+        assertTrue(st.pendingStencilTextures.contains(DEPTH), "the format has no stencil aspect to clear");
+        assertFalse(st.clearedStencilTexturesThisFrame.contains(DEPTH));
+    }
+
+    @Test
+    void anUnclearedDepthTargetIsStillConsumed() {
+        final ContextState st = new ContextState();
+        FBOClearTracker.recordPendingDepthClear(st, DEPTH, 1f);
+
+        consumeClears(rm(), st, fbo(SDL_GPU_TEXTUREFORMAT_D24_UNORM), DUMMY, 0, false, false, false);
+
+        assertFalse(st.pendingDepthTextures.contains(DEPTH));
+        assertFalse(st.clearedTexturesThisFrame.contains(DEPTH), "no clear was baked, so nothing was cleared");
+    }
+}
@@ -0,0 +1,44 @@
+package com.gtnewhorizons.angelica.sdlgpu.pipeline;
+
+import org.junit.jupiter.api.Test;
+
+import static com.gtnewhorizons.angelica.sdlgpu.pipeline.PipelineApplier.foldClearColor;
+import static com.gtnewhorizons.angelica.sdlgpu.pipeline.PipelineApplier.foldClearDepth;
+import static com.gtnewhorizons.angelica.sdlgpu.pipeline.PipelineApplier.foldClearStencil;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+
+class ClearValueLayoutHashTest {
+
+    private static final long SEED = 0xA5A5A5A5A5A5A5A5L;
+
+    @Test
+    void depthZeroAndDepthOneDoNotCollide() {
+        assertNotEquals(foldClearDepth(SEED, 0.0f), foldClearDepth(SEED, 1.0f), "the minimap mask clear must not reuse the world's depth-1 clear target");
+    }
+
+    @Test
+    void depthFoldIsStableForTheSameValue() {
+        assertEquals(foldClearDepth(SEED, 0.0f), foldClearDepth(SEED, 0.0f));
+    }
+
+    @Test
+    void negativeZeroIsDistinguishedFromZero() {
+        assertNotEquals(foldClearDepth(SEED, 0.0f), foldClearDepth(SEED, -0.0f), "raw bits, not numeric equality, so the cached value always matches what was baked");
+    }
+
+    @Test
+    void everyColorChannelParticipates() {
+        final long base = foldClearColor(SEED, 0f, 0f, 0f, 1f);
+        assertNotEquals(base, foldClearColor(SEED, 1f, 0f, 0f, 1f), "red");
+        assertNotEquals(base, foldClearColor(SEED, 0f, 1f, 0f, 1f), "green");
+        assertNotEquals(base, foldClearColor(SEED, 0f, 0f, 1f, 1f), "blue");
+        assertNotEquals(base, foldClearColor(SEED, 0f, 0f, 0f, 0f), "alpha");
+    }
+
+    @Test
+    void stencilValuesDoNotCollide() {
+        assertNotEquals(foldClearStencil(SEED, 0), foldClearStencil(SEED, 1));
+        assertEquals(foldClearStencil(SEED, 0xFF), foldClearStencil(SEED, 0xFF));
+    }
+}
@@ -0,0 +1,232 @@
+package com.gtnewhorizons.angelica.sdlgpu.pipeline;
+
+import com.gtnewhorizons.angelica.glsm.ffp.VAOManager;
+import com.gtnewhorizons.angelica.sdlgpu.SdlTestRig;
+import com.gtnewhorizons.angelica.sdlgpu.frame.ContextState;
+import com.gtnewhorizons.angelica.sdlgpu.resource.PixelOps;
+import com.gtnewhorizons.angelica.sdlgpu.shader.ShaderManager;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.BeforeAll;
+import org.junit.jupiter.api.Test;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL20;
+import org.lwjgl.opengl.GL30;
+import org.lwjgl.sdl.SDLError;
+import org.lwjgl.sdl.SDL_GPUColorTargetInfo;
+import org.lwjgl.sdl.SDL_GPUDepthStencilTargetInfo;
+import org.lwjgl.system.MemoryStack;
+import org.lwjgl.system.MemoryUtil;
+
+import java.nio.ByteBuffer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.lwjgl.sdl.SDLGPU.*;
+
+class StencilMaskGpuTest {
+
+    private static SdlTestRig rig;
+    private static ShaderManager sm;
+
+    private static final int SIZE = 64;
+    private static final int MASK = 32;
+
+    private static PipelineStore store;
+    private static long colorTexture;
+    private static int colorFormat;
+    private static long depthTexture;
+    private static int depthFormat;
+    private static long maskPipeline;
+    private static long fillPipeline;
+
+    private static final String VERTEX = String.join("\n",
+        "#version 460 core",
+        "void main() {",
+        "    vec2 p = vec2((gl_VertexID << 1) & 2, gl_VertexID & 2);",
+        "    gl_Position = vec4(p * 2.0 - 1.0, 0.0, 1.0);",
+        "}",
+        "");
+
+    private static final String MASK_FRAGMENT = String.join("\n",
+        "#version 460 core",
+        "layout(location = 0) out vec4 fragColor;",
+        "void main() {",
+        "    if (gl_FragCoord.x >= " + MASK + ".0 || gl_FragCoord.y >= " + MASK + ".0) discard;",
+        "    fragColor = vec4(0.0, 0.0, 1.0, 1.0);",
+        "}",
+        "");
+
+    private static final String FILL_FRAGMENT = String.join("\n",
+        "#version 460 core",
+        "layout(location = 0) out vec4 fragColor;",
+        "void main() {",
+        "    fragColor = vec4(1.0, 0.0, 0.0, 1.0);",
+        "}",
+        "");
+
+    @BeforeAll
+    static void setUp() throws Exception {
+        rig = SdlTestRig.acquireRealDevice();
+        rig.resourceManager.cachePreferredDepthFormats();
+        sm = new ShaderManager(rig.device);
+        VAOManager.init(0);
+        store = new PipelineStore(rig.device);
+
+        colorTexture = rig.resourceManager.createTexture(9500, GL11.GL_TEXTURE_2D, GL11.GL_RGBA8, SIZE, SIZE, 1, 1);
+        assertTrue(colorTexture != 0, "color target creation failed");
+        colorFormat = rig.resourceManager.getTextureMeta(9500).sdlFormat();
+        PipelineCache.setSwapchainFormats(new int[]{ colorFormat });
+
+        rig.resourceManager.createTexture(9501, GL11.GL_TEXTURE_2D, GL30.GL_DEPTH24_STENCIL8, SIZE, SIZE, 1, 1);
+        depthTexture = rig.resourceManager.ensureTextureUsage(9501, SDL_GPU_TEXTUREUSAGE_DEPTH_STENCIL_TARGET);
+        assertTrue(depthTexture != 0, "depth+stencil target creation failed");
+        depthFormat = rig.resourceManager.getTextureMeta(9501).sdlFormat();
+        assertEquals(8, PixelOps.stencilBits(depthFormat), "test needs a packed depth+stencil format");
+
+        maskPipeline = createPipeline(MASK_FRAGMENT, true);
+        fillPipeline = createPipeline(FILL_FRAGMENT, false);
+    }
+
+    @AfterAll
+    static void tearDown() {
+        SdlTestRig.releaseRealDevice();
+    }
+
+    private static long createPipeline(String fragmentSource, boolean writesMask) {
+        final int vs = sm.createShader(GL20.GL_VERTEX_SHADER);
+        sm.shaderSource(vs, VERTEX);
+        sm.compileShader(vs);
+        final int fs = sm.createShader(GL20.GL_FRAGMENT_SHADER);
+        sm.shaderSource(fs, fragmentSource);
+        sm.compileShader(fs);
+        final int prog = sm.createProgram();
+        sm.attachShader(prog, vs);
+        sm.attachShader(prog, fs);
+        sm.linkProgram(prog);
+        final ShaderManager.ProgramObject po = sm.getProgram(prog);
+        assertTrue(po != null && po.linked, "link failed: " + (po == null ? "no program" : po.infoLog));
+
+        po.sdlVertexShader = sm.createSDLShader(po.vertexSpirv, SDL_GPU_SHADERSTAGE_VERTEX, po.vertexResources.numSamplers(), po.vertexResources.numUBOs(), po.vertexResources.numStorageBuffers(), po.vertexResources.numStorageTextures());
+        po.sdlFragmentShader = sm.createSDLShader(po.fragmentSpirv, SDL_GPU_SHADERSTAGE_FRAGMENT, po.fragmentResources.numSamplers(), po.fragmentResources.numUBOs(), po.fragmentResources.numStorageBuffers(), po.fragmentResources.numStorageTextures());
+        assertTrue(po.sdlVertexShader != 0 && po.sdlFragmentShader != 0, "SDL shader creation failed");
+
+        final ContextState cs = new ContextState();
+        final PipelineCache cache = cs.pipeline;
+        cache.vertexShader = po.sdlVertexShader;
+        cache.fragmentShader = po.sdlFragmentShader;
+        cache.programId = prog;
+        cache.maxFragOutputLocation = po.maxFragOutputLocation;
+        cache.shaderInputMask = po.vertexInputMask;
+        cache.shaderInputVecSize = po.vertexInputVecSize;
+        cache.shaderInputBaseType = po.vertexInputBaseType;
+        cache.shaderInputName = po.vertexInputName;
+        cache.setColorTargetFormats(new int[]{ colorFormat });
+        cache.setDrawBuffers(new int[]{ 0 });
+        cache.hasDepthTarget = true;
+        cache.depthTargetFormat = depthFormat;
+        cache.depthTestEnabled = false;
+        cache.depthWriteEnabled = false;
+        cache.stencilTestEnabled = true;
+        cache.stencilCompareMask = 0xFF;
+        cache.stencilWriteMask = writesMask ? 0xFF : 0x00;
+        final int compareOp = writesMask ? SDL_GPU_COMPAREOP_ALWAYS : SDL_GPU_COMPAREOP_EQUAL;
+        final int passOp = writesMask ? SDL_GPU_STENCILOP_REPLACE : SDL_GPU_STENCILOP_KEEP;
+        cache.stencilFrontCompareOp = compareOp;
+        cache.stencilBackCompareOp = compareOp;
+        cache.stencilFrontPassOp = passOp;
+        cache.stencilBackPassOp = passOp;
+        cache.markShaderDirty();
+        cache.markOutputDirty();
+
+        assertTrue(cache.effectiveStencilTestEnabled(), "stencil must survive the depth-format gate");
+        final long pipeline = cache.getOrCreatePipeline(store, cs);
+        assertTrue(pipeline != 0, "pipeline creation failed: " + SDLError.SDL_GetError());
+        return pipeline;
+    }
+
+    private static void render(int secondPassStencilLoad) {
+        try (MemoryStack stack = MemoryStack.stackPush()) {
+            final long cb = SDL_AcquireGPUCommandBuffer(rig.device.getDevice());
+            assertTrue(cb != 0, "no command buffer");
+
+            final SDL_GPUColorTargetInfo.Buffer color = SDL_GPUColorTargetInfo.calloc(1, stack);
+            color.get(0).texture(colorTexture).load_op(SDL_GPU_LOADOP_CLEAR).store_op(SDL_GPU_STOREOP_STORE);
+            final SDL_GPUDepthStencilTargetInfo ds = SDL_GPUDepthStencilTargetInfo.calloc(stack)
+                .texture(depthTexture)
+                .load_op(SDL_GPU_LOADOP_CLEAR).store_op(SDL_GPU_STOREOP_STORE).clear_depth(1.0f)
+                .stencil_load_op(SDL_GPU_LOADOP_CLEAR).stencil_store_op(SDL_GPU_STOREOP_STORE).clear_stencil((byte) 0);
+
+            long pass = SDL_BeginGPURenderPass(cb, color, ds);
+            assertTrue(pass != 0, "no render pass");
+            SDL_SetGPUStencilReference(pass, (byte) 1);
+            SDL_BindGPUGraphicsPipeline(pass, maskPipeline);
+            SDL_DrawGPUPrimitives(pass, 3, 1, 0, 0);
+            if (secondPassStencilLoad < 0) {
+                SDL_BindGPUGraphicsPipeline(pass, fillPipeline);
+                SDL_DrawGPUPrimitives(pass, 3, 1, 0, 0);
+            }
+            SDL_EndGPURenderPass(pass);
+
+            if (secondPassStencilLoad >= 0) {
+                color.get(0).load_op(SDL_GPU_LOADOP_LOAD);
+                ds.load_op(SDL_GPU_LOADOP_LOAD).stencil_load_op(secondPassStencilLoad).clear_stencil((byte) 0);
+                pass = SDL_BeginGPURenderPass(cb, color, ds);
+                assertTrue(pass != 0, "no second render pass");
+                SDL_SetGPUStencilReference(pass, (byte) 1);
+                SDL_BindGPUGraphicsPipeline(pass, fillPipeline);
+                SDL_DrawGPUPrimitives(pass, 3, 1, 0, 0);
+                SDL_EndGPURenderPass(pass);
+            }
+
+            assertTrue(SDL_SubmitGPUCommandBuffer(cb), "draw submit failed");
+            SDL_WaitForGPUIdle(rig.device.getDevice());
+        }
+    }
+
+    private static int[] readRedPixels() {
+        final ByteBuffer pixels = MemoryUtil.memAlloc(SIZE * SIZE * 4);
+        try {
+            final long cb = SDL_AcquireGPUCommandBuffer(rig.device.getDevice());
+            assertTrue(cb != 0, "no readback command buffer");
+            rig.resourceManager.downloadFromTexture(cb, colorTexture, 0, 0, SIZE, SIZE, 0, pixels);
+            int count = 0, maxX = -1, minX = SIZE;
+            for (int y = 0; y < SIZE; y++) {
+                for (int x = 0; x < SIZE; x++) {
+                    final int i = (y * SIZE + x) * 4;
+                    final boolean red = (pixels.get(i) & 0xFF) > 200 && (pixels.get(i + 1) & 0xFF) < 64;
+                    if (red) {
+                        count++;
+                        if (x > maxX) maxX = x;
+                        if (x < minX) minX = x;
+                    }
+                }
+            }
+            return new int[]{ count, minX, maxX };
+        } finally {
+            MemoryUtil.memFree(pixels);
+        }
+    }
+
+    @Test
+    void fillIsClippedToTheStencilMask() {
+        render(-1);
+        final int[] r = readRedPixels();
+        assertEquals(MASK * MASK, r[0], "fill must cover exactly the masked region, not the whole target");
+        assertEquals(0, r[1], "masked region starts at x=0");
+        assertEquals(MASK - 1, r[2], "masked region must not bleed past the mask");
+    }
+
+    @Test
+    void maskSurvivesAPassBoundaryWhenStencilIsLoaded() {
+        render(SDL_GPU_LOADOP_LOAD);
+        final int[] r = readRedPixels();
+        assertEquals(MASK * MASK, r[0], "a stored stencil buffer must still clip the next pass");
+        assertEquals(MASK - 1, r[2]);
+    }
+
+    @Test
+    void clearingStencilWipesTheMask() {
+        render(SDL_GPU_LOADOP_CLEAR);
+        assertEquals(0, readRedPixels()[0], "a cleared stencil buffer must clip everything");
+    }
+}
@@ -0,0 +1,42 @@
+package com.gtnewhorizons.angelica.sdlgpu.resource;
+
+import com.gtnewhorizons.angelica.sdlgpu.SdlTestRig;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ColorContentLifetimeTest {
+
+    private static final long TEX = 0xC010125L;
+
+    @Test
+    void freshTextureHasUndefinedContents() {
+        final ResourceManager rm = SdlTestRig.resourceManager();
+        assertFalse(rm.isTextureContentDefined(TEX), "never written, so the first pass must clear");
+    }
+
+    @Test
+    void definedContentsSurviveAcrossFrames() {
+        final ResourceManager rm = SdlTestRig.resourceManager();
+        rm.markTextureContentDefined(TEX);
+        assertTrue(rm.isTextureContentDefined(TEX));
+
+        assertTrue(rm.isTextureContentDefined(TEX), "contents outlive the frame that produced them");
+    }
+
+    @Test
+    void releaseResetsContentsBecauseSdlCanRecycleThePointer() {
+        final ResourceManager rm = SdlTestRig.resourceManager();
+        rm.markTextureContentDefined(TEX);
+        rm.markTextureContentUndefined(TEX);
+        assertFalse(rm.isTextureContentDefined(TEX), "a recycled handle must not inherit the previous texture's defined flag");
+    }
+
+    @Test
+    void theZeroHandleIsNeverDefined() {
+        final ResourceManager rm = SdlTestRig.resourceManager();
+        rm.markTextureContentDefined(0L);
+        assertFalse(rm.isTextureContentDefined(0L));
+    }
+}
@@ -0,0 +1,64 @@
+package com.gtnewhorizons.angelica.sdlgpu.resource;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.lwjgl.sdl.SDLGPU.*;
+
+class DepthStencilBitsTest {
+
+    @Test
+    void depthBitsPerFormat() {
+        assertEquals(16, PixelOps.depthBits(SDL_GPU_TEXTUREFORMAT_D16_UNORM));
+        assertEquals(24, PixelOps.depthBits(SDL_GPU_TEXTUREFORMAT_D24_UNORM));
+        assertEquals(24, PixelOps.depthBits(SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT));
+        assertEquals(32, PixelOps.depthBits(SDL_GPU_TEXTUREFORMAT_D32_FLOAT));
+        assertEquals(32, PixelOps.depthBits(SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT));
+        assertEquals(0, PixelOps.depthBits(SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM));
+    }
+
+    @Test
+    void onlyPackedFormatsCarryStencil() {
+        assertEquals(8, PixelOps.stencilBits(SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT));
+        assertEquals(8, PixelOps.stencilBits(SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT));
+        assertEquals(0, PixelOps.stencilBits(SDL_GPU_TEXTUREFORMAT_D24_UNORM));
+        assertEquals(0, PixelOps.stencilBits(SDL_GPU_TEXTUREFORMAT_D32_FLOAT));
+        assertEquals(0, PixelOps.stencilBits(SDL_GPU_TEXTUREFORMAT_D16_UNORM));
+        assertEquals(0, PixelOps.stencilBits(SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM));
+    }
+
+    @Test
+    void stencilBitsAgreesWithIsDepthStencilFormat() {
+        final int[] formats = {
+            SDL_GPU_TEXTUREFORMAT_D16_UNORM, SDL_GPU_TEXTUREFORMAT_D24_UNORM, SDL_GPU_TEXTUREFORMAT_D32_FLOAT,
+            SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT, SDL_GPU_TEXTUREFORMAT_D32_FLOAT_S8_UINT,
+            SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM,
+        };
+        for (int f : formats) {
+            assertEquals(PixelOps.isDepthStencilFormat(f), PixelOps.stencilBits(f) != 0, "format " + f);
+        }
+    }
+
+    @Test
+    void colorChannelBitsForCommonFormats() {
+        for (int fmt : new int[]{ SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM, SDL_GPU_TEXTUREFORMAT_B8G8R8A8_UNORM }) {
+            for (int c = 0; c < 4; c++) assertEquals(8, PixelOps.colorChannelBits(fmt, c), "channel " + c);
+        }
+        assertEquals(16, PixelOps.colorChannelBits(SDL_GPU_TEXTUREFORMAT_R16G16B16A16_FLOAT, 3));
+        assertEquals(8, PixelOps.colorChannelBits(SDL_GPU_TEXTUREFORMAT_R8_UNORM, 0));
+        assertEquals(0, PixelOps.colorChannelBits(SDL_GPU_TEXTUREFORMAT_R8_UNORM, 1));
+        assertEquals(8, PixelOps.colorChannelBits(SDL_GPU_TEXTUREFORMAT_R8G8_UNORM, 1));
+        assertEquals(0, PixelOps.colorChannelBits(SDL_GPU_TEXTUREFORMAT_R8G8_UNORM, 2));
+        assertEquals(10, PixelOps.colorChannelBits(SDL_GPU_TEXTUREFORMAT_R10G10B10A2_UNORM, 0));
+        assertEquals(2, PixelOps.colorChannelBits(SDL_GPU_TEXTUREFORMAT_R10G10B10A2_UNORM, 3));
+        assertEquals(0, PixelOps.colorChannelBits(SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT, 0));
+    }
+
+    @Test
+    void depthFormatsAreNotColorFormats() {
+        assertTrue(PixelOps.isDepthFormat(SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT));
+        assertFalse(PixelOps.isDepthFormat(SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM));
+    }
+}
@@ -35,6 +35,18 @@ class FullCoverageClearDiscardTest {
        assertTrue(st.clearedTexturesThisFrame.contains(HANDLE), "the overwrite counts as the clear");
    }

+    @Test
+    void fullTargetColorBlitDefinesTheContents() {
+        final ContextState st = new ContextState();
+        FBOClearTracker.recordPendingColorClear(st, HANDLE, 1f, 0f, 0f, 1f);
+
+        final SdlTestRig rig = SdlTestRig.create();
+        final FBOClearTracker tracker = new FBOClearTracker(rig.frameManager, rig.resourceManager, null);
+        assertTrue(tracker.discardPendingClearIfFullyCovered(st, HANDLE, 0, 0, 0, W, H, meta()));
+
+        assertTrue(rig.resourceManager.isTextureContentDefined(HANDLE), "the overwrite defines the contents, so a later frame must not clear it back");
+    }
+
    @Test
    void fullTargetDepthBlitDropsThePendingClear() {
        final ContextState st = new ContextState();
@@ -0,0 +1,68 @@
+package com.gtnewhorizons.angelica.sdlgpu.resource;
+
+import org.junit.jupiter.api.Test;
+
+import static com.gtnewhorizons.angelica.sdlgpu.resource.PixelOps.colorChannelBits;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_A8_UNORM;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_B4G4R4A4_UNORM;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_B5G5R5A1_UNORM;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_B5G6R5_UNORM;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_BC1_RGBA_UNORM;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_R11G11B10_UFLOAT;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_R10G10B10A2_UNORM;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_R16G16_FLOAT;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_R8_UNORM;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM;
+
+class PixelFormatBitsTest {
+
+    private static int[] rgba(int sdlFormat) {
+        return new int[]{
+            colorChannelBits(sdlFormat, 0),
+            colorChannelBits(sdlFormat, 1),
+            colorChannelBits(sdlFormat, 2),
+            colorChannelBits(sdlFormat, 3),
+        };
+    }
+
+    private static void assertRgba(int sdlFormat, int r, int g, int b, int a) {
+        assertEquals(r, colorChannelBits(sdlFormat, 0), "red");
+        assertEquals(g, colorChannelBits(sdlFormat, 1), "green");
+        assertEquals(b, colorChannelBits(sdlFormat, 2), "blue");
+        assertEquals(a, colorChannelBits(sdlFormat, 3), "alpha");
+    }
+
+    @Test
+    void uniformWidthFormats() {
+        assertRgba(SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM, 8, 8, 8, 8);
+        assertRgba(SDL_GPU_TEXTUREFORMAT_R8_UNORM, 8, 0, 0, 0);
+        assertRgba(SDL_GPU_TEXTUREFORMAT_R16G16_FLOAT, 16, 16, 0, 0);
+        assertRgba(SDL_GPU_TEXTUREFORMAT_R32G32B32A32_FLOAT, 32, 32, 32, 32);
+    }
+
+    @Test
+    void packedFormatsReportTheirRealChannelWidths() {
+        assertRgba(SDL_GPU_TEXTUREFORMAT_A8_UNORM, 0, 0, 0, 8);
+        assertRgba(SDL_GPU_TEXTUREFORMAT_R10G10B10A2_UNORM, 10, 10, 10, 2);
+        assertRgba(SDL_GPU_TEXTUREFORMAT_R11G11B10_UFLOAT, 11, 11, 10, 0);
+        assertRgba(SDL_GPU_TEXTUREFORMAT_B5G6R5_UNORM, 5, 6, 5, 0);
+        assertRgba(SDL_GPU_TEXTUREFORMAT_B5G5R5A1_UNORM, 5, 5, 5, 1);
+        assertRgba(SDL_GPU_TEXTUREFORMAT_B4G4R4A4_UNORM, 4, 4, 4, 4);
+    }
+
+    @Test
+    void depthAndCompressedFormatsHaveNoColorChannels() {
+        assertRgba(SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT, 0, 0, 0, 0);
+        assertRgba(SDL_GPU_TEXTUREFORMAT_BC1_RGBA_UNORM, 0, 0, 0, 0);
+    }
+
+    @Test
+    void outOfRangeChannelsAreZero() {
+        assertEquals(0, colorChannelBits(SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM, -1));
+        assertEquals(0, colorChannelBits(SDL_GPU_TEXTUREFORMAT_R8G8B8A8_UNORM, 4));
+        assertEquals(4, rgba(SDL_GPU_TEXTUREFORMAT_B4G4R4A4_UNORM).length);
+    }
+}
@@ -0,0 +1,58 @@
+package com.gtnewhorizons.angelica.sdlgpu.resource;
+
+import com.gtnewhorizons.angelica.sdlgpu.SdlTestRig;
+import com.gtnewhorizons.angelica.sdlgpu.frame.FrameManager;
+import org.junit.jupiter.api.AfterAll;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.Timeout;
+import org.lwjgl.opengl.GL11;
+
+import java.nio.ByteBuffer;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREUSAGE_COLOR_TARGET;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREUSAGE_SAMPLER;
+import static org.lwjgl.system.MemoryUtil.memAlloc;
+import static org.lwjgl.system.MemoryUtil.memFree;
+
+@Timeout(60)
+class ReadbackSubmitOrderGpuTest {
+
+    private static final int SIZE = 4;
+
+    @AfterAll
+    static void releaseDevice() {
+        SdlTestRig.releaseRealDevice();
+    }
+
+    @Test
+    void aReadbackSubmitsTheFramesWritesFirst() throws Exception {
+        final SdlTestRig rig = SdlTestRig.acquireRealDevice();
+        final ResourceManager rm = rig.resourceManager;
+        final FrameManager fm = rig.frameManager;
+        final TextureOps textureOps = new TextureOps(rig.device, fm, rm, null);
+
+        final int glId = rm.genTexture();
+        final long texture = rm.createTexture(glId, GL11.GL_TEXTURE_2D, GL11.GL_RGBA8, SIZE, SIZE, 1, 1, SDL_GPU_TEXTUREUSAGE_SAMPLER | SDL_GPU_TEXTUREUSAGE_COLOR_TARGET);
+        assertNotEquals(0L, texture, "texture creation failed");
+
+        fm.beginFrame();
+        final FrameManager.FrameState f = fm.frame();
+        final long frameCb = f.commandBuffer;
+        assertNotEquals(0L, frameCb, "no frame command buffer to order against");
+        assertEquals(0, f.midFrameSubmitsThisFrame);
+
+        final ByteBuffer out = memAlloc(SIZE * SIZE * 4);
+        try {
+            textureOps.readbackTexture(texture, 0, 0, SIZE, SIZE, 0, out);
+        } finally {
+            memFree(out);
+        }
+
+        assertEquals(1, f.midFrameSubmitsThisFrame, "the frame command buffer must be submitted before the download buffer, or the readback sees stale contents");
+        assertNotEquals(frameCb, f.commandBuffer, "the frame must continue on a freshly acquired command buffer");
+
+        fm.endFrame();
+    }
+}
@@ -0,0 +1,122 @@
+package com.gtnewhorizons.angelica.sdlgpu.resource;
+
+import com.gtnewhorizons.angelica.sdlgpu.SdlTestRig;
+import com.gtnewhorizons.angelica.sdlgpu.frame.ContextState;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.lwjgl.sdl.SDLGPU.SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT;
+
+class StencilClearTrackingTest {
+
+    private static final long DEPTH = 0xD00DL;
+
+    private static FBOClearTracker tracker() {
+        final SdlTestRig rig = SdlTestRig.create();
+        return new FBOClearTracker(rig.frameManager, rig.resourceManager, null);
+    }
+
+    private static FboState packedDepthStencilFbo() {
+        final FboState fbo = new FboState();
+        fbo.depthTexture = DEPTH;
+        fbo.depthGlId = 5;
+        fbo.depthFormat = SDL_GPU_TEXTUREFORMAT_D24_UNORM_S8_UINT;
+        fbo.recomputeTargets();
+        return fbo;
+    }
+
+    @Test
+    void pendingStencilClearIsTrackedSeparatelyFromDepth() {
+        final ContextState st = new ContextState();
+        FBOClearTracker.recordPendingStencilClear(st, DEPTH, 0);
+
+        assertTrue(st.pendingStencilTextures.contains(DEPTH));
+        assertFalse(st.pendingDepthTextures.contains(DEPTH), "a stencil clear must not imply a depth clear");
+    }
+
+    @Test
+    void stencilClearSurvivesADepthClearOnTheSameHandle() {
+        final ContextState st = new ContextState();
+        FBOClearTracker.recordPendingStencilClear(st, DEPTH, 3);
+        FBOClearTracker.recordPendingDepthClear(st, DEPTH, 1f);
+
+        assertTrue(st.pendingStencilTextures.contains(DEPTH), "depth and stencil share a texture but not a clear");
+        assertEquals(3, st.pendingStencilValues.get(DEPTH));
+    }
+
+    @Test
+    void aPendingStencilClearAloneBlocksTargetReuse() {
+        final ContextState st = new ContextState();
+        final FboState fbo = packedDepthStencilFbo();
+        assertFalse(FBOClearTracker.fboHasPendingClear(st, fbo));
+
+        FBOClearTracker.recordPendingStencilClear(st, DEPTH, 0);
+        assertTrue(FBOClearTracker.fboHasPendingClear(st, fbo), "the pass must be rebuilt to apply the stencil clear");
+    }
+
+    @Test
+    void recordingAStencilClearRetractsTheClearedThisFrameMark() {
+        final ContextState st = new ContextState();
+        st.clearedStencilTexturesThisFrame.add(DEPTH);
+
+        FBOClearTracker.recordPendingStencilClear(st, DEPTH, 0);
+        assertFalse(st.clearedStencilTexturesThisFrame.contains(DEPTH), "a second clear in one frame must not be swallowed");
+    }
+
+    @Test
+    void recordingBumpsMutationGen() {
+        final ContextState st = new ContextState();
+        FBOClearTracker.snapshotFlushGenerations(st);
+        final int before = st.pendingMutationGen;
+
+        FBOClearTracker.recordPendingStencilClear(st, DEPTH, 0);
+        assertEquals(before + 1, st.pendingMutationGen);
+    }
+
+    @Test
+    void scrubDropsStencilStateWithTheTexture() {
+        final ContextState st = new ContextState();
+        FBOClearTracker.recordPendingStencilClear(st, DEPTH, 7);
+        st.clearedStencilTexturesThisFrame.add(DEPTH);
+
+        final SdlTestRig rig = SdlTestRig.create();
+        final int glId = rig.resourceManager.genTexture();
+        SdlReflect.putTextureHandle(rig.resourceManager, glId, DEPTH);
+        new FBOClearTracker(rig.frameManager, rig.resourceManager, null).scrubPendingClearsForTexture(st, glId);
+
+        assertFalse(st.pendingStencilTextures.contains(DEPTH));
+        assertFalse(st.pendingStencilValues.containsKey(DEPTH));
+        assertFalse(st.clearedStencilTexturesThisFrame.contains(DEPTH));
+    }
+
+    @Test
+    void stencilClearValueIsMaskedToEightBits() {
+        final ContextState st = new ContextState();
+        FBOClearTracker.recordPendingStencilClear(st, DEPTH, 0xFF);
+        assertEquals(0xFF, st.pendingStencilValues.get(DEPTH));
+        assertEquals((byte) 0xFF, (byte) st.pendingStencilValues.get(DEPTH));
+    }
+
+    @Test
+    void aStencilOnlyClearStillReachesTheSamplerFlush() {
+        final ContextState st = new ContextState();
+        FBOClearTracker.recordPendingStencilClear(st, DEPTH, 0);
+        final int gen = st.pendingMutationGen;
+
+        tracker().flushPendingClearsForBoundSamplers(st);
+
+        assertEquals(gen, st.lastFlushedPendingMutationGen, "the early-out must not skip a texture whose only pending clear is stencil");
+    }
+
+    @Test
+    void trackerIsUnusedForFbosWithoutADepthAttachment() {
+        final ContextState st = new ContextState();
+        FBOClearTracker.recordPendingStencilClear(st, DEPTH, 0);
+        final FboState colorOnly = new FboState();
+        colorOnly.colorTextures[0] = 0xAAAAL;
+        colorOnly.recomputeTargets();
+        assertFalse(FBOClearTracker.fboHasPendingClear(st, colorOnly));
+    }
+}
@@ -0,0 +1,112 @@
+package com.gtnewhorizons.angelica.sdlgpu.resource;
+
+import com.gtnewhorizons.angelica.glsm.testutil.Reflect;
+import com.gtnewhorizons.angelica.sdlgpu.SdlTestRig;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class TextureReleaseUploadOrderTest {
+
+    private static final long HANDLE = 0xBEEFL;
+
+    private static List<Long> deferredReleases(ResourceManager rm) {
+        return Reflect.get(rm, "deferredTextureReleases");
+    }
+
+    private static void setUploadSeqs(ResourceManager rm, long lastUpload) {
+        Reflect.setDeclared(ResourceManager.class, rm, "lastTextureUploadSeq", lastUpload);
+    }
+
+    @Test
+    void releaseIsImmediateWhenNoTransferThreadIsAttached() {
+        final ResourceManager rm = SdlTestRig.resourceManager();
+        setUploadSeqs(rm, 50L);
+        assertFalse(rm.shouldDeferTextureRelease(), "with no transfer thread there is nothing to outlive");
+    }
+
+    @Test
+    void releaseIsDeferredWhileTextureUploadsAreStillQueued() {
+        final SdlTestRig rig = SdlTestRig.create();
+        final ResourceManager rm = rig.resourceManager;
+        final TransferThread tt = new TransferThread(rig.device, rm);
+        rm.setTransferThread(tt);
+        setUploadSeqs(rm, 50L);
+        Reflect.setDeclared(TransferThread.class, tt, "submittedSeq", 10L);
+
+        rm.trackTextureHandle(HANDLE);
+        final int glId = rm.genTexture();
+        SdlReflect.putTextureHandle(rm, glId, HANDLE);
+
+        rm.deleteTexture(glId);
+        assertEquals(List.of(HANDLE), deferredReleases(rm), "the free must wait for the queued upload");
+    }
+
+    @Test
+    void releaseIsImmediateOnceTheTransferThreadHasCaughtUp() {
+        final SdlTestRig rig = SdlTestRig.create();
+        final ResourceManager rm = rig.resourceManager;
+        final TransferThread tt = new TransferThread(rig.device, rm);
+        rm.setTransferThread(tt);
+        setUploadSeqs(rm, 50L);
+
+        Reflect.setDeclared(TransferThread.class, tt, "submittedSeq", 49L);
+        assertTrue(rm.shouldDeferTextureRelease(), "one upload still unsubmitted is enough to defer");
+
+        Reflect.setDeclared(TransferThread.class, tt, "submittedSeq", 50L);
+        assertFalse(rm.shouldDeferTextureRelease(), "nothing is in flight, so no need to defer");
+    }
+
+    @Test
+    void aQueuedInlineBatchAlsoDefersTheRelease() {
+        final SdlTestRig rig = SdlTestRig.create();
+        final ResourceManager rm = rig.resourceManager;
+        rig.frameManager.setResourceManager(rm);
+        assertFalse(rm.shouldDeferTextureRelease(), "nothing queued yet");
+
+        rig.frameManager.frame().pendingTexHandles.add(HANDLE);
+        assertTrue(rm.hasBatchedUploads());
+        assertTrue(rm.shouldDeferTextureRelease(), "a queued batch entry must outlive the release");
+
+        rig.frameManager.frame().pendingTexHandles.clear();
+        assertFalse(rm.shouldDeferTextureRelease());
+    }
+
+    @Test
+    void releasingATextureBlanksItsQueuedBatchEntries() {
+        final SdlTestRig rig = SdlTestRig.create();
+        final ResourceManager rm = rig.resourceManager;
+        rig.frameManager.setResourceManager(rm);
+        final var handles = rig.frameManager.frame().pendingTexHandles;
+        handles.add(HANDLE);
+        handles.add(0xFEEDL);
+        handles.add(HANDLE);
+
+        rm.dropBatchedUploadsTargeting(HANDLE);
+
+        assertEquals(0L, handles.getLong(0), "every entry for the dying texture is blanked");
+        assertEquals(0xFEEDL, handles.getLong(1), "other destinations are untouched");
+        assertEquals(0L, handles.getLong(2));
+    }
+
+    @Test
+    void reallocReleaseObeysTheSameRule() {
+        final SdlTestRig rig = SdlTestRig.create();
+        final ResourceManager rm = rig.resourceManager;
+        final TransferThread tt = new TransferThread(rig.device, rm);
+        rm.setTransferThread(tt);
+        setUploadSeqs(rm, 7L);
+        Reflect.setDeclared(TransferThread.class, tt, "submittedSeq", 0L);
+
+        rm.trackTextureHandle(HANDLE);
+        final int glId = rm.genTexture();
+        SdlReflect.putTextureHandle(rm, glId, HANDLE);
+
+        rm.releaseTextureHandleForRealloc(glId);
+        assertEquals(List.of(HANDLE), deferredReleases(rm), "glTexImage2D re-specification frees the old handle on the same path as a delete");
+    }
+}
Author	SHA1	Message	Date
ah-OOG-ah	6d8cbf9c2f	Add a flag to StateAwareTesselator for per-quad directional shading (#1989 ) * Add a flag for no directional shading * Mark StateAwareTessellator as an API * Reset internal state better	2026-08-19 18:16:04 +00:00
boubou19	096dd01446	Avoid rescanning atlas for each CTM tile (#2029 )	2026-08-19 09:32:42 -07:00
Eclipse-SolandMartin Robertz	22c9479946	Many bug fixes (#2017 ) Co-authored-by: Martin Robertz <[email protected]>	2026-08-19 08:55:43 -07:00
Jason Mitchell	b2f597a73a	SDL presenter fixes and frame pacer adjustments (#2025 )	2026-08-16 17:59:33 -07:00
Jason Mitchell	553dec5b6d	Mark tiles at transform time instead of using reflection (#2024 )	2026-08-16 16:05:04 -07:00
Jason Mitchell	bc8116006c	Tracy 0.14 (#2019 )	2026-08-15 19:09:36 -07:00
Jason Mitchell	bf9492dffb	Defer ticking on TEs we eagerly create until they get a description packet (#2018 )	2026-08-15 17:04:50 -07:00
Jason Mitchell	69aed42b89	Sign Fix (#2016 )	2026-08-15 14:32:50 -07:00
KAMKEELandJason Mitchell	ffe54f61b9	Fixes World Lighting to Text Rendering so its not Fullbright (#1976 ) * Fixes World Lighting to Text Rendering so its not Fullbright * Carry lightmap state per text segment * Text lighting: per-segment lightmap uniform, fix GL_RESCALE_NORMAL * per segment uniform instead of stride increase * Shade text based on GL light state * fix u_NormalScale * GL_LIGHT > 1 usage warnings (not currently handled) --------- Co-authored-by: Jason Mitchell <[email protected]>	2026-08-14 21:34:58 -07:00
Jason Mitchell	c86e1de9f6	TE and world access thread safety for rendering, and remesh on first TE update packet. (#2014 )	2026-08-14 20:21:13 -07:00
brandyn	6af401c834	fix starminer rotation & optimize starminer rotateCorpseByGravity (#2005 ) * fix starminer rotation & optimize starminer rotateCorpseByGravity fixes #487 * remove Object[] allocation * add shared helper, fix NPEs, fallbacks	2026-08-13 11:27:43 -07:00
Jason Mitchell	b17bb42c49	vsync adjustments: on/mailbox/off + windows input lag fix + glsl parsing optimizations (#2009 )	2026-08-12 21:20:10 -07:00
Jason Mitchell	3659b59db9	Adjust vsync and fps limiters, and fix WSR with player models (#2002 )	2026-08-09 20:06:53 -07:00
Jason Mitchell	8c31eec525	SDL followup fixes (#2001 ) * Deploy fixes * Narrow transformer exclusions for Legends mods, and mixin priority for CustomNPC * Journeymap 6 stencil/depth fix * OpenLTW swizzle workaround	2026-08-09 13:43:46 -07:00