io.qt.opengl.QOpenGLFunctions_3_3_Compatibility Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of qtjambi-opengl Show documentation
Classes that make it easy to use OpenGL in Qt applications.
The newest version!
package io.qt.opengl;

import io.qt.*;


/**
 * All functions for OpenGL 3.3 compatibility profile
 * Java wrapper for Qt class QOpenGLFunctions_3_3_Compatibility
 */
public class QOpenGLFunctions_3_3_Compatibility extends io.qt.opengl.QAbstractOpenGLFunctions
{
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::QOpenGLFunctions_3_3_Compatibility()
     */
    public QOpenGLFunctions_3_3_Compatibility(){
        super((QPrivateConstructor)null);
        initialize_native(this);
    }
    
    private native static void initialize_native(QOpenGLFunctions_3_3_Compatibility instance);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glAccum(GLenum,GLfloat)
     * @param op
     * @param value
     */
    @QtUninvokable
    public final void glAccum(int op, float value){
        glAccum_native_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), op, value);
    }
    
    @QtUninvokable
    private native void glAccum_native_GLenum_GLfloat(long __this__nativeId, int op, float value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glActiveTexture(GLenum)
     * @param texture
     */
    @QtUninvokable
    public final void glActiveTexture(int texture){
        glActiveTexture_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), texture);
    }
    
    @QtUninvokable
    private native void glActiveTexture_native_GLenum(long __this__nativeId, int texture);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glAlphaFunc(GLenum,GLfloat)
     * @param func
     * @param ref
     */
    @QtUninvokable
    public final void glAlphaFunc(int func, float ref){
        glAlphaFunc_native_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), func, ref);
    }
    
    @QtUninvokable
    private native void glAlphaFunc_native_GLenum_GLfloat(long __this__nativeId, int func, float ref);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glAreTexturesResident(GLsizei,const GLuint*,GLboolean*)
     * @param textures
     * @param residences
     * @return
     */
    @QtUninvokable
    public final boolean glAreTexturesResident(java.nio.@Nullable IntBuffer textures, boolean[] residences){
        return glAreTexturesResident_native_GLsizei_const_GLuint_ptr_GLboolean_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), textures, residences);
    }
    
    @QtUninvokable
    private native boolean glAreTexturesResident_native_GLsizei_const_GLuint_ptr_GLboolean_ptr(long __this__nativeId, java.nio.IntBuffer textures, boolean[] residences);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glArrayElement(GLint)
     * @param i
     */
    @QtUninvokable
    public final void glArrayElement(int i){
        glArrayElement_native_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), i);
    }
    
    @QtUninvokable
    private native void glArrayElement_native_GLint(long __this__nativeId, int i);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glAttachShader(GLuint,GLuint)
     * @param program
     * @param shader
     */
    @QtUninvokable
    public final void glAttachShader(int program, int shader){
        glAttachShader_native_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program, shader);
    }
    
    @QtUninvokable
    private native void glAttachShader_native_GLuint_GLuint(long __this__nativeId, int program, int shader);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBegin(GLenum)
     * @param mode
     */
    @QtUninvokable
    public final void glBegin(int mode){
        glBegin_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), mode);
    }
    
    @QtUninvokable
    private native void glBegin_native_GLenum(long __this__nativeId, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBeginConditionalRender(GLuint,GLenum)
     * @param id
     * @param mode
     */
    @QtUninvokable
    public final void glBeginConditionalRender(int id, int mode){
        glBeginConditionalRender_native_GLuint_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), id, mode);
    }
    
    @QtUninvokable
    private native void glBeginConditionalRender_native_GLuint_GLenum(long __this__nativeId, int id, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBeginQuery(GLenum,GLuint)
     * @param target
     * @param id
     */
    @QtUninvokable
    public final void glBeginQuery(int target, int id){
        glBeginQuery_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, id);
    }
    
    @QtUninvokable
    private native void glBeginQuery_native_GLenum_GLuint(long __this__nativeId, int target, int id);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBeginTransformFeedback(GLenum)
     * @param primitiveMode
     */
    @QtUninvokable
    public final void glBeginTransformFeedback(int primitiveMode){
        glBeginTransformFeedback_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), primitiveMode);
    }
    
    @QtUninvokable
    private native void glBeginTransformFeedback_native_GLenum(long __this__nativeId, int primitiveMode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBindAttribLocation(GLuint,GLuint,const GLchar*)
     * @param program
     * @param index
     * @param name
     */
    @QtUninvokable
    public final void glBindAttribLocation(int program, int index, java.nio.@Nullable CharBuffer name){
        glBindAttribLocation_native_GLuint_GLuint_const_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, index, name);
    }
    
    @QtUninvokable
    private native void glBindAttribLocation_native_GLuint_GLuint_const_GLchar_ptr(long __this__nativeId, int program, int index, java.nio.CharBuffer name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBindBuffer(GLenum,GLuint)
     * @param target
     * @param buffer
     */
    @QtUninvokable
    public final void glBindBuffer(int target, int buffer){
        glBindBuffer_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, buffer);
    }
    
    @QtUninvokable
    private native void glBindBuffer_native_GLenum_GLuint(long __this__nativeId, int target, int buffer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBindBufferBase(GLenum,GLuint,GLuint)
     * @param target
     * @param index
     * @param buffer
     */
    @QtUninvokable
    public final void glBindBufferBase(int target, int index, int buffer){
        glBindBufferBase_native_GLenum_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, index, buffer);
    }
    
    @QtUninvokable
    private native void glBindBufferBase_native_GLenum_GLuint_GLuint(long __this__nativeId, int target, int index, int buffer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBindBufferRange(GLenum,GLuint,GLuint,GLintptr,GLsizeiptr)
     * @param target
     * @param index
     * @param buffer
     * @param offset
     * @param size
     */
    @QtUninvokable
    public final void glBindBufferRange(int target, int index, int buffer, long offset, long size){
        glBindBufferRange_native_GLenum_GLuint_GLuint_GLintptr_GLsizeiptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, index, buffer, offset, size);
    }
    
    @QtUninvokable
    private native void glBindBufferRange_native_GLenum_GLuint_GLuint_GLintptr_GLsizeiptr(long __this__nativeId, int target, int index, int buffer, long offset, long size);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBindFragDataLocation(GLuint,GLuint,const GLchar*)
     * @param program
     * @param color
     * @param name
     */
    @QtUninvokable
    public final void glBindFragDataLocation(int program, int color, java.nio.@Nullable CharBuffer name){
        glBindFragDataLocation_native_GLuint_GLuint_const_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, color, name);
    }
    
    @QtUninvokable
    private native void glBindFragDataLocation_native_GLuint_GLuint_const_GLchar_ptr(long __this__nativeId, int program, int color, java.nio.CharBuffer name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBindFragDataLocationIndexed(GLuint,GLuint,GLuint,const GLchar*)
     * @param program
     * @param colorNumber
     * @param index
     * @param name
     */
    @QtUninvokable
    public final void glBindFragDataLocationIndexed(int program, int colorNumber, int index, java.nio.@Nullable CharBuffer name){
        glBindFragDataLocationIndexed_native_GLuint_GLuint_GLuint_const_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, colorNumber, index, name);
    }
    
    @QtUninvokable
    private native void glBindFragDataLocationIndexed_native_GLuint_GLuint_GLuint_const_GLchar_ptr(long __this__nativeId, int program, int colorNumber, int index, java.nio.CharBuffer name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBindFramebuffer(GLenum,GLuint)
     * @param target
     * @param framebuffer
     */
    @QtUninvokable
    public final void glBindFramebuffer(int target, int framebuffer){
        glBindFramebuffer_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, framebuffer);
    }
    
    @QtUninvokable
    private native void glBindFramebuffer_native_GLenum_GLuint(long __this__nativeId, int target, int framebuffer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBindRenderbuffer(GLenum,GLuint)
     * @param target
     * @param renderbuffer
     */
    @QtUninvokable
    public final void glBindRenderbuffer(int target, int renderbuffer){
        glBindRenderbuffer_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, renderbuffer);
    }
    
    @QtUninvokable
    private native void glBindRenderbuffer_native_GLenum_GLuint(long __this__nativeId, int target, int renderbuffer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBindSampler(GLuint,GLuint)
     * @param unit
     * @param sampler
     */
    @QtUninvokable
    public final void glBindSampler(int unit, int sampler){
        glBindSampler_native_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), unit, sampler);
    }
    
    @QtUninvokable
    private native void glBindSampler_native_GLuint_GLuint(long __this__nativeId, int unit, int sampler);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBindTexture(GLenum,GLuint)
     * @param target
     * @param texture
     */
    @QtUninvokable
    public final void glBindTexture(int target, int texture){
        glBindTexture_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, texture);
    }
    
    @QtUninvokable
    private native void glBindTexture_native_GLenum_GLuint(long __this__nativeId, int target, int texture);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBindVertexArray(GLuint)
     * @param array
     */
    @QtUninvokable
    public final void glBindVertexArray(int array){
        glBindVertexArray_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), array);
    }
    
    @QtUninvokable
    private native void glBindVertexArray_native_GLuint(long __this__nativeId, int array);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBitmap(GLsizei,GLsizei,GLfloat,GLfloat,GLfloat,GLfloat,const GLubyte*)
     * @param width
     * @param height
     * @param xorig
     * @param yorig
     * @param xmove
     * @param ymove
     * @param bitmap
     */
    @QtUninvokable
    public final void glBitmap(int width, int height, float xorig, float yorig, float xmove, float ymove, java.nio.@Nullable ByteBuffer bitmap){
        glBitmap_native_GLsizei_GLsizei_GLfloat_GLfloat_GLfloat_GLfloat_const_GLubyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), width, height, xorig, yorig, xmove, ymove, bitmap);
    }
    
    @QtUninvokable
    private native void glBitmap_native_GLsizei_GLsizei_GLfloat_GLfloat_GLfloat_GLfloat_const_GLubyte_ptr(long __this__nativeId, int width, int height, float xorig, float yorig, float xmove, float ymove, java.nio.ByteBuffer bitmap);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBlendColor(GLfloat,GLfloat,GLfloat,GLfloat)
     * @param red
     * @param green
     * @param blue
     * @param alpha
     */
    @QtUninvokable
    public final void glBlendColor(float red, float green, float blue, float alpha){
        glBlendColor_native_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue, alpha);
    }
    
    @QtUninvokable
    private native void glBlendColor_native_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, float red, float green, float blue, float alpha);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBlendEquation(GLenum)
     * @param mode
     */
    @QtUninvokable
    public final void glBlendEquation(int mode){
        glBlendEquation_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), mode);
    }
    
    @QtUninvokable
    private native void glBlendEquation_native_GLenum(long __this__nativeId, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBlendEquationSeparate(GLenum,GLenum)
     * @param modeRGB
     * @param modeAlpha
     */
    @QtUninvokable
    public final void glBlendEquationSeparate(int modeRGB, int modeAlpha){
        glBlendEquationSeparate_native_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), modeRGB, modeAlpha);
    }
    
    @QtUninvokable
    private native void glBlendEquationSeparate_native_GLenum_GLenum(long __this__nativeId, int modeRGB, int modeAlpha);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBlendFunc(GLenum,GLenum)
     * @param sfactor
     * @param dfactor
     */
    @QtUninvokable
    public final void glBlendFunc(int sfactor, int dfactor){
        glBlendFunc_native_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), sfactor, dfactor);
    }
    
    @QtUninvokable
    private native void glBlendFunc_native_GLenum_GLenum(long __this__nativeId, int sfactor, int dfactor);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBlendFuncSeparate(GLenum,GLenum,GLenum,GLenum)
     * @param sfactorRGB
     * @param dfactorRGB
     * @param sfactorAlpha
     * @param dfactorAlpha
     */
    @QtUninvokable
    public final void glBlendFuncSeparate(int sfactorRGB, int dfactorRGB, int sfactorAlpha, int dfactorAlpha){
        glBlendFuncSeparate_native_GLenum_GLenum_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
    }
    
    @QtUninvokable
    private native void glBlendFuncSeparate_native_GLenum_GLenum_GLenum_GLenum(long __this__nativeId, int sfactorRGB, int dfactorRGB, int sfactorAlpha, int dfactorAlpha);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBlitFramebuffer(GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLint,GLbitfield,GLenum)
     * @param srcX0
     * @param srcY0
     * @param srcX1
     * @param srcY1
     * @param dstX0
     * @param dstY0
     * @param dstX1
     * @param dstY1
     * @param mask
     * @param filter
     */
    @QtUninvokable
    public final void glBlitFramebuffer(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, int mask, int filter){
        glBlitFramebuffer_native_GLint_GLint_GLint_GLint_GLint_GLint_GLint_GLint_GLbitfield_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
    }
    
    @QtUninvokable
    private native void glBlitFramebuffer_native_GLint_GLint_GLint_GLint_GLint_GLint_GLint_GLint_GLbitfield_GLenum(long __this__nativeId, int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, int mask, int filter);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBufferData(GLenum,GLsizeiptr,const GLvoid*,GLenum)
     * @param target
     * @param size
     * @param data
     * @param usage
     */
    @QtUninvokable
    public final void glBufferData(int target, long size, java.nio.@Nullable Buffer data, int usage){
        glBufferData_native_GLenum_GLsizeiptr_const_GLvoid_ptr_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target, size, data, usage);
    }
    
    @QtUninvokable
    private native void glBufferData_native_GLenum_GLsizeiptr_const_GLvoid_ptr_GLenum(long __this__nativeId, int target, long size, java.nio.Buffer data, int usage);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glBufferSubData(GLenum,GLintptr,GLsizeiptr,const GLvoid*)
     * @param target
     * @param offset
     * @param size
     * @param data
     */
    @QtUninvokable
    public final void glBufferSubData(int target, long offset, long size, java.nio.@Nullable Buffer data){
        glBufferSubData_native_GLenum_GLintptr_GLsizeiptr_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, offset, size, data);
    }
    
    @QtUninvokable
    private native void glBufferSubData_native_GLenum_GLintptr_GLsizeiptr_const_GLvoid_ptr(long __this__nativeId, int target, long offset, long size, java.nio.Buffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCallList(GLuint)
     * @param list
     */
    @QtUninvokable
    public final void glCallList(int list){
        glCallList_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), list);
    }
    
    @QtUninvokable
    private native void glCallList_native_GLuint(long __this__nativeId, int list);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCallLists(GLsizei,GLenum,const GLvoid*)
     * @param n
     * @param type
     * @param lists
     */
    @QtUninvokable
    public final void glCallLists(int n, int type, java.nio.@Nullable Buffer lists){
        glCallLists_native_GLsizei_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, type, lists);
    }
    
    @QtUninvokable
    private native void glCallLists_native_GLsizei_GLenum_const_GLvoid_ptr(long __this__nativeId, int n, int type, java.nio.Buffer lists);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCheckFramebufferStatus(GLenum)
     * @param target
     * @return
     */
    @QtUninvokable
    public final int glCheckFramebufferStatus(int target){
        return glCheckFramebufferStatus_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target);
    }
    
    @QtUninvokable
    private native int glCheckFramebufferStatus_native_GLenum(long __this__nativeId, int target);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClampColor(GLenum,GLenum)
     * @param target
     * @param clamp
     */
    @QtUninvokable
    public final void glClampColor(int target, int clamp){
        glClampColor_native_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target, clamp);
    }
    
    @QtUninvokable
    private native void glClampColor_native_GLenum_GLenum(long __this__nativeId, int target, int clamp);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClear(GLbitfield)
     * @param mask
     */
    @QtUninvokable
    public final void glClear(int mask){
        glClear_native_GLbitfield(QtJambi_LibraryUtilities.internal.nativeId(this), mask);
    }
    
    @QtUninvokable
    private native void glClear_native_GLbitfield(long __this__nativeId, int mask);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClearAccum(GLfloat,GLfloat,GLfloat,GLfloat)
     * @param red
     * @param green
     * @param blue
     * @param alpha
     */
    @QtUninvokable
    public final void glClearAccum(float red, float green, float blue, float alpha){
        glClearAccum_native_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue, alpha);
    }
    
    @QtUninvokable
    private native void glClearAccum_native_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, float red, float green, float blue, float alpha);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClearBufferfi(GLenum,GLint,GLfloat,GLint)
     * @param buffer
     * @param drawbuffer
     * @param depth
     * @param stencil
     */
    @QtUninvokable
    public final void glClearBufferfi(int buffer, int drawbuffer, float depth, int stencil){
        glClearBufferfi_native_GLenum_GLint_GLfloat_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), buffer, drawbuffer, depth, stencil);
    }
    
    @QtUninvokable
    private native void glClearBufferfi_native_GLenum_GLint_GLfloat_GLint(long __this__nativeId, int buffer, int drawbuffer, float depth, int stencil);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClearBufferfv(GLenum,GLint,const GLfloat*)
     * @param buffer
     * @param drawbuffer
     * @param value
     */
    @QtUninvokable
    public final void glClearBufferfv(int buffer, int drawbuffer, java.nio.@Nullable FloatBuffer value){
        glClearBufferfv_native_GLenum_GLint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), buffer, drawbuffer, value);
    }
    
    @QtUninvokable
    private native void glClearBufferfv_native_GLenum_GLint_const_GLfloat_ptr(long __this__nativeId, int buffer, int drawbuffer, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClearBufferiv(GLenum,GLint,const GLint*)
     * @param buffer
     * @param drawbuffer
     * @param value
     */
    @QtUninvokable
    public final void glClearBufferiv(int buffer, int drawbuffer, java.nio.@Nullable IntBuffer value){
        glClearBufferiv_native_GLenum_GLint_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), buffer, drawbuffer, value);
    }
    
    @QtUninvokable
    private native void glClearBufferiv_native_GLenum_GLint_const_GLint_ptr(long __this__nativeId, int buffer, int drawbuffer, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClearBufferuiv(GLenum,GLint,const GLuint*)
     * @param buffer
     * @param drawbuffer
     * @param value
     */
    @QtUninvokable
    public final void glClearBufferuiv(int buffer, int drawbuffer, java.nio.@Nullable IntBuffer value){
        glClearBufferuiv_native_GLenum_GLint_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), buffer, drawbuffer, value);
    }
    
    @QtUninvokable
    private native void glClearBufferuiv_native_GLenum_GLint_const_GLuint_ptr(long __this__nativeId, int buffer, int drawbuffer, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClearColor(GLfloat,GLfloat,GLfloat,GLfloat)
     * @param red
     * @param green
     * @param blue
     * @param alpha
     */
    @QtUninvokable
    public final void glClearColor(float red, float green, float blue, float alpha){
        glClearColor_native_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue, alpha);
    }
    
    @QtUninvokable
    private native void glClearColor_native_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, float red, float green, float blue, float alpha);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClearDepth(GLdouble)
     * @param depth
     */
    @QtUninvokable
    public final void glClearDepth(double depth){
        glClearDepth_native_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), depth);
    }
    
    @QtUninvokable
    private native void glClearDepth_native_GLdouble(long __this__nativeId, double depth);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClearIndex(GLfloat)
     * @param c
     */
    @QtUninvokable
    public final void glClearIndex(float c){
        glClearIndex_native_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), c);
    }
    
    @QtUninvokable
    private native void glClearIndex_native_GLfloat(long __this__nativeId, float c);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClearStencil(GLint)
     * @param s
     */
    @QtUninvokable
    public final void glClearStencil(int s){
        glClearStencil_native_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), s);
    }
    
    @QtUninvokable
    private native void glClearStencil_native_GLint(long __this__nativeId, int s);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClientActiveTexture(GLenum)
     * @param texture
     */
    @QtUninvokable
    public final void glClientActiveTexture(int texture){
        glClientActiveTexture_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), texture);
    }
    
    @QtUninvokable
    private native void glClientActiveTexture_native_GLenum(long __this__nativeId, int texture);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClientWaitSync(GLsync,GLbitfield,GLuint64)
     * @param sync
     * @param flags
     * @param timeout
     * @return
     */
    @QtUninvokable
    public final int glClientWaitSync(io.qt.gui.gl.@Nullable GLsync sync, int flags, long timeout){
        return glClientWaitSync_native___GLsync_ptr_GLbitfield_GLuint64(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(sync), flags, timeout);
    }
    
    @QtUninvokable
    private native int glClientWaitSync_native___GLsync_ptr_GLbitfield_GLuint64(long __this__nativeId, long sync, int flags, long timeout);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glClipPlane(GLenum,const GLdouble*)
     * @param plane
     * @param equation
     */
    @QtUninvokable
    public final void glClipPlane(int plane, double[] equation){
        if(equation!=null && equation.length < 4)
            throw new IllegalArgumentException("Argument 'equation': Wrong number of elements in array. Found: " + equation.length + ", expected: 4");
        glClipPlane_native_GLenum_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), plane, equation);
    }
    
    @QtUninvokable
    private native void glClipPlane_native_GLenum_const_GLdouble_ptr(long __this__nativeId, int plane, double[] equation);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor3b(GLbyte,GLbyte,GLbyte)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glColor3b(byte red, byte green, byte blue){
        glColor3b_native_GLbyte_GLbyte_GLbyte(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glColor3b_native_GLbyte_GLbyte_GLbyte(long __this__nativeId, byte red, byte green, byte blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor3bv(const GLbyte*)
     * @param v
     */
    @QtUninvokable
    public final void glColor3bv(byte[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glColor3bv_native_const_GLbyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glColor3bv_native_const_GLbyte_ptr(long __this__nativeId, byte[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor3d(GLdouble,GLdouble,GLdouble)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glColor3d(double red, double green, double blue){
        glColor3d_native_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glColor3d_native_GLdouble_GLdouble_GLdouble(long __this__nativeId, double red, double green, double blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor3dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glColor3dv(double[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glColor3dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glColor3dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor3f(GLfloat,GLfloat,GLfloat)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glColor3f(float red, float green, float blue){
        glColor3f_native_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glColor3f_native_GLfloat_GLfloat_GLfloat(long __this__nativeId, float red, float green, float blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor3fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glColor3fv(float[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glColor3fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glColor3fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor3i(GLint,GLint,GLint)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glColor3i(int red, int green, int blue){
        glColor3i_native_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glColor3i_native_GLint_GLint_GLint(long __this__nativeId, int red, int green, int blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor3iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glColor3iv(int[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glColor3iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glColor3iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor3s(GLshort,GLshort,GLshort)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glColor3s(short red, short green, short blue){
        glColor3s_native_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glColor3s_native_GLshort_GLshort_GLshort(long __this__nativeId, short red, short green, short blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor3sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glColor3sv(short[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glColor3sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glColor3sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor4b(GLbyte,GLbyte,GLbyte,GLbyte)
     * @param red
     * @param green
     * @param blue
     * @param alpha
     */
    @QtUninvokable
    public final void glColor4b(byte red, byte green, byte blue, byte alpha){
        glColor4b_native_GLbyte_GLbyte_GLbyte_GLbyte(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue, alpha);
    }
    
    @QtUninvokable
    private native void glColor4b_native_GLbyte_GLbyte_GLbyte_GLbyte(long __this__nativeId, byte red, byte green, byte blue, byte alpha);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor4bv(const GLbyte*)
     * @param v
     */
    @QtUninvokable
    public final void glColor4bv(byte[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glColor4bv_native_const_GLbyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glColor4bv_native_const_GLbyte_ptr(long __this__nativeId, byte[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor4d(GLdouble,GLdouble,GLdouble,GLdouble)
     * @param red
     * @param green
     * @param blue
     * @param alpha
     */
    @QtUninvokable
    public final void glColor4d(double red, double green, double blue, double alpha){
        glColor4d_native_GLdouble_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue, alpha);
    }
    
    @QtUninvokable
    private native void glColor4d_native_GLdouble_GLdouble_GLdouble_GLdouble(long __this__nativeId, double red, double green, double blue, double alpha);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor4dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glColor4dv(double[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glColor4dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glColor4dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor4f(GLfloat,GLfloat,GLfloat,GLfloat)
     * @param red
     * @param green
     * @param blue
     * @param alpha
     */
    @QtUninvokable
    public final void glColor4f(float red, float green, float blue, float alpha){
        glColor4f_native_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue, alpha);
    }
    
    @QtUninvokable
    private native void glColor4f_native_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, float red, float green, float blue, float alpha);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor4fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glColor4fv(float[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glColor4fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glColor4fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor4i(GLint,GLint,GLint,GLint)
     * @param red
     * @param green
     * @param blue
     * @param alpha
     */
    @QtUninvokable
    public final void glColor4i(int red, int green, int blue, int alpha){
        glColor4i_native_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue, alpha);
    }
    
    @QtUninvokable
    private native void glColor4i_native_GLint_GLint_GLint_GLint(long __this__nativeId, int red, int green, int blue, int alpha);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor4iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glColor4iv(int[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glColor4iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glColor4iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor4s(GLshort,GLshort,GLshort,GLshort)
     * @param red
     * @param green
     * @param blue
     * @param alpha
     */
    @QtUninvokable
    public final void glColor4s(short red, short green, short blue, short alpha){
        glColor4s_native_GLshort_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue, alpha);
    }
    
    @QtUninvokable
    private native void glColor4s_native_GLshort_GLshort_GLshort_GLshort(long __this__nativeId, short red, short green, short blue, short alpha);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColor4sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glColor4sv(short[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glColor4sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glColor4sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorMask(GLboolean,GLboolean,GLboolean,GLboolean)
     * @param red
     * @param green
     * @param blue
     * @param alpha
     */
    @QtUninvokable
    public final void glColorMask(boolean red, boolean green, boolean blue, boolean alpha){
        glColorMask_native_GLboolean_GLboolean_GLboolean_GLboolean(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue, alpha);
    }
    
    @QtUninvokable
    private native void glColorMask_native_GLboolean_GLboolean_GLboolean_GLboolean(long __this__nativeId, boolean red, boolean green, boolean blue, boolean alpha);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorMaski(GLuint,GLboolean,GLboolean,GLboolean,GLboolean)
     * @param index
     * @param r
     * @param g
     * @param b
     * @param a
     */
    @QtUninvokable
    public final void glColorMaski(int index, boolean r, boolean g, boolean b, boolean a){
        glColorMaski_native_GLuint_GLboolean_GLboolean_GLboolean_GLboolean(QtJambi_LibraryUtilities.internal.nativeId(this), index, r, g, b, a);
    }
    
    @QtUninvokable
    private native void glColorMaski_native_GLuint_GLboolean_GLboolean_GLboolean_GLboolean(long __this__nativeId, int index, boolean r, boolean g, boolean b, boolean a);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorMaterial(GLenum,GLenum)
     * @param face
     * @param mode
     */
    @QtUninvokable
    public final void glColorMaterial(int face, int mode){
        glColorMaterial_native_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), face, mode);
    }
    
    @QtUninvokable
    private native void glColorMaterial_native_GLenum_GLenum(long __this__nativeId, int face, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorP3ui(GLenum,GLuint)
     * @param type
     * @param color
     */
    @QtUninvokable
    public final void glColorP3ui(int type, int color){
        glColorP3ui_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), type, color);
    }
    
    @QtUninvokable
    private native void glColorP3ui_native_GLenum_GLuint(long __this__nativeId, int type, int color);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorP3uiv(GLenum,const GLuint*)
     * @param type
     * @param color
     */
    @QtUninvokable
    public final void glColorP3uiv(int type, java.nio.@Nullable IntBuffer color){
        glColorP3uiv_native_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, color);
    }
    
    @QtUninvokable
    private native void glColorP3uiv_native_GLenum_const_GLuint_ptr(long __this__nativeId, int type, java.nio.IntBuffer color);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorP4ui(GLenum,GLuint)
     * @param type
     * @param color
     */
    @QtUninvokable
    public final void glColorP4ui(int type, int color){
        glColorP4ui_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), type, color);
    }
    
    @QtUninvokable
    private native void glColorP4ui_native_GLenum_GLuint(long __this__nativeId, int type, int color);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorP4uiv(GLenum,const GLuint*)
     * @param type
     * @param color
     */
    @QtUninvokable
    public final void glColorP4uiv(int type, java.nio.@Nullable IntBuffer color){
        glColorP4uiv_native_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, color);
    }
    
    @QtUninvokable
    private native void glColorP4uiv_native_GLenum_const_GLuint_ptr(long __this__nativeId, int type, java.nio.IntBuffer color);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorPointer(GLint,GLenum,GLsizei,const GLvoid*)
     * @param size
     * @param type
     * @param stride
     * @param pointer
     */
    @QtUninvokable
    public final void glColorPointer(int size, int type, int stride, java.nio.@Nullable Buffer pointer){
        glColorPointer_native_GLint_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), size, type, stride, pointer);
    }
    
    @QtUninvokable
    private native void glColorPointer_native_GLint_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int size, int type, int stride, java.nio.Buffer pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorSubTable(GLenum,GLsizei,GLsizei,GLenum,GLenum,const GLvoid*)
     * @param target
     * @param start
     * @param count
     * @param format
     * @param type
     * @param data
     */
    @QtUninvokable
    public final void glColorSubTable(int target, int start, int count, int format, int type, java.nio.@Nullable Buffer data){
        glColorSubTable_native_GLenum_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, start, count, format, type, data);
    }
    
    @QtUninvokable
    private native void glColorSubTable_native_GLenum_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr(long __this__nativeId, int target, int start, int count, int format, int type, java.nio.Buffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorTable(GLenum,GLenum,GLsizei,GLenum,GLenum,const GLvoid*)
     * @param target
     * @param internalformat
     * @param width
     * @param format
     * @param type
     * @param table
     */
    @QtUninvokable
    public final void glColorTable(int target, int internalformat, int width, int format, int type, java.nio.@Nullable Buffer table){
        glColorTable_native_GLenum_GLenum_GLsizei_GLenum_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, internalformat, width, format, type, table);
    }
    
    @QtUninvokable
    private native void glColorTable_native_GLenum_GLenum_GLsizei_GLenum_GLenum_const_GLvoid_ptr(long __this__nativeId, int target, int internalformat, int width, int format, int type, java.nio.Buffer table);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorTableParameterfv(GLenum,GLenum,const GLfloat*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glColorTableParameterfv(int target, int pname, java.nio.@Nullable FloatBuffer params){
        glColorTableParameterfv_native_GLenum_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glColorTableParameterfv_native_GLenum_GLenum_const_GLfloat_ptr(long __this__nativeId, int target, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glColorTableParameteriv(GLenum,GLenum,const GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glColorTableParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glColorTableParameteriv_native_GLenum_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glColorTableParameteriv_native_GLenum_GLenum_const_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCompileShader(GLuint)
     * @param shader
     */
    @QtUninvokable
    public final void glCompileShader(int shader){
        glCompileShader_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), shader);
    }
    
    @QtUninvokable
    private native void glCompileShader_native_GLuint(long __this__nativeId, int shader);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCompressedTexImage1D(GLenum,GLint,GLenum,GLsizei,GLint,GLsizei,const GLvoid*)
     * @param target
     * @param level
     * @param internalformat
     * @param width
     * @param border
     * @param imageSize
     * @param data
     */
    @QtUninvokable
    public final void glCompressedTexImage1D(int target, int level, int internalformat, int width, int border, int imageSize, java.nio.@Nullable Buffer data){
        glCompressedTexImage1D_native_GLenum_GLint_GLenum_GLsizei_GLint_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, internalformat, width, border, imageSize, data);
    }
    
    @QtUninvokable
    private native void glCompressedTexImage1D_native_GLenum_GLint_GLenum_GLsizei_GLint_GLsizei_const_GLvoid_ptr(long __this__nativeId, int target, int level, int internalformat, int width, int border, int imageSize, java.nio.Buffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCompressedTexImage2D(GLenum,GLint,GLenum,GLsizei,GLsizei,GLint,GLsizei,const GLvoid*)
     * @param target
     * @param level
     * @param internalformat
     * @param width
     * @param height
     * @param border
     * @param imageSize
     * @param data
     */
    @QtUninvokable
    public final void glCompressedTexImage2D(int target, int level, int internalformat, int width, int height, int border, int imageSize, java.nio.@Nullable Buffer data){
        glCompressedTexImage2D_native_GLenum_GLint_GLenum_GLsizei_GLsizei_GLint_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, internalformat, width, height, border, imageSize, data);
    }
    
    @QtUninvokable
    private native void glCompressedTexImage2D_native_GLenum_GLint_GLenum_GLsizei_GLsizei_GLint_GLsizei_const_GLvoid_ptr(long __this__nativeId, int target, int level, int internalformat, int width, int height, int border, int imageSize, java.nio.Buffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCompressedTexImage3D(GLenum,GLint,GLenum,GLsizei,GLsizei,GLsizei,GLint,GLsizei,const GLvoid*)
     * @param target
     * @param level
     * @param internalformat
     * @param width
     * @param height
     * @param depth
     * @param border
     * @param imageSize
     * @param data
     */
    @QtUninvokable
    public final void glCompressedTexImage3D(int target, int level, int internalformat, int width, int height, int depth, int border, int imageSize, java.nio.@Nullable Buffer data){
        glCompressedTexImage3D_native_GLenum_GLint_GLenum_GLsizei_GLsizei_GLsizei_GLint_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, internalformat, width, height, depth, border, imageSize, data);
    }
    
    @QtUninvokable
    private native void glCompressedTexImage3D_native_GLenum_GLint_GLenum_GLsizei_GLsizei_GLsizei_GLint_GLsizei_const_GLvoid_ptr(long __this__nativeId, int target, int level, int internalformat, int width, int height, int depth, int border, int imageSize, java.nio.Buffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCompressedTexSubImage1D(GLenum,GLint,GLint,GLsizei,GLenum,GLsizei,const GLvoid*)
     * @param target
     * @param level
     * @param xoffset
     * @param width
     * @param format
     * @param imageSize
     * @param data
     */
    @QtUninvokable
    public final void glCompressedTexSubImage1D(int target, int level, int xoffset, int width, int format, int imageSize, java.nio.@Nullable Buffer data){
        glCompressedTexSubImage1D_native_GLenum_GLint_GLint_GLsizei_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, xoffset, width, format, imageSize, data);
    }
    
    @QtUninvokable
    private native void glCompressedTexSubImage1D_native_GLenum_GLint_GLint_GLsizei_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int target, int level, int xoffset, int width, int format, int imageSize, java.nio.Buffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCompressedTexSubImage2D(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLsizei,const GLvoid*)
     * @param target
     * @param level
     * @param xoffset
     * @param yoffset
     * @param width
     * @param height
     * @param format
     * @param imageSize
     * @param data
     */
    @QtUninvokable
    public final void glCompressedTexSubImage2D(int target, int level, int xoffset, int yoffset, int width, int height, int format, int imageSize, java.nio.@Nullable Buffer data){
        glCompressedTexSubImage2D_native_GLenum_GLint_GLint_GLint_GLsizei_GLsizei_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, xoffset, yoffset, width, height, format, imageSize, data);
    }
    
    @QtUninvokable
    private native void glCompressedTexSubImage2D_native_GLenum_GLint_GLint_GLint_GLsizei_GLsizei_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int target, int level, int xoffset, int yoffset, int width, int height, int format, int imageSize, java.nio.Buffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCompressedTexSubImage3D(GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLsizei,const GLvoid*)
     * @param target
     * @param level
     * @param xoffset
     * @param yoffset
     * @param zoffset
     * @param width
     * @param height
     * @param depth
     * @param format
     * @param imageSize
     * @param data
     */
    @QtUninvokable
    public final void glCompressedTexSubImage3D(int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int imageSize, java.nio.@Nullable Buffer data){
        glCompressedTexSubImage3D_native_GLenum_GLint_GLint_GLint_GLint_GLsizei_GLsizei_GLsizei_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
    }
    
    @QtUninvokable
    private native void glCompressedTexSubImage3D_native_GLenum_GLint_GLint_GLint_GLint_GLsizei_GLsizei_GLsizei_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int imageSize, java.nio.Buffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glConvolutionFilter1D(GLenum,GLenum,GLsizei,GLenum,GLenum,const GLvoid*)
     * @param target
     * @param internalformat
     * @param width
     * @param format
     * @param type
     * @param image
     */
    @QtUninvokable
    public final void glConvolutionFilter1D(int target, int internalformat, int width, int format, int type, java.nio.@Nullable Buffer image){
        glConvolutionFilter1D_native_GLenum_GLenum_GLsizei_GLenum_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, internalformat, width, format, type, image);
    }
    
    @QtUninvokable
    private native void glConvolutionFilter1D_native_GLenum_GLenum_GLsizei_GLenum_GLenum_const_GLvoid_ptr(long __this__nativeId, int target, int internalformat, int width, int format, int type, java.nio.Buffer image);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glConvolutionFilter2D(GLenum,GLenum,GLsizei,GLsizei,GLenum,GLenum,const GLvoid*)
     * @param target
     * @param internalformat
     * @param width
     * @param height
     * @param format
     * @param type
     * @param image
     */
    @QtUninvokable
    public final void glConvolutionFilter2D(int target, int internalformat, int width, int height, int format, int type, java.nio.@Nullable Buffer image){
        glConvolutionFilter2D_native_GLenum_GLenum_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, internalformat, width, height, format, type, image);
    }
    
    @QtUninvokable
    private native void glConvolutionFilter2D_native_GLenum_GLenum_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr(long __this__nativeId, int target, int internalformat, int width, int height, int format, int type, java.nio.Buffer image);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glConvolutionParameterf(GLenum,GLenum,GLfloat)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glConvolutionParameterf(int target, int pname, float params){
        glConvolutionParameterf_native_GLenum_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glConvolutionParameterf_native_GLenum_GLenum_GLfloat(long __this__nativeId, int target, int pname, float params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glConvolutionParameterfv(GLenum,GLenum,const GLfloat*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glConvolutionParameterfv(int target, int pname, java.nio.@Nullable FloatBuffer params){
        glConvolutionParameterfv_native_GLenum_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glConvolutionParameterfv_native_GLenum_GLenum_const_GLfloat_ptr(long __this__nativeId, int target, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glConvolutionParameteri(GLenum,GLenum,GLint)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glConvolutionParameteri(int target, int pname, int params){
        glConvolutionParameteri_native_GLenum_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glConvolutionParameteri_native_GLenum_GLenum_GLint(long __this__nativeId, int target, int pname, int params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glConvolutionParameteriv(GLenum,GLenum,const GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glConvolutionParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glConvolutionParameteriv_native_GLenum_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glConvolutionParameteriv_native_GLenum_GLenum_const_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCopyBufferSubData(GLenum,GLenum,GLintptr,GLintptr,GLsizeiptr)
     * @param readTarget
     * @param writeTarget
     * @param readOffset
     * @param writeOffset
     * @param size
     */
    @QtUninvokable
    public final void glCopyBufferSubData(int readTarget, int writeTarget, long readOffset, long writeOffset, long size){
        glCopyBufferSubData_native_GLenum_GLenum_GLintptr_GLintptr_GLsizeiptr(QtJambi_LibraryUtilities.internal.nativeId(this), readTarget, writeTarget, readOffset, writeOffset, size);
    }
    
    @QtUninvokable
    private native void glCopyBufferSubData_native_GLenum_GLenum_GLintptr_GLintptr_GLsizeiptr(long __this__nativeId, int readTarget, int writeTarget, long readOffset, long writeOffset, long size);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCopyColorSubTable(GLenum,GLsizei,GLint,GLint,GLsizei)
     * @param target
     * @param start
     * @param x
     * @param y
     * @param width
     */
    @QtUninvokable
    public final void glCopyColorSubTable(int target, int start, int x, int y, int width){
        glCopyColorSubTable_native_GLenum_GLsizei_GLint_GLint_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), target, start, x, y, width);
    }
    
    @QtUninvokable
    private native void glCopyColorSubTable_native_GLenum_GLsizei_GLint_GLint_GLsizei(long __this__nativeId, int target, int start, int x, int y, int width);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCopyColorTable(GLenum,GLenum,GLint,GLint,GLsizei)
     * @param target
     * @param internalformat
     * @param x
     * @param y
     * @param width
     */
    @QtUninvokable
    public final void glCopyColorTable(int target, int internalformat, int x, int y, int width){
        glCopyColorTable_native_GLenum_GLenum_GLint_GLint_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), target, internalformat, x, y, width);
    }
    
    @QtUninvokable
    private native void glCopyColorTable_native_GLenum_GLenum_GLint_GLint_GLsizei(long __this__nativeId, int target, int internalformat, int x, int y, int width);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCopyConvolutionFilter1D(GLenum,GLenum,GLint,GLint,GLsizei)
     * @param target
     * @param internalformat
     * @param x
     * @param y
     * @param width
     */
    @QtUninvokable
    public final void glCopyConvolutionFilter1D(int target, int internalformat, int x, int y, int width){
        glCopyConvolutionFilter1D_native_GLenum_GLenum_GLint_GLint_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), target, internalformat, x, y, width);
    }
    
    @QtUninvokable
    private native void glCopyConvolutionFilter1D_native_GLenum_GLenum_GLint_GLint_GLsizei(long __this__nativeId, int target, int internalformat, int x, int y, int width);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCopyConvolutionFilter2D(GLenum,GLenum,GLint,GLint,GLsizei,GLsizei)
     * @param target
     * @param internalformat
     * @param x
     * @param y
     * @param width
     * @param height
     */
    @QtUninvokable
    public final void glCopyConvolutionFilter2D(int target, int internalformat, int x, int y, int width, int height){
        glCopyConvolutionFilter2D_native_GLenum_GLenum_GLint_GLint_GLsizei_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), target, internalformat, x, y, width, height);
    }
    
    @QtUninvokable
    private native void glCopyConvolutionFilter2D_native_GLenum_GLenum_GLint_GLint_GLsizei_GLsizei(long __this__nativeId, int target, int internalformat, int x, int y, int width, int height);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCopyPixels(GLint,GLint,GLsizei,GLsizei,GLenum)
     * @param x
     * @param y
     * @param width
     * @param height
     * @param type
     */
    @QtUninvokable
    public final void glCopyPixels(int x, int y, int width, int height, int type){
        glCopyPixels_native_GLint_GLint_GLsizei_GLsizei_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, width, height, type);
    }
    
    @QtUninvokable
    private native void glCopyPixels_native_GLint_GLint_GLsizei_GLsizei_GLenum(long __this__nativeId, int x, int y, int width, int height, int type);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCopyTexImage1D(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLint)
     * @param target
     * @param level
     * @param internalformat
     * @param x
     * @param y
     * @param width
     * @param border
     */
    @QtUninvokable
    public final void glCopyTexImage1D(int target, int level, int internalformat, int x, int y, int width, int border){
        glCopyTexImage1D_native_GLenum_GLint_GLenum_GLint_GLint_GLsizei_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, internalformat, x, y, width, border);
    }
    
    @QtUninvokable
    private native void glCopyTexImage1D_native_GLenum_GLint_GLenum_GLint_GLint_GLsizei_GLint(long __this__nativeId, int target, int level, int internalformat, int x, int y, int width, int border);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCopyTexImage2D(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint)
     * @param target
     * @param level
     * @param internalformat
     * @param x
     * @param y
     * @param width
     * @param height
     * @param border
     */
    @QtUninvokable
    public final void glCopyTexImage2D(int target, int level, int internalformat, int x, int y, int width, int height, int border){
        glCopyTexImage2D_native_GLenum_GLint_GLenum_GLint_GLint_GLsizei_GLsizei_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, internalformat, x, y, width, height, border);
    }
    
    @QtUninvokable
    private native void glCopyTexImage2D_native_GLenum_GLint_GLenum_GLint_GLint_GLsizei_GLsizei_GLint(long __this__nativeId, int target, int level, int internalformat, int x, int y, int width, int height, int border);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCopyTexSubImage1D(GLenum,GLint,GLint,GLint,GLint,GLsizei)
     * @param target
     * @param level
     * @param xoffset
     * @param x
     * @param y
     * @param width
     */
    @QtUninvokable
    public final void glCopyTexSubImage1D(int target, int level, int xoffset, int x, int y, int width){
        glCopyTexSubImage1D_native_GLenum_GLint_GLint_GLint_GLint_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, xoffset, x, y, width);
    }
    
    @QtUninvokable
    private native void glCopyTexSubImage1D_native_GLenum_GLint_GLint_GLint_GLint_GLsizei(long __this__nativeId, int target, int level, int xoffset, int x, int y, int width);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCopyTexSubImage2D(GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei)
     * @param target
     * @param level
     * @param xoffset
     * @param yoffset
     * @param x
     * @param y
     * @param width
     * @param height
     */
    @QtUninvokable
    public final void glCopyTexSubImage2D(int target, int level, int xoffset, int yoffset, int x, int y, int width, int height){
        glCopyTexSubImage2D_native_GLenum_GLint_GLint_GLint_GLint_GLint_GLsizei_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, xoffset, yoffset, x, y, width, height);
    }
    
    @QtUninvokable
    private native void glCopyTexSubImage2D_native_GLenum_GLint_GLint_GLint_GLint_GLint_GLsizei_GLsizei(long __this__nativeId, int target, int level, int xoffset, int yoffset, int x, int y, int width, int height);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCopyTexSubImage3D(GLenum,GLint,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei)
     * @param target
     * @param level
     * @param xoffset
     * @param yoffset
     * @param zoffset
     * @param x
     * @param y
     * @param width
     * @param height
     */
    @QtUninvokable
    public final void glCopyTexSubImage3D(int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height){
        glCopyTexSubImage3D_native_GLenum_GLint_GLint_GLint_GLint_GLint_GLint_GLsizei_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, xoffset, yoffset, zoffset, x, y, width, height);
    }
    
    @QtUninvokable
    private native void glCopyTexSubImage3D_native_GLenum_GLint_GLint_GLint_GLint_GLint_GLint_GLsizei_GLsizei(long __this__nativeId, int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCreateProgram()
     * @return
     */
    @QtUninvokable
    public final int glCreateProgram(){
        return glCreateProgram_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int glCreateProgram_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCreateShader(GLenum)
     * @param type
     * @return
     */
    @QtUninvokable
    public final int glCreateShader(int type){
        return glCreateShader_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), type);
    }
    
    @QtUninvokable
    private native int glCreateShader_native_GLenum(long __this__nativeId, int type);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glCullFace(GLenum)
     * @param mode
     */
    @QtUninvokable
    public final void glCullFace(int mode){
        glCullFace_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), mode);
    }
    
    @QtUninvokable
    private native void glCullFace_native_GLenum(long __this__nativeId, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDeleteBuffers(GLsizei,const GLuint*)
     * @param n
     * @param buffers
     */
    @QtUninvokable
    public final void glDeleteBuffers(int n, java.nio.@Nullable IntBuffer buffers){
        glDeleteBuffers_native_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, buffers);
    }
    
    @QtUninvokable
    private native void glDeleteBuffers_native_GLsizei_const_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer buffers);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDeleteFramebuffers(GLsizei,const GLuint*)
     * @param n
     * @param framebuffers
     */
    @QtUninvokable
    public final void glDeleteFramebuffers(int n, java.nio.@Nullable IntBuffer framebuffers){
        glDeleteFramebuffers_native_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, framebuffers);
    }
    
    @QtUninvokable
    private native void glDeleteFramebuffers_native_GLsizei_const_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer framebuffers);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDeleteLists(GLuint,GLsizei)
     * @param list
     * @param range
     */
    @QtUninvokable
    public final void glDeleteLists(int list, int range){
        glDeleteLists_native_GLuint_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), list, range);
    }
    
    @QtUninvokable
    private native void glDeleteLists_native_GLuint_GLsizei(long __this__nativeId, int list, int range);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDeleteProgram(GLuint)
     * @param program
     */
    @QtUninvokable
    public final void glDeleteProgram(int program){
        glDeleteProgram_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program);
    }
    
    @QtUninvokable
    private native void glDeleteProgram_native_GLuint(long __this__nativeId, int program);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDeleteQueries(GLsizei,const GLuint*)
     * @param n
     * @param ids
     */
    @QtUninvokable
    public final void glDeleteQueries(int n, java.nio.@Nullable IntBuffer ids){
        glDeleteQueries_native_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, ids);
    }
    
    @QtUninvokable
    private native void glDeleteQueries_native_GLsizei_const_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer ids);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDeleteRenderbuffers(GLsizei,const GLuint*)
     * @param n
     * @param renderbuffers
     */
    @QtUninvokable
    public final void glDeleteRenderbuffers(int n, java.nio.@Nullable IntBuffer renderbuffers){
        glDeleteRenderbuffers_native_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, renderbuffers);
    }
    
    @QtUninvokable
    private native void glDeleteRenderbuffers_native_GLsizei_const_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer renderbuffers);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDeleteSamplers(GLsizei,const GLuint*)
     * @param count
     * @param samplers
     */
    @QtUninvokable
    public final void glDeleteSamplers(int count, java.nio.@Nullable IntBuffer samplers){
        glDeleteSamplers_native_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), count, samplers);
    }
    
    @QtUninvokable
    private native void glDeleteSamplers_native_GLsizei_const_GLuint_ptr(long __this__nativeId, int count, java.nio.IntBuffer samplers);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDeleteShader(GLuint)
     * @param shader
     */
    @QtUninvokable
    public final void glDeleteShader(int shader){
        glDeleteShader_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), shader);
    }
    
    @QtUninvokable
    private native void glDeleteShader_native_GLuint(long __this__nativeId, int shader);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDeleteSync(GLsync)
     * @param sync
     */
    @QtUninvokable
    public final void glDeleteSync(io.qt.gui.gl.@Nullable GLsync sync){
        glDeleteSync_native___GLsync_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(sync));
    }
    
    @QtUninvokable
    private native void glDeleteSync_native___GLsync_ptr(long __this__nativeId, long sync);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDeleteTextures(GLsizei,const GLuint*)
     * @param n
     * @param textures
     */
    @QtUninvokable
    public final void glDeleteTextures(int n, java.nio.@Nullable IntBuffer textures){
        glDeleteTextures_native_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, textures);
    }
    
    @QtUninvokable
    private native void glDeleteTextures_native_GLsizei_const_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer textures);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDeleteVertexArrays(GLsizei,const GLuint*)
     * @param n
     * @param arrays
     */
    @QtUninvokable
    public final void glDeleteVertexArrays(int n, java.nio.@Nullable IntBuffer arrays){
        glDeleteVertexArrays_native_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, arrays);
    }
    
    @QtUninvokable
    private native void glDeleteVertexArrays_native_GLsizei_const_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer arrays);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDepthFunc(GLenum)
     * @param func
     */
    @QtUninvokable
    public final void glDepthFunc(int func){
        glDepthFunc_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), func);
    }
    
    @QtUninvokable
    private native void glDepthFunc_native_GLenum(long __this__nativeId, int func);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDepthMask(GLboolean)
     * @param flag
     */
    @QtUninvokable
    public final void glDepthMask(boolean flag){
        glDepthMask_native_GLboolean(QtJambi_LibraryUtilities.internal.nativeId(this), flag);
    }
    
    @QtUninvokable
    private native void glDepthMask_native_GLboolean(long __this__nativeId, boolean flag);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDepthRange(GLdouble,GLdouble)
     * @param nearVal
     * @param farVal
     */
    @QtUninvokable
    public final void glDepthRange(double nearVal, double farVal){
        glDepthRange_native_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), nearVal, farVal);
    }
    
    @QtUninvokable
    private native void glDepthRange_native_GLdouble_GLdouble(long __this__nativeId, double nearVal, double farVal);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDetachShader(GLuint,GLuint)
     * @param program
     * @param shader
     */
    @QtUninvokable
    public final void glDetachShader(int program, int shader){
        glDetachShader_native_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program, shader);
    }
    
    @QtUninvokable
    private native void glDetachShader_native_GLuint_GLuint(long __this__nativeId, int program, int shader);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDisable(GLenum)
     * @param cap
     */
    @QtUninvokable
    public final void glDisable(int cap){
        glDisable_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), cap);
    }
    
    @QtUninvokable
    private native void glDisable_native_GLenum(long __this__nativeId, int cap);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDisableClientState(GLenum)
     * @param array
     */
    @QtUninvokable
    public final void glDisableClientState(int array){
        glDisableClientState_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), array);
    }
    
    @QtUninvokable
    private native void glDisableClientState_native_GLenum(long __this__nativeId, int array);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDisableVertexAttribArray(GLuint)
     * @param index
     */
    @QtUninvokable
    public final void glDisableVertexAttribArray(int index){
        glDisableVertexAttribArray_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index);
    }
    
    @QtUninvokable
    private native void glDisableVertexAttribArray_native_GLuint(long __this__nativeId, int index);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDisablei(GLenum,GLuint)
     * @param target
     * @param index
     */
    @QtUninvokable
    public final void glDisablei(int target, int index){
        glDisablei_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, index);
    }
    
    @QtUninvokable
    private native void glDisablei_native_GLenum_GLuint(long __this__nativeId, int target, int index);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDrawArrays(GLenum,GLint,GLsizei)
     * @param mode
     * @param first
     * @param count
     */
    @QtUninvokable
    public final void glDrawArrays(int mode, int first, int count){
        glDrawArrays_native_GLenum_GLint_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), mode, first, count);
    }
    
    @QtUninvokable
    private native void glDrawArrays_native_GLenum_GLint_GLsizei(long __this__nativeId, int mode, int first, int count);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDrawArraysInstanced(GLenum,GLint,GLsizei,GLsizei)
     * @param mode
     * @param first
     * @param count
     * @param instancecount
     */
    @QtUninvokable
    public final void glDrawArraysInstanced(int mode, int first, int count, int instancecount){
        glDrawArraysInstanced_native_GLenum_GLint_GLsizei_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), mode, first, count, instancecount);
    }
    
    @QtUninvokable
    private native void glDrawArraysInstanced_native_GLenum_GLint_GLsizei_GLsizei(long __this__nativeId, int mode, int first, int count, int instancecount);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDrawBuffer(GLenum)
     * @param mode
     */
    @QtUninvokable
    public final void glDrawBuffer(int mode){
        glDrawBuffer_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), mode);
    }
    
    @QtUninvokable
    private native void glDrawBuffer_native_GLenum(long __this__nativeId, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDrawBuffers(GLsizei,const GLenum*)
     * @param n
     * @param bufs
     */
    @QtUninvokable
    public final void glDrawBuffers(int n, java.nio.@Nullable IntBuffer bufs){
        glDrawBuffers_native_GLsizei_const_GLenum_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, bufs);
    }
    
    @QtUninvokable
    private native void glDrawBuffers_native_GLsizei_const_GLenum_ptr(long __this__nativeId, int n, java.nio.IntBuffer bufs);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDrawElements(GLenum,GLsizei,GLenum,const GLvoid*)
     * @param mode
     * @param count
     * @param type
     * @param indices
     */
    @QtUninvokable
    public final void glDrawElements(int mode, int count, int type, java.nio.@Nullable Buffer indices){
        glDrawElements_native_GLenum_GLsizei_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), mode, count, type, indices);
    }
    
    @QtUninvokable
    private native void glDrawElements_native_GLenum_GLsizei_GLenum_const_GLvoid_ptr(long __this__nativeId, int mode, int count, int type, java.nio.Buffer indices);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDrawElementsBaseVertex(GLenum,GLsizei,GLenum,const GLvoid*,GLint)
     * @param mode
     * @param count
     * @param type
     * @param indices
     * @param basevertex
     */
    @QtUninvokable
    public final void glDrawElementsBaseVertex(int mode, int count, int type, java.nio.@Nullable Buffer indices, int basevertex){
        glDrawElementsBaseVertex_native_GLenum_GLsizei_GLenum_const_GLvoid_ptr_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), mode, count, type, indices, basevertex);
    }
    
    @QtUninvokable
    private native void glDrawElementsBaseVertex_native_GLenum_GLsizei_GLenum_const_GLvoid_ptr_GLint(long __this__nativeId, int mode, int count, int type, java.nio.Buffer indices, int basevertex);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDrawElementsInstanced(GLenum,GLsizei,GLenum,const GLvoid*,GLsizei)
     * @param mode
     * @param count
     * @param type
     * @param indices
     * @param instancecount
     */
    @QtUninvokable
    public final void glDrawElementsInstanced(int mode, int count, int type, java.nio.@Nullable Buffer indices, int instancecount){
        glDrawElementsInstanced_native_GLenum_GLsizei_GLenum_const_GLvoid_ptr_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), mode, count, type, indices, instancecount);
    }
    
    @QtUninvokable
    private native void glDrawElementsInstanced_native_GLenum_GLsizei_GLenum_const_GLvoid_ptr_GLsizei(long __this__nativeId, int mode, int count, int type, java.nio.Buffer indices, int instancecount);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDrawElementsInstancedBaseVertex(GLenum,GLsizei,GLenum,const GLvoid*,GLsizei,GLint)
     * @param mode
     * @param count
     * @param type
     * @param indices
     * @param instancecount
     * @param basevertex
     */
    @QtUninvokable
    public final void glDrawElementsInstancedBaseVertex(int mode, int count, int type, java.nio.@Nullable Buffer indices, int instancecount, int basevertex){
        glDrawElementsInstancedBaseVertex_native_GLenum_GLsizei_GLenum_const_GLvoid_ptr_GLsizei_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), mode, count, type, indices, instancecount, basevertex);
    }
    
    @QtUninvokable
    private native void glDrawElementsInstancedBaseVertex_native_GLenum_GLsizei_GLenum_const_GLvoid_ptr_GLsizei_GLint(long __this__nativeId, int mode, int count, int type, java.nio.Buffer indices, int instancecount, int basevertex);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDrawPixels(GLsizei,GLsizei,GLenum,GLenum,const GLvoid*)
     * @param width
     * @param height
     * @param format
     * @param type
     * @param pixels
     */
    @QtUninvokable
    public final void glDrawPixels(int width, int height, int format, int type, java.nio.@Nullable Buffer pixels){
        glDrawPixels_native_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), width, height, format, type, pixels);
    }
    
    @QtUninvokable
    private native void glDrawPixels_native_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr(long __this__nativeId, int width, int height, int format, int type, java.nio.Buffer pixels);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDrawRangeElements(GLenum,GLuint,GLuint,GLsizei,GLenum,const GLvoid*)
     * @param mode
     * @param start
     * @param end
     * @param count
     * @param type
     * @param indices
     */
    @QtUninvokable
    public final void glDrawRangeElements(int mode, int start, int end, int count, int type, java.nio.@Nullable Buffer indices){
        glDrawRangeElements_native_GLenum_GLuint_GLuint_GLsizei_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), mode, start, end, count, type, indices);
    }
    
    @QtUninvokable
    private native void glDrawRangeElements_native_GLenum_GLuint_GLuint_GLsizei_GLenum_const_GLvoid_ptr(long __this__nativeId, int mode, int start, int end, int count, int type, java.nio.Buffer indices);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glDrawRangeElementsBaseVertex(GLenum,GLuint,GLuint,GLsizei,GLenum,const GLvoid*,GLint)
     * @param mode
     * @param start
     * @param end
     * @param count
     * @param type
     * @param indices
     * @param basevertex
     */
    @QtUninvokable
    public final void glDrawRangeElementsBaseVertex(int mode, int start, int end, int count, int type, java.nio.@Nullable Buffer indices, int basevertex){
        glDrawRangeElementsBaseVertex_native_GLenum_GLuint_GLuint_GLsizei_GLenum_const_GLvoid_ptr_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), mode, start, end, count, type, indices, basevertex);
    }
    
    @QtUninvokable
    private native void glDrawRangeElementsBaseVertex_native_GLenum_GLuint_GLuint_GLsizei_GLenum_const_GLvoid_ptr_GLint(long __this__nativeId, int mode, int start, int end, int count, int type, java.nio.Buffer indices, int basevertex);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEdgeFlag(GLboolean)
     * @param flag
     */
    @QtUninvokable
    public final void glEdgeFlag(boolean flag){
        glEdgeFlag_native_GLboolean(QtJambi_LibraryUtilities.internal.nativeId(this), flag);
    }
    
    @QtUninvokable
    private native void glEdgeFlag_native_GLboolean(long __this__nativeId, boolean flag);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEdgeFlagPointer(GLsizei,const GLvoid*)
     * @param stride
     * @param pointer
     */
    @QtUninvokable
    public final void glEdgeFlagPointer(int stride, java.nio.@Nullable Buffer pointer){
        glEdgeFlagPointer_native_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), stride, pointer);
    }
    
    @QtUninvokable
    private native void glEdgeFlagPointer_native_GLsizei_const_GLvoid_ptr(long __this__nativeId, int stride, java.nio.Buffer pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEnable(GLenum)
     * @param cap
     */
    @QtUninvokable
    public final void glEnable(int cap){
        glEnable_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), cap);
    }
    
    @QtUninvokable
    private native void glEnable_native_GLenum(long __this__nativeId, int cap);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEnableClientState(GLenum)
     * @param array
     */
    @QtUninvokable
    public final void glEnableClientState(int array){
        glEnableClientState_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), array);
    }
    
    @QtUninvokable
    private native void glEnableClientState_native_GLenum(long __this__nativeId, int array);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEnableVertexAttribArray(GLuint)
     * @param index
     */
    @QtUninvokable
    public final void glEnableVertexAttribArray(int index){
        glEnableVertexAttribArray_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index);
    }
    
    @QtUninvokable
    private native void glEnableVertexAttribArray_native_GLuint(long __this__nativeId, int index);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEnablei(GLenum,GLuint)
     * @param target
     * @param index
     */
    @QtUninvokable
    public final void glEnablei(int target, int index){
        glEnablei_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, index);
    }
    
    @QtUninvokable
    private native void glEnablei_native_GLenum_GLuint(long __this__nativeId, int target, int index);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEnd()
     */
    @QtUninvokable
    public final void glEnd(){
        glEnd_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glEnd_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEndConditionalRender()
     */
    @QtUninvokable
    public final void glEndConditionalRender(){
        glEndConditionalRender_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glEndConditionalRender_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEndList()
     */
    @QtUninvokable
    public final void glEndList(){
        glEndList_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glEndList_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEndQuery(GLenum)
     * @param target
     */
    @QtUninvokable
    public final void glEndQuery(int target){
        glEndQuery_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target);
    }
    
    @QtUninvokable
    private native void glEndQuery_native_GLenum(long __this__nativeId, int target);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEndTransformFeedback()
     */
    @QtUninvokable
    public final void glEndTransformFeedback(){
        glEndTransformFeedback_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glEndTransformFeedback_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalCoord1d(GLdouble)
     * @param u
     */
    @QtUninvokable
    public final void glEvalCoord1d(double u){
        glEvalCoord1d_native_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), u);
    }
    
    @QtUninvokable
    private native void glEvalCoord1d_native_GLdouble(long __this__nativeId, double u);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalCoord1dv(const GLdouble*)
     * @param u
     */
    @QtUninvokable
    public final void glEvalCoord1dv(double[] u){
        if(u!=null && u.length < 1)
            throw new IllegalArgumentException("Argument 'u': Wrong number of elements in array. Found: " + u.length + ", expected: 1");
        glEvalCoord1dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), u);
    }
    
    @QtUninvokable
    private native void glEvalCoord1dv_native_const_GLdouble_ptr(long __this__nativeId, double[] u);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalCoord1f(GLfloat)
     * @param u
     */
    @QtUninvokable
    public final void glEvalCoord1f(float u){
        glEvalCoord1f_native_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), u);
    }
    
    @QtUninvokable
    private native void glEvalCoord1f_native_GLfloat(long __this__nativeId, float u);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalCoord1fv(const GLfloat*)
     * @param u
     */
    @QtUninvokable
    public final void glEvalCoord1fv(float[] u){
        if(u!=null && u.length < 1)
            throw new IllegalArgumentException("Argument 'u': Wrong number of elements in array. Found: " + u.length + ", expected: 1");
        glEvalCoord1fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), u);
    }
    
    @QtUninvokable
    private native void glEvalCoord1fv_native_const_GLfloat_ptr(long __this__nativeId, float[] u);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalCoord2d(GLdouble,GLdouble)
     * @param u
     * @param v
     */
    @QtUninvokable
    public final void glEvalCoord2d(double u, double v){
        glEvalCoord2d_native_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), u, v);
    }
    
    @QtUninvokable
    private native void glEvalCoord2d_native_GLdouble_GLdouble(long __this__nativeId, double u, double v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalCoord2dv(const GLdouble*)
     * @param u
     */
    @QtUninvokable
    public final void glEvalCoord2dv(double[] u){
        if(u!=null && u.length < 2)
            throw new IllegalArgumentException("Argument 'u': Wrong number of elements in array. Found: " + u.length + ", expected: 2");
        glEvalCoord2dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), u);
    }
    
    @QtUninvokable
    private native void glEvalCoord2dv_native_const_GLdouble_ptr(long __this__nativeId, double[] u);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalCoord2f(GLfloat,GLfloat)
     * @param u
     * @param v
     */
    @QtUninvokable
    public final void glEvalCoord2f(float u, float v){
        glEvalCoord2f_native_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), u, v);
    }
    
    @QtUninvokable
    private native void glEvalCoord2f_native_GLfloat_GLfloat(long __this__nativeId, float u, float v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalCoord2fv(const GLfloat*)
     * @param u
     */
    @QtUninvokable
    public final void glEvalCoord2fv(float[] u){
        if(u!=null && u.length < 2)
            throw new IllegalArgumentException("Argument 'u': Wrong number of elements in array. Found: " + u.length + ", expected: 2");
        glEvalCoord2fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), u);
    }
    
    @QtUninvokable
    private native void glEvalCoord2fv_native_const_GLfloat_ptr(long __this__nativeId, float[] u);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalMesh1(GLenum,GLint,GLint)
     * @param mode
     * @param i1
     * @param i2
     */
    @QtUninvokable
    public final void glEvalMesh1(int mode, int i1, int i2){
        glEvalMesh1_native_GLenum_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), mode, i1, i2);
    }
    
    @QtUninvokable
    private native void glEvalMesh1_native_GLenum_GLint_GLint(long __this__nativeId, int mode, int i1, int i2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalMesh2(GLenum,GLint,GLint,GLint,GLint)
     * @param mode
     * @param i1
     * @param i2
     * @param j1
     * @param j2
     */
    @QtUninvokable
    public final void glEvalMesh2(int mode, int i1, int i2, int j1, int j2){
        glEvalMesh2_native_GLenum_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), mode, i1, i2, j1, j2);
    }
    
    @QtUninvokable
    private native void glEvalMesh2_native_GLenum_GLint_GLint_GLint_GLint(long __this__nativeId, int mode, int i1, int i2, int j1, int j2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalPoint1(GLint)
     * @param i
     */
    @QtUninvokable
    public final void glEvalPoint1(int i){
        glEvalPoint1_native_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), i);
    }
    
    @QtUninvokable
    private native void glEvalPoint1_native_GLint(long __this__nativeId, int i);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glEvalPoint2(GLint,GLint)
     * @param i
     * @param j
     */
    @QtUninvokable
    public final void glEvalPoint2(int i, int j){
        glEvalPoint2_native_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), i, j);
    }
    
    @QtUninvokable
    private native void glEvalPoint2_native_GLint_GLint(long __this__nativeId, int i, int j);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFeedbackBuffer(GLsizei,GLenum,GLfloat*)
     * @param type
     * @param buffer
     */
    @QtUninvokable
    public final void glFeedbackBuffer(int type, java.nio.@Nullable FloatBuffer buffer){
        glFeedbackBuffer_native_GLsizei_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, buffer);
    }
    
    @QtUninvokable
    private native void glFeedbackBuffer_native_GLsizei_GLenum_GLfloat_ptr(long __this__nativeId, int type, java.nio.FloatBuffer buffer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFenceSync(GLenum,GLbitfield)
     * @param condition
     * @param flags
     * @return
     */
    @QtUninvokable
    public final io.qt.gui.gl.@Nullable GLsync glFenceSync(int condition, int flags){
        return glFenceSync_native_GLenum_GLbitfield(QtJambi_LibraryUtilities.internal.nativeId(this), condition, flags);
    }
    
    @QtUninvokable
    private native io.qt.gui.gl.GLsync glFenceSync_native_GLenum_GLbitfield(long __this__nativeId, int condition, int flags);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFinish()
     */
    @QtUninvokable
    public final void glFinish(){
        glFinish_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glFinish_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFlush()
     */
    @QtUninvokable
    public final void glFlush(){
        glFlush_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glFlush_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFlushMappedBufferRange(GLenum,GLintptr,GLsizeiptr)
     * @param target
     * @param offset
     * @param length
     */
    @QtUninvokable
    public final void glFlushMappedBufferRange(int target, long offset, long length){
        glFlushMappedBufferRange_native_GLenum_GLintptr_GLsizeiptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, offset, length);
    }
    
    @QtUninvokable
    private native void glFlushMappedBufferRange_native_GLenum_GLintptr_GLsizeiptr(long __this__nativeId, int target, long offset, long length);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFogCoordPointer(GLenum,GLsizei,const GLvoid*)
     * @param type
     * @param stride
     * @param pointer
     */
    @QtUninvokable
    public final void glFogCoordPointer(int type, int stride, java.nio.@Nullable Buffer pointer){
        glFogCoordPointer_native_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, stride, pointer);
    }
    
    @QtUninvokable
    private native void glFogCoordPointer_native_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int type, int stride, java.nio.Buffer pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFogCoordd(GLdouble)
     * @param coord
     */
    @QtUninvokable
    public final void glFogCoordd(double coord){
        glFogCoordd_native_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), coord);
    }
    
    @QtUninvokable
    private native void glFogCoordd_native_GLdouble(long __this__nativeId, double coord);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFogCoorddv(const GLdouble*)
     * @param coord
     */
    @QtUninvokable
    public final void glFogCoorddv(java.nio.@Nullable DoubleBuffer coord){
        glFogCoorddv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), coord);
    }
    
    @QtUninvokable
    private native void glFogCoorddv_native_const_GLdouble_ptr(long __this__nativeId, java.nio.DoubleBuffer coord);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFogCoordf(GLfloat)
     * @param coord
     */
    @QtUninvokable
    public final void glFogCoordf(float coord){
        glFogCoordf_native_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), coord);
    }
    
    @QtUninvokable
    private native void glFogCoordf_native_GLfloat(long __this__nativeId, float coord);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFogCoordfv(const GLfloat*)
     * @param coord
     */
    @QtUninvokable
    public final void glFogCoordfv(java.nio.@Nullable FloatBuffer coord){
        glFogCoordfv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), coord);
    }
    
    @QtUninvokable
    private native void glFogCoordfv_native_const_GLfloat_ptr(long __this__nativeId, java.nio.FloatBuffer coord);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFogf(GLenum,GLfloat)
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glFogf(int pname, float param){
        glFogf_native_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), pname, param);
    }
    
    @QtUninvokable
    private native void glFogf_native_GLenum_GLfloat(long __this__nativeId, int pname, float param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFogfv(GLenum,const GLfloat*)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glFogfv(int pname, float[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glFogfv_native_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glFogfv_native_GLenum_const_GLfloat_ptr(long __this__nativeId, int pname, float[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFogi(GLenum,GLint)
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glFogi(int pname, int param){
        glFogi_native_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), pname, param);
    }
    
    @QtUninvokable
    private native void glFogi_native_GLenum_GLint(long __this__nativeId, int pname, int param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFogiv(GLenum,const GLint*)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glFogiv(int pname, int[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glFogiv_native_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glFogiv_native_GLenum_const_GLint_ptr(long __this__nativeId, int pname, int[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFramebufferRenderbuffer(GLenum,GLenum,GLenum,GLuint)
     * @param target
     * @param attachment
     * @param renderbuffertarget
     * @param renderbuffer
     */
    @QtUninvokable
    public final void glFramebufferRenderbuffer(int target, int attachment, int renderbuffertarget, int renderbuffer){
        glFramebufferRenderbuffer_native_GLenum_GLenum_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, attachment, renderbuffertarget, renderbuffer);
    }
    
    @QtUninvokable
    private native void glFramebufferRenderbuffer_native_GLenum_GLenum_GLenum_GLuint(long __this__nativeId, int target, int attachment, int renderbuffertarget, int renderbuffer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture(GLenum,GLenum,GLuint,GLint)
     * @param target
     * @param attachment
     * @param texture
     * @param level
     */
    @QtUninvokable
    public final void glFramebufferTexture(int target, int attachment, int texture, int level){
        glFramebufferTexture_native_GLenum_GLenum_GLuint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, attachment, texture, level);
    }
    
    @QtUninvokable
    private native void glFramebufferTexture_native_GLenum_GLenum_GLuint_GLint(long __this__nativeId, int target, int attachment, int texture, int level);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture1D(GLenum,GLenum,GLenum,GLuint,GLint)
     * @param target
     * @param attachment
     * @param textarget
     * @param texture
     * @param level
     */
    @QtUninvokable
    public final void glFramebufferTexture1D(int target, int attachment, int textarget, int texture, int level){
        glFramebufferTexture1D_native_GLenum_GLenum_GLenum_GLuint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, attachment, textarget, texture, level);
    }
    
    @QtUninvokable
    private native void glFramebufferTexture1D_native_GLenum_GLenum_GLenum_GLuint_GLint(long __this__nativeId, int target, int attachment, int textarget, int texture, int level);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture2D(GLenum,GLenum,GLenum,GLuint,GLint)
     * @param target
     * @param attachment
     * @param textarget
     * @param texture
     * @param level
     */
    @QtUninvokable
    public final void glFramebufferTexture2D(int target, int attachment, int textarget, int texture, int level){
        glFramebufferTexture2D_native_GLenum_GLenum_GLenum_GLuint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, attachment, textarget, texture, level);
    }
    
    @QtUninvokable
    private native void glFramebufferTexture2D_native_GLenum_GLenum_GLenum_GLuint_GLint(long __this__nativeId, int target, int attachment, int textarget, int texture, int level);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFramebufferTexture3D(GLenum,GLenum,GLenum,GLuint,GLint,GLint)
     * @param target
     * @param attachment
     * @param textarget
     * @param texture
     * @param level
     * @param zoffset
     */
    @QtUninvokable
    public final void glFramebufferTexture3D(int target, int attachment, int textarget, int texture, int level, int zoffset){
        glFramebufferTexture3D_native_GLenum_GLenum_GLenum_GLuint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, attachment, textarget, texture, level, zoffset);
    }
    
    @QtUninvokable
    private native void glFramebufferTexture3D_native_GLenum_GLenum_GLenum_GLuint_GLint_GLint(long __this__nativeId, int target, int attachment, int textarget, int texture, int level, int zoffset);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFramebufferTextureLayer(GLenum,GLenum,GLuint,GLint,GLint)
     * @param target
     * @param attachment
     * @param texture
     * @param level
     * @param layer
     */
    @QtUninvokable
    public final void glFramebufferTextureLayer(int target, int attachment, int texture, int level, int layer){
        glFramebufferTextureLayer_native_GLenum_GLenum_GLuint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, attachment, texture, level, layer);
    }
    
    @QtUninvokable
    private native void glFramebufferTextureLayer_native_GLenum_GLenum_GLuint_GLint_GLint(long __this__nativeId, int target, int attachment, int texture, int level, int layer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFrontFace(GLenum)
     * @param mode
     */
    @QtUninvokable
    public final void glFrontFace(int mode){
        glFrontFace_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), mode);
    }
    
    @QtUninvokable
    private native void glFrontFace_native_GLenum(long __this__nativeId, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glFrustum(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble)
     * @param left
     * @param right
     * @param bottom
     * @param top
     * @param zNear
     * @param zFar
     */
    @QtUninvokable
    public final void glFrustum(double left, double right, double bottom, double top, double zNear, double zFar){
        glFrustum_native_GLdouble_GLdouble_GLdouble_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), left, right, bottom, top, zNear, zFar);
    }
    
    @QtUninvokable
    private native void glFrustum_native_GLdouble_GLdouble_GLdouble_GLdouble_GLdouble_GLdouble(long __this__nativeId, double left, double right, double bottom, double top, double zNear, double zFar);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGenBuffers(GLsizei,GLuint*)
     * @param n
     * @param buffers
     */
    @QtUninvokable
    public final void glGenBuffers(int n, java.nio.@Nullable IntBuffer buffers){
        glGenBuffers_native_GLsizei_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, buffers);
    }
    
    @QtUninvokable
    private native void glGenBuffers_native_GLsizei_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer buffers);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGenFramebuffers(GLsizei,GLuint*)
     * @param n
     * @param framebuffers
     */
    @QtUninvokable
    public final void glGenFramebuffers(int n, java.nio.@Nullable IntBuffer framebuffers){
        glGenFramebuffers_native_GLsizei_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, framebuffers);
    }
    
    @QtUninvokable
    private native void glGenFramebuffers_native_GLsizei_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer framebuffers);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGenLists(GLsizei)
     * @param range
     * @return
     */
    @QtUninvokable
    public final int glGenLists(int range){
        return glGenLists_native_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), range);
    }
    
    @QtUninvokable
    private native int glGenLists_native_GLsizei(long __this__nativeId, int range);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGenQueries(GLsizei,GLuint*)
     * @param n
     * @param ids
     */
    @QtUninvokable
    public final void glGenQueries(int n, java.nio.@Nullable IntBuffer ids){
        glGenQueries_native_GLsizei_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, ids);
    }
    
    @QtUninvokable
    private native void glGenQueries_native_GLsizei_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer ids);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGenRenderbuffers(GLsizei,GLuint*)
     * @param n
     * @param renderbuffers
     */
    @QtUninvokable
    public final void glGenRenderbuffers(int n, java.nio.@Nullable IntBuffer renderbuffers){
        glGenRenderbuffers_native_GLsizei_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, renderbuffers);
    }
    
    @QtUninvokable
    private native void glGenRenderbuffers_native_GLsizei_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer renderbuffers);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGenSamplers(GLsizei,GLuint*)
     * @param count
     * @param samplers
     */
    @QtUninvokable
    public final void glGenSamplers(int count, java.nio.@Nullable IntBuffer samplers){
        glGenSamplers_native_GLsizei_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), count, samplers);
    }
    
    @QtUninvokable
    private native void glGenSamplers_native_GLsizei_GLuint_ptr(long __this__nativeId, int count, java.nio.IntBuffer samplers);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGenTextures(GLsizei,GLuint*)
     * @param n
     * @param textures
     */
    @QtUninvokable
    public final void glGenTextures(int n, java.nio.@Nullable IntBuffer textures){
        glGenTextures_native_GLsizei_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, textures);
    }
    
    @QtUninvokable
    private native void glGenTextures_native_GLsizei_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer textures);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGenVertexArrays(GLsizei,GLuint*)
     * @param n
     * @param arrays
     */
    @QtUninvokable
    public final void glGenVertexArrays(int n, java.nio.@Nullable IntBuffer arrays){
        glGenVertexArrays_native_GLsizei_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, arrays);
    }
    
    @QtUninvokable
    private native void glGenVertexArrays_native_GLsizei_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer arrays);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGenerateMipmap(GLenum)
     * @param target
     */
    @QtUninvokable
    public final void glGenerateMipmap(int target){
        glGenerateMipmap_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target);
    }
    
    @QtUninvokable
    private native void glGenerateMipmap_native_GLenum(long __this__nativeId, int target);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetActiveAttrib(GLuint,GLuint,GLsizei,GLsizei*,GLint*,GLenum*,GLchar*)
     * @param program
     * @param index
     * @param bufSize
     * @param length
     * @param size
     * @param type
     * @param name
     */
    @QtUninvokable
    public final void glGetActiveAttrib(int program, int index, int bufSize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable IntBuffer size, java.nio.@Nullable IntBuffer type, java.nio.@Nullable CharBuffer name){
        glGetActiveAttrib_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLint_ptr_GLenum_ptr_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, index, bufSize, length, size, type, name);
    }
    
    @QtUninvokable
    private native void glGetActiveAttrib_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLint_ptr_GLenum_ptr_GLchar_ptr(long __this__nativeId, int program, int index, int bufSize, java.nio.IntBuffer length, java.nio.IntBuffer size, java.nio.IntBuffer type, java.nio.CharBuffer name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetActiveUniform(GLuint,GLuint,GLsizei,GLsizei*,GLint*,GLenum*,GLchar*)
     * @param program
     * @param index
     * @param bufSize
     * @param length
     * @param size
     * @param type
     * @param name
     */
    @QtUninvokable
    public final void glGetActiveUniform(int program, int index, int bufSize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable IntBuffer size, java.nio.@Nullable IntBuffer type, java.nio.@Nullable CharBuffer name){
        glGetActiveUniform_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLint_ptr_GLenum_ptr_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, index, bufSize, length, size, type, name);
    }
    
    @QtUninvokable
    private native void glGetActiveUniform_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLint_ptr_GLenum_ptr_GLchar_ptr(long __this__nativeId, int program, int index, int bufSize, java.nio.IntBuffer length, java.nio.IntBuffer size, java.nio.IntBuffer type, java.nio.CharBuffer name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformBlockName(GLuint,GLuint,GLsizei,GLsizei*,GLchar*)
     * @param program
     * @param uniformBlockIndex
     * @param bufSize
     * @param length
     * @param uniformBlockName
     */
    @QtUninvokable
    public final void glGetActiveUniformBlockName(int program, int uniformBlockIndex, int bufSize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable CharBuffer uniformBlockName){
        glGetActiveUniformBlockName_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, uniformBlockIndex, bufSize, length, uniformBlockName);
    }
    
    @QtUninvokable
    private native void glGetActiveUniformBlockName_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLchar_ptr(long __this__nativeId, int program, int uniformBlockIndex, int bufSize, java.nio.IntBuffer length, java.nio.CharBuffer uniformBlockName);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformBlockiv(GLuint,GLuint,GLenum,GLint*)
     * @param program
     * @param uniformBlockIndex
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetActiveUniformBlockiv(int program, int uniformBlockIndex, int pname, java.nio.@Nullable IntBuffer params){
        glGetActiveUniformBlockiv_native_GLuint_GLuint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, uniformBlockIndex, pname, params);
    }
    
    @QtUninvokable
    private native void glGetActiveUniformBlockiv_native_GLuint_GLuint_GLenum_GLint_ptr(long __this__nativeId, int program, int uniformBlockIndex, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformName(GLuint,GLuint,GLsizei,GLsizei*,GLchar*)
     * @param program
     * @param uniformIndex
     * @param bufSize
     * @param length
     * @param uniformName
     */
    @QtUninvokable
    public final void glGetActiveUniformName(int program, int uniformIndex, int bufSize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable CharBuffer uniformName){
        glGetActiveUniformName_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, uniformIndex, bufSize, length, uniformName);
    }
    
    @QtUninvokable
    private native void glGetActiveUniformName_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLchar_ptr(long __this__nativeId, int program, int uniformIndex, int bufSize, java.nio.IntBuffer length, java.nio.CharBuffer uniformName);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetActiveUniformsiv(GLuint,GLsizei,const GLuint*,GLenum,GLint*)
     * @param program
     * @param uniformCount
     * @param uniformIndices
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetActiveUniformsiv(int program, int uniformCount, java.nio.@Nullable IntBuffer uniformIndices, int pname, java.nio.@Nullable IntBuffer params){
        glGetActiveUniformsiv_native_GLuint_GLsizei_const_GLuint_ptr_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, uniformCount, uniformIndices, pname, params);
    }
    
    @QtUninvokable
    private native void glGetActiveUniformsiv_native_GLuint_GLsizei_const_GLuint_ptr_GLenum_GLint_ptr(long __this__nativeId, int program, int uniformCount, java.nio.IntBuffer uniformIndices, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetAttachedShaders(GLuint,GLsizei,GLsizei*,GLuint*)
     * @param program
     * @param maxCount
     * @param count
     * @param obj
     */
    @QtUninvokable
    public final void glGetAttachedShaders(int program, int maxCount, java.nio.@Nullable IntBuffer count, java.nio.@Nullable IntBuffer obj){
        glGetAttachedShaders_native_GLuint_GLsizei_GLsizei_ptr_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, maxCount, count, obj);
    }
    
    @QtUninvokable
    private native void glGetAttachedShaders_native_GLuint_GLsizei_GLsizei_ptr_GLuint_ptr(long __this__nativeId, int program, int maxCount, java.nio.IntBuffer count, java.nio.IntBuffer obj);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetAttribLocation(GLuint,const GLchar*)
     * @param program
     * @param name
     * @return
     */
    @QtUninvokable
    public final int glGetAttribLocation(int program, java.nio.@Nullable CharBuffer name){
        return glGetAttribLocation_native_GLuint_const_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, name);
    }
    
    @QtUninvokable
    private native int glGetAttribLocation_native_GLuint_const_GLchar_ptr(long __this__nativeId, int program, java.nio.CharBuffer name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetBooleani_v(GLenum,GLuint,GLboolean*)
     * @param target
     * @param index
     * @param data
     */
    @QtUninvokable
    public final void glGetBooleani_v(int target, int index, java.nio.@Nullable IntBuffer data){
        glGetBooleani_v_native_GLenum_GLuint_GLboolean_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, index, data);
    }
    
    @QtUninvokable
    private native void glGetBooleani_v_native_GLenum_GLuint_GLboolean_ptr(long __this__nativeId, int target, int index, java.nio.IntBuffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetBooleanv(GLenum,GLboolean*)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetBooleanv(int pname, boolean[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glGetBooleanv_native_GLenum_GLboolean_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glGetBooleanv_native_GLenum_GLboolean_ptr(long __this__nativeId, int pname, boolean[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetBufferParameteri64v(GLenum,GLenum,GLint64*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetBufferParameteri64v(int target, int pname, java.nio.@Nullable LongBuffer params){
        glGetBufferParameteri64v_native_GLenum_GLenum_GLint64_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetBufferParameteri64v_native_GLenum_GLenum_GLint64_ptr(long __this__nativeId, int target, int pname, java.nio.LongBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetBufferParameteriv(GLenum,GLenum,GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetBufferParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetBufferParameteriv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetBufferParameteriv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetBufferPointerv(GLenum,GLenum,GLvoid**)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetBufferPointerv(int target, int pname, java.nio.@Nullable Buffer[] params){
        glGetBufferPointerv_native_GLenum_GLenum_GLvoid_ptr_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetBufferPointerv_native_GLenum_GLenum_GLvoid_ptr_ptr(long __this__nativeId, int target, int pname, java.nio.Buffer[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetBufferSubData(GLenum,GLintptr,GLsizeiptr,GLvoid*)
     * @param target
     * @param offset
     * @param size
     * @param data
     */
    @QtUninvokable
    public final void glGetBufferSubData(int target, long offset, long size, java.nio.@Nullable Buffer data){
        glGetBufferSubData_native_GLenum_GLintptr_GLsizeiptr_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, offset, size, data);
    }
    
    @QtUninvokable
    private native void glGetBufferSubData_native_GLenum_GLintptr_GLsizeiptr_GLvoid_ptr(long __this__nativeId, int target, long offset, long size, java.nio.Buffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetClipPlane(GLenum,GLdouble*)
     * @param plane
     * @param equation
     */
    @QtUninvokable
    public final void glGetClipPlane(int plane, double[] equation){
        if(equation!=null && equation.length < 4)
            throw new IllegalArgumentException("Argument 'equation': Wrong number of elements in array. Found: " + equation.length + ", expected: 4");
        glGetClipPlane_native_GLenum_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), plane, equation);
    }
    
    @QtUninvokable
    private native void glGetClipPlane_native_GLenum_GLdouble_ptr(long __this__nativeId, int plane, double[] equation);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetColorTable(GLenum,GLenum,GLenum,GLvoid*)
     * @param target
     * @param format
     * @param type
     * @param table
     */
    @QtUninvokable
    public final void glGetColorTable(int target, int format, int type, java.nio.@Nullable Buffer table){
        glGetColorTable_native_GLenum_GLenum_GLenum_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, format, type, table);
    }
    
    @QtUninvokable
    private native void glGetColorTable_native_GLenum_GLenum_GLenum_GLvoid_ptr(long __this__nativeId, int target, int format, int type, java.nio.Buffer table);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetColorTableParameterfv(GLenum,GLenum,GLfloat*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetColorTableParameterfv(int target, int pname, java.nio.@Nullable FloatBuffer params){
        glGetColorTableParameterfv_native_GLenum_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetColorTableParameterfv_native_GLenum_GLenum_GLfloat_ptr(long __this__nativeId, int target, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetColorTableParameteriv(GLenum,GLenum,GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetColorTableParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetColorTableParameteriv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetColorTableParameteriv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetCompressedTexImage(GLenum,GLint,GLvoid*)
     * @param target
     * @param level
     * @param img
     */
    @QtUninvokable
    public final void glGetCompressedTexImage(int target, int level, java.nio.@Nullable Buffer img){
        glGetCompressedTexImage_native_GLenum_GLint_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, img);
    }
    
    @QtUninvokable
    private native void glGetCompressedTexImage_native_GLenum_GLint_GLvoid_ptr(long __this__nativeId, int target, int level, java.nio.Buffer img);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetConvolutionFilter(GLenum,GLenum,GLenum,GLvoid*)
     * @param target
     * @param format
     * @param type
     * @param image
     */
    @QtUninvokable
    public final void glGetConvolutionFilter(int target, int format, int type, java.nio.@Nullable Buffer image){
        glGetConvolutionFilter_native_GLenum_GLenum_GLenum_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, format, type, image);
    }
    
    @QtUninvokable
    private native void glGetConvolutionFilter_native_GLenum_GLenum_GLenum_GLvoid_ptr(long __this__nativeId, int target, int format, int type, java.nio.Buffer image);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetConvolutionParameterfv(GLenum,GLenum,GLfloat*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetConvolutionParameterfv(int target, int pname, java.nio.@Nullable FloatBuffer params){
        glGetConvolutionParameterfv_native_GLenum_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetConvolutionParameterfv_native_GLenum_GLenum_GLfloat_ptr(long __this__nativeId, int target, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetConvolutionParameteriv(GLenum,GLenum,GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetConvolutionParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetConvolutionParameteriv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetConvolutionParameteriv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetDoublev(GLenum,GLdouble*)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetDoublev(int pname, double[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glGetDoublev_native_GLenum_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glGetDoublev_native_GLenum_GLdouble_ptr(long __this__nativeId, int pname, double[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetError()
     * @return
     */
    @QtUninvokable
    public final int glGetError(){
        return glGetError_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int glGetError_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetFloatv(GLenum,GLfloat*)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetFloatv(int pname, float[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glGetFloatv_native_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glGetFloatv_native_GLenum_GLfloat_ptr(long __this__nativeId, int pname, float[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetFragDataIndex(GLuint,const GLchar*)
     * @param program
     * @param name
     * @return
     */
    @QtUninvokable
    public final int glGetFragDataIndex(int program, java.nio.@Nullable CharBuffer name){
        return glGetFragDataIndex_native_GLuint_const_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, name);
    }
    
    @QtUninvokable
    private native int glGetFragDataIndex_native_GLuint_const_GLchar_ptr(long __this__nativeId, int program, java.nio.CharBuffer name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetFragDataLocation(GLuint,const GLchar*)
     * @param program
     * @param name
     * @return
     */
    @QtUninvokable
    public final int glGetFragDataLocation(int program, java.nio.@Nullable CharBuffer name){
        return glGetFragDataLocation_native_GLuint_const_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, name);
    }
    
    @QtUninvokable
    private native int glGetFragDataLocation_native_GLuint_const_GLchar_ptr(long __this__nativeId, int program, java.nio.CharBuffer name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetFramebufferAttachmentParameteriv(GLenum,GLenum,GLenum,GLint*)
     * @param target
     * @param attachment
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetFramebufferAttachmentParameteriv(int target, int attachment, int pname, java.nio.@Nullable IntBuffer params){
        glGetFramebufferAttachmentParameteriv_native_GLenum_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, attachment, pname, params);
    }
    
    @QtUninvokable
    private native void glGetFramebufferAttachmentParameteriv_native_GLenum_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int attachment, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetHistogram(GLenum,GLboolean,GLenum,GLenum,GLvoid*)
     * @param target
     * @param reset
     * @param format
     * @param type
     * @param values
     */
    @QtUninvokable
    public final void glGetHistogram(int target, boolean reset, int format, int type, java.nio.@Nullable Buffer values){
        glGetHistogram_native_GLenum_GLboolean_GLenum_GLenum_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, reset, format, type, values);
    }
    
    @QtUninvokable
    private native void glGetHistogram_native_GLenum_GLboolean_GLenum_GLenum_GLvoid_ptr(long __this__nativeId, int target, boolean reset, int format, int type, java.nio.Buffer values);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetHistogramParameterfv(GLenum,GLenum,GLfloat*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetHistogramParameterfv(int target, int pname, java.nio.@Nullable FloatBuffer params){
        glGetHistogramParameterfv_native_GLenum_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetHistogramParameterfv_native_GLenum_GLenum_GLfloat_ptr(long __this__nativeId, int target, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetHistogramParameteriv(GLenum,GLenum,GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetHistogramParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetHistogramParameteriv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetHistogramParameteriv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetInteger64i_v(GLenum,GLuint,GLint64*)
     * @param target
     * @param index
     * @param data
     */
    @QtUninvokable
    public final void glGetInteger64i_v(int target, int index, java.nio.@Nullable LongBuffer data){
        glGetInteger64i_v_native_GLenum_GLuint_GLint64_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, index, data);
    }
    
    @QtUninvokable
    private native void glGetInteger64i_v_native_GLenum_GLuint_GLint64_ptr(long __this__nativeId, int target, int index, java.nio.LongBuffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetInteger64v(GLenum,GLint64*)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetInteger64v(int pname, java.nio.@Nullable LongBuffer params){
        glGetInteger64v_native_GLenum_GLint64_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glGetInteger64v_native_GLenum_GLint64_ptr(long __this__nativeId, int pname, java.nio.LongBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetIntegeri_v(GLenum,GLuint,GLint*)
     * @param target
     * @param index
     * @param data
     */
    @QtUninvokable
    public final void glGetIntegeri_v(int target, int index, java.nio.@Nullable IntBuffer data){
        glGetIntegeri_v_native_GLenum_GLuint_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, index, data);
    }
    
    @QtUninvokable
    private native void glGetIntegeri_v_native_GLenum_GLuint_GLint_ptr(long __this__nativeId, int target, int index, java.nio.IntBuffer data);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetIntegerv(GLenum,GLint*)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetIntegerv(int pname, int[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glGetIntegerv_native_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glGetIntegerv_native_GLenum_GLint_ptr(long __this__nativeId, int pname, int[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetLightfv(GLenum,GLenum,GLfloat*)
     * @param light
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetLightfv(int light, int pname, float[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glGetLightfv_native_GLenum_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), light, pname, params);
    }
    
    @QtUninvokable
    private native void glGetLightfv_native_GLenum_GLenum_GLfloat_ptr(long __this__nativeId, int light, int pname, float[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetLightiv(GLenum,GLenum,GLint*)
     * @param light
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetLightiv(int light, int pname, int[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glGetLightiv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), light, pname, params);
    }
    
    @QtUninvokable
    private native void glGetLightiv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int light, int pname, int[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetMapdv(GLenum,GLenum,GLdouble*)
     * @param target
     * @param query
     * @param v
     */
    @QtUninvokable
    public final void glGetMapdv(int target, int query, double[] v){
        if(v!=null && v.length < 1)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 1");
        glGetMapdv_native_GLenum_GLenum_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, query, v);
    }
    
    @QtUninvokable
    private native void glGetMapdv_native_GLenum_GLenum_GLdouble_ptr(long __this__nativeId, int target, int query, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetMapfv(GLenum,GLenum,GLfloat*)
     * @param target
     * @param query
     * @param v
     */
    @QtUninvokable
    public final void glGetMapfv(int target, int query, float[] v){
        if(v!=null && v.length < 1)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 1");
        glGetMapfv_native_GLenum_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, query, v);
    }
    
    @QtUninvokable
    private native void glGetMapfv_native_GLenum_GLenum_GLfloat_ptr(long __this__nativeId, int target, int query, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetMapiv(GLenum,GLenum,GLint*)
     * @param target
     * @param query
     * @param v
     */
    @QtUninvokable
    public final void glGetMapiv(int target, int query, int[] v){
        if(v!=null && v.length < 1)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 1");
        glGetMapiv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, query, v);
    }
    
    @QtUninvokable
    private native void glGetMapiv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int query, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetMaterialfv(GLenum,GLenum,GLfloat*)
     * @param face
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetMaterialfv(int face, int pname, float[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glGetMaterialfv_native_GLenum_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), face, pname, params);
    }
    
    @QtUninvokable
    private native void glGetMaterialfv_native_GLenum_GLenum_GLfloat_ptr(long __this__nativeId, int face, int pname, float[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetMaterialiv(GLenum,GLenum,GLint*)
     * @param face
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetMaterialiv(int face, int pname, int[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glGetMaterialiv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), face, pname, params);
    }
    
    @QtUninvokable
    private native void glGetMaterialiv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int face, int pname, int[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetMinmax(GLenum,GLboolean,GLenum,GLenum,GLvoid*)
     * @param target
     * @param reset
     * @param format
     * @param type
     * @param values
     */
    @QtUninvokable
    public final void glGetMinmax(int target, boolean reset, int format, int type, java.nio.@Nullable Buffer values){
        glGetMinmax_native_GLenum_GLboolean_GLenum_GLenum_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, reset, format, type, values);
    }
    
    @QtUninvokable
    private native void glGetMinmax_native_GLenum_GLboolean_GLenum_GLenum_GLvoid_ptr(long __this__nativeId, int target, boolean reset, int format, int type, java.nio.Buffer values);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetMinmaxParameterfv(GLenum,GLenum,GLfloat*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetMinmaxParameterfv(int target, int pname, java.nio.@Nullable FloatBuffer params){
        glGetMinmaxParameterfv_native_GLenum_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetMinmaxParameterfv_native_GLenum_GLenum_GLfloat_ptr(long __this__nativeId, int target, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetMinmaxParameteriv(GLenum,GLenum,GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetMinmaxParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetMinmaxParameteriv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetMinmaxParameteriv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetMultisamplefv(GLenum,GLuint,GLfloat*)
     * @param pname
     * @param index
     * @param val
     */
    @QtUninvokable
    public final void glGetMultisamplefv(int pname, int index, java.nio.@Nullable FloatBuffer val){
        glGetMultisamplefv_native_GLenum_GLuint_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, index, val);
    }
    
    @QtUninvokable
    private native void glGetMultisamplefv_native_GLenum_GLuint_GLfloat_ptr(long __this__nativeId, int pname, int index, java.nio.FloatBuffer val);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetPixelMapfv(GLenum,GLfloat*)
     * @param map
     * @param values
     */
    @QtUninvokable
    public final void glGetPixelMapfv(int map, java.nio.@Nullable FloatBuffer values){
        glGetPixelMapfv_native_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), map, values);
    }
    
    @QtUninvokable
    private native void glGetPixelMapfv_native_GLenum_GLfloat_ptr(long __this__nativeId, int map, java.nio.FloatBuffer values);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetPixelMapuiv(GLenum,GLuint*)
     * @param map
     * @param values
     */
    @QtUninvokable
    public final void glGetPixelMapuiv(int map, java.nio.@Nullable IntBuffer values){
        glGetPixelMapuiv_native_GLenum_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), map, values);
    }
    
    @QtUninvokable
    private native void glGetPixelMapuiv_native_GLenum_GLuint_ptr(long __this__nativeId, int map, java.nio.IntBuffer values);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetPixelMapusv(GLenum,GLushort*)
     * @param map
     * @param values
     */
    @QtUninvokable
    public final void glGetPixelMapusv(int map, java.nio.@Nullable ShortBuffer values){
        glGetPixelMapusv_native_GLenum_GLushort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), map, values);
    }
    
    @QtUninvokable
    private native void glGetPixelMapusv_native_GLenum_GLushort_ptr(long __this__nativeId, int map, java.nio.ShortBuffer values);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetPointerv(GLenum,GLvoid**)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetPointerv(int pname, java.nio.Buffer @StrictNonNull[] params){
        java.util.Objects.requireNonNull(params, "Argument 'params': null not expected.");
        glGetPointerv_native_GLenum_GLvoid_ptr_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glGetPointerv_native_GLenum_GLvoid_ptr_ptr(long __this__nativeId, int pname, java.nio.Buffer[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetPolygonStipple(GLubyte*)
     * @param mask
     */
    @QtUninvokable
    public final void glGetPolygonStipple(java.nio.@Nullable ByteBuffer mask){
        glGetPolygonStipple_native_GLubyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), mask);
    }
    
    @QtUninvokable
    private native void glGetPolygonStipple_native_GLubyte_ptr(long __this__nativeId, java.nio.ByteBuffer mask);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetProgramInfoLog(GLuint,GLsizei,GLsizei*,GLchar*)
     * @param program
     * @param bufSize
     * @param length
     * @param infoLog
     */
    @QtUninvokable
    public final void glGetProgramInfoLog(int program, int bufSize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable CharBuffer infoLog){
        glGetProgramInfoLog_native_GLuint_GLsizei_GLsizei_ptr_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, bufSize, length, infoLog);
    }
    
    @QtUninvokable
    private native void glGetProgramInfoLog_native_GLuint_GLsizei_GLsizei_ptr_GLchar_ptr(long __this__nativeId, int program, int bufSize, java.nio.IntBuffer length, java.nio.CharBuffer infoLog);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetProgramiv(GLuint,GLenum,GLint*)
     * @param program
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetProgramiv(int program, int pname, java.nio.@Nullable IntBuffer params){
        glGetProgramiv_native_GLuint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, pname, params);
    }
    
    @QtUninvokable
    private native void glGetProgramiv_native_GLuint_GLenum_GLint_ptr(long __this__nativeId, int program, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetQueryObjecti64v(GLuint,GLenum,GLint64*)
     * @param id
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetQueryObjecti64v(int id, int pname, java.nio.@Nullable LongBuffer params){
        glGetQueryObjecti64v_native_GLuint_GLenum_GLint64_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), id, pname, params);
    }
    
    @QtUninvokable
    private native void glGetQueryObjecti64v_native_GLuint_GLenum_GLint64_ptr(long __this__nativeId, int id, int pname, java.nio.LongBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetQueryObjectiv(GLuint,GLenum,GLint*)
     * @param id
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetQueryObjectiv(int id, int pname, java.nio.@Nullable IntBuffer params){
        glGetQueryObjectiv_native_GLuint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), id, pname, params);
    }
    
    @QtUninvokable
    private native void glGetQueryObjectiv_native_GLuint_GLenum_GLint_ptr(long __this__nativeId, int id, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetQueryObjectui64v(GLuint,GLenum,GLuint64*)
     * @param id
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetQueryObjectui64v(int id, int pname, java.nio.@Nullable LongBuffer params){
        glGetQueryObjectui64v_native_GLuint_GLenum_GLuint64_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), id, pname, params);
    }
    
    @QtUninvokable
    private native void glGetQueryObjectui64v_native_GLuint_GLenum_GLuint64_ptr(long __this__nativeId, int id, int pname, java.nio.LongBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetQueryObjectuiv(GLuint,GLenum,GLuint*)
     * @param id
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetQueryObjectuiv(int id, int pname, java.nio.@Nullable IntBuffer params){
        glGetQueryObjectuiv_native_GLuint_GLenum_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), id, pname, params);
    }
    
    @QtUninvokable
    private native void glGetQueryObjectuiv_native_GLuint_GLenum_GLuint_ptr(long __this__nativeId, int id, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetQueryiv(GLenum,GLenum,GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetQueryiv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetQueryiv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetQueryiv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetRenderbufferParameteriv(GLenum,GLenum,GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetRenderbufferParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetRenderbufferParameteriv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetRenderbufferParameteriv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameterIiv(GLuint,GLenum,GLint*)
     * @param sampler
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetSamplerParameterIiv(int sampler, int pname, java.nio.@Nullable IntBuffer params){
        glGetSamplerParameterIiv_native_GLuint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), sampler, pname, params);
    }
    
    @QtUninvokable
    private native void glGetSamplerParameterIiv_native_GLuint_GLenum_GLint_ptr(long __this__nativeId, int sampler, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameterIuiv(GLuint,GLenum,GLuint*)
     * @param sampler
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetSamplerParameterIuiv(int sampler, int pname, java.nio.@Nullable IntBuffer params){
        glGetSamplerParameterIuiv_native_GLuint_GLenum_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), sampler, pname, params);
    }
    
    @QtUninvokable
    private native void glGetSamplerParameterIuiv_native_GLuint_GLenum_GLuint_ptr(long __this__nativeId, int sampler, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameterfv(GLuint,GLenum,GLfloat*)
     * @param sampler
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetSamplerParameterfv(int sampler, int pname, java.nio.@Nullable FloatBuffer params){
        glGetSamplerParameterfv_native_GLuint_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), sampler, pname, params);
    }
    
    @QtUninvokable
    private native void glGetSamplerParameterfv_native_GLuint_GLenum_GLfloat_ptr(long __this__nativeId, int sampler, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetSamplerParameteriv(GLuint,GLenum,GLint*)
     * @param sampler
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetSamplerParameteriv(int sampler, int pname, java.nio.@Nullable IntBuffer params){
        glGetSamplerParameteriv_native_GLuint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), sampler, pname, params);
    }
    
    @QtUninvokable
    private native void glGetSamplerParameteriv_native_GLuint_GLenum_GLint_ptr(long __this__nativeId, int sampler, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetSeparableFilter(GLenum,GLenum,GLenum,GLvoid*,GLvoid*,GLvoid*)
     * @param target
     * @param format
     * @param type
     * @param row
     * @param column
     * @param span
     */
    @QtUninvokable
    public final void glGetSeparableFilter(int target, int format, int type, java.nio.@Nullable Buffer row, java.nio.@Nullable Buffer column, java.nio.@Nullable Buffer span){
        glGetSeparableFilter_native_GLenum_GLenum_GLenum_GLvoid_ptr_GLvoid_ptr_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, format, type, row, column, span);
    }
    
    @QtUninvokable
    private native void glGetSeparableFilter_native_GLenum_GLenum_GLenum_GLvoid_ptr_GLvoid_ptr_GLvoid_ptr(long __this__nativeId, int target, int format, int type, java.nio.Buffer row, java.nio.Buffer column, java.nio.Buffer span);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetShaderInfoLog(GLuint,GLsizei,GLsizei*,GLchar*)
     * @param shader
     * @param bufSize
     * @param length
     * @param infoLog
     */
    @QtUninvokable
    public final void glGetShaderInfoLog(int shader, int bufSize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable CharBuffer infoLog){
        glGetShaderInfoLog_native_GLuint_GLsizei_GLsizei_ptr_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), shader, bufSize, length, infoLog);
    }
    
    @QtUninvokable
    private native void glGetShaderInfoLog_native_GLuint_GLsizei_GLsizei_ptr_GLchar_ptr(long __this__nativeId, int shader, int bufSize, java.nio.IntBuffer length, java.nio.CharBuffer infoLog);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetShaderSource(GLuint,GLsizei,GLsizei*,GLchar*)
     * @param shader
     * @param bufSize
     * @param length
     * @param source
     */
    @QtUninvokable
    public final void glGetShaderSource(int shader, int bufSize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable CharBuffer source){
        glGetShaderSource_native_GLuint_GLsizei_GLsizei_ptr_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), shader, bufSize, length, source);
    }
    
    @QtUninvokable
    private native void glGetShaderSource_native_GLuint_GLsizei_GLsizei_ptr_GLchar_ptr(long __this__nativeId, int shader, int bufSize, java.nio.IntBuffer length, java.nio.CharBuffer source);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetShaderiv(GLuint,GLenum,GLint*)
     * @param shader
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetShaderiv(int shader, int pname, java.nio.@Nullable IntBuffer params){
        glGetShaderiv_native_GLuint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), shader, pname, params);
    }
    
    @QtUninvokable
    private native void glGetShaderiv_native_GLuint_GLenum_GLint_ptr(long __this__nativeId, int shader, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetString(GLenum)
     * @param name
     * @return
     */
    @QtUninvokable
    public final java.lang.@NonNull String glGetString(int name){
        return glGetString_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), name);
    }
    
    @QtUninvokable
    private native java.lang.@NonNull String glGetString_native_GLenum(long __this__nativeId, int name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetStringi(GLenum,GLuint)
     * @param name
     * @param index
     * @return
     */
    @QtUninvokable
    public final java.lang.@NonNull String glGetStringi(int name, int index){
        return glGetStringi_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), name, index);
    }
    
    @QtUninvokable
    private native java.lang.@NonNull String glGetStringi_native_GLenum_GLuint(long __this__nativeId, int name, int index);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetSynciv(GLsync,GLenum,GLsizei,GLsizei*,GLint*)
     * @param sync
     * @param pname
     * @param length
     * @param values
     */
    @QtUninvokable
    public final void glGetSynciv(io.qt.gui.gl.@Nullable GLsync sync, int pname, int[] length, java.nio.@Nullable IntBuffer values){
        if(length!=null && length.length < 1)
            throw new IllegalArgumentException("Argument 'length': Wrong number of elements in array. Found: " + length.length + ", expected: 1");
        glGetSynciv_native___GLsync_ptr_GLenum_GLsizei_GLsizei_ptr_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(sync), pname, length, values);
    }
    
    @QtUninvokable
    private native void glGetSynciv_native___GLsync_ptr_GLenum_GLsizei_GLsizei_ptr_GLint_ptr(long __this__nativeId, long sync, int pname, int[] length, java.nio.IntBuffer values);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexEnvfv(GLenum,GLenum,GLfloat*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetTexEnvfv(int target, int pname, java.nio.@Nullable FloatBuffer params){
        glGetTexEnvfv_native_GLenum_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetTexEnvfv_native_GLenum_GLenum_GLfloat_ptr(long __this__nativeId, int target, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexEnviv(GLenum,GLenum,GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetTexEnviv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetTexEnviv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetTexEnviv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexGendv(GLenum,GLenum,GLdouble*)
     * @param coord
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetTexGendv(int coord, int pname, java.nio.@Nullable DoubleBuffer params){
        glGetTexGendv_native_GLenum_GLenum_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), coord, pname, params);
    }
    
    @QtUninvokable
    private native void glGetTexGendv_native_GLenum_GLenum_GLdouble_ptr(long __this__nativeId, int coord, int pname, java.nio.DoubleBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexGenfv(GLenum,GLenum,GLfloat*)
     * @param coord
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetTexGenfv(int coord, int pname, java.nio.@Nullable FloatBuffer params){
        glGetTexGenfv_native_GLenum_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), coord, pname, params);
    }
    
    @QtUninvokable
    private native void glGetTexGenfv_native_GLenum_GLenum_GLfloat_ptr(long __this__nativeId, int coord, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexGeniv(GLenum,GLenum,GLint*)
     * @param coord
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetTexGeniv(int coord, int pname, java.nio.@Nullable IntBuffer params){
        glGetTexGeniv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), coord, pname, params);
    }
    
    @QtUninvokable
    private native void glGetTexGeniv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int coord, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexImage(GLenum,GLint,GLenum,GLenum,GLvoid*)
     * @param target
     * @param level
     * @param format
     * @param type
     * @param pixels
     */
    @QtUninvokable
    public final void glGetTexImage(int target, int level, int format, int type, java.nio.@Nullable Buffer pixels){
        glGetTexImage_native_GLenum_GLint_GLenum_GLenum_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, format, type, pixels);
    }
    
    @QtUninvokable
    private native void glGetTexImage_native_GLenum_GLint_GLenum_GLenum_GLvoid_ptr(long __this__nativeId, int target, int level, int format, int type, java.nio.Buffer pixels);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexLevelParameterfv(GLenum,GLint,GLenum,GLfloat*)
     * @param target
     * @param level
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetTexLevelParameterfv(int target, int level, int pname, java.nio.@Nullable FloatBuffer params){
        glGetTexLevelParameterfv_native_GLenum_GLint_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, pname, params);
    }
    
    @QtUninvokable
    private native void glGetTexLevelParameterfv_native_GLenum_GLint_GLenum_GLfloat_ptr(long __this__nativeId, int target, int level, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexLevelParameteriv(GLenum,GLint,GLenum,GLint*)
     * @param target
     * @param level
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetTexLevelParameteriv(int target, int level, int pname, java.nio.@Nullable IntBuffer params){
        glGetTexLevelParameteriv_native_GLenum_GLint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, pname, params);
    }
    
    @QtUninvokable
    private native void glGetTexLevelParameteriv_native_GLenum_GLint_GLenum_GLint_ptr(long __this__nativeId, int target, int level, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexParameterIiv(GLenum,GLenum,GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetTexParameterIiv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetTexParameterIiv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetTexParameterIiv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexParameterIuiv(GLenum,GLenum,GLuint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetTexParameterIuiv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetTexParameterIuiv_native_GLenum_GLenum_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetTexParameterIuiv_native_GLenum_GLenum_GLuint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexParameterfv(GLenum,GLenum,GLfloat*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetTexParameterfv(int target, int pname, java.nio.@Nullable FloatBuffer params){
        glGetTexParameterfv_native_GLenum_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetTexParameterfv_native_GLenum_GLenum_GLfloat_ptr(long __this__nativeId, int target, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTexParameteriv(GLenum,GLenum,GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetTexParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetTexParameteriv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetTexParameteriv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetTransformFeedbackVarying(GLuint,GLuint,GLsizei,GLsizei*,GLsizei*,GLenum*,GLchar*)
     * @param program
     * @param index
     * @param size
     * @param type
     * @param name
     */
    @QtUninvokable
    public final void glGetTransformFeedbackVarying(int program, int index, int[] size, int[] type, java.lang.String[] name){
        if (name.length < 1)
            throw new IllegalArgumentException("Argument 'name': Wrong number of elements in array. Found: 0, expected: 1");
        if(size!=null && size.length < 1)
            throw new IllegalArgumentException("Argument 'size': Wrong number of elements in array. Found: " + size.length + ", expected: 1");
        if(type!=null && type.length < 1)
            throw new IllegalArgumentException("Argument 'type': Wrong number of elements in array. Found: " + type.length + ", expected: 1");
        glGetTransformFeedbackVarying_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLsizei_ptr_GLenum_ptr_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, index, size, type, name);
    }
    
    @QtUninvokable
    private native void glGetTransformFeedbackVarying_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLsizei_ptr_GLenum_ptr_GLchar_ptr(long __this__nativeId, int program, int index, int[] size, int[] type, java.lang.String[] name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetUniformBlockIndex(GLuint,const GLchar*)
     * @param program
     * @param uniformBlockName
     * @return
     */
    @QtUninvokable
    public final int glGetUniformBlockIndex(int program, java.nio.@Nullable CharBuffer uniformBlockName){
        return glGetUniformBlockIndex_native_GLuint_const_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, uniformBlockName);
    }
    
    @QtUninvokable
    private native int glGetUniformBlockIndex_native_GLuint_const_GLchar_ptr(long __this__nativeId, int program, java.nio.CharBuffer uniformBlockName);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetUniformIndices(GLuint,GLsizei,const GLchar*const*,GLuint*)
     * @param program
     * @param uniformNames
     * @param uniformIndices
     */
    @QtUninvokable
    public final void glGetUniformIndices(int program, java.lang.String[] uniformNames, int[] uniformIndices){
        glGetUniformIndices_native_GLuint_GLsizei_const_GLchar_cptr_ptr_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, uniformNames, uniformIndices);
    }
    
    @QtUninvokable
    private native void glGetUniformIndices_native_GLuint_GLsizei_const_GLchar_cptr_ptr_GLuint_ptr(long __this__nativeId, int program, java.lang.String[] uniformNames, int[] uniformIndices);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetUniformLocation(GLuint,const GLchar*)
     * @param program
     * @param name
     * @return
     */
    @QtUninvokable
    public final int glGetUniformLocation(int program, java.nio.@Nullable CharBuffer name){
        return glGetUniformLocation_native_GLuint_const_GLchar_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, name);
    }
    
    @QtUninvokable
    private native int glGetUniformLocation_native_GLuint_const_GLchar_ptr(long __this__nativeId, int program, java.nio.CharBuffer name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetUniformfv(GLuint,GLint,GLfloat*)
     * @param program
     * @param location
     * @param params
     */
    @QtUninvokable
    public final void glGetUniformfv(int program, int location, java.nio.@Nullable FloatBuffer params){
        glGetUniformfv_native_GLuint_GLint_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, location, params);
    }
    
    @QtUninvokable
    private native void glGetUniformfv_native_GLuint_GLint_GLfloat_ptr(long __this__nativeId, int program, int location, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetUniformiv(GLuint,GLint,GLint*)
     * @param program
     * @param location
     * @param params
     */
    @QtUninvokable
    public final void glGetUniformiv(int program, int location, java.nio.@Nullable IntBuffer params){
        glGetUniformiv_native_GLuint_GLint_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, location, params);
    }
    
    @QtUninvokable
    private native void glGetUniformiv_native_GLuint_GLint_GLint_ptr(long __this__nativeId, int program, int location, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetUniformuiv(GLuint,GLint,GLuint*)
     * @param program
     * @param location
     * @param params
     */
    @QtUninvokable
    public final void glGetUniformuiv(int program, int location, java.nio.@Nullable IntBuffer params){
        glGetUniformuiv_native_GLuint_GLint_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, location, params);
    }
    
    @QtUninvokable
    private native void glGetUniformuiv_native_GLuint_GLint_GLuint_ptr(long __this__nativeId, int program, int location, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribIiv(GLuint,GLenum,GLint*)
     * @param index
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetVertexAttribIiv(int index, int pname, java.nio.@Nullable IntBuffer params){
        glGetVertexAttribIiv_native_GLuint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, pname, params);
    }
    
    @QtUninvokable
    private native void glGetVertexAttribIiv_native_GLuint_GLenum_GLint_ptr(long __this__nativeId, int index, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribIuiv(GLuint,GLenum,GLuint*)
     * @param index
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetVertexAttribIuiv(int index, int pname, java.nio.@Nullable IntBuffer params){
        glGetVertexAttribIuiv_native_GLuint_GLenum_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, pname, params);
    }
    
    @QtUninvokable
    private native void glGetVertexAttribIuiv_native_GLuint_GLenum_GLuint_ptr(long __this__nativeId, int index, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribPointerv(GLuint,GLenum,GLvoid**)
     * @param index
     * @param pname
     * @param pointer
     */
    @QtUninvokable
    public final void glGetVertexAttribPointerv(int index, int pname, java.nio.@Nullable Buffer[] pointer){
        glGetVertexAttribPointerv_native_GLuint_GLenum_GLvoid_ptr_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, pname, pointer);
    }
    
    @QtUninvokable
    private native void glGetVertexAttribPointerv_native_GLuint_GLenum_GLvoid_ptr_ptr(long __this__nativeId, int index, int pname, java.nio.Buffer[] pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribdv(GLuint,GLenum,GLdouble*)
     * @param index
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetVertexAttribdv(int index, int pname, java.nio.@Nullable DoubleBuffer params){
        glGetVertexAttribdv_native_GLuint_GLenum_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, pname, params);
    }
    
    @QtUninvokable
    private native void glGetVertexAttribdv_native_GLuint_GLenum_GLdouble_ptr(long __this__nativeId, int index, int pname, java.nio.DoubleBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribfv(GLuint,GLenum,GLfloat*)
     * @param index
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetVertexAttribfv(int index, int pname, java.nio.@Nullable FloatBuffer params){
        glGetVertexAttribfv_native_GLuint_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, pname, params);
    }
    
    @QtUninvokable
    private native void glGetVertexAttribfv_native_GLuint_GLenum_GLfloat_ptr(long __this__nativeId, int index, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glGetVertexAttribiv(GLuint,GLenum,GLint*)
     * @param index
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glGetVertexAttribiv(int index, int pname, java.nio.@Nullable IntBuffer params){
        glGetVertexAttribiv_native_GLuint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, pname, params);
    }
    
    @QtUninvokable
    private native void glGetVertexAttribiv_native_GLuint_GLenum_GLint_ptr(long __this__nativeId, int index, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glHint(GLenum,GLenum)
     * @param target
     * @param mode
     */
    @QtUninvokable
    public final void glHint(int target, int mode){
        glHint_native_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target, mode);
    }
    
    @QtUninvokable
    private native void glHint_native_GLenum_GLenum(long __this__nativeId, int target, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glHistogram(GLenum,GLsizei,GLenum,GLboolean)
     * @param target
     * @param width
     * @param internalformat
     * @param sink
     */
    @QtUninvokable
    public final void glHistogram(int target, int width, int internalformat, boolean sink){
        glHistogram_native_GLenum_GLsizei_GLenum_GLboolean(QtJambi_LibraryUtilities.internal.nativeId(this), target, width, internalformat, sink);
    }
    
    @QtUninvokable
    private native void glHistogram_native_GLenum_GLsizei_GLenum_GLboolean(long __this__nativeId, int target, int width, int internalformat, boolean sink);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexMask(GLuint)
     * @param mask
     */
    @QtUninvokable
    public final void glIndexMask(int mask){
        glIndexMask_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), mask);
    }
    
    @QtUninvokable
    private native void glIndexMask_native_GLuint(long __this__nativeId, int mask);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexPointer(GLenum,GLsizei,const GLvoid*)
     * @param type
     * @param stride
     * @param pointer
     */
    @QtUninvokable
    public final void glIndexPointer(int type, int stride, java.nio.@Nullable Buffer pointer){
        glIndexPointer_native_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, stride, pointer);
    }
    
    @QtUninvokable
    private native void glIndexPointer_native_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int type, int stride, java.nio.Buffer pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexd(GLdouble)
     * @param c
     */
    @QtUninvokable
    public final void glIndexd(double c){
        glIndexd_native_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), c);
    }
    
    @QtUninvokable
    private native void glIndexd_native_GLdouble(long __this__nativeId, double c);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexdv(const GLdouble*)
     * @param c
     */
    @QtUninvokable
    public final void glIndexdv(double[] c){
        if(c!=null && c.length < 1)
            throw new IllegalArgumentException("Argument 'c': Wrong number of elements in array. Found: " + c.length + ", expected: 1");
        glIndexdv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), c);
    }
    
    @QtUninvokable
    private native void glIndexdv_native_const_GLdouble_ptr(long __this__nativeId, double[] c);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexf(GLfloat)
     * @param c
     */
    @QtUninvokable
    public final void glIndexf(float c){
        glIndexf_native_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), c);
    }
    
    @QtUninvokable
    private native void glIndexf_native_GLfloat(long __this__nativeId, float c);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexfv(const GLfloat*)
     * @param c
     */
    @QtUninvokable
    public final void glIndexfv(float[] c){
        if(c!=null && c.length < 1)
            throw new IllegalArgumentException("Argument 'c': Wrong number of elements in array. Found: " + c.length + ", expected: 1");
        glIndexfv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), c);
    }
    
    @QtUninvokable
    private native void glIndexfv_native_const_GLfloat_ptr(long __this__nativeId, float[] c);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexi(GLint)
     * @param c
     */
    @QtUninvokable
    public final void glIndexi(int c){
        glIndexi_native_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), c);
    }
    
    @QtUninvokable
    private native void glIndexi_native_GLint(long __this__nativeId, int c);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexiv(const GLint*)
     * @param c
     */
    @QtUninvokable
    public final void glIndexiv(int[] c){
        if(c!=null && c.length < 1)
            throw new IllegalArgumentException("Argument 'c': Wrong number of elements in array. Found: " + c.length + ", expected: 1");
        glIndexiv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), c);
    }
    
    @QtUninvokable
    private native void glIndexiv_native_const_GLint_ptr(long __this__nativeId, int[] c);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexs(GLshort)
     * @param c
     */
    @QtUninvokable
    public final void glIndexs(short c){
        glIndexs_native_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), c);
    }
    
    @QtUninvokable
    private native void glIndexs_native_GLshort(long __this__nativeId, short c);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexsv(const GLshort*)
     * @param c
     */
    @QtUninvokable
    public final void glIndexsv(short[] c){
        if(c!=null && c.length < 1)
            throw new IllegalArgumentException("Argument 'c': Wrong number of elements in array. Found: " + c.length + ", expected: 1");
        glIndexsv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), c);
    }
    
    @QtUninvokable
    private native void glIndexsv_native_const_GLshort_ptr(long __this__nativeId, short[] c);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexub(GLubyte)
     * @param c
     */
    @QtUninvokable
    public final void glIndexub(byte c){
        glIndexub_native_GLubyte(QtJambi_LibraryUtilities.internal.nativeId(this), c);
    }
    
    @QtUninvokable
    private native void glIndexub_native_GLubyte(long __this__nativeId, byte c);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIndexubv(const GLubyte*)
     * @param c
     */
    @QtUninvokable
    public final void glIndexubv(byte[] c){
        if(c!=null && c.length < 1)
            throw new IllegalArgumentException("Argument 'c': Wrong number of elements in array. Found: " + c.length + ", expected: 1");
        glIndexubv_native_const_GLubyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), c);
    }
    
    @QtUninvokable
    private native void glIndexubv_native_const_GLubyte_ptr(long __this__nativeId, byte[] c);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glInitNames()
     */
    @QtUninvokable
    public final void glInitNames(){
        glInitNames_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glInitNames_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glInterleavedArrays(GLenum,GLsizei,const GLvoid*)
     * @param format
     * @param stride
     * @param pointer
     */
    @QtUninvokable
    public final void glInterleavedArrays(int format, int stride, java.nio.@Nullable Buffer pointer){
        glInterleavedArrays_native_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), format, stride, pointer);
    }
    
    @QtUninvokable
    private native void glInterleavedArrays_native_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int format, int stride, java.nio.Buffer pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsBuffer(GLuint)
     * @param buffer
     * @return
     */
    @QtUninvokable
    public final boolean glIsBuffer(int buffer){
        return glIsBuffer_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), buffer);
    }
    
    @QtUninvokable
    private native boolean glIsBuffer_native_GLuint(long __this__nativeId, int buffer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsEnabled(GLenum)
     * @param cap
     * @return
     */
    @QtUninvokable
    public final boolean glIsEnabled(int cap){
        return glIsEnabled_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), cap);
    }
    
    @QtUninvokable
    private native boolean glIsEnabled_native_GLenum(long __this__nativeId, int cap);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsEnabledi(GLenum,GLuint)
     * @param target
     * @param index
     * @return
     */
    @QtUninvokable
    public final boolean glIsEnabledi(int target, int index){
        return glIsEnabledi_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, index);
    }
    
    @QtUninvokable
    private native boolean glIsEnabledi_native_GLenum_GLuint(long __this__nativeId, int target, int index);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsFramebuffer(GLuint)
     * @param framebuffer
     * @return
     */
    @QtUninvokable
    public final boolean glIsFramebuffer(int framebuffer){
        return glIsFramebuffer_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), framebuffer);
    }
    
    @QtUninvokable
    private native boolean glIsFramebuffer_native_GLuint(long __this__nativeId, int framebuffer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsList(GLuint)
     * @param list
     * @return
     */
    @QtUninvokable
    public final boolean glIsList(int list){
        return glIsList_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), list);
    }
    
    @QtUninvokable
    private native boolean glIsList_native_GLuint(long __this__nativeId, int list);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsProgram(GLuint)
     * @param program
     * @return
     */
    @QtUninvokable
    public final boolean glIsProgram(int program){
        return glIsProgram_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program);
    }
    
    @QtUninvokable
    private native boolean glIsProgram_native_GLuint(long __this__nativeId, int program);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsQuery(GLuint)
     * @param id
     * @return
     */
    @QtUninvokable
    public final boolean glIsQuery(int id){
        return glIsQuery_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), id);
    }
    
    @QtUninvokable
    private native boolean glIsQuery_native_GLuint(long __this__nativeId, int id);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsRenderbuffer(GLuint)
     * @param renderbuffer
     * @return
     */
    @QtUninvokable
    public final boolean glIsRenderbuffer(int renderbuffer){
        return glIsRenderbuffer_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), renderbuffer);
    }
    
    @QtUninvokable
    private native boolean glIsRenderbuffer_native_GLuint(long __this__nativeId, int renderbuffer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsSampler(GLuint)
     * @param sampler
     * @return
     */
    @QtUninvokable
    public final boolean glIsSampler(int sampler){
        return glIsSampler_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), sampler);
    }
    
    @QtUninvokable
    private native boolean glIsSampler_native_GLuint(long __this__nativeId, int sampler);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsShader(GLuint)
     * @param shader
     * @return
     */
    @QtUninvokable
    public final boolean glIsShader(int shader){
        return glIsShader_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), shader);
    }
    
    @QtUninvokable
    private native boolean glIsShader_native_GLuint(long __this__nativeId, int shader);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsSync(GLsync)
     * @param sync
     * @return
     */
    @QtUninvokable
    public final boolean glIsSync(io.qt.gui.gl.@Nullable GLsync sync){
        return glIsSync_native___GLsync_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(sync));
    }
    
    @QtUninvokable
    private native boolean glIsSync_native___GLsync_ptr(long __this__nativeId, long sync);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsTexture(GLuint)
     * @param texture
     * @return
     */
    @QtUninvokable
    public final boolean glIsTexture(int texture){
        return glIsTexture_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), texture);
    }
    
    @QtUninvokable
    private native boolean glIsTexture_native_GLuint(long __this__nativeId, int texture);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glIsVertexArray(GLuint)
     * @param array
     * @return
     */
    @QtUninvokable
    public final boolean glIsVertexArray(int array){
        return glIsVertexArray_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), array);
    }
    
    @QtUninvokable
    private native boolean glIsVertexArray_native_GLuint(long __this__nativeId, int array);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLightModelf(GLenum,GLfloat)
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glLightModelf(int pname, float param){
        glLightModelf_native_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), pname, param);
    }
    
    @QtUninvokable
    private native void glLightModelf_native_GLenum_GLfloat(long __this__nativeId, int pname, float param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLightModelfv(GLenum,const GLfloat*)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glLightModelfv(int pname, float[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glLightModelfv_native_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glLightModelfv_native_GLenum_const_GLfloat_ptr(long __this__nativeId, int pname, float[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLightModeli(GLenum,GLint)
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glLightModeli(int pname, int param){
        glLightModeli_native_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), pname, param);
    }
    
    @QtUninvokable
    private native void glLightModeli_native_GLenum_GLint(long __this__nativeId, int pname, int param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLightModeliv(GLenum,const GLint*)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glLightModeliv(int pname, int[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glLightModeliv_native_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glLightModeliv_native_GLenum_const_GLint_ptr(long __this__nativeId, int pname, int[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLightf(GLenum,GLenum,GLfloat)
     * @param light
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glLightf(int light, int pname, float param){
        glLightf_native_GLenum_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), light, pname, param);
    }
    
    @QtUninvokable
    private native void glLightf_native_GLenum_GLenum_GLfloat(long __this__nativeId, int light, int pname, float param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLightfv(GLenum,GLenum,const GLfloat*)
     * @param light
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glLightfv(int light, int pname, float[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glLightfv_native_GLenum_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), light, pname, params);
    }
    
    @QtUninvokable
    private native void glLightfv_native_GLenum_GLenum_const_GLfloat_ptr(long __this__nativeId, int light, int pname, float[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLighti(GLenum,GLenum,GLint)
     * @param light
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glLighti(int light, int pname, int param){
        glLighti_native_GLenum_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), light, pname, param);
    }
    
    @QtUninvokable
    private native void glLighti_native_GLenum_GLenum_GLint(long __this__nativeId, int light, int pname, int param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLightiv(GLenum,GLenum,const GLint*)
     * @param light
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glLightiv(int light, int pname, int[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glLightiv_native_GLenum_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), light, pname, params);
    }
    
    @QtUninvokable
    private native void glLightiv_native_GLenum_GLenum_const_GLint_ptr(long __this__nativeId, int light, int pname, int[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLineStipple(GLint,GLushort)
     * @param factor
     * @param pattern
     */
    @QtUninvokable
    public final void glLineStipple(int factor, short pattern){
        glLineStipple_native_GLint_GLushort(QtJambi_LibraryUtilities.internal.nativeId(this), factor, pattern);
    }
    
    @QtUninvokable
    private native void glLineStipple_native_GLint_GLushort(long __this__nativeId, int factor, short pattern);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLineWidth(GLfloat)
     * @param width
     */
    @QtUninvokable
    public final void glLineWidth(float width){
        glLineWidth_native_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), width);
    }
    
    @QtUninvokable
    private native void glLineWidth_native_GLfloat(long __this__nativeId, float width);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLinkProgram(GLuint)
     * @param program
     */
    @QtUninvokable
    public final void glLinkProgram(int program){
        glLinkProgram_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program);
    }
    
    @QtUninvokable
    private native void glLinkProgram_native_GLuint(long __this__nativeId, int program);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glListBase(GLuint)
     * @param base
     */
    @QtUninvokable
    public final void glListBase(int base){
        glListBase_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), base);
    }
    
    @QtUninvokable
    private native void glListBase_native_GLuint(long __this__nativeId, int base);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLoadIdentity()
     */
    @QtUninvokable
    public final void glLoadIdentity(){
        glLoadIdentity_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glLoadIdentity_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLoadMatrixd(const GLdouble*)
     * @param m
     */
    @QtUninvokable
    public final void glLoadMatrixd(double[] m){
        if(m!=null && m.length < 16)
            throw new IllegalArgumentException("Argument 'm': Wrong number of elements in array. Found: " + m.length + ", expected: 16");
        glLoadMatrixd_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), m);
    }
    
    @QtUninvokable
    private native void glLoadMatrixd_native_const_GLdouble_ptr(long __this__nativeId, double[] m);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLoadMatrixf(const GLfloat*)
     * @param m
     */
    @QtUninvokable
    public final void glLoadMatrixf(float[] m){
        if(m!=null && m.length < 16)
            throw new IllegalArgumentException("Argument 'm': Wrong number of elements in array. Found: " + m.length + ", expected: 16");
        glLoadMatrixf_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), m);
    }
    
    @QtUninvokable
    private native void glLoadMatrixf_native_const_GLfloat_ptr(long __this__nativeId, float[] m);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLoadName(GLuint)
     * @param name
     */
    @QtUninvokable
    public final void glLoadName(int name){
        glLoadName_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), name);
    }
    
    @QtUninvokable
    private native void glLoadName_native_GLuint(long __this__nativeId, int name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLoadTransposeMatrixd(const GLdouble*)
     * @param m
     */
    @QtUninvokable
    public final void glLoadTransposeMatrixd(java.nio.@Nullable DoubleBuffer m){
        glLoadTransposeMatrixd_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), m);
    }
    
    @QtUninvokable
    private native void glLoadTransposeMatrixd_native_const_GLdouble_ptr(long __this__nativeId, java.nio.DoubleBuffer m);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLoadTransposeMatrixf(const GLfloat*)
     * @param m
     */
    @QtUninvokable
    public final void glLoadTransposeMatrixf(java.nio.@Nullable FloatBuffer m){
        glLoadTransposeMatrixf_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), m);
    }
    
    @QtUninvokable
    private native void glLoadTransposeMatrixf_native_const_GLfloat_ptr(long __this__nativeId, java.nio.FloatBuffer m);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glLogicOp(GLenum)
     * @param opcode
     */
    @QtUninvokable
    public final void glLogicOp(int opcode){
        glLogicOp_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), opcode);
    }
    
    @QtUninvokable
    private native void glLogicOp_native_GLenum(long __this__nativeId, int opcode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMap1d(GLenum,GLdouble,GLdouble,GLint,GLint,const GLdouble*)
     * @param target
     * @param u1
     * @param u2
     * @param stride
     * @param order
     * @param points
     */
    @QtUninvokable
    public final void glMap1d(int target, double u1, double u2, int stride, int order, java.nio.@Nullable DoubleBuffer points){
        glMap1d_native_GLenum_GLdouble_GLdouble_GLint_GLint_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, u1, u2, stride, order, points);
    }
    
    @QtUninvokable
    private native void glMap1d_native_GLenum_GLdouble_GLdouble_GLint_GLint_const_GLdouble_ptr(long __this__nativeId, int target, double u1, double u2, int stride, int order, java.nio.DoubleBuffer points);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMap1f(GLenum,GLfloat,GLfloat,GLint,GLint,const GLfloat*)
     * @param target
     * @param u1
     * @param u2
     * @param stride
     * @param order
     * @param points
     */
    @QtUninvokable
    public final void glMap1f(int target, float u1, float u2, int stride, int order, java.nio.@Nullable FloatBuffer points){
        glMap1f_native_GLenum_GLfloat_GLfloat_GLint_GLint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, u1, u2, stride, order, points);
    }
    
    @QtUninvokable
    private native void glMap1f_native_GLenum_GLfloat_GLfloat_GLint_GLint_const_GLfloat_ptr(long __this__nativeId, int target, float u1, float u2, int stride, int order, java.nio.FloatBuffer points);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMap2d(GLenum,GLdouble,GLdouble,GLint,GLint,GLdouble,GLdouble,GLint,GLint,const GLdouble*)
     * @param target
     * @param u1
     * @param u2
     * @param ustride
     * @param uorder
     * @param v1
     * @param v2
     * @param vstride
     * @param vorder
     * @param points
     */
    @QtUninvokable
    public final void glMap2d(int target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, java.nio.@Nullable DoubleBuffer points){
        glMap2d_native_GLenum_GLdouble_GLdouble_GLint_GLint_GLdouble_GLdouble_GLint_GLint_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
    }
    
    @QtUninvokable
    private native void glMap2d_native_GLenum_GLdouble_GLdouble_GLint_GLint_GLdouble_GLdouble_GLint_GLint_const_GLdouble_ptr(long __this__nativeId, int target, double u1, double u2, int ustride, int uorder, double v1, double v2, int vstride, int vorder, java.nio.DoubleBuffer points);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMap2f(GLenum,GLfloat,GLfloat,GLint,GLint,GLfloat,GLfloat,GLint,GLint,const GLfloat*)
     * @param target
     * @param u1
     * @param u2
     * @param ustride
     * @param uorder
     * @param v1
     * @param v2
     * @param vstride
     * @param vorder
     * @param points
     */
    @QtUninvokable
    public final void glMap2f(int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, java.nio.@Nullable FloatBuffer points){
        glMap2f_native_GLenum_GLfloat_GLfloat_GLint_GLint_GLfloat_GLfloat_GLint_GLint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
    }
    
    @QtUninvokable
    private native void glMap2f_native_GLenum_GLfloat_GLfloat_GLint_GLint_GLfloat_GLfloat_GLint_GLint_const_GLfloat_ptr(long __this__nativeId, int target, float u1, float u2, int ustride, int uorder, float v1, float v2, int vstride, int vorder, java.nio.FloatBuffer points);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMapBuffer(GLenum,GLenum)
     * @param target
     * @param access
     * @return
     */
    @QtUninvokable
    public final java.nio.@Nullable Buffer glMapBuffer(int target, int access){
        return glMapBuffer_native_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target, access);
    }
    
    @QtUninvokable
    private native java.nio.Buffer glMapBuffer_native_GLenum_GLenum(long __this__nativeId, int target, int access);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMapBufferRange(GLenum,GLintptr,GLsizeiptr,GLbitfield)
     * @param target
     * @param offset
     * @param access
     * @return
     */
    @QtUninvokable
    public final java.nio.@Nullable Buffer glMapBufferRange(int target, long offset, int access){
        return glMapBufferRange_native_GLenum_GLintptr_GLsizeiptr_GLbitfield(QtJambi_LibraryUtilities.internal.nativeId(this), target, offset, access);
    }
    
    @QtUninvokable
    private native java.nio.Buffer glMapBufferRange_native_GLenum_GLintptr_GLsizeiptr_GLbitfield(long __this__nativeId, int target, long offset, int access);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMapGrid1d(GLint,GLdouble,GLdouble)
     * @param un
     * @param u1
     * @param u2
     */
    @QtUninvokable
    public final void glMapGrid1d(int un, double u1, double u2){
        glMapGrid1d_native_GLint_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), un, u1, u2);
    }
    
    @QtUninvokable
    private native void glMapGrid1d_native_GLint_GLdouble_GLdouble(long __this__nativeId, int un, double u1, double u2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMapGrid1f(GLint,GLfloat,GLfloat)
     * @param un
     * @param u1
     * @param u2
     */
    @QtUninvokable
    public final void glMapGrid1f(int un, float u1, float u2){
        glMapGrid1f_native_GLint_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), un, u1, u2);
    }
    
    @QtUninvokable
    private native void glMapGrid1f_native_GLint_GLfloat_GLfloat(long __this__nativeId, int un, float u1, float u2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMapGrid2d(GLint,GLdouble,GLdouble,GLint,GLdouble,GLdouble)
     * @param un
     * @param u1
     * @param u2
     * @param vn
     * @param v1
     * @param v2
     */
    @QtUninvokable
    public final void glMapGrid2d(int un, double u1, double u2, int vn, double v1, double v2){
        glMapGrid2d_native_GLint_GLdouble_GLdouble_GLint_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), un, u1, u2, vn, v1, v2);
    }
    
    @QtUninvokable
    private native void glMapGrid2d_native_GLint_GLdouble_GLdouble_GLint_GLdouble_GLdouble(long __this__nativeId, int un, double u1, double u2, int vn, double v1, double v2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMapGrid2f(GLint,GLfloat,GLfloat,GLint,GLfloat,GLfloat)
     * @param un
     * @param u1
     * @param u2
     * @param vn
     * @param v1
     * @param v2
     */
    @QtUninvokable
    public final void glMapGrid2f(int un, float u1, float u2, int vn, float v1, float v2){
        glMapGrid2f_native_GLint_GLfloat_GLfloat_GLint_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), un, u1, u2, vn, v1, v2);
    }
    
    @QtUninvokable
    private native void glMapGrid2f_native_GLint_GLfloat_GLfloat_GLint_GLfloat_GLfloat(long __this__nativeId, int un, float u1, float u2, int vn, float v1, float v2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMaterialf(GLenum,GLenum,GLfloat)
     * @param face
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glMaterialf(int face, int pname, float param){
        glMaterialf_native_GLenum_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), face, pname, param);
    }
    
    @QtUninvokable
    private native void glMaterialf_native_GLenum_GLenum_GLfloat(long __this__nativeId, int face, int pname, float param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMaterialfv(GLenum,GLenum,const GLfloat*)
     * @param face
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glMaterialfv(int face, int pname, float[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glMaterialfv_native_GLenum_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), face, pname, params);
    }
    
    @QtUninvokable
    private native void glMaterialfv_native_GLenum_GLenum_const_GLfloat_ptr(long __this__nativeId, int face, int pname, float[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMateriali(GLenum,GLenum,GLint)
     * @param face
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glMateriali(int face, int pname, int param){
        glMateriali_native_GLenum_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), face, pname, param);
    }
    
    @QtUninvokable
    private native void glMateriali_native_GLenum_GLenum_GLint(long __this__nativeId, int face, int pname, int param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMaterialiv(GLenum,GLenum,const GLint*)
     * @param face
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glMaterialiv(int face, int pname, int[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glMaterialiv_native_GLenum_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), face, pname, params);
    }
    
    @QtUninvokable
    private native void glMaterialiv_native_GLenum_GLenum_const_GLint_ptr(long __this__nativeId, int face, int pname, int[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMatrixMode(GLenum)
     * @param mode
     */
    @QtUninvokable
    public final void glMatrixMode(int mode){
        glMatrixMode_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), mode);
    }
    
    @QtUninvokable
    private native void glMatrixMode_native_GLenum(long __this__nativeId, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMinmax(GLenum,GLenum,GLboolean)
     * @param target
     * @param internalformat
     * @param sink
     */
    @QtUninvokable
    public final void glMinmax(int target, int internalformat, boolean sink){
        glMinmax_native_GLenum_GLenum_GLboolean(QtJambi_LibraryUtilities.internal.nativeId(this), target, internalformat, sink);
    }
    
    @QtUninvokable
    private native void glMinmax_native_GLenum_GLenum_GLboolean(long __this__nativeId, int target, int internalformat, boolean sink);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultMatrixd(const GLdouble*)
     * @param m
     */
    @QtUninvokable
    public final void glMultMatrixd(double[] m){
        if(m!=null && m.length < 16)
            throw new IllegalArgumentException("Argument 'm': Wrong number of elements in array. Found: " + m.length + ", expected: 16");
        glMultMatrixd_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), m);
    }
    
    @QtUninvokable
    private native void glMultMatrixd_native_const_GLdouble_ptr(long __this__nativeId, double[] m);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultMatrixf(const GLfloat*)
     * @param m
     */
    @QtUninvokable
    public final void glMultMatrixf(float[] m){
        if(m!=null && m.length < 16)
            throw new IllegalArgumentException("Argument 'm': Wrong number of elements in array. Found: " + m.length + ", expected: 16");
        glMultMatrixf_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), m);
    }
    
    @QtUninvokable
    private native void glMultMatrixf_native_const_GLfloat_ptr(long __this__nativeId, float[] m);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultTransposeMatrixd(const GLdouble*)
     * @param m
     */
    @QtUninvokable
    public final void glMultTransposeMatrixd(java.nio.@Nullable DoubleBuffer m){
        glMultTransposeMatrixd_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), m);
    }
    
    @QtUninvokable
    private native void glMultTransposeMatrixd_native_const_GLdouble_ptr(long __this__nativeId, java.nio.DoubleBuffer m);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultTransposeMatrixf(const GLfloat*)
     * @param m
     */
    @QtUninvokable
    public final void glMultTransposeMatrixf(java.nio.@Nullable FloatBuffer m){
        glMultTransposeMatrixf_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), m);
    }
    
    @QtUninvokable
    private native void glMultTransposeMatrixf_native_const_GLfloat_ptr(long __this__nativeId, java.nio.FloatBuffer m);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiDrawArrays(GLenum,const GLint*,const GLsizei*,GLsizei)
     * @param mode
     * @param first
     * @param count
     * @param drawcount
     */
    @QtUninvokable
    public final void glMultiDrawArrays(int mode, java.nio.@Nullable IntBuffer first, java.nio.@Nullable IntBuffer count, int drawcount){
        glMultiDrawArrays_native_GLenum_const_GLint_ptr_const_GLsizei_ptr_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), mode, first, count, drawcount);
    }
    
    @QtUninvokable
    private native void glMultiDrawArrays_native_GLenum_const_GLint_ptr_const_GLsizei_ptr_GLsizei(long __this__nativeId, int mode, java.nio.IntBuffer first, java.nio.IntBuffer count, int drawcount);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiDrawElements(GLenum,const GLsizei*,GLenum,const GLvoid*const*,GLsizei)
     * @param mode
     * @param count
     * @param type
     * @param indices
     * @param drawcount
     */
    @QtUninvokable
    public final void glMultiDrawElements(int mode, java.nio.@Nullable IntBuffer count, int type, java.nio.Buffer @StrictNonNull[] indices, int drawcount){
        java.util.Objects.requireNonNull(indices, "Argument 'indices': null not expected.");
        glMultiDrawElements_native_GLenum_const_GLsizei_ptr_GLenum_const_GLvoid_cptr_ptr_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), mode, count, type, indices, drawcount);
    }
    
    @QtUninvokable
    private native void glMultiDrawElements_native_GLenum_const_GLsizei_ptr_GLenum_const_GLvoid_cptr_ptr_GLsizei(long __this__nativeId, int mode, java.nio.IntBuffer count, int type, java.nio.Buffer[] indices, int drawcount);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiDrawElementsBaseVertex(GLenum,const GLsizei*,GLenum,const GLvoid*const*,GLsizei,const GLint*)
     * @param mode
     * @param count
     * @param type
     * @param indices
     * @param drawcount
     * @param basevertex
     */
    @QtUninvokable
    public final void glMultiDrawElementsBaseVertex(int mode, java.nio.@Nullable IntBuffer count, int type, java.nio.Buffer @StrictNonNull[] indices, int drawcount, java.nio.@Nullable IntBuffer basevertex){
        java.util.Objects.requireNonNull(indices, "Argument 'indices': null not expected.");
        glMultiDrawElementsBaseVertex_native_GLenum_const_GLsizei_ptr_GLenum_const_GLvoid_cptr_ptr_GLsizei_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), mode, count, type, indices, drawcount, basevertex);
    }
    
    @QtUninvokable
    private native void glMultiDrawElementsBaseVertex_native_GLenum_const_GLsizei_ptr_GLenum_const_GLvoid_cptr_ptr_GLsizei_const_GLint_ptr(long __this__nativeId, int mode, java.nio.IntBuffer count, int type, java.nio.Buffer[] indices, int drawcount, java.nio.IntBuffer basevertex);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1d(GLenum,GLdouble)
     * @param target
     * @param s
     */
    @QtUninvokable
    public final void glMultiTexCoord1d(int target, double s){
        glMultiTexCoord1d_native_GLenum_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), target, s);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord1d_native_GLenum_GLdouble(long __this__nativeId, int target, double s);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1dv(GLenum,const GLdouble*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord1dv(int target, java.nio.@Nullable DoubleBuffer v){
        glMultiTexCoord1dv_native_GLenum_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord1dv_native_GLenum_const_GLdouble_ptr(long __this__nativeId, int target, java.nio.DoubleBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1f(GLenum,GLfloat)
     * @param target
     * @param s
     */
    @QtUninvokable
    public final void glMultiTexCoord1f(int target, float s){
        glMultiTexCoord1f_native_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), target, s);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord1f_native_GLenum_GLfloat(long __this__nativeId, int target, float s);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1fv(GLenum,const GLfloat*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord1fv(int target, java.nio.@Nullable FloatBuffer v){
        glMultiTexCoord1fv_native_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord1fv_native_GLenum_const_GLfloat_ptr(long __this__nativeId, int target, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1i(GLenum,GLint)
     * @param target
     * @param s
     */
    @QtUninvokable
    public final void glMultiTexCoord1i(int target, int s){
        glMultiTexCoord1i_native_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, s);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord1i_native_GLenum_GLint(long __this__nativeId, int target, int s);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1iv(GLenum,const GLint*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord1iv(int target, java.nio.@Nullable IntBuffer v){
        glMultiTexCoord1iv_native_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord1iv_native_GLenum_const_GLint_ptr(long __this__nativeId, int target, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1s(GLenum,GLshort)
     * @param target
     * @param s
     */
    @QtUninvokable
    public final void glMultiTexCoord1s(int target, short s){
        glMultiTexCoord1s_native_GLenum_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), target, s);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord1s_native_GLenum_GLshort(long __this__nativeId, int target, short s);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord1sv(GLenum,const GLshort*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord1sv(int target, java.nio.@Nullable ShortBuffer v){
        glMultiTexCoord1sv_native_GLenum_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord1sv_native_GLenum_const_GLshort_ptr(long __this__nativeId, int target, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2d(GLenum,GLdouble,GLdouble)
     * @param target
     * @param s
     * @param t
     */
    @QtUninvokable
    public final void glMultiTexCoord2d(int target, double s, double t){
        glMultiTexCoord2d_native_GLenum_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord2d_native_GLenum_GLdouble_GLdouble(long __this__nativeId, int target, double s, double t);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2dv(GLenum,const GLdouble*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord2dv(int target, java.nio.@Nullable DoubleBuffer v){
        glMultiTexCoord2dv_native_GLenum_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord2dv_native_GLenum_const_GLdouble_ptr(long __this__nativeId, int target, java.nio.DoubleBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2f(GLenum,GLfloat,GLfloat)
     * @param target
     * @param s
     * @param t
     */
    @QtUninvokable
    public final void glMultiTexCoord2f(int target, float s, float t){
        glMultiTexCoord2f_native_GLenum_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord2f_native_GLenum_GLfloat_GLfloat(long __this__nativeId, int target, float s, float t);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2fv(GLenum,const GLfloat*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord2fv(int target, java.nio.@Nullable FloatBuffer v){
        glMultiTexCoord2fv_native_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord2fv_native_GLenum_const_GLfloat_ptr(long __this__nativeId, int target, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2i(GLenum,GLint,GLint)
     * @param target
     * @param s
     * @param t
     */
    @QtUninvokable
    public final void glMultiTexCoord2i(int target, int s, int t){
        glMultiTexCoord2i_native_GLenum_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord2i_native_GLenum_GLint_GLint(long __this__nativeId, int target, int s, int t);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2iv(GLenum,const GLint*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord2iv(int target, java.nio.@Nullable IntBuffer v){
        glMultiTexCoord2iv_native_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord2iv_native_GLenum_const_GLint_ptr(long __this__nativeId, int target, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2s(GLenum,GLshort,GLshort)
     * @param target
     * @param s
     * @param t
     */
    @QtUninvokable
    public final void glMultiTexCoord2s(int target, short s, short t){
        glMultiTexCoord2s_native_GLenum_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord2s_native_GLenum_GLshort_GLshort(long __this__nativeId, int target, short s, short t);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord2sv(GLenum,const GLshort*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord2sv(int target, java.nio.@Nullable ShortBuffer v){
        glMultiTexCoord2sv_native_GLenum_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord2sv_native_GLenum_const_GLshort_ptr(long __this__nativeId, int target, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3d(GLenum,GLdouble,GLdouble,GLdouble)
     * @param target
     * @param s
     * @param t
     * @param r
     */
    @QtUninvokable
    public final void glMultiTexCoord3d(int target, double s, double t, double r){
        glMultiTexCoord3d_native_GLenum_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t, r);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord3d_native_GLenum_GLdouble_GLdouble_GLdouble(long __this__nativeId, int target, double s, double t, double r);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3dv(GLenum,const GLdouble*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord3dv(int target, java.nio.@Nullable DoubleBuffer v){
        glMultiTexCoord3dv_native_GLenum_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord3dv_native_GLenum_const_GLdouble_ptr(long __this__nativeId, int target, java.nio.DoubleBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3f(GLenum,GLfloat,GLfloat,GLfloat)
     * @param target
     * @param s
     * @param t
     * @param r
     */
    @QtUninvokable
    public final void glMultiTexCoord3f(int target, float s, float t, float r){
        glMultiTexCoord3f_native_GLenum_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t, r);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord3f_native_GLenum_GLfloat_GLfloat_GLfloat(long __this__nativeId, int target, float s, float t, float r);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3fv(GLenum,const GLfloat*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord3fv(int target, java.nio.@Nullable FloatBuffer v){
        glMultiTexCoord3fv_native_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord3fv_native_GLenum_const_GLfloat_ptr(long __this__nativeId, int target, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3i(GLenum,GLint,GLint,GLint)
     * @param target
     * @param s
     * @param t
     * @param r
     */
    @QtUninvokable
    public final void glMultiTexCoord3i(int target, int s, int t, int r){
        glMultiTexCoord3i_native_GLenum_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t, r);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord3i_native_GLenum_GLint_GLint_GLint(long __this__nativeId, int target, int s, int t, int r);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3iv(GLenum,const GLint*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord3iv(int target, java.nio.@Nullable IntBuffer v){
        glMultiTexCoord3iv_native_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord3iv_native_GLenum_const_GLint_ptr(long __this__nativeId, int target, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3s(GLenum,GLshort,GLshort,GLshort)
     * @param target
     * @param s
     * @param t
     * @param r
     */
    @QtUninvokable
    public final void glMultiTexCoord3s(int target, short s, short t, short r){
        glMultiTexCoord3s_native_GLenum_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t, r);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord3s_native_GLenum_GLshort_GLshort_GLshort(long __this__nativeId, int target, short s, short t, short r);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord3sv(GLenum,const GLshort*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord3sv(int target, java.nio.@Nullable ShortBuffer v){
        glMultiTexCoord3sv_native_GLenum_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord3sv_native_GLenum_const_GLshort_ptr(long __this__nativeId, int target, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4d(GLenum,GLdouble,GLdouble,GLdouble,GLdouble)
     * @param target
     * @param s
     * @param t
     * @param r
     * @param q
     */
    @QtUninvokable
    public final void glMultiTexCoord4d(int target, double s, double t, double r, double q){
        glMultiTexCoord4d_native_GLenum_GLdouble_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t, r, q);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord4d_native_GLenum_GLdouble_GLdouble_GLdouble_GLdouble(long __this__nativeId, int target, double s, double t, double r, double q);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4dv(GLenum,const GLdouble*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord4dv(int target, java.nio.@Nullable DoubleBuffer v){
        glMultiTexCoord4dv_native_GLenum_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord4dv_native_GLenum_const_GLdouble_ptr(long __this__nativeId, int target, java.nio.DoubleBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4f(GLenum,GLfloat,GLfloat,GLfloat,GLfloat)
     * @param target
     * @param s
     * @param t
     * @param r
     * @param q
     */
    @QtUninvokable
    public final void glMultiTexCoord4f(int target, float s, float t, float r, float q){
        glMultiTexCoord4f_native_GLenum_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t, r, q);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord4f_native_GLenum_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, int target, float s, float t, float r, float q);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4fv(GLenum,const GLfloat*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord4fv(int target, java.nio.@Nullable FloatBuffer v){
        glMultiTexCoord4fv_native_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord4fv_native_GLenum_const_GLfloat_ptr(long __this__nativeId, int target, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4i(GLenum,GLint,GLint,GLint,GLint)
     * @param target
     * @param s
     * @param t
     * @param r
     * @param q
     */
    @QtUninvokable
    public final void glMultiTexCoord4i(int target, int s, int t, int r, int q){
        glMultiTexCoord4i_native_GLenum_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t, r, q);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord4i_native_GLenum_GLint_GLint_GLint_GLint(long __this__nativeId, int target, int s, int t, int r, int q);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4iv(GLenum,const GLint*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord4iv(int target, java.nio.@Nullable IntBuffer v){
        glMultiTexCoord4iv_native_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord4iv_native_GLenum_const_GLint_ptr(long __this__nativeId, int target, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4s(GLenum,GLshort,GLshort,GLshort,GLshort)
     * @param target
     * @param s
     * @param t
     * @param r
     * @param q
     */
    @QtUninvokable
    public final void glMultiTexCoord4s(int target, short s, short t, short r, short q){
        glMultiTexCoord4s_native_GLenum_GLshort_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), target, s, t, r, q);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord4s_native_GLenum_GLshort_GLshort_GLshort_GLshort(long __this__nativeId, int target, short s, short t, short r, short q);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoord4sv(GLenum,const GLshort*)
     * @param target
     * @param v
     */
    @QtUninvokable
    public final void glMultiTexCoord4sv(int target, java.nio.@Nullable ShortBuffer v){
        glMultiTexCoord4sv_native_GLenum_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, v);
    }
    
    @QtUninvokable
    private native void glMultiTexCoord4sv_native_GLenum_const_GLshort_ptr(long __this__nativeId, int target, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP1ui(GLenum,GLenum,GLuint)
     * @param texture
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glMultiTexCoordP1ui(int texture, int type, int coords){
        glMultiTexCoordP1ui_native_GLenum_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), texture, type, coords);
    }
    
    @QtUninvokable
    private native void glMultiTexCoordP1ui_native_GLenum_GLenum_GLuint(long __this__nativeId, int texture, int type, int coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP1uiv(GLenum,GLenum,const GLuint*)
     * @param texture
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glMultiTexCoordP1uiv(int texture, int type, java.nio.@Nullable IntBuffer coords){
        glMultiTexCoordP1uiv_native_GLenum_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), texture, type, coords);
    }
    
    @QtUninvokable
    private native void glMultiTexCoordP1uiv_native_GLenum_GLenum_const_GLuint_ptr(long __this__nativeId, int texture, int type, java.nio.IntBuffer coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP2ui(GLenum,GLenum,GLuint)
     * @param texture
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glMultiTexCoordP2ui(int texture, int type, int coords){
        glMultiTexCoordP2ui_native_GLenum_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), texture, type, coords);
    }
    
    @QtUninvokable
    private native void glMultiTexCoordP2ui_native_GLenum_GLenum_GLuint(long __this__nativeId, int texture, int type, int coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP2uiv(GLenum,GLenum,const GLuint*)
     * @param texture
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glMultiTexCoordP2uiv(int texture, int type, java.nio.@Nullable IntBuffer coords){
        glMultiTexCoordP2uiv_native_GLenum_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), texture, type, coords);
    }
    
    @QtUninvokable
    private native void glMultiTexCoordP2uiv_native_GLenum_GLenum_const_GLuint_ptr(long __this__nativeId, int texture, int type, java.nio.IntBuffer coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP3ui(GLenum,GLenum,GLuint)
     * @param texture
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glMultiTexCoordP3ui(int texture, int type, int coords){
        glMultiTexCoordP3ui_native_GLenum_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), texture, type, coords);
    }
    
    @QtUninvokable
    private native void glMultiTexCoordP3ui_native_GLenum_GLenum_GLuint(long __this__nativeId, int texture, int type, int coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP3uiv(GLenum,GLenum,const GLuint*)
     * @param texture
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glMultiTexCoordP3uiv(int texture, int type, java.nio.@Nullable IntBuffer coords){
        glMultiTexCoordP3uiv_native_GLenum_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), texture, type, coords);
    }
    
    @QtUninvokable
    private native void glMultiTexCoordP3uiv_native_GLenum_GLenum_const_GLuint_ptr(long __this__nativeId, int texture, int type, java.nio.IntBuffer coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP4ui(GLenum,GLenum,GLuint)
     * @param texture
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glMultiTexCoordP4ui(int texture, int type, int coords){
        glMultiTexCoordP4ui_native_GLenum_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), texture, type, coords);
    }
    
    @QtUninvokable
    private native void glMultiTexCoordP4ui_native_GLenum_GLenum_GLuint(long __this__nativeId, int texture, int type, int coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glMultiTexCoordP4uiv(GLenum,GLenum,const GLuint*)
     * @param texture
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glMultiTexCoordP4uiv(int texture, int type, java.nio.@Nullable IntBuffer coords){
        glMultiTexCoordP4uiv_native_GLenum_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), texture, type, coords);
    }
    
    @QtUninvokable
    private native void glMultiTexCoordP4uiv_native_GLenum_GLenum_const_GLuint_ptr(long __this__nativeId, int texture, int type, java.nio.IntBuffer coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNewList(GLuint,GLenum)
     * @param list
     * @param mode
     */
    @QtUninvokable
    public final void glNewList(int list, int mode){
        glNewList_native_GLuint_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), list, mode);
    }
    
    @QtUninvokable
    private native void glNewList_native_GLuint_GLenum(long __this__nativeId, int list, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormal3b(GLbyte,GLbyte,GLbyte)
     * @param nx
     * @param ny
     * @param nz
     */
    @QtUninvokable
    public final void glNormal3b(byte nx, byte ny, byte nz){
        glNormal3b_native_GLbyte_GLbyte_GLbyte(QtJambi_LibraryUtilities.internal.nativeId(this), nx, ny, nz);
    }
    
    @QtUninvokable
    private native void glNormal3b_native_GLbyte_GLbyte_GLbyte(long __this__nativeId, byte nx, byte ny, byte nz);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormal3bv(const GLbyte*)
     * @param v
     */
    @QtUninvokable
    public final void glNormal3bv(byte[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glNormal3bv_native_const_GLbyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glNormal3bv_native_const_GLbyte_ptr(long __this__nativeId, byte[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormal3d(GLdouble,GLdouble,GLdouble)
     * @param nx
     * @param ny
     * @param nz
     */
    @QtUninvokable
    public final void glNormal3d(double nx, double ny, double nz){
        glNormal3d_native_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), nx, ny, nz);
    }
    
    @QtUninvokable
    private native void glNormal3d_native_GLdouble_GLdouble_GLdouble(long __this__nativeId, double nx, double ny, double nz);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormal3dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glNormal3dv(double[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glNormal3dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glNormal3dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormal3f(GLfloat,GLfloat,GLfloat)
     * @param nx
     * @param ny
     * @param nz
     */
    @QtUninvokable
    public final void glNormal3f(float nx, float ny, float nz){
        glNormal3f_native_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), nx, ny, nz);
    }
    
    @QtUninvokable
    private native void glNormal3f_native_GLfloat_GLfloat_GLfloat(long __this__nativeId, float nx, float ny, float nz);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormal3fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glNormal3fv(float[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glNormal3fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glNormal3fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormal3i(GLint,GLint,GLint)
     * @param nx
     * @param ny
     * @param nz
     */
    @QtUninvokable
    public final void glNormal3i(int nx, int ny, int nz){
        glNormal3i_native_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), nx, ny, nz);
    }
    
    @QtUninvokable
    private native void glNormal3i_native_GLint_GLint_GLint(long __this__nativeId, int nx, int ny, int nz);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormal3iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glNormal3iv(int[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glNormal3iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glNormal3iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormal3s(GLshort,GLshort,GLshort)
     * @param nx
     * @param ny
     * @param nz
     */
    @QtUninvokable
    public final void glNormal3s(short nx, short ny, short nz){
        glNormal3s_native_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), nx, ny, nz);
    }
    
    @QtUninvokable
    private native void glNormal3s_native_GLshort_GLshort_GLshort(long __this__nativeId, short nx, short ny, short nz);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormal3sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glNormal3sv(short[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glNormal3sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glNormal3sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormalP3ui(GLenum,GLuint)
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glNormalP3ui(int type, int coords){
        glNormalP3ui_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), type, coords);
    }
    
    @QtUninvokable
    private native void glNormalP3ui_native_GLenum_GLuint(long __this__nativeId, int type, int coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormalP3uiv(GLenum,const GLuint*)
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glNormalP3uiv(int type, java.nio.@Nullable IntBuffer coords){
        glNormalP3uiv_native_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, coords);
    }
    
    @QtUninvokable
    private native void glNormalP3uiv_native_GLenum_const_GLuint_ptr(long __this__nativeId, int type, java.nio.IntBuffer coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glNormalPointer(GLenum,GLsizei,const GLvoid*)
     * @param type
     * @param stride
     * @param pointer
     */
    @QtUninvokable
    public final void glNormalPointer(int type, int stride, java.nio.@Nullable Buffer pointer){
        glNormalPointer_native_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, stride, pointer);
    }
    
    @QtUninvokable
    private native void glNormalPointer_native_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int type, int stride, java.nio.Buffer pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glOrtho(GLdouble,GLdouble,GLdouble,GLdouble,GLdouble,GLdouble)
     * @param left
     * @param right
     * @param bottom
     * @param top
     * @param zNear
     * @param zFar
     */
    @QtUninvokable
    public final void glOrtho(double left, double right, double bottom, double top, double zNear, double zFar){
        glOrtho_native_GLdouble_GLdouble_GLdouble_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), left, right, bottom, top, zNear, zFar);
    }
    
    @QtUninvokable
    private native void glOrtho_native_GLdouble_GLdouble_GLdouble_GLdouble_GLdouble_GLdouble(long __this__nativeId, double left, double right, double bottom, double top, double zNear, double zFar);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPassThrough(GLfloat)
     * @param token
     */
    @QtUninvokable
    public final void glPassThrough(float token){
        glPassThrough_native_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), token);
    }
    
    @QtUninvokable
    private native void glPassThrough_native_GLfloat(long __this__nativeId, float token);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPixelMapfv(GLenum,GLint,const GLfloat*)
     * @param map
     * @param mapsize
     * @param values
     */
    @QtUninvokable
    public final void glPixelMapfv(int map, int mapsize, java.nio.@Nullable FloatBuffer values){
        glPixelMapfv_native_GLenum_GLint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), map, mapsize, values);
    }
    
    @QtUninvokable
    private native void glPixelMapfv_native_GLenum_GLint_const_GLfloat_ptr(long __this__nativeId, int map, int mapsize, java.nio.FloatBuffer values);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPixelMapuiv(GLenum,GLint,const GLuint*)
     * @param map
     * @param mapsize
     * @param values
     */
    @QtUninvokable
    public final void glPixelMapuiv(int map, int mapsize, java.nio.@Nullable IntBuffer values){
        glPixelMapuiv_native_GLenum_GLint_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), map, mapsize, values);
    }
    
    @QtUninvokable
    private native void glPixelMapuiv_native_GLenum_GLint_const_GLuint_ptr(long __this__nativeId, int map, int mapsize, java.nio.IntBuffer values);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPixelMapusv(GLenum,GLint,const GLushort*)
     * @param map
     * @param mapsize
     * @param values
     */
    @QtUninvokable
    public final void glPixelMapusv(int map, int mapsize, java.nio.@Nullable ShortBuffer values){
        glPixelMapusv_native_GLenum_GLint_const_GLushort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), map, mapsize, values);
    }
    
    @QtUninvokable
    private native void glPixelMapusv_native_GLenum_GLint_const_GLushort_ptr(long __this__nativeId, int map, int mapsize, java.nio.ShortBuffer values);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPixelStoref(GLenum,GLfloat)
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glPixelStoref(int pname, float param){
        glPixelStoref_native_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), pname, param);
    }
    
    @QtUninvokable
    private native void glPixelStoref_native_GLenum_GLfloat(long __this__nativeId, int pname, float param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPixelStorei(GLenum,GLint)
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glPixelStorei(int pname, int param){
        glPixelStorei_native_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), pname, param);
    }
    
    @QtUninvokable
    private native void glPixelStorei_native_GLenum_GLint(long __this__nativeId, int pname, int param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPixelTransferf(GLenum,GLfloat)
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glPixelTransferf(int pname, float param){
        glPixelTransferf_native_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), pname, param);
    }
    
    @QtUninvokable
    private native void glPixelTransferf_native_GLenum_GLfloat(long __this__nativeId, int pname, float param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPixelTransferi(GLenum,GLint)
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glPixelTransferi(int pname, int param){
        glPixelTransferi_native_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), pname, param);
    }
    
    @QtUninvokable
    private native void glPixelTransferi_native_GLenum_GLint(long __this__nativeId, int pname, int param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPixelZoom(GLfloat,GLfloat)
     * @param xfactor
     * @param yfactor
     */
    @QtUninvokable
    public final void glPixelZoom(float xfactor, float yfactor){
        glPixelZoom_native_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), xfactor, yfactor);
    }
    
    @QtUninvokable
    private native void glPixelZoom_native_GLfloat_GLfloat(long __this__nativeId, float xfactor, float yfactor);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPointParameterf(GLenum,GLfloat)
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glPointParameterf(int pname, float param){
        glPointParameterf_native_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), pname, param);
    }
    
    @QtUninvokable
    private native void glPointParameterf_native_GLenum_GLfloat(long __this__nativeId, int pname, float param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPointParameterfv(GLenum,const GLfloat*)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glPointParameterfv(int pname, java.nio.@Nullable FloatBuffer params){
        glPointParameterfv_native_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glPointParameterfv_native_GLenum_const_GLfloat_ptr(long __this__nativeId, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPointParameteri(GLenum,GLint)
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glPointParameteri(int pname, int param){
        glPointParameteri_native_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), pname, param);
    }
    
    @QtUninvokable
    private native void glPointParameteri_native_GLenum_GLint(long __this__nativeId, int pname, int param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPointParameteriv(GLenum,const GLint*)
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glPointParameteriv(int pname, java.nio.@Nullable IntBuffer params){
        glPointParameteriv_native_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), pname, params);
    }
    
    @QtUninvokable
    private native void glPointParameteriv_native_GLenum_const_GLint_ptr(long __this__nativeId, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPointSize(GLfloat)
     * @param size
     */
    @QtUninvokable
    public final void glPointSize(float size){
        glPointSize_native_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), size);
    }
    
    @QtUninvokable
    private native void glPointSize_native_GLfloat(long __this__nativeId, float size);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPolygonMode(GLenum,GLenum)
     * @param face
     * @param mode
     */
    @QtUninvokable
    public final void glPolygonMode(int face, int mode){
        glPolygonMode_native_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), face, mode);
    }
    
    @QtUninvokable
    private native void glPolygonMode_native_GLenum_GLenum(long __this__nativeId, int face, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPolygonOffset(GLfloat,GLfloat)
     * @param factor
     * @param units
     */
    @QtUninvokable
    public final void glPolygonOffset(float factor, float units){
        glPolygonOffset_native_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), factor, units);
    }
    
    @QtUninvokable
    private native void glPolygonOffset_native_GLfloat_GLfloat(long __this__nativeId, float factor, float units);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPolygonStipple(const GLubyte*)
     * @param mask
     */
    @QtUninvokable
    public final void glPolygonStipple(java.nio.@Nullable ByteBuffer mask){
        glPolygonStipple_native_const_GLubyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), mask);
    }
    
    @QtUninvokable
    private native void glPolygonStipple_native_const_GLubyte_ptr(long __this__nativeId, java.nio.ByteBuffer mask);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPopAttrib()
     */
    @QtUninvokable
    public final void glPopAttrib(){
        glPopAttrib_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glPopAttrib_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPopClientAttrib()
     */
    @QtUninvokable
    public final void glPopClientAttrib(){
        glPopClientAttrib_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glPopClientAttrib_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPopMatrix()
     */
    @QtUninvokable
    public final void glPopMatrix(){
        glPopMatrix_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glPopMatrix_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPopName()
     */
    @QtUninvokable
    public final void glPopName(){
        glPopName_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glPopName_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPrimitiveRestartIndex(GLuint)
     * @param index
     */
    @QtUninvokable
    public final void glPrimitiveRestartIndex(int index){
        glPrimitiveRestartIndex_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index);
    }
    
    @QtUninvokable
    private native void glPrimitiveRestartIndex_native_GLuint(long __this__nativeId, int index);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPrioritizeTextures(GLsizei,const GLuint*,const GLfloat*)
     * @param n
     * @param textures
     * @param priorities
     */
    @QtUninvokable
    public final void glPrioritizeTextures(int n, java.nio.@Nullable IntBuffer textures, java.nio.@Nullable FloatBuffer priorities){
        glPrioritizeTextures_native_GLsizei_const_GLuint_ptr_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, textures, priorities);
    }
    
    @QtUninvokable
    private native void glPrioritizeTextures_native_GLsizei_const_GLuint_ptr_const_GLfloat_ptr(long __this__nativeId, int n, java.nio.IntBuffer textures, java.nio.FloatBuffer priorities);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glProvokingVertex(GLenum)
     * @param mode
     */
    @QtUninvokable
    public final void glProvokingVertex(int mode){
        glProvokingVertex_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), mode);
    }
    
    @QtUninvokable
    private native void glProvokingVertex_native_GLenum(long __this__nativeId, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPushAttrib(GLbitfield)
     * @param mask
     */
    @QtUninvokable
    public final void glPushAttrib(int mask){
        glPushAttrib_native_GLbitfield(QtJambi_LibraryUtilities.internal.nativeId(this), mask);
    }
    
    @QtUninvokable
    private native void glPushAttrib_native_GLbitfield(long __this__nativeId, int mask);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPushClientAttrib(GLbitfield)
     * @param mask
     */
    @QtUninvokable
    public final void glPushClientAttrib(int mask){
        glPushClientAttrib_native_GLbitfield(QtJambi_LibraryUtilities.internal.nativeId(this), mask);
    }
    
    @QtUninvokable
    private native void glPushClientAttrib_native_GLbitfield(long __this__nativeId, int mask);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPushMatrix()
     */
    @QtUninvokable
    public final void glPushMatrix(){
        glPushMatrix_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glPushMatrix_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glPushName(GLuint)
     * @param name
     */
    @QtUninvokable
    public final void glPushName(int name){
        glPushName_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), name);
    }
    
    @QtUninvokable
    private native void glPushName_native_GLuint(long __this__nativeId, int name);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glQueryCounter(GLuint,GLenum)
     * @param id
     * @param target
     */
    @QtUninvokable
    public final void glQueryCounter(int id, int target){
        glQueryCounter_native_GLuint_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), id, target);
    }
    
    @QtUninvokable
    private native void glQueryCounter_native_GLuint_GLenum(long __this__nativeId, int id, int target);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos2d(GLdouble,GLdouble)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glRasterPos2d(double x, double y){
        glRasterPos2d_native_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glRasterPos2d_native_GLdouble_GLdouble(long __this__nativeId, double x, double y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos2dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos2dv(double[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glRasterPos2dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos2dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos2f(GLfloat,GLfloat)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glRasterPos2f(float x, float y){
        glRasterPos2f_native_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glRasterPos2f_native_GLfloat_GLfloat(long __this__nativeId, float x, float y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos2fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos2fv(float[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glRasterPos2fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos2fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos2i(GLint,GLint)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glRasterPos2i(int x, int y){
        glRasterPos2i_native_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glRasterPos2i_native_GLint_GLint(long __this__nativeId, int x, int y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos2iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos2iv(int[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glRasterPos2iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos2iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos2s(GLshort,GLshort)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glRasterPos2s(short x, short y){
        glRasterPos2s_native_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glRasterPos2s_native_GLshort_GLshort(long __this__nativeId, short x, short y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos2sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos2sv(short[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glRasterPos2sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos2sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos3d(GLdouble,GLdouble,GLdouble)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glRasterPos3d(double x, double y, double z){
        glRasterPos3d_native_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glRasterPos3d_native_GLdouble_GLdouble_GLdouble(long __this__nativeId, double x, double y, double z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos3dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos3dv(double[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glRasterPos3dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos3dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos3f(GLfloat,GLfloat,GLfloat)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glRasterPos3f(float x, float y, float z){
        glRasterPos3f_native_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glRasterPos3f_native_GLfloat_GLfloat_GLfloat(long __this__nativeId, float x, float y, float z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos3fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos3fv(float[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glRasterPos3fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos3fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos3i(GLint,GLint,GLint)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glRasterPos3i(int x, int y, int z){
        glRasterPos3i_native_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glRasterPos3i_native_GLint_GLint_GLint(long __this__nativeId, int x, int y, int z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos3iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos3iv(int[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glRasterPos3iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos3iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos3s(GLshort,GLshort,GLshort)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glRasterPos3s(short x, short y, short z){
        glRasterPos3s_native_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glRasterPos3s_native_GLshort_GLshort_GLshort(long __this__nativeId, short x, short y, short z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos3sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos3sv(short[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glRasterPos3sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos3sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos4d(GLdouble,GLdouble,GLdouble,GLdouble)
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glRasterPos4d(double x, double y, double z, double w){
        glRasterPos4d_native_GLdouble_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z, w);
    }
    
    @QtUninvokable
    private native void glRasterPos4d_native_GLdouble_GLdouble_GLdouble_GLdouble(long __this__nativeId, double x, double y, double z, double w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos4dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos4dv(double[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glRasterPos4dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos4dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos4f(GLfloat,GLfloat,GLfloat,GLfloat)
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glRasterPos4f(float x, float y, float z, float w){
        glRasterPos4f_native_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z, w);
    }
    
    @QtUninvokable
    private native void glRasterPos4f_native_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, float x, float y, float z, float w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos4fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos4fv(float[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glRasterPos4fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos4fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos4i(GLint,GLint,GLint,GLint)
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glRasterPos4i(int x, int y, int z, int w){
        glRasterPos4i_native_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z, w);
    }
    
    @QtUninvokable
    private native void glRasterPos4i_native_GLint_GLint_GLint_GLint(long __this__nativeId, int x, int y, int z, int w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos4iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos4iv(int[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glRasterPos4iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos4iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos4s(GLshort,GLshort,GLshort,GLshort)
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glRasterPos4s(short x, short y, short z, short w){
        glRasterPos4s_native_GLshort_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z, w);
    }
    
    @QtUninvokable
    private native void glRasterPos4s_native_GLshort_GLshort_GLshort_GLshort(long __this__nativeId, short x, short y, short z, short w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRasterPos4sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glRasterPos4sv(short[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glRasterPos4sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glRasterPos4sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glReadBuffer(GLenum)
     * @param mode
     */
    @QtUninvokable
    public final void glReadBuffer(int mode){
        glReadBuffer_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), mode);
    }
    
    @QtUninvokable
    private native void glReadBuffer_native_GLenum(long __this__nativeId, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glReadPixels(GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,GLvoid*)
     * @param x
     * @param y
     * @param width
     * @param height
     * @param format
     * @param type
     * @param pixels
     */
    @QtUninvokable
    public final void glReadPixels(int x, int y, int width, int height, int format, int type, java.nio.@Nullable Buffer pixels){
        glReadPixels_native_GLint_GLint_GLsizei_GLsizei_GLenum_GLenum_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, width, height, format, type, pixels);
    }
    
    @QtUninvokable
    private native void glReadPixels_native_GLint_GLint_GLsizei_GLsizei_GLenum_GLenum_GLvoid_ptr(long __this__nativeId, int x, int y, int width, int height, int format, int type, java.nio.Buffer pixels);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRectd(GLdouble,GLdouble,GLdouble,GLdouble)
     * @param x1
     * @param y1
     * @param x2
     * @param y2
     */
    @QtUninvokable
    public final void glRectd(double x1, double y1, double x2, double y2){
        glRectd_native_GLdouble_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), x1, y1, x2, y2);
    }
    
    @QtUninvokable
    private native void glRectd_native_GLdouble_GLdouble_GLdouble_GLdouble(long __this__nativeId, double x1, double y1, double x2, double y2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRectdv(const GLdouble*,const GLdouble*)
     * @param v1
     * @param v2
     */
    @QtUninvokable
    public final void glRectdv(double[] v1, double[] v2){
        if(v1!=null && v1.length < 2)
            throw new IllegalArgumentException("Argument 'v1': Wrong number of elements in array. Found: " + v1.length + ", expected: 2");
        if(v2!=null && v2.length < 2)
            throw new IllegalArgumentException("Argument 'v2': Wrong number of elements in array. Found: " + v2.length + ", expected: 2");
        glRectdv_native_const_GLdouble_ptr_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v1, v2);
    }
    
    @QtUninvokable
    private native void glRectdv_native_const_GLdouble_ptr_const_GLdouble_ptr(long __this__nativeId, double[] v1, double[] v2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRectf(GLfloat,GLfloat,GLfloat,GLfloat)
     * @param x1
     * @param y1
     * @param x2
     * @param y2
     */
    @QtUninvokable
    public final void glRectf(float x1, float y1, float x2, float y2){
        glRectf_native_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), x1, y1, x2, y2);
    }
    
    @QtUninvokable
    private native void glRectf_native_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, float x1, float y1, float x2, float y2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRectfv(const GLfloat*,const GLfloat*)
     * @param v1
     * @param v2
     */
    @QtUninvokable
    public final void glRectfv(float[] v1, float[] v2){
        if(v1!=null && v1.length < 2)
            throw new IllegalArgumentException("Argument 'v1': Wrong number of elements in array. Found: " + v1.length + ", expected: 2");
        if(v2!=null && v2.length < 2)
            throw new IllegalArgumentException("Argument 'v2': Wrong number of elements in array. Found: " + v2.length + ", expected: 2");
        glRectfv_native_const_GLfloat_ptr_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v1, v2);
    }
    
    @QtUninvokable
    private native void glRectfv_native_const_GLfloat_ptr_const_GLfloat_ptr(long __this__nativeId, float[] v1, float[] v2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRecti(GLint,GLint,GLint,GLint)
     * @param x1
     * @param y1
     * @param x2
     * @param y2
     */
    @QtUninvokable
    public final void glRecti(int x1, int y1, int x2, int y2){
        glRecti_native_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), x1, y1, x2, y2);
    }
    
    @QtUninvokable
    private native void glRecti_native_GLint_GLint_GLint_GLint(long __this__nativeId, int x1, int y1, int x2, int y2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRectiv(const GLint*,const GLint*)
     * @param v1
     * @param v2
     */
    @QtUninvokable
    public final void glRectiv(int[] v1, int[] v2){
        if(v1!=null && v1.length < 2)
            throw new IllegalArgumentException("Argument 'v1': Wrong number of elements in array. Found: " + v1.length + ", expected: 2");
        if(v2!=null && v2.length < 2)
            throw new IllegalArgumentException("Argument 'v2': Wrong number of elements in array. Found: " + v2.length + ", expected: 2");
        glRectiv_native_const_GLint_ptr_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v1, v2);
    }
    
    @QtUninvokable
    private native void glRectiv_native_const_GLint_ptr_const_GLint_ptr(long __this__nativeId, int[] v1, int[] v2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRects(GLshort,GLshort,GLshort,GLshort)
     * @param x1
     * @param y1
     * @param x2
     * @param y2
     */
    @QtUninvokable
    public final void glRects(short x1, short y1, short x2, short y2){
        glRects_native_GLshort_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), x1, y1, x2, y2);
    }
    
    @QtUninvokable
    private native void glRects_native_GLshort_GLshort_GLshort_GLshort(long __this__nativeId, short x1, short y1, short x2, short y2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRectsv(const GLshort*,const GLshort*)
     * @param v1
     * @param v2
     */
    @QtUninvokable
    public final void glRectsv(short[] v1, short[] v2){
        if(v1!=null && v1.length < 2)
            throw new IllegalArgumentException("Argument 'v1': Wrong number of elements in array. Found: " + v1.length + ", expected: 2");
        if(v2!=null && v2.length < 2)
            throw new IllegalArgumentException("Argument 'v2': Wrong number of elements in array. Found: " + v2.length + ", expected: 2");
        glRectsv_native_const_GLshort_ptr_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v1, v2);
    }
    
    @QtUninvokable
    private native void glRectsv_native_const_GLshort_ptr_const_GLshort_ptr(long __this__nativeId, short[] v1, short[] v2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRenderMode(GLenum)
     * @param mode
     * @return
     */
    @QtUninvokable
    public final int glRenderMode(int mode){
        return glRenderMode_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), mode);
    }
    
    @QtUninvokable
    private native int glRenderMode_native_GLenum(long __this__nativeId, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRenderbufferStorage(GLenum,GLenum,GLsizei,GLsizei)
     * @param target
     * @param internalformat
     * @param width
     * @param height
     */
    @QtUninvokable
    public final void glRenderbufferStorage(int target, int internalformat, int width, int height){
        glRenderbufferStorage_native_GLenum_GLenum_GLsizei_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), target, internalformat, width, height);
    }
    
    @QtUninvokable
    private native void glRenderbufferStorage_native_GLenum_GLenum_GLsizei_GLsizei(long __this__nativeId, int target, int internalformat, int width, int height);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRenderbufferStorageMultisample(GLenum,GLsizei,GLenum,GLsizei,GLsizei)
     * @param target
     * @param samples
     * @param internalformat
     * @param width
     * @param height
     */
    @QtUninvokable
    public final void glRenderbufferStorageMultisample(int target, int samples, int internalformat, int width, int height){
        glRenderbufferStorageMultisample_native_GLenum_GLsizei_GLenum_GLsizei_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), target, samples, internalformat, width, height);
    }
    
    @QtUninvokable
    private native void glRenderbufferStorageMultisample_native_GLenum_GLsizei_GLenum_GLsizei_GLsizei(long __this__nativeId, int target, int samples, int internalformat, int width, int height);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glResetHistogram(GLenum)
     * @param target
     */
    @QtUninvokable
    public final void glResetHistogram(int target){
        glResetHistogram_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target);
    }
    
    @QtUninvokable
    private native void glResetHistogram_native_GLenum(long __this__nativeId, int target);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glResetMinmax(GLenum)
     * @param target
     */
    @QtUninvokable
    public final void glResetMinmax(int target){
        glResetMinmax_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target);
    }
    
    @QtUninvokable
    private native void glResetMinmax_native_GLenum(long __this__nativeId, int target);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRotated(GLdouble,GLdouble,GLdouble,GLdouble)
     * @param angle
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glRotated(double angle, double x, double y, double z){
        glRotated_native_GLdouble_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), angle, x, y, z);
    }
    
    @QtUninvokable
    private native void glRotated_native_GLdouble_GLdouble_GLdouble_GLdouble(long __this__nativeId, double angle, double x, double y, double z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glRotatef(GLfloat,GLfloat,GLfloat,GLfloat)
     * @param angle
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glRotatef(float angle, float x, float y, float z){
        glRotatef_native_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), angle, x, y, z);
    }
    
    @QtUninvokable
    private native void glRotatef_native_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, float angle, float x, float y, float z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSampleCoverage(GLfloat,GLboolean)
     * @param value
     * @param invert
     */
    @QtUninvokable
    public final void glSampleCoverage(float value, boolean invert){
        glSampleCoverage_native_GLfloat_GLboolean(QtJambi_LibraryUtilities.internal.nativeId(this), value, invert);
    }
    
    @QtUninvokable
    private native void glSampleCoverage_native_GLfloat_GLboolean(long __this__nativeId, float value, boolean invert);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSampleMaski(GLuint,GLbitfield)
     * @param index
     * @param mask
     */
    @QtUninvokable
    public final void glSampleMaski(int index, int mask){
        glSampleMaski_native_GLuint_GLbitfield(QtJambi_LibraryUtilities.internal.nativeId(this), index, mask);
    }
    
    @QtUninvokable
    private native void glSampleMaski_native_GLuint_GLbitfield(long __this__nativeId, int index, int mask);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSamplerParameterIiv(GLuint,GLenum,const GLint*)
     * @param sampler
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glSamplerParameterIiv(int sampler, int pname, java.nio.@Nullable IntBuffer param){
        glSamplerParameterIiv_native_GLuint_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), sampler, pname, param);
    }
    
    @QtUninvokable
    private native void glSamplerParameterIiv_native_GLuint_GLenum_const_GLint_ptr(long __this__nativeId, int sampler, int pname, java.nio.IntBuffer param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSamplerParameterIuiv(GLuint,GLenum,const GLuint*)
     * @param sampler
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glSamplerParameterIuiv(int sampler, int pname, java.nio.@Nullable IntBuffer param){
        glSamplerParameterIuiv_native_GLuint_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), sampler, pname, param);
    }
    
    @QtUninvokable
    private native void glSamplerParameterIuiv_native_GLuint_GLenum_const_GLuint_ptr(long __this__nativeId, int sampler, int pname, java.nio.IntBuffer param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSamplerParameterf(GLuint,GLenum,GLfloat)
     * @param sampler
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glSamplerParameterf(int sampler, int pname, float param){
        glSamplerParameterf_native_GLuint_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), sampler, pname, param);
    }
    
    @QtUninvokable
    private native void glSamplerParameterf_native_GLuint_GLenum_GLfloat(long __this__nativeId, int sampler, int pname, float param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSamplerParameterfv(GLuint,GLenum,const GLfloat*)
     * @param sampler
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glSamplerParameterfv(int sampler, int pname, java.nio.@Nullable FloatBuffer param){
        glSamplerParameterfv_native_GLuint_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), sampler, pname, param);
    }
    
    @QtUninvokable
    private native void glSamplerParameterfv_native_GLuint_GLenum_const_GLfloat_ptr(long __this__nativeId, int sampler, int pname, java.nio.FloatBuffer param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSamplerParameteri(GLuint,GLenum,GLint)
     * @param sampler
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glSamplerParameteri(int sampler, int pname, int param){
        glSamplerParameteri_native_GLuint_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), sampler, pname, param);
    }
    
    @QtUninvokable
    private native void glSamplerParameteri_native_GLuint_GLenum_GLint(long __this__nativeId, int sampler, int pname, int param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSamplerParameteriv(GLuint,GLenum,const GLint*)
     * @param sampler
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glSamplerParameteriv(int sampler, int pname, java.nio.@Nullable IntBuffer param){
        glSamplerParameteriv_native_GLuint_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), sampler, pname, param);
    }
    
    @QtUninvokable
    private native void glSamplerParameteriv_native_GLuint_GLenum_const_GLint_ptr(long __this__nativeId, int sampler, int pname, java.nio.IntBuffer param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glScaled(GLdouble,GLdouble,GLdouble)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glScaled(double x, double y, double z){
        glScaled_native_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glScaled_native_GLdouble_GLdouble_GLdouble(long __this__nativeId, double x, double y, double z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glScalef(GLfloat,GLfloat,GLfloat)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glScalef(float x, float y, float z){
        glScalef_native_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glScalef_native_GLfloat_GLfloat_GLfloat(long __this__nativeId, float x, float y, float z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glScissor(GLint,GLint,GLsizei,GLsizei)
     * @param x
     * @param y
     * @param width
     * @param height
     */
    @QtUninvokable
    public final void glScissor(int x, int y, int width, int height){
        glScissor_native_GLint_GLint_GLsizei_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, width, height);
    }
    
    @QtUninvokable
    private native void glScissor_native_GLint_GLint_GLsizei_GLsizei(long __this__nativeId, int x, int y, int width, int height);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3b(GLbyte,GLbyte,GLbyte)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glSecondaryColor3b(byte red, byte green, byte blue){
        glSecondaryColor3b_native_GLbyte_GLbyte_GLbyte(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3b_native_GLbyte_GLbyte_GLbyte(long __this__nativeId, byte red, byte green, byte blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3bv(const GLbyte*)
     * @param v
     */
    @QtUninvokable
    public final void glSecondaryColor3bv(java.nio.@Nullable ByteBuffer v){
        glSecondaryColor3bv_native_const_GLbyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3bv_native_const_GLbyte_ptr(long __this__nativeId, java.nio.ByteBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3d(GLdouble,GLdouble,GLdouble)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glSecondaryColor3d(double red, double green, double blue){
        glSecondaryColor3d_native_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3d_native_GLdouble_GLdouble_GLdouble(long __this__nativeId, double red, double green, double blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glSecondaryColor3dv(java.nio.@Nullable DoubleBuffer v){
        glSecondaryColor3dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3dv_native_const_GLdouble_ptr(long __this__nativeId, java.nio.DoubleBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3f(GLfloat,GLfloat,GLfloat)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glSecondaryColor3f(float red, float green, float blue){
        glSecondaryColor3f_native_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3f_native_GLfloat_GLfloat_GLfloat(long __this__nativeId, float red, float green, float blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glSecondaryColor3fv(java.nio.@Nullable FloatBuffer v){
        glSecondaryColor3fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3fv_native_const_GLfloat_ptr(long __this__nativeId, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3i(GLint,GLint,GLint)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glSecondaryColor3i(int red, int green, int blue){
        glSecondaryColor3i_native_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3i_native_GLint_GLint_GLint(long __this__nativeId, int red, int green, int blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glSecondaryColor3iv(java.nio.@Nullable IntBuffer v){
        glSecondaryColor3iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3iv_native_const_GLint_ptr(long __this__nativeId, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3s(GLshort,GLshort,GLshort)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glSecondaryColor3s(short red, short green, short blue){
        glSecondaryColor3s_native_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3s_native_GLshort_GLshort_GLshort(long __this__nativeId, short red, short green, short blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glSecondaryColor3sv(java.nio.@Nullable ShortBuffer v){
        glSecondaryColor3sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3sv_native_const_GLshort_ptr(long __this__nativeId, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3ub(GLubyte,GLubyte,GLubyte)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glSecondaryColor3ub(byte red, byte green, byte blue){
        glSecondaryColor3ub_native_GLubyte_GLubyte_GLubyte(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3ub_native_GLubyte_GLubyte_GLubyte(long __this__nativeId, byte red, byte green, byte blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3ubv(const GLubyte*)
     * @param v
     */
    @QtUninvokable
    public final void glSecondaryColor3ubv(java.nio.@Nullable ByteBuffer v){
        glSecondaryColor3ubv_native_const_GLubyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3ubv_native_const_GLubyte_ptr(long __this__nativeId, java.nio.ByteBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3ui(GLuint,GLuint,GLuint)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glSecondaryColor3ui(int red, int green, int blue){
        glSecondaryColor3ui_native_GLuint_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3ui_native_GLuint_GLuint_GLuint(long __this__nativeId, int red, int green, int blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3uiv(const GLuint*)
     * @param v
     */
    @QtUninvokable
    public final void glSecondaryColor3uiv(java.nio.@Nullable IntBuffer v){
        glSecondaryColor3uiv_native_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3uiv_native_const_GLuint_ptr(long __this__nativeId, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3us(GLushort,GLushort,GLushort)
     * @param red
     * @param green
     * @param blue
     */
    @QtUninvokable
    public final void glSecondaryColor3us(short red, short green, short blue){
        glSecondaryColor3us_native_GLushort_GLushort_GLushort(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3us_native_GLushort_GLushort_GLushort(long __this__nativeId, short red, short green, short blue);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColor3usv(const GLushort*)
     * @param v
     */
    @QtUninvokable
    public final void glSecondaryColor3usv(java.nio.@Nullable ShortBuffer v){
        glSecondaryColor3usv_native_const_GLushort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glSecondaryColor3usv_native_const_GLushort_ptr(long __this__nativeId, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColorP3ui(GLenum,GLuint)
     * @param type
     * @param color
     */
    @QtUninvokable
    public final void glSecondaryColorP3ui(int type, int color){
        glSecondaryColorP3ui_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), type, color);
    }
    
    @QtUninvokable
    private native void glSecondaryColorP3ui_native_GLenum_GLuint(long __this__nativeId, int type, int color);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColorP3uiv(GLenum,const GLuint*)
     * @param type
     * @param color
     */
    @QtUninvokable
    public final void glSecondaryColorP3uiv(int type, java.nio.@Nullable IntBuffer color){
        glSecondaryColorP3uiv_native_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, color);
    }
    
    @QtUninvokable
    private native void glSecondaryColorP3uiv_native_GLenum_const_GLuint_ptr(long __this__nativeId, int type, java.nio.IntBuffer color);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSecondaryColorPointer(GLint,GLenum,GLsizei,const GLvoid*)
     * @param size
     * @param type
     * @param stride
     * @param pointer
     */
    @QtUninvokable
    public final void glSecondaryColorPointer(int size, int type, int stride, java.nio.@Nullable Buffer pointer){
        glSecondaryColorPointer_native_GLint_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), size, type, stride, pointer);
    }
    
    @QtUninvokable
    private native void glSecondaryColorPointer_native_GLint_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int size, int type, int stride, java.nio.Buffer pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSelectBuffer(GLsizei,GLuint*)
     * @param buffer
     */
    @QtUninvokable
    public final void glSelectBuffer(java.nio.@Nullable IntBuffer buffer){
        glSelectBuffer_native_GLsizei_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), buffer);
    }
    
    @QtUninvokable
    private native void glSelectBuffer_native_GLsizei_GLuint_ptr(long __this__nativeId, java.nio.IntBuffer buffer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glSeparableFilter2D(GLenum,GLenum,GLsizei,GLsizei,GLenum,GLenum,const GLvoid*,const GLvoid*)
     * @param target
     * @param internalformat
     * @param width
     * @param height
     * @param format
     * @param type
     * @param row
     * @param column
     */
    @QtUninvokable
    public final void glSeparableFilter2D(int target, int internalformat, int width, int height, int format, int type, java.nio.@Nullable Buffer row, java.nio.@Nullable Buffer column){
        glSeparableFilter2D_native_GLenum_GLenum_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, internalformat, width, height, format, type, row, column);
    }
    
    @QtUninvokable
    private native void glSeparableFilter2D_native_GLenum_GLenum_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr_const_GLvoid_ptr(long __this__nativeId, int target, int internalformat, int width, int height, int format, int type, java.nio.Buffer row, java.nio.Buffer column);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glShadeModel(GLenum)
     * @param mode
     */
    @QtUninvokable
    public final void glShadeModel(int mode){
        glShadeModel_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), mode);
    }
    
    @QtUninvokable
    private native void glShadeModel_native_GLenum(long __this__nativeId, int mode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glShaderSource(GLuint,GLsizei,const GLchar*const*,const GLint*)
     * @param shader
     * @param string
     * @param length
     */
    @QtUninvokable
    public final void glShaderSource(int shader, java.lang.String[] string, java.nio.@Nullable IntBuffer length){
        glShaderSource_native_GLuint_GLsizei_const_GLchar_cptr_ptr_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), shader, string, length);
    }
    
    @QtUninvokable
    private native void glShaderSource_native_GLuint_GLsizei_const_GLchar_cptr_ptr_const_GLint_ptr(long __this__nativeId, int shader, java.lang.String[] string, java.nio.IntBuffer length);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glStencilFunc(GLenum,GLint,GLuint)
     * @param func
     * @param ref
     * @param mask
     */
    @QtUninvokable
    public final void glStencilFunc(int func, int ref, int mask){
        glStencilFunc_native_GLenum_GLint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), func, ref, mask);
    }
    
    @QtUninvokable
    private native void glStencilFunc_native_GLenum_GLint_GLuint(long __this__nativeId, int func, int ref, int mask);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glStencilFuncSeparate(GLenum,GLenum,GLint,GLuint)
     * @param face
     * @param func
     * @param ref
     * @param mask
     */
    @QtUninvokable
    public final void glStencilFuncSeparate(int face, int func, int ref, int mask){
        glStencilFuncSeparate_native_GLenum_GLenum_GLint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), face, func, ref, mask);
    }
    
    @QtUninvokable
    private native void glStencilFuncSeparate_native_GLenum_GLenum_GLint_GLuint(long __this__nativeId, int face, int func, int ref, int mask);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glStencilMask(GLuint)
     * @param mask
     */
    @QtUninvokable
    public final void glStencilMask(int mask){
        glStencilMask_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), mask);
    }
    
    @QtUninvokable
    private native void glStencilMask_native_GLuint(long __this__nativeId, int mask);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glStencilMaskSeparate(GLenum,GLuint)
     * @param face
     * @param mask
     */
    @QtUninvokable
    public final void glStencilMaskSeparate(int face, int mask){
        glStencilMaskSeparate_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), face, mask);
    }
    
    @QtUninvokable
    private native void glStencilMaskSeparate_native_GLenum_GLuint(long __this__nativeId, int face, int mask);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glStencilOp(GLenum,GLenum,GLenum)
     * @param fail
     * @param zfail
     * @param zpass
     */
    @QtUninvokable
    public final void glStencilOp(int fail, int zfail, int zpass){
        glStencilOp_native_GLenum_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), fail, zfail, zpass);
    }
    
    @QtUninvokable
    private native void glStencilOp_native_GLenum_GLenum_GLenum(long __this__nativeId, int fail, int zfail, int zpass);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glStencilOpSeparate(GLenum,GLenum,GLenum,GLenum)
     * @param face
     * @param sfail
     * @param dpfail
     * @param dppass
     */
    @QtUninvokable
    public final void glStencilOpSeparate(int face, int sfail, int dpfail, int dppass){
        glStencilOpSeparate_native_GLenum_GLenum_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), face, sfail, dpfail, dppass);
    }
    
    @QtUninvokable
    private native void glStencilOpSeparate_native_GLenum_GLenum_GLenum_GLenum(long __this__nativeId, int face, int sfail, int dpfail, int dppass);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexBuffer(GLenum,GLenum,GLuint)
     * @param target
     * @param internalformat
     * @param buffer
     */
    @QtUninvokable
    public final void glTexBuffer(int target, int internalformat, int buffer){
        glTexBuffer_native_GLenum_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, internalformat, buffer);
    }
    
    @QtUninvokable
    private native void glTexBuffer_native_GLenum_GLenum_GLuint(long __this__nativeId, int target, int internalformat, int buffer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord1d(GLdouble)
     * @param s
     */
    @QtUninvokable
    public final void glTexCoord1d(double s){
        glTexCoord1d_native_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), s);
    }
    
    @QtUninvokable
    private native void glTexCoord1d_native_GLdouble(long __this__nativeId, double s);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord1dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord1dv(double[] v){
        if(v!=null && v.length < 1)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 1");
        glTexCoord1dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord1dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord1f(GLfloat)
     * @param s
     */
    @QtUninvokable
    public final void glTexCoord1f(float s){
        glTexCoord1f_native_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), s);
    }
    
    @QtUninvokable
    private native void glTexCoord1f_native_GLfloat(long __this__nativeId, float s);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord1fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord1fv(float[] v){
        if(v!=null && v.length < 1)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 1");
        glTexCoord1fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord1fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord1i(GLint)
     * @param s
     */
    @QtUninvokable
    public final void glTexCoord1i(int s){
        glTexCoord1i_native_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), s);
    }
    
    @QtUninvokable
    private native void glTexCoord1i_native_GLint(long __this__nativeId, int s);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord1iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord1iv(int[] v){
        if(v!=null && v.length < 1)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 1");
        glTexCoord1iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord1iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord1s(GLshort)
     * @param s
     */
    @QtUninvokable
    public final void glTexCoord1s(short s){
        glTexCoord1s_native_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), s);
    }
    
    @QtUninvokable
    private native void glTexCoord1s_native_GLshort(long __this__nativeId, short s);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord1sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord1sv(short[] v){
        if(v!=null && v.length < 1)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 1");
        glTexCoord1sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord1sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord2d(GLdouble,GLdouble)
     * @param s
     * @param t
     */
    @QtUninvokable
    public final void glTexCoord2d(double s, double t){
        glTexCoord2d_native_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), s, t);
    }
    
    @QtUninvokable
    private native void glTexCoord2d_native_GLdouble_GLdouble(long __this__nativeId, double s, double t);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord2dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord2dv(double[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glTexCoord2dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord2dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord2f(GLfloat,GLfloat)
     * @param s
     * @param t
     */
    @QtUninvokable
    public final void glTexCoord2f(float s, float t){
        glTexCoord2f_native_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), s, t);
    }
    
    @QtUninvokable
    private native void glTexCoord2f_native_GLfloat_GLfloat(long __this__nativeId, float s, float t);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord2fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord2fv(float[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glTexCoord2fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord2fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord2i(GLint,GLint)
     * @param s
     * @param t
     */
    @QtUninvokable
    public final void glTexCoord2i(int s, int t){
        glTexCoord2i_native_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), s, t);
    }
    
    @QtUninvokable
    private native void glTexCoord2i_native_GLint_GLint(long __this__nativeId, int s, int t);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord2iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord2iv(int[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glTexCoord2iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord2iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord2s(GLshort,GLshort)
     * @param s
     * @param t
     */
    @QtUninvokable
    public final void glTexCoord2s(short s, short t){
        glTexCoord2s_native_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), s, t);
    }
    
    @QtUninvokable
    private native void glTexCoord2s_native_GLshort_GLshort(long __this__nativeId, short s, short t);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord2sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord2sv(short[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glTexCoord2sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord2sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord3d(GLdouble,GLdouble,GLdouble)
     * @param s
     * @param t
     * @param r
     */
    @QtUninvokable
    public final void glTexCoord3d(double s, double t, double r){
        glTexCoord3d_native_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), s, t, r);
    }
    
    @QtUninvokable
    private native void glTexCoord3d_native_GLdouble_GLdouble_GLdouble(long __this__nativeId, double s, double t, double r);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord3dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord3dv(double[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glTexCoord3dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord3dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord3f(GLfloat,GLfloat,GLfloat)
     * @param s
     * @param t
     * @param r
     */
    @QtUninvokable
    public final void glTexCoord3f(float s, float t, float r){
        glTexCoord3f_native_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), s, t, r);
    }
    
    @QtUninvokable
    private native void glTexCoord3f_native_GLfloat_GLfloat_GLfloat(long __this__nativeId, float s, float t, float r);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord3fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord3fv(float[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glTexCoord3fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord3fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord3i(GLint,GLint,GLint)
     * @param s
     * @param t
     * @param r
     */
    @QtUninvokable
    public final void glTexCoord3i(int s, int t, int r){
        glTexCoord3i_native_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), s, t, r);
    }
    
    @QtUninvokable
    private native void glTexCoord3i_native_GLint_GLint_GLint(long __this__nativeId, int s, int t, int r);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord3iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord3iv(int[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glTexCoord3iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord3iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord3s(GLshort,GLshort,GLshort)
     * @param s
     * @param t
     * @param r
     */
    @QtUninvokable
    public final void glTexCoord3s(short s, short t, short r){
        glTexCoord3s_native_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), s, t, r);
    }
    
    @QtUninvokable
    private native void glTexCoord3s_native_GLshort_GLshort_GLshort(long __this__nativeId, short s, short t, short r);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord3sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord3sv(short[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glTexCoord3sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord3sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord4d(GLdouble,GLdouble,GLdouble,GLdouble)
     * @param s
     * @param t
     * @param r
     * @param q
     */
    @QtUninvokable
    public final void glTexCoord4d(double s, double t, double r, double q){
        glTexCoord4d_native_GLdouble_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), s, t, r, q);
    }
    
    @QtUninvokable
    private native void glTexCoord4d_native_GLdouble_GLdouble_GLdouble_GLdouble(long __this__nativeId, double s, double t, double r, double q);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord4dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord4dv(double[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glTexCoord4dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord4dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord4f(GLfloat,GLfloat,GLfloat,GLfloat)
     * @param s
     * @param t
     * @param r
     * @param q
     */
    @QtUninvokable
    public final void glTexCoord4f(float s, float t, float r, float q){
        glTexCoord4f_native_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), s, t, r, q);
    }
    
    @QtUninvokable
    private native void glTexCoord4f_native_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, float s, float t, float r, float q);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord4fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord4fv(float[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glTexCoord4fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord4fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord4i(GLint,GLint,GLint,GLint)
     * @param s
     * @param t
     * @param r
     * @param q
     */
    @QtUninvokable
    public final void glTexCoord4i(int s, int t, int r, int q){
        glTexCoord4i_native_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), s, t, r, q);
    }
    
    @QtUninvokable
    private native void glTexCoord4i_native_GLint_GLint_GLint_GLint(long __this__nativeId, int s, int t, int r, int q);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord4iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord4iv(int[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glTexCoord4iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord4iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord4s(GLshort,GLshort,GLshort,GLshort)
     * @param s
     * @param t
     * @param r
     * @param q
     */
    @QtUninvokable
    public final void glTexCoord4s(short s, short t, short r, short q){
        glTexCoord4s_native_GLshort_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), s, t, r, q);
    }
    
    @QtUninvokable
    private native void glTexCoord4s_native_GLshort_GLshort_GLshort_GLshort(long __this__nativeId, short s, short t, short r, short q);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoord4sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glTexCoord4sv(short[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glTexCoord4sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glTexCoord4sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoordP1ui(GLenum,GLuint)
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glTexCoordP1ui(int type, int coords){
        glTexCoordP1ui_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), type, coords);
    }
    
    @QtUninvokable
    private native void glTexCoordP1ui_native_GLenum_GLuint(long __this__nativeId, int type, int coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoordP1uiv(GLenum,const GLuint*)
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glTexCoordP1uiv(int type, java.nio.@Nullable IntBuffer coords){
        glTexCoordP1uiv_native_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, coords);
    }
    
    @QtUninvokable
    private native void glTexCoordP1uiv_native_GLenum_const_GLuint_ptr(long __this__nativeId, int type, java.nio.IntBuffer coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoordP2ui(GLenum,GLuint)
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glTexCoordP2ui(int type, int coords){
        glTexCoordP2ui_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), type, coords);
    }
    
    @QtUninvokable
    private native void glTexCoordP2ui_native_GLenum_GLuint(long __this__nativeId, int type, int coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoordP2uiv(GLenum,const GLuint*)
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glTexCoordP2uiv(int type, java.nio.@Nullable IntBuffer coords){
        glTexCoordP2uiv_native_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, coords);
    }
    
    @QtUninvokable
    private native void glTexCoordP2uiv_native_GLenum_const_GLuint_ptr(long __this__nativeId, int type, java.nio.IntBuffer coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoordP3ui(GLenum,GLuint)
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glTexCoordP3ui(int type, int coords){
        glTexCoordP3ui_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), type, coords);
    }
    
    @QtUninvokable
    private native void glTexCoordP3ui_native_GLenum_GLuint(long __this__nativeId, int type, int coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoordP3uiv(GLenum,const GLuint*)
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glTexCoordP3uiv(int type, java.nio.@Nullable IntBuffer coords){
        glTexCoordP3uiv_native_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, coords);
    }
    
    @QtUninvokable
    private native void glTexCoordP3uiv_native_GLenum_const_GLuint_ptr(long __this__nativeId, int type, java.nio.IntBuffer coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoordP4ui(GLenum,GLuint)
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glTexCoordP4ui(int type, int coords){
        glTexCoordP4ui_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), type, coords);
    }
    
    @QtUninvokable
    private native void glTexCoordP4ui_native_GLenum_GLuint(long __this__nativeId, int type, int coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoordP4uiv(GLenum,const GLuint*)
     * @param type
     * @param coords
     */
    @QtUninvokable
    public final void glTexCoordP4uiv(int type, java.nio.@Nullable IntBuffer coords){
        glTexCoordP4uiv_native_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, coords);
    }
    
    @QtUninvokable
    private native void glTexCoordP4uiv_native_GLenum_const_GLuint_ptr(long __this__nativeId, int type, java.nio.IntBuffer coords);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexCoordPointer(GLint,GLenum,GLsizei,const GLvoid*)
     * @param size
     * @param type
     * @param stride
     * @param pointer
     */
    @QtUninvokable
    public final void glTexCoordPointer(int size, int type, int stride, java.nio.@Nullable Buffer pointer){
        glTexCoordPointer_native_GLint_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), size, type, stride, pointer);
    }
    
    @QtUninvokable
    private native void glTexCoordPointer_native_GLint_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int size, int type, int stride, java.nio.Buffer pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexEnvf(GLenum,GLenum,GLfloat)
     * @param target
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glTexEnvf(int target, int pname, float param){
        glTexEnvf_native_GLenum_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, param);
    }
    
    @QtUninvokable
    private native void glTexEnvf_native_GLenum_GLenum_GLfloat(long __this__nativeId, int target, int pname, float param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexEnvfv(GLenum,GLenum,const GLfloat*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glTexEnvfv(int target, int pname, float[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glTexEnvfv_native_GLenum_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glTexEnvfv_native_GLenum_GLenum_const_GLfloat_ptr(long __this__nativeId, int target, int pname, float[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexEnvi(GLenum,GLenum,GLint)
     * @param target
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glTexEnvi(int target, int pname, int param){
        glTexEnvi_native_GLenum_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, param);
    }
    
    @QtUninvokable
    private native void glTexEnvi_native_GLenum_GLenum_GLint(long __this__nativeId, int target, int pname, int param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexEnviv(GLenum,GLenum,const GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glTexEnviv(int target, int pname, int[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glTexEnviv_native_GLenum_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glTexEnviv_native_GLenum_GLenum_const_GLint_ptr(long __this__nativeId, int target, int pname, int[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexGend(GLenum,GLenum,GLdouble)
     * @param coord
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glTexGend(int coord, int pname, double param){
        glTexGend_native_GLenum_GLenum_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), coord, pname, param);
    }
    
    @QtUninvokable
    private native void glTexGend_native_GLenum_GLenum_GLdouble(long __this__nativeId, int coord, int pname, double param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexGendv(GLenum,GLenum,const GLdouble*)
     * @param coord
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glTexGendv(int coord, int pname, double[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glTexGendv_native_GLenum_GLenum_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), coord, pname, params);
    }
    
    @QtUninvokable
    private native void glTexGendv_native_GLenum_GLenum_const_GLdouble_ptr(long __this__nativeId, int coord, int pname, double[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexGenf(GLenum,GLenum,GLfloat)
     * @param coord
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glTexGenf(int coord, int pname, float param){
        glTexGenf_native_GLenum_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), coord, pname, param);
    }
    
    @QtUninvokable
    private native void glTexGenf_native_GLenum_GLenum_GLfloat(long __this__nativeId, int coord, int pname, float param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexGenfv(GLenum,GLenum,const GLfloat*)
     * @param coord
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glTexGenfv(int coord, int pname, float[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glTexGenfv_native_GLenum_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), coord, pname, params);
    }
    
    @QtUninvokable
    private native void glTexGenfv_native_GLenum_GLenum_const_GLfloat_ptr(long __this__nativeId, int coord, int pname, float[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexGeni(GLenum,GLenum,GLint)
     * @param coord
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glTexGeni(int coord, int pname, int param){
        glTexGeni_native_GLenum_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), coord, pname, param);
    }
    
    @QtUninvokable
    private native void glTexGeni_native_GLenum_GLenum_GLint(long __this__nativeId, int coord, int pname, int param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexGeniv(GLenum,GLenum,const GLint*)
     * @param coord
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glTexGeniv(int coord, int pname, int[] params){
        if(params!=null && params.length < 1)
            throw new IllegalArgumentException("Argument 'params': Wrong number of elements in array. Found: " + params.length + ", expected: 1");
        glTexGeniv_native_GLenum_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), coord, pname, params);
    }
    
    @QtUninvokable
    private native void glTexGeniv_native_GLenum_GLenum_const_GLint_ptr(long __this__nativeId, int coord, int pname, int[] params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexImage1D(GLenum,GLint,GLint,GLsizei,GLint,GLenum,GLenum,const GLvoid*)
     * @param target
     * @param level
     * @param internalformat
     * @param width
     * @param border
     * @param format
     * @param type
     * @param pixels
     */
    @QtUninvokable
    public final void glTexImage1D(int target, int level, int internalformat, int width, int border, int format, int type, java.nio.@Nullable Buffer pixels){
        glTexImage1D_native_GLenum_GLint_GLint_GLsizei_GLint_GLenum_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, internalformat, width, border, format, type, pixels);
    }
    
    @QtUninvokable
    private native void glTexImage1D_native_GLenum_GLint_GLint_GLsizei_GLint_GLenum_GLenum_const_GLvoid_ptr(long __this__nativeId, int target, int level, int internalformat, int width, int border, int format, int type, java.nio.Buffer pixels);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexImage2D(GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLenum,GLenum,const GLvoid*)
     * @param target
     * @param level
     * @param internalformat
     * @param width
     * @param height
     * @param border
     * @param format
     * @param type
     * @param pixels
     */
    @QtUninvokable
    public final void glTexImage2D(int target, int level, int internalformat, int width, int height, int border, int format, int type, java.nio.@Nullable Buffer pixels){
        glTexImage2D_native_GLenum_GLint_GLint_GLsizei_GLsizei_GLint_GLenum_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, internalformat, width, height, border, format, type, pixels);
    }
    
    @QtUninvokable
    private native void glTexImage2D_native_GLenum_GLint_GLint_GLsizei_GLsizei_GLint_GLenum_GLenum_const_GLvoid_ptr(long __this__nativeId, int target, int level, int internalformat, int width, int height, int border, int format, int type, java.nio.Buffer pixels);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexImage2DMultisample(GLenum,GLsizei,GLint,GLsizei,GLsizei,GLboolean)
     * @param target
     * @param samples
     * @param internalformat
     * @param width
     * @param height
     * @param fixedsamplelocations
     */
    @QtUninvokable
    public final void glTexImage2DMultisample(int target, int samples, int internalformat, int width, int height, boolean fixedsamplelocations){
        glTexImage2DMultisample_native_GLenum_GLsizei_GLint_GLsizei_GLsizei_GLboolean(QtJambi_LibraryUtilities.internal.nativeId(this), target, samples, internalformat, width, height, fixedsamplelocations);
    }
    
    @QtUninvokable
    private native void glTexImage2DMultisample_native_GLenum_GLsizei_GLint_GLsizei_GLsizei_GLboolean(long __this__nativeId, int target, int samples, int internalformat, int width, int height, boolean fixedsamplelocations);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexImage3D(GLenum,GLint,GLint,GLsizei,GLsizei,GLsizei,GLint,GLenum,GLenum,const GLvoid*)
     * @param target
     * @param level
     * @param internalformat
     * @param width
     * @param height
     * @param depth
     * @param border
     * @param format
     * @param type
     * @param pixels
     */
    @QtUninvokable
    public final void glTexImage3D(int target, int level, int internalformat, int width, int height, int depth, int border, int format, int type, java.nio.@Nullable Buffer pixels){
        glTexImage3D_native_GLenum_GLint_GLint_GLsizei_GLsizei_GLsizei_GLint_GLenum_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, internalformat, width, height, depth, border, format, type, pixels);
    }
    
    @QtUninvokable
    private native void glTexImage3D_native_GLenum_GLint_GLint_GLsizei_GLsizei_GLsizei_GLint_GLenum_GLenum_const_GLvoid_ptr(long __this__nativeId, int target, int level, int internalformat, int width, int height, int depth, int border, int format, int type, java.nio.Buffer pixels);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexImage3DMultisample(GLenum,GLsizei,GLint,GLsizei,GLsizei,GLsizei,GLboolean)
     * @param target
     * @param samples
     * @param internalformat
     * @param width
     * @param height
     * @param depth
     * @param fixedsamplelocations
     */
    @QtUninvokable
    public final void glTexImage3DMultisample(int target, int samples, int internalformat, int width, int height, int depth, boolean fixedsamplelocations){
        glTexImage3DMultisample_native_GLenum_GLsizei_GLint_GLsizei_GLsizei_GLsizei_GLboolean(QtJambi_LibraryUtilities.internal.nativeId(this), target, samples, internalformat, width, height, depth, fixedsamplelocations);
    }
    
    @QtUninvokable
    private native void glTexImage3DMultisample_native_GLenum_GLsizei_GLint_GLsizei_GLsizei_GLsizei_GLboolean(long __this__nativeId, int target, int samples, int internalformat, int width, int height, int depth, boolean fixedsamplelocations);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexParameterIiv(GLenum,GLenum,const GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glTexParameterIiv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glTexParameterIiv_native_GLenum_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glTexParameterIiv_native_GLenum_GLenum_const_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexParameterIuiv(GLenum,GLenum,const GLuint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glTexParameterIuiv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glTexParameterIuiv_native_GLenum_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glTexParameterIuiv_native_GLenum_GLenum_const_GLuint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexParameterf(GLenum,GLenum,GLfloat)
     * @param target
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glTexParameterf(int target, int pname, float param){
        glTexParameterf_native_GLenum_GLenum_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, param);
    }
    
    @QtUninvokable
    private native void glTexParameterf_native_GLenum_GLenum_GLfloat(long __this__nativeId, int target, int pname, float param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexParameterfv(GLenum,GLenum,const GLfloat*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glTexParameterfv(int target, int pname, java.nio.@Nullable FloatBuffer params){
        glTexParameterfv_native_GLenum_GLenum_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glTexParameterfv_native_GLenum_GLenum_const_GLfloat_ptr(long __this__nativeId, int target, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexParameteri(GLenum,GLenum,GLint)
     * @param target
     * @param pname
     * @param param
     */
    @QtUninvokable
    public final void glTexParameteri(int target, int pname, int param){
        glTexParameteri_native_GLenum_GLenum_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, param);
    }
    
    @QtUninvokable
    private native void glTexParameteri_native_GLenum_GLenum_GLint(long __this__nativeId, int target, int pname, int param);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexParameteriv(GLenum,GLenum,const GLint*)
     * @param target
     * @param pname
     * @param params
     */
    @QtUninvokable
    public final void glTexParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glTexParameteriv_native_GLenum_GLenum_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glTexParameteriv_native_GLenum_GLenum_const_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexSubImage1D(GLenum,GLint,GLint,GLsizei,GLenum,GLenum,const GLvoid*)
     * @param target
     * @param level
     * @param xoffset
     * @param width
     * @param format
     * @param type
     * @param pixels
     */
    @QtUninvokable
    public final void glTexSubImage1D(int target, int level, int xoffset, int width, int format, int type, java.nio.@Nullable Buffer pixels){
        glTexSubImage1D_native_GLenum_GLint_GLint_GLsizei_GLenum_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, xoffset, width, format, type, pixels);
    }
    
    @QtUninvokable
    private native void glTexSubImage1D_native_GLenum_GLint_GLint_GLsizei_GLenum_GLenum_const_GLvoid_ptr(long __this__nativeId, int target, int level, int xoffset, int width, int format, int type, java.nio.Buffer pixels);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexSubImage2D(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,const GLvoid*)
     * @param target
     * @param level
     * @param xoffset
     * @param yoffset
     * @param width
     * @param height
     * @param format
     * @param type
     * @param pixels
     */
    @QtUninvokable
    public final void glTexSubImage2D(int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, java.nio.@Nullable Buffer pixels){
        glTexSubImage2D_native_GLenum_GLint_GLint_GLint_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, xoffset, yoffset, width, height, format, type, pixels);
    }
    
    @QtUninvokable
    private native void glTexSubImage2D_native_GLenum_GLint_GLint_GLint_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr(long __this__nativeId, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, java.nio.Buffer pixels);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTexSubImage3D(GLenum,GLint,GLint,GLint,GLint,GLsizei,GLsizei,GLsizei,GLenum,GLenum,const GLvoid*)
     * @param target
     * @param level
     * @param xoffset
     * @param yoffset
     * @param zoffset
     * @param width
     * @param height
     * @param depth
     * @param format
     * @param type
     * @param pixels
     */
    @QtUninvokable
    public final void glTexSubImage3D(int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int type, java.nio.@Nullable Buffer pixels){
        glTexSubImage3D_native_GLenum_GLint_GLint_GLint_GLint_GLsizei_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
    }
    
    @QtUninvokable
    private native void glTexSubImage3D_native_GLenum_GLint_GLint_GLint_GLint_GLsizei_GLsizei_GLsizei_GLenum_GLenum_const_GLvoid_ptr(long __this__nativeId, int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int type, java.nio.Buffer pixels);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTransformFeedbackVaryings(GLuint,GLsizei,const GLchar*const*,GLenum)
     * @param program
     * @param varyings
     * @param bufferMode
     */
    @QtUninvokable
    public final void glTransformFeedbackVaryings(int program, java.lang.String[] varyings, int bufferMode){
        glTransformFeedbackVaryings_native_GLuint_GLsizei_const_GLchar_cptr_ptr_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), program, varyings, bufferMode);
    }
    
    @QtUninvokable
    private native void glTransformFeedbackVaryings_native_GLuint_GLsizei_const_GLchar_cptr_ptr_GLenum(long __this__nativeId, int program, java.lang.String[] varyings, int bufferMode);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTranslated(GLdouble,GLdouble,GLdouble)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glTranslated(double x, double y, double z){
        glTranslated_native_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glTranslated_native_GLdouble_GLdouble_GLdouble(long __this__nativeId, double x, double y, double z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glTranslatef(GLfloat,GLfloat,GLfloat)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glTranslatef(float x, float y, float z){
        glTranslatef_native_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glTranslatef_native_GLfloat_GLfloat_GLfloat(long __this__nativeId, float x, float y, float z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform1f(GLint,GLfloat)
     * @param location
     * @param v0
     */
    @QtUninvokable
    public final void glUniform1f(int location, float v0){
        glUniform1f_native_GLint_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0);
    }
    
    @QtUninvokable
    private native void glUniform1f_native_GLint_GLfloat(long __this__nativeId, int location, float v0);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform1fv(GLint,GLsizei,const GLfloat*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform1fv(int location, int count, java.nio.@Nullable FloatBuffer value){
        glUniform1fv_native_GLint_GLsizei_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform1fv_native_GLint_GLsizei_const_GLfloat_ptr(long __this__nativeId, int location, int count, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform1i(GLint,GLint)
     * @param location
     * @param v0
     */
    @QtUninvokable
    public final void glUniform1i(int location, int v0){
        glUniform1i_native_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0);
    }
    
    @QtUninvokable
    private native void glUniform1i_native_GLint_GLint(long __this__nativeId, int location, int v0);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform1iv(GLint,GLsizei,const GLint*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform1iv(int location, int count, java.nio.@Nullable IntBuffer value){
        glUniform1iv_native_GLint_GLsizei_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform1iv_native_GLint_GLsizei_const_GLint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform1ui(GLint,GLuint)
     * @param location
     * @param v0
     */
    @QtUninvokable
    public final void glUniform1ui(int location, int v0){
        glUniform1ui_native_GLint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0);
    }
    
    @QtUninvokable
    private native void glUniform1ui_native_GLint_GLuint(long __this__nativeId, int location, int v0);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform1uiv(GLint,GLsizei,const GLuint*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform1uiv(int location, int count, java.nio.@Nullable IntBuffer value){
        glUniform1uiv_native_GLint_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform1uiv_native_GLint_GLsizei_const_GLuint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform2f(GLint,GLfloat,GLfloat)
     * @param location
     * @param v0
     * @param v1
     */
    @QtUninvokable
    public final void glUniform2f(int location, float v0, float v1){
        glUniform2f_native_GLint_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0, v1);
    }
    
    @QtUninvokable
    private native void glUniform2f_native_GLint_GLfloat_GLfloat(long __this__nativeId, int location, float v0, float v1);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform2fv(GLint,GLsizei,const GLfloat*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform2fv(int location, int count, java.nio.@Nullable FloatBuffer value){
        glUniform2fv_native_GLint_GLsizei_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform2fv_native_GLint_GLsizei_const_GLfloat_ptr(long __this__nativeId, int location, int count, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform2i(GLint,GLint,GLint)
     * @param location
     * @param v0
     * @param v1
     */
    @QtUninvokable
    public final void glUniform2i(int location, int v0, int v1){
        glUniform2i_native_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0, v1);
    }
    
    @QtUninvokable
    private native void glUniform2i_native_GLint_GLint_GLint(long __this__nativeId, int location, int v0, int v1);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform2iv(GLint,GLsizei,const GLint*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform2iv(int location, int count, java.nio.@Nullable IntBuffer value){
        glUniform2iv_native_GLint_GLsizei_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform2iv_native_GLint_GLsizei_const_GLint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform2ui(GLint,GLuint,GLuint)
     * @param location
     * @param v0
     * @param v1
     */
    @QtUninvokable
    public final void glUniform2ui(int location, int v0, int v1){
        glUniform2ui_native_GLint_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0, v1);
    }
    
    @QtUninvokable
    private native void glUniform2ui_native_GLint_GLuint_GLuint(long __this__nativeId, int location, int v0, int v1);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform2uiv(GLint,GLsizei,const GLuint*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform2uiv(int location, int count, java.nio.@Nullable IntBuffer value){
        glUniform2uiv_native_GLint_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform2uiv_native_GLint_GLsizei_const_GLuint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform3f(GLint,GLfloat,GLfloat,GLfloat)
     * @param location
     * @param v0
     * @param v1
     * @param v2
     */
    @QtUninvokable
    public final void glUniform3f(int location, float v0, float v1, float v2){
        glUniform3f_native_GLint_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0, v1, v2);
    }
    
    @QtUninvokable
    private native void glUniform3f_native_GLint_GLfloat_GLfloat_GLfloat(long __this__nativeId, int location, float v0, float v1, float v2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform3fv(GLint,GLsizei,const GLfloat*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform3fv(int location, int count, java.nio.@Nullable FloatBuffer value){
        glUniform3fv_native_GLint_GLsizei_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform3fv_native_GLint_GLsizei_const_GLfloat_ptr(long __this__nativeId, int location, int count, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform3i(GLint,GLint,GLint,GLint)
     * @param location
     * @param v0
     * @param v1
     * @param v2
     */
    @QtUninvokable
    public final void glUniform3i(int location, int v0, int v1, int v2){
        glUniform3i_native_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0, v1, v2);
    }
    
    @QtUninvokable
    private native void glUniform3i_native_GLint_GLint_GLint_GLint(long __this__nativeId, int location, int v0, int v1, int v2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform3iv(GLint,GLsizei,const GLint*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform3iv(int location, int count, java.nio.@Nullable IntBuffer value){
        glUniform3iv_native_GLint_GLsizei_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform3iv_native_GLint_GLsizei_const_GLint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform3ui(GLint,GLuint,GLuint,GLuint)
     * @param location
     * @param v0
     * @param v1
     * @param v2
     */
    @QtUninvokable
    public final void glUniform3ui(int location, int v0, int v1, int v2){
        glUniform3ui_native_GLint_GLuint_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0, v1, v2);
    }
    
    @QtUninvokable
    private native void glUniform3ui_native_GLint_GLuint_GLuint_GLuint(long __this__nativeId, int location, int v0, int v1, int v2);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform3uiv(GLint,GLsizei,const GLuint*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform3uiv(int location, int count, java.nio.@Nullable IntBuffer value){
        glUniform3uiv_native_GLint_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform3uiv_native_GLint_GLsizei_const_GLuint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform4f(GLint,GLfloat,GLfloat,GLfloat,GLfloat)
     * @param location
     * @param v0
     * @param v1
     * @param v2
     * @param v3
     */
    @QtUninvokable
    public final void glUniform4f(int location, float v0, float v1, float v2, float v3){
        glUniform4f_native_GLint_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0, v1, v2, v3);
    }
    
    @QtUninvokable
    private native void glUniform4f_native_GLint_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, int location, float v0, float v1, float v2, float v3);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform4fv(GLint,GLsizei,const GLfloat*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform4fv(int location, int count, java.nio.@Nullable FloatBuffer value){
        glUniform4fv_native_GLint_GLsizei_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform4fv_native_GLint_GLsizei_const_GLfloat_ptr(long __this__nativeId, int location, int count, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform4i(GLint,GLint,GLint,GLint,GLint)
     * @param location
     * @param v0
     * @param v1
     * @param v2
     * @param v3
     */
    @QtUninvokable
    public final void glUniform4i(int location, int v0, int v1, int v2, int v3){
        glUniform4i_native_GLint_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0, v1, v2, v3);
    }
    
    @QtUninvokable
    private native void glUniform4i_native_GLint_GLint_GLint_GLint_GLint(long __this__nativeId, int location, int v0, int v1, int v2, int v3);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform4iv(GLint,GLsizei,const GLint*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform4iv(int location, int count, java.nio.@Nullable IntBuffer value){
        glUniform4iv_native_GLint_GLsizei_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform4iv_native_GLint_GLsizei_const_GLint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform4ui(GLint,GLuint,GLuint,GLuint,GLuint)
     * @param location
     * @param v0
     * @param v1
     * @param v2
     * @param v3
     */
    @QtUninvokable
    public final void glUniform4ui(int location, int v0, int v1, int v2, int v3){
        glUniform4ui_native_GLint_GLuint_GLuint_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), location, v0, v1, v2, v3);
    }
    
    @QtUninvokable
    private native void glUniform4ui_native_GLint_GLuint_GLuint_GLuint_GLuint(long __this__nativeId, int location, int v0, int v1, int v2, int v3);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniform4uiv(GLint,GLsizei,const GLuint*)
     * @param location
     * @param count
     * @param value
     */
    @QtUninvokable
    public final void glUniform4uiv(int location, int count, java.nio.@Nullable IntBuffer value){
        glUniform4uiv_native_GLint_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, value);
    }
    
    @QtUninvokable
    private native void glUniform4uiv_native_GLint_GLsizei_const_GLuint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniformBlockBinding(GLuint,GLuint,GLuint)
     * @param program
     * @param uniformBlockIndex
     * @param uniformBlockBinding
     */
    @QtUninvokable
    public final void glUniformBlockBinding(int program, int uniformBlockIndex, int uniformBlockBinding){
        glUniformBlockBinding_native_GLuint_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program, uniformBlockIndex, uniformBlockBinding);
    }
    
    @QtUninvokable
    private native void glUniformBlockBinding_native_GLuint_GLuint_GLuint(long __this__nativeId, int program, int uniformBlockIndex, int uniformBlockBinding);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniformMatrix2fv(GLint,GLsizei,GLboolean,const GLfloat*)
     * @param location
     * @param count
     * @param transpose
     * @param value
     */
    @QtUninvokable
    public final void glUniformMatrix2fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix2fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix2fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniformMatrix2x3fv(GLint,GLsizei,GLboolean,const GLfloat*)
     * @param location
     * @param count
     * @param transpose
     * @param value
     */
    @QtUninvokable
    public final void glUniformMatrix2x3fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix2x3fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix2x3fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniformMatrix2x4fv(GLint,GLsizei,GLboolean,const GLfloat*)
     * @param location
     * @param count
     * @param transpose
     * @param value
     */
    @QtUninvokable
    public final void glUniformMatrix2x4fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix2x4fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix2x4fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniformMatrix3fv(GLint,GLsizei,GLboolean,const GLfloat*)
     * @param location
     * @param count
     * @param transpose
     * @param value
     */
    @QtUninvokable
    public final void glUniformMatrix3fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix3fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix3fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniformMatrix3x2fv(GLint,GLsizei,GLboolean,const GLfloat*)
     * @param location
     * @param count
     * @param transpose
     * @param value
     */
    @QtUninvokable
    public final void glUniformMatrix3x2fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix3x2fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix3x2fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniformMatrix3x4fv(GLint,GLsizei,GLboolean,const GLfloat*)
     * @param location
     * @param count
     * @param transpose
     * @param value
     */
    @QtUninvokable
    public final void glUniformMatrix3x4fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix3x4fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix3x4fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniformMatrix4fv(GLint,GLsizei,GLboolean,const GLfloat*)
     * @param location
     * @param count
     * @param transpose
     * @param value
     */
    @QtUninvokable
    public final void glUniformMatrix4fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix4fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix4fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniformMatrix4x2fv(GLint,GLsizei,GLboolean,const GLfloat*)
     * @param location
     * @param count
     * @param transpose
     * @param value
     */
    @QtUninvokable
    public final void glUniformMatrix4x2fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix4x2fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix4x2fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUniformMatrix4x3fv(GLint,GLsizei,GLboolean,const GLfloat*)
     * @param location
     * @param count
     * @param transpose
     * @param value
     */
    @QtUninvokable
    public final void glUniformMatrix4x3fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix4x3fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix4x3fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUnmapBuffer(GLenum)
     * @param target
     * @return
     */
    @QtUninvokable
    public final boolean glUnmapBuffer(int target){
        return glUnmapBuffer_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target);
    }
    
    @QtUninvokable
    private native boolean glUnmapBuffer_native_GLenum(long __this__nativeId, int target);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glUseProgram(GLuint)
     * @param program
     */
    @QtUninvokable
    public final void glUseProgram(int program){
        glUseProgram_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program);
    }
    
    @QtUninvokable
    private native void glUseProgram_native_GLuint(long __this__nativeId, int program);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glValidateProgram(GLuint)
     * @param program
     */
    @QtUninvokable
    public final void glValidateProgram(int program){
        glValidateProgram_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program);
    }
    
    @QtUninvokable
    private native void glValidateProgram_native_GLuint(long __this__nativeId, int program);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex2d(GLdouble,GLdouble)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glVertex2d(double x, double y){
        glVertex2d_native_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glVertex2d_native_GLdouble_GLdouble(long __this__nativeId, double x, double y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex2dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex2dv(double[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glVertex2dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex2dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex2f(GLfloat,GLfloat)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glVertex2f(float x, float y){
        glVertex2f_native_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glVertex2f_native_GLfloat_GLfloat(long __this__nativeId, float x, float y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex2fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex2fv(float[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glVertex2fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex2fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex2i(GLint,GLint)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glVertex2i(int x, int y){
        glVertex2i_native_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glVertex2i_native_GLint_GLint(long __this__nativeId, int x, int y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex2iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex2iv(int[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glVertex2iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex2iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex2s(GLshort,GLshort)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glVertex2s(short x, short y){
        glVertex2s_native_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glVertex2s_native_GLshort_GLshort(long __this__nativeId, short x, short y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex2sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex2sv(short[] v){
        if(v!=null && v.length < 2)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 2");
        glVertex2sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex2sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex3d(GLdouble,GLdouble,GLdouble)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glVertex3d(double x, double y, double z){
        glVertex3d_native_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glVertex3d_native_GLdouble_GLdouble_GLdouble(long __this__nativeId, double x, double y, double z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex3dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex3dv(double[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glVertex3dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex3dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex3f(GLfloat,GLfloat,GLfloat)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glVertex3f(float x, float y, float z){
        glVertex3f_native_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glVertex3f_native_GLfloat_GLfloat_GLfloat(long __this__nativeId, float x, float y, float z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex3fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex3fv(float[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glVertex3fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex3fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex3i(GLint,GLint,GLint)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glVertex3i(int x, int y, int z){
        glVertex3i_native_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glVertex3i_native_GLint_GLint_GLint(long __this__nativeId, int x, int y, int z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex3iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex3iv(int[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glVertex3iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex3iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex3s(GLshort,GLshort,GLshort)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glVertex3s(short x, short y, short z){
        glVertex3s_native_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glVertex3s_native_GLshort_GLshort_GLshort(long __this__nativeId, short x, short y, short z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex3sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex3sv(short[] v){
        if(v!=null && v.length < 3)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 3");
        glVertex3sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex3sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex4d(GLdouble,GLdouble,GLdouble,GLdouble)
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glVertex4d(double x, double y, double z, double w){
        glVertex4d_native_GLdouble_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z, w);
    }
    
    @QtUninvokable
    private native void glVertex4d_native_GLdouble_GLdouble_GLdouble_GLdouble(long __this__nativeId, double x, double y, double z, double w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex4dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex4dv(double[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glVertex4dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex4dv_native_const_GLdouble_ptr(long __this__nativeId, double[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex4f(GLfloat,GLfloat,GLfloat,GLfloat)
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glVertex4f(float x, float y, float z, float w){
        glVertex4f_native_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z, w);
    }
    
    @QtUninvokable
    private native void glVertex4f_native_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, float x, float y, float z, float w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex4fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex4fv(float[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glVertex4fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex4fv_native_const_GLfloat_ptr(long __this__nativeId, float[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex4i(GLint,GLint,GLint,GLint)
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glVertex4i(int x, int y, int z, int w){
        glVertex4i_native_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z, w);
    }
    
    @QtUninvokable
    private native void glVertex4i_native_GLint_GLint_GLint_GLint(long __this__nativeId, int x, int y, int z, int w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex4iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex4iv(int[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glVertex4iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex4iv_native_const_GLint_ptr(long __this__nativeId, int[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex4s(GLshort,GLshort,GLshort,GLshort)
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glVertex4s(short x, short y, short z, short w){
        glVertex4s_native_GLshort_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z, w);
    }
    
    @QtUninvokable
    private native void glVertex4s_native_GLshort_GLshort_GLshort_GLshort(long __this__nativeId, short x, short y, short z, short w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertex4sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glVertex4sv(short[] v){
        if(v!=null && v.length < 4)
            throw new IllegalArgumentException("Argument 'v': Wrong number of elements in array. Found: " + v.length + ", expected: 4");
        glVertex4sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glVertex4sv_native_const_GLshort_ptr(long __this__nativeId, short[] v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1d(GLuint,GLdouble)
     * @param index
     * @param x
     */
    @QtUninvokable
    public final void glVertexAttrib1d(int index, double x){
        glVertexAttrib1d_native_GLuint_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), index, x);
    }
    
    @QtUninvokable
    private native void glVertexAttrib1d_native_GLuint_GLdouble(long __this__nativeId, int index, double x);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1dv(GLuint,const GLdouble*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib1dv(int index, java.nio.@Nullable DoubleBuffer v){
        glVertexAttrib1dv_native_GLuint_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib1dv_native_GLuint_const_GLdouble_ptr(long __this__nativeId, int index, java.nio.DoubleBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1f(GLuint,GLfloat)
     * @param index
     * @param x
     */
    @QtUninvokable
    public final void glVertexAttrib1f(int index, float x){
        glVertexAttrib1f_native_GLuint_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), index, x);
    }
    
    @QtUninvokable
    private native void glVertexAttrib1f_native_GLuint_GLfloat(long __this__nativeId, int index, float x);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1fv(GLuint,const GLfloat*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib1fv(int index, java.nio.@Nullable FloatBuffer v){
        glVertexAttrib1fv_native_GLuint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib1fv_native_GLuint_const_GLfloat_ptr(long __this__nativeId, int index, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1s(GLuint,GLshort)
     * @param index
     * @param x
     */
    @QtUninvokable
    public final void glVertexAttrib1s(int index, short x){
        glVertexAttrib1s_native_GLuint_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), index, x);
    }
    
    @QtUninvokable
    private native void glVertexAttrib1s_native_GLuint_GLshort(long __this__nativeId, int index, short x);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib1sv(GLuint,const GLshort*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib1sv(int index, java.nio.@Nullable ShortBuffer v){
        glVertexAttrib1sv_native_GLuint_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib1sv_native_GLuint_const_GLshort_ptr(long __this__nativeId, int index, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2d(GLuint,GLdouble,GLdouble)
     * @param index
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glVertexAttrib2d(int index, double x, double y){
        glVertexAttrib2d_native_GLuint_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y);
    }
    
    @QtUninvokable
    private native void glVertexAttrib2d_native_GLuint_GLdouble_GLdouble(long __this__nativeId, int index, double x, double y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2dv(GLuint,const GLdouble*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib2dv(int index, java.nio.@Nullable DoubleBuffer v){
        glVertexAttrib2dv_native_GLuint_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib2dv_native_GLuint_const_GLdouble_ptr(long __this__nativeId, int index, java.nio.DoubleBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2f(GLuint,GLfloat,GLfloat)
     * @param index
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glVertexAttrib2f(int index, float x, float y){
        glVertexAttrib2f_native_GLuint_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y);
    }
    
    @QtUninvokable
    private native void glVertexAttrib2f_native_GLuint_GLfloat_GLfloat(long __this__nativeId, int index, float x, float y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2fv(GLuint,const GLfloat*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib2fv(int index, java.nio.@Nullable FloatBuffer v){
        glVertexAttrib2fv_native_GLuint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib2fv_native_GLuint_const_GLfloat_ptr(long __this__nativeId, int index, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2s(GLuint,GLshort,GLshort)
     * @param index
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glVertexAttrib2s(int index, short x, short y){
        glVertexAttrib2s_native_GLuint_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y);
    }
    
    @QtUninvokable
    private native void glVertexAttrib2s_native_GLuint_GLshort_GLshort(long __this__nativeId, int index, short x, short y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib2sv(GLuint,const GLshort*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib2sv(int index, java.nio.@Nullable ShortBuffer v){
        glVertexAttrib2sv_native_GLuint_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib2sv_native_GLuint_const_GLshort_ptr(long __this__nativeId, int index, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3d(GLuint,GLdouble,GLdouble,GLdouble)
     * @param index
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glVertexAttrib3d(int index, double x, double y, double z){
        glVertexAttrib3d_native_GLuint_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y, z);
    }
    
    @QtUninvokable
    private native void glVertexAttrib3d_native_GLuint_GLdouble_GLdouble_GLdouble(long __this__nativeId, int index, double x, double y, double z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3dv(GLuint,const GLdouble*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib3dv(int index, java.nio.@Nullable DoubleBuffer v){
        glVertexAttrib3dv_native_GLuint_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib3dv_native_GLuint_const_GLdouble_ptr(long __this__nativeId, int index, java.nio.DoubleBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3f(GLuint,GLfloat,GLfloat,GLfloat)
     * @param index
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glVertexAttrib3f(int index, float x, float y, float z){
        glVertexAttrib3f_native_GLuint_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y, z);
    }
    
    @QtUninvokable
    private native void glVertexAttrib3f_native_GLuint_GLfloat_GLfloat_GLfloat(long __this__nativeId, int index, float x, float y, float z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3fv(GLuint,const GLfloat*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib3fv(int index, java.nio.@Nullable FloatBuffer v){
        glVertexAttrib3fv_native_GLuint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib3fv_native_GLuint_const_GLfloat_ptr(long __this__nativeId, int index, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3s(GLuint,GLshort,GLshort,GLshort)
     * @param index
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glVertexAttrib3s(int index, short x, short y, short z){
        glVertexAttrib3s_native_GLuint_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y, z);
    }
    
    @QtUninvokable
    private native void glVertexAttrib3s_native_GLuint_GLshort_GLshort_GLshort(long __this__nativeId, int index, short x, short y, short z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib3sv(GLuint,const GLshort*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib3sv(int index, java.nio.@Nullable ShortBuffer v){
        glVertexAttrib3sv_native_GLuint_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib3sv_native_GLuint_const_GLshort_ptr(long __this__nativeId, int index, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nbv(GLuint,const GLbyte*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4Nbv(int index, java.nio.@Nullable ByteBuffer v){
        glVertexAttrib4Nbv_native_GLuint_const_GLbyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4Nbv_native_GLuint_const_GLbyte_ptr(long __this__nativeId, int index, java.nio.ByteBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Niv(GLuint,const GLint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4Niv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttrib4Niv_native_GLuint_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4Niv_native_GLuint_const_GLint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nsv(GLuint,const GLshort*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4Nsv(int index, java.nio.@Nullable ShortBuffer v){
        glVertexAttrib4Nsv_native_GLuint_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4Nsv_native_GLuint_const_GLshort_ptr(long __this__nativeId, int index, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nub(GLuint,GLubyte,GLubyte,GLubyte,GLubyte)
     * @param index
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glVertexAttrib4Nub(int index, byte x, byte y, byte z, byte w){
        glVertexAttrib4Nub_native_GLuint_GLubyte_GLubyte_GLubyte_GLubyte(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y, z, w);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4Nub_native_GLuint_GLubyte_GLubyte_GLubyte_GLubyte(long __this__nativeId, int index, byte x, byte y, byte z, byte w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nubv(GLuint,const GLubyte*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4Nubv(int index, java.nio.@Nullable ByteBuffer v){
        glVertexAttrib4Nubv_native_GLuint_const_GLubyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4Nubv_native_GLuint_const_GLubyte_ptr(long __this__nativeId, int index, java.nio.ByteBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nuiv(GLuint,const GLuint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4Nuiv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttrib4Nuiv_native_GLuint_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4Nuiv_native_GLuint_const_GLuint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4Nusv(GLuint,const GLushort*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4Nusv(int index, java.nio.@Nullable ShortBuffer v){
        glVertexAttrib4Nusv_native_GLuint_const_GLushort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4Nusv_native_GLuint_const_GLushort_ptr(long __this__nativeId, int index, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4bv(GLuint,const GLbyte*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4bv(int index, java.nio.@Nullable ByteBuffer v){
        glVertexAttrib4bv_native_GLuint_const_GLbyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4bv_native_GLuint_const_GLbyte_ptr(long __this__nativeId, int index, java.nio.ByteBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4d(GLuint,GLdouble,GLdouble,GLdouble,GLdouble)
     * @param index
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glVertexAttrib4d(int index, double x, double y, double z, double w){
        glVertexAttrib4d_native_GLuint_GLdouble_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y, z, w);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4d_native_GLuint_GLdouble_GLdouble_GLdouble_GLdouble(long __this__nativeId, int index, double x, double y, double z, double w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4dv(GLuint,const GLdouble*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4dv(int index, java.nio.@Nullable DoubleBuffer v){
        glVertexAttrib4dv_native_GLuint_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4dv_native_GLuint_const_GLdouble_ptr(long __this__nativeId, int index, java.nio.DoubleBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4f(GLuint,GLfloat,GLfloat,GLfloat,GLfloat)
     * @param index
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glVertexAttrib4f(int index, float x, float y, float z, float w){
        glVertexAttrib4f_native_GLuint_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y, z, w);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4f_native_GLuint_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, int index, float x, float y, float z, float w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4fv(GLuint,const GLfloat*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4fv(int index, java.nio.@Nullable FloatBuffer v){
        glVertexAttrib4fv_native_GLuint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4fv_native_GLuint_const_GLfloat_ptr(long __this__nativeId, int index, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4iv(GLuint,const GLint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4iv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttrib4iv_native_GLuint_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4iv_native_GLuint_const_GLint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4s(GLuint,GLshort,GLshort,GLshort,GLshort)
     * @param index
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glVertexAttrib4s(int index, short x, short y, short z, short w){
        glVertexAttrib4s_native_GLuint_GLshort_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y, z, w);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4s_native_GLuint_GLshort_GLshort_GLshort_GLshort(long __this__nativeId, int index, short x, short y, short z, short w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4sv(GLuint,const GLshort*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4sv(int index, java.nio.@Nullable ShortBuffer v){
        glVertexAttrib4sv_native_GLuint_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4sv_native_GLuint_const_GLshort_ptr(long __this__nativeId, int index, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4ubv(GLuint,const GLubyte*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4ubv(int index, java.nio.@Nullable ByteBuffer v){
        glVertexAttrib4ubv_native_GLuint_const_GLubyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4ubv_native_GLuint_const_GLubyte_ptr(long __this__nativeId, int index, java.nio.ByteBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4uiv(GLuint,const GLuint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4uiv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttrib4uiv_native_GLuint_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4uiv_native_GLuint_const_GLuint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttrib4usv(GLuint,const GLushort*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttrib4usv(int index, java.nio.@Nullable ShortBuffer v){
        glVertexAttrib4usv_native_GLuint_const_GLushort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4usv_native_GLuint_const_GLushort_ptr(long __this__nativeId, int index, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribDivisor(GLuint,GLuint)
     * @param index
     * @param divisor
     */
    @QtUninvokable
    public final void glVertexAttribDivisor(int index, int divisor){
        glVertexAttribDivisor_native_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index, divisor);
    }
    
    @QtUninvokable
    private native void glVertexAttribDivisor_native_GLuint_GLuint(long __this__nativeId, int index, int divisor);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1i(GLuint,GLint)
     * @param index
     * @param x
     */
    @QtUninvokable
    public final void glVertexAttribI1i(int index, int x){
        glVertexAttribI1i_native_GLuint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), index, x);
    }
    
    @QtUninvokable
    private native void glVertexAttribI1i_native_GLuint_GLint(long __this__nativeId, int index, int x);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1iv(GLuint,const GLint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI1iv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttribI1iv_native_GLuint_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI1iv_native_GLuint_const_GLint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1ui(GLuint,GLuint)
     * @param index
     * @param x
     */
    @QtUninvokable
    public final void glVertexAttribI1ui(int index, int x){
        glVertexAttribI1ui_native_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index, x);
    }
    
    @QtUninvokable
    private native void glVertexAttribI1ui_native_GLuint_GLuint(long __this__nativeId, int index, int x);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI1uiv(GLuint,const GLuint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI1uiv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttribI1uiv_native_GLuint_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI1uiv_native_GLuint_const_GLuint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2i(GLuint,GLint,GLint)
     * @param index
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glVertexAttribI2i(int index, int x, int y){
        glVertexAttribI2i_native_GLuint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y);
    }
    
    @QtUninvokable
    private native void glVertexAttribI2i_native_GLuint_GLint_GLint(long __this__nativeId, int index, int x, int y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2iv(GLuint,const GLint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI2iv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttribI2iv_native_GLuint_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI2iv_native_GLuint_const_GLint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2ui(GLuint,GLuint,GLuint)
     * @param index
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glVertexAttribI2ui(int index, int x, int y){
        glVertexAttribI2ui_native_GLuint_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y);
    }
    
    @QtUninvokable
    private native void glVertexAttribI2ui_native_GLuint_GLuint_GLuint(long __this__nativeId, int index, int x, int y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI2uiv(GLuint,const GLuint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI2uiv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttribI2uiv_native_GLuint_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI2uiv_native_GLuint_const_GLuint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3i(GLuint,GLint,GLint,GLint)
     * @param index
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glVertexAttribI3i(int index, int x, int y, int z){
        glVertexAttribI3i_native_GLuint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y, z);
    }
    
    @QtUninvokable
    private native void glVertexAttribI3i_native_GLuint_GLint_GLint_GLint(long __this__nativeId, int index, int x, int y, int z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3iv(GLuint,const GLint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI3iv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttribI3iv_native_GLuint_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI3iv_native_GLuint_const_GLint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3ui(GLuint,GLuint,GLuint,GLuint)
     * @param index
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glVertexAttribI3ui(int index, int x, int y, int z){
        glVertexAttribI3ui_native_GLuint_GLuint_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y, z);
    }
    
    @QtUninvokable
    private native void glVertexAttribI3ui_native_GLuint_GLuint_GLuint_GLuint(long __this__nativeId, int index, int x, int y, int z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI3uiv(GLuint,const GLuint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI3uiv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttribI3uiv_native_GLuint_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI3uiv_native_GLuint_const_GLuint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4bv(GLuint,const GLbyte*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI4bv(int index, java.nio.@Nullable ByteBuffer v){
        glVertexAttribI4bv_native_GLuint_const_GLbyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI4bv_native_GLuint_const_GLbyte_ptr(long __this__nativeId, int index, java.nio.ByteBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4i(GLuint,GLint,GLint,GLint,GLint)
     * @param index
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glVertexAttribI4i(int index, int x, int y, int z, int w){
        glVertexAttribI4i_native_GLuint_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y, z, w);
    }
    
    @QtUninvokable
    private native void glVertexAttribI4i_native_GLuint_GLint_GLint_GLint_GLint(long __this__nativeId, int index, int x, int y, int z, int w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4iv(GLuint,const GLint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI4iv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttribI4iv_native_GLuint_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI4iv_native_GLuint_const_GLint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4sv(GLuint,const GLshort*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI4sv(int index, java.nio.@Nullable ShortBuffer v){
        glVertexAttribI4sv_native_GLuint_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI4sv_native_GLuint_const_GLshort_ptr(long __this__nativeId, int index, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4ubv(GLuint,const GLubyte*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI4ubv(int index, java.nio.@Nullable ByteBuffer v){
        glVertexAttribI4ubv_native_GLuint_const_GLubyte_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI4ubv_native_GLuint_const_GLubyte_ptr(long __this__nativeId, int index, java.nio.ByteBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4ui(GLuint,GLuint,GLuint,GLuint,GLuint)
     * @param index
     * @param x
     * @param y
     * @param z
     * @param w
     */
    @QtUninvokable
    public final void glVertexAttribI4ui(int index, int x, int y, int z, int w){
        glVertexAttribI4ui_native_GLuint_GLuint_GLuint_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index, x, y, z, w);
    }
    
    @QtUninvokable
    private native void glVertexAttribI4ui_native_GLuint_GLuint_GLuint_GLuint_GLuint(long __this__nativeId, int index, int x, int y, int z, int w);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4uiv(GLuint,const GLuint*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI4uiv(int index, java.nio.@Nullable IntBuffer v){
        glVertexAttribI4uiv_native_GLuint_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI4uiv_native_GLuint_const_GLuint_ptr(long __this__nativeId, int index, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribI4usv(GLuint,const GLushort*)
     * @param index
     * @param v
     */
    @QtUninvokable
    public final void glVertexAttribI4usv(int index, java.nio.@Nullable ShortBuffer v){
        glVertexAttribI4usv_native_GLuint_const_GLushort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, v);
    }
    
    @QtUninvokable
    private native void glVertexAttribI4usv_native_GLuint_const_GLushort_ptr(long __this__nativeId, int index, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribIPointer(GLuint,GLint,GLenum,GLsizei,const GLvoid*)
     * @param index
     * @param size
     * @param type
     * @param stride
     * @param pointer
     */
    @QtUninvokable
    public final void glVertexAttribIPointer(int index, int size, int type, int stride, java.nio.@Nullable Buffer pointer){
        glVertexAttribIPointer_native_GLuint_GLint_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, size, type, stride, pointer);
    }
    
    @QtUninvokable
    private native void glVertexAttribIPointer_native_GLuint_GLint_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int index, int size, int type, int stride, java.nio.Buffer pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribP1ui(GLuint,GLenum,GLboolean,GLuint)
     * @param index
     * @param type
     * @param normalized
     * @param value
     */
    @QtUninvokable
    public final void glVertexAttribP1ui(int index, int type, boolean normalized, int value){
        glVertexAttribP1ui_native_GLuint_GLenum_GLboolean_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index, type, normalized, value);
    }
    
    @QtUninvokable
    private native void glVertexAttribP1ui_native_GLuint_GLenum_GLboolean_GLuint(long __this__nativeId, int index, int type, boolean normalized, int value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribP1uiv(GLuint,GLenum,GLboolean,const GLuint*)
     * @param index
     * @param type
     * @param normalized
     * @param value
     */
    @QtUninvokable
    public final void glVertexAttribP1uiv(int index, int type, boolean normalized, java.nio.@Nullable IntBuffer value){
        glVertexAttribP1uiv_native_GLuint_GLenum_GLboolean_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, type, normalized, value);
    }
    
    @QtUninvokable
    private native void glVertexAttribP1uiv_native_GLuint_GLenum_GLboolean_const_GLuint_ptr(long __this__nativeId, int index, int type, boolean normalized, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribP2ui(GLuint,GLenum,GLboolean,GLuint)
     * @param index
     * @param type
     * @param normalized
     * @param value
     */
    @QtUninvokable
    public final void glVertexAttribP2ui(int index, int type, boolean normalized, int value){
        glVertexAttribP2ui_native_GLuint_GLenum_GLboolean_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index, type, normalized, value);
    }
    
    @QtUninvokable
    private native void glVertexAttribP2ui_native_GLuint_GLenum_GLboolean_GLuint(long __this__nativeId, int index, int type, boolean normalized, int value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribP2uiv(GLuint,GLenum,GLboolean,const GLuint*)
     * @param index
     * @param type
     * @param normalized
     * @param value
     */
    @QtUninvokable
    public final void glVertexAttribP2uiv(int index, int type, boolean normalized, java.nio.@Nullable IntBuffer value){
        glVertexAttribP2uiv_native_GLuint_GLenum_GLboolean_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, type, normalized, value);
    }
    
    @QtUninvokable
    private native void glVertexAttribP2uiv_native_GLuint_GLenum_GLboolean_const_GLuint_ptr(long __this__nativeId, int index, int type, boolean normalized, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribP3ui(GLuint,GLenum,GLboolean,GLuint)
     * @param index
     * @param type
     * @param normalized
     * @param value
     */
    @QtUninvokable
    public final void glVertexAttribP3ui(int index, int type, boolean normalized, int value){
        glVertexAttribP3ui_native_GLuint_GLenum_GLboolean_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index, type, normalized, value);
    }
    
    @QtUninvokable
    private native void glVertexAttribP3ui_native_GLuint_GLenum_GLboolean_GLuint(long __this__nativeId, int index, int type, boolean normalized, int value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribP3uiv(GLuint,GLenum,GLboolean,const GLuint*)
     * @param index
     * @param type
     * @param normalized
     * @param value
     */
    @QtUninvokable
    public final void glVertexAttribP3uiv(int index, int type, boolean normalized, java.nio.@Nullable IntBuffer value){
        glVertexAttribP3uiv_native_GLuint_GLenum_GLboolean_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, type, normalized, value);
    }
    
    @QtUninvokable
    private native void glVertexAttribP3uiv_native_GLuint_GLenum_GLboolean_const_GLuint_ptr(long __this__nativeId, int index, int type, boolean normalized, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribP4ui(GLuint,GLenum,GLboolean,GLuint)
     * @param index
     * @param type
     * @param normalized
     * @param value
     */
    @QtUninvokable
    public final void glVertexAttribP4ui(int index, int type, boolean normalized, int value){
        glVertexAttribP4ui_native_GLuint_GLenum_GLboolean_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index, type, normalized, value);
    }
    
    @QtUninvokable
    private native void glVertexAttribP4ui_native_GLuint_GLenum_GLboolean_GLuint(long __this__nativeId, int index, int type, boolean normalized, int value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribP4uiv(GLuint,GLenum,GLboolean,const GLuint*)
     * @param index
     * @param type
     * @param normalized
     * @param value
     */
    @QtUninvokable
    public final void glVertexAttribP4uiv(int index, int type, boolean normalized, java.nio.@Nullable IntBuffer value){
        glVertexAttribP4uiv_native_GLuint_GLenum_GLboolean_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, type, normalized, value);
    }
    
    @QtUninvokable
    private native void glVertexAttribP4uiv_native_GLuint_GLenum_GLboolean_const_GLuint_ptr(long __this__nativeId, int index, int type, boolean normalized, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexAttribPointer(GLuint,GLint,GLenum,GLboolean,GLsizei,const GLvoid*)
     * @param index
     * @param size
     * @param type
     * @param normalized
     * @param stride
     * @param pointer
     */
    @QtUninvokable
    public final void glVertexAttribPointer(int index, int size, int type, boolean normalized, int stride, java.nio.@Nullable Buffer pointer){
        glVertexAttribPointer_native_GLuint_GLint_GLenum_GLboolean_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, size, type, normalized, stride, pointer);
    }
    
    @QtUninvokable
    private native void glVertexAttribPointer_native_GLuint_GLint_GLenum_GLboolean_GLsizei_const_GLvoid_ptr(long __this__nativeId, int index, int size, int type, boolean normalized, int stride, java.nio.Buffer pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexP2ui(GLenum,GLuint)
     * @param type
     * @param value
     */
    @QtUninvokable
    public final void glVertexP2ui(int type, int value){
        glVertexP2ui_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), type, value);
    }
    
    @QtUninvokable
    private native void glVertexP2ui_native_GLenum_GLuint(long __this__nativeId, int type, int value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexP2uiv(GLenum,const GLuint*)
     * @param type
     * @param value
     */
    @QtUninvokable
    public final void glVertexP2uiv(int type, java.nio.@Nullable IntBuffer value){
        glVertexP2uiv_native_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, value);
    }
    
    @QtUninvokable
    private native void glVertexP2uiv_native_GLenum_const_GLuint_ptr(long __this__nativeId, int type, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexP3ui(GLenum,GLuint)
     * @param type
     * @param value
     */
    @QtUninvokable
    public final void glVertexP3ui(int type, int value){
        glVertexP3ui_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), type, value);
    }
    
    @QtUninvokable
    private native void glVertexP3ui_native_GLenum_GLuint(long __this__nativeId, int type, int value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexP3uiv(GLenum,const GLuint*)
     * @param type
     * @param value
     */
    @QtUninvokable
    public final void glVertexP3uiv(int type, java.nio.@Nullable IntBuffer value){
        glVertexP3uiv_native_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, value);
    }
    
    @QtUninvokable
    private native void glVertexP3uiv_native_GLenum_const_GLuint_ptr(long __this__nativeId, int type, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexP4ui(GLenum,GLuint)
     * @param type
     * @param value
     */
    @QtUninvokable
    public final void glVertexP4ui(int type, int value){
        glVertexP4ui_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), type, value);
    }
    
    @QtUninvokable
    private native void glVertexP4ui_native_GLenum_GLuint(long __this__nativeId, int type, int value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexP4uiv(GLenum,const GLuint*)
     * @param type
     * @param value
     */
    @QtUninvokable
    public final void glVertexP4uiv(int type, java.nio.@Nullable IntBuffer value){
        glVertexP4uiv_native_GLenum_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), type, value);
    }
    
    @QtUninvokable
    private native void glVertexP4uiv_native_GLenum_const_GLuint_ptr(long __this__nativeId, int type, java.nio.IntBuffer value);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glVertexPointer(GLint,GLenum,GLsizei,const GLvoid*)
     * @param size
     * @param type
     * @param stride
     * @param pointer
     */
    @QtUninvokable
    public final void glVertexPointer(int size, int type, int stride, java.nio.@Nullable Buffer pointer){
        glVertexPointer_native_GLint_GLenum_GLsizei_const_GLvoid_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), size, type, stride, pointer);
    }
    
    @QtUninvokable
    private native void glVertexPointer_native_GLint_GLenum_GLsizei_const_GLvoid_ptr(long __this__nativeId, int size, int type, int stride, java.nio.Buffer pointer);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glViewport(GLint,GLint,GLsizei,GLsizei)
     * @param x
     * @param y
     * @param width
     * @param height
     */
    @QtUninvokable
    public final void glViewport(int x, int y, int width, int height){
        glViewport_native_GLint_GLint_GLsizei_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, width, height);
    }
    
    @QtUninvokable
    private native void glViewport_native_GLint_GLint_GLsizei_GLsizei(long __this__nativeId, int x, int y, int width, int height);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWaitSync(GLsync,GLbitfield,GLuint64)
     * @param sync
     * @param flags
     * @param timeout
     */
    @QtUninvokable
    public final void glWaitSync(io.qt.gui.gl.@Nullable GLsync sync, int flags, long timeout){
        glWaitSync_native___GLsync_ptr_GLbitfield_GLuint64(QtJambi_LibraryUtilities.internal.nativeId(this), QtJambi_LibraryUtilities.internal.checkedNativeId(sync), flags, timeout);
    }
    
    @QtUninvokable
    private native void glWaitSync_native___GLsync_ptr_GLbitfield_GLuint64(long __this__nativeId, long sync, int flags, long timeout);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos2d(GLdouble,GLdouble)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glWindowPos2d(double x, double y){
        glWindowPos2d_native_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glWindowPos2d_native_GLdouble_GLdouble(long __this__nativeId, double x, double y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos2dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glWindowPos2dv(java.nio.@Nullable DoubleBuffer v){
        glWindowPos2dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glWindowPos2dv_native_const_GLdouble_ptr(long __this__nativeId, java.nio.DoubleBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos2f(GLfloat,GLfloat)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glWindowPos2f(float x, float y){
        glWindowPos2f_native_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glWindowPos2f_native_GLfloat_GLfloat(long __this__nativeId, float x, float y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos2fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glWindowPos2fv(java.nio.@Nullable FloatBuffer v){
        glWindowPos2fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glWindowPos2fv_native_const_GLfloat_ptr(long __this__nativeId, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos2i(GLint,GLint)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glWindowPos2i(int x, int y){
        glWindowPos2i_native_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glWindowPos2i_native_GLint_GLint(long __this__nativeId, int x, int y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos2iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glWindowPos2iv(java.nio.@Nullable IntBuffer v){
        glWindowPos2iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glWindowPos2iv_native_const_GLint_ptr(long __this__nativeId, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos2s(GLshort,GLshort)
     * @param x
     * @param y
     */
    @QtUninvokable
    public final void glWindowPos2s(short x, short y){
        glWindowPos2s_native_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), x, y);
    }
    
    @QtUninvokable
    private native void glWindowPos2s_native_GLshort_GLshort(long __this__nativeId, short x, short y);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos2sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glWindowPos2sv(java.nio.@Nullable ShortBuffer v){
        glWindowPos2sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glWindowPos2sv_native_const_GLshort_ptr(long __this__nativeId, java.nio.ShortBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos3d(GLdouble,GLdouble,GLdouble)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glWindowPos3d(double x, double y, double z){
        glWindowPos3d_native_GLdouble_GLdouble_GLdouble(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glWindowPos3d_native_GLdouble_GLdouble_GLdouble(long __this__nativeId, double x, double y, double z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos3dv(const GLdouble*)
     * @param v
     */
    @QtUninvokable
    public final void glWindowPos3dv(java.nio.@Nullable DoubleBuffer v){
        glWindowPos3dv_native_const_GLdouble_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glWindowPos3dv_native_const_GLdouble_ptr(long __this__nativeId, java.nio.DoubleBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos3f(GLfloat,GLfloat,GLfloat)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glWindowPos3f(float x, float y, float z){
        glWindowPos3f_native_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glWindowPos3f_native_GLfloat_GLfloat_GLfloat(long __this__nativeId, float x, float y, float z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos3fv(const GLfloat*)
     * @param v
     */
    @QtUninvokable
    public final void glWindowPos3fv(java.nio.@Nullable FloatBuffer v){
        glWindowPos3fv_native_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glWindowPos3fv_native_const_GLfloat_ptr(long __this__nativeId, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos3i(GLint,GLint,GLint)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glWindowPos3i(int x, int y, int z){
        glWindowPos3i_native_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glWindowPos3i_native_GLint_GLint_GLint(long __this__nativeId, int x, int y, int z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos3iv(const GLint*)
     * @param v
     */
    @QtUninvokable
    public final void glWindowPos3iv(java.nio.@Nullable IntBuffer v){
        glWindowPos3iv_native_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glWindowPos3iv_native_const_GLint_ptr(long __this__nativeId, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos3s(GLshort,GLshort,GLshort)
     * @param x
     * @param y
     * @param z
     */
    @QtUninvokable
    public final void glWindowPos3s(short x, short y, short z){
        glWindowPos3s_native_GLshort_GLshort_GLshort(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, z);
    }
    
    @QtUninvokable
    private native void glWindowPos3s_native_GLshort_GLshort_GLshort(long __this__nativeId, short x, short y, short z);
    
    /**
     * See QOpenGLFunctions_3_3_Compatibility::glWindowPos3sv(const GLshort*)
     * @param v
     */
    @QtUninvokable
    public final void glWindowPos3sv(java.nio.@Nullable ShortBuffer v){
        glWindowPos3sv_native_const_GLshort_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), v);
    }
    
    @QtUninvokable
    private native void glWindowPos3sv_native_const_GLshort_ptr(long __this__nativeId, java.nio.ShortBuffer v);
    
    /**
     * See QAbstractOpenGLFunctions::initializeOpenGLFunctions()
     * @return
     */
    @QtUninvokable
    @Override
    public boolean initializeOpenGLFunctions(){
        return initializeOpenGLFunctions_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native boolean initializeOpenGLFunctions_native(long __this__nativeId);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QOpenGLFunctions_3_3_Compatibility(QPrivateConstructor p) { super(p); } 
    
}