First implementation of the unified renderer for the JOGL backend, untested

jme3-jogl/src/main/java/com/jme3/renderer/jogl/JoglGL.java

@@ -0,0 +1,594 @@
+package com.jme3.renderer.jogl;
+
+import com.jme3.renderer.RendererException;
+import com.jme3.renderer.opengl.GL;
+import com.jme3.renderer.opengl.GL2;
+import com.jme3.renderer.opengl.GL3;
+
+import java.nio.Buffer;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+import java.nio.ShortBuffer;
+
+import com.jme3.renderer.opengl.GL4;
+import com.jogamp.opengl.GLContext;
+
+public class JoglGL implements GL, GL2, GL3, GL4 {
+    
+	private static int getLimitBytes(ByteBuffer buffer) {
+        checkLimit(buffer);
+        return buffer.limit();
+    }
+
+    private static int getLimitBytes(ShortBuffer buffer) {
+        checkLimit(buffer);
+        return buffer.limit() * 2;
+    }
+
+    private static int getLimitBytes(FloatBuffer buffer) {
+        checkLimit(buffer);
+        return buffer.limit() * 4;
+    }
+
+    private static int getLimitCount(Buffer buffer, int elementSize) {
+        checkLimit(buffer);
+        return buffer.limit() / elementSize;
+    }
+	
+    private static void checkLimit(Buffer buffer) {
+        if (buffer == null) {
+            return;
+        }
+        if (buffer.limit() == 0) {
+            throw new RendererException("Attempting to upload empty buffer (limit = 0), that's an error");
+        }
+        if (buffer.remaining() == 0) {
+            throw new RendererException("Attempting to upload empty buffer (remaining = 0), that's an error");
+        }
+    }
+    
+    @Override
+	public void resetStats() {
+    }
+    
+    @Override
+	public void glActiveTexture(int param1) {
+        GLContext.getCurrentGL().glActiveTexture(param1);
+    }
+
+    @Override
+	public void glAlphaFunc(int param1, float param2) {
+        GLContext.getCurrentGL().getGL2ES1().glAlphaFunc(param1, param2);
+    }
+
+    @Override
+	public void glAttachShader(int param1, int param2) {
+        GLContext.getCurrentGL().getGL2ES2().glAttachShader(param1, param2);
+    }
+
+    @Override
+	public void glBindBuffer(int param1, int param2) {
+        GLContext.getCurrentGL().glBindBuffer(param1, param2);
+    }
+
+    @Override
+	public void glBindTexture(int param1, int param2) {
+        GLContext.getCurrentGL().glBindTexture(param1, param2);
+    }
+
+    @Override
+	public void glBlendFunc(int param1, int param2) {
+        GLContext.getCurrentGL().glBlendFunc(param1, param2);
+    }
+
+    @Override
+	public void glBufferData(int param1, long param2, int param3) {
+        GLContext.getCurrentGL().glBufferData(param1, param2, null, param3);
+    }
+    
+    @Override
+	public void glBufferData(int param1, FloatBuffer param2, int param3) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().glBufferData(param1, getLimitBytes(param2), param2, param3);
+    }
+
+    @Override
+	public void glBufferData(int param1, ShortBuffer param2, int param3) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().glBufferData(param1, getLimitBytes(param2), param2, param3);
+    }
+
+    @Override
+	public void glBufferData(int param1, ByteBuffer param2, int param3) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().glBufferData(param1, getLimitBytes(param2), param2, param3);
+    }
+
+    @Override
+	public void glBufferSubData(int param1, long param2, FloatBuffer param3) {
+        checkLimit(param3);
+        GLContext.getCurrentGL().glBufferSubData(param1, param2, getLimitBytes(param3), param3);
+    }
+
+    @Override
+	public void glBufferSubData(int param1, long param2, ShortBuffer param3) {
+        checkLimit(param3);
+        GLContext.getCurrentGL().glBufferSubData(param1, param2, getLimitBytes(param3), param3);
+    }
+
+    @Override
+	public void glBufferSubData(int param1, long param2, ByteBuffer param3) {
+        checkLimit(param3);
+        GLContext.getCurrentGL().glBufferSubData(param1, param2, getLimitBytes(param3), param3);
+    }
+
+    @Override
+	public void glClear(int param1) {
+        GLContext.getCurrentGL().glClear(param1);
+    }
+
+    @Override
+	public void glClearColor(float param1, float param2, float param3, float param4) {
+        GLContext.getCurrentGL().glClearColor(param1, param2, param3, param4);
+    }
+
+    @Override
+	public void glColorMask(boolean param1, boolean param2, boolean param3, boolean param4) {
+        GLContext.getCurrentGL().glColorMask(param1, param2, param3, param4);
+    }
+
+    @Override
+	public void glCompileShader(int param1) {
+        GLContext.getCurrentGL().getGL2ES2().glCompileShader(param1);
+    }
+
+    @Override
+	public void glCompressedTexImage2D(int param1, int param2, int param3, int param4, int param5, int param6, ByteBuffer param7) {
+        checkLimit(param7);
+        GLContext.getCurrentGL().glCompressedTexImage2D(param1, param2, param3, param4, param5, param6, getLimitBytes(param7), param7);
+    }
+
+    @Override
+	public void glCompressedTexImage3D(int param1, int param2, int param3, int param4, int param5, int param6, int param7, ByteBuffer param8) {
+        checkLimit(param8);
+        GLContext.getCurrentGL().getGL2ES2().glCompressedTexImage3D(param1, param2, param3, param4, param5, param6, param7, getLimitBytes(param8), param8);
+    }
+
+    @Override
+	public void glCompressedTexSubImage2D(int param1, int param2, int param3, int param4, int param5, int param6, int param7, ByteBuffer param8) {
+        checkLimit(param8);
+        GLContext.getCurrentGL().glCompressedTexSubImage2D(param1, param2, param3, param4, param5, param6, param7, getLimitBytes(param8), param8);
+    }
+
+    @Override
+	public void glCompressedTexSubImage3D(int param1, int param2, int param3, int param4, int param5, int param6, int param7, int param8, int param9, ByteBuffer param10) {
+        checkLimit(param10);
+        GLContext.getCurrentGL().getGL2ES2().glCompressedTexSubImage3D(param1, param2, param3, param4, param5, param6, param7, param8, param9, getLimitBytes(param10), param10);
+    }
+
+    @Override
+	public int glCreateProgram() {
+        return GLContext.getCurrentGL().getGL2ES2().glCreateProgram();
+    }
+
+    @Override
+	public int glCreateShader(int param1) {
+        return GLContext.getCurrentGL().getGL2ES2().glCreateShader(param1);
+    }
+
+    @Override
+	public void glCullFace(int param1) {
+        GLContext.getCurrentGL().glCullFace(param1);
+    }
+
+    @Override
+	public void glDeleteBuffers(IntBuffer param1) {
+        checkLimit(param1);
+        GLContext.getCurrentGL().glDeleteBuffers(param1.limit(), param1);
+    }
+
+    @Override
+	public void glDeleteProgram(int param1) {
+        GLContext.getCurrentGL().getGL2ES2().glDeleteProgram(param1);
+    }
+
+    @Override
+	public void glDeleteShader(int param1) {
+        GLContext.getCurrentGL().getGL2ES2().glDeleteShader(param1);
+    }
+
+    @Override
+	public void glDeleteTextures(IntBuffer param1) {
+        checkLimit(param1);
+        GLContext.getCurrentGL().glDeleteTextures(param1.limit() ,param1);
+    }
+
+    @Override
+	public void glDepthFunc(int param1) {
+        GLContext.getCurrentGL().glDepthFunc(param1);
+    }
+
+    @Override
+	public void glDepthMask(boolean param1) {
+        GLContext.getCurrentGL().glDepthMask(param1);
+    }
+
+    @Override
+	public void glDepthRange(double param1, double param2) {
+        GLContext.getCurrentGL().glDepthRange(param1, param2);
+    }
+
+    @Override
+	public void glDetachShader(int param1, int param2) {
+        GLContext.getCurrentGL().getGL2ES2().glDetachShader(param1, param2);
+    }
+
+    @Override
+	public void glDisable(int param1) {
+        GLContext.getCurrentGL().glDisable(param1);
+    }
+
+    @Override
+	public void glDisableVertexAttribArray(int param1) {
+        GLContext.getCurrentGL().getGL2ES2().glDisableVertexAttribArray(param1);
+    }
+
+    @Override
+	public void glDrawArrays(int param1, int param2, int param3) {
+        GLContext.getCurrentGL().glDrawArrays(param1, param2, param3);
+    }
+
+    @Override
+	public void glDrawBuffer(int param1) {
+        GLContext.getCurrentGL().getGL2GL3().glDrawBuffer(param1);
+    }
+    
+    @Override
+	public void glDrawRangeElements(int param1, int param2, int param3, int param4, int param5, long param6) {
+        GLContext.getCurrentGL().getGL2ES3().glDrawRangeElements(param1, param2, param3, param4, param5, param6);
+    }
+
+    @Override
+	public void glEnable(int param1) {
+        GLContext.getCurrentGL().glEnable(param1);
+    }
+
+    @Override
+	public void glEnableVertexAttribArray(int param1) {
+        GLContext.getCurrentGL().getGL2ES2().glEnableVertexAttribArray(param1);
+    }
+
+    @Override
+	public void glGenBuffers(IntBuffer param1) {
+        checkLimit(param1);
+        GLContext.getCurrentGL().glGenBuffers(param1.limit(), param1);
+    }
+
+    @Override
+	public void glGenTextures(IntBuffer param1) {
+        checkLimit(param1);
+        GLContext.getCurrentGL().glGenTextures(param1.limit(), param1);
+    }
+
+    @Override
+	public void glGetBoolean(int param1, ByteBuffer param2) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().glGetBooleanv(param1, param2);
+    }
+    
+    @Override
+	public void glGetBufferSubData(int target, long offset, ByteBuffer data) {
+        checkLimit(data);
+        GLContext.getCurrentGL().getGL2GL3().glGetBufferSubData(target, offset, getLimitBytes(data), data);
+    }
+
+    @Override
+	public int glGetError() {
+        return GLContext.getCurrentGL().glGetError();
+    }
+    
+    @Override
+	public void glGetInteger(int param1, IntBuffer param2) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().glGetIntegerv(param1, param2);
+    }
+
+    @Override
+	public void glGetProgram(int param1, int param2, IntBuffer param3) {
+        checkLimit(param3);
+        GLContext.getCurrentGL().getGL2ES2().glGetProgramiv(param1, param2, param3);
+    }
+
+    @Override
+	public void glGetShader(int param1, int param2, IntBuffer param3) {
+        checkLimit(param3);
+        GLContext.getCurrentGL().getGL2ES2().glGetShaderiv(param1, param2, param3);
+    }
+
+    @Override
+	public String glGetString(int param1) {
+        return GLContext.getCurrentGL().glGetString(param1);
+    }
+    
+    @Override
+	public String glGetString(int param1, int param2) {
+        return GLContext.getCurrentGL().getGL2ES3().glGetStringi(param1, param2);
+    }
+
+    @Override
+	public boolean glIsEnabled(int param1) {
+        return GLContext.getCurrentGL().glIsEnabled(param1);
+    }
+
+    @Override
+	public void glLineWidth(float param1) {
+        GLContext.getCurrentGL().glLineWidth(param1);
+    }
+
+    @Override
+	public void glLinkProgram(int param1) {
+        GLContext.getCurrentGL().getGL2ES2().glLinkProgram(param1);
+    }
+
+    @Override
+	public void glPixelStorei(int param1, int param2) {
+        GLContext.getCurrentGL().glPixelStorei(param1, param2);
+    }
+
+    @Override
+	public void glPointSize(float param1) {
+        GLContext.getCurrentGL().getGL2ES1().glPointSize(param1);
+    }
+
+    @Override
+	public void glPolygonMode(int param1, int param2) {
+        GLContext.getCurrentGL().getGL2().glPolygonMode(param1, param2);
+    }
+
+    @Override
+	public void glPolygonOffset(float param1, float param2) {
+        GLContext.getCurrentGL().glPolygonOffset(param1, param2);
+    }
+
+    @Override
+	public void glReadBuffer(int param1) {
+        GLContext.getCurrentGL().getGL2ES3().glReadBuffer(param1);
+    }
+
+    @Override
+	public void glReadPixels(int param1, int param2, int param3, int param4, int param5, int param6, ByteBuffer param7) {
+        checkLimit(param7);
+        GLContext.getCurrentGL().glReadPixels(param1, param2, param3, param4, param5, param6, param7);
+    }
+    
+    @Override
+	public void glReadPixels(int param1, int param2, int param3, int param4, int param5, int param6, long param7) {
+        GLContext.getCurrentGL().glReadPixels(param1, param2, param3, param4, param5, param6, param7);
+    }
+
+    @Override
+	public void glScissor(int param1, int param2, int param3, int param4) {
+        GLContext.getCurrentGL().glScissor(param1, param2, param3, param4);
+    }
+
+    @Override
+	public void glStencilFuncSeparate(int param1, int param2, int param3, int param4) {
+        GLContext.getCurrentGL().getGL2ES2().glStencilFuncSeparate(param1, param2, param3, param4);
+    }
+
+    @Override
+	public void glStencilOpSeparate(int param1, int param2, int param3, int param4) {
+        GLContext.getCurrentGL().getGL2ES2().glStencilOpSeparate(param1, param2, param3, param4);
+    }
+
+    @Override
+	public void glTexImage2D(int param1, int param2, int param3, int param4, int param5, int param6, int param7, int param8, ByteBuffer param9) {
+        checkLimit(param9);
+        GLContext.getCurrentGL().glTexImage2D(param1, param2, param3, param4, param5, param6, param7, param8, param9);
+    }
+
+    @Override
+	public void glTexImage3D(int param1, int param2, int param3, int param4, int param5, int param6, int param7, int param8, int param9, ByteBuffer param10) {
+        checkLimit(param10);
+        GLContext.getCurrentGL().getGL2ES2().glTexImage3D(param1, param2, param3, param4, param5, param6, param7, param8, param9, param10);
+    }
+
+    @Override
+	public void glTexParameterf(int param1, int param2, float param3) {
+        GLContext.getCurrentGL().glTexParameterf(param1, param2, param3);
+    }
+
+    @Override
+	public void glTexParameteri(int param1, int param2, int param3) {
+        GLContext.getCurrentGL().glTexParameteri(param1, param2, param3);
+    }
+
+    @Override
+	public void glTexSubImage2D(int param1, int param2, int param3, int param4, int param5, int param6, int param7, int param8, ByteBuffer param9) {
+        checkLimit(param9);
+        GLContext.getCurrentGL().glTexSubImage2D(param1, param2, param3, param4, param5, param6, param7, param8, param9);
+    }
+
+    @Override
+	public void glTexSubImage3D(int param1, int param2, int param3, int param4, int param5, int param6, int param7, int param8, int param9, int param10, ByteBuffer param11) {
+        checkLimit(param11);
+        GLContext.getCurrentGL().getGL2ES2().glTexSubImage3D(param1, param2, param3, param4, param5, param6, param7, param8, param9, param10, param11);
+    }
+
+    @Override
+	public void glUniform1(int param1, FloatBuffer param2) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().getGL2ES2().glUniform1fv(param1, getLimitCount(param2, 1), param2);
+    }
+
+    @Override
+	public void glUniform1(int param1, IntBuffer param2) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().getGL2ES2().glUniform1iv(param1, getLimitCount(param2, 1), param2);
+    }
+
+    @Override
+	public void glUniform1f(int param1, float param2) {
+        GLContext.getCurrentGL().getGL2ES2().glUniform1f(param1, param2);
+    }
+
+    @Override
+	public void glUniform1i(int param1, int param2) {
+        GLContext.getCurrentGL().getGL2ES2().glUniform1i(param1, param2);
+    }
+
+    @Override
+	public void glUniform2(int param1, IntBuffer param2) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().getGL2ES2().glUniform2iv(param1, getLimitCount(param2, 2), param2);
+    }
+
+    @Override
+	public void glUniform2(int param1, FloatBuffer param2) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().getGL2ES2().glUniform2fv(param1, getLimitCount(param2, 2), param2);
+    }
+
+    @Override
+	public void glUniform2f(int param1, float param2, float param3) {
+        GLContext.getCurrentGL().getGL2ES2().glUniform2f(param1, param2, param3);
+    }
+
+    @Override
+	public void glUniform3(int param1, IntBuffer param2) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().getGL2ES2().glUniform3iv(param1, getLimitCount(param2, 3), param2);
+    }
+
+    @Override
+	public void glUniform3(int param1, FloatBuffer param2) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().getGL2ES2().glUniform3fv(param1, getLimitCount(param2, 3), param2);
+    }
+
+    @Override
+	public void glUniform3f(int param1, float param2, float param3, float param4) {
+        GLContext.getCurrentGL().getGL2ES2().glUniform3f(param1, param2, param3, param4);
+    }
+
+    @Override
+	public void glUniform4(int param1, FloatBuffer param2) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().getGL2ES2().glUniform4fv(param1, getLimitCount(param2, 4), param2);
+    }
+
+    @Override
+	public void glUniform4(int param1, IntBuffer param2) {
+        checkLimit(param2);
+        GLContext.getCurrentGL().getGL2ES2().glUniform4iv(param1, getLimitCount(param2, 4), param2);
+    }
+
+    @Override
+	public void glUniform4f(int param1, float param2, float param3, float param4, float param5) {
+        GLContext.getCurrentGL().getGL2ES2().glUniform4f(param1, param2, param3, param4, param5);
+    }
+
+    @Override
+	public void glUniformMatrix3(int param1, boolean param2, FloatBuffer param3) {
+        checkLimit(param3);
+        GLContext.getCurrentGL().getGL2ES2().glUniformMatrix3fv(param1, getLimitCount(param3, 3 * 3), param2, param3);
+    }
+
+    @Override
+	public void glUniformMatrix4(int param1, boolean param2, FloatBuffer param3) {
+        checkLimit(param3);
+        GLContext.getCurrentGL().getGL2ES2().glUniformMatrix4fv(param1, getLimitCount(param3, 4 * 4), param2, param3);
+    }
+
+    @Override
+	public void glUseProgram(int param1) {
+        GLContext.getCurrentGL().getGL2ES2().glUseProgram(param1);
+    }
+
+    @Override
+	public void glVertexAttribPointer(int param1, int param2, int param3, boolean param4, int param5, long param6) {
+        GLContext.getCurrentGL().getGL2ES2().glVertexAttribPointer(param1, param2, param3, param4, param5, param6);
+    }
+
+    @Override
+	public void glViewport(int param1, int param2, int param3, int param4) {
+        GLContext.getCurrentGL().glViewport(param1, param2, param3, param4);
+    }
+
+    @Override
+	public int glGetAttribLocation(int param1, String param2) {
+        // FIXME: Does JOGL require null-terminated strings?????
+        return GLContext.getCurrentGL().getGL2ES2().glGetAttribLocation(param1, param2 + "\0");
+    }
+
+    @Override
+	public int glGetUniformLocation(int param1, String param2) {
+        // FIXME: Does JOGL require null-terminated strings????????
+        return GLContext.getCurrentGL().getGL2ES2().glGetUniformLocation(param1, param2 + "\0");
+    }
+
+    @Override
+	public void glShaderSource(int param1, String[] param2, IntBuffer param3) {
+        checkLimit(param3);
+        GLContext.getCurrentGL().getGL2ES2().glShaderSource(param1, param2.length, param2, param3);
+    }
+
+    @Override
+	public String glGetProgramInfoLog(int program, int maxSize) {
+    	ByteBuffer buffer = ByteBuffer.allocateDirect(maxSize);
+		buffer.order(ByteOrder.nativeOrder());
+		ByteBuffer tmp = ByteBuffer.allocateDirect(4);
+		tmp.order(ByteOrder.nativeOrder());
+		IntBuffer intBuffer = tmp.asIntBuffer();
+
+		GLContext.getCurrentGL().getGL2ES2().glGetProgramInfoLog(program, maxSize, intBuffer, buffer);
+		int numBytes = intBuffer.get(0);
+		byte[] bytes = new byte[numBytes];
+		buffer.get(bytes);
+		return new String(bytes);
+    }
+
+    @Override
+	public String glGetShaderInfoLog(int shader, int maxSize) {
+    	ByteBuffer buffer = ByteBuffer.allocateDirect(maxSize);
+		buffer.order(ByteOrder.nativeOrder());
+		ByteBuffer tmp = ByteBuffer.allocateDirect(4);
+		tmp.order(ByteOrder.nativeOrder());
+		IntBuffer intBuffer = tmp.asIntBuffer();
+
+		GLContext.getCurrentGL().getGL2ES2().glGetShaderInfoLog(shader, maxSize, intBuffer, buffer);
+		int numBytes = intBuffer.get(0);
+		byte[] bytes = new byte[numBytes];
+		buffer.get(bytes);
+		return new String(bytes);
+    }
+
+    @Override
+	public void glBindFragDataLocation(int param1, int param2, String param3) {
+        GLContext.getCurrentGL().getGL2GL3().glBindFragDataLocation(param1, param2, param3);
+    }
+
+    @Override
+	public void glBindVertexArray(int param1) {
+        GLContext.getCurrentGL().getGL2ES3().glBindVertexArray(param1);
+    }
+
+    @Override
+	public void glGenVertexArrays(IntBuffer param1) {
+        checkLimit(param1);
+        GLContext.getCurrentGL().getGL2ES3().glGenVertexArrays(param1.limit(), param1);
+    }
+
+    @Override
+	public void glPatchParameter(int count) {
+        GLContext.getCurrentGL().getGL3().glPatchParameteri(com.jogamp.opengl.GL3.GL_PATCH_VERTICES, count);
+    }
+    
+    @Override
+	public void glDeleteVertexArrays(IntBuffer arrays) {
+        checkLimit(arrays);
+        GLContext.getCurrentGL().getGL2ES3().glDeleteVertexArrays(arrays.limit(), arrays);
+    }
+}

jme3-jogl/src/main/java/com/jme3/renderer/jogl/JoglGLExt.java

@@ -0,0 +1,88 @@
+package com.jme3.renderer.jogl;
+
+import com.jme3.renderer.RendererException;
+import com.jme3.renderer.opengl.GLExt;
+import com.jogamp.opengl.GLContext;
+
+import java.nio.Buffer;
+import java.nio.FloatBuffer;
+import java.nio.IntBuffer;
+
+public class JoglGLExt implements GLExt {
+
+	private static int getLimitBytes(IntBuffer buffer) {
+        checkLimit(buffer);
+        return buffer.limit() * 4;
+    }
+	
+    private static void checkLimit(Buffer buffer) {
+        if (buffer == null) {
+            return;
+        }
+        if (buffer.limit() == 0) {
+            throw new RendererException("Attempting to upload empty buffer (limit = 0), that's an error");
+        }
+        if (buffer.remaining() == 0) {
+            throw new RendererException("Attempting to upload empty buffer (remaining = 0), that's an error");
+        }
+    }
+
+    @Override
+    public void glBufferData(int target, IntBuffer data, int usage) {
+        checkLimit(data);
+        GLContext.getCurrentGL().glBufferData(target, getLimitBytes(data), data, usage);
+    }
+
+    @Override
+    public void glBufferSubData(int target, long offset, IntBuffer data) {
+        checkLimit(data);
+        GLContext.getCurrentGL().glBufferSubData(target, getLimitBytes(data), offset, data);
+    }
+
+    @Override
+    public void glDrawArraysInstancedARB(int mode, int first, int count, int primcount) {
+        GLContext.getCurrentGL().getGL2ES3().glDrawArraysInstanced(mode, first, count, primcount);
+    }
+
+    @Override
+    public void glDrawBuffers(IntBuffer bufs) {
+        checkLimit(bufs);
+        GLContext.getCurrentGL().getGL2ES2().glDrawBuffers(bufs.limit(), bufs);
+    }
+
+    @Override
+    public void glDrawElementsInstancedARB(int mode, int indices_count, int type, long indices_buffer_offset, int primcount) {
+        GLContext.getCurrentGL().getGL2ES3().glDrawElementsInstanced(mode, indices_count, type, indices_buffer_offset, primcount);
+    }
+
+    @Override
+    public void glGetMultisample(int pname, int index, FloatBuffer val) {
+        checkLimit(val);
+        GLContext.getCurrentGL().getGL2ES2().glGetMultisamplefv(pname, index, val);
+    }
+
+    @Override
+    public void glTexImage2DMultisample(int target, int samples, int internalformat, int width, int height, boolean fixedsamplelocations) {
+        GLContext.getCurrentGL().getGL2ES2().glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
+    }
+
+    @Override
+    public void glVertexAttribDivisorARB(int index, int divisor) {
+        GLContext.getCurrentGL().getGL2ES3().glVertexAttribDivisor(index, divisor);
+    }
+
+    @Override
+    public Object glFenceSync(int condition, int flags) {
+        return GLContext.getCurrentGL().getGL3ES3().glFenceSync(condition, flags);
+    }
+    
+    @Override
+    public int glClientWaitSync(Object sync, int flags, long timeout) {
+        return GLContext.getCurrentGL().getGL3ES3().glClientWaitSync((long) sync, flags, timeout);
+    }
+
+    @Override
+    public void glDeleteSync(Object sync) {
+        GLContext.getCurrentGL().getGL3ES3().glDeleteSync((long) sync);
+    }
+}

jme3-jogl/src/main/java/com/jme3/renderer/jogl/JoglGLFbo.java

@@ -0,0 +1,97 @@
+package com.jme3.renderer.jogl;
+
+import com.jme3.renderer.RendererException;
+import com.jme3.renderer.opengl.GLFbo;
+import com.jogamp.opengl.GLContext;
+
+import java.nio.Buffer;
+import java.nio.IntBuffer;
+
+/**
+ * Implements GLFbo
+ * 
+ * @author Kirill Vainer
+ */
+public class JoglGLFbo implements GLFbo {
+
+    private static void checkLimit(Buffer buffer) {
+        if (buffer == null) {
+            return;
+        }
+        if (buffer.limit() == 0) {
+            throw new RendererException("Attempting to upload empty buffer (limit = 0), that's an error");
+        }
+        if (buffer.remaining() == 0) {
+            throw new RendererException("Attempting to upload empty buffer (remaining = 0), that's an error");
+        }
+    }
+    
+    @Override
+    public void glBlitFramebufferEXT(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, int mask, int filter) {
+        GLContext.getCurrentGL().getGL2ES3().glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
+    }
+    
+    @Override
+    public void glRenderbufferStorageMultisampleEXT(int target, int samples, int internalformat, int width, int height) {
+        GLContext.getCurrentGL().glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
+    }
+    
+    @Override
+    public void glBindFramebufferEXT(int param1, int param2) {
+        GLContext.getCurrentGL().glBindFramebuffer(param1, param2);
+    }
+    
+    @Override
+    public void glBindRenderbufferEXT(int param1, int param2) {
+        GLContext.getCurrentGL().glBindRenderbuffer(param1, param2);
+    }
+    
+    @Override
+    public int glCheckFramebufferStatusEXT(int param1) {
+        return GLContext.getCurrentGL().glCheckFramebufferStatus(param1);
+    }
+    
+    @Override
+    public void glDeleteFramebuffersEXT(IntBuffer param1) {
+        checkLimit(param1);
+        GLContext.getCurrentGL().glDeleteFramebuffers(param1.limit(), param1);
+    }
+    
+    @Override
+    public void glDeleteRenderbuffersEXT(IntBuffer param1) {
+        checkLimit(param1);
+        GLContext.getCurrentGL().glDeleteRenderbuffers(param1.limit(), param1);
+    }
+    
+    @Override
+    public void glFramebufferRenderbufferEXT(int param1, int param2, int param3, int param4) {
+        GLContext.getCurrentGL().glFramebufferRenderbuffer(param1, param2, param3, param4);
+    }
+    
+    @Override
+    public void glFramebufferTexture2DEXT(int param1, int param2, int param3, int param4, int param5) {
+        GLContext.getCurrentGL().glFramebufferTexture2D(param1, param2, param3, param4, param5);
+    }
+    
+    @Override
+    public void glGenFramebuffersEXT(IntBuffer param1) {
+        checkLimit(param1);
+        GLContext.getCurrentGL().glGenFramebuffers(param1.limit(), param1);
+    }
+    
+    @Override
+    public void glGenRenderbuffersEXT(IntBuffer param1) {
+        checkLimit(param1);
+        GLContext.getCurrentGL().glGenRenderbuffers(param1.limit(), param1);
+    }
+    
+    @Override
+    public void glGenerateMipmapEXT(int param1) {
+        GLContext.getCurrentGL().glGenerateMipmap(param1);
+    }
+    
+    @Override
+    public void glRenderbufferStorageEXT(int param1, int param2, int param3, int param4) {
+        GLContext.getCurrentGL().glRenderbufferStorage(param1, param2, param3, param4);
+    }
+}

jme3-jogl/src/main/java/com/jme3/system/jogl/JoglAbstractDisplay.java

@@ -128,7 +128,8 @@ public abstract class JoglAbstractDisplay extends JoglContext implements GLEvent
         canvas.setIgnoreRepaint(true);
         canvas.addGLEventListener(this);
 
-        if (settings.getBoolean("GraphicsDebug")) {
+        //TODO remove this block once for all when the unified renderer is stable
+        /*if (settings.getBoolean("GraphicsDebug")) {
             canvas.invoke(false, new GLRunnable() {
                 public boolean run(GLAutoDrawable glad) {
                     GL gl = glad.getGL();
@@ -177,7 +178,7 @@ public abstract class JoglAbstractDisplay extends JoglContext implements GLEvent
                 renderer.setMainFrameBufferSrgb(settings.getGammaCorrection());
                 return true;
             }
-        });
+        });*/
     }
 
     protected void startGLCanvas() {

jme3-jogl/src/main/java/com/jme3/system/jogl/JoglCanvas.java

@@ -41,28 +41,34 @@ public class JoglCanvas extends JoglAbstractDisplay implements JmeCanvasContext
 
     private static final Logger logger = Logger.getLogger(JoglCanvas.class.getName());
     private int width, height;
+    private boolean runningFirstTime = true;
 
     public JoglCanvas(){
         super();
         initGLCanvas();
     }
 
-    public Type getType() {
+    @Override
+	public Type getType() {
         return Type.Canvas;
     }
 
-    public void setTitle(String title) {
+    @Override
+	public void setTitle(String title) {
     }
 
-    public void restart() {
+    @Override
+	public void restart() {
     }
 
-    public void create(boolean waitFor){
+    @Override
+	public void create(boolean waitFor){
         if (waitFor)
             waitFor(true);
     }
 
-    public void destroy(boolean waitFor){
+    @Override
+	public void destroy(boolean waitFor){
         if (waitFor)
             waitFor(false);
         if (animator.isAnimating())
@@ -81,13 +87,20 @@ public class JoglCanvas extends JoglAbstractDisplay implements JmeCanvasContext
         startGLCanvas();
     }
 
-    public void init(GLAutoDrawable drawable) {
+    @Override
+	public void init(GLAutoDrawable drawable) {
         canvas.requestFocus();
 
         super.internalCreate();
         logger.fine("Display created.");
 
-        renderer.initialize();
+        // At this point, the OpenGL context is active.
+        if (runningFirstTime){
+            // THIS is the part that creates the renderer.
+            // It must always be called, now that we have the pbuffer workaround.
+            initContextFirstTime();
+            runningFirstTime = false;
+        }
         listener.initialize();
     }
 
@@ -97,7 +110,8 @@ public class JoglCanvas extends JoglAbstractDisplay implements JmeCanvasContext
         super.startGLCanvas();
     }
 
-    public void display(GLAutoDrawable glad) {
+    @Override
+	public void display(GLAutoDrawable glad) {
         if (!created.get() && renderer != null){
             listener.destroy();
             logger.fine("Canvas destroyed.");
@@ -129,7 +143,8 @@ public class JoglCanvas extends JoglAbstractDisplay implements JmeCanvasContext
 
     }
 
-    public Canvas getCanvas() {
+    @Override
+	public Canvas getCanvas() {
         return canvas;
     }
 

jme3-jogl/src/main/java/com/jme3/system/jogl/JoglContext.java

@@ -36,17 +36,32 @@ import com.jme3.input.JoyInput;
 import com.jme3.input.KeyInput;
 import com.jme3.input.MouseInput;
 import com.jme3.renderer.Renderer;
-import com.jme3.renderer.jogl.JoglRenderer;
+import com.jme3.renderer.RendererException;
+import com.jme3.renderer.jogl.JoglGL;
+import com.jme3.renderer.jogl.JoglGLExt;
+import com.jme3.renderer.jogl.JoglGLFbo;
+import com.jme3.renderer.opengl.GL2;
+import com.jme3.renderer.opengl.GL3;
+import com.jme3.renderer.opengl.GL4;
+import com.jme3.renderer.opengl.GLDebugDesktop;
+import com.jme3.renderer.opengl.GLExt;
+import com.jme3.renderer.opengl.GLFbo;
+import com.jme3.renderer.opengl.GLRenderer;
+import com.jme3.renderer.opengl.GLTiming;
+import com.jme3.renderer.opengl.GLTimingState;
+import com.jme3.renderer.opengl.GLTracer;
 import com.jme3.system.AppSettings;
 import com.jme3.system.JmeContext;
 import com.jme3.system.NanoTimer;
 import com.jme3.system.NativeLibraryLoader;
 import com.jme3.system.SystemListener;
 import com.jme3.system.Timer;
+
 import java.nio.IntBuffer;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.logging.Level;
 import java.util.logging.Logger;
+
 import com.jogamp.opengl.GL;
 import com.jogamp.opengl.GL2GL3;
 import com.jogamp.opengl.GLContext;
@@ -62,7 +77,7 @@ public abstract class JoglContext implements JmeContext {
     protected final Object createdLock = new Object();
 
     protected AppSettings settings = new AppSettings(true);
-    protected JoglRenderer renderer;
+    protected Renderer renderer;
     protected Timer timer;
     protected SystemListener listener;
 
@@ -77,43 +92,53 @@ public abstract class JoglContext implements JmeContext {
         }
     }
     
-    public void setSystemListener(SystemListener listener){
+    @Override
+	public void setSystemListener(SystemListener listener){
         this.listener = listener;
     }
 
-    public void setSettings(AppSettings settings) {
+    @Override
+	public void setSettings(AppSettings settings) {
         this.settings.copyFrom(settings);
     }
     
-    public boolean isRenderable(){
+    @Override
+	public boolean isRenderable(){
         return renderable.get();
     }
 
-    public AppSettings getSettings() {
+    @Override
+	public AppSettings getSettings() {
         return settings;
     }
 
-    public Renderer getRenderer() {
+    @Override
+	public Renderer getRenderer() {
         return renderer;
     }
 
-    public MouseInput getMouseInput() {
+    @Override
+	public MouseInput getMouseInput() {
         return mouseInput;
     }
 
-    public KeyInput getKeyInput() {
+    @Override
+	public KeyInput getKeyInput() {
         return keyInput;
     }
 
-    public JoyInput getJoyInput() {
+    @Override
+	public JoyInput getJoyInput() {
         return joyInput;
     }
 
-    public Timer getTimer() {
+    @Override
+	public Timer getTimer() {
         return timer;
     }
 
-    public boolean isCreated() {
+    @Override
+	public boolean isCreated() {
         return created.get();
     }
 
@@ -135,13 +160,76 @@ public abstract class JoglContext implements JmeContext {
             }
         }
     }
+    
+    protected void initContextFirstTime(){
+        if (GLContext.getCurrent().getGLVersionNumber().getMajor() < 2) {
+            throw new RendererException("OpenGL 2.0 or higher is " + 
+                                        "required for jMonkeyEngine");
+        }
+        
+        if (settings.getRenderer().equals("JOGL")) {
+        	com.jme3.renderer.opengl.GL gl = new JoglGL();
+        	GLExt glext = new JoglGLExt();
+        	GLFbo glfbo = new JoglGLFbo();
+            
+            if (settings.getBoolean("GraphicsDebug")) {
+                gl    = new GLDebugDesktop(gl, glext, glfbo);
+                glext = (GLExt) gl;
+                glfbo = (GLFbo) gl;
+            }
+            
+            if (settings.getBoolean("GraphicsTiming")) {
+                GLTimingState timingState = new GLTimingState();
+                gl    = (com.jme3.renderer.opengl.GL) GLTiming.createGLTiming(gl, timingState, GL.class, GL2.class, GL3.class, GL4.class);
+                glext = (GLExt) GLTiming.createGLTiming(glext, timingState, GLExt.class);
+                glfbo = (GLFbo) GLTiming.createGLTiming(glfbo, timingState, GLFbo.class);
+            }
+                  
+            if (settings.getBoolean("GraphicsTrace")) {
+                gl    = (com.jme3.renderer.opengl.GL) GLTracer.createDesktopGlTracer(gl, GL.class, GL2.class, GL3.class, GL4.class);
+                glext = (GLExt) GLTracer.createDesktopGlTracer(glext, GLExt.class);
+                glfbo = (GLFbo) GLTracer.createDesktopGlTracer(glfbo, GLFbo.class);
+            }
+            
+            renderer = new GLRenderer(gl, glext, glfbo);
+            renderer.initialize();
+        } else {
+            throw new UnsupportedOperationException("Unsupported renderer: " + settings.getRenderer());
+        }
+        
+        if (GLContext.getCurrentGL().isExtensionAvailable("GL_ARB_debug_output") && settings.getBoolean("GraphicsDebug")) {
+        	GLContext.getCurrent().enableGLDebugMessage(true);
+        	GLContext.getCurrent().addGLDebugListener(new JoglGLDebugOutputHandler());
+        }
+        
+        renderer.setMainFrameBufferSrgb(settings.getGammaCorrection());
+        renderer.setLinearizeSrgbImages(settings.getGammaCorrection());
 
-     public void internalCreate() {
+        // Init input
+        if (keyInput != null) {
+            keyInput.initialize();
+        }
+
+        if (mouseInput != null) {
+            mouseInput.initialize();
+        }
+
+        if (joyInput != null) {
+            joyInput.initialize();
+        }
+    }
+
+    public void internalCreate() {
         timer = new NanoTimer();
         synchronized (createdLock){
             created.set(true);
             createdLock.notifyAll();
         }
+        if (renderable.get()){
+            initContextFirstTime();
+        } else {
+            assert getType() == Type.Canvas;
+        }
     }
 
     protected void internalDestroy() {

jme3-jogl/src/main/java/com/jme3/system/jogl/JoglGLDebugOutputHandler.java

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2009-2015 jMonkeyEngine
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of 'jMonkeyEngine' nor the names of its contributors
+ *   may be used to endorse or promote products derived from this software
+ *   without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
+ * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+package com.jme3.system.jogl;
+
+import java.util.HashMap;
+
+import com.jogamp.opengl.GL2ES2;
+import com.jogamp.opengl.GLDebugListener;
+import com.jogamp.opengl.GLDebugMessage;
+
+class JoglGLDebugOutputHandler implements GLDebugListener {
+
+    private static final HashMap<Integer, String> constMap = new HashMap<Integer, String>();
+    private static final String MESSAGE_FORMAT = 
+            "[JME3] OpenGL debug message\r\n" +
+            "       ID: %d\r\n" +
+            "       Source: %s\r\n" +
+            "       Type: %s\r\n" +
+            "       Severity: %s\r\n" +
+            "       Message: %s";
+    
+    static {
+        constMap.put(GL2ES2.GL_DEBUG_SOURCE_API, "API");
+        constMap.put(GL2ES2.GL_DEBUG_SOURCE_APPLICATION, "APPLICATION");
+        constMap.put(GL2ES2.GL_DEBUG_SOURCE_OTHER, "OTHER");
+        constMap.put(GL2ES2.GL_DEBUG_SOURCE_SHADER_COMPILER, "SHADER_COMPILER");
+        constMap.put(GL2ES2.GL_DEBUG_SOURCE_THIRD_PARTY, "THIRD_PARTY");
+        constMap.put(GL2ES2.GL_DEBUG_SOURCE_WINDOW_SYSTEM, "WINDOW_SYSTEM");
+        
+        constMap.put(GL2ES2.GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR, "DEPRECATED_BEHAVIOR");
+        constMap.put(GL2ES2.GL_DEBUG_TYPE_ERROR, "ERROR");
+        constMap.put(GL2ES2.GL_DEBUG_TYPE_OTHER, "OTHER");
+        constMap.put(GL2ES2.GL_DEBUG_TYPE_PERFORMANCE, "PERFORMANCE");
+        constMap.put(GL2ES2.GL_DEBUG_TYPE_PORTABILITY, "PORTABILITY");
+        constMap.put(GL2ES2.GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR, "UNDEFINED_BEHAVIOR");
+        
+        constMap.put(GL2ES2.GL_DEBUG_SEVERITY_HIGH, "HIGH");
+        constMap.put(GL2ES2.GL_DEBUG_SEVERITY_MEDIUM, "MEDIUM");
+        constMap.put(GL2ES2.GL_DEBUG_SEVERITY_LOW, "LOW");
+    }
+    
+    @Override
+	public void messageSent(GLDebugMessage event) {
+    	String sourceStr = constMap.get(event.getDbgSource());
+        String typeStr = constMap.get(event.getDbgType());
+        String severityStr = constMap.get(event.getDbgSeverity());
+        
+        System.err.println(String.format(MESSAGE_FORMAT, event.getDbgId(), sourceStr, typeStr, severityStr, event.getDbgMsg()));
+	}
+    
+}

jme3-jogl/src/main/java/com/jme3/system/jogl/JoglNewtAbstractDisplay.java

@@ -107,7 +107,8 @@ public abstract class JoglNewtAbstractDisplay extends JoglContext implements GLE
         canvas.setSize(settings.getWidth(), settings.getHeight());
         canvas.addGLEventListener(this);
 
-        if (settings.getBoolean("GraphicsDebug")) {
+        //TODO remove this block once for all when the unified renderer is stable
+        /*if (settings.getBoolean("GraphicsDebug")) {
             canvas.invoke(false, new GLRunnable() {
                 public boolean run(GLAutoDrawable glad) {
                     GL gl = glad.getGL();
@@ -156,7 +157,7 @@ public abstract class JoglNewtAbstractDisplay extends JoglContext implements GLE
                 renderer.setMainFrameBufferSrgb(settings.getGammaCorrection());
                 return true;
             }
-        });
+        });*/
     }
 
     protected void startGLCanvas() {

jme3-jogl/src/main/java/com/jme3/system/jogl/JoglNewtCanvas.java

@@ -41,6 +41,7 @@ public class JoglNewtCanvas extends JoglNewtAbstractDisplay implements JmeCanvas
     
     private static final Logger logger = Logger.getLogger(JoglNewtCanvas.class.getName());
     private int width, height;
+    private boolean runningFirstTime = true;
     
     private NewtCanvasAWT newtAwtCanvas;
 
@@ -53,7 +54,9 @@ public class JoglNewtCanvas extends JoglNewtAbstractDisplay implements JmeCanvas
     protected final void initGLCanvas() {
         super.initGLCanvas();
         newtAwtCanvas = new NewtCanvasAWT(canvas) {
-            @Override
+            private static final long serialVersionUID = 1L;
+
+			@Override
             public void addNotify() {
                 super.addNotify();
                 onCanvasAdded();
@@ -67,22 +70,27 @@ public class JoglNewtCanvas extends JoglNewtAbstractDisplay implements JmeCanvas
         };
     }
 
-    public Type getType() {
+    @Override
+	public Type getType() {
         return Type.Canvas;
     }
 
-    public void setTitle(String title) {
+    @Override
+	public void setTitle(String title) {
     }
 
-    public void restart() {
+    @Override
+	public void restart() {
     }
 
-    public void create(boolean waitFor){
+    @Override
+	public void create(boolean waitFor){
         if (waitFor)
             waitFor(true);
     }
 
-    public void destroy(boolean waitFor){
+    @Override
+	public void destroy(boolean waitFor){
         if (waitFor)
             waitFor(false);
         if (animator.isAnimating())
@@ -101,13 +109,20 @@ public class JoglNewtCanvas extends JoglNewtAbstractDisplay implements JmeCanvas
         startGLCanvas();
     }
 
-    public void init(GLAutoDrawable drawable) {
+    @Override
+	public void init(GLAutoDrawable drawable) {
         canvas.requestFocus();
 
         super.internalCreate();
         logger.fine("Display created.");
 
-        renderer.initialize();
+        // At this point, the OpenGL context is active.
+        if (runningFirstTime){
+            // THIS is the part that creates the renderer.
+            // It must always be called, now that we have the pbuffer workaround.
+            initContextFirstTime();
+            runningFirstTime = false;
+        }
         listener.initialize();
     }
 
@@ -117,7 +132,8 @@ public class JoglNewtCanvas extends JoglNewtAbstractDisplay implements JmeCanvas
         super.startGLCanvas();
     }
 
-    public void display(GLAutoDrawable glad) {
+    @Override
+	public void display(GLAutoDrawable glad) {
         if (!created.get() && renderer != null){
             listener.destroy();
             logger.fine("Canvas destroyed.");