GLSM Extraction (#1527)

.gitignore

@@ -5,6 +5,7 @@
 /.vscode/
 /run/
 /build/
+/glsm/build/
 /eclipse/
 .classpath
 .project

build.gradle.kts

@@ -19,8 +19,7 @@ tasks.test {
         events("passed", "skipped", "failed")
     }
     // On macOS ARM64, use an ARM64-compatible JVM for tests
-    val isMacOsArm64 = System.getProperty("os.name").lowercase().contains("mac") &&
-        System.getProperty("os.arch") == "aarch64"
+    val isMacOsArm64 = System.getProperty("os.name").lowercase().contains("mac") && System.getProperty("os.arch") == "aarch64"
     javaLauncher = javaToolchains.launcherFor {
         languageVersion = JavaLanguageVersion.of(8)
         if (isMacOsArm64) {
@@ -48,20 +47,31 @@ tasks.register<Copy>("copyDependencies") {
 
 val embedOnly: Configuration by configurations
 
-// Downgrade embedOnly jars for the tests
+val stripModuleInfoFromEmbeds by tasks.registering(Jar::class) {
+    dependsOn(embedOnly)
+    from(embedOnly.map(::zipTree))
+    exclude("module-info.class")
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    archiveClassifier = "embeds-stripped"
+}
+
+// Downgrade embedOnly jars for the tests.
 val downgradeEmbedOnlyForTest by tasks.registering(DowngradeFiles::class) {
-    inputCollection = embedOnly
+    inputCollection = files(stripModuleInfoFromEmbeds.map { it.archiveFile })
+    outputs.dir(temporaryDir)
 }
 
 tasks.test {
     dependsOn(downgradeEmbedOnlyForTest)
-    classpath = classpath
-        .minus(embedOnly)
-        .plus(files(downgradeEmbedOnlyForTest.map { it.outputCollection }))
+    classpath = classpath.plus(files({ fileTree(downgradeEmbedOnlyForTest.get().temporaryDir) }))
 }
 
 tasks.shadowJar {
+    dependsOn(embedOnly)
     from(embedOnly.map(::zipTree))
+    minimize {
+        exclude(project(":glsm"))
+    }
     relocate("com.mitchej123", "com.mitchej123")
     relocate("org.embeddedt", "org.embeddedt")
 }

dependencies.gradle

@@ -53,7 +53,6 @@ configurations {
     embedOnly.canBeResolved = true
     compileClasspath.extendsFrom(embedOnly)
     testCompileClasspath.extendsFrom(embedOnly)
-    testRuntimeClasspath.extendsFrom(embedOnly)
 }
 
 
@@ -74,6 +73,8 @@ dependencies {
     compileOnly('org.jetbrains:annotations:26.0.2')
     api("com.github.GTNewHorizons:GTNHLib:0.9.36:dev")
 
+    embedOnly(project(":glsm")) { transitive = false }
+    embedOnly("net.minecraftforge:eventbus:7.0-beta.15")
     shadowImplementation("org.anarres:jcpp:1.4.14") // Apache 2.0
     shadowImplementation("org.taumc:glsl-transformation-lib:0.2.0-26.g5ee7d96-GTNH") {
         exclude module: "antlr4" // we only want to shadow the runtime module

glsm/build.gradle.kts

@@ -0,0 +1,190 @@
+import xyz.wagyourtail.jvmdg.gradle.task.files.DowngradeFiles
+
+plugins {
+    `java-library`
+    `maven-publish`
+}
+
+apply(plugin = "xyz.wagyourtail.jvmdowngrader")
+
+version = rootProject.version
+
+java {
+    toolchain.languageVersion.set(JavaLanguageVersion.of(21))
+    withSourcesJar()
+}
+
+// RFG variant attributes: the root Angelica project uses RetroFuturaGradle which expects
+// these attributes on dependencies. Without them, Gradle can't resolve the subproject variant.
+val rfgObfAttr = Attribute.of("com.gtnewhorizons.retrofuturagradle.obfuscation", String::class.java)
+val rfgTransformedAttr = Attribute.of("rfgDeobfuscatorTransformed", Boolean::class.javaObjectType)
+
+configurations {
+    listOf("apiElements", "runtimeElements").forEach { name ->
+        named(name) {
+            attributes {
+                attribute(rfgObfAttr, "mcp")
+                attribute(rfgTransformedAttr, true)
+            }
+        }
+    }
+}
+
+// Compile stubs: MC class signatures needed to resolve GTNHLib's type hierarchy.
+// Not included in the published jar — real MC classes are on the classpath at runtime.
+sourceSets {
+    create("stubs") {
+        java.srcDir("src/stubs/java")
+    }
+}
+
+// Exclude stubs from all output jars
+tasks.withType<Jar>().configureEach {
+    exclude("net/minecraft/**")
+}
+
+repositories {
+    maven {
+        name = "Mojang"
+        url = uri("https://libraries.minecraft.net")
+    }
+    maven {
+        name = "GTNH Maven"
+        url = uri("https://nexus.gtnewhorizons.com/repository/public/")
+    }
+    maven {
+        name = "Forge"
+        url = uri("https://maven.minecraftforge.net/")
+    }
+    maven {
+        name = "taumc"
+        url = uri("https://maven.taumc.org/releases")
+    }
+    maven {
+        name = "WagYourTail"
+        url = uri("https://maven.wagyourtail.xyz/releases")
+        content { includeGroup("xyz.wagyourtail.jvmdowngrader") }
+    }
+    mavenCentral()
+}
+
+dependencies {
+    // MC compile stubs
+    compileOnly(sourceSets["stubs"].output)
+
+    // LWJGL
+    compileOnly("org.lwjgl.lwjgl:lwjgl:${property("lwjglVersion")}")
+    compileOnly("org.lwjgl.lwjgl:lwjgl_util:${property("lwjglVersion")}")
+
+    // Our Deps
+    api("com.github.GTNewHorizons:GTNHLib:${property("gtnhlibVersion")}:dev")
+    api("net.minecraftforge:eventbus:${property("eventbusVersion")}")
+
+    compileOnly("org.embeddedt.celeritas:celeritas-common:${property("celeritasVersion")}") { isTransitive = false }
+    implementation("org.taumc:glsl-transformation-lib:${property("glslTransformLibVersion")}") { exclude(module = "antlr4") }
+    implementation("org.antlr:antlr4-runtime:${property("antlr4RuntimeVersion")}")
+    implementation("org.anarres:jcpp:${property("jcppVersion")}")
+
+    compileOnly("org.projectlombok:lombok:${property("lombokVersion")}") { isTransitive = false }
+    annotationProcessor("org.projectlombok:lombok:${property("lombokVersion")}")
+    compileOnly("org.jetbrains:annotations:${property("jetbrainsAnnotationsVersion")}")
+    compileOnly("org.apache.logging.log4j:log4j-api:${property("log4jVersion")}")
+
+    // Deps (normally from MC) - compile only, but needed at test runtime
+    compileOnly("com.google.guava:guava:${property("guavaVersion")}")
+    testRuntimeOnly("com.google.guava:guava:${property("guavaVersion")}")
+
+    // Test
+    testImplementation(sourceSets["stubs"].output)
+    testImplementation(platform("org.junit:junit-bom:${property("junitBomVersion")}"))
+    testImplementation("org.junit.jupiter:junit-jupiter")
+    testImplementation("org.lwjgl.lwjgl:lwjgl:${property("lwjglVersion")}")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher")
+    testRuntimeOnly("org.apache.logging.log4j:log4j-core:${property("log4jVersion")}")
+    testRuntimeOnly("org.embeddedt.celeritas:celeritas-lwjgl2-service:${property("celeritasVersion")}") { isTransitive = false }
+    testRuntimeOnly("xyz.wagyourtail.jvmdowngrader:jvmdowngrader-java-api:${property("jvmDowngraderVersion")}:downgraded-8")
+    testRuntimeOnly("org.apache.commons:commons-lang3:${property("commonsLang3Version")}")
+}
+
+val depsToDowngrade by configurations.creating {
+    isCanBeConsumed = false
+    isCanBeResolved = true
+}
+
+dependencies {
+    depsToDowngrade("net.minecraftforge:eventbus:${property("eventbusVersion")}")
+    depsToDowngrade("org.embeddedt.celeritas:celeritas-common:${property("celeritasVersion")}") { isTransitive = false }
+}
+
+tasks.withType<DowngradeFiles>().configureEach {
+    downgradeTo.set(JavaVersion.VERSION_1_8)
+    multiReleaseOriginal.set(false)
+    multiReleaseVersions.set(emptySet())
+}
+
+val downgradeDepsForTest by tasks.registering(DowngradeFiles::class) {
+    inputCollection = depsToDowngrade
+}
+
+val downgradeMainClasses by tasks.registering(DowngradeFiles::class) {
+    inputCollection = sourceSets["main"].output.classesDirs.plus(sourceSets["stubs"].output.classesDirs)
+    classpath = sourceSets["main"].compileClasspath
+    dependsOn(tasks.named("classes"), tasks.named("stubsClasses"))
+}
+
+val downgradeTestClasses by tasks.registering(DowngradeFiles::class) {
+    inputCollection = sourceSets["test"].output.classesDirs
+    classpath = sourceSets["test"].compileClasspath
+    dependsOn(tasks.named("testClasses"))
+}
+
+tasks.test {
+    useJUnitPlatform()
+
+    javaLauncher = javaToolchains.launcherFor {
+        languageVersion = JavaLanguageVersion.of(8)
+    }
+
+    dependsOn(downgradeMainClasses, downgradeTestClasses, downgradeDepsForTest)
+
+    val mainClassesDirs = sourceSets["main"].output.classesDirs
+        .plus(sourceSets["stubs"].output.classesDirs)
+    val testClassesDirs = sourceSets["test"].output.classesDirs
+
+    val downgradedTest = files(downgradeTestClasses.map { it.outputCollection })
+    val downgradedMain = files(downgradeMainClasses.map { it.outputCollection })
+    val downgradedDeps = files(downgradeDepsForTest.map { it.outputCollection })
+
+    setTestClassesDirs(downgradedTest)
+    classpath = downgradedTest
+        .plus(downgradedMain)
+        .plus(downgradedDeps)
+        .plus(classpath.minus(mainClassesDirs).minus(testClassesDirs).minus(depsToDowngrade))
+
+    val extractNatives = rootProject.tasks.named("extractNatives2")
+    dependsOn(extractNatives)
+    jvmArgs("-Djava.library.path=${extractNatives.get().property("destinationFolder").let { (it as DirectoryProperty).asFile.get().path }}")
+}
+
+publishing {
+    publications {
+        create<MavenPublication>("mavenJava") {
+            groupId = "com.gtnewhorizons.angelica"
+            artifactId = "glsm"
+            version = rootProject.version.toString()
+            from(components["java"])
+        }
+    }
+    repositories {
+        if (System.getenv("MAVEN_USER") != null) {
+            maven {
+                name = "GTNHMaven"
+                url = uri(rootProject.findProperty("mavenPublishUrl")?.toString() ?: "https://nexus.gtnewhorizons.com/repository/releases/")
+                credentials {
+                    username = System.getenv("MAVEN_USER")
+                    password = System.getenv("MAVEN_PASSWORD")
+                }
+            }
+        }
+    }
+}

glsm/gradle.properties

@@ -0,0 +1,14 @@
+lwjglVersion = 2.9.4-nightly-20150209
+eventbusVersion = 7.0-beta.15
+celeritasVersion = 2.5.3-GTNH
+lombokVersion = 1.18.42
+log4jVersion = 2.0-beta9
+guavaVersion = 18.0
+gtnhlibVersion = 0.9.36
+glslTransformLibVersion = 0.2.0-26.g5ee7d96-GTNH
+antlr4RuntimeVersion = 4.13.2
+jcppVersion = 1.4.14
+jetbrainsAnnotationsVersion = 26.0.2
+junitBomVersion = 5.14.1
+jvmDowngraderVersion = 1.3.5
+commonsLang3Version = 3.17.0

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

@@ -1,6 +1,5 @@
 package com.gtnewhorizons.angelica.glsm;
 
-import net.minecraft.launchwrapper.Launch;
 import org.taumc.glsl.ShaderParser;
 import org.taumc.glsl.Transformer;
 
@@ -18,8 +17,6 @@ import java.util.concurrent.atomic.AtomicInteger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
-
 /**
  * Compat transformation for mod shaders running under core profile.
  *
@@ -39,13 +36,11 @@ import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
  */
 public class CompatShaderTransformer {
 
-    private static final Pattern VERSION_PATTERN =
-        Pattern.compile("#version[ \\t]+(\\d+)(?:[ \\t]+(\\w+))?");
+    private static final Pattern VERSION_PATTERN = Pattern.compile("#version[ \\t]+(\\d+)(?:[ \\t]+(\\w+))?");
 
-    private static final Pattern DEFINE_PATTERN =
-        Pattern.compile("^\\s*#\\s*define\\s+.+$", Pattern.MULTILINE);
+    private static final Pattern DEFINE_PATTERN = Pattern.compile("^\\s*#\\s*define\\s+.+$", Pattern.MULTILINE);
 
-    /** Compat builtins that trigger AST transformation.  */
+    /** Compat builtins that trigger AST transformation. */
     private static final Set<String> COMPAT_BUILTINS = Set.of(
         "gl_ModelView", "gl_Projection", "gl_NormalMatrix", "gl_TextureMatrix",
         "gl_FragColor", "gl_Fog", "gl_FrontColor", "gl_Color",
@@ -69,14 +64,9 @@ public class CompatShaderTransformer {
 
     private static final Path DUMP_DIR;
     private static final AtomicInteger dumpCounter = new AtomicInteger(0);
+
     static {
-        boolean isDev = false;
-        try {
-            final Object deobfEnv = Launch.blackboard != null ? Launch.blackboard.get("fml.deobfuscatedEnvironment") : null;
-            isDev = Boolean.TRUE.equals(deobfEnv);
-        } catch (Exception ignored) {}
-        DUMP_DIR = (isDev || Boolean.parseBoolean(System.getProperty("angelica.compat.dumpShaders", "false")))
-            ? Paths.get("compat_shaders") : null;
+        DUMP_DIR = Boolean.parseBoolean(System.getProperty("angelica.dumpShaders", "false")) ? Paths.get("compat_shaders") : null;
     }
 
     private static final int CACHE_SIZE = 32;
@@ -84,9 +74,9 @@ public class CompatShaderTransformer {
     private static final Map<CacheKey, String> cache = Collections.synchronizedMap(
         new LinkedHashMap<>(32, 0.75f, true) {
             @Override protected boolean removeEldestEntry(Map.Entry<CacheKey, String> eldest) {
-                return size() > CACHE_SIZE;
-            }
-        });
+            return size() > CACHE_SIZE;
+        }
+    });
 
     public static void clearCache() {
         cache.clear();
@@ -112,7 +102,7 @@ public class CompatShaderTransformer {
                 result = transformInternal(source, isFragment);
                 cache.put(key, result);
             } catch (Exception e) {
-                LOGGER.warn("CompatShaderTransformer: AST transformation failed, falling back to version fixup only", e);
+                GLStateManager.LOGGER.warn("CompatShaderTransformer: AST transformation failed, falling back to version fixup only", e);
                 result = fixupVersion(source);
             }
         }
@@ -160,22 +150,20 @@ public class CompatShaderTransformer {
 
         // gl_LightSource[i] → struct + uniform array (both via injectFunction to keep struct before uniform)
         if (source.contains("gl_LightSource")) {
-            transformer.injectFunction(
-                "struct angelica_LightSourceParameters {"
-                + "vec4 ambient;vec4 diffuse;vec4 specular;vec4 position;vec4 halfVector;"
-                + "vec3 spotDirection;float spotExponent;float spotCutoff;float spotCosCutoff;"
-                + "float constantAttenuation;float linearAttenuation;float quadraticAttenuation;"
-                + "};");
+            transformer.injectFunction("struct angelica_LightSourceParameters {"
+                    + "vec4 ambient;vec4 diffuse;vec4 specular;vec4 position;vec4 halfVector;"
+                    + "vec3 spotDirection;float spotExponent;float spotCutoff;float spotCosCutoff;"
+                    + "float constantAttenuation;float linearAttenuation;float quadraticAttenuation;"
+                    + "};");
             transformer.injectFunction("uniform angelica_LightSourceParameters angelica_LightSource[2];");
             transformer.rename("gl_LightSource", "angelica_LightSource");
         }
 
         // gl_FrontMaterial → struct + uniform (both via injectFunction to keep struct before uniform)
         if (source.contains("gl_FrontMaterial")) {
-            transformer.injectFunction(
-                "struct angelica_MaterialParameters {"
-                + "vec4 emission;vec4 ambient;vec4 diffuse;vec4 specular;float shininess;"
-                + "};");
+            transformer.injectFunction("struct angelica_MaterialParameters {"
+                    + "vec4 emission;vec4 ambient;vec4 diffuse;vec4 specular;float shininess;"
+                    + "};");
             transformer.injectFunction("uniform angelica_MaterialParameters angelica_FrontMaterial;");
             transformer.rename("gl_FrontMaterial", "angelica_FrontMaterial");
         }
@@ -263,7 +251,9 @@ public class CompatShaderTransformer {
         transformer.replaceExpression("gl_ModelViewProjectionMatrix", "(angelica_ProjectionMatrix * angelica_ModelViewMatrix)");
         transformer.replaceExpression("gl_TextureMatrix[0]", "mat4(1.0)");
         transformer.replaceExpression("gl_TextureMatrix[1]", "angelica_LightmapTextureMatrix");
-        transformer.replaceExpression("gl_TextureMatrix", "mat4[8](mat4(1.0), angelica_LightmapTextureMatrix, mat4(1.0), mat4(1.0), mat4(1.0), mat4(1.0), mat4(1.0), mat4(1.0))");
+        transformer.replaceExpression(
+                "gl_TextureMatrix",
+                "mat4[8](mat4(1.0), angelica_LightmapTextureMatrix, mat4(1.0), mat4(1.0), mat4(1.0), mat4(1.0), mat4(1.0), mat4(1.0))");
     }
 
     /**
@@ -306,10 +296,9 @@ public class CompatShaderTransformer {
         transformer.injectVariable("uniform float angelica_FogEnd;");
         transformer.injectVariable("uniform vec4 angelica_FogColor;");
         transformer.injectFunction("struct angelica_FogParameters {vec4 color;float density;float start;float end;float scale;};");
-        transformer.injectFunction(
-            "angelica_FogParameters angelica_Fog = angelica_FogParameters("
-            + "angelica_FogColor, angelica_FogDensity, angelica_FogStart, angelica_FogEnd, "
-            + "1.0 / (angelica_FogEnd - angelica_FogStart));");
+        transformer.injectFunction("angelica_FogParameters angelica_Fog = angelica_FogParameters("
+                + "angelica_FogColor, angelica_FogDensity, angelica_FogStart, angelica_FogEnd, "
+                + "1.0 / (angelica_FogEnd - angelica_FogStart));");
     }
 
     /**
@@ -356,7 +345,7 @@ public class CompatShaderTransformer {
             Files.writeString(DUMP_DIR.resolve(id + "_original" + suffix), header + original, StandardCharsets.UTF_8);
             Files.writeString(DUMP_DIR.resolve(id + "_transformed" + suffix), header + transformed, StandardCharsets.UTF_8);
         } catch (IOException e) {
-            LOGGER.warn("Failed to dump compat shader: {}", e.getMessage());
+            GLStateManager.LOGGER.warn("Failed to dump compat shader: {}", e.getMessage());
         }
     }
 

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

@@ -15,12 +15,11 @@ import org.lwjgl.opengl.GL20;
 
 import java.nio.FloatBuffer;
 
-import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
-
 /**
  * Per-program compat uniform location cache and upload manager.
  *
- * <p>Manages {@code angelica_*} uniforms injected by {@link CompatShaderTransformer} and {@code iris_*} matrix uniforms used by Iris/celeritas shader programs.
+ * <p>Manages {@code angelica_*} uniforms injected by {@link CompatShaderTransformer} and {@code iris_*} matrix uniforms used by Iris/celeritas shader
+ * programs.
  */
 public class CompatUniformManager {
 
@@ -69,6 +68,7 @@ public class CompatUniformManager {
     };
 
     private static final String[] UNIFORM_NAMES;
+
     static {
         UNIFORM_NAMES = new String[LOC_COUNT];
         UNIFORM_NAMES[LOC_MODELVIEW] = "angelica_ModelViewMatrix";
@@ -91,8 +91,7 @@ public class CompatUniformManager {
         UNIFORM_NAMES[LOC_CLIP_PLANES_ENABLED] = "angelica_ClipPlanesEnabled";
         for (int li = 0; li < 2; li++) {
             for (int fi = 0; fi < LIGHT_FIELDS; fi++) {
-                UNIFORM_NAMES[LOC_LIGHT_BASE + li * LIGHT_FIELDS + fi] =
-                    "angelica_LightSource[" + li + "]." + LIGHT_FIELD_NAMES[fi];
+                UNIFORM_NAMES[LOC_LIGHT_BASE + li * LIGHT_FIELDS + fi] = "angelica_LightSource[" + li + "]." + LIGHT_FIELD_NAMES[fi];
             }
         }
         for (int fi = 0; fi < MAT_FIELDS; fi++) {
@@ -113,6 +112,7 @@ public class CompatUniformManager {
 
     private static final float LIGHTMAP_SCALE = 1.0f / 256.0f;
     private static final FloatBuffer lightmapMatrixBuf;
+
     static {
         lightmapMatrixBuf = BufferUtils.createFloatBuffer(16);
         new Matrix4f().scale(LIGHTMAP_SCALE).translate(8.0f, 8.0f, 8.0f).get(lightmapMatrixBuf);
@@ -140,7 +140,7 @@ public class CompatUniformManager {
 
         if (hasAny) {
             programLocations.put(program, locs);
-            LOGGER.debug("CompatUniformManager: program {} has compat uniforms", program);
+            GLStateManager.LOGGER.debug("CompatUniformManager: program {} has compat uniforms", program);
         }
     }
 
@@ -277,8 +277,7 @@ public class CompatUniformManager {
         }
         if (locs[LOC_FOG_COLOR] != -1) {
             vec4Buf.clear();
-            vec4Buf.put((float) fog.getFogColor().x).put((float) fog.getFogColor().y)
-                   .put((float) fog.getFogColor().z).put(fog.getFogAlpha());
+            vec4Buf.put((float) fog.getFogColor().x).put((float) fog.getFogColor().y).put((float) fog.getFogColor().z).put(fog.getFogAlpha());
             vec4Buf.flip();
             GL20.glUniform4(locs[LOC_FOG_COLOR], vec4Buf);
         }
@@ -287,8 +286,7 @@ public class CompatUniformManager {
         // Return -1.0f for ALWAYS or disabled so `alpha <= ref` never discards.
         if (locs[LOC_ALPHA_TEST_REF] != -1) {
             final float ref;
-            if (!GLStateManager.getAlphaTest().isEnabled()
-                || GLStateManager.getAlphaState().getFunction() == GL11.GL_ALWAYS) {
+            if (!GLStateManager.getAlphaTest().isEnabled() || GLStateManager.getAlphaState().getFunction() == GL11.GL_ALWAYS) {
                 ref = -1.0f;
             } else {
                 ref = GLStateManager.getAlphaState().getReference();
@@ -298,8 +296,7 @@ public class CompatUniformManager {
     }
 
     /**
-     * Scene color = emission + ambient * lightModel.ambient, alpha = diffuse.a
-     * Same computation as {@code Uniforms.uploadLightingPreComputed()}.
+     * Scene color = emission + ambient * lightModel.ambient, alpha = diffuse.a Same computation as {@code Uniforms.uploadLightingPreComputed()}.
      */
     private static void uploadSceneColor(int[] locs) {
         final MaterialState mat = GLStateManager.getFrontMaterial();
@@ -333,8 +330,9 @@ public class CompatUniformManager {
                 // halfVector = normalize(normalize(position.xyz) + eye), eye=(0,0,1) for infinite viewer
                 float hx, hy, hz;
                 if (light.position.w == 0.0f) {
-                    float len = (float) Math.sqrt(light.position.x * light.position.x
-                        + light.position.y * light.position.y + light.position.z * light.position.z);
+                    final float len = (float) Math.sqrt(light.position.x * light.position.x
+                            + light.position.y * light.position.y
+                            + light.position.z * light.position.z);
                     if (len > 0) {
                         hx = light.position.x / len;
                         hy = light.position.y / len;
@@ -345,24 +343,17 @@ public class CompatUniformManager {
                 } else {
                     hx = 0; hy = 0; hz = 1;
                 }
-                float hlen = (float) Math.sqrt(hx * hx + hy * hy + hz * hz);
+                final float hlen = (float) Math.sqrt(hx * hx + hy * hy + hz * hz);
                 if (hlen > 0) { hx /= hlen; hy /= hlen; hz /= hlen; }
                 GL20.glUniform4f(locs[base + LF_HALF_VECTOR], hx, hy, hz, 0.0f);
             }
-            if (locs[base + LF_SPOT_DIRECTION] != -1)
-                GL20.glUniform3f(locs[base + LF_SPOT_DIRECTION], light.spotDirection.x, light.spotDirection.y, light.spotDirection.z);
-            if (locs[base + LF_SPOT_EXPONENT] != -1)
-                GL20.glUniform1f(locs[base + LF_SPOT_EXPONENT], light.spotExponent);
-            if (locs[base + LF_SPOT_CUTOFF] != -1)
-                GL20.glUniform1f(locs[base + LF_SPOT_CUTOFF], light.spotCutoff);
-            if (locs[base + LF_SPOT_COS_CUTOFF] != -1)
-                GL20.glUniform1f(locs[base + LF_SPOT_COS_CUTOFF], light.spotCosCutoff);
-            if (locs[base + LF_CONSTANT_ATTEN] != -1)
-                GL20.glUniform1f(locs[base + LF_CONSTANT_ATTEN], light.constantAttenuation);
-            if (locs[base + LF_LINEAR_ATTEN] != -1)
-                GL20.glUniform1f(locs[base + LF_LINEAR_ATTEN], light.linearAttenuation);
-            if (locs[base + LF_QUADRATIC_ATTEN] != -1)
-                GL20.glUniform1f(locs[base + LF_QUADRATIC_ATTEN], light.quadraticAttenuation);
+            if (locs[base + LF_SPOT_DIRECTION] != -1) GL20.glUniform3f(locs[base + LF_SPOT_DIRECTION], light.spotDirection.x, light.spotDirection.y, light.spotDirection.z);
+            if (locs[base + LF_SPOT_EXPONENT] != -1) GL20.glUniform1f(locs[base + LF_SPOT_EXPONENT], light.spotExponent);
+            if (locs[base + LF_SPOT_CUTOFF] != -1) GL20.glUniform1f(locs[base + LF_SPOT_CUTOFF], light.spotCutoff);
+            if (locs[base + LF_SPOT_COS_CUTOFF] != -1) GL20.glUniform1f(locs[base + LF_SPOT_COS_CUTOFF], light.spotCosCutoff);
+            if (locs[base + LF_CONSTANT_ATTEN] != -1) GL20.glUniform1f(locs[base + LF_CONSTANT_ATTEN], light.constantAttenuation);
+            if (locs[base + LF_LINEAR_ATTEN] != -1) GL20.glUniform1f(locs[base + LF_LINEAR_ATTEN], light.linearAttenuation);
+            if (locs[base + LF_QUADRATIC_ATTEN] != -1) GL20.glUniform1f(locs[base + LF_QUADRATIC_ATTEN], light.quadraticAttenuation);
         }
     }
 

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

@@ -1,6 +1,5 @@
 package com.gtnewhorizons.angelica.glsm;
 
-import com.github.bsideup.jabel.Desugar;
 import com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities;
 import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
 import com.gtnewhorizon.gtnhlib.client.renderer.TessellatorManager;
@@ -8,6 +7,7 @@ import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VBOManager;
 import com.gtnewhorizon.gtnhlib.client.renderer.vbo.VertexBuffer;
 import com.gtnewhorizon.gtnhlib.client.renderer.vertex.DefaultVertexFormat;
 import com.gtnewhorizons.angelica.glsm.recording.AccumulatedDraw;
+import com.gtnewhorizons.angelica.glsm.recording.ImmediateModeRecorder;
 import com.gtnewhorizons.angelica.glsm.recording.CommandBuffer;
 import com.gtnewhorizons.angelica.glsm.recording.CommandRecorder;
 import com.gtnewhorizons.angelica.glsm.recording.CompiledDisplayList;
@@ -19,8 +19,6 @@ import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
 import lombok.Getter;
 import lombok.experimental.UtilityClass;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.joml.Matrix4f;
 import org.joml.Matrix4fStack;
 import org.joml.Vector3f;
@@ -49,8 +47,6 @@ import static com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities.memGetInt;
  */
 @UtilityClass
 public class DisplayListManager {
-    private static final Logger LOGGER = LogManager.getLogger("DisplayListManager");
-
     // -Dangelica.debugDisplayLists: disable transform collapsing and draw merging
     private static final boolean DEBUG_DISPLAY_LISTS = Boolean.getBoolean("angelica.debugDisplayLists");
 
@@ -60,7 +56,7 @@ public class DisplayListManager {
     static {
         LOG_DISPLAY_LIST_COMPILATION = Boolean.getBoolean("angelica.logDisplayListCompilation");
         if (LOG_DISPLAY_LIST_COMPILATION) {
-            LogManager.getLogger("DisplayListManager").warn("Display list compilation logging ENABLED (-Dangelica.logDisplayListCompilation=true)");
+            GLStateManager.LOGGER.warn("Display list compilation logging ENABLED (-Dangelica.logDisplayListCompilation=true)");
         }
     }
 
@@ -113,7 +109,6 @@ public class DisplayListManager {
      * Compilation context for a single display list being compiled.
      * Used to support nested glNewList() calls (spec-violating but needed for mod compatibility).
      */
-    @Desugar
     private record CompilationContext(
         int listId,
         int listMode,
@@ -144,6 +139,16 @@ public class DisplayListManager {
         return glListMode == GL11.GL_COMPILE_AND_EXECUTE;
     }
 
+    public static CommandRecorder pauseRecording() {
+        final CommandRecorder r = currentRecorder;
+        currentRecorder = null;
+        return r;
+    }
+
+    public static void resumeRecording(CommandRecorder r) {
+        currentRecorder = r;
+    }
+
     /**
      * Emit accumulated transform as MultMatrix if non-identity, then reset.
      */
@@ -160,7 +165,7 @@ public class DisplayListManager {
         // Save pending transform ops for logging (before we clear them)
         if (multMatrixSources != null && pendingTransformOps != null) {
             if (pendingTransformOps.isEmpty()) {
-                LOGGER.warn("flushMatrix: non-identity transform with no tracked ops");
+                GLStateManager.LOGGER.warn("flushMatrix: non-identity transform with no tracked ops");
                 multMatrixSources.add(Collections.singletonList("(unknown source)"));
             } else {
                 multMatrixSources.add(new ArrayList<>(pendingTransformOps));
@@ -174,11 +179,6 @@ public class DisplayListManager {
             stateGeneration++;
         }
 
-        // COMPILE_AND_EXECUTE: apply to GLSM software stack
-        if (glListMode == GL11.GL_COMPILE_AND_EXECUTE) {
-            GLStateManager.getMatrixStack().mul(relativeTransform);
-        }
-
         // Reset to identity - we're now synchronized with GL
         relativeTransform.identity();
 
@@ -258,6 +258,9 @@ public class DisplayListManager {
         if (currentRecorder == null) return;
         drawBarrier();
         currentRecorder.recordColor(r, g, b, a);
+        if (ImmediateModeRecorder.isDrawing()) {
+            ImmediateModeRecorder.setColor(r, g, b, a);
+        }
     }
 
     public static void recordColorMask(boolean r, boolean g, boolean b, boolean a) {
@@ -624,9 +627,6 @@ public class DisplayListManager {
             final Matrix4f singleTransform = new Matrix4f();
             applyTransformOp(singleTransform, x, y, z, op, rotationAxis);
             if (currentRecorder != null) currentRecorder.recordMultMatrix(singleTransform);
-            if (glListMode == GL11.GL_COMPILE_AND_EXECUTE) {
-                GLStateManager.getMatrixStack().mul(singleTransform);
-            }
             return;
         }
 
@@ -660,10 +660,6 @@ public class DisplayListManager {
             if (currentRecorder != null) {
                 currentRecorder.recordMultMatrix(matrix);
             }
-
-            if (glListMode == GL11.GL_COMPILE_AND_EXECUTE) {
-                GLStateManager.getMatrixStack().mul(matrix);
-            }
             return;
         }
 
@@ -969,7 +965,7 @@ public class DisplayListManager {
     // ==================== DEBUG LOGGING ====================
 
     public static void logCompiledDisplayList(int listId, CompiledDisplayList compiled, StackTraceElement[] stackTrace) {
-        LOGGER.debug(getCompiledDisplayListString(listId, compiled, stackTrace));
+        GLStateManager.LOGGER.debug(getCompiledDisplayListString(listId, compiled, stackTrace));
     }
 
     public static String getCompiledDisplayListString(int listId, CompiledDisplayList compiled, StackTraceElement[] stackTrace) {

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

@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.glsm;
 import com.gtnewhorizons.angelica.glsm.recording.ImmediateModeRecorder;
 import com.gtnewhorizons.angelica.glsm.states.VertexAttribState;
 import com.gtnewhorizons.angelica.glsm.states.ViewportState;
-import com.gtnewhorizons.angelica.loading.AngelicaTweaker;
 import org.joml.Matrix4f;
 import org.joml.Vector4f;
 import org.lwjgl.opengl.GL11;
@@ -39,6 +38,7 @@ public class FeedbackManager {
 
     @FunctionalInterface
     private interface IndexReader {
+
         int read(int i);
     }
 
@@ -48,7 +48,7 @@ public class FeedbackManager {
 
     public static void glFeedbackBuffer(int type, FloatBuffer buffer) {
         if (renderMode == GL11.GL_FEEDBACK) {
-            AngelicaTweaker.LOGGER.error("glFeedbackBuffer called while already in feedback mode");
+            GLStateManager.LOGGER.error("glFeedbackBuffer called while already in feedback mode");
             return;
         }
         feedbackBuffer = buffer;
@@ -65,7 +65,7 @@ public class FeedbackManager {
         };
 
         if (mode == GL11.GL_SELECT) {
-            AngelicaTweaker.LOGGER.warn("glRenderMode(GL_SELECT): selection mode not emulated");
+            GLStateManager.LOGGER.warn("glRenderMode(GL_SELECT): selection mode not emulated");
         }
 
         feedbackCount = 0;
@@ -118,8 +118,7 @@ public class FeedbackManager {
         final ViewportState vp = GLStateManager.getViewportState();
         final float winX = vp.x + vp.width * (ndcX + 1.0f) * 0.5f;
         final float winY = vp.y + vp.height * (ndcY + 1.0f) * 0.5f;
-        final float winZ = (float) ((vp.depthRangeFar - vp.depthRangeNear) * ndcZ
-            + (vp.depthRangeFar + vp.depthRangeNear)) * 0.5f;
+        final float winZ = (float) ((vp.depthRangeFar - vp.depthRangeNear) * ndcZ + (vp.depthRangeFar + vp.depthRangeNear)) * 0.5f;
         final float winW = 1.0f / w;
 
         feedbackVertex(winX, winY, winZ, winW);

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

@@ -19,79 +19,81 @@ import org.lwjgl.opengl.GL43;
 import org.lwjgl.opengl.KHRDebug;
 import org.lwjgl.opengl.KHRDebugCallback;
 
-import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
 import static org.lwjgl.opengl.ARBDebugOutput.glDebugMessageCallbackARB;
 
 public final class GLDebug {
+
     /**
      * Sets up debug callbacks
+     *
      * @return 0 for failure, 1 for success, 2 for restart required.
      */
     public static int setupDebugMessageCallback() {
         if (Thread.currentThread() != GLStateManager.getMainThread()) {
-            LOGGER.warn("setupDebugMessageCallback called from non-main thread!");
+            GLStateManager.LOGGER.warn("setupDebugMessageCallback called from non-main thread!");
             return 0;
         }
         return setupDebugMessageCallbackImpl();
     }
 
-	public static Throwable filterStackTrace(Throwable throwable, int offset) {
-		StackTraceElement[] elems = throwable.getStackTrace();
-		StackTraceElement[] filtered = new StackTraceElement[elems.length];
-		int j = 0;
-		for (int i = offset; i < elems.length; i++) {
-			String className = elems[i].getClassName();
-			if (className == null) {
-				className = "";
-			}
-			filtered[j++] = elems[i];
-		}
-		StackTraceElement[] newElems = new StackTraceElement[j];
-		System.arraycopy(filtered, 0, newElems, 0, j);
-		throwable.setStackTrace(newElems);
-		return throwable;
-	}
+    public static Throwable filterStackTrace(Throwable throwable, int offset) {
+        StackTraceElement[] elems = throwable.getStackTrace();
+        StackTraceElement[] filtered = new StackTraceElement[elems.length];
+        int j = 0;
+        for (int i = offset; i < elems.length; i++) {
+            String className = elems[i].getClassName();
+            if (className == null) {
+                className = "";
+            }
+            filtered[j++] = elems[i];
+        }
+        StackTraceElement[] newElems = new StackTraceElement[j];
+        System.arraycopy(filtered, 0, newElems, 0, j);
+        throwable.setStackTrace(newElems);
+        return throwable;
+    }
 
-	private static String buildStackTrace() {
-		StackTraceElement[] elems = filterStackTrace(new Throwable(), 4).getStackTrace();
-		StringBuilder sb = new StringBuilder();
-		for (StackTraceElement elem : elems) {
-			sb.append("\n\t").append(elem.toString());
-		}
-		return sb.toString();
-	}
+    private static String buildStackTrace() {
+        StackTraceElement[] elems = filterStackTrace(new Throwable(), 4).getStackTrace();
+        StringBuilder sb = new StringBuilder();
+        for (StackTraceElement elem : elems) {
+            sb.append("\n\t").append(elem.toString());
+        }
+        return sb.toString();
+    }
 
-	private static void logDebugMessage(int id, String source, String type, String severity, String message) {
-		String fullMessage = String.format("[GL] %s %s (0x%X) from %s: %s%s", severity, type, id, source, message, buildStackTrace());
+    private static void logDebugMessage(int id, String source, String type, String severity, String message) {
+        String fullMessage = String.format("[GL] %s %s (0x%X) from %s: %s%s", severity, type, id, source, message, buildStackTrace());
 
-		if ("HIGH".equals(severity)) {
-			LOGGER.error(fullMessage);
-		} else if ("MEDIUM".equals(severity)) {
-			LOGGER.warn(fullMessage);
-		} else {
-			LOGGER.info(fullMessage);
-		}
-	}
+        if ("HIGH".equals(severity)) {
+            GLStateManager.LOGGER.error(fullMessage);
+        } else if ("MEDIUM".equals(severity)) {
+            GLStateManager.LOGGER.warn(fullMessage);
+        } else {
+            GLStateManager.LOGGER.info(fullMessage);
+        }
+    }
 
-	private static void logDebugMessageAMD(int id, String category, String severity, String message) {
-		String fullMessage = String.format("[GL] %s %s (0x%X): %s%s", severity, category, id, message, buildStackTrace());
+    private static void logDebugMessageAMD(int id, String category, String severity, String message) {
+        String fullMessage = String.format("[GL] %s %s (0x%X): %s%s", severity, category, id, message, buildStackTrace());
 
-		if ("HIGH".equals(severity)) {
-			LOGGER.error(fullMessage);
-		} else if ("MEDIUM".equals(severity)) {
-			LOGGER.warn(fullMessage);
-		} else {
-			LOGGER.info(fullMessage);
-		}
-	}
+        if ("HIGH".equals(severity)) {
+            GLStateManager.LOGGER.error(fullMessage);
+        } else if ("MEDIUM".equals(severity)) {
+            GLStateManager.LOGGER.warn(fullMessage);
+        } else {
+            GLStateManager.LOGGER.info(fullMessage);
+        }
+    }
 
     /**
      * Sets up debug callbacks
+     *
      * @return 0 for failure, 1 for success, 2 for restart required.
      */
     private static int setupDebugMessageCallbackImpl() {
         if (GLStateManager.capabilities.OpenGL43 || GLStateManager.capabilities.GL_KHR_debug) {
-            LOGGER.info("[GL] Using OpenGL 4.3 for error logging.");
+            GLStateManager.LOGGER.info("[GL] Using OpenGL 4.3 for error logging.");
             final KHRDebugCallback proc = new KHRDebugCallback((source, type, id, severity, message) -> {
                 logDebugMessage(id, getDebugSource(source), getDebugType(type), getDebugSeverity(severity), message);
             });
@@ -105,13 +107,13 @@ public final class GLDebug {
             GL11.glEnable(GL43.GL_DEBUG_OUTPUT_SYNCHRONOUS);
 
             if ((GL11.glGetInteger(GL30.GL_CONTEXT_FLAGS) & GL43.GL_CONTEXT_FLAG_DEBUG_BIT) == 0) {
-                LOGGER.warn("[GL] Warning: A non-debug context may not produce any debug output.");
+                GLStateManager.LOGGER.warn("[GL] Warning: A non-debug context may not produce any debug output.");
                 GL11.glEnable(GL43.GL_DEBUG_OUTPUT);
                 return 2;
             }
             return 1;
         } else if (GLStateManager.capabilities.GL_ARB_debug_output) {
-            LOGGER.info("[GL] Using ARB_debug_output for error logging.");
+            GLStateManager.LOGGER.info("[GL] Using ARB_debug_output for error logging.");
             final ARBDebugOutputCallback proc = new ARBDebugOutputCallback((source, type, id, severity, message) -> {
                 logDebugMessage(id, getSourceARB(source), getTypeARB(type), getSeverityARB(severity), message);
             });
@@ -125,7 +127,7 @@ public final class GLDebug {
             GL11.glEnable(ARBDebugOutput.GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
             return 1;
         } else if (GLStateManager.capabilities.GL_AMD_debug_output) {
-            LOGGER.info("[GL] Using AMD_debug_output for error logging.");
+            GLStateManager.LOGGER.info("[GL] Using AMD_debug_output for error logging.");
             final AMDDebugOutputCallback proc = new AMDDebugOutputCallback((id, category, severity, message) -> {
                 logDebugMessageAMD(id, getCategoryAMD(category), getSeverityAMD(severity), message);
             });
@@ -136,35 +138,34 @@ public final class GLDebug {
             AMDDebugOutput.glDebugMessageCallbackAMD(proc);
             return 1;
         } else {
-            LOGGER.info("[GL] No debug output implementation is available, cannot return debug info.");
+            GLStateManager.LOGGER.info("[GL] No debug output implementation is available, cannot return debug info.");
             return 0;
         }
     }
 
-	public static int disableDebugMessages() {
-		if (GLStateManager.capabilities.OpenGL43) {
-			GL43.glDebugMessageCallback(null);
-			return 1;
-		} else if (GLStateManager.capabilities.GL_KHR_debug) {
-			KHRDebug.glDebugMessageCallback(null);
-			if (GLStateManager.capabilities.OpenGL30 && (GL11.glGetInteger(GL30.GL_CONTEXT_FLAGS) & 2) == 0) {
+    public static int disableDebugMessages() {
+        if (GLStateManager.capabilities.OpenGL43) {
+            GL43.glDebugMessageCallback(null);
+            return 1;
+        } else if (GLStateManager.capabilities.GL_KHR_debug) {
+            KHRDebug.glDebugMessageCallback(null);
+            if (GLStateManager.capabilities.OpenGL30 && (GL11.glGetInteger(GL30.GL_CONTEXT_FLAGS) & 2) == 0) {
                 GL11.glDisable(GL43.GL_DEBUG_OUTPUT);
-			}
-			return 1;
-		} else if (GLStateManager.capabilities.GL_ARB_debug_output) {
-			glDebugMessageCallbackARB(null);
-			return 1;
-		} else if (GLStateManager.capabilities.GL_AMD_debug_output) {
-			AMDDebugOutput.glDebugMessageCallbackAMD(null);
-			return 1;
-		} else {
-			LOGGER.info("[GL] No debug output implementation is available, cannot disable debug info.");
-			return 0;
-		}
-	}
+            }
+            return 1;
+        } else if (GLStateManager.capabilities.GL_ARB_debug_output) {
+            glDebugMessageCallbackARB(null);
+            return 1;
+        } else if (GLStateManager.capabilities.GL_AMD_debug_output) {
+            AMDDebugOutput.glDebugMessageCallbackAMD(null);
+            return 1;
+        } else {
+            GLStateManager.LOGGER.info("[GL] No debug output implementation is available, cannot disable debug info.");
+            return 0;
+        }
+    }
 
-
-	private static String getDebugSource(int source) {
+    private static String getDebugSource(int source) {
         return switch (source) {
             case GL43.GL_DEBUG_SOURCE_API -> "API";
             case GL43.GL_DEBUG_SOURCE_WINDOW_SYSTEM -> "WINDOW SYSTEM";
@@ -174,9 +175,9 @@ public final class GLDebug {
             case GL43.GL_DEBUG_SOURCE_OTHER -> "OTHER";
             default -> String.format("Unknown [0x%X]", source);
         };
-	}
+    }
 
-	private static String getDebugType(int type) {
+    private static String getDebugType(int type) {
         return switch (type) {
             case GL43.GL_DEBUG_TYPE_ERROR -> "ERROR";
             case GL43.GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR -> "DEPRECATED BEHAVIOR";
@@ -187,9 +188,9 @@ public final class GLDebug {
             case GL43.GL_DEBUG_TYPE_MARKER -> "MARKER";
             default -> String.format("Unknown [0x%X]", type);
         };
-	}
+    }
 
-	private static String getDebugSeverity(int severity) {
+    private static String getDebugSeverity(int severity) {
         return switch (severity) {
             case GL43.GL_DEBUG_SEVERITY_NOTIFICATION -> "NOTIFICATION";
             case GL43.GL_DEBUG_SEVERITY_HIGH -> "HIGH";
@@ -197,7 +198,7 @@ public final class GLDebug {
             case GL43.GL_DEBUG_SEVERITY_LOW -> "LOW";
             default -> String.format("Unknown [0x%X]", severity);
         };
-	}
+    }
 
     private static String getSourceARB(int source) {
         return switch (source) {
@@ -232,7 +233,7 @@ public final class GLDebug {
         };
     }
 
-	private static String getCategoryAMD(int category) {
+    private static String getCategoryAMD(int category) {
         return switch (category) {
             case AMDDebugOutput.GL_DEBUG_CATEGORY_API_ERROR_AMD -> "API ERROR";
             case AMDDebugOutput.GL_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD -> "WINDOW SYSTEM";
@@ -244,18 +245,18 @@ public final class GLDebug {
             case AMDDebugOutput.GL_DEBUG_CATEGORY_OTHER_AMD -> "OTHER";
             default -> String.format("Unknown [0x%X]", category);
         };
-	}
+    }
 
-	private static String getSeverityAMD(int severity) {
+    private static String getSeverityAMD(int severity) {
         return switch (severity) {
             case AMDDebugOutput.GL_DEBUG_SEVERITY_HIGH_AMD -> "HIGH";
             case AMDDebugOutput.GL_DEBUG_SEVERITY_MEDIUM_AMD -> "MEDIUM";
             case AMDDebugOutput.GL_DEBUG_SEVERITY_LOW_AMD -> "LOW";
             default -> String.format("Unknown [0x%X]", severity);
         };
-	}
+    }
 
-	public static String getMatrixModeName(int mode) {
+    public static String getMatrixModeName(int mode) {
         return switch (mode) {
             case GL11.GL_MODELVIEW -> "MODELVIEW";
             case GL11.GL_PROJECTION -> "PROJECTION";
@@ -263,9 +264,9 @@ public final class GLDebug {
             case GL11.GL_COLOR -> "COLOR";
             default -> String.format("0x%X", mode);
         };
-	}
+    }
 
-	public static String getCapabilityName(int cap) {
+    public static String getCapabilityName(int cap) {
         return switch (cap) {
             case GL11.GL_ALPHA_TEST -> "ALPHA_TEST";
             case GL11.GL_BLEND -> "BLEND";
@@ -295,9 +296,9 @@ public final class GLDebug {
             case GL11.GL_LIGHT7 -> "LIGHT7";
             default -> String.format("0x%X", cap);
         };
-	}
+    }
 
-	public static String getComparisonFuncName(int func) {
+    public static String getComparisonFuncName(int func) {
         return switch (func) {
             case GL11.GL_NEVER -> "NEVER";
             case GL11.GL_LESS -> "LESS";
@@ -309,9 +310,9 @@ public final class GLDebug {
             case GL11.GL_ALWAYS -> "ALWAYS";
             default -> String.format("0x%X", func);
         };
-	}
+    }
 
-	public static String getBlendFactorName(int factor) {
+    public static String getBlendFactorName(int factor) {
         return switch (factor) {
             case GL11.GL_ZERO -> "ZERO";
             case GL11.GL_ONE -> "ONE";
@@ -330,17 +331,17 @@ public final class GLDebug {
             case GL11.GL_SRC_ALPHA_SATURATE -> "SRC_ALPHA_SATURATE";
             default -> String.format("0x%X", factor);
         };
-	}
+    }
 
-	public static String getShadeModelName(int mode) {
+    public static String getShadeModelName(int mode) {
         return switch (mode) {
             case GL11.GL_FLAT -> "FLAT";
             case GL11.GL_SMOOTH -> "SMOOTH";
             default -> String.format("0x%X", mode);
         };
-	}
+    }
 
-	public static String getTextureTargetName(int target) {
+    public static String getTextureTargetName(int target) {
         return switch (target) {
             case GL11.GL_TEXTURE_1D -> "TEXTURE_1D";
             case GL11.GL_TEXTURE_2D -> "TEXTURE_2D";
@@ -348,9 +349,9 @@ public final class GLDebug {
             case GL13.GL_TEXTURE_CUBE_MAP -> "TEXTURE_CUBE_MAP";
             default -> String.format("0x%X", target);
         };
-	}
+    }
 
-	public static String getTexturePnameName(int pname) {
+    public static String getTexturePnameName(int pname) {
         return switch (pname) {
             case GL11.GL_TEXTURE_MIN_FILTER -> "TEXTURE_MIN_FILTER";
             case GL11.GL_TEXTURE_MAG_FILTER -> "TEXTURE_MAG_FILTER";
@@ -367,9 +368,9 @@ public final class GLDebug {
             case GL14.GL_GENERATE_MIPMAP -> "GENERATE_MIPMAP";
             default -> String.format("0x%X", pname);
         };
-	}
+    }
 
-	public static String getTextureFormatName(int format) {
+    public static String getTextureFormatName(int format) {
         return switch (format) {
             case GL11.GL_RED -> "RED";
             case GL11.GL_GREEN -> "GREEN";
@@ -392,9 +393,9 @@ public final class GLDebug {
             case GL11.GL_LUMINANCE8_ALPHA8 -> "LUMINANCE8_ALPHA8";
             default -> String.format("0x%X", format);
         };
-	}
+    }
 
-	public static String getDataTypeName(int type) {
+    public static String getDataTypeName(int type) {
         return switch (type) {
             case GL11.GL_UNSIGNED_BYTE -> "UNSIGNED_BYTE";
             case GL11.GL_BYTE -> "BYTE";
@@ -411,9 +412,9 @@ public final class GLDebug {
             case GL12.GL_UNSIGNED_INT_10_10_10_2 -> "UNSIGNED_INT_10_10_10_2";
             default -> String.format("0x%X", type);
         };
-	}
+    }
 
-	public static String getLightName(int light) {
+    public static String getLightName(int light) {
         return switch (light) {
             case GL11.GL_LIGHT0 -> "LIGHT0";
             case GL11.GL_LIGHT1 -> "LIGHT1";
@@ -425,9 +426,9 @@ public final class GLDebug {
             case GL11.GL_LIGHT7 -> "LIGHT7";
             default -> String.format("0x%X", light);
         };
-	}
+    }
 
-	public static String getLightPnameName(int pname) {
+    public static String getLightPnameName(int pname) {
         return switch (pname) {
             case GL11.GL_AMBIENT -> "AMBIENT";
             case GL11.GL_DIFFUSE -> "DIFFUSE";
@@ -441,9 +442,9 @@ public final class GLDebug {
             case GL11.GL_QUADRATIC_ATTENUATION -> "QUADRATIC_ATTENUATION";
             default -> String.format("0x%X", pname);
         };
-	}
+    }
 
-	public static String getMaterialPnameName(int pname) {
+    public static String getMaterialPnameName(int pname) {
         return switch (pname) {
             case GL11.GL_AMBIENT -> "AMBIENT";
             case GL11.GL_DIFFUSE -> "DIFFUSE";
@@ -454,18 +455,18 @@ public final class GLDebug {
             case GL11.GL_COLOR_INDEXES -> "COLOR_INDEXES";
             default -> String.format("0x%X", pname);
         };
-	}
+    }
 
-	public static String getFaceName(int face) {
+    public static String getFaceName(int face) {
         return switch (face) {
             case GL11.GL_FRONT -> "FRONT";
             case GL11.GL_BACK -> "BACK";
             case GL11.GL_FRONT_AND_BACK -> "FRONT_AND_BACK";
             default -> String.format("0x%X", face);
         };
-	}
+    }
 
-	public static String getColorMaterialModeName(int mode) {
+    public static String getColorMaterialModeName(int mode) {
         return switch (mode) {
             case GL11.GL_AMBIENT -> "AMBIENT";
             case GL11.GL_DIFFUSE -> "DIFFUSE";
@@ -474,9 +475,9 @@ public final class GLDebug {
             case GL11.GL_AMBIENT_AND_DIFFUSE -> "AMBIENT_AND_DIFFUSE";
             default -> String.format("0x%X", mode);
         };
-	}
+    }
 
-	public static String getFogPnameName(int pname) {
+    public static String getFogPnameName(int pname) {
         return switch (pname) {
             case GL11.GL_FOG_MODE -> "FOG_MODE";
             case GL11.GL_FOG_DENSITY -> "FOG_DENSITY";
@@ -486,9 +487,9 @@ public final class GLDebug {
             case GL11.GL_FOG_COLOR -> "FOG_COLOR";
             default -> String.format("0x%X", pname);
         };
-	}
+    }
 
-	public static String getLightModelPnameName(int pname) {
+    public static String getLightModelPnameName(int pname) {
         return switch (pname) {
             case GL11.GL_LIGHT_MODEL_AMBIENT -> "LIGHT_MODEL_AMBIENT";
             case GL11.GL_LIGHT_MODEL_LOCAL_VIEWER -> "LIGHT_MODEL_LOCAL_VIEWER";
@@ -496,9 +497,9 @@ public final class GLDebug {
             case GL12.GL_LIGHT_MODEL_COLOR_CONTROL -> "LIGHT_MODEL_COLOR_CONTROL";
             default -> String.format("0x%X", pname);
         };
-	}
+    }
 
-	public static String getClearMaskString(int mask) {
+    public static String getClearMaskString(int mask) {
         StringBuilder sb = new StringBuilder();
         boolean first = true;
         if ((mask & GL11.GL_COLOR_BUFFER_BIT) != 0) {
@@ -520,18 +521,18 @@ public final class GLDebug {
             sb.append("ACCUM");
         }
         return sb.toString();
-	}
+    }
 
-	public static String getCullFaceName(int mode) {
+    public static String getCullFaceName(int mode) {
         return switch (mode) {
             case GL11.GL_FRONT -> "FRONT";
             case GL11.GL_BACK -> "BACK";
             case GL11.GL_FRONT_AND_BACK -> "FRONT_AND_BACK";
             default -> String.format("0x%X", mode);
         };
-	}
+    }
 
-	public static String getLogicOpName(int opcode) {
+    public static String getLogicOpName(int opcode) {
         return switch (opcode) {
             case GL11.GL_CLEAR -> "CLEAR";
             case GL11.GL_AND -> "AND";
@@ -551,9 +552,9 @@ public final class GLDebug {
             case GL11.GL_SET -> "SET";
             default -> String.format("0x%X", opcode);
         };
-	}
+    }
 
-	public static String getFramebufferStatusName(int status) {
+    public static String getFramebufferStatusName(int status) {
         return switch (status) {
             case GL30.GL_FRAMEBUFFER_COMPLETE -> "COMPLETE";
             case GL30.GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT -> "INCOMPLETE_ATTACHMENT";
@@ -565,9 +566,9 @@ public final class GLDebug {
             case 0 -> "NO_FRAMEBUFFER_BOUND";
             default -> String.format("UNKNOWN(0x%X)", status);
         };
-	}
+    }
 
-	public static String getInternalFormatName(int format) {
+    public static String getInternalFormatName(int format) {
         return switch (format) {
             // Basic
             case GL11.GL_RGBA -> "RGBA";
@@ -602,33 +603,38 @@ public final class GLDebug {
             case GL11.GL_RGB10_A2 -> "RGB10_A2";
             default -> String.format("0x%X", format);
         };
-	}
+    }
 
-	private static DebugState debugState;
+    private static DebugState debugState;
 
     private interface DebugState {
-		void nameObject(int id, int object, String name);
-		void pushGroup(String name);
-		void popGroup();
+
+        void nameObject(int id, int object, String name);
+
+        void pushGroup(String name);
+
+        void popGroup();
+
         void debugMessage(String name);
 
         String getObjectLabel(int glProgram, int program);
     }
 
-	private static class KHRDebugState implements DebugState {
+    private static class KHRDebugState implements DebugState {
+
         private static final int ID = 0;
-		private int depth = 0;
+        private int depth = 0;
         private static final int maxDepth = GL11.glGetInteger(KHRDebug.GL_MAX_DEBUG_GROUP_STACK_DEPTH);
         private static final int maxNameLength = GL11.glGetInteger(KHRDebug.GL_MAX_LABEL_LENGTH);
         private final String[] groupStack = new String[maxDepth + 1];
 
-		@Override
-		public void nameObject(int id, int object, String name) {
-			KHRDebug.glObjectLabel(id, object, name);
-		}
+        @Override
+        public void nameObject(int id, int object, String name) {
+            KHRDebug.glObjectLabel(id, object, name);
+        }
 
-		@Override
-		public void pushGroup(String name) {
+        @Override
+        public void pushGroup(String name) {
             if (depth + 1 > maxDepth) {
                 final StringBuilder sb = new StringBuilder();
                 sb.append("Debug group stack overflow (maxDepth=").append(maxDepth).append("), current stack:\n");
@@ -639,46 +645,51 @@ public final class GLDebug {
                 throw new RuntimeException(sb.toString());
             }
             groupStack[depth] = name;
-			KHRDebug.glPushDebugGroup(KHRDebug.GL_DEBUG_SOURCE_APPLICATION, ID, name);
+            KHRDebug.glPushDebugGroup(KHRDebug.GL_DEBUG_SOURCE_APPLICATION, ID, name);
             depth++;
-		}
+        }
 
-		@Override
-		public void popGroup() {
+        @Override
+        public void popGroup() {
             if (depth - 1 < 0) {
                 throw new RuntimeException("Stack underflow");
             }
             KHRDebug.glPopDebugGroup();
             depth--;
             groupStack[depth] = null;
-		}
+        }
 
         @Override
         public void debugMessage(String message) {
-            KHRDebug.glDebugMessageInsert(KHRDebug.GL_DEBUG_SOURCE_APPLICATION, KHRDebug.GL_DEBUG_TYPE_MARKER, ID, KHRDebug.GL_DEBUG_SEVERITY_NOTIFICATION, message);
+            KHRDebug.glDebugMessageInsert(
+                    KHRDebug.GL_DEBUG_SOURCE_APPLICATION,
+                    KHRDebug.GL_DEBUG_TYPE_MARKER,
+                    ID,
+                    KHRDebug.GL_DEBUG_SEVERITY_NOTIFICATION,
+                    message);
         }
 
         @Override
         public String getObjectLabel(int glProgram, int program) {
-            if(program == 0)
-                return "";
+            if (program == 0) return "";
 
             return KHRDebug.glGetObjectLabel(glProgram, program, maxNameLength);
         }
     }
 
-	private static class UnsupportedDebugState implements DebugState {
-		@Override
-		public void nameObject(int id, int object, String name) {
-		}
+    private static class UnsupportedDebugState implements DebugState {
 
-		@Override
-		public void pushGroup(String name) {
-		}
+        @Override
+        public void nameObject(int id, int object, String name) {
+        }
 
-		@Override
-		public void popGroup() {
-		}
+        @Override
+        public void pushGroup(String name) {
+        }
+
+        @Override
+        public void popGroup() {
+        }
 
         @Override
         public void debugMessage(String name) {
@@ -691,40 +702,43 @@ public final class GLDebug {
         }
     }
 
-	public static void initDebugState() {
-		if (GLStateManager.capabilities.GL_KHR_debug || GLStateManager.capabilities.OpenGL43) {
-			debugState = new KHRDebugState();
-		} else {
-			debugState = new UnsupportedDebugState();
-		}
-	}
+    public static void initDebugState() {
+        if (GLStateManager.capabilities.GL_KHR_debug || GLStateManager.capabilities.OpenGL43) {
+            debugState = new KHRDebugState();
+        } else {
+            debugState = new UnsupportedDebugState();
+        }
+    }
 
     public static void nameObject(int id, int object, String name) {
-        if(debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
+        if (debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
             debugState.nameObject(id, object, name);
         }
     }
+
     public static void pushGroup(String group) {
-        if(debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
+        if (debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
             debugState.pushGroup(group);
         }
     }
+
     public static void popGroup() {
-        if(debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
+        if (debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
             debugState.popGroup();
         }
     }
+
     public static void debugMessage(String message) {
-        if(debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
+        if (debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
             debugState.debugMessage(message);
         }
     }
+
     public static String getObjectLabel(int glProgram, int program) {
-        if(debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
+        if (debugState != null && Thread.currentThread() == GLStateManager.getMainThread()) {
             return debugState.getObjectLabel(glProgram, program);
         }
         return "";
     }
 
-
 }

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

@@ -0,0 +1,550 @@
+package com.gtnewhorizons.angelica.glsm;
+
+import com.gtnewhorizons.angelica.glsm.dsa.DSAARB;
+import com.gtnewhorizons.angelica.glsm.dsa.DSAAccess;
+import com.gtnewhorizons.angelica.glsm.dsa.DSACore;
+import com.gtnewhorizons.angelica.glsm.dsa.DSAEXT;
+import com.gtnewhorizons.angelica.glsm.dsa.DSAUnsupported;
+import com.gtnewhorizons.angelica.glsm.ffp.ShaderManager;
+import com.gtnewhorizons.angelica.glsm.texture.TextureInfoCache;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Matrix4f;
+import org.joml.Vector3i;
+import org.lwjgl.BufferUtils;
+import org.lwjgl.opengl.ARBBufferStorage;
+import org.lwjgl.opengl.ARBClearBufferObject;
+import org.lwjgl.opengl.ARBClearTexture;
+import org.lwjgl.opengl.ARBShaderImageLoadStore;
+import org.lwjgl.opengl.ARBShaderStorageBufferObject;
+import org.lwjgl.opengl.EXTShaderImageLoadStore;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL12;
+import org.lwjgl.opengl.GL15;
+import org.lwjgl.opengl.GL20;
+import org.lwjgl.opengl.GL30;
+import org.lwjgl.opengl.GL32;
+import org.lwjgl.opengl.GL33;
+import org.lwjgl.opengl.GL40;
+import org.lwjgl.opengl.GL42;
+import org.lwjgl.opengl.GL43;
+import org.lwjgl.opengl.GL44;
+import org.lwjgl.opengl.NVXGpuMemoryInfo;
+
+import java.nio.ByteBuffer;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.util.Objects;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * This class is responsible for abstracting calls to OpenGL and asserting that calls are run on the render thread.
+ */
+public class RenderSystem {
+    private static DSAAccess dsaState;
+    private static boolean supportsCompute;
+    private static boolean supportsImageLoadStore;
+    private static boolean supportsSSBO;
+    private static boolean supportsBufferStorage;
+    private static boolean supportsClearTexture;
+    private static boolean supportsTesselation;
+    private static boolean supportsSamplerObjects;
+    private static int maxImageUnits;
+    private static int maxSSBOBindings;
+    private static int maxGlslVersion;
+    private static boolean supportsGpuShader4;
+
+    // Sampler object state tracking (null if unsupported)
+    private static int[] samplers;
+
+    private static final Pattern SEMVER_PATTERN = Pattern.compile("(?<major>\\d+)\\.(?<minor>\\d+)\\.*(?<bugfix>\\d*)(.*)");
+
+    private RenderSystem() {}
+
+    public static void initRenderer() {
+        try {
+            if (GLStateManager.capabilities.OpenGL45) {
+                dsaState = (Runtime.version().feature() > 8 && GLStateManager.capabilities.GL_EXT_direct_state_access) ? new DSAEXT() : new DSACore();
+                GLStateManager.LOGGER.info("OpenGL 4.5 detected, enabling DSA.");
+            }
+
+        } catch (NoSuchFieldError ignored) {
+        }
+        try {
+            if (dsaState == null && GLStateManager.capabilities.GL_ARB_direct_state_access) {
+                dsaState = new DSAARB();
+                GLStateManager.LOGGER.info("ARB_direct_state_access detected, enabling DSA.");
+            }
+        } catch (NoSuchFieldError ignored) {
+        }
+        if (dsaState == null) {
+            dsaState = new DSAUnsupported();
+            GLStateManager.LOGGER.info("No DSA support detected, falling back to legacy OpenGL.");
+        }
+
+        supportsCompute = supportsCompute();
+        supportsTesselation = GLStateManager.capabilities.GL_ARB_tessellation_shader || GLStateManager.capabilities.OpenGL40;
+
+        supportsImageLoadStore = GLStateManager.capabilities.OpenGL42
+                || GLStateManager.capabilities.GL_ARB_shader_image_load_store
+                || GLStateManager.capabilities.GL_EXT_shader_image_load_store;
+        supportsSSBO = GLStateManager.capabilities.OpenGL43 || GLStateManager.capabilities.GL_ARB_shader_storage_buffer_object;
+        supportsBufferStorage = GLStateManager.capabilities.OpenGL44 || GLStateManager.capabilities.GL_ARB_buffer_storage;
+        supportsClearTexture = GLStateManager.capabilities.OpenGL44 || GLStateManager.capabilities.GL_ARB_clear_texture;
+
+        // Cache maximum image units
+        if (supportsImageLoadStore) {
+            if (GLStateManager.capabilities.OpenGL42) {
+                maxImageUnits = GL11.glGetInteger(GL42.GL_MAX_IMAGE_UNITS);
+            } else if (GLStateManager.capabilities.GL_ARB_shader_image_load_store) {
+                maxImageUnits = GL11.glGetInteger(ARBShaderImageLoadStore.GL_MAX_IMAGE_UNITS);
+            } else {
+                maxImageUnits = GL11.glGetInteger(EXTShaderImageLoadStore.GL_MAX_IMAGE_UNITS_EXT);
+            }
+        } else {
+            maxImageUnits = 0;
+        }
+
+        // Cache maximum SSBO bindings
+        if (supportsSSBO) {
+            if (GLStateManager.capabilities.OpenGL43) {
+                maxSSBOBindings = GL11.glGetInteger(GL43.GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS);
+            } else {
+                maxSSBOBindings = GL11.glGetInteger(ARBShaderStorageBufferObject.GL_MAX_SHADER_STORAGE_BUFFER_BINDINGS);
+            }
+        } else {
+            maxSSBOBindings = 0;
+        }
+
+        // Check for sampler objects support (GL 3.3+ or ARB extension)
+        supportsSamplerObjects = GLStateManager.capabilities.OpenGL33 || GLStateManager.capabilities.GL_ARB_sampler_objects;
+        if (supportsSamplerObjects) {
+            samplers = new int[GL11.glGetInteger(GL20.GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS)];
+        }
+
+        maxGlslVersion = Integer.parseInt(parseGlVersionString(GL11.glGetString(GL20.GL_SHADING_LANGUAGE_VERSION)));
+        supportsGpuShader4 = GLStateManager.capabilities.GL_EXT_gpu_shader4;
+
+        GLStateManager.LOGGER.info("Max GLSL version: {}, GPU Shader4: {}", maxGlslVersion, supportsGpuShader4);
+        GLStateManager.LOGGER.info("Image Load/Store: {}, Max Image Units: {}", supportsImageLoadStore, maxImageUnits);
+        GLStateManager.LOGGER.info("SSBO: {}, Max SSBO Bindings: {}", supportsSSBO, maxSSBOBindings);
+        GLStateManager.LOGGER.info("Buffer Storage: {}, Clear Texture: {}, Sampler Objects: {}", supportsBufferStorage, supportsClearTexture, supportsSamplerObjects);
+
+        if (GLStateManager.capabilities.OpenGL32) {
+            final int profileMask = GL11.glGetInteger(GL32.GL_CONTEXT_PROFILE_MASK);
+            if ((profileMask & GL32.GL_CONTEXT_CORE_PROFILE_BIT) != 0) {
+                GLStateManager.LOGGER.info("GL 3.3 core profile detected, enabling FFP shader emulation.");
+                ShaderManager.getInstance().enable();
+            }
+        }
+    }
+
+    public static void generateMipmaps(int texture, int mipmapTarget) {
+        dsaState.generateMipmaps(texture, mipmapTarget);
+    }
+
+    public static void bindAttributeLocation(int program, int index, CharSequence name) {
+        GL20.glBindAttribLocation(program, index, name);
+    }
+
+    public static void texImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, @Nullable ByteBuffer pixels) {
+        GLStateManager.glBindTexture(target, texture);
+        GL11.glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+        if (target == GL11.GL_TEXTURE_2D && level == 0) {
+            TextureInfoCache.INSTANCE.onTexImage2D(target, level, internalformat, width, height, border, format, type, pixels);
+        }
+    }
+
+    public static void uniformMatrix4fv(int location, boolean transpose, FloatBuffer matrix) {
+        GL20.glUniformMatrix4(location, transpose, matrix);
+    }
+
+    public static void copyTexImage2D(int target, int level, int internalFormat, int x, int y, int width, int height, int border) {
+        GLStateManager.glCopyTexImage2D(target, level, internalFormat, x, y, width, height, border);
+    }
+
+    public static void uniform1f(int location, float v0) {
+        GL20.glUniform1f(location, v0);
+    }
+
+    public static void uniform1i(int location, int v0) {
+        GL20.glUniform1i(location, v0);
+    }
+
+    public static void uniform2f(int location, float v0, float v1) {
+        GL20.glUniform2f(location, v0, v1);
+    }
+
+    public static void uniform2i(int location, int v0, int v1) {
+        GL20.glUniform2i(location, v0, v1);
+    }
+
+    public static void uniform3f(int location, float v0, float v1, float v2) {
+        GL20.glUniform3f(location, v0, v1, v2);
+    }
+
+    public static void uniform3i(int location, int v0, int v1, int v2) {GL20.glUniform3i(location, v0, v1, v2);}
+
+    public static void uniform4f(int location, float v0, float v1, float v2, float v3) {
+        GL20.glUniform4f(location, v0, v1, v2, v3);
+    }
+
+    public static void uniform4i(int location, int v0, int v1, int v2, int v3) {
+        GL20.glUniform4i(location, v0, v1, v2, v3);
+    }
+
+    public static int getAttribLocation(int programId, String name) {
+        return GL20.glGetAttribLocation(programId, name);
+    }
+
+    public static int getUniformLocation(int programId, String name) {
+        return GL20.glGetUniformLocation(programId, name);
+    }
+
+    public static void texParameteriv(int texture, int target, int pname, IntBuffer params) {
+        dsaState.texParameteriv(texture, target, pname, params);
+    }
+
+    public static void copyTexSubImage2D(int destTexture, int target, int i, int i1, int i2, int i3, int i4, int width, int height) {
+        dsaState.copyTexSubImage2D(destTexture, target, i, i1, i2, i3, i4, width, height);
+    }
+
+    public static void texParameteri(int texture, int target, int pname, int param) {
+        dsaState.texParameteri(texture, target, pname, param);
+    }
+
+    public static void texParameterf(int texture, int target, int pname, float param) {
+        dsaState.texParameterf(texture, target, pname, param);
+    }
+
+    public static void textureImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, ByteBuffer pixels) {
+        dsaState.textureImage2D(texture, target, level, internalformat, width, height, border, format, type, pixels);
+    }
+
+    public static void textureImage2D(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, IntBuffer pixels) {
+        dsaState.textureImage2D(texture, target, level, internalformat, width, height, border, format, type, pixels);
+    }
+
+    public static void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, ByteBuffer pixels) {
+        dsaState.textureSubImage2D(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
+    }
+
+    public static void textureSubImage2D(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, IntBuffer pixels) {
+        dsaState.textureSubImage2D(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
+    }
+
+    public static void texImage1D(int texture, int target, int level, int internalformat, int width, int border, int format, int type, ByteBuffer pixels) {
+        GL11.glBindTexture(target, texture);
+        GL11.glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
+    }
+
+    public static void texImage3D(int texture, int target, int level, int internalformat, int width, int height, int depth, int border, int format, int type, ByteBuffer pixels) {
+        GL11.glBindTexture(target, texture);
+        GL12.glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
+    }
+
+    public static String getProgramInfoLog(int program) {
+        return GL20.glGetProgramInfoLog(program, GL20.glGetProgrami(program, GL20.GL_INFO_LOG_LENGTH));
+    }
+
+    public static String getShaderInfoLog(int shader) {
+        return GL20.glGetShaderInfoLog(shader, GL20.glGetShaderi(shader, GL20.GL_INFO_LOG_LENGTH));
+    }
+
+    public static void drawBuffers(int framebuffer, IntBuffer buffers) {
+        dsaState.drawBuffers(framebuffer, buffers);
+    }
+
+    public static void readBuffer(int framebuffer, int buffer) {
+        dsaState.readBuffer(framebuffer, buffer);
+    }
+
+    public static String getActiveUniform(int program, int index, int maxLength, IntBuffer sizeType) {
+        return GL20.glGetActiveUniform(program, index, maxLength, sizeType);
+    }
+
+    public static void readPixels(int x, int y, int width, int height, int format, int type, FloatBuffer pixels) {
+        GL11.glReadPixels(x, y, width, height, format, type, pixels);
+    }
+
+    public static void bufferData(int target, FloatBuffer data, int usage) {
+        GL15.glBufferData(target, data, usage);
+    }
+
+    public static int bufferStorage(int target, FloatBuffer data, int usage) {
+        return dsaState.bufferStorage(target, data, usage);
+    }
+
+    public static void vertexAttrib4f(int index, float v0, float v1, float v2, float v3) {
+        GL20.glVertexAttrib4f(index, v0, v1, v2, v3);
+    }
+
+    public static void detachShader(int program, int shader) {
+        GL20.glDetachShader(program, shader);
+    }
+
+    public static void framebufferTexture2D(int fb, int fbtarget, int attachment, int target, int texture, int levels) {
+        dsaState.framebufferTexture2D(fb, fbtarget, attachment, target, texture, levels);
+    }
+
+    public static int getTexParameteri(int texture, int target, int pname) {
+        return dsaState.getTexParameteri(texture, target, pname);
+    }
+
+    public static int getTexLevelParameteri(int texture, int level, int pname) {
+        return dsaState.getTexLevelParameteri(texture, level, pname);
+    }
+
+    public static void bindImageTexture(int unit, int texture, int level, boolean layered, int layer, int access, int format) {
+        if (GLStateManager.capabilities.OpenGL42) {
+            GL42.glBindImageTexture(unit, texture, level, layered, layer, access, format);
+        } else {
+            EXTShaderImageLoadStore.glBindImageTextureEXT(unit, texture, level, layered, layer, access, format);
+        }
+    }
+
+    public static int getMaxImageUnits() {
+        return maxImageUnits;
+    }
+
+    public static boolean supportsImageLoadStore() {
+        return supportsImageLoadStore;
+    }
+
+    public static boolean supportsSSBO() {
+        return supportsSSBO;
+    }
+
+    public static boolean supportsBufferStorage() {
+        return supportsBufferStorage;
+    }
+
+    public static boolean supportsClearTexture() {
+        return supportsClearTexture;
+    }
+
+    public static int getMaxSSBOBindings() {
+        return maxSSBOBindings;
+    }
+
+    public static void getProgramiv(int program, int value, IntBuffer storage) {
+        GL20.glGetProgram(program, value, storage);
+    }
+
+    public static void dispatchCompute(int workX, int workY, int workZ) {
+        GL43.glDispatchCompute(workX, workY, workZ);
+    }
+
+    public static void dispatchCompute(Vector3i workGroups) {
+        GL43.glDispatchCompute(workGroups.x, workGroups.y, workGroups.z);
+    }
+
+    public static void dispatchComputeIndirect(long offset) {
+        GL43.glDispatchComputeIndirect(offset);
+    }
+
+    public static void bindBuffer(int target, int buffer) {
+        GLStateManager.glBindBuffer(target, buffer);
+    }
+
+    public static void memoryBarrier(int barriers) {
+        if (supportsCompute) {
+            GL42.glMemoryBarrier(barriers);
+        }
+    }
+
+    public static boolean supportsBufferBlending() {
+        return GLStateManager.capabilities.GL_ARB_draw_buffers_blend || GLStateManager.capabilities.OpenGL40;
+    }
+
+    public static void disableBufferBlend(int buffer) {
+        GL30.glDisablei(GL11.GL_BLEND, buffer);
+        GLStateManager.getBlendMode().setUnknownState();
+    }
+
+    public static void enableBufferBlend(int buffer) {
+        GL30.glEnablei(GL11.GL_BLEND, buffer);
+        GLStateManager.getBlendMode().setUnknownState();
+    }
+
+    public static void blendFuncSeparatei(int buffer, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha) {
+        GL40.glBlendFuncSeparatei(buffer, srcRGB, dstRGB, srcAlpha, dstAlpha);
+    }
+
+    public static void bindTextureToUnit(int unit, int texture) {
+        dsaState.bindTextureToUnit(unit, texture);
+    }
+
+    public static void bindTextureToUnit(int target, int unit, int texture) {
+        dsaState.bindTextureToUnit(target, unit, texture);
+    }
+
+    public static final FloatBuffer PROJECTION_MATRIX_BUFFER = BufferUtils.createFloatBuffer(16);
+
+    public static void setupProjectionMatrix(Matrix4f matrix) {
+        GLStateManager.glMatrixMode(GL11.GL_PROJECTION);
+        GLStateManager.glPushMatrix();
+        matrix.get(0, PROJECTION_MATRIX_BUFFER);
+        GLStateManager.glLoadMatrix(PROJECTION_MATRIX_BUFFER);
+        GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+    }
+
+    public static void restoreProjectionMatrix() {
+        GLStateManager.glMatrixMode(GL11.GL_PROJECTION);
+        GLStateManager.glPopMatrix();
+        GLStateManager.glMatrixMode(GL11.GL_MODELVIEW);
+    }
+
+    public static void blitFramebuffer(int source, int dest, int offsetX, int offsetY, int width, int height, int offsetX2, int offsetY2, int width2,
+            int height2, int bufferChoice, int filter) {
+        dsaState.blitFramebuffer(source, dest, offsetX, offsetY, width, height, offsetX2, offsetY2, width2, height2, bufferChoice, filter);
+    }
+
+    public static int createFramebuffer() {
+        return dsaState.createFramebuffer();
+    }
+
+    public static int createTexture(int target) {
+        return dsaState.createTexture(target);
+    }
+
+    // TODO: Proper notification of compute support
+    public static boolean supportsCompute() {
+        try {
+            return GLStateManager.capabilities.GL_ARB_compute_shader;
+        } catch (Exception ignored) {
+            return false;
+        }
+    }
+
+    public static int createBuffers() {
+        return GL15.glGenBuffers();
+    }
+
+    public static void bindBufferBase(int target, int index, int buffer) {
+        GL30.glBindBufferBase(target, index, buffer);
+    }
+
+    public static void bufferStorage(int target, long size, int flags) {
+        if (GLStateManager.capabilities.OpenGL44) {
+            GL44.glBufferStorage(target, size, flags);
+        } else if (GLStateManager.capabilities.GL_ARB_buffer_storage) {
+            ARBBufferStorage.glBufferStorage(target, size, flags);
+        } else {
+            // Fallback: use mutable storage
+            GL15.glBufferData(target, size, GL15.GL_DYNAMIC_DRAW);
+        }
+    }
+
+    public static void clearBufferSubData(int target, int internalFormat, long offset, long size, int format, int type, int[] data) {
+        final ByteBuffer buf = BufferUtils.createByteBuffer(data.length * 4);
+        buf.asIntBuffer().put(data);
+        if (GLStateManager.capabilities.OpenGL43) {
+            GL43.glClearBufferSubData(target, internalFormat, offset, size, format, type, buf);
+        } else if (GLStateManager.capabilities.GL_ARB_clear_buffer_object) {
+            ARBClearBufferObject.glClearBufferSubData(target, internalFormat, offset, size, format, type, buf);
+        }
+    }
+
+    public static void deleteBuffers(int buffer) {
+        GL15.glDeleteBuffers(buffer);
+    }
+
+    public static long getVRAM() {
+        if (GLStateManager.capabilities.GL_NVX_gpu_memory_info) {
+            return GL11.glGetInteger(NVXGpuMemoryInfo.GL_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX) * 1024L;
+        } else {
+            // Default to 4GB if we can't query VRAM
+            return 4294967296L;
+        }
+    }
+
+    public static void clearTexImage(int texture, int target, int level, int format, int type) {
+        if (GLStateManager.capabilities.OpenGL44) {
+            GL44.glClearTexImage(texture, level, format, type, (ByteBuffer) null);
+        } else {
+            ARBClearTexture.glClearTexImage(texture, level, format, type, (ByteBuffer) null);
+        }
+    }
+
+    public static void textureStorage1D(int texture, int target, int levels, int internalFormat, int width) {
+        dsaState.textureStorage1D(texture, target, levels, internalFormat, width);
+    }
+
+    public static void textureStorage2D(int texture, int target, int levels, int internalFormat, int width, int height) {
+        dsaState.textureStorage2D(texture, target, levels, internalFormat, width, height);
+    }
+
+    public static void textureStorage3D(int texture, int target, int levels, int internalFormat, int width, int height, int depth) {
+        dsaState.textureStorage3D(texture, target, levels, internalFormat, width, height, depth);
+    }
+
+    public static int getMaxGlslVersion() {
+        return maxGlslVersion;
+    }
+
+    public static boolean supportsGpuShader4() {
+        return supportsGpuShader4;
+    }
+
+    public static boolean supportsSnormFormats() {
+        return GLStateManager.capabilities.OpenGL31;
+    }
+
+    public static boolean supportsPackedFloatRenderable() {
+        return GLStateManager.capabilities.OpenGL30 && maxGlslVersion >= 130;
+    }
+
+    public static boolean supportsTesselation() {
+        return supportsTesselation;
+    }
+
+    public static boolean supportsSamplerObjects() {
+        return supportsSamplerObjects;
+    }
+
+    public static int genSampler() {
+        if (!supportsSamplerObjects) return 0;
+        return GL33.glGenSamplers();
+    }
+
+    public static void destroySampler(int sampler) {
+        if (!supportsSamplerObjects || sampler == 0) return;
+        GL33.glDeleteSamplers(sampler);
+    }
+
+    public static void samplerParameteri(int sampler, int pname, int param) {
+        if (!supportsSamplerObjects || sampler == 0) return;
+        GL33.glSamplerParameteri(sampler, pname, param);
+    }
+
+    public static void bindSamplerToUnit(int unit, int sampler) {
+        if (!supportsSamplerObjects) return;
+        if (samplers[unit] == sampler) return;
+        GL33.glBindSampler(unit, sampler);
+        samplers[unit] = sampler;
+    }
+
+    public static void unbindAllSamplers() {
+        if (!supportsSamplerObjects) return;
+        for (int i = 0; i < samplers.length; i++) {
+            if (samplers[i] != 0) {
+                GL33.glBindSampler(i, 0);
+                samplers[i] = 0;
+            }
+        }
+    }
+
+    /** Parse a GL version string (e.g. "4.6.0 NVIDIA ...") into concatenated digits "460". Inlined from StandardMacros.getGlVersion(). */
+    static String parseGlVersionString(String info) {
+        final Matcher matcher = SEMVER_PATTERN.matcher(Objects.requireNonNull(info));
+        if (!matcher.matches()) {
+            throw new IllegalStateException("Could not parse GL version from \"" + info + "\"");
+        }
+        final String major = matcher.group("major");
+        final String minor = matcher.group("minor");
+        String bugfix = matcher.group("bugfix");
+        if (bugfix == null || bugfix.isEmpty()) bugfix = "0";
+        return major + minor + bugfix;
+    }
+}

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

@@ -2,8 +2,6 @@ package com.gtnewhorizons.angelica.glsm;
 
 import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
 import com.gtnewhorizons.angelica.glsm.recording.commands.MultMatrixCmd;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.joml.Matrix4f;
 
 import java.util.ArrayDeque;
@@ -20,8 +18,6 @@ import java.util.List;
  * </ul>
  */
 class TransformOptimizer {
-    private static final Logger LOGGER = LogManager.getLogger("TransformOptimizer");
-
     private final Matrix4f accumulated = new Matrix4f();  // Current accumulated transform
     private final Matrix4f lastEmitted = new Matrix4f();  // Last emitted transform
     private final Deque<Matrix4f> stack = new ArrayDeque<>();  // For Push/Pop
@@ -53,7 +49,7 @@ class TransformOptimizer {
             // After Pop, GL state is restored to the pushed value so lastEmitted should also reflect this
             lastEmitted.set(accumulated);
         } else {
-            LOGGER.warn("[TransformOptimizer] list={} Pop with empty stack - resetting to identity", listId);
+            GLStateManager.LOGGER.warn("[TransformOptimizer] list={} Pop with empty stack - resetting to identity", listId);
             accumulated.identity();
             lastEmitted.identity();
         }

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/compat/lwjgl/AngelicaPartialDisk.java

@@ -3,7 +3,6 @@ package com.gtnewhorizons.angelica.glsm.compat.lwjgl;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import org.lwjgl.util.glu.PartialDisk;
 
-import static com.gtnewhorizons.angelica.loading.AngelicaTweaker.LOGGER;
 import static org.lwjgl.opengl.GL11.GL_LINE_STRIP;
 import static org.lwjgl.opengl.GL11.GL_POINTS;
 import static org.lwjgl.opengl.GL11.GL_TRIANGLE_FAN;
@@ -35,7 +34,7 @@ public class AngelicaPartialDisk extends PartialDisk {
 
         if (slices >= CACHE_SIZE) slices = CACHE_SIZE - 1;
         if (slices < 2 || loops < 1 || outerRadius <= 0.0f || innerRadius < 0.0f || innerRadius > outerRadius) {
-            LOGGER.warn("PartialDisk: GLU_INVALID_VALUE (slices={}, loops={}, innerRadius={}, outerRadius={})", slices, loops, innerRadius, outerRadius);
+            GLStateManager.LOGGER.warn("PartialDisk: GLU_INVALID_VALUE (slices={}, loops={}, innerRadius={}, outerRadius={})", slices, loops, innerRadius, outerRadius);
             return;
         }
 

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

@@ -4,8 +4,6 @@ import java.util.Arrays;
 
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.states.TexEnvState;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL12;
 import org.lwjgl.opengl.GL13;
@@ -34,8 +32,6 @@ import org.lwjgl.opengl.GL13;
  *   42-46: arg2 Alpha
  */
 public final class FragmentKey {
-    private static final Logger LOGGER = LogManager.getLogger("FragmentKey");
-
     public static final int TEX_ENV_MODULATE = 0;
     public static final int TEX_ENV_REPLACE  = 1;
     public static final int TEX_ENV_ADD      = 2;
@@ -297,7 +293,7 @@ public final class FragmentKey {
             case GL13.GL_PRIMARY_COLOR -> SRC_PRIMARY_COLOR;
             case GL13.GL_PREVIOUS      -> SRC_PREVIOUS;
             default -> {
-                LOGGER.debug("Unknown TexEnv source 0x{}, falling back to SRC_PREVIOUS", Integer.toHexString(glSource));
+                GLStateManager.LOGGER.debug("Unknown TexEnv source 0x{}, falling back to SRC_PREVIOUS", Integer.toHexString(glSource));
                 yield SRC_PREVIOUS;
             }
         };

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

@@ -4,8 +4,6 @@ import com.gtnewhorizons.angelica.glsm.GLDebug;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.RenderSystem;
 import lombok.Getter;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL20;
 import org.lwjgl.opengl.GL32;
@@ -20,7 +18,6 @@ import java.util.concurrent.atomic.AtomicInteger;
  */
 public class Program {
 
-    private static final Logger LOGGER = LogManager.getLogger("FFPProgram");
     private static final AtomicInteger PROGRAM_COUNTER = new AtomicInteger();
 
     @Getter private final int programId;
@@ -206,7 +203,7 @@ public class Program {
 
             final String log = RenderSystem.getProgramInfoLog(program);
             if (!log.isEmpty()) {
-                LOGGER.warn("FFP program link log (vk=0x{}, fk={}): {}", vkHex, fk, log);
+                GLStateManager.LOGGER.warn("FFP program link log (vk=0x{}, fk={}): {}", vkHex, fk, log);
             }
 
             if (GL20.glGetProgrami(program, GL20.GL_LINK_STATUS) != GL11.GL_TRUE) {
@@ -258,12 +255,12 @@ public class Program {
 
         final String log = RenderSystem.getShaderInfoLog(shader);
         if (!log.isEmpty()) {
-            LOGGER.warn("FFP {} shader compilation log for {}: {}", typeName, name, log);
+            GLStateManager.LOGGER.warn("FFP {} shader compilation log for {}: {}", typeName, name, log);
         }
 
         final int result = GL20.glGetShaderi(shader, GL20.GL_COMPILE_STATUS);
         if (result != GL11.GL_TRUE) {
-            LOGGER.error("FFP {} shader source:\n{}", typeName, src);
+            GLStateManager.LOGGER.error("FFP {} shader source:\n{}", typeName, src);
             GL20.glDeleteShader(shader);
             throw new RuntimeException("FFP " + typeName + " shader compilation failed for " + name + ": " + log);
         }

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

@@ -2,8 +2,7 @@ package com.gtnewhorizons.angelica.glsm.ffp;
 
 import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
 import lombok.Setter;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
 
 import java.io.IOException;
 import java.nio.charset.StandardCharsets;
@@ -26,7 +25,6 @@ import java.util.IdentityHashMap;
  * </pre>
  */
 public class ShaderCache {
-    private static final Logger LOGGER = LogManager.getLogger("FFPShaderCache");
     private static final int SLOT_STRIDE = 6;
     private static final int INITIAL_CAPACITY = 64; // power of 2
     private static final long EMPTY_MARKER = 0L; // slot [1] == 0 means empty (fkLen >= 1 guarantees nonzero)
@@ -123,7 +121,7 @@ public class ShaderCache {
 
         setLastUsed(vkPacked, fkPacked, fkLen, program);
 
-        LOGGER.debug("FFP variant compiled: {} + {} (total: {} programs)", vk, fk, count);
+        GLStateManager.LOGGER.debug("FFP variant compiled: {} + {} (total: {} programs)", vk, fk, count);
 
         if (dumpDir != null) {
             dumpShader(Long.toHexString(vkPacked), ".vert.glsl", vertSrc);
@@ -234,7 +232,7 @@ public class ShaderCache {
                 Files.writeString(file, source, StandardCharsets.UTF_8);
             }
         } catch (IOException e) {
-            LOGGER.warn("Failed to dump FFP shader to {}: {}", dumpDir, e.getMessage());
+            GLStateManager.LOGGER.warn("Failed to dump FFP shader to {}: {}", dumpDir, e.getMessage());
         }
     }
 
@@ -256,10 +254,10 @@ public class ShaderCache {
             for (var entry : geometrySourceCache.entrySet()) {
                 dumpShader(Long.toHexString(entry.getKey()), ".geom.glsl", entry.getValue());
             }
-            LOGGER.info("Dumped {} vertex, {} geometry, and {} fragment FFP shader sources to {}",
+            GLStateManager.LOGGER.info("Dumped {} vertex, {} geometry, and {} fragment FFP shader sources to {}",
                 vertexSourceCache.size(), geometrySourceCache.size(), seen.size(), outputDir);
         } catch (IOException e) {
-            LOGGER.warn("Failed to dump FFP shaders: {}", e.getMessage());
+            GLStateManager.LOGGER.warn("Failed to dump FFP shaders: {}", e.getMessage());
         }
     }
 
@@ -279,7 +277,7 @@ public class ShaderCache {
         geometrySourceCache.clear();
         lastProgram = null;
         lastVK = Long.MIN_VALUE;
-        LOGGER.debug("FFP shader cache cleared");
+        GLStateManager.LOGGER.debug("FFP shader cache cleared");
     }
 
     public int getProgramCount() {

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

@@ -1,33 +1,32 @@
 package com.gtnewhorizons.angelica.glsm.ffp;
 
-import java.util.Arrays;
-
-import com.gtnewhorizon.gtnhlib.client.renderer.stacks.IStateStack;
 import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFlags;
 import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormat;
 import com.gtnewhorizons.angelica.glsm.CompatUniformManager;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
+import com.gtnewhorizons.angelica.glsm.hooks.DeferredBlendHandler;
+import com.gtnewhorizons.angelica.glsm.hooks.GLSMHooks;
 import com.gtnewhorizons.angelica.glsm.stacks.Vec3fStack;
 import com.gtnewhorizons.angelica.glsm.stacks.Vec4fStack;
 import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
+import com.gtnewhorizons.angelica.glsm.hooks.GLSMInitConfig;
 import lombok.Getter;
-import net.coderbot.iris.gl.blending.BlendModeStorage;
-import net.minecraft.launchwrapper.Launch;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.joml.Vector3f;
 import org.joml.Vector4f;
 import org.lwjgl.opengl.GL20;
 
 import java.nio.file.Paths;
+import java.util.Arrays;
 
 /**
  * FFP shader manager
  */
 public class ShaderManager {
-    private static final Logger LOGGER = LogManager.getLogger("FFPShaderManager");
 
-    private static final class Holder { static final ShaderManager INSTANCE = new ShaderManager(); }
+    private static final class Holder {
+
+        static final ShaderManager INSTANCE = new ShaderManager();
+    }
 
     private final ShaderCache cache = new ShaderCache();
     private final Uniforms uniforms = new Uniforms();
@@ -52,12 +51,7 @@ public class ShaderManager {
 
     private ShaderManager() {
         vaoVertexFlags.defaultReturnValue(-1);
-        boolean isDev = false;
-        try {
-            final Object deobfEnv = Launch.blackboard != null ? Launch.blackboard.get("fml.deobfuscatedEnvironment") : null;
-            isDev = Boolean.TRUE.equals(deobfEnv);
-        } catch (Exception ignored) {}
-        if (isDev || Boolean.parseBoolean(System.getProperty("angelica.ffp.dumpShaders", "false"))) {
+        if (Boolean.parseBoolean(System.getProperty("angelica.dumpShaders", "false"))) {
             cache.setDumpDir(Paths.get("ffp_shaders"));
         }
     }
@@ -75,7 +69,7 @@ public class ShaderManager {
             return false;
         });
 
-        LOGGER.info("FFP shader emulation enabled");
+        GLStateManager.LOGGER.info("FFP shader emulation enabled");
     }
 
     public void disable() {
@@ -95,11 +89,10 @@ public class ShaderManager {
         currentFKLen = 0;
     }
 
-
-
     public void preDraw(boolean hasColor, boolean hasNormal, boolean hasTexCoord, boolean hasLightmap) {
         GLStateManager.flushDeferredVertexAttribs();
-        BlendModeStorage.flushDeferredBlend();
+        final DeferredBlendHandler bh = GLSMHooks.blendHandler;
+        if (bh != null) bh.flushDeferredBlend();
 
         if (!active) {
             if (enabled) {
@@ -171,10 +164,10 @@ public class ShaderManager {
     public static void bumpNormalGeneration() { normalGeneration++; }
     public static void bumpTexCoordGeneration() { texCoordGeneration++; }
 
-    public void enableClientVertexFlag(int flag)  { currentVertexFlags |= flag; }
-    public void disableClientVertexFlag(int flag) { currentVertexFlags &= ~flag; }
-    public int getCurrentVertexFlags() { return currentVertexFlags; }
-    public void setCurrentVertexFlags(int flags) { currentVertexFlags = flags; }
+    public void enableClientVertexFlag(int flag) {currentVertexFlags |= flag;}
+    public void disableClientVertexFlag(int flag) {currentVertexFlags &= ~flag;}
+    public int getCurrentVertexFlags() {return currentVertexFlags;}
+    public void setCurrentVertexFlags(int flags) {currentVertexFlags = flags;}
 
     public void onBindVertexArray(int vaoId) {
         final int flags = vaoVertexFlags.get(vaoId);
@@ -190,7 +183,8 @@ public class ShaderManager {
     public void destroy() {
         cache.destroy();
         uniforms.destroy();
-        TessellatorStreamingDrawer.destroy();
+        final GLSMInitConfig config = GLStateManager.getInitConfig();
+        if (config != null && config.getStreamingDrawerDestroy() != null) config.getStreamingDrawerDestroy().run();
         com.gtnewhorizons.angelica.glsm.QuadConverter.destroy();
         active = false;
         currentProgram = null;

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

@@ -6,7 +6,7 @@ import com.gtnewhorizons.angelica.glsm.states.FogState;
 import com.gtnewhorizons.angelica.glsm.states.LightState;
 import com.gtnewhorizons.angelica.glsm.states.MaterialState;
 import com.gtnewhorizons.angelica.glsm.states.TexGenState;
-import net.minecraft.client.renderer.OpenGlHelper;
+import com.gtnewhorizons.angelica.glsm.hooks.GLSMConfig;
 import org.joml.Matrix3f;
 import org.joml.Matrix4f;
 import org.joml.Vector4f;
@@ -119,10 +119,10 @@ public class Uniforms {
         }
 
         if (program.getVertexKey().lightmapEnabled() && !program.getVertexKey().hasVertexLightmap()) {
-            if (programChanged || OpenGlHelper.lastBrightnessX != lastLightmapX || OpenGlHelper.lastBrightnessY != lastLightmapY) {
+            if (programChanged || GLSMConfig.lastBrightnessX != lastLightmapX || GLSMConfig.lastBrightnessY != lastLightmapY) {
                 uploadCurrentLightmapCoord(program);
-                lastLightmapX = OpenGlHelper.lastBrightnessX;
-                lastLightmapY = OpenGlHelper.lastBrightnessY;
+                lastLightmapX = GLSMConfig.lastBrightnessX;
+                lastLightmapY = GLSMConfig.lastBrightnessY;
             }
         }
 
@@ -332,7 +332,7 @@ public class Uniforms {
     private void uploadCurrentLightmapCoord(Program program) {
         if (program.locCurrentLightmapCoord == -1) return;
         GL20.glUniform2f(program.locCurrentLightmapCoord,
-            OpenGlHelper.lastBrightnessX, OpenGlHelper.lastBrightnessY);
+            GLSMConfig.lastBrightnessX, GLSMConfig.lastBrightnessY);
     }
 
     private void uploadCurrentNormal(Program program) {

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

@@ -0,0 +1,7 @@
+package com.gtnewhorizons.angelica.glsm.hooks;
+
+public interface DeferredAlphaHandler {
+    boolean isAlphaTestLocked();
+    void deferAlphaTestToggle(boolean enabled);
+    void deferAlphaFunc(int function, float reference);
+}

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

@@ -0,0 +1,8 @@
+package com.gtnewhorizons.angelica.glsm.hooks;
+
+public interface DeferredBlendHandler {
+    boolean isBlendLocked();
+    void deferBlendModeToggle(boolean enabled);
+    void deferBlendFunc(int srcRgb, int dstRgb, int srcAlpha, int dstAlpha);
+    void flushDeferredBlend();
+}

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

@@ -0,0 +1,7 @@
+package com.gtnewhorizons.angelica.glsm.hooks;
+
+public interface DeferredDepthColorHandler {
+    boolean isDepthColorLocked();
+    void deferDepthEnable(boolean enabled);
+    void deferColorMask(boolean r, boolean g, boolean b, boolean a);
+}

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

@@ -0,0 +1,12 @@
+package com.gtnewhorizons.angelica.glsm.hooks;
+
+public final class GLSMConfig {
+
+    // Lightmap (replaces OpenGlHelper.lastBrightnessX/Y)
+    public static float lastBrightnessX;
+    public static float lastBrightnessY;
+
+    public static boolean hudCacheOverride;
+
+    private GLSMConfig() {}
+}

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

@@ -0,0 +1,37 @@
+package com.gtnewhorizons.angelica.glsm.hooks;
+
+import com.gtnewhorizons.angelica.glsm.hooks.events.BlendFuncChangeEvent;
+import com.gtnewhorizons.angelica.glsm.hooks.events.FogStateChangeEvent;
+import com.gtnewhorizons.angelica.glsm.hooks.events.LightmapCoordsEvent;
+import com.gtnewhorizons.angelica.glsm.hooks.events.ProgramChangeEvent;
+import com.gtnewhorizons.angelica.glsm.hooks.events.TextureBindEvent;
+import com.gtnewhorizons.angelica.glsm.hooks.events.TextureDeleteEvent;
+import com.gtnewhorizons.angelica.glsm.hooks.events.TextureUnitStateEvent;
+import net.minecraftforge.eventbus.api.bus.EventBus;
+
+public final class GLSMHooks {
+
+    public static DeferredBlendHandler blendHandler;
+    public static DeferredAlphaHandler alphaHandler;
+    public static DeferredDepthColorHandler depthColorHandler;
+
+    // EventBus instances
+    public static final EventBus<TextureBindEvent> TEXTURE_BIND = EventBus.create(TextureBindEvent.class);
+    public static final EventBus<TextureDeleteEvent> TEXTURE_DELETE = EventBus.create(TextureDeleteEvent.class);
+    public static final EventBus<TextureUnitStateEvent> TEXTURE_UNIT_STATE = EventBus.create(TextureUnitStateEvent.class);
+    public static final EventBus<ProgramChangeEvent> PROGRAM_CHANGE = EventBus.create(ProgramChangeEvent.class);
+    public static final EventBus<BlendFuncChangeEvent> BLEND_FUNC_CHANGE = EventBus.create(BlendFuncChangeEvent.class);
+    public static final EventBus<FogStateChangeEvent> FOG_STATE_CHANGE = EventBus.create(FogStateChangeEvent.class);
+    public static final EventBus<LightmapCoordsEvent> LIGHTMAP_COORDS = EventBus.create(LightmapCoordsEvent.class);
+
+    // Reusable event instances
+    public static final TextureBindEvent textureBindEvent = new TextureBindEvent();
+    public static final TextureDeleteEvent textureDeleteEvent = new TextureDeleteEvent();
+    public static final TextureUnitStateEvent textureUnitStateEvent = new TextureUnitStateEvent();
+    public static final ProgramChangeEvent programChangeEvent = new ProgramChangeEvent();
+    public static final BlendFuncChangeEvent blendFuncChangeEvent = new BlendFuncChangeEvent();
+    public static final FogStateChangeEvent fogStateChangeEvent = new FogStateChangeEvent();
+    public static final LightmapCoordsEvent lightmapCoordsEvent = new LightmapCoordsEvent();
+
+    private GLSMHooks() {}
+}

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

@@ -0,0 +1,103 @@
+package com.gtnewhorizons.angelica.glsm.hooks;
+
+import com.gtnewhorizon.gtnhlib.client.renderer.DirectTessellator;
+import com.gtnewhorizons.angelica.glsm.streaming.StreamingUploader;
+
+import java.util.function.Consumer;
+
+public final class GLSMInitConfig {
+    private final boolean lwjglDebug;
+    private final StreamingUploader.UploadStrategy streamingUploadStrategy;
+    private final boolean framebufferSupported;
+    private final boolean fboEnabled;
+    private final Consumer<DirectTessellator> directDrawer;
+    private final Runnable streamingDrawerDestroy;
+    private final int displayWidth;
+    private final int displayHeight;
+    private final Runnable postInitCallback;
+
+    private GLSMInitConfig(Builder builder) {
+        this.lwjglDebug = builder.lwjglDebug;
+        this.streamingUploadStrategy = builder.streamingUploadStrategy;
+        this.framebufferSupported = builder.framebufferSupported;
+        this.fboEnabled = builder.fboEnabled;
+        this.directDrawer = builder.directDrawer;
+        this.streamingDrawerDestroy = builder.streamingDrawerDestroy;
+        this.displayWidth = builder.displayWidth;
+        this.displayHeight = builder.displayHeight;
+        this.postInitCallback = builder.postInitCallback;
+    }
+
+    public static Builder builder() {
+        return new Builder();
+    }
+
+    public boolean isLwjglDebug() { return lwjglDebug; }
+    public StreamingUploader.UploadStrategy getStreamingUploadStrategy() { return streamingUploadStrategy; }
+    public boolean isFramebufferSupported() { return framebufferSupported; }
+    public boolean isFboEnabled() { return fboEnabled; }
+    public Consumer<DirectTessellator> getDirectDrawer() { return directDrawer; }
+    public Runnable getStreamingDrawerDestroy() { return streamingDrawerDestroy; }
+    public int getDisplayWidth() { return displayWidth; }
+    public int getDisplayHeight() { return displayHeight; }
+    public Runnable getPostInitCallback() { return postInitCallback; }
+
+    public static final class Builder {
+        private boolean lwjglDebug = false;
+        private StreamingUploader.UploadStrategy streamingUploadStrategy = StreamingUploader.UploadStrategy.BUFFER_DATA;
+        private boolean framebufferSupported = false;
+        private boolean fboEnabled = false;
+        private Consumer<DirectTessellator> directDrawer = null;
+        private Runnable streamingDrawerDestroy = null;
+        private int displayWidth = 0;
+        private int displayHeight = 0;
+        private Runnable postInitCallback = null;
+
+        private Builder() {}
+
+        public Builder lwjglDebug(boolean lwjglDebug) {
+            this.lwjglDebug = lwjglDebug;
+            return this;
+        }
+
+        public Builder streamingUploadStrategy(StreamingUploader.UploadStrategy strategy) {
+            this.streamingUploadStrategy = strategy;
+            return this;
+        }
+
+        public Builder framebufferSupported(boolean framebufferSupported) {
+            this.framebufferSupported = framebufferSupported;
+            return this;
+        }
+
+        public Builder fboEnabled(boolean fboEnabled) {
+            this.fboEnabled = fboEnabled;
+            return this;
+        }
+
+        public Builder directDrawer(Consumer<DirectTessellator> directDrawer) {
+            this.directDrawer = directDrawer;
+            return this;
+        }
+
+        public Builder streamingDrawerDestroy(Runnable streamingDrawerDestroy) {
+            this.streamingDrawerDestroy = streamingDrawerDestroy;
+            return this;
+        }
+
+        public Builder displaySize(int width, int height) {
+            this.displayWidth = width;
+            this.displayHeight = height;
+            return this;
+        }
+
+        public Builder postInitCallback(Runnable callback) {
+            this.postInitCallback = callback;
+            return this;
+        }
+
+        public GLSMInitConfig build() {
+            return new GLSMInitConfig(this);
+        }
+    }
+}

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/events/BlendFuncChangeEvent.java

@@ -0,0 +1,10 @@
+package com.gtnewhorizons.angelica.glsm.hooks.events;
+
+import net.minecraftforge.eventbus.api.event.MutableEvent;
+
+public final class BlendFuncChangeEvent extends MutableEvent {
+    public int srcRgb;
+    public int dstRgb;
+    public int srcAlpha;
+    public int dstAlpha;
+}

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/events/FogStateChangeEvent.java

@@ -0,0 +1,6 @@
+package com.gtnewhorizons.angelica.glsm.hooks.events;
+
+import net.minecraftforge.eventbus.api.event.MutableEvent;
+
+/** FogState changed - Listeners should query GLSM fog state directly if they care what changed. */
+public final class FogStateChangeEvent extends MutableEvent {}

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/events/LightmapCoordsEvent.java

@@ -0,0 +1,8 @@
+package com.gtnewhorizons.angelica.glsm.hooks.events;
+
+import net.minecraftforge.eventbus.api.event.MutableEvent;
+
+public final class LightmapCoordsEvent extends MutableEvent {
+    public float x;
+    public float y;
+}

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/events/ProgramChangeEvent.java

@@ -0,0 +1,8 @@
+package com.gtnewhorizons.angelica.glsm.hooks.events;
+
+import net.minecraftforge.eventbus.api.event.MutableEvent;
+
+public final class ProgramChangeEvent extends MutableEvent {
+    public int previousProgram;
+    public int newProgram;
+}

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/events/TextureBindEvent.java

@@ -0,0 +1,7 @@
+package com.gtnewhorizons.angelica.glsm.hooks.events;
+
+import net.minecraftforge.eventbus.api.event.MutableEvent;
+
+public final class TextureBindEvent extends MutableEvent {
+    public int textureId;
+}

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/events/TextureDeleteEvent.java

@@ -0,0 +1,7 @@
+package com.gtnewhorizons.angelica.glsm.hooks.events;
+
+import net.minecraftforge.eventbus.api.event.MutableEvent;
+
+public final class TextureDeleteEvent extends MutableEvent {
+    public int textureId;
+}

glsm/src/main/java/com/gtnewhorizons/angelica/glsm/hooks/events/TextureUnitStateEvent.java

@@ -0,0 +1,8 @@
+package com.gtnewhorizons.angelica.glsm.hooks.events;
+
+import net.minecraftforge.eventbus.api.event.MutableEvent;
+
+public final class TextureUnitStateEvent extends MutableEvent {
+    public int unit;
+    public boolean enabled;
+}

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

@@ -490,10 +490,10 @@ public final class CommandBufferExecutor {
                     // Restore attributes based on flags
                     if ((flags & VertexFlags.COLOR_BIT) != 0) {
                         final int color = memGetInt(ptr + 8);
-                        byte a = (byte) ((color >> 24) & 0xFF);
-                        byte r = (byte) ((color >> 16) & 0xFF);
-                        byte g = (byte) ((color >> 8) & 0xFF);
-                        byte b = (byte) ((color & 0xFF));
+                        final byte a = (byte) ((color >> 24) & 0xFF);
+                        final byte b = (byte) ((color >> 16) & 0xFF);
+                        final byte g = (byte) ((color >> 8) & 0xFF);
+                        final byte r = (byte) ((color & 0xFF));
                         GLStateManager.glColor4ub(r, g, b, a);
                     }
                     if ((flags & VertexFlags.NORMAL_BIT) != 0) {

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

@@ -1,18 +1,12 @@
 package com.gtnewhorizons.angelica.glsm.recording;
 
-import com.gtnewhorizons.angelica.glsm.DisplayListManager;
+import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.recording.commands.DisplayListCommand;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.joml.Matrix4f;
-import org.lwjgl.opengl.GL11;
 
 import java.nio.FloatBuffer;
-import java.util.ArrayDeque;
-import java.util.Deque;
 
 public final class CommandBufferProcessor {
-    private static final Logger LOGGER = LogManager.getLogger("CommandBufferProcessor");
     private static final Matrix4f tempMatrix = new Matrix4f();
 
     private CommandBufferProcessor() {}
@@ -168,7 +162,7 @@ public final class CommandBufferProcessor {
                 out.writeComplexRef((DisplayListCommand) obj);
             }
 
-            default -> LOGGER.warn("[CommandBufferProcessor] Unknown opcode in buffer copy: {}", opcode);
+            default -> GLStateManager.LOGGER.warn("[CommandBufferProcessor] Unknown opcode in buffer copy: {}", opcode);
         }
     }
 }

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

@@ -6,8 +6,6 @@ import com.gtnewhorizon.gtnhlib.client.renderer.vertex.VertexFormatElement.Usage
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import com.gtnewhorizons.angelica.glsm.states.VertexAttribState;
 import com.gtnewhorizon.gtnhlib.bytebuf.MemoryUtilities;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
 import org.lwjgl.opengl.GL11;
 import org.lwjgl.opengl.GL15;
 
@@ -19,7 +17,6 @@ import java.util.Arrays;
  * Used both during display list compilation and for live immediate mode emulation in core profile.
  */
 public final class ImmediateModeRecorder {
-    private static final Logger LOGGER = LogManager.getLogger("ImmediateModeRecorder");
     private static final DirectTessellator tessellator = new DirectTessellator(TessellatorManager.DEFAULT_BUFFER_SIZE);
 
     /** Separate tessellator for the splash thread. Nulled after splash completes. */
@@ -234,7 +231,7 @@ public final class ImmediateModeRecorder {
             final int eboReadOffset = (int) indicesOffset;
             final int eboReadSize = indicesCount * indexSize;
             if (eboReadOffset + eboReadSize > eboSize) {
-                LOGGER.warn("[EBO] Read range {}+{} exceeds buffer size {}", eboReadOffset, eboReadSize, eboSize);
+                GLStateManager.LOGGER.warn("[EBO] Read range {}+{} exceeds buffer size {}", eboReadOffset, eboReadSize, eboSize);
                 GLStateManager.glBindBuffer(GL15.GL_ELEMENT_ARRAY_BUFFER, prevEBO);
                 return null;
             }
@@ -286,7 +283,7 @@ public final class ImmediateModeRecorder {
                     GLStateManager.glBindBuffer(GL15.GL_ARRAY_BUFFER, a.vboId);
                     final int bufferSize = GL15.glGetBufferParameteri(GL15.GL_ARRAY_BUFFER, GL15.GL_BUFFER_SIZE);
                     if (bufferSize <= 0) {
-                        LOGGER.warn("[VBO Readback] GL_BUFFER_SIZE={} for VBO {}", bufferSize, a.vboId);
+                        GLStateManager.LOGGER.warn("[VBO Readback] GL_BUFFER_SIZE={} for VBO {}", bufferSize, a.vboId);
                         continue;
                     }
 

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

@@ -1,6 +1,5 @@
 package com.gtnewhorizons.angelica.glsm.recording.commands;
 
-import com.github.bsideup.jabel.Desugar;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import org.jetbrains.annotations.NotNull;
 import org.joml.Matrix4f;
@@ -12,7 +11,6 @@ import java.nio.FloatBuffer;
  * Command: glMultMatrix(matrix)
  * Multiplies the current matrix by the specified matrix.
  */
-@Desugar
 public record MultMatrixCmd(Matrix4f matrix, FloatBuffer buffer) implements DisplayListCommand {
 
     /**

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

@@ -1,6 +1,5 @@
 package com.gtnewhorizons.angelica.glsm.recording.commands;
 
-import com.github.bsideup.jabel.Desugar;
 import com.gtnewhorizons.angelica.glsm.GLDebug;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import org.jetbrains.annotations.NotNull;
@@ -16,7 +15,6 @@ import java.nio.IntBuffer;
  * Command: glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels)
  * Specifies a two-dimensional texture image during display list playback.
  */
-@Desugar
 public record TexImage2DCmd(
     int target,
     int level,

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

@@ -1,6 +1,5 @@
 package com.gtnewhorizons.angelica.glsm.recording.commands;
 
-import com.github.bsideup.jabel.Desugar;
 import com.gtnewhorizons.angelica.glsm.GLDebug;
 import com.gtnewhorizons.angelica.glsm.GLStateManager;
 import org.jetbrains.annotations.NotNull;
@@ -16,7 +15,6 @@ import java.nio.IntBuffer;
  * Command: glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels)
  * Updates a portion of an existing two-dimensional texture image during display list playback.
  */
-@Desugar
 public record TexSubImage2DCmd(
     int target,
     int level,