improve compatibility layer.

src/main/java/com/simibubi/create/foundation/render/backend/Backend.java

@@ -11,6 +11,7 @@
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 
+import com.simibubi.create.foundation.render.backend.gl.versioned.GlFunctions;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.lwjgl.opengl.GL;
@@ -44,16 +45,12 @@ public class Backend {
     private static boolean enabled;
 
     public static GLCapabilities capabilities;
-    private static MapBuffer mapBuffer;
+    public static GlFunctions functions;
 
     public Backend() {
         throw new IllegalStateException();
     }
 
-    public static void mapBuffer(int target, int offset, int length, Consumer<ByteBuffer> upload) {
-        mapBuffer.mapBuffer(target, offset, length, upload);
-    }
-
     /**
      * Register a shader program. TODO: replace with forge registry?
      */
@@ -71,47 +68,21 @@ public static <P extends GlProgram, S extends ProgramSpec<P>> P getProgram(S spe
         return (P) programs.get(spec);
     }
 
-    /**
-     * Get the most compatible version of a specific OpenGL feature by iterating over enum constants in order.
-     *
-     * @param clazz The class of the versioning enum.
-     * @param <V> The type of the versioning enum.
-     * @return The first defined enum variant to return true.
-     */
-    public static <V extends Enum<V> & GlVersioned> V getLatest(Class<V> clazz) {
-        return getLatest(clazz, capabilities);
-    }
-
-    /**
-     * Get the most compatible version of a specific OpenGL feature by iterating over enum constants in order.
-     *
-     * @param clazz The class of the versioning enum.
-     * @param caps The current system's supported features.
-     * @param <V> The type of the versioning enum.
-     * @return The first defined enum variant to return true.
-     */
-    public static <V extends Enum<V> & GlVersioned> V getLatest(Class<V> clazz, GLCapabilities caps) {
-        V[] constants = clazz.getEnumConstants();
-        V last = constants[constants.length - 1];
-        if (!last.supported(caps)) {
-            throw new IllegalStateException("");
-        }
-
-        return Arrays.stream(constants).filter(it -> it.supported(caps)).findFirst().orElse(last);
+    public static boolean available() {
+        return canUseVBOs();
     }
 
     public static boolean canUseInstancing() {
-        return enabled && gl33();
+        return enabled &&
+                functions.vertexArrayObjectsSupported() &&
+                functions.drawInstancedSupported() &&
+                functions.instancedArraysSupported();
     }
 
     public static boolean canUseVBOs() {
         return enabled && gl20();
     }
 
-    public static boolean available() {
-        return enabled && gl20();
-    }
-
     public static boolean gl33() {
         return capabilities.OpenGL33;
     }
@@ -136,7 +107,7 @@ public static void init() {
     private static void onResourceManagerReload(IResourceManager manager, Predicate<IResourceType> predicate) {
         if (predicate.test(VanillaResourceType.SHADERS)) {
             capabilities = GL.createCapabilities();
-            mapBuffer = getLatest(MapBuffer.class);
+            functions = new GlFunctions(capabilities);
 
             OptifineHandler.refresh();
             refresh();

src/main/java/com/simibubi/create/foundation/render/backend/gl/GlBuffer.java

@@ -3,9 +3,9 @@
 import java.nio.ByteBuffer;
 import java.util.function.Consumer;
 
-import org.lwjgl.opengl.GL20;
-
 import com.simibubi.create.foundation.render.backend.Backend;
+import com.simibubi.create.foundation.render.backend.gl.versioned.GlFunctions;
+import org.lwjgl.opengl.GL20;
 
 public class GlBuffer extends GlObject {
 
@@ -35,11 +35,11 @@ public void with(Consumer<GlBuffer> action) {
     }
 
     public void map(int length, Consumer<ByteBuffer> upload) {
-        Backend.mapBuffer(bufferType, 0, length, upload);
+        Backend.functions.mapBuffer(bufferType, 0, length, upload);
     }
 
     public void map(int offset, int length, Consumer<ByteBuffer> upload) {
-        Backend.mapBuffer(bufferType, offset, length, upload);
+        Backend.functions.mapBuffer(bufferType, offset, length, upload);
     }
 
     protected void deleteInternal(int handle) {

src/main/java/com/simibubi/create/foundation/render/backend/gl/GlVertexArray.java

@@ -2,19 +2,20 @@
 
 import java.util.function.Consumer;
 
+import com.simibubi.create.foundation.render.backend.Backend;
 import org.lwjgl.opengl.GL30;
 
 public class GlVertexArray extends GlObject {
     public GlVertexArray() {
-        setHandle(GL30.glGenVertexArrays());
+        setHandle(Backend.functions.genVertexArrays());
     }
 
     public void bind() {
-        GL30.glBindVertexArray(handle());
+        Backend.functions.bindVertexArray(handle());
     }
 
     public void unbind() {
-        GL30.glBindVertexArray(0);
+        Backend.functions.bindVertexArray(0);
     }
 
     public void with(Consumer<GlVertexArray> action) {
@@ -24,6 +25,6 @@ public void with(Consumer<GlVertexArray> action) {
     }
 
     protected void deleteInternal(int handle) {
-        GL30.glDeleteVertexArrays(handle);
+        Backend.functions.deleteVertexArrays(handle);
     }
 }

src/main/java/com/simibubi/create/foundation/render/backend/gl/versioned/DrawInstanced.java

@@ -0,0 +1,54 @@
+package com.simibubi.create.foundation.render.backend.gl.versioned;
+
+import org.lwjgl.opengl.*;
+
+public enum DrawInstanced implements GlVersioned {
+    GL31_DRAW_INSTANCED {
+        @Override
+        public boolean supported(GLCapabilities caps) {
+            return caps.OpenGL31;
+        }
+
+        @Override
+        public void drawArraysInstanced(int mode, int first, int count, int primcount) {
+            GL31.glDrawArraysInstanced(mode, first, count, primcount);
+        }
+    },
+    ARB_DRAW_INSTANCED {
+        @Override
+        public boolean supported(GLCapabilities caps) {
+            return caps.GL_ARB_draw_instanced;
+        }
+
+        @Override
+        public void drawArraysInstanced(int mode, int first, int count, int primcount) {
+            ARBDrawInstanced.glDrawArraysInstancedARB(mode, first, count, primcount);
+        }
+    },
+    EXT_DRAW_INSTANCED {
+        @Override
+        public boolean supported(GLCapabilities caps) {
+            return caps.GL_EXT_draw_instanced;
+        }
+
+        @Override
+        public void drawArraysInstanced(int mode, int first, int count, int primcount) {
+            EXTDrawInstanced.glDrawArraysInstancedEXT(mode, first, count, primcount);
+        }
+    },
+    UNSUPPORTED {
+        @Override
+        public boolean supported(GLCapabilities caps) {
+            return true;
+        }
+
+        @Override
+        public void drawArraysInstanced(int mode, int first, int count, int primcount) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    ;
+
+    public abstract void drawArraysInstanced(int mode, int first, int count, int primcount);
+}

src/main/java/com/simibubi/create/foundation/render/backend/gl/versioned/GlFunctions.java

@@ -0,0 +1,85 @@
+package com.simibubi.create.foundation.render.backend.gl.versioned;
+
+import org.lwjgl.opengl.GLCapabilities;
+
+import java.nio.ByteBuffer;
+import java.util.Arrays;
+import java.util.function.Consumer;
+
+/**
+ * An instance of this class stores information
+ * about what OpenGL features are available.
+ *
+ * Each field stores an enum variant that provides access to the
+ * most appropriate version of a feature for the current system.
+ */
+public class GlFunctions {
+    public final MapBuffer mapBuffer;
+
+    public final VertexArrayObject vertexArrayObject;
+    public final InstancedArrays instancedArrays;
+    public final DrawInstanced drawInstanced;
+
+    public GlFunctions(GLCapabilities caps) {
+        mapBuffer = getLatest(MapBuffer.class, caps);
+
+        vertexArrayObject = getLatest(VertexArrayObject.class, caps);
+        instancedArrays = getLatest(InstancedArrays.class, caps);
+        drawInstanced = getLatest(DrawInstanced.class, caps);
+    }
+
+    public void mapBuffer(int target, int offset, int length, Consumer<ByteBuffer> upload) {
+        mapBuffer.mapBuffer(target, offset, length, upload);
+    }
+
+    public void vertexAttribDivisor(int index, int divisor) {
+        instancedArrays.vertexAttribDivisor(index, divisor);
+    }
+
+    public void drawArraysInstanced(int mode, int first, int count, int primcount) {
+        drawInstanced.drawArraysInstanced(mode, first, count, primcount);
+    }
+
+    public int genVertexArrays() {
+        return vertexArrayObject.genVertexArrays();
+    }
+
+    public void deleteVertexArrays(int array) {
+        vertexArrayObject.deleteVertexArrays(array);
+    }
+
+    public void bindVertexArray(int array) {
+        vertexArrayObject.bindVertexArray(array);
+    }
+
+    public boolean vertexArrayObjectsSupported() {
+        return vertexArrayObject != VertexArrayObject.UNSUPPORTED;
+    }
+
+    public boolean instancedArraysSupported() {
+        return instancedArrays != InstancedArrays.UNSUPPORTED;
+    }
+
+    public boolean drawInstancedSupported() {
+        return drawInstanced != DrawInstanced.UNSUPPORTED;
+    }
+
+    /**
+     * Get the most compatible version of a specific OpenGL feature by iterating over enum constants in order.
+     *
+     * @param clazz The class of the versioning enum.
+     * @param caps The current system's supported features.
+     * @param <V> The type of the versioning enum.
+     * @return The first defined enum variant to return true.
+     */
+    public static <V extends Enum<V> & GlVersioned> V getLatest(Class<V> clazz, GLCapabilities caps) {
+        V[] constants = clazz.getEnumConstants();
+        V last = constants[constants.length - 1];
+        if (!last.supported(caps)) {
+            throw new IllegalStateException("");
+        }
+
+        return Arrays.stream(constants).filter(it -> it.supported(caps)).findFirst().get();
+    }
+}
+

src/main/java/com/simibubi/create/foundation/render/backend/gl/versioned/GlVersioned.java

@@ -2,7 +2,15 @@
 
 import org.lwjgl.opengl.GLCapabilities;
 
-
+/**
+ * This interface should be implemented by enums such that the
+ * last defined variant <em>always</em> returns <code>true</code>.
+ */
 public interface GlVersioned {
+    /**
+     * Queries whether this variant is supported by the current system.
+     * @param caps The {@link GLCapabilities} reported by the current system.
+     * @return <code>true</code> if this variant is supported, or if this is the last defined variant.
+     */
     boolean supported(GLCapabilities caps);
 }

src/main/java/com/simibubi/create/foundation/render/backend/gl/versioned/InstancedArrays.java

@@ -0,0 +1,43 @@
+package com.simibubi.create.foundation.render.backend.gl.versioned;
+
+import org.lwjgl.opengl.*;
+
+public enum InstancedArrays implements GlVersioned {
+    GL33_INSTANCED_ARRAYS {
+        @Override
+        public boolean supported(GLCapabilities caps) {
+            return caps.OpenGL33;
+        }
+
+        @Override
+        public void vertexAttribDivisor(int index, int divisor) {
+            GL33.glVertexAttribDivisor(index, divisor);
+        }
+    },
+    ARB_INSTANCED_ARRAYS {
+        @Override
+        public boolean supported(GLCapabilities caps) {
+            return caps.GL_ARB_instanced_arrays;
+        }
+
+        @Override
+        public void vertexAttribDivisor(int index, int divisor) {
+            ARBInstancedArrays.glVertexAttribDivisorARB(index, divisor);
+        }
+    },
+    UNSUPPORTED {
+        @Override
+        public boolean supported(GLCapabilities caps) {
+            return true;
+        }
+
+        @Override
+        public void vertexAttribDivisor(int index, int divisor) {
+            throw new UnsupportedOperationException();
+        }
+    }
+
+    ;
+
+    public abstract void vertexAttribDivisor(int index, int divisor);
+}