LwjglRenderer - Preparing for abstraction layer shift

 * All GL calls are done via static imports
 * Once again remove dependency on GL21 / GL30 - with the generator it will be possible to choose whether to target GL2+extensions or GL3 core
 * ContextCapabilities is field in Renderer, not allowed to use GLContext to retrieve it anymore
 * Assume depth textures are always supported (they should be since GL1.4)

jme3-lwjgl/src/main/java/com/jme3/renderer/lwjgl/LwjglGL1Renderer.java

@@ -47,6 +47,7 @@ import com.jme3.texture.Texture;
 import com.jme3.texture.Texture.WrapAxis;
 import com.jme3.util.BufferUtils;
 import com.jme3.util.NativeObjectManager;
+import org.lwjgl.opengl.ContextCapabilities;
 
 public class LwjglGL1Renderer implements GL1Renderer {
 
@@ -76,6 +77,8 @@ public class LwjglGL1Renderer implements GL1Renderer {
     private ArrayList<Light> lightList = new ArrayList<Light>(8);
     private ColorRGBA materialAmbientColor = new ColorRGBA();
     private Vector3f tempVec = new Vector3f();
+    
+    private ContextCapabilities ctxCaps;
 
     protected void updateNameBuffer() {
         int len = stringBuf.length();
@@ -98,7 +101,9 @@ public class LwjglGL1Renderer implements GL1Renderer {
     }
 
     public void initialize() {
-        if (GLContext.getCapabilities().OpenGL12){
+        ctxCaps = GLContext.getCapabilities();
+        
+        if (ctxCaps.OpenGL12){
             gl12 = true;
         }
         
@@ -119,7 +124,7 @@ public class LwjglGL1Renderer implements GL1Renderer {
             glEnable(GL_NORMALIZE);
         }
 
-        if (GLContext.getCapabilities().GL_ARB_texture_non_power_of_two) {
+        if (ctxCaps.GL_ARB_texture_non_power_of_two) {
             caps.add(Caps.NonPowerOfTwoTextures);
         } else {
             logger.log(Level.WARNING, "Your graphics card does not "
@@ -753,7 +758,7 @@ public class LwjglGL1Renderer implements GL1Renderer {
         }
 
         // Check sizes if graphics card doesn't support NPOT
-        if (!GLContext.getCapabilities().GL_ARB_texture_non_power_of_two && img.isNPOT()) {
+        if (!ctxCaps.GL_ARB_texture_non_power_of_two && img.isNPOT()) {
             // Resize texture to Power-of-2 size
             MipMapGenerator.resizeToPowerOf2(img);
         }
@@ -763,7 +768,7 @@ public class LwjglGL1Renderer implements GL1Renderer {
             // generate from base level if required
 
             // Check if hardware mips are supported
-            if (GLContext.getCapabilities().OpenGL14) {
+            if (ctxCaps.OpenGL14) {
                 glTexParameteri(target, GL14.GL_GENERATE_MIPMAP, GL_TRUE);
             } else {
                 MipMapGenerator.generateMipMaps(img);
@@ -797,7 +802,7 @@ public class LwjglGL1Renderer implements GL1Renderer {
         TextureUtil.uploadTexture(img, target, i, 0, tdc);
         }
         } else {*/
-        TextureUtil.uploadTexture(img, target, 0, 0, false);
+        TextureUtil.uploadTexture(ctxCaps, img, target, 0, 0, false);
         //}
 
         img.clearUpdateNeeded();
@@ -848,7 +853,7 @@ public class LwjglGL1Renderer implements GL1Renderer {
 
     public void modifyTexture(Texture tex, Image pixels, int x, int y) {
       setTexture(0, tex);
-      TextureUtil.uploadSubTexture(pixels, convertTextureType(tex.getType()), 0, x, y, false);
+      TextureUtil.uploadSubTexture(ctxCaps, pixels, convertTextureType(tex.getType()), 0, x, y, false);
     }
 
     private void clearTextureUnits() {

jme3-lwjgl/src/main/java/com/jme3/renderer/lwjgl/LwjglRenderer.java

@@ -63,18 +63,30 @@ import java.util.logging.Level;
 import java.util.logging.Logger;
 import jme3tools.converters.MipMapGenerator;
 import jme3tools.shader.ShaderDebug;
+
+import static org.lwjgl.opengl.ARBDrawInstanced.*;
+import static org.lwjgl.opengl.ARBInstancedArrays.*;
+import static org.lwjgl.opengl.ARBMultisample.*;
 import static org.lwjgl.opengl.ARBTextureMultisample.*;
+import static org.lwjgl.opengl.ARBVertexArrayObject.*;
+import org.lwjgl.opengl.ContextCapabilities;
 import static org.lwjgl.opengl.EXTFramebufferBlit.*;
 import static org.lwjgl.opengl.EXTFramebufferMultisample.*;
 import static org.lwjgl.opengl.EXTFramebufferObject.*;
+import static org.lwjgl.opengl.EXTFramebufferSRGB.*;
+import static org.lwjgl.opengl.EXTGpuShader4.*;
+import static org.lwjgl.opengl.EXTTextureArray.*;
+import static org.lwjgl.opengl.EXTTextureFilterAnisotropic.*;
 import static org.lwjgl.opengl.GL11.*;
 import static org.lwjgl.opengl.GL12.*;
 import static org.lwjgl.opengl.GL13.*;
 import static org.lwjgl.opengl.GL14.*;
 import static org.lwjgl.opengl.GL15.*;
 import static org.lwjgl.opengl.GL20.*;
-import org.lwjgl.opengl.*;
-//import static org.lwjgl.opengl.ARBDrawInstanced.*;
+import org.lwjgl.opengl.GLContext;
+//import static org.lwjgl.opengl.GL21.*;
+//import static org.lwjgl.opengl.GL30.*;
+
 
 public class LwjglRenderer implements Renderer {
 
@@ -113,6 +125,7 @@ public class LwjglRenderer implements Renderer {
     private int vpX, vpY, vpW, vpH;
     private int clipX, clipY, clipW, clipH;
     private boolean linearizeSrgbImages;
+    private ContextCapabilities ctxCaps;
 
     public LwjglRenderer() {
     }
@@ -141,7 +154,7 @@ public class LwjglRenderer implements Renderer {
 
     @SuppressWarnings("fallthrough")
     public void initialize() {
-        ContextCapabilities ctxCaps = GLContext.getCapabilities();
+        ctxCaps = GLContext.getCapabilities();
         if (ctxCaps.OpenGL20) {
             caps.add(Caps.OpenGL20);
             if (ctxCaps.OpenGL21) {
@@ -371,24 +384,17 @@ public class LwjglRenderer implements Renderer {
                 caps.add(Caps.FrameBufferMRT);
                 logger.log(Level.FINER, "FBO Max MRT renderbuffers: {0}", maxMRTFBOAttachs);
             }
-            
-//            if (ctxCaps.GL_ARB_draw_buffers) {
-//                caps.add(Caps.FrameBufferMRT);
-//                glGetInteger(ARBDrawBuffers.GL_MAX_DRAW_BUFFERS_ARB, intBuf16);
-//                maxMRTFBOAttachs = intBuf16.get(0);
-//                logger.log(Level.FINER, "FBO Max MRT renderbuffers: {0}", maxMRTFBOAttachs);
-            //}
         }
 
         if (ctxCaps.GL_ARB_multisample) {
-            glGetInteger(ARBMultisample.GL_SAMPLE_BUFFERS_ARB, intBuf16);
+            glGetInteger(GL_SAMPLE_BUFFERS_ARB, intBuf16);
             boolean available = intBuf16.get(0) != 0;
-            glGetInteger(ARBMultisample.GL_SAMPLES_ARB, intBuf16);
+            glGetInteger(GL_SAMPLES_ARB, intBuf16);
             int samples = intBuf16.get(0);
             logger.log(Level.FINER, "Samples: {0}", samples);
-            boolean enabled = glIsEnabled(ARBMultisample.GL_MULTISAMPLE_ARB);
+            boolean enabled = glIsEnabled(GL_MULTISAMPLE_ARB);
             if (samples > 0 && available && !enabled) {
-                glEnable(ARBMultisample.GL_MULTISAMPLE_ARB);
+                glEnable(GL_MULTISAMPLE_ARB);
             }
             caps.add(Caps.Multisample);
         }
@@ -472,11 +478,11 @@ public class LwjglRenderer implements Renderer {
     }
 
     public void setAlphaToCoverage(boolean value) {
-        if (caps.contains(Caps.Multisample)) {
+        if (ctxCaps.GL_ARB_multisample) {
             if (value) {
-                glEnable(ARBMultisample.GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
+                glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
             } else {
-                glDisable(ARBMultisample.GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
+                glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE_ARB);
             }
         }
     }
@@ -1068,12 +1074,12 @@ public class LwjglRenderer implements Renderer {
             glAttachShader(id, source.getId());
         }
 
-        if (caps.contains(Caps.OpenGL30)) {
+        if (ctxCaps.GL_EXT_gpu_shader4) {
             // Check if GLSL version is 1.5 for shader
-            GL30.glBindFragDataLocation(id, 0, "outFragColor");
+            glBindFragDataLocationEXT(id, 0, "outFragColor");
             // For MRT
             for (int i = 0; i < maxMRTFBOAttachs; i++) {
-                GL30.glBindFragDataLocation(id, i, "outFragData[" + i + "]");
+                glBindFragDataLocationEXT(id, i, "outFragData[" + i + "]");
             }
         }
 
@@ -1178,7 +1184,7 @@ public class LwjglRenderer implements Renderer {
     }
 
     public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst, boolean copyDepth) {
-        if (GLContext.getCapabilities().GL_EXT_framebuffer_blit) {
+        if (ctxCaps.GL_EXT_framebuffer_blit) {
             int srcX0 = 0;
             int srcY0 = 0;
             int srcX1;
@@ -1310,8 +1316,8 @@ public class LwjglRenderer implements Renderer {
         String readBuf = getTargetBufferName(glGetInteger(GL_READ_BUFFER));
 
         int fbId = fb.getId();
-        int curDrawBinding = glGetInteger(ARBFramebufferObject.GL_DRAW_FRAMEBUFFER_BINDING);
-        int curReadBinding = glGetInteger(ARBFramebufferObject.GL_READ_FRAMEBUFFER_BINDING);
+        int curDrawBinding = glGetInteger(GL_DRAW_FRAMEBUFFER_BINDING_EXT);
+        int curReadBinding = glGetInteger(GL_READ_FRAMEBUFFER_BINDING_EXT);
 
         System.out.println("=== OpenGL FBO State ===");
         System.out.println("Context doublebuffered? " + doubleBuffer);
@@ -1384,9 +1390,9 @@ public class LwjglRenderer implements Renderer {
                     + ":" + fb.getHeight() + " is not supported.");
         }
 
-        TextureUtil.GLImageFormat glFmt = TextureUtil.getImageFormatWithError(rb.getFormat(), fb.isSrgb());
+        TextureUtil.GLImageFormat glFmt = TextureUtil.getImageFormatWithError(ctxCaps, rb.getFormat(), fb.isSrgb());
 
-        if (fb.getSamples() > 1 && GLContext.getCapabilities().GL_EXT_framebuffer_multisample) {
+        if (fb.getSamples() > 1 && ctxCaps.GL_EXT_framebuffer_multisample) {
             int samples = fb.getSamples();
             if (maxFBOSamples < samples) {
                 samples = maxFBOSamples;
@@ -1488,6 +1494,9 @@ public class LwjglRenderer implements Renderer {
         if (fb.getSamples() <= 1) {
             throw new IllegalArgumentException("Framebuffer must be multisampled");
         }
+        if (!ctxCaps.GL_ARB_texture_multisample) {
+            throw new RendererException("Multisampled textures are not supported");
+        }
 
         setFrameBuffer(fb);
 
@@ -1507,6 +1516,11 @@ public class LwjglRenderer implements Renderer {
     }
 
     public void setFrameBuffer(FrameBuffer fb) {
+        if (!ctxCaps.GL_EXT_framebuffer_object) {
+            throw new RendererException("Framebuffer objects are not supported" +
+                                        " by the video hardware");
+        }
+        
         if (fb == null && mainFbOverride != null) {
             fb = mainFbOverride;
         }
@@ -1684,18 +1698,23 @@ public class LwjglRenderer implements Renderer {
     |* Textures                                                          *|
     \*********************************************************************/
     private int convertTextureType(Texture.Type type, int samples, int face) {
+        if (samples > 1 && !ctxCaps.GL_ARB_texture_multisample) {
+            throw new RendererException("Multisample textures are not supported" + 
+                                        " by the video hardware.");
+        }
+        
         switch (type) {
             case TwoDimensional:
                 if (samples > 1) {
-                    return ARBTextureMultisample.GL_TEXTURE_2D_MULTISAMPLE;
+                    return GL_TEXTURE_2D_MULTISAMPLE;
                 } else {
                     return GL_TEXTURE_2D;
                 }
             case TwoDimensionalArray:
                 if (samples > 1) {
-                    return ARBTextureMultisample.GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
+                    return GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
                 } else {
-                    return EXTTextureArray.GL_TEXTURE_2D_ARRAY_EXT;
+                    return GL_TEXTURE_2D_ARRAY_EXT;
                 }
             case ThreeDimensional:
                 return GL_TEXTURE_3D;
@@ -1771,9 +1790,9 @@ public class LwjglRenderer implements Renderer {
         glTexParameteri(target, GL_TEXTURE_MAG_FILTER, magFilter);
 
         if (tex.getAnisotropicFilter() > 1) {
-            if (GLContext.getCapabilities().GL_EXT_texture_filter_anisotropic) {
+            if (ctxCaps.GL_EXT_texture_filter_anisotropic) {
                 glTexParameterf(target,
-                        EXTTextureFilterAnisotropic.GL_TEXTURE_MAX_ANISOTROPY_EXT,
+                        GL_TEXTURE_MAX_ANISOTROPY_EXT,
                         tex.getAnisotropicFilter());
             }
         }
@@ -1853,7 +1872,7 @@ public class LwjglRenderer implements Renderer {
             // Image does not have mipmaps, but they are required.
             // Generate from base level.
 
-            if (!GLContext.getCapabilities().OpenGL30) {
+            if (!ctxCaps.OpenGL30) {
                 glTexParameteri(target, GL_GENERATE_MIPMAP, GL_TRUE);
                 img.setMipmapsGenerated(true);
             } else {
@@ -1880,7 +1899,7 @@ public class LwjglRenderer implements Renderer {
         }
 
         // Yes, some OpenGL2 cards (GeForce 5) still dont support NPOT.
-        if (!GLContext.getCapabilities().GL_ARB_texture_non_power_of_two && img.isNPOT()) {
+        if (!ctxCaps.GL_ARB_texture_non_power_of_two && img.isNPOT()) {
             if (img.getData(0) == null) {
                 throw new RendererException("non-power-of-2 framebuffer textures are not supported by the video hardware");
             } else {
@@ -1889,7 +1908,7 @@ public class LwjglRenderer implements Renderer {
         }
 
         // Check if graphics card doesn't support multisample textures
-        if (!GLContext.getCapabilities().GL_ARB_texture_multisample) {
+        if (!ctxCaps.GL_ARB_texture_multisample) {
             if (img.getMultiSamples() > 1) {
                 throw new RendererException("Multisample textures not supported by graphics hardware");
             }
@@ -1914,9 +1933,9 @@ public class LwjglRenderer implements Renderer {
                 return;
             }
             for (int i = 0; i < 6; i++) {
-                TextureUtil.uploadTexture(img, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, i, 0, linearizeSrgbImages);
+                TextureUtil.uploadTexture(ctxCaps, img, GL_TEXTURE_CUBE_MAP_POSITIVE_X + i, i, 0, linearizeSrgbImages);
             }
-        } else if (target == EXTTextureArray.GL_TEXTURE_2D_ARRAY_EXT) {
+        } else if (target == GL_TEXTURE_2D_ARRAY_EXT) {
             if (!caps.contains(Caps.TextureArray)) {
                 throw new RendererException("Texture arrays not supported by graphics hardware");
             }
@@ -1924,22 +1943,22 @@ public class LwjglRenderer implements Renderer {
             List<ByteBuffer> data = img.getData();
             
             // -1 index specifies prepare data for 2D Array
-            TextureUtil.uploadTexture(img, target, -1, 0, linearizeSrgbImages);
+            TextureUtil.uploadTexture(ctxCaps, img, target, -1, 0, linearizeSrgbImages);
             
             for (int i = 0; i < data.size(); i++) {
                 // upload each slice of 2D array in turn
                 // this time with the appropriate index
-                TextureUtil.uploadTexture(img, target, i, 0, linearizeSrgbImages);
+                TextureUtil.uploadTexture(ctxCaps, img, target, i, 0, linearizeSrgbImages);
             }
         } else {
-            TextureUtil.uploadTexture(img, target, 0, 0, linearizeSrgbImages);
+            TextureUtil.uploadTexture(ctxCaps, img, target, 0, 0, linearizeSrgbImages);
         }
 
         if (img.getMultiSamples() != imageSamples) {
             img.setMultiSamples(imageSamples);
         }
 
-        if (GLContext.getCapabilities().OpenGL30) {
+        if (ctxCaps.OpenGL30) {
             if (!img.hasMipmaps() && img.isGeneratedMipmapsRequired() && img.getData() != null) {
                 // XXX: Required for ATI
                 glEnable(target);
@@ -1990,7 +2009,7 @@ public class LwjglRenderer implements Renderer {
 
     public void modifyTexture(Texture tex, Image pixels, int x, int y) {
       setTexture(0, tex);
-      TextureUtil.uploadSubTexture(pixels, convertTextureType(tex.getType(), pixels.getMultiSamples(), -1), 0, x, y, linearizeSrgbImages);
+      TextureUtil.uploadSubTexture(ctxCaps, pixels, convertTextureType(tex.getType(), pixels.getMultiSamples(), -1), 0, x, y, linearizeSrgbImages);
     }
 
     public void clearTextureUnits() {
@@ -2050,9 +2069,6 @@ public class LwjglRenderer implements Renderer {
                 return GL_INT;
             case UnsignedInt:
                 return GL_UNSIGNED_INT;
-//            case Half:
-//                return NVHalfFloat.GL_HALF_FLOAT_NV;
-//                return ARBHalfFloatVertex.GL_HALF_FLOAT;
             case Float:
                 return GL_FLOAT;
             case Double:
@@ -2175,7 +2191,7 @@ public class LwjglRenderer implements Renderer {
             int idx = attribList.oldList[i];
             glDisableVertexAttribArray(idx);
             if (context.boundAttribs[idx].isInstanced()) {
-                ARBInstancedArrays.glVertexAttribDivisorARB(idx, 0);
+                glVertexAttribDivisorARB(idx, 0);
             }
             context.boundAttribs[idx] = null;
         }
@@ -2212,8 +2228,8 @@ public class LwjglRenderer implements Renderer {
             
             int slotsRequired = 1;
             if (vb.isInstanced()) {
-                if (!GLContext.getCapabilities().GL_ARB_instanced_arrays
-                 || !GLContext.getCapabilities().GL_ARB_draw_instanced) {
+                if (!ctxCaps.GL_ARB_instanced_arrays
+                 || !ctxCaps.GL_ARB_draw_instanced) {
                     throw new RendererException("Instancing is required, "
                             + "but not supported by the "
                             + "graphics hardware");
@@ -2278,10 +2294,10 @@ public class LwjglRenderer implements Renderer {
                     int slot = loc + i;
                     if (vb.isInstanced() && (attribs[slot] == null || !attribs[slot].isInstanced())) {
                         // non-instanced -> instanced
-                        ARBInstancedArrays.glVertexAttribDivisorARB(slot, 1);
+                        glVertexAttribDivisorARB(slot, 1);
                     } else if (!vb.isInstanced() && attribs[slot] != null && attribs[slot].isInstanced()) {
                         // instanced -> non-instanced
-                        ARBInstancedArrays.glVertexAttribDivisorARB(slot, 0);
+                        glVertexAttribDivisorARB(slot, 0);
                     }
                     attribs[slot] = vb;
                 }
@@ -2298,7 +2314,7 @@ public class LwjglRenderer implements Renderer {
     public void drawTriangleArray(Mesh.Mode mode, int count, int vertCount) {
         boolean useInstancing = count > 1 && caps.contains(Caps.MeshInstancing);
         if (useInstancing) {
-            ARBDrawInstanced.glDrawArraysInstancedARB(convertElementMode(mode), 0,
+            glDrawArraysInstancedARB(convertElementMode(mode), 0,
                     vertCount, count);
         } else {
             glDrawArrays(convertElementMode(mode), 0, vertCount);
@@ -2348,7 +2364,7 @@ public class LwjglRenderer implements Renderer {
                 int elementLength = elementLengths[i];
 
                 if (useInstancing) {
-                    ARBDrawInstanced.glDrawElementsInstancedARB(elMode,
+                    glDrawElementsInstancedARB(elMode,
                             elementLength,
                             fmt,
                             curOffset,
@@ -2366,7 +2382,7 @@ public class LwjglRenderer implements Renderer {
             }
         } else {
             if (useInstancing) {
-                ARBDrawInstanced.glDrawElementsInstancedARB(convertElementMode(mesh.getMode()),
+                glDrawElementsInstancedARB(convertElementMode(mesh.getMode()),
                         indexBuf.getData().limit(),
                         convertFormat(indexBuf.getFormat()),
                         0,
@@ -2410,13 +2426,13 @@ public class LwjglRenderer implements Renderer {
         int id = mesh.getId();
         if (id == -1) {
             IntBuffer temp = intBuf1;
-            ARBVertexArrayObject.glGenVertexArrays(temp);
+            glGenVertexArrays(temp);
             id = temp.get(0);
             mesh.setId(id);
         }
 
         if (context.boundVertexArray != id) {
-            ARBVertexArrayObject.glBindVertexArray(id);
+            glBindVertexArray(id);
             context.boundVertexArray = id;
         }
 
@@ -2454,7 +2470,7 @@ public class LwjglRenderer implements Renderer {
         }
 
         if (context.boundVertexArray != mesh.getId()) {
-            ARBVertexArrayObject.glBindVertexArray(mesh.getId());
+            glBindVertexArray(mesh.getId());
             context.boundVertexArray = mesh.getId();
         }
 
@@ -2546,7 +2562,7 @@ public class LwjglRenderer implements Renderer {
         }
 
         statistics.onMeshDrawn(mesh, lod, count);
-//        if (GLContext.getCapabilities().GL_ARB_vertex_array_object){
+//        if (ctxCaps.GL_ARB_vertex_array_object){
 //            renderMeshVertexArray(mesh, lod, count);
 //        }else{
         renderMeshDefault(mesh, lod, count, instanceData);
@@ -2568,25 +2584,18 @@ public class LwjglRenderer implements Renderer {
         setFrameBuffer(null);
 
         if (enableSrgb) {
-            if (!glGetBoolean(GL30.GL_FRAMEBUFFER_SRGB_CAPABLE)) {
+            if (!glGetBoolean(GL_FRAMEBUFFER_SRGB_CAPABLE_EXT)) {
                 logger.warning("Driver claims that default framebuffer "
                         + "is not sRGB capable. Enabling anyway.");
             }
 
-            int encoding = GL30.glGetFramebufferAttachmentParameteri(GL30.GL_DRAW_FRAMEBUFFER,
-                    GL_FRONT_LEFT,
-                    GL30.GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING);
-
-            if (encoding != GL21.GL_SRGB) {
-                logger.warning("Driver claims that default framebuffer "
-                        + "is not using sRGB color encoding. Enabling anyway.");
-            }
+            
 
-            glEnable(GL30.GL_FRAMEBUFFER_SRGB);
+            glEnable(GL_FRAMEBUFFER_SRGB_EXT);
 
             logger.log(Level.FINER, "SRGB FrameBuffer enabled (Gamma Correction)");
         } else {
-            glDisable(GL30.GL_FRAMEBUFFER_SRGB);
+            glDisable(GL_FRAMEBUFFER_SRGB_EXT);
         }
     }
 

jme3-lwjgl/src/main/java/com/jme3/renderer/lwjgl/TextureUtil.java

@@ -39,20 +39,23 @@ import com.jme3.texture.image.ColorSpace;
 import java.nio.ByteBuffer;
 import java.util.logging.Level;
 import java.util.logging.Logger;
-import org.lwjgl.opengl.ARBTextureFloat;
-import org.lwjgl.opengl.ARBTextureMultisample;
+import static org.lwjgl.opengl.ARBDepthBufferFloat.*;
+import static org.lwjgl.opengl.ARBHalfFloatPixel.*;
+import static org.lwjgl.opengl.ARBTextureFloat.*;
+import static org.lwjgl.opengl.ARBTextureMultisample.*;
 import org.lwjgl.opengl.ContextCapabilities;
-import org.lwjgl.opengl.EXTTextureArray;
-import org.lwjgl.opengl.EXTTextureCompressionLATC;
-import org.lwjgl.opengl.EXTTextureCompressionS3TC;
-import org.lwjgl.opengl.EXTTextureSRGB;
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.opengl.GL12;
-import org.lwjgl.opengl.GL13;
-import org.lwjgl.opengl.GL14;
-import org.lwjgl.opengl.GL21;
-import org.lwjgl.opengl.GL30;
-import org.lwjgl.opengl.GLContext;
+import static org.lwjgl.opengl.EXTPackedDepthStencil.*;
+import static org.lwjgl.opengl.EXTPackedFloat.*;
+import static org.lwjgl.opengl.EXTTextureArray.*;
+import static org.lwjgl.opengl.EXTTextureCompressionLATC.*;
+import static org.lwjgl.opengl.EXTTextureCompressionS3TC.*;
+import static org.lwjgl.opengl.EXTTextureSRGB.*;
+import static org.lwjgl.opengl.EXTTextureSharedExponent.*;
+import static org.lwjgl.opengl.GL11.*;
+import static org.lwjgl.opengl.GL12.*;
+import static org.lwjgl.opengl.GL13.*;
+import static org.lwjgl.opengl.GL14.*;
+import static org.lwjgl.opengl.GL20.*;
 
 class TextureUtil {
 
@@ -79,80 +82,80 @@ class TextureUtil {
     
     static {
         // Alpha formats
-        setFormat(Format.Alpha8,  GL11.GL_ALPHA8,  GL11.GL_ALPHA, GL11.GL_UNSIGNED_BYTE, false);
-        setFormat(Format.Alpha16, GL11.GL_ALPHA16, GL11.GL_ALPHA, GL11.GL_UNSIGNED_SHORT, false);
+        setFormat(Format.Alpha8,  GL_ALPHA8,  GL_ALPHA, GL_UNSIGNED_BYTE, false);
+        setFormat(Format.Alpha16, GL_ALPHA16, GL_ALPHA, GL_UNSIGNED_SHORT, false);
         
         // Luminance formats
-        setFormat(Format.Luminance8,   GL11.GL_LUMINANCE8,  GL11.GL_LUMINANCE, GL11.GL_UNSIGNED_BYTE, false);
-        setFormat(Format.Luminance16,  GL11.GL_LUMINANCE16, GL11.GL_LUMINANCE, GL11.GL_UNSIGNED_SHORT, false);
-        setFormat(Format.Luminance16F, ARBTextureFloat.GL_LUMINANCE16F_ARB, GL11.GL_LUMINANCE, GL30.GL_HALF_FLOAT, false);
-        setFormat(Format.Luminance32F, ARBTextureFloat.GL_LUMINANCE32F_ARB, GL11.GL_LUMINANCE, GL11.GL_FLOAT, false);
+        setFormat(Format.Luminance8,   GL_LUMINANCE8,  GL_LUMINANCE, GL_UNSIGNED_BYTE, false);
+        setFormat(Format.Luminance16,  GL_LUMINANCE16, GL_LUMINANCE, GL_UNSIGNED_SHORT, false);
+        setFormat(Format.Luminance16F, GL_LUMINANCE16F_ARB, GL_LUMINANCE, GL_HALF_FLOAT_ARB, false);
+        setFormat(Format.Luminance32F, GL_LUMINANCE32F_ARB, GL_LUMINANCE, GL_FLOAT, false);
         
         // Luminance alpha formats
-        setFormat(Format.Luminance8Alpha8, GL11.GL_LUMINANCE8_ALPHA8,  GL11.GL_LUMINANCE_ALPHA, GL11.GL_UNSIGNED_BYTE, false);
-        setFormat(Format.Luminance16Alpha16, GL11.GL_LUMINANCE16_ALPHA16, GL11.GL_LUMINANCE_ALPHA, GL11.GL_UNSIGNED_SHORT, false);
-        setFormat(Format.Luminance16FAlpha16F, ARBTextureFloat.GL_LUMINANCE_ALPHA16F_ARB, GL11.GL_LUMINANCE_ALPHA, GL30.GL_HALF_FLOAT, false);
+        setFormat(Format.Luminance8Alpha8, GL_LUMINANCE8_ALPHA8,  GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, false);
+        setFormat(Format.Luminance16Alpha16, GL_LUMINANCE16_ALPHA16, GL_LUMINANCE_ALPHA, GL_UNSIGNED_SHORT, false);
+        setFormat(Format.Luminance16FAlpha16F, GL_LUMINANCE_ALPHA16F_ARB, GL_LUMINANCE_ALPHA, GL_HALF_FLOAT_ARB, false);
         
         // Depth formats
-        setFormat(Format.Depth,    GL11.GL_DEPTH_COMPONENT,    GL11.GL_DEPTH_COMPONENT, GL11.GL_UNSIGNED_BYTE, false);
-        setFormat(Format.Depth16,  GL14.GL_DEPTH_COMPONENT16,  GL11.GL_DEPTH_COMPONENT, GL11.GL_UNSIGNED_SHORT, false);
-        setFormat(Format.Depth24,  GL14.GL_DEPTH_COMPONENT24,  GL11.GL_DEPTH_COMPONENT, GL11.GL_UNSIGNED_INT, false);
-        setFormat(Format.Depth32,  GL14.GL_DEPTH_COMPONENT32,  GL11.GL_DEPTH_COMPONENT, GL11.GL_UNSIGNED_INT, false);
-        setFormat(Format.Depth32F, GL30.GL_DEPTH_COMPONENT32F, GL11.GL_DEPTH_COMPONENT, GL11.GL_FLOAT,         false);
+        setFormat(Format.Depth,    GL_DEPTH_COMPONENT,    GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, false);
+        setFormat(Format.Depth16,  GL_DEPTH_COMPONENT16,  GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, false);
+        setFormat(Format.Depth24,  GL_DEPTH_COMPONENT24,  GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false);
+        setFormat(Format.Depth32,  GL_DEPTH_COMPONENT32,  GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, false);
+        setFormat(Format.Depth32F, GL_DEPTH_COMPONENT32F, GL_DEPTH_COMPONENT, GL_FLOAT,         false);
         
         // Depth stencil formats
-        setFormat(Format.Depth24Stencil8, GL30.GL_DEPTH24_STENCIL8, GL30.GL_DEPTH_STENCIL, GL30.GL_UNSIGNED_INT_24_8, false);
+        setFormat(Format.Depth24Stencil8, GL_DEPTH24_STENCIL8_EXT, GL_DEPTH_STENCIL_EXT, GL_UNSIGNED_INT_24_8_EXT, false);
 
         // RGB formats
-        setFormat(Format.BGR8,        GL11.GL_RGB8,   GL12.GL_BGR,  GL11.GL_UNSIGNED_BYTE, false);
-        setFormat(Format.ARGB8,       GL11.GL_RGBA8,  GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8, false);
-        setFormat(Format.BGRA8,       GL11.GL_RGBA8,  GL12.GL_BGRA, GL11.GL_UNSIGNED_BYTE, false);
-        setFormat(Format.RGB8,        GL11.GL_RGB8,   GL11.GL_RGB,  GL11.GL_UNSIGNED_BYTE, false);
-//        setFormat(Format.RGB10,      GL11.GL_RGB10, GL11.GL_RGB,        GL12.GL_UNSIGNED_INT_10_10_10_2, false); 
-        setFormat(Format.RGB16,      GL11.GL_RGB16, GL11.GL_RGB,  GL11.GL_UNSIGNED_SHORT, false); 
-        setFormat(Format.RGB16F,     GL30.GL_RGB16F, GL11.GL_RGB, GL30.GL_HALF_FLOAT, false);
-        setFormat(Format.RGB32F,     GL30.GL_RGB32F, GL11.GL_RGB, GL11.GL_FLOAT, false);
+        setFormat(Format.BGR8,        GL_RGB8,   GL_BGR,  GL_UNSIGNED_BYTE, false);
+        setFormat(Format.ARGB8,       GL_RGBA8,  GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, false);
+        setFormat(Format.BGRA8,       GL_RGBA8,  GL_BGRA, GL_UNSIGNED_BYTE, false);
+        setFormat(Format.RGB8,        GL_RGB8,   GL_RGB,  GL_UNSIGNED_BYTE, false);
+//        setFormat(Format.RGB10,      GL_RGB10, GL_RGB,        GL_UNSIGNED_INT_10_10_10_2, false); 
+        setFormat(Format.RGB16,      GL_RGB16, GL_RGB,  GL_UNSIGNED_SHORT, false); 
+        setFormat(Format.RGB16F,     GL_RGB16F_ARB, GL_RGB, GL_HALF_FLOAT_ARB, false);
+        setFormat(Format.RGB32F,     GL_RGB32F_ARB, GL_RGB, GL_FLOAT, false);
         
         // Special RGB formats
-        setFormat(Format.RGB111110F,           GL30.GL_R11F_G11F_B10F, GL11.GL_RGB, GL30.GL_UNSIGNED_INT_10F_11F_11F_REV, false);
-        setFormat(Format.RGB9E5,               GL30.GL_RGB9_E5,         GL11.GL_RGB, GL30.GL_UNSIGNED_INT_5_9_9_9_REV, false);
-        setFormat(Format.RGB16F_to_RGB111110F, GL30.GL_R11F_G11F_B10F, GL11.GL_RGB, GL30.GL_HALF_FLOAT, false);
-        setFormat(Format.RGB16F_to_RGB9E5,     GL30.GL_RGB9_E5,         GL11.GL_RGB, GL30.GL_HALF_FLOAT, false);
-        setFormat(Format.RGB10_A2,             GL11.GL_RGB10_A2,        GL11.GL_RGBA, GL12.GL_UNSIGNED_INT_10_10_10_2, false);
+        setFormat(Format.RGB111110F,           GL_R11F_G11F_B10F_EXT, GL_RGB, GL_UNSIGNED_INT_10F_11F_11F_REV_EXT, false);
+        setFormat(Format.RGB9E5,               GL_RGB9_E5_EXT,         GL_RGB, GL_UNSIGNED_INT_5_9_9_9_REV_EXT, false);
+        setFormat(Format.RGB16F_to_RGB111110F, GL_R11F_G11F_B10F_EXT, GL_RGB, GL_HALF_FLOAT_ARB, false);
+        setFormat(Format.RGB16F_to_RGB9E5,     GL_RGB9_E5_EXT,         GL_RGB, GL_HALF_FLOAT_ARB, false);
+        setFormat(Format.RGB10_A2,             GL_RGB10_A2,        GL_RGBA, GL_UNSIGNED_INT_10_10_10_2, false);
         
         // RGBA formats
-        setFormat(Format.ABGR8,   GL11.GL_RGBA8,  GL11.GL_RGBA, GL12.GL_UNSIGNED_INT_8_8_8_8, false);
-        setFormat(Format.RGB5A1,  GL11.GL_RGB5_A1, GL11.GL_RGBA, GL12.GL_UNSIGNED_SHORT_5_5_5_1, false);
-        setFormat(Format.ARGB4444,GL11.GL_RGBA4,   GL11.GL_RGBA, GL12.GL_UNSIGNED_SHORT_4_4_4_4_REV, false);
-        setFormat(Format.RGBA8,   GL11.GL_RGBA8,   GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, false);
-        setFormat(Format.RGBA16,  GL11.GL_RGBA16,  GL11.GL_RGBA, GL11.GL_UNSIGNED_SHORT, false); // might be incorrect
-        setFormat(Format.RGBA16F, GL30.GL_RGBA16F, GL11.GL_RGBA, GL30.GL_HALF_FLOAT, false);
-        setFormat(Format.RGBA32F, GL30.GL_RGBA32F, GL11.GL_RGBA, GL11.GL_FLOAT, false);
+        setFormat(Format.ABGR8,   GL_RGBA8,  GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, false);
+        setFormat(Format.RGB5A1,  GL_RGB5_A1, GL_RGBA, GL_UNSIGNED_SHORT_5_5_5_1, false);
+        setFormat(Format.ARGB4444,GL_RGBA4,   GL_RGBA, GL_UNSIGNED_SHORT_4_4_4_4_REV, false);
+        setFormat(Format.RGBA8,   GL_RGBA8,   GL_RGBA, GL_UNSIGNED_BYTE, false);
+        setFormat(Format.RGBA16,  GL_RGBA16,  GL_RGBA, GL_UNSIGNED_SHORT, false); // might be incorrect
+        setFormat(Format.RGBA16F, GL_RGBA16F_ARB, GL_RGBA, GL_HALF_FLOAT_ARB, false);
+        setFormat(Format.RGBA32F, GL_RGBA32F_ARB, GL_RGBA, GL_FLOAT, false);
         
         // DXT formats
-        setFormat(Format.DXT1,  EXTTextureCompressionS3TC.GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL11.GL_RGB,   GL11.GL_UNSIGNED_BYTE, true);
-        setFormat(Format.DXT1A, EXTTextureCompressionS3TC.GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, true);
-        setFormat(Format.DXT3,  EXTTextureCompressionS3TC.GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, true);
-        setFormat(Format.DXT5,  EXTTextureCompressionS3TC.GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, true);
+        setFormat(Format.DXT1,  GL_COMPRESSED_RGB_S3TC_DXT1_EXT, GL_RGB,   GL_UNSIGNED_BYTE, true);
+        setFormat(Format.DXT1A, GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, GL_RGBA, GL_UNSIGNED_BYTE, true);
+        setFormat(Format.DXT3,  GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_BYTE, true);
+        setFormat(Format.DXT5,  GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_BYTE, true);
     
         // LTC/LATC/3Dc formats
-        setFormat(Format.LTC,  EXTTextureCompressionLATC.GL_COMPRESSED_LUMINANCE_LATC1_EXT,       GL11.GL_LUMINANCE,       GL11.GL_UNSIGNED_BYTE, true);
-        setFormat(Format.LATC, EXTTextureCompressionLATC.GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT, GL11.GL_LUMINANCE_ALPHA, GL11.GL_UNSIGNED_BYTE, true);   
+        setFormat(Format.LTC,  GL_COMPRESSED_LUMINANCE_LATC1_EXT,       GL_LUMINANCE,       GL_UNSIGNED_BYTE, true);
+        setFormat(Format.LATC, GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, true);   
     }
     
     //sRGB formats        
-    private static final GLImageFormat sRGB_RGB8 = new GLImageFormat(GL21.GL_SRGB8, GL11.GL_RGB, GL11.GL_UNSIGNED_BYTE, false);
-    private static final GLImageFormat sRGB_RGBA8 = new GLImageFormat(GL21.GL_SRGB8_ALPHA8, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, false);
-    private static final GLImageFormat sRGB_Luminance8 = new GLImageFormat(GL21.GL_SLUMINANCE8, GL11.GL_LUMINANCE, GL11.GL_UNSIGNED_BYTE, false);
-    private static final GLImageFormat sRGB_LuminanceAlpha8 = new GLImageFormat(GL21.GL_SLUMINANCE8_ALPHA8, GL11.GL_LUMINANCE_ALPHA, GL11.GL_UNSIGNED_BYTE, false);
-    private static final GLImageFormat sRGB_BGR8 = new GLImageFormat(GL21.GL_SRGB8, GL12.GL_BGR, GL11.GL_UNSIGNED_BYTE, false);
-    private static final GLImageFormat sRGB_ABGR8 = new GLImageFormat(GL21.GL_SRGB8_ALPHA8, GL11.GL_RGBA, GL12.GL_UNSIGNED_INT_8_8_8_8, false);
-    private static final GLImageFormat sRGB_ARGB8 = new GLImageFormat(GL21.GL_SRGB8_ALPHA8, GL12.GL_BGRA, GL12.GL_UNSIGNED_INT_8_8_8_8, false);
-    private static final GLImageFormat sRGB_BGRA8 = new GLImageFormat(GL21.GL_SRGB8_ALPHA8, GL12.GL_BGRA, GL11.GL_UNSIGNED_BYTE, false);
-    private static final GLImageFormat sRGB_DXT1 = new GLImageFormat(EXTTextureSRGB.GL_COMPRESSED_SRGB_S3TC_DXT1_EXT,GL11.GL_RGB,   GL11.GL_UNSIGNED_BYTE, true);
-    private static final GLImageFormat sRGB_DXT1A = new GLImageFormat(EXTTextureSRGB.GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, true);
-    private static final GLImageFormat sRGB_DXT3 = new GLImageFormat(EXTTextureSRGB.GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, true);
-    private static final GLImageFormat sRGB_DXT5 = new GLImageFormat(EXTTextureSRGB.GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL11.GL_RGBA, GL11.GL_UNSIGNED_BYTE, true);
+    private static final GLImageFormat sRGB_RGB8 = new GLImageFormat(GL_SRGB8_EXT, GL_RGB, GL_UNSIGNED_BYTE, false);
+    private static final GLImageFormat sRGB_RGBA8 = new GLImageFormat(GL_SRGB8_ALPHA8_EXT, GL_RGBA, GL_UNSIGNED_BYTE, false);
+    private static final GLImageFormat sRGB_Luminance8 = new GLImageFormat(GL_SLUMINANCE8_EXT, GL_LUMINANCE, GL_UNSIGNED_BYTE, false);
+    private static final GLImageFormat sRGB_LuminanceAlpha8 = new GLImageFormat(GL_SLUMINANCE8_ALPHA8_EXT, GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE, false);
+    private static final GLImageFormat sRGB_BGR8 = new GLImageFormat(GL_SRGB8_EXT, GL_BGR, GL_UNSIGNED_BYTE, false);
+    private static final GLImageFormat sRGB_ABGR8 = new GLImageFormat(GL_SRGB8_ALPHA8_EXT, GL_RGBA, GL_UNSIGNED_INT_8_8_8_8, false);
+    private static final GLImageFormat sRGB_ARGB8 = new GLImageFormat(GL_SRGB8_ALPHA8_EXT, GL_BGRA, GL_UNSIGNED_INT_8_8_8_8, false);
+    private static final GLImageFormat sRGB_BGRA8 = new GLImageFormat(GL_SRGB8_ALPHA8_EXT, GL_BGRA, GL_UNSIGNED_BYTE, false);
+    private static final GLImageFormat sRGB_DXT1 = new GLImageFormat(GL_COMPRESSED_SRGB_S3TC_DXT1_EXT,GL_RGB,   GL_UNSIGNED_BYTE, true);
+    private static final GLImageFormat sRGB_DXT1A = new GLImageFormat(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT, GL_RGBA, GL_UNSIGNED_BYTE, true);
+    private static final GLImageFormat sRGB_DXT3 = new GLImageFormat(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT, GL_RGBA, GL_UNSIGNED_BYTE, true);
+    private static final GLImageFormat sRGB_DXT5 = new GLImageFormat(GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT, GL_RGBA, GL_UNSIGNED_BYTE, true);
 
     public static GLImageFormat getImageFormat(ContextCapabilities caps, Format fmt, boolean isSrgb){
         switch (fmt){
@@ -164,14 +167,6 @@ class TextureUtil {
                     return null;
                 }
                 break;
-            case Depth:
-            case Depth16:
-            case Depth24:
-            case Depth32:
-                if (!caps.OpenGL14 && !caps.GL_ARB_depth_texture){
-                    return null;
-                }
-                break;
             case Depth24Stencil8:
                 if (!caps.OpenGL30 && !caps.GL_EXT_packed_depth_stencil){
                     return null;
@@ -219,8 +214,8 @@ class TextureUtil {
         }
     }
     
-    public static GLImageFormat getImageFormatWithError(Format fmt, boolean isSrgb) {
-        GLImageFormat glFmt = getImageFormat(GLContext.getCapabilities(), fmt, isSrgb);
+    public static GLImageFormat getImageFormatWithError(ContextCapabilities caps, Format fmt, boolean isSrgb) {
+        GLImageFormat glFmt = getImageFormat(caps, fmt, isSrgb);
         if (glFmt == null) {
             throw new RendererException("Image format '" + fmt + "' is unsupported by the video hardware.");
         }
@@ -259,14 +254,15 @@ class TextureUtil {
         }
     }
     
-    public static void uploadTexture(Image image,
+    public static void uploadTexture(ContextCapabilities caps,
+                                     Image image,
                                      int target,
                                      int index,
                                      int border,
                                      boolean linearizeSrgb){
         
         Image.Format fmt = image.getFormat();
-        GLImageFormat glFmt = getImageFormatWithError(fmt, image.getColorSpace() == ColorSpace.sRGB && linearizeSrgb);
+        GLImageFormat glFmt = getImageFormatWithError(caps, fmt, image.getColorSpace() == ColorSpace.sRGB && linearizeSrgb);
 
         ByteBuffer data;
         if (index >= 0 && image.getData() != null && image.getData().size() > 0){
@@ -280,7 +276,7 @@ class TextureUtil {
         int depth = image.getDepth();
 
         if (data != null) {
-            GL11.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1);
+            glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
         }
 
         int[] mipSizes = image.getMipMapSizes();
@@ -307,63 +303,63 @@ class TextureUtil {
             }
             
             if (glFmt.compressed && data != null){
-                if (target == GL12.GL_TEXTURE_3D){
-                    GL13.glCompressedTexImage3D(target,
-                                                i,
-                                                glFmt.internalFormat,
-                                                mipWidth,
-                                                mipHeight,
-                                                mipDepth,
-                                                border,
-                                                data);
+                if (target == GL_TEXTURE_3D){
+                    glCompressedTexImage3D(target,
+                                            i,
+                                            glFmt.internalFormat,
+                                            mipWidth,
+                                            mipHeight,
+                                            mipDepth,
+                                            border,
+                                            data);
                 }else{
                     //all other targets use 2D: array, cubemap, 2d
-                    GL13.glCompressedTexImage2D(target,
-                                                i,
-                                                glFmt.internalFormat,
-                                                mipWidth,
-                                                mipHeight,
-                                                border,
-                                                data);
+                    glCompressedTexImage2D(target,
+                                            i,
+                                            glFmt.internalFormat,
+                                            mipWidth,
+                                            mipHeight,
+                                            border,
+                                            data);
                 }
             }else{
-                if (target == GL12.GL_TEXTURE_3D){
-                    GL12.glTexImage3D(target,
-                                      i,
-                                      glFmt.internalFormat,
-                                      mipWidth,
-                                      mipHeight,
-                                      mipDepth,
-                                      border,
-                                      glFmt.format,
-                                      glFmt.dataType,
-                                      data);
-                }else if (target == EXTTextureArray.GL_TEXTURE_2D_ARRAY_EXT){
+                if (target == GL_TEXTURE_3D){
+                    glTexImage3D(target,
+                                i,
+                                glFmt.internalFormat,
+                                mipWidth,
+                                mipHeight,
+                                mipDepth,
+                                border,
+                                glFmt.format,
+                                glFmt.dataType,
+                                data);
+                }else if (target == GL_TEXTURE_2D_ARRAY_EXT){
                     // prepare data for 2D array
                     // or upload slice
                     if (index == -1){
-                        GL12.glTexImage3D(target,
-                                          i,
-                                          glFmt.internalFormat,
-                                          mipWidth,
-                                          mipHeight,
-                                          image.getData().size(), //# of slices
-                                          border,
-                                          glFmt.format,
-                                          glFmt.dataType,
-                                          data);
+                        glTexImage3D(target,
+                                    i,
+                                    glFmt.internalFormat,
+                                    mipWidth,
+                                    mipHeight,
+                                    image.getData().size(), //# of slices
+                                    border,
+                                    glFmt.format,
+                                    glFmt.dataType,
+                                    data);
                     }else{
-                        GL12.glTexSubImage3D(target,
-                                             i, // level
-                                             0, // xoffset
-                                             0, // yoffset
-                                             index, // zoffset
-                                             width, // width
-                                             height, // height
-                                             1, // depth
-                                             glFmt.format,
-                                             glFmt.dataType,
-                                             data);
+                        glTexSubImage3D(target,
+                                        i, // level
+                                        0, // xoffset
+                                        0, // yoffset
+                                        index, // zoffset
+                                        width, // width
+                                        height, // height
+                                        1, // depth
+                                        glFmt.format,
+                                        glFmt.dataType,
+                                        data);
                     }
                 }else{
                     if (subtex){
@@ -371,31 +367,31 @@ class TextureUtil {
                             throw new IllegalStateException("Cannot update multisample textures");
                         }
 
-                        GL11.glTexSubImage2D(target,
-                                             i,
-                                             0, 0,
-                                             mipWidth, mipHeight,
-                                             glFmt.format,
-                                             glFmt.dataType,
-                                             data);
+                        glTexSubImage2D(target,
+                                        i,
+                                        0, 0,
+                                        mipWidth, mipHeight,
+                                        glFmt.format,
+                                        glFmt.dataType,
+                                        data);
                     }else{
                         if (samples > 1){
-                            ARBTextureMultisample.glTexImage2DMultisample(target,
-                                                                          samples,
-                                                                          glFmt.internalFormat,
-                                                                          mipWidth,
-                                                                          mipHeight,
-                                                                          true);
+                            glTexImage2DMultisample(target,
+                                                    samples,
+                                                    glFmt.internalFormat,
+                                                    mipWidth,
+                                                    mipHeight,
+                                                    true);
                         }else{
-                            GL11.glTexImage2D(target,
-                                              i,
-                                              glFmt.internalFormat,
-                                              mipWidth,
-                                              mipHeight,
-                                              border,
-                                              glFmt.format,
-                                              glFmt.dataType,
-                                              data);
+                            glTexImage2D(target,
+                                        i,
+                                        glFmt.internalFormat,
+                                        mipWidth,
+                                        mipHeight,
+                                        border,
+                                        glFmt.format,
+                                        glFmt.dataType,
+                                        data);
                         }
                     }
                 }
@@ -416,6 +412,7 @@ class TextureUtil {
      * @param y the y position where to put the image in the texture
      */
     public static void uploadSubTexture(
+        ContextCapabilities caps,
         Image image,
         int target,
         int index,
@@ -423,7 +420,7 @@ class TextureUtil {
         int y,
         boolean linearizeSrgb) {
       Image.Format fmt = image.getFormat();
-      GLImageFormat glFmt = getImageFormatWithError(fmt, image.getColorSpace() == ColorSpace.sRGB  && linearizeSrgb);
+      GLImageFormat glFmt = getImageFormatWithError(caps, fmt, image.getColorSpace() == ColorSpace.sRGB  && linearizeSrgb);
 
       ByteBuffer data = null;
       if (index >= 0 && image.getData() != null && image.getData().size() > 0) {
@@ -435,7 +432,7 @@ class TextureUtil {
       int depth = image.getDepth();
 
       if (data != null) {
-        GL11.glPixelStorei(GL11.GL_UNPACK_ALIGNMENT, 1);
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
       }
 
       int[] mipSizes = image.getMipMapSizes();
@@ -471,29 +468,29 @@ class TextureUtil {
         int glFmtDataType = glFmt.dataType;
 
         if (glFmt.compressed && data != null){
-          if (target == GL12.GL_TEXTURE_3D){
-            GL13.glCompressedTexSubImage3D(target, i, x, y, index, mipWidth, mipHeight, mipDepth, glFmtInternal, data);
+          if (target == GL_TEXTURE_3D){
+            glCompressedTexSubImage3D(target, i, x, y, index, mipWidth, mipHeight, mipDepth, glFmtInternal, data);
             continue;
           }
 
           // all other targets use 2D: array, cubemap, 2d
-          GL13.glCompressedTexSubImage2D(target, i, x, y, mipWidth, mipHeight, glFmtInternal, data);
+          glCompressedTexSubImage2D(target, i, x, y, mipWidth, mipHeight, glFmtInternal, data);
           continue;
         }
 
-        if (target == GL12.GL_TEXTURE_3D){
-          GL12.glTexSubImage3D(target, i, x, y, index, mipWidth, mipHeight, mipDepth, glFmtFormat, glFmtDataType, data);
+        if (target == GL_TEXTURE_3D){
+          glTexSubImage3D(target, i, x, y, index, mipWidth, mipHeight, mipDepth, glFmtFormat, glFmtDataType, data);
           continue;
         }
 
-        if (target == EXTTextureArray.GL_TEXTURE_2D_ARRAY_EXT){
+        if (target == GL_TEXTURE_2D_ARRAY_EXT){
           // prepare data for 2D array or upload slice
           if (index == -1){
-            GL12.glTexSubImage3D(target, i, x, y, index, mipWidth, mipHeight, mipDepth, glFmtFormat, glFmtDataType, data);
+            glTexSubImage3D(target, i, x, y, index, mipWidth, mipHeight, mipDepth, glFmtFormat, glFmtDataType, data);
             continue;
           }
 
-          GL12.glTexSubImage3D(target, i, x, y, index, width, height, 1, glFmtFormat, glFmtDataType, data);
+          glTexSubImage3D(target, i, x, y, index, width, height, 1, glFmtFormat, glFmtDataType, data);
           continue;
         }
 
@@ -501,8 +498,7 @@ class TextureUtil {
           throw new IllegalStateException("Cannot update multisample textures");
         }
 
-        GL11.glTexSubImage2D(target, i, x, y, mipWidth, mipHeight, glFmtFormat, glFmtDataType, data);
-        continue;
+        glTexSubImage2D(target, i, x, y, mipWidth, mipHeight, glFmtFormat, glFmtDataType, data);
       }
     }
 }