io.qt.opengl.QOpenGLFunctions_1_3 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 1.3 specification
 * Java wrapper for Qt class QOpenGLFunctions_1_3
 */
public class QOpenGLFunctions_1_3 extends io.qt.opengl.QAbstractOpenGLFunctions
{
    
    /**
     * See QOpenGLFunctions_1_3::QOpenGLFunctions_1_3()
     */
    public QOpenGLFunctions_1_3(){
        super((QPrivateConstructor)null);
        initialize_native(this);
    }
    
    private native static void initialize_native(QOpenGLFunctions_1_3 instance);
    
    /**
     * See QOpenGLFunctions_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::glEnd()
     */
    @QtUninvokable
    public final void glEnd(){
        glEnd_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glEnd_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_1_3::glEndList()
     */
    @QtUninvokable
    public final void glEndList(){
        glEndList_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glEndList_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::glFinish()
     */
    @QtUninvokable
    public final void glFinish(){
        glFinish_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glFinish_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_1_3::glFlush()
     */
    @QtUninvokable
    public final void glFlush(){
        glFlush_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glFlush_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::glInitNames()
     */
    @QtUninvokable
    public final void glInitNames(){
        glInitNames_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glInitNames_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::glLoadIdentity()
     */
    @QtUninvokable
    public final void glLoadIdentity(){
        glLoadIdentity_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glLoadIdentity_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::glPopAttrib()
     */
    @QtUninvokable
    public final void glPopAttrib(){
        glPopAttrib_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glPopAttrib_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_1_3::glPopClientAttrib()
     */
    @QtUninvokable
    public final void glPopClientAttrib(){
        glPopClientAttrib_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glPopClientAttrib_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_1_3::glPopMatrix()
     */
    @QtUninvokable
    public final void glPopMatrix(){
        glPopMatrix_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glPopMatrix_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_1_3::glPopName()
     */
    @QtUninvokable
    public final void glPopName(){
        glPopName_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glPopName_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_1_3::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_1_3::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_1_3::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_1_3::glPushMatrix()
     */
    @QtUninvokable
    public final void glPushMatrix(){
        glPushMatrix_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glPushMatrix_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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_1_3::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 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_1_3(QPrivateConstructor p) { super(p); } 
    
}