GLDebugES.java

package com.jme3.renderer.opengl;

import java.nio.ByteBuffer;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import java.nio.ShortBuffer;

public class GLDebugES extends GLDebug implements GL, GLFbo, GLExt {

    private final GLFbo glfbo;
    private final GLExt glext;

    public GLDebugES(GL gl, GLExt glext, GLFbo glfbo) {
        this.gl = gl;
        this.glext = glext;
        this.glfbo = glfbo;
    }

    public void resetStats() {
        gl.resetStats();
    }
    
    public void glActiveTexture(int texture) {
        gl.glActiveTexture(texture);
        checkError();
    }

    public void glAttachShader(int program, int shader) {
        gl.glAttachShader(program, shader);
        checkError();
    }

    @Override
    public void glBeginQuery(int target, int query) {
        gl.glBeginQuery(target, query);
        checkError();
    }

    public void glBindBuffer(int target, int buffer) {
        gl.glBindBuffer(target, buffer);
        checkError();
    }

    public void glBindTexture(int target, int texture) {
        gl.glBindTexture(target, texture);
        checkError();
    }

    public void glBlendFunc(int sfactor, int dfactor) {
        gl.glBlendFunc(sfactor, dfactor);
        checkError();
    }
    
    public void glBlendFuncSeparate(int sfactorRGB, int dfactorRGB, int sfactorAlpha, int dFactorAlpha)
    {
       gl.glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dFactorAlpha);
       checkError();
    }

    public void glBufferData(int target, FloatBuffer data, int usage) {
        gl.glBufferData(target, data, usage);
        checkError();
    }

    public void glBufferData(int target, ShortBuffer data, int usage) {
        gl.glBufferData(target, data, usage);
        checkError();
    }

    public void glBufferData(int target, ByteBuffer data, int usage) {
        gl.glBufferData(target, data, usage);
        checkError();
    }

    public void glBufferSubData(int target, long offset, FloatBuffer data) {
        gl.glBufferSubData(target, offset, data);
        checkError();
    }

    public void glBufferSubData(int target, long offset, ShortBuffer data) {
        gl.glBufferSubData(target, offset, data);
        checkError();
    }

    public void glBufferSubData(int target, long offset, ByteBuffer data) {
        gl.glBufferSubData(target, offset, data);
        checkError();
    }

    public void glClear(int mask) {
        gl.glClear(mask);
        checkError();
    }

    public void glClearColor(float red, float green, float blue, float alpha) {
        gl.glClearColor(red, green, blue, alpha);
        checkError();
    }

    public void glColorMask(boolean red, boolean green, boolean blue, boolean alpha) {
        gl.glColorMask(red, green, blue, alpha);
        checkError();
    }

    public void glCompileShader(int shader) {
        gl.glCompileShader(shader);
        checkError();
    }

    public void glCompressedTexImage2D(int target, int level, int internalformat, int width, int height, int border, ByteBuffer data) {
        gl.glCompressedTexImage2D(target, level, internalformat, width, height, border, data);
        checkError();
    }

    public void glCompressedTexSubImage2D(int target, int level, int xoffset, int yoffset, int width, int height, int format, ByteBuffer data) {
        gl.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, data);
        checkError();
    }

    public int glCreateProgram() {
        int program = gl.glCreateProgram();
        checkError();
        return program;
    }

    public int glCreateShader(int shaderType) {
        int shader = gl.glCreateShader(shaderType);
        checkError();
        return shader;
    }

    public void glCullFace(int mode) {
        gl.glCullFace(mode);
        checkError();
    }

    public void glDeleteBuffers(IntBuffer buffers) {
        gl.glDeleteBuffers(buffers);
        checkError();
    }

    public void glDeleteProgram(int program) {
        gl.glDeleteProgram(program);
        checkError();
    }

    public void glDeleteShader(int shader) {
        gl.glDeleteShader(shader);
        checkError();
    }

    public void glDeleteTextures(IntBuffer textures) {
        gl.glDeleteTextures(textures);
        checkError();
    }

    public void glDepthFunc(int func) {
        gl.glDepthFunc(func);
        checkError();
    }

    public void glDepthMask(boolean flag) {
        gl.glDepthMask(flag);
        checkError();
    }

    public void glDepthRange(double nearVal, double farVal) {
        gl.glDepthRange(nearVal, farVal);
        checkError();
    }

    public void glDetachShader(int program, int shader) {
        gl.glDetachShader(program, shader);
        checkError();
    }

    public void glDisable(int cap) {
        gl.glDisable(cap);
        checkError();
    }

    public void glDisableVertexAttribArray(int index) {
        gl.glDisableVertexAttribArray(index);
        checkError();
    }

    public void glDrawArrays(int mode, int first, int count) {
        gl.glDrawArrays(mode, first, count);
        checkError();
    }

    public void glDrawRangeElements(int mode, int start, int end, int count, int type, long indices) {
        gl.glDrawRangeElements(mode, start, end, count, type, indices);
        checkError();
    }

    public void glEnable(int cap) {
        gl.glEnable(cap);
        checkError();
    }

    public void glEnableVertexAttribArray(int index) {
        gl.glEnableVertexAttribArray(index);
        checkError();
    }

    @Override
    public void glEndQuery(int target) {
        checkError();
    }

    public void glGenBuffers(IntBuffer buffers) {
        gl.glGenBuffers(buffers);
        checkError();
    }

    public void glGenTextures(IntBuffer textures) {
        gl.glGenTextures(textures);
        checkError();
    }

    @Override
    public void glGenQueries(int num, IntBuffer ids) {
        glGenQueries(num, ids);
        checkError();
    }

    public int glGetAttribLocation(int program, String name) {
        int location = gl.glGetAttribLocation(program, name);
        checkError();
        return location;
    }

    public void glGetBoolean(int pname, ByteBuffer params) {
        gl.glGetBoolean(pname, params);
        checkError();
    }

    public int glGetError() {
        // No need to check for error here? Haha
        return gl.glGetError();
    }

    public void glGetInteger(int pname, IntBuffer params) {
        gl.glGetInteger(pname, params);
        checkError();
    }

    public void glGetProgram(int program, int pname, IntBuffer params) {
        gl.glGetProgram(program, pname, params);
        checkError();
    }

    public String glGetProgramInfoLog(int program, int maxSize) {
        String infoLog =  gl.glGetProgramInfoLog(program, maxSize);
        checkError();
        return infoLog;
    }

    @Override
    public long glGetQueryObjectui64(int query, int pname) {
        long res = gl.glGetQueryObjectui64(query, pname);
        checkError();
        return res;
    }

    @Override
    public int glGetQueryObjectiv(int query, int pname) {
        int res = gl.glGetQueryObjectiv(query, pname);
        checkError();
        return res;
    }

    public void glGetShader(int shader, int pname, IntBuffer params) {
        gl.glGetShader(shader, pname, params);
        checkError();
    }

    public String glGetShaderInfoLog(int shader, int maxSize) {
        String infoLog = gl.glGetShaderInfoLog(shader, maxSize);
        checkError();
        return infoLog;
    }

    public String glGetString(int name) {
        String string = gl.glGetString(name);
        checkError();
        return string;
    }

    public int glGetUniformLocation(int program, String name) {
        int location = gl.glGetUniformLocation(program, name);
        checkError();
        return location;
    }

    public boolean glIsEnabled(int cap) {
        boolean enabled = gl.glIsEnabled(cap);
        checkError();
        return enabled;
    }

    public void glLineWidth(float width) {
        gl.glLineWidth(width);
        checkError();
    }

    public void glLinkProgram(int program) {
        gl.glLinkProgram(program);
        checkError();
    }

    public void glPixelStorei(int pname, int param) {
        gl.glPixelStorei(pname, param);
        checkError();
    }

    public void glPolygonOffset(float factor, float units) {
        gl.glPolygonOffset(factor, units);
        checkError();
    }

    public void glReadPixels(int x, int y, int width, int height, int format, int type, ByteBuffer data) {
        gl.glReadPixels(x, y, width, height, format, type, data);
        checkError();
    }
    
    public void glReadPixels(int x, int y, int width, int height, int format, int type, long offset) {
        gl.glReadPixels(x, y, width, height, format, type, offset);
        checkError();
    }

    public void glScissor(int x, int y, int width, int height) {
        gl.glScissor(x, y, width, height);
        checkError();
    }

    public void glShaderSource(int shader, String[] string, IntBuffer length) {
        gl.glShaderSource(shader, string, length);
        checkError();
    }

    public void glStencilFuncSeparate(int face, int func, int ref, int mask) {
        gl.glStencilFuncSeparate(face, func, ref, mask);
        checkError();
    }

    public void glStencilOpSeparate(int face, int sfail, int dpfail, int dppass) {
        gl.glStencilOpSeparate(face, sfail, dpfail, dppass);
        checkError();
    }

    public void glTexImage2D(int target, int level, int internalFormat, int width, int height, int border, int format, int type, ByteBuffer data) {
        gl.glTexImage2D(target, level, internalFormat, width, height, border, format, type, data);
        checkError();
    }

    public void glTexParameterf(int target, int pname, float param) {
        gl.glTexParameterf(target, pname, param);
        checkError();
    }

    public void glTexParameteri(int target, int pname, int param) {
        gl.glTexParameteri(target, pname, param);
        checkError();
    }

    public void glTexSubImage2D(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, ByteBuffer data) {
        gl.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, data);
        checkError();
    }

    public void glUniform1(int location, FloatBuffer value) {
        gl.glUniform1(location, value);
        checkError();
    }

    public void glUniform1(int location, IntBuffer value) {
        gl.glUniform1(location, value);
        checkError();
    }

    public void glUniform1f(int location, float v0) {
        gl.glUniform1f(location, v0);
        checkError();
    }

    public void glUniform1i(int location, int v0) {
        gl.glUniform1i(location, v0);
        checkError();
    }

    public void glUniform2(int location, IntBuffer value) {
        gl.glUniform2(location, value);
        checkError();
    }

    public void glUniform2(int location, FloatBuffer value) {
        gl.glUniform2(location, value);
        checkError();
    }

    public void glUniform2f(int location, float v0, float v1) {
        gl.glUniform2f(location, v0, v1);
        checkError();
    }

    public void glUniform3(int location, IntBuffer value) {
        gl.glUniform3(location, value);
        checkError();
    }

    public void glUniform3(int location, FloatBuffer value) {
        gl.glUniform3(location, value);
        checkError();
    }

    public void glUniform3f(int location, float v0, float v1, float v2) {
        gl.glUniform3f(location, v0, v1, v2);
        checkError();
    }

    public void glUniform4(int location, FloatBuffer value) {
        gl.glUniform4(location, value);
        checkError();
    }

    public void glUniform4(int location, IntBuffer value) {
        gl.glUniform4(location, value);
        checkError();
    }

    public void glUniform4f(int location, float v0, float v1, float v2, float v3) {
        gl.glUniform4f(location, v0, v1, v2, v3);
        checkError();
    }

    public void glUniformMatrix3(int location, boolean transpose, FloatBuffer value) {
        gl.glUniformMatrix3(location, transpose, value);
        checkError();
    }

    public void glUniformMatrix4(int location, boolean transpose, FloatBuffer value) {
        gl.glUniformMatrix4(location, transpose, value);
        checkError();
    }

    public void glUseProgram(int program) {
        gl.glUseProgram(program);
        checkError();
    }

    public void glVertexAttribPointer(int index, int size, int type, boolean normalized, int stride, long pointer) {
        gl.glVertexAttribPointer(index, size, type, normalized, stride, pointer);
        checkError();
    }

    public void glViewport(int x, int y, int width, int height) {
        gl.glViewport(x, y, width, height);
        checkError();
    }

    public void glBindFramebufferEXT(int param1, int param2) {
        glfbo.glBindFramebufferEXT(param1, param2);
        checkError();
    }

    public void glBindRenderbufferEXT(int param1, int param2) {
        glfbo.glBindRenderbufferEXT(param1, param2);
        checkError();
    }

    public int glCheckFramebufferStatusEXT(int param1) {
        int result = glfbo.glCheckFramebufferStatusEXT(param1);
        checkError();
        return result;
    }

    public void glDeleteFramebuffersEXT(IntBuffer param1) {
        glfbo.glDeleteFramebuffersEXT(param1);
        checkError();
    }

    public void glDeleteRenderbuffersEXT(IntBuffer param1) {
        glfbo.glDeleteRenderbuffersEXT(param1);
        checkError();
    }

    public void glFramebufferRenderbufferEXT(int param1, int param2, int param3, int param4) {
        glfbo.glFramebufferRenderbufferEXT(param1, param2, param3, param4);
        checkError();
    }

    public void glFramebufferTexture2DEXT(int param1, int param2, int param3, int param4, int param5) {
        glfbo.glFramebufferTexture2DEXT(param1, param2, param3, param4, param5);
        checkError();
    }

    public void glGenFramebuffersEXT(IntBuffer param1) {
        glfbo.glGenFramebuffersEXT(param1);
        checkError();
    }

    public void glGenRenderbuffersEXT(IntBuffer param1) {
        glfbo.glGenRenderbuffersEXT(param1);
        checkError();
    }

    public void glGenerateMipmapEXT(int param1) {
        glfbo.glGenerateMipmapEXT(param1);
        checkError();
    }

    public void glRenderbufferStorageEXT(int param1, int param2, int param3, int param4) {
        glfbo.glRenderbufferStorageEXT(param1, param2, param3, param4);
        checkError();
    }

    public void glBlitFramebufferEXT(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, int mask, int filter) {
        glfbo.glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
        checkError();
    }

    @Override
    public void glBufferData(int target, long data_size, int usage) {
        gl.glBufferData(target, data_size, usage);
        checkError();
    }

    @Override
    public void glGetBufferSubData(int target, long offset, ByteBuffer data) {
        gl.glGetBufferSubData(target, offset, data);
        checkError();
    }
    
    public void glBufferData(int target, IntBuffer data, int usage) {
        glext.glBufferData(target, data, usage);
        checkError();
    }

    public void glBufferSubData(int target, long offset, IntBuffer data) {
        glext.glBufferSubData(target, offset, data);
        checkError();
    }

    public void glDrawArraysInstancedARB(int mode, int first, int count, int primcount) {
        glext.glDrawArraysInstancedARB(mode, first, count, primcount);
        checkError();
    }

    public void glDrawBuffers(IntBuffer bufs) {
        glext.glDrawBuffers(bufs);
        checkError();
    }

    public void glDrawElementsInstancedARB(int mode, int indices_count, int type, long indices_buffer_offset, int primcount) {
        glext.glDrawElementsInstancedARB(mode, indices_count, type, indices_buffer_offset, primcount);
        checkError();
    }

    public void glGetMultisample(int pname, int index, FloatBuffer val) {
        glext.glGetMultisample(pname, index, val);
        checkError();
    }

    public void glRenderbufferStorageMultisampleEXT(int target, int samples, int internalformat, int width, int height) {
        glfbo.glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
        checkError();
    }

    public void glTexImage2DMultisample(int target, int samples, int internalformat, int width, int height, boolean fixedsamplelocations) {
        glext.glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
        checkError();
    }

    public void glVertexAttribDivisorARB(int index, int divisor) {
        glext.glVertexAttribDivisorARB(index, divisor);
        checkError();
    }

    @Override
    public int glClientWaitSync(Object sync, int flags, long timeout) {
        int result = glext.glClientWaitSync(sync, flags, timeout);
        checkError();
        return result;
    }

    @Override
    public void glDeleteSync(Object sync) {
        glext.glDeleteSync(sync);
        checkError();
    }

    @Override
    public Object glFenceSync(int condition, int flags) {
        Object sync = glext.glFenceSync(condition, flags);
        checkError();
        return sync;
    }

    public void glBlendEquationSeparate(int colorMode, int alphaMode) {
        gl.glBlendEquationSeparate(colorMode, alphaMode);
        checkError();
    }
}