Improves OpenGL-ES support (especially for Raspberry Pi), uses several contributions of Erkki Nokso-Koivisto

git-svn-id: https://jmonkeyengine.googlecode.com/svn/trunk@10264 75d07b2b-3a1a-0410-a2c5-0572b91ccdca

engine/src/jogl/com/jme3/renderer/jogl/JoglGL1Renderer.java

@@ -62,6 +62,7 @@ import java.util.EnumSet;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.media.opengl.*;
+import javax.media.opengl.fixedfunc.GLLightingFunc;
 import jme3tools.converters.MipMapGenerator;
 
 public class JoglGL1Renderer implements GL1Renderer {
@@ -120,16 +121,16 @@ public class JoglGL1Renderer implements GL1Renderer {
         }
         
         // Default values for certain GL state.
-        gl.getGL2().glShadeModel(GL2.GL_SMOOTH);
-        gl.getGL2().glColorMaterial(GL2.GL_FRONT_AND_BACK, GL2.GL_DIFFUSE);
-        gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
+        gl.getGL2ES1().glShadeModel(GLLightingFunc.GL_SMOOTH);
+        gl.getGL2().glColorMaterial(GL.GL_FRONT_AND_BACK, GLLightingFunc.GL_DIFFUSE);
+        gl.glHint(GL2ES1.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
         
         // Enable rescaling/normaling of normal vectors.
         // Fixes lighting issues with scaled models.
         if (gl12){
-            gl.glEnable(GL2.GL_RESCALE_NORMAL);
+            gl.glEnable(GL2ES1.GL_RESCALE_NORMAL);
         }else{
-            gl.glEnable(GL2.GL_NORMALIZE);
+            gl.glEnable(GLLightingFunc.GL_NORMALIZE);
         }
 
         if (gl.isExtensionAvailable("GL_ARB_texture_non_power_of_two")) {
@@ -140,7 +141,7 @@ public class JoglGL1Renderer implements GL1Renderer {
                     + "Some features might not work.");
         }
         
-        gl.glGetIntegerv(GL2.GL_MAX_LIGHTS, ib1);
+        gl.glGetIntegerv(GL2ES1.GL_MAX_LIGHTS, ib1);
         maxLights = ib1.get(0);
         
         gl.glGetIntegerv(GL.GL_MAX_TEXTURE_SIZE, ib1);
@@ -167,7 +168,7 @@ public class JoglGL1Renderer implements GL1Renderer {
 
     public void setDepthRange(float start, float end) {
         GL gl = GLContext.getCurrentGL();
-        gl.getGL2().glDepthRange(start, end);
+        gl.getGL2ES2().glDepthRange(start, end);
     }
 
     public void clearBuffers(boolean color, boolean depth, boolean stencil) {
@@ -222,15 +223,15 @@ public class JoglGL1Renderer implements GL1Renderer {
     private void applyFixedFuncBindings(boolean forLighting){
         GL gl = GLContext.getCurrentGL();
         if (forLighting) {
-            gl.getGL2().glMaterialf(GL.GL_FRONT_AND_BACK, GL2.GL_SHININESS, context.shininess);
-            setMaterialColor(GL2.GL_AMBIENT, context.ambient, ColorRGBA.DarkGray);
-            setMaterialColor(GL2.GL_DIFFUSE, context.diffuse, ColorRGBA.White);
-            setMaterialColor(GL2.GL_SPECULAR, context.specular, ColorRGBA.Black);
+            gl.getGL2().glMaterialf(GL.GL_FRONT_AND_BACK, GLLightingFunc.GL_SHININESS, context.shininess);
+            setMaterialColor(GLLightingFunc.GL_AMBIENT, context.ambient, ColorRGBA.DarkGray);
+            setMaterialColor(GLLightingFunc.GL_DIFFUSE, context.diffuse, ColorRGBA.White);
+            setMaterialColor(GLLightingFunc.GL_SPECULAR, context.specular, ColorRGBA.Black);
 
             if (context.useVertexColor) {
-                gl.glEnable(GL2.GL_COLOR_MATERIAL);
+                gl.glEnable(GLLightingFunc.GL_COLOR_MATERIAL);
             } else {
-                gl.glDisable(GL2.GL_COLOR_MATERIAL);
+                gl.glDisable(GLLightingFunc.GL_COLOR_MATERIAL);
             }
         } else {
             // Ignore other values as they have no effect when 

engine/src/jogl/com/jme3/renderer/jogl/JoglRenderer.java

@@ -64,7 +64,6 @@ import com.jme3.util.BufferUtils;
 import com.jme3.util.ListMap;
 import com.jme3.util.NativeObjectManager;
 import com.jme3.util.SafeArrayList;
-import com.jogamp.common.nio.Buffers;
 import java.nio.*;
 import java.util.EnumSet;
 import java.util.List;
@@ -72,6 +71,7 @@ import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.media.opengl.GL;
 import javax.media.opengl.GL2;
+import javax.media.opengl.GL2ES1;
 import javax.media.opengl.GL2ES2;
 import javax.media.opengl.GL2GL3;
 import javax.media.opengl.GLContext;
@@ -361,16 +361,16 @@ public class JoglRenderer implements Renderer {
             if (gl.isExtensionAvailable("GL_ARB_texture_multisample")) {
                 caps.add(Caps.TextureMultisample);
 
-                gl.glGetIntegerv(GL2.GL_MAX_COLOR_TEXTURE_SAMPLES, intBuf16);
+                gl.glGetIntegerv(GL2GL3.GL_MAX_COLOR_TEXTURE_SAMPLES, intBuf16);
                 maxColorTexSamples = intBuf16.get(0);
                 logger.log(Level.FINER, "Texture Multisample Color Samples: {0}", maxColorTexSamples);
 
-                gl.glGetIntegerv(GL2.GL_MAX_DEPTH_TEXTURE_SAMPLES, intBuf16);
+                gl.glGetIntegerv(GL2GL3.GL_MAX_DEPTH_TEXTURE_SAMPLES, intBuf16);
                 maxDepthTexSamples = intBuf16.get(0);
                 logger.log(Level.FINER, "Texture Multisample Depth Samples: {0}", maxDepthTexSamples);
             }
             
-            gl.glGetIntegerv(GL2GL3.GL_MAX_DRAW_BUFFERS, intBuf16);
+            gl.glGetIntegerv(GL2ES2.GL_MAX_DRAW_BUFFERS, intBuf16);
             maxMRTFBOAttachs = intBuf16.get(0);
             if (maxMRTFBOAttachs > 1) {
                 caps.add(Caps.FrameBufferMRT);
@@ -407,9 +407,9 @@ public class JoglRenderer implements Renderer {
         lastFb = null;
 
         GL gl = GLContext.getCurrentGL();
-        gl.glGetIntegerv(GL2.GL_DRAW_BUFFER, intBuf1);
+        gl.glGetIntegerv(GL2GL3.GL_DRAW_BUFFER, intBuf1);
         initialDrawBuf = intBuf1.get(0);
-        gl.glGetIntegerv(GL2.GL_READ_BUFFER, intBuf1);
+        gl.glGetIntegerv(GL2GL3.GL_READ_BUFFER, intBuf1);
         initialReadBuf = intBuf1.get(0);
     }
     
@@ -481,9 +481,9 @@ public class JoglRenderer implements Renderer {
         if (caps.contains(Caps.Multisample)) {
             GL gl = GLContext.getCurrentGL();
             if (value) {
-                gl.glEnable(GL2.GL_SAMPLE_ALPHA_TO_COVERAGE);
+                gl.glEnable(GL.GL_SAMPLE_ALPHA_TO_COVERAGE);
             } else {
-                gl.glDisable(GL2.GL_SAMPLE_ALPHA_TO_COVERAGE);
+                gl.glDisable(GL.GL_SAMPLE_ALPHA_TO_COVERAGE);
             }
         }
     }
@@ -491,10 +491,14 @@ public class JoglRenderer implements Renderer {
     public void applyRenderState(RenderState state) {
         GL gl = GLContext.getCurrentGL();
         if (state.isWireframe() && !context.wireframe) {
-            gl.getGL2GL3().glPolygonMode(GL.GL_FRONT_AND_BACK, GL2.GL_LINE);
+            if (gl.isGL2GL3()) {
+                gl.getGL2GL3().glPolygonMode(GL.GL_FRONT_AND_BACK, GL2GL3.GL_LINE);
+            }
             context.wireframe = true;
         } else if (!state.isWireframe() && context.wireframe) {
-            gl.getGL2GL3().glPolygonMode(GL.GL_FRONT_AND_BACK, GL2.GL_FILL);
+            if (gl.isGL2GL3()) {
+                gl.getGL2GL3().glPolygonMode(GL.GL_FRONT_AND_BACK, GL2GL3.GL_FILL);
+            }
             context.wireframe = false;
         }
 
@@ -508,11 +512,15 @@ public class JoglRenderer implements Renderer {
         }
 
         if (state.isAlphaTest() && context.alphaTestFallOff == 0) {
-            gl.glEnable(GL2.GL_ALPHA_TEST);
-            gl.getGL2().glAlphaFunc(GL.GL_GREATER, state.getAlphaFallOff());
+            gl.glEnable(GL2ES1.GL_ALPHA_TEST);
+            if (gl.isGL2ES1()) {
+                gl.getGL2ES1().glAlphaFunc(GL.GL_GREATER, state.getAlphaFallOff());
+            }
             context.alphaTestFallOff = state.getAlphaFallOff();
         } else if (!state.isAlphaTest() && context.alphaTestFallOff != 0) {
-            gl.glDisable(GL2.GL_ALPHA_TEST);
+            if (gl.isGL2ES1()) {
+                gl.glDisable(GL2ES1.GL_ALPHA_TEST);
+            }
             context.alphaTestFallOff = 0;
         }
 
@@ -539,8 +547,12 @@ public class JoglRenderer implements Renderer {
                     gl.glActiveTexture(GL.GL_TEXTURE0);
                     context.boundTextureUnit = 0;
                 }
-                gl.glEnable(GL2.GL_POINT_SPRITE);
-                gl.glEnable(GL2.GL_VERTEX_PROGRAM_POINT_SIZE);
+                if (gl.isGL2ES1()) {
+                    gl.glEnable(GL2ES1.GL_POINT_SPRITE);
+                }
+                if (gl.isGL2GL3()) {
+                    gl.glEnable(GL2GL3.GL_VERTEX_PROGRAM_POINT_SIZE);
+                }
             }
             context.pointSprite = true;
         } else if (!state.isPointSprite() && context.pointSprite) {
@@ -549,8 +561,12 @@ public class JoglRenderer implements Renderer {
                     gl.glActiveTexture(GL.GL_TEXTURE0);
                     context.boundTextureUnit = 0;
                 }
-                gl.glDisable(GL2.GL_POINT_SPRITE);
-                gl.glDisable(GL2.GL_VERTEX_PROGRAM_POINT_SIZE);
+                if (gl.isGL2ES1()) {
+                    gl.glDisable(GL2ES1.GL_POINT_SPRITE);
+                }
+                if (gl.isGL2GL3()) {
+                    gl.glDisable(GL2GL3.GL_VERTEX_PROGRAM_POINT_SIZE);
+                }
                 context.pointSprite = false;
             }
         }
@@ -667,18 +683,18 @@ public class JoglRenderer implements Renderer {
 
             if (state.isStencilTest()) {
                 gl.glEnable(GL.GL_STENCIL_TEST);
-                gl.getGL2GL3().glStencilOpSeparate(GL.GL_FRONT,
+                gl.getGL2ES2().glStencilOpSeparate(GL.GL_FRONT,
                         convertStencilOperation(state.getFrontStencilStencilFailOperation()),
                         convertStencilOperation(state.getFrontStencilDepthFailOperation()),
                         convertStencilOperation(state.getFrontStencilDepthPassOperation()));
-                gl.getGL2GL3().glStencilOpSeparate(GL.GL_BACK,
+                gl.getGL2ES2().glStencilOpSeparate(GL.GL_BACK,
                         convertStencilOperation(state.getBackStencilStencilFailOperation()),
                         convertStencilOperation(state.getBackStencilDepthFailOperation()),
                         convertStencilOperation(state.getBackStencilDepthPassOperation()));
-                gl.getGL2GL3().glStencilFuncSeparate(GL.GL_FRONT,
+                gl.getGL2ES2().glStencilFuncSeparate(GL.GL_FRONT,
                         convertTestFunction(state.getFrontStencilFunction()),
                         0, Integer.MAX_VALUE);
-                gl.getGL2GL3().glStencilFuncSeparate(GL.GL_BACK,
+                gl.getGL2ES2().glStencilFuncSeparate(GL.GL_BACK,
                         convertTestFunction(state.getBackStencilFunction()),
                         0, Integer.MAX_VALUE);
             } else {
@@ -791,7 +807,7 @@ public class JoglRenderer implements Renderer {
     protected void updateUniformLocation(Shader shader, Uniform uniform) {
         GL gl = GLContext.getCurrentGL();
         // passing a null terminated string is not necessary with JOGL 2.0
-        int loc = gl.getGL2GL3().glGetUniformLocation(shader.getId(), uniform.getName());
+        int loc = gl.getGL2ES2().glGetUniformLocation(shader.getId(), uniform.getName());
         if (loc < 0) {
             uniform.setLocation(-1);
             // uniform is not declared in shader
@@ -806,7 +822,7 @@ public class JoglRenderer implements Renderer {
         int shaderId = shader.getId();
         if (context.boundShaderProgram != shaderId) {
             GL gl = GLContext.getCurrentGL();
-            gl.getGL2GL3().glUseProgram(shaderId);
+            gl.getGL2ES2().glUseProgram(shaderId);
             statistics.onShaderUse(shader, true);
             boundShader = shader;
             context.boundShaderProgram = shaderId;
@@ -850,66 +866,66 @@ public class JoglRenderer implements Renderer {
         switch (uniform.getVarType()) {
             case Float:
                 Float f = (Float) uniform.getValue();
-                gl.getGL2GL3().glUniform1f(loc, f.floatValue());
+                gl.getGL2ES2().glUniform1f(loc, f.floatValue());
                 break;
             case Vector2:
                 Vector2f v2 = (Vector2f) uniform.getValue();
-                gl.getGL2GL3().glUniform2f(loc, v2.getX(), v2.getY());
+                gl.getGL2ES2().glUniform2f(loc, v2.getX(), v2.getY());
                 break;
             case Vector3:
                 Vector3f v3 = (Vector3f) uniform.getValue();
-                gl.getGL2GL3().glUniform3f(loc, v3.getX(), v3.getY(), v3.getZ());
+                gl.getGL2ES2().glUniform3f(loc, v3.getX(), v3.getY(), v3.getZ());
                 break;
             case Vector4:
                 Object val = uniform.getValue();
                 if (val instanceof ColorRGBA) {
                     ColorRGBA c = (ColorRGBA) val;
-                    gl.getGL2GL3().glUniform4f(loc, c.r, c.g, c.b, c.a);
+                    gl.getGL2ES2().glUniform4f(loc, c.r, c.g, c.b, c.a);
                 } else if (val instanceof Vector4f) {
                     Vector4f c = (Vector4f) val;
-                    gl.getGL2GL3().glUniform4f(loc, c.x, c.y, c.z, c.w);
+                    gl.getGL2ES2().glUniform4f(loc, c.x, c.y, c.z, c.w);
                 } else {
                     Quaternion c = (Quaternion) uniform.getValue();
-                    gl.getGL2GL3().glUniform4f(loc, c.getX(), c.getY(), c.getZ(), c.getW());
+                    gl.getGL2ES2().glUniform4f(loc, c.getX(), c.getY(), c.getZ(), c.getW());
                 }
                 break;
             case Boolean:
                 Boolean b = (Boolean) uniform.getValue();
-                gl.getGL2GL3().glUniform1i(loc, b.booleanValue() ? GL.GL_TRUE : GL.GL_FALSE);
+                gl.getGL2ES2().glUniform1i(loc, b.booleanValue() ? GL.GL_TRUE : GL.GL_FALSE);
                 break;
             case Matrix3:
                 fb = (FloatBuffer) uniform.getValue();
                 assert fb.remaining() == 9;
-                gl.getGL2GL3().glUniformMatrix3fv(loc, 1, false, fb);
+                gl.getGL2ES2().glUniformMatrix3fv(loc, 1, false, fb);
                 break;
             case Matrix4:
                 fb = (FloatBuffer) uniform.getValue();
                 assert fb.remaining() == 16;
-                gl.getGL2GL3().glUniformMatrix4fv(loc, 1, false, fb);
+                gl.getGL2ES2().glUniformMatrix4fv(loc, 1, false, fb);
                 break;
             case FloatArray:
                 fb = (FloatBuffer) uniform.getValue();
-                gl.getGL2GL3().glUniform1fv(loc, fb.remaining(), fb);
+                gl.getGL2ES2().glUniform1fv(loc, fb.remaining(), fb);
                 break;
             case Vector2Array:
                 fb = (FloatBuffer) uniform.getValue();
-                gl.getGL2GL3().glUniform2fv(loc, fb.remaining(), fb);
+                gl.getGL2ES2().glUniform2fv(loc, fb.remaining(), fb);
                 break;
             case Vector3Array:
                 fb = (FloatBuffer) uniform.getValue();
-                gl.getGL2GL3().glUniform3fv(loc, fb.remaining(), fb);
+                gl.getGL2ES2().glUniform3fv(loc, fb.remaining(), fb);
                 break;
             case Vector4Array:
                 fb = (FloatBuffer) uniform.getValue();
-                gl.getGL2GL3().glUniform4fv(loc, fb.remaining(), fb);
+                gl.getGL2ES2().glUniform4fv(loc, fb.remaining(), fb);
                 break;
             case Matrix4Array:
                 fb = (FloatBuffer) uniform.getValue();
-                gl.getGL2GL3().glUniformMatrix4fv(loc, 1, false, fb);
+                gl.getGL2ES2().glUniformMatrix4fv(loc, 1, false, fb);
                 break;
             case Int:
                 Integer i = (Integer) uniform.getValue();
-                gl.getGL2GL3().glUniform1i(loc, i.intValue());
+                gl.getGL2ES2().glUniform1i(loc, i.intValue());
                 break;
             default:
                 throw new UnsupportedOperationException("Unsupported uniform type: " + uniform.getVarType());
@@ -944,9 +960,9 @@ public class JoglRenderer implements Renderer {
     public int convertShaderType(Shader.ShaderType type) {
         switch (type) {
             case Fragment:
-                return GL2.GL_FRAGMENT_SHADER;
+                return GL2ES2.GL_FRAGMENT_SHADER;
             case Vertex:
-                return GL2.GL_VERTEX_SHADER;
+                return GL2ES2.GL_VERTEX_SHADER;
 //            case Geometry:
 //                return ARBGeometryShader4.GL_GEOMETRY_SHADER_ARB;
             default:
@@ -959,7 +975,7 @@ public class JoglRenderer implements Renderer {
         GL gl = GLContext.getCurrentGL();
         if (id == -1) {
             // Create id
-            id = gl.getGL2GL3().glCreateShader(convertShaderType(source.getType()));
+            id = gl.getGL2ES2().glCreateShader(convertShaderType(source.getType()));
             if (id <= 0) {
                 throw new RendererException("Invalid ID received when trying to create shader.");
             }
@@ -1001,10 +1017,10 @@ public class JoglRenderer implements Renderer {
         codeBuf.get(array);
         codeBuf.rewind();
 
-        gl.getGL2GL3().glShaderSource(id, 1, new String[]{new String(array)}, new int[]{array.length}, 0);
-        gl.getGL2GL3().glCompileShader(id);
+        gl.getGL2ES2().glShaderSource(id, 1, new String[]{new String(array)}, new int[]{array.length}, 0);
+        gl.getGL2ES2().glCompileShader(id);
 
-        gl.getGL2GL3().glGetShaderiv(id, GL2.GL_COMPILE_STATUS, intBuf1);
+        gl.getGL2ES2().glGetShaderiv(id, GL2ES2.GL_COMPILE_STATUS, intBuf1);
 
         boolean compiledOK = intBuf1.get(0) == GL.GL_TRUE;
         String infoLog = null;
@@ -1012,12 +1028,12 @@ public class JoglRenderer implements Renderer {
         if (VALIDATE_SHADER || !compiledOK) {
             // even if compile succeeded, check
             // log for warnings
-            gl.getGL2GL3().glGetShaderiv(id, GL2.GL_INFO_LOG_LENGTH, intBuf1);
+            gl.getGL2ES2().glGetShaderiv(id, GL2ES2.GL_INFO_LOG_LENGTH, intBuf1);
             int length = intBuf1.get(0);
             if (length > 3) {
                 // get infos
                 ByteBuffer logBuf = BufferUtils.createByteBuffer(length);
-                gl.getGL2GL3().glGetShaderInfoLog(id, length, null, logBuf);
+                gl.getGL2ES2().glGetShaderInfoLog(id, length, null, logBuf);
                 byte[] logBytes = new byte[length];
                 logBuf.get(logBytes, 0, length);
                 // convert to string, etc
@@ -1050,7 +1066,7 @@ public class JoglRenderer implements Renderer {
         boolean needRegister = false;
         if (id == -1) {
             // create program
-            id = gl.getGL2GL3().glCreateProgram();
+            id = gl.getGL2ES2().glCreateProgram();
             if (id == 0) {
                 throw new RendererException("Invalid ID (" + id + ") received when trying to create shader program.");
             }
@@ -1063,10 +1079,10 @@ public class JoglRenderer implements Renderer {
             if (source.isUpdateNeeded()) {
                 updateShaderSourceData(source);
             }
-            gl.getGL2GL3().glAttachShader(id, source.getId());
+            gl.getGL2ES2().glAttachShader(id, source.getId());
         }
 
-        if (caps.contains(Caps.OpenGL30)) {
+        if (caps.contains(Caps.OpenGL30) && gl.isGL2GL3()) {
             // Check if GLSL version is 1.5 for shader
             gl.getGL2GL3().glBindFragDataLocation(id, 0, "outFragColor");
             // For MRT
@@ -1076,20 +1092,20 @@ public class JoglRenderer implements Renderer {
         }
 
         // Link shaders to program
-        gl.getGL2GL3().glLinkProgram(id);
+        gl.getGL2ES2().glLinkProgram(id);
 
         // Check link status
-        gl.getGL2GL3().glGetProgramiv(id, GL2.GL_LINK_STATUS, intBuf1);
+        gl.getGL2ES2().glGetProgramiv(id, GL2ES2.GL_LINK_STATUS, intBuf1);
         boolean linkOK = intBuf1.get(0) == GL.GL_TRUE;
         String infoLog = null;
 
         if (VALIDATE_SHADER || !linkOK) {
-            gl.getGL2GL3().glGetProgramiv(id, GL2.GL_INFO_LOG_LENGTH, intBuf1);
+            gl.getGL2ES2().glGetProgramiv(id, GL2ES2.GL_INFO_LOG_LENGTH, intBuf1);
             int length = intBuf1.get(0);
             if (length > 3) {
                 // get infos
                 ByteBuffer logBuf = BufferUtils.createByteBuffer(length);
-                gl.getGL2GL3().glGetProgramInfoLog(id, length, null, logBuf);
+                gl.getGL2ES2().glGetProgramInfoLog(id, length, null, logBuf);
 
                 // convert to string, etc
                 byte[] logBytes = new byte[length];
@@ -1147,7 +1163,7 @@ public class JoglRenderer implements Renderer {
         }
         source.clearUpdateNeeded();
         GL gl = GLContext.getCurrentGL();
-        gl.getGL2GL3().glDeleteShader(source.getId());
+        gl.getGL2ES2().glDeleteShader(source.getId());
         source.resetObject();
     }
 
@@ -1160,12 +1176,12 @@ public class JoglRenderer implements Renderer {
         GL gl = GLContext.getCurrentGL();
         for (ShaderSource source : shader.getSources()) {
             if (source.getId() != -1) {
-                gl.getGL2GL3().glDetachShader(shader.getId(), source.getId());
+                gl.getGL2ES2().glDetachShader(shader.getId(), source.getId());
                 deleteShaderSource(source);
             }
         }
 
-        gl.getGL2GL3().glDeleteProgram(shader.getId());
+        gl.getGL2ES2().glDeleteProgram(shader.getId());
         statistics.onDeleteShader();
         shader.resetObject();
     }
@@ -1179,7 +1195,7 @@ public class JoglRenderer implements Renderer {
 
     public void copyFrameBuffer(FrameBuffer src, FrameBuffer dst, boolean copyDepth) {
         GL gl = GLContext.getCurrentGL();
-        if (gl.isExtensionAvailable("GL_EXT_framebuffer_blit")) {
+        if (gl.isExtensionAvailable("GL_EXT_framebuffer_blit") && gl.isGL2GL3()) {
             int srcX0 = 0;
             int srcY0 = 0;
             int srcX1/* = 0*/;
@@ -1210,24 +1226,24 @@ public class JoglRenderer implements Renderer {
             }
 
             if (src == null) {
-                gl.glBindFramebuffer(GL2.GL_READ_FRAMEBUFFER, 0);
+                gl.glBindFramebuffer(GL2GL3.GL_READ_FRAMEBUFFER, 0);
                 srcX0 = vpX;
                 srcY0 = vpY;
                 srcX1 = vpX + vpW;
                 srcY1 = vpY + vpH;
             } else {
-                gl.glBindFramebuffer(GL2.GL_READ_FRAMEBUFFER, src.getId());
+                gl.glBindFramebuffer(GL2GL3.GL_READ_FRAMEBUFFER, src.getId());
                 srcX1 = src.getWidth();
                 srcY1 = src.getHeight();
             }
             if (dst == null) {
-                gl.glBindFramebuffer(GL2.GL_DRAW_FRAMEBUFFER, 0);
+                gl.glBindFramebuffer(GL2GL3.GL_DRAW_FRAMEBUFFER, 0);
                 dstX0 = vpX;
                 dstY0 = vpY;
                 dstX1 = vpX + vpW;
                 dstY1 = vpY + vpH;
             } else {
-                gl.glBindFramebuffer(GL2.GL_DRAW_FRAMEBUFFER, dst.getId());
+                gl.glBindFramebuffer(GL2GL3.GL_DRAW_FRAMEBUFFER, dst.getId());
                 dstX1 = dst.getWidth();
                 dstY1 = dst.getHeight();
             }
@@ -1238,9 +1254,9 @@ public class JoglRenderer implements Renderer {
             gl.getGL2GL3().glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1,
                     dstX0, dstY0, dstX1, dstY1, mask,
                     GL.GL_NEAREST);
+            gl.glBindFramebuffer(GL2GL3.GL_FRAMEBUFFER, prevFBO);
 
-
-            gl.glBindFramebuffer(GL2.GL_FRAMEBUFFER, prevFBO);
+            
             try {
                 checkFrameBufferError();
             } catch (IllegalStateException ex) {
@@ -1264,7 +1280,7 @@ public class JoglRenderer implements Renderer {
                 return "GL_BACK";
             default:
                 if (buffer >= GL.GL_COLOR_ATTACHMENT0
-                        && buffer <= GL2.GL_COLOR_ATTACHMENT15) {
+                        && buffer <= GL2ES2.GL_COLOR_ATTACHMENT15) {
                     return "GL_COLOR_ATTACHMENT"
                             + (buffer - GL.GL_COLOR_ATTACHMENT0);
                 } else {
@@ -1281,11 +1297,11 @@ public class JoglRenderer implements Renderer {
 
         int attachment = convertAttachmentSlot(rb.getSlot());
 
-        gl.glGetFramebufferAttachmentParameteriv(GL2.GL_DRAW_FRAMEBUFFER,
+        gl.glGetFramebufferAttachmentParameteriv(GL2GL3.GL_DRAW_FRAMEBUFFER,
                 attachment,
                 GL.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE, intBuf16);
         int type = intBuf16.get(0);
-        gl.glGetFramebufferAttachmentParameteriv(GL2.GL_DRAW_FRAMEBUFFER,
+        gl.glGetFramebufferAttachmentParameteriv(GL2GL3.GL_DRAW_FRAMEBUFFER,
                 attachment,
                 GL.GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME, intBuf16);
         int rbName  = intBuf16.get(0);
@@ -1297,7 +1313,7 @@ public class JoglRenderer implements Renderer {
             case GL.GL_TEXTURE:
                 System.out.println("Type: Texture");
                 break;
-            case GL2.GL_RENDERBUFFER:
+            case GL.GL_RENDERBUFFER:
                 System.out.println("Type: Buffer");
                 System.out.println("RB ID: " + rbName);
                 break;
@@ -1310,17 +1326,17 @@ public class JoglRenderer implements Renderer {
     private void printRealFrameBufferInfo(FrameBuffer fb) {
         GL gl = GLContext.getCurrentGL();
         final byte[] param = new byte[1];
-        gl.glGetBooleanv(GL2.GL_DOUBLEBUFFER, param, 0);
+        gl.glGetBooleanv(GL2GL3.GL_DOUBLEBUFFER, param, 0);
         boolean doubleBuffer = param[0] != (byte) 0x00;
-        gl.glGetIntegerv(GL2.GL_DRAW_BUFFER, intBuf16);
+        gl.glGetIntegerv(GL2GL3.GL_DRAW_BUFFER, intBuf16);
         String drawBuf = getTargetBufferName(intBuf16.get(0));
-        gl.glGetIntegerv(GL2.GL_READ_BUFFER, intBuf16);
+        gl.glGetIntegerv(GL2GL3.GL_READ_BUFFER, intBuf16);
         String readBuf = getTargetBufferName(intBuf16.get(0));
 
         int fbId = fb.getId();
-        gl.glGetIntegerv(GL2.GL_DRAW_FRAMEBUFFER_BINDING, intBuf16);
+        gl.glGetIntegerv(GL2GL3.GL_DRAW_FRAMEBUFFER_BINDING, intBuf16);
         int curDrawBinding = intBuf16.get(0);
-        gl.glGetIntegerv(GL2.GL_READ_FRAMEBUFFER_BINDING, intBuf16);
+        gl.glGetIntegerv(GL2GL3.GL_READ_FRAMEBUFFER_BINDING, intBuf16);
         int curReadBinding = intBuf16.get(0);
 
         System.out.println("=== OpenGL FBO State ===");
@@ -1333,7 +1349,7 @@ public class JoglRenderer implements Renderer {
         System.out.println("Read buffer: " + readBuf);
 
         if (context.boundFBO != fbId) {
-            gl.glBindFramebuffer(GL2.GL_DRAW_FRAMEBUFFER, fbId);
+            gl.glBindFramebuffer(GL2GL3.GL_DRAW_FRAMEBUFFER, fbId);
             context.boundFBO = fbId;
         }
 
@@ -1400,7 +1416,7 @@ public class JoglRenderer implements Renderer {
         TextureUtil.GLImageFormat glFmt = TextureUtil.getImageFormatWithError(rb.getFormat());
         
         if (fb.getSamples() > 1 && gl.isExtensionAvailable("GL_EXT_framebuffer_multisample")
-                /*&& gl.isFunctionAvailable("glRenderbufferStorageMultisample")*/) {
+                && gl.isGL2GL3()/*&& gl.isFunctionAvailable("glRenderbufferStorageMultisample")*/) {
             int samples = fb.getSamples();
             if (maxFBOSamples < samples) {
                 samples = maxFBOSamples;
@@ -1505,11 +1521,13 @@ public class JoglRenderer implements Renderer {
         Vector2f[] samplePositions = new Vector2f[fb.getSamples()];
         FloatBuffer samplePos = BufferUtils.createFloatBuffer(2);
         GL gl = GLContext.getCurrentGL();
-        for (int i = 0; i < samplePositions.length; i++) {
-            gl.getGL2GL3().glGetMultisamplefv(GL2.GL_SAMPLE_POSITION, i, samplePos);
-            samplePos.clear();
-            samplePositions[i] = new Vector2f(samplePos.get(0) - 0.5f,
-                    samplePos.get(1) - 0.5f);
+        if (gl.isGL2GL3()) {
+            for (int i = 0; i < samplePositions.length; i++) {
+                gl.getGL2GL3().glGetMultisamplefv(GL2GL3.GL_SAMPLE_POSITION, i, samplePos);
+                samplePos.clear();
+                samplePositions[i] = new Vector2f(samplePos.get(0) - 0.5f,
+                        samplePos.get(1) - 0.5f);
+            }
         }
         return samplePositions;
     }
@@ -1557,11 +1575,15 @@ public class JoglRenderer implements Renderer {
             }
             // select back buffer
             if (context.boundDrawBuf != -1) {
-                gl.getGL2GL3().glDrawBuffer(initialDrawBuf);
+                if (gl.isGL2GL3()) {
+                    gl.getGL2GL3().glDrawBuffer(initialDrawBuf);
+                }
                 context.boundDrawBuf = -1;
             }
             if (context.boundReadBuf != -1) {
-                gl.getGL2GL3().glReadBuffer(initialReadBuf);
+                if (gl.isGL2GL3()) {
+                    gl.getGL2GL3().glReadBuffer(initialReadBuf);
+                }
                 context.boundReadBuf = -1;
             }
 
@@ -1591,11 +1613,15 @@ public class JoglRenderer implements Renderer {
                 // make sure to select NONE as draw buf
                 // no color buffer attached. select NONE
                 if (context.boundDrawBuf != -2) {
-                    gl.getGL2GL3().glDrawBuffer(GL.GL_NONE);
+                    if (gl.isGL2GL3()) {
+                        gl.getGL2GL3().glDrawBuffer(GL.GL_NONE);
+                    }
                     context.boundDrawBuf = -2;
                 }
                 if (context.boundReadBuf != -2) {
-                    gl.getGL2GL3().glReadBuffer(GL.GL_NONE);
+                    if (gl.isGL2GL3()) {
+                        gl.getGL2GL3().glReadBuffer(GL.GL_NONE);
+                    }
                     context.boundReadBuf = -2;
                 }
             } else {
@@ -1618,14 +1644,18 @@ public class JoglRenderer implements Renderer {
                         }
 
                         intBuf16.flip();
-                        gl.getGL2GL3().glDrawBuffers(intBuf16.limit(), intBuf16);
+                        if (gl.isGL2GL3()) {
+                            gl.getGL2GL3().glDrawBuffers(intBuf16.limit(), intBuf16);
+                        }
                         context.boundDrawBuf = 100 + fb.getNumColorBuffers();
                     }
                 } else {
                     RenderBuffer rb = fb.getColorBuffer(fb.getTargetIndex());
                     // select this draw buffer
                     if (context.boundDrawBuf != rb.getSlot()) {
-                        gl.getGL2GL3().glDrawBuffer(GL.GL_COLOR_ATTACHMENT0 + rb.getSlot());
+                        if (gl.isGL2GL3()) {
+                            gl.getGL2GL3().glDrawBuffer(GL.GL_COLOR_ATTACHMENT0 + rb.getSlot());
+                        }
                         context.boundDrawBuf = rb.getSlot();
                     }
                 }
@@ -1656,7 +1686,9 @@ public class JoglRenderer implements Renderer {
 
             setFrameBuffer(fb);
             if (context.boundReadBuf != rb.getSlot()) {
-                gl.getGL2GL3().glReadBuffer(GL.GL_COLOR_ATTACHMENT0 + rb.getSlot());
+                if (gl.isGL2GL3()) {
+                    gl.getGL2GL3().glReadBuffer(GL.GL_COLOR_ATTACHMENT0 + rb.getSlot());
+                }
                 context.boundReadBuf = rb.getSlot();
             }
         } else {
@@ -1702,18 +1734,18 @@ public class JoglRenderer implements Renderer {
         switch (type) {
             case TwoDimensional:
                 if (samples > 1) {
-                    return GL2.GL_TEXTURE_2D_MULTISAMPLE;
+                    return GL2GL3.GL_TEXTURE_2D_MULTISAMPLE;
                 } else {
                     return GL.GL_TEXTURE_2D;
                 }
             case TwoDimensionalArray:
                 if (samples > 1) {
-                    return GL2.GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
+                    return GL2GL3.GL_TEXTURE_2D_MULTISAMPLE_ARRAY;
                 } else {
-                    return GL2.GL_TEXTURE_2D_ARRAY;
+                    return GL.GL_TEXTURE_2D_ARRAY;
                 }
             case ThreeDimensional:
-                return GL2.GL_TEXTURE_3D;
+                return GL2ES2.GL_TEXTURE_3D;
             case CubeMap:
                 if (face < 0) {
                     return GL.GL_TEXTURE_CUBE_MAP;
@@ -1801,13 +1833,13 @@ public class JoglRenderer implements Renderer {
         switch (tex.getType()) {
             case ThreeDimensional:
             case CubeMap: // cubemaps use 3D coords
-                gl.glTexParameteri(target, GL2.GL_TEXTURE_WRAP_R, convertWrapMode(tex.getWrap(WrapAxis.R)));
+                gl.glTexParameteri(target, GL2ES2.GL_TEXTURE_WRAP_R, convertWrapMode(tex.getWrap(WrapAxis.R)));
             case TwoDimensional:
             case TwoDimensionalArray:
-                gl.glTexParameteri(target, GL2.GL_TEXTURE_WRAP_T, convertWrapMode(tex.getWrap(WrapAxis.T)));
+                gl.glTexParameteri(target, GL2ES2.GL_TEXTURE_WRAP_T, convertWrapMode(tex.getWrap(WrapAxis.T)));
                 // fall down here is intentional..
 //            case OneDimensional:
-                gl.glTexParameteri(target, GL2.GL_TEXTURE_WRAP_S, convertWrapMode(tex.getWrap(WrapAxis.S)));
+                gl.glTexParameteri(target, GL2ES2.GL_TEXTURE_WRAP_S, convertWrapMode(tex.getWrap(WrapAxis.S)));
                 break;
             default:
                 throw new UnsupportedOperationException("Unknown texture type: " + tex.getType());
@@ -1816,16 +1848,16 @@ public class JoglRenderer implements Renderer {
         if (tex.isNeedCompareModeUpdate()) {
             // R to Texture compare mode
             if (tex.getShadowCompareMode() != Texture.ShadowCompareMode.Off) {
-                gl.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_MODE, GL2.GL_COMPARE_R_TO_TEXTURE);
+                gl.glTexParameteri(target, GL2ES2.GL_TEXTURE_COMPARE_MODE, GL2.GL_COMPARE_R_TO_TEXTURE);
                 gl.glTexParameteri(target, GL2.GL_DEPTH_TEXTURE_MODE, GL2.GL_INTENSITY);
                 if (tex.getShadowCompareMode() == Texture.ShadowCompareMode.GreaterOrEqual) {
-                    gl.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_FUNC, GL.GL_GEQUAL);
+                    gl.glTexParameteri(target, GL2ES2.GL_TEXTURE_COMPARE_FUNC, GL.GL_GEQUAL);
                 } else {
-                    gl.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_FUNC, GL.GL_LEQUAL);
+                    gl.glTexParameteri(target, GL2ES2.GL_TEXTURE_COMPARE_FUNC, GL.GL_LEQUAL);
                 }
             } else {
                 //restoring default value
-                gl.glTexParameteri(target, GL2.GL_TEXTURE_COMPARE_MODE, GL2.GL_NONE);
+                gl.glTexParameteri(target, GL2ES2.GL_TEXTURE_COMPARE_MODE, GL.GL_NONE);
             }
             tex.compareModeUpdated();
         }
@@ -1869,14 +1901,18 @@ public class JoglRenderer implements Renderer {
             // No pregenerated mips available,
             // generate from base level if required
             if (!gl.isExtensionAvailable("GL_VERSION_3_0")) {
-                gl.glTexParameteri(target, GL2.GL_GENERATE_MIPMAP, GL.GL_TRUE);
+                if (gl.isGL2ES1()) {
+                    gl.glTexParameteri(target, GL2ES1.GL_GENERATE_MIPMAP, GL.GL_TRUE);
+                }
                 img.setMipmapsGenerated(true);
             }
         } else {
             // Image already has mipmaps or no mipmap generation desired.
 //          glTexParameteri(target, GL_TEXTURE_BASE_LEVEL, 0 );
             if (img.getMipMapSizes() != null) {
-                gl.glTexParameteri(target, GL2.GL_TEXTURE_MAX_LEVEL, img.getMipMapSizes().length - 1);
+                if (gl.isGL2GL3()) {
+                    gl.glTexParameteri(target, GL2GL3.GL_TEXTURE_MAX_LEVEL, img.getMipMapSizes().length - 1);
+                }
             }
         }
 
@@ -2055,7 +2091,7 @@ public class JoglRenderer implements Renderer {
             case UnsignedShort:
                 return GL.GL_UNSIGNED_SHORT;
             case Int:
-                return GL2.GL_INT;
+                return GL2ES2.GL_INT;
             case UnsignedInt:
                 return GL.GL_UNSIGNED_INT;
 //            case Half:
@@ -2064,7 +2100,7 @@ public class JoglRenderer implements Renderer {
             case Float:
                 return GL.GL_FLOAT;
             case Double:
-                return GL2.GL_DOUBLE;
+                return GL2GL3.GL_DOUBLE;
             default:
                 throw new UnsupportedOperationException("Unknown buffer format.");
 
@@ -2142,7 +2178,7 @@ public class JoglRenderer implements Renderer {
         for (int i = 0; i < attribList.oldLen; i++) {
             int idx = attribList.oldList[i];
             GL gl = GLContext.getCurrentGL();
-            gl.getGL2GL3().glDisableVertexAttribArray(idx);
+            gl.getGL2ES2().glDisableVertexAttribArray(idx);
             context.boundAttribs[idx] = null;
         }
         context.attribIndexList.copyNewToOld();
@@ -2165,7 +2201,7 @@ public class JoglRenderer implements Renderer {
                 stringBuf.setLength(0);
                 // JOGL 2.0 doesn't need a null terminated string
                 stringBuf.append("in").append(vb.getBufferType().name());
-                loc = gl.getGL2GL3().glGetAttribLocation(programId, stringBuf.toString());
+                loc = gl.getGL2ES2().glGetAttribLocation(programId, stringBuf.toString());
 
                 // not really the name of it in the shader (inPosition\0) but
                 // the internal name of the enum (Position).
@@ -2183,7 +2219,7 @@ public class JoglRenderer implements Renderer {
 
             VertexBuffer[] attribs = context.boundAttribs;
             if (!context.attribIndexList.moveToNew(loc)) {
-                gl.getGL2GL3().glEnableVertexAttribArray(loc);
+                gl.getGL2ES2().glEnableVertexAttribArray(loc);
                 //System.out.println("Enabled ATTRIB IDX: "+loc);
             }
             if (attribs[loc] != vb) {
@@ -2198,7 +2234,7 @@ public class JoglRenderer implements Renderer {
                     //statistics.onVertexBufferUse(vb, false);
                 }
 
-                gl.getGL2GL3().glVertexAttribPointer(loc,
+                gl.getGL2ES2().glVertexAttribPointer(loc,
                         vb.getNumComponents(),
                         convertFormat(vb.getFormat()),
                         vb.isNormalized(),
@@ -2219,8 +2255,10 @@ public class JoglRenderer implements Renderer {
     public void drawTriangleArray(Mesh.Mode mode, int count, int vertCount) {
         GL gl = GLContext.getCurrentGL();
         if (count > 1) {
-            gl.getGL2GL3().glDrawArraysInstanced(convertElementMode(mode), 0,
+            if (gl.isGL2GL3()) {
+                gl.getGL2GL3().glDrawArraysInstanced(convertElementMode(mode), 0,
                     vertCount, count);
+            }
         } else {
             gl.glDrawArrays(convertElementMode(mode), 0, vertCount);
         }
@@ -2239,74 +2277,78 @@ public class JoglRenderer implements Renderer {
         assert bufId != -1;
 
         GL gl = GLContext.getCurrentGL();
-        if (context.boundElementArrayVBO != bufId) {
-            gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, bufId);
-            context.boundElementArrayVBO = bufId;
-            //statistics.onVertexBufferUse(indexBuf, true);
-        } else {
-            //statistics.onVertexBufferUse(indexBuf, true);
-        }
-
-        int vertCount = mesh.getVertexCount();
-        boolean useInstancing = count > 1 && caps.contains(Caps.MeshInstancing);
-
-        if (mesh.getMode() == Mode.Hybrid) {
-            int[] modeStart = mesh.getModeStart();
-            int[] elementLengths = mesh.getElementLengths();
-
-            int elMode = convertElementMode(Mode.Triangles);
-            int fmt = convertFormat(indexBuf.getFormat());
-            int elSize = indexBuf.getFormat().getComponentSize();
-            int listStart = modeStart[0];
-            int stripStart = modeStart[1];
-            int fanStart = modeStart[2];
-            int curOffset = 0;
-            for (int i = 0; i < elementLengths.length; i++) {
-                if (i == stripStart) {
-                    elMode = convertElementMode(Mode.TriangleStrip);
-                } else if (i == fanStart) {
-                    elMode = convertElementMode(Mode.TriangleStrip);
-                }
-                int elementLength = elementLengths[i];
+        if (gl.isGL2GL3()) {
+            if (context.boundElementArrayVBO != bufId) {
+                gl.glBindBuffer(GL.GL_ELEMENT_ARRAY_BUFFER, bufId);
+                context.boundElementArrayVBO = bufId;
+                //statistics.onVertexBufferUse(indexBuf, true);
+            } else {
+                //statistics.onVertexBufferUse(indexBuf, true);
+            }
+
+            int vertCount = mesh.getVertexCount();
+            boolean useInstancing = count > 1 && caps.contains(Caps.MeshInstancing);
+
+            if (mesh.getMode() == Mode.Hybrid) {
+                int[] modeStart = mesh.getModeStart();
+                int[] elementLengths = mesh.getElementLengths();
+
+                int elMode = convertElementMode(Mode.Triangles);
+                int fmt = convertFormat(indexBuf.getFormat());
+                int elSize = indexBuf.getFormat().getComponentSize();
+                int listStart = modeStart[0];
+                int stripStart = modeStart[1];
+                int fanStart = modeStart[2];
+                int curOffset = 0;
+                for (int i = 0; i < elementLengths.length; i++) {
+                    if (i == stripStart) {
+                        elMode = convertElementMode(Mode.TriangleStrip);
+                    } else if (i == fanStart) {
+                        elMode = convertElementMode(Mode.TriangleStrip);
+                    }
+                    int elementLength = elementLengths[i];
+
+                    if (useInstancing) {
+
+                        indexBuf.getData().position(curOffset);
+                        indexBuf.getData().limit(curOffset + elementLength);
+
+                        gl.getGL2GL3().glDrawElementsInstanced(elMode,
+                                elementLength,
+                                fmt,
+                                indexBuf.getData(),
+                                count);
+
+                    } else {
+                        gl.getGL2GL3().glDrawRangeElements(elMode,
+                                0,
+                                vertCount,
+                                elementLength,
+                                fmt,
+                                curOffset);
+                    }
 
+                    //FIXME check whether elSize is required
+                    curOffset += elementLength/* * elSize*/;
+                }
+            } else {
                 if (useInstancing) {
-                    
-                    indexBuf.getData().position(curOffset);
-                    indexBuf.getData().limit(curOffset + elementLength);
-                    
-                    gl.getGL2GL3().glDrawElementsInstanced(elMode,
-                            elementLength,
-                            fmt,
+                    gl.getGL2GL3().glDrawElementsInstanced(convertElementMode(mesh.getMode()),
+                            indexBuf.getData().limit(),
+                            convertFormat(indexBuf.getFormat()),
                             indexBuf.getData(),
                             count);
-                    
                 } else {
-                    gl.getGL2GL3().glDrawRangeElements(elMode,
+                    gl.getGL2GL3().glDrawRangeElements(convertElementMode(mesh.getMode()),
                             0,
                             vertCount,
-                            elementLength,
-                            fmt,
-                            curOffset);
+                            indexBuf.getData().limit(),
+                            convertFormat(indexBuf.getFormat()),
+                            0);
                 }
-
-                //FIXME check whether elSize is required
-                curOffset += elementLength/* * elSize*/;
             }
         } else {
-            if (useInstancing) {
-                gl.getGL2GL3().glDrawElementsInstanced(convertElementMode(mesh.getMode()),
-                        indexBuf.getData().limit(),
-                        convertFormat(indexBuf.getFormat()),
-                        indexBuf.getData(),
-                        count);
-            } else {
-                gl.getGL2GL3().glDrawRangeElements(convertElementMode(mesh.getMode()),
-                        0,
-                        vertCount,
-                        indexBuf.getData().limit(),
-                        convertFormat(indexBuf.getFormat()),
-                        0);
-            }
+            //FIXME: ES impl
         }
     }
 
@@ -2339,13 +2381,17 @@ public class JoglRenderer implements Renderer {
         GL gl = GLContext.getCurrentGL();
         if (id == -1) {
             IntBuffer temp = intBuf1;
-            gl.getGL2GL3().glGenVertexArrays(1, temp);
+            if (gl.isGL2GL3()) {
+                gl.getGL2GL3().glGenVertexArrays(1, temp);
+            }
             id = temp.get(0);
             mesh.setId(id);
         }
 
         if (context.boundVertexArray != id) {
-            gl.getGL2GL3().glBindVertexArray(id);
+            if (gl.isGL2GL3()) {
+                gl.getGL2GL3().glBindVertexArray(id);
+            }
             context.boundVertexArray = id;
         }
 
@@ -2380,7 +2426,9 @@ public class JoglRenderer implements Renderer {
 
         if (context.boundVertexArray != mesh.getId()) {
             GL gl = GLContext.getCurrentGL();
-            gl.getGL2GL3().glBindVertexArray(mesh.getId());
+            if (gl.isGL2GL3()) {
+                gl.getGL2GL3().glBindVertexArray(mesh.getId());
+            }
             context.boundVertexArray = mesh.getId();
         }
 
@@ -2457,14 +2505,20 @@ public class JoglRenderer implements Renderer {
                     gl.glActiveTexture(GL.GL_TEXTURE0);
                     context.boundTextureUnit = 0;
                 }
-                gl.glDisable(GL2.GL_POINT_SPRITE);
-                gl.glDisable(GL2.GL_VERTEX_PROGRAM_POINT_SIZE);
+                if (gl.isGL2ES1()) {
+                    gl.glDisable(GL2ES1.GL_POINT_SPRITE);
+                }
+                if (gl.isGL2GL3()) {
+                    gl.glDisable(GL2GL3.GL_VERTEX_PROGRAM_POINT_SIZE);
+                }
                 context.pointSprite = false;
             }
         }
 
         if (context.pointSize != mesh.getPointSize()) {
-            gl.getGL2GL3().glPointSize(mesh.getPointSize());
+            if (gl.isGL2GL3()) {
+                gl.getGL2GL3().glPointSize(mesh.getPointSize());
+            }
             context.pointSize = mesh.getPointSize();
         }
         if (context.lineWidth != mesh.getLineWidth()) {