Adjustments needed to get Angelica (Iris/Oculus backport) working

build.gradle

@@ -1,4 +1,4 @@
-//version: 1696952014
+//version: 1699290261
 /*
  DO NOT CHANGE THIS FILE!
  Also, you may replace this file at any time if there is an update available.
@@ -646,7 +646,7 @@ repositories {
 
 def mixinProviderGroup = "io.github.legacymoddingmc"
 def mixinProviderModule = "unimixins"
-def mixinProviderVersion = "0.1.7.1"
+def mixinProviderVersion = "0.1.13"
 def mixinProviderSpecNoClassifer = "${mixinProviderGroup}:${mixinProviderModule}:${mixinProviderVersion}"
 def mixinProviderSpec = "${mixinProviderSpecNoClassifer}:dev"
 ext.mixinProviderSpec = mixinProviderSpec
@@ -798,7 +798,7 @@ dependencies {
         java17Dependencies("com.github.GTNewHorizons:lwjgl3ify:${lwjgl3ifyVersion}")
     }
     if (modId != 'hodgepodge') {
-        java17Dependencies('com.github.GTNewHorizons:Hodgepodge:2.3.7')
+        java17Dependencies('com.github.GTNewHorizons:Hodgepodge:2.3.17')
     }
 
     java17PatchDependencies("com.github.GTNewHorizons:lwjgl3ify:${lwjgl3ifyVersion}:forgePatches") {transitive = false}
@@ -1187,9 +1187,8 @@ publishing {
             version = System.getenv("RELEASE_VERSION") ?: identifiedVersion
         }
     }
-
     repositories {
-        if (usesMavenPublishing.toBoolean()) {
+        if (usesMavenPublishing.toBoolean() && System.getenv("MAVEN_USER") != null) {
             maven {
                 url = mavenPublishUrl
                 allowInsecureProtocol = mavenPublishUrl.startsWith("http://") // Mostly for the GTNH maven

src/generated/java/org/lwjglx/opengl/ARBDirectStateAccess.java

@@ -454,6 +454,10 @@ public static void glTextureParameteri(int texture, int pname, int param) {
         org.lwjgl.opengl.ARBDirectStateAccess.glTextureParameteri(texture, pname, param);
     }
 
+    public static void glTextureParameter(int texture, int pname, java.nio.IntBuffer params) {
+        org.lwjgl.opengl.ARBDirectStateAccess.glTextureParameteriv(texture, pname, params);
+    }
+
     public static void glTextureStorage1D(int texture, int levels, int internalformat, int width) {
         org.lwjgl.opengl.ARBDirectStateAccess.glTextureStorage1D(texture, levels, internalformat, width);
     }

src/generated/java/org/lwjglx/opengl/GL20.java

@@ -1,5 +1,7 @@
 package org.lwjglx.opengl;
 
+import org.lwjgl.system.MemoryUtil;
+
 public class GL20 {
 
     public static final int GL_ACTIVE_ATTRIBUTES = (int) 35721;
@@ -154,6 +156,15 @@ public static void glGetActiveUniform(int program, int index, java.nio.IntBuffer
         org.lwjgl.opengl.GL20.glGetActiveUniform(program, index, length, size, type, name);
     }
 
+    public static String glGetActiveUniform(int program, int index, int maxLength, java.nio.IntBuffer sizeType) {
+        return org.lwjgl.opengl.GL20.glGetActiveUniform(
+            program,
+            index,
+            maxLength,
+            MemoryUtil.memSlice(sizeType, 0, 1),
+            MemoryUtil.memSlice(sizeType, 1, 1));
+    }
+
     public static void glGetAttachedShaders(int program, java.nio.IntBuffer count, java.nio.IntBuffer shaders) {
         org.lwjgl.opengl.GL20.glGetAttachedShaders(program, count, shaders);
     }

src/generated/java/org/lwjglx/opengl/GL43.java

@@ -1,5 +1,7 @@
 package org.lwjglx.opengl;
 
+import org.lwjgl.opengl.GLDebugMessageCallback;
+
 public class GL43 {
 
     public static final int GL_ACTIVE_RESOURCES = (int) 37621;
@@ -520,4 +522,20 @@ public static void glVertexBindingDivisor(int bindingindex, int divisor) {
         org.lwjgl.opengl.GL43.glVertexBindingDivisor(bindingindex, divisor);
     }
 
+    // Callbacks have to be kept alive, a GC collection could falsely collect them.
+    private static ThreadLocal<GLDebugMessageCallback> glDebugMessageCallbackStorage = new ThreadLocal<>();
+
+    public static void glDebugMessageCallback(org.lwjglx.opengl.KHRDebugCallback callback) {
+        if (callback == null) {
+            org.lwjgl.opengl.GL43.glDebugMessageCallback(null, 0L);
+            return;
+        }
+        GLDebugMessageCallback cb = glDebugMessageCallbackStorage.get();
+        if (cb == null) {
+            cb = GLDebugMessageCallback.create(callback);
+            glDebugMessageCallbackStorage.set(cb);
+        }
+        org.lwjgl.opengl.GL43.glDebugMessageCallback(cb, 0L);
+    }
+
 }

src/generated/java/org/lwjglx/opengl/KHRDebug.java

@@ -54,6 +54,10 @@ public static void glDebugMessageInsert(int source, int type, int id, int severi
         org.lwjgl.opengl.KHRDebug.glDebugMessageInsert(source, type, id, severity, buf);
     }
 
+    public static void glDebugMessageCallback(org.lwjglx.opengl.KHRDebugCallback callback) {
+        org.lwjglx.opengl.GL43.glDebugMessageCallback(callback);
+    }
+
     public static int glGetDebugMessageLog(int count, java.nio.IntBuffer sources, java.nio.IntBuffer types,
         java.nio.IntBuffer ids, java.nio.IntBuffer severities, java.nio.IntBuffer lengths,
         java.nio.ByteBuffer messageLog) {

src/generated/java/org/lwjglx/opengl/KHRDebugCallback.java

@@ -0,0 +1,139 @@
+package org.lwjglx.opengl;
+
+import org.lwjgl.opengl.GLDebugMessageCallback;
+import org.lwjgl.opengl.GLDebugMessageCallbackI;
+
+public class KHRDebugCallback extends org.lwjglx.PointerWrapperAbstract implements GLDebugMessageCallbackI {
+
+    /** Severity levels. */
+    private static final int GL_DEBUG_SEVERITY_HIGH = 0x9146, GL_DEBUG_SEVERITY_MEDIUM = 0x9147,
+        GL_DEBUG_SEVERITY_LOW = 0x9148, GL_DEBUG_SEVERITY_NOTIFICATION = 0x826B;
+
+    /** Sources. */
+    private static final int GL_DEBUG_SOURCE_API = 0x8246, GL_DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247,
+        GL_DEBUG_SOURCE_SHADER_COMPILER = 0x8248, GL_DEBUG_SOURCE_THIRD_PARTY = 0x8249,
+        GL_DEBUG_SOURCE_APPLICATION = 0x824A, GL_DEBUG_SOURCE_OTHER = 0x824B;
+
+    /** Types. */
+    private static final int GL_DEBUG_TYPE_ERROR = 0x824C, GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D,
+        GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E, GL_DEBUG_TYPE_PORTABILITY = 0x824F,
+        GL_DEBUG_TYPE_PERFORMANCE = 0x8250, GL_DEBUG_TYPE_OTHER = 0x8251, GL_DEBUG_TYPE_MARKER = 0x8268;
+
+    private static final long CALLBACK_POINTER;
+
+    static {
+        long pointer = 0;
+        try {
+            // Call reflectively so that we can compile this class for the Generator.
+            pointer = (Long) Class.forName("org.lwjgl.opengl.CallbackUtil")
+                .getDeclaredMethod("getDebugCallbackKHR")
+                .invoke(null);
+        } catch (Exception e) {
+            // ignore
+        }
+        CALLBACK_POINTER = pointer;
+    }
+
+    private final Handler handler;
+
+    /**
+     * Creates an KHRebugCallback with a default callback handler.
+     * The default handler will simply print the message on System.err.
+     */
+    public KHRDebugCallback() {
+        this(new Handler() {
+
+            public void handleMessage(final int source, final int type, final int id, final int severity,
+                final String message) {
+                System.err.println("[LWJGL] KHR_debug message");
+                System.err.println("\tID: " + id);
+
+                String description = switch (source) {
+                    case GL_DEBUG_SOURCE_API -> "API";
+                    case GL_DEBUG_SOURCE_WINDOW_SYSTEM -> "WINDOW SYSTEM";
+                    case GL_DEBUG_SOURCE_SHADER_COMPILER -> "SHADER COMPILER";
+                    case GL_DEBUG_SOURCE_THIRD_PARTY -> "THIRD PARTY";
+                    case GL_DEBUG_SOURCE_APPLICATION -> "APPLICATION";
+                    case GL_DEBUG_SOURCE_OTHER -> "OTHER";
+                    default -> printUnknownToken(source);
+                };
+                System.err.println("\tSource: " + description);
+
+                description = switch (type) {
+                    case GL_DEBUG_TYPE_ERROR -> "ERROR";
+                    case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR -> "DEPRECATED BEHAVIOR";
+                    case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR -> "UNDEFINED BEHAVIOR";
+                    case GL_DEBUG_TYPE_PORTABILITY -> "PORTABILITY";
+                    case GL_DEBUG_TYPE_PERFORMANCE -> "PERFORMANCE";
+                    case GL_DEBUG_TYPE_OTHER -> "OTHER";
+                    case GL_DEBUG_TYPE_MARKER -> "MARKER";
+                    default -> printUnknownToken(type);
+                };
+                System.err.println("\tType: " + description);
+
+                description = switch (severity) {
+                    case GL_DEBUG_SEVERITY_HIGH -> "HIGH";
+                    case GL_DEBUG_SEVERITY_MEDIUM -> "MEDIUM";
+                    case GL_DEBUG_SEVERITY_LOW -> "LOW";
+                    case GL_DEBUG_SEVERITY_NOTIFICATION -> "NOTIFICATION";
+                    default -> printUnknownToken(severity);
+                };
+                System.err.println("\tSeverity: " + description);
+
+                System.err.println("\tMessage: " + message);
+            }
+
+            private String printUnknownToken(final int token) {
+                return "Unknown (0x" + Integer.toHexString(token)
+                    .toUpperCase() + ")";
+            }
+        });
+    }
+
+    /**
+     * Creates an ARBDebugOutputCallback with the specified callback handler.
+     * The handler's {@code handleMessage} method will be called whenever
+     * debug output is generated by the GL.
+     *
+     * @param handler the callback handler
+     */
+    public KHRDebugCallback(final Handler handler) {
+        super(CALLBACK_POINTER);
+
+        this.handler = handler;
+    }
+
+    Handler getHandler() {
+        return handler;
+    }
+
+    @Override
+    public void invoke(int source, int type, int id, int severity, int length, long message, long userParam) {
+        if (this.handler == null) {
+            return;
+        }
+        this.handler.handleMessage(source, type, id, severity, GLDebugMessageCallback.getMessage(length, message));
+    }
+
+    @Override
+    public long address() {
+        return GLDebugMessageCallbackI.super.address();
+    }
+
+    /** Implementations of this interface can be used to receive ARB_debug_output notifications. */
+    public interface Handler {
+
+        /**
+         * This method will be called when an ARB_debug_output message is generated.
+         *
+         * @param source   the message source
+         * @param type     the message type
+         * @param id       the message ID
+         * @param severity the message severity
+         * @param message  the string representation of the message.
+         */
+        void handleMessage(int source, int type, int id, int severity, String message);
+
+    }
+
+}

src/main/java/me/eigenraven/lwjgl3ify/ClientProxy.java

@@ -10,6 +10,7 @@
 import cpw.mods.fml.common.FMLCommonHandler;
 import cpw.mods.fml.common.ICrashCallable;
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import me.eigenraven.lwjgl3ify.client.GLDebugLog;
 import me.eigenraven.lwjgl3ify.client.GLInfoCrashCallable;
 import me.eigenraven.lwjgl3ify.core.Config;
 
@@ -30,6 +31,9 @@ public class ClientProxy extends CommonProxy {
     public void runCompatHooks() {
         super.runCompatHooks();
         replaceOpenGLCrashHandler();
+        if (Config.DEBUG_REGISTER_OPENGL_LOGGER) {
+            GLDebugLog.setupDebugMessageCallback();
+        }
     }
 
     @Override

src/main/java/me/eigenraven/lwjgl3ify/client/GLDebugLog.java

@@ -0,0 +1,127 @@
+package me.eigenraven.lwjgl3ify.client;
+
+public class GLDebugLog {
+
+    private static void printDetail(java.io.PrintStream stream, String type, String message) {
+        stream.printf("  %s: %s\n", type, message);
+    }
+
+    private static void trace(java.util.function.Consumer<String> output) {
+        /*
+         * We can not just use a fixed stacktrace element offset, because some methods
+         * are intercepted and some are not. So, check the package name.
+         */
+        StackTraceElement[] elems = filterStackTrace(new Throwable(), 4).getStackTrace();
+        for (StackTraceElement ste : elems) {
+            output.accept(ste.toString());
+        }
+    }
+
+    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 void printTrace(java.io.PrintStream stream) {
+        trace(new java.util.function.Consumer<String>() {
+
+            boolean first = true;
+
+            public void accept(String str) {
+                if (first) {
+                    printDetail(stream, "Stacktrace", str);
+                    first = false;
+                } else {
+                    printDetailLine(stream, "Stacktrace", str);
+                }
+            }
+        });
+    }
+
+    private static void printDetailLine(java.io.PrintStream stream, String type, String message) {
+        stream.append("    ");
+        for (int i = 0; i < type.length(); i++) {
+            stream.append(" ");
+        }
+        stream.append(message)
+            .append("\n");
+    }
+
+    private static String getDebugSource(int source) {
+        return switch (source) {
+            case org.lwjgl.opengl.GL43.GL_DEBUG_SOURCE_API -> "API";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_SOURCE_WINDOW_SYSTEM -> "WINDOW SYSTEM";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_SOURCE_SHADER_COMPILER -> "SHADER COMPILER";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_SOURCE_THIRD_PARTY -> "THIRD PARTY";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_SOURCE_APPLICATION -> "APPLICATION";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_SOURCE_OTHER -> "OTHER";
+            default -> String.format("Unknown [0x%X]", source);
+        };
+    }
+
+    private static String getDebugType(int type) {
+        return switch (type) {
+            case org.lwjgl.opengl.GL43.GL_DEBUG_TYPE_ERROR -> "ERROR";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR -> "DEPRECATED BEHAVIOR";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR -> "UNDEFINED BEHAVIOR";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_TYPE_PORTABILITY -> "PORTABILITY";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_TYPE_PERFORMANCE -> "PERFORMANCE";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_TYPE_OTHER -> "OTHER";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_TYPE_MARKER -> "MARKER";
+            default -> String.format("Unknown [0x%X]", type);
+        };
+    }
+
+    private static String getDebugSeverity(int severity) {
+        return switch (severity) {
+            case org.lwjgl.opengl.GL43.GL_DEBUG_SEVERITY_NOTIFICATION -> "NOTIFICATION";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_SEVERITY_HIGH -> "HIGH";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_SEVERITY_MEDIUM -> "MEDIUM";
+            case org.lwjgl.opengl.GL43.GL_DEBUG_SEVERITY_LOW -> "LOW";
+            default -> String.format("Unknown [0x%X]", severity);
+        };
+    }
+
+    public static void setupDebugMessageCallback() {
+        org.lwjgl.opengl.GLCapabilities caps = org.lwjgl.opengl.GL.getCapabilities();
+        final java.io.PrintStream stream = org.lwjgl.system.APIUtil.DEBUG_STREAM;
+        if (caps.OpenGL43) {
+            org.lwjgl.system.APIUtil.apiLog("[GL] Using OpenGL 4.3 for error logging.");
+            org.lwjgl.opengl.GLDebugMessageCallback proc = org.lwjgl.opengl.GLDebugMessageCallback
+                .create((source, type, id, severity, length, message, userParam) -> {
+                    String level;
+                    if (severity == org.lwjgl.opengl.GL43.GL_DEBUG_SEVERITY_NOTIFICATION
+                        || severity == org.lwjgl.opengl.GL43.GL_DEBUG_SEVERITY_LOW) level = "info ";
+                    else if (severity == org.lwjgl.opengl.GL43.GL_DEBUG_SEVERITY_MEDIUM) level = "warn ";
+                    else level = "error";
+                    stream.println("[" + level + "] OpenGL debug message");
+                    printDetail(stream, "ID", String.format("0x%X", id));
+                    printDetail(stream, "Source", getDebugSource(source));
+                    printDetail(stream, "Type", getDebugType(type));
+                    printDetail(stream, "Severity", getDebugSeverity(severity));
+                    printDetail(stream, "Message", org.lwjgl.opengl.GLDebugMessageCallback.getMessage(length, message));
+                    printTrace(stream);
+
+                });
+            org.lwjgl.opengl.GL43.glDebugMessageCallback(proc, org.lwjgl.system.MemoryUtil.NULL);
+            if ((org.lwjgl.opengl.GL11.glGetInteger(org.lwjgl.opengl.GL43.GL_CONTEXT_FLAGS)
+                & org.lwjgl.opengl.GL43.GL_CONTEXT_FLAG_DEBUG_BIT) == 0) {
+                org.lwjgl.system.APIUtil.apiLog("[GL] Warning: A non-debug context may not produce any debug output.");
+                org.lwjgl.opengl.GL11.glEnable(org.lwjgl.opengl.GL43.GL_DEBUG_OUTPUT);
+            }
+            org.lwjgl.opengl.GL11.glEnable(org.lwjgl.opengl.GL43.GL_DEBUG_OUTPUT_SYNCHRONOUS);
+        }
+    }
+}