io.qt.gui.QOpenGLFunctions Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of qtjambi Show documentation
QtJambi base module containing QtCore, QtGui and QtWidgets.
There is a newer version: 6.8.0
package io.qt.gui;

import io.qt.*;


/**
 * Cross-platform access to the OpenGL ES 2.0 API
 * Java wrapper for Qt class QOpenGLFunctions
 */
public class QOpenGLFunctions extends QtObject
    implements java.lang.Cloneable
{
    static {
        QtJambi_LibraryUtilities.initialize();
    }
    
    /**
     * Java wrapper for Qt enum QOpenGLFunctions::OpenGLFeature
     * 
     * @see OpenGLFeatures
     */
    public enum OpenGLFeature implements QtFlagEnumerator {
        /**
         * Representing QOpenGLFunctions::Multitexture
         */
        Multitexture(1),
        /**
         * Representing QOpenGLFunctions::Shaders
         */
        Shaders(2),
        /**
         * Representing QOpenGLFunctions::Buffers
         */
        Buffers(4),
        /**
         * Representing QOpenGLFunctions::Framebuffers
         */
        Framebuffers(8),
        /**
         * Representing QOpenGLFunctions::BlendColor
         */
        BlendColor(16),
        /**
         * Representing QOpenGLFunctions::BlendEquation
         */
        BlendEquation(32),
        /**
         * Representing QOpenGLFunctions::BlendEquationSeparate
         */
        BlendEquationSeparate(64),
        /**
         * Representing QOpenGLFunctions::BlendFuncSeparate
         */
        BlendFuncSeparate(128),
        /**
         * Representing QOpenGLFunctions::BlendSubtract
         */
        BlendSubtract(256),
        /**
         * Representing QOpenGLFunctions::CompressedTextures
         */
        CompressedTextures(512),
        /**
         * Representing QOpenGLFunctions::Multisample
         */
        Multisample(1024),
        /**
         * Representing QOpenGLFunctions::StencilSeparate
         */
        StencilSeparate(2048),
        /**
         * Representing QOpenGLFunctions::NPOTTextures
         */
        NPOTTextures(4096),
        /**
         * Representing QOpenGLFunctions::NPOTTextureRepeat
         */
        NPOTTextureRepeat(8192),
        /**
         * Representing QOpenGLFunctions::FixedFunctionPipeline
         */
        FixedFunctionPipeline(16384),
        /**
         * Representing QOpenGLFunctions::TextureRGFormats
         */
        TextureRGFormats(32768),
        /**
         * Representing QOpenGLFunctions::MultipleRenderTargets
         */
        MultipleRenderTargets(65536),
        /**
         * Representing QOpenGLFunctions::BlendEquationAdvanced
         */
        BlendEquationAdvanced(131072);

        static {
            QtJambi_LibraryUtilities.initialize();
        }

        private OpenGLFeature(int value) {
            this.value = value;
        }

        /**
         * {@inheritDoc}
         */
        public int value() {
            return value;
        }

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        public @NonNull OpenGLFeatures asFlags() {
            return new OpenGLFeatures(value);
        }

        /**
         * Combines this entry with other enum entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull OpenGLFeatures combined(@NonNull OpenGLFeature e) {
            return asFlags().setFlag(e, true);
        }

        /**
         * Excludes other enum entry from a flag of this entry.
         * @param e enum entry
         * @return new flag
         */
        public @NonNull OpenGLFeatures cleared(@NonNull OpenGLFeature e) {
            return asFlags().setFlag(e, false);
        }

        /**
         * Creates a new {@link OpenGLFeatures} from the entries.
         * @param values entries
         * @return new flag
         */
        public static @NonNull OpenGLFeatures flags(@Nullable OpenGLFeature @NonNull... values) {
            return new OpenGLFeatures(values);
        }

        /**
         * Returns the corresponding enum entry for the given value.
         * @param value
         * @return enum entry
         */
        public static @NonNull OpenGLFeature resolve(int value) {
            switch (value) {
            case 1: return Multitexture;
            case 2: return Shaders;
            case 4: return Buffers;
            case 8: return Framebuffers;
            case 16: return BlendColor;
            case 32: return BlendEquation;
            case 64: return BlendEquationSeparate;
            case 128: return BlendFuncSeparate;
            case 256: return BlendSubtract;
            case 512: return CompressedTextures;
            case 1024: return Multisample;
            case 2048: return StencilSeparate;
            case 4096: return NPOTTextures;
            case 8192: return NPOTTextureRepeat;
            case 16384: return FixedFunctionPipeline;
            case 32768: return TextureRGFormats;
            case 65536: return MultipleRenderTargets;
            case 131072: return BlendEquationAdvanced;
            default: throw new QNoSuchEnumValueException(value);
            }
        }


        private final int value;
    }
    
    /**
     * {@link QFlags} type for enum {@link OpenGLFeature}
     */
    public static final class OpenGLFeatures extends QFlags implements Comparable {
        private static final long serialVersionUID = 0x1ba753bec9dc801eL;
        static {
            QtJambi_LibraryUtilities.initialize();
        }

        /**
         * Creates a new OpenGLFeatures where the flags in args are set.
         * @param args enum entries
         */
        public OpenGLFeatures(@Nullable OpenGLFeature @NonNull... args){
            super(args);
        }

        /**
         * Creates a new OpenGLFeatures with given value.
         * @param value
         */
        public OpenGLFeatures(int value) {
            super(value);
        }

        /**
         * Combines this flags with enum entry.
         * @param e enum entry
         * @return new OpenGLFeatures
         */
        @Override
        public final @NonNull OpenGLFeatures combined(@StrictNonNull OpenGLFeature e){
            return new OpenGLFeatures(value() | e.value());
        }

        /**
         * Sets the flag e
         * @param e enum entry
         * @return this
         */
        public final @NonNull OpenGLFeatures setFlag(@Nullable OpenGLFeature e){
            return setFlag(e, true);
        }

        /**
         * Sets or clears the flag flag
         * @param e enum entry
         * @param on set (true) or clear (false)
         * @return this
         */
        public final @NonNull OpenGLFeatures setFlag(@Nullable OpenGLFeature e, boolean on){
            if (on) {
            	setValue(value() | e.value());
            }else {
            	setValue(value() & ~e.value());
            }
            return this;
        }

        /**
         * Returns an array of flag objects represented by this OpenGLFeatures.
         * @return array of enum entries
         */
        @Override
        public final @NonNull OpenGLFeature @NonNull[] flags(){
            return super.flags(OpenGLFeature.values());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final @NonNull OpenGLFeatures clone(){
            return new OpenGLFeatures(value());
        }

        /**
         * {@inheritDoc}
         */
        @Override
        public final int compareTo(@StrictNonNull OpenGLFeatures other){
            return Integer.compare(value(), other.value());
        }
    }
    
    
    /**
     * See QOpenGLFunctions::QOpenGLFunctions()
     */
    public QOpenGLFunctions(){
        super((QPrivateConstructor)null);
        initialize_native(this);
    }
    
    private native static void initialize_native(QOpenGLFunctions instance);
    
    /**
     * See QOpenGLFunctions::QOpenGLFunctions(QOpenGLContext*)
     */
    public QOpenGLFunctions(io.qt.gui.@Nullable QOpenGLContext context){
        super((QPrivateConstructor)null);
        initialize_native(this, context);
    }
    
    private native static void initialize_native(QOpenGLFunctions instance, io.qt.gui.QOpenGLContext context);
    
    /**
     * See QOpenGLFunctions::QOpenGLFunctions(QOpenGLFunctions)
     */
    public QOpenGLFunctions(io.qt.gui.@StrictNonNull QOpenGLFunctions other){
        super((QPrivateConstructor)null);
        java.util.Objects.requireNonNull(other, "Argument 'other': null not expected.");
        initialize_native(this, other);
    }
    
    private native static void initialize_native(QOpenGLFunctions instance, io.qt.gui.QOpenGLFunctions other);
    
    /**
     * See QOpenGLFunctions::glActiveTexture(GLenum)
     */
    @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::glAttachShader(GLuint,GLuint)
     */
    @QtUninvokable
    public final void glAttachShader(int program, int shader){
        glAttachShader_native_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program, shader);
    }
    
    @QtUninvokable
    private native void glAttachShader_native_GLuint_GLuint(long __this__nativeId, int program, int shader);
    
    /**
     * See QOpenGLFunctions::glBindAttribLocation(GLuint,GLuint,const char*)
     */
    @QtUninvokable
    public final void glBindAttribLocation(int program, int index, java.lang.@Nullable String name){
        glBindAttribLocation_native_GLuint_GLuint_const_char_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, index, name);
    }
    
    @QtUninvokable
    private native void glBindAttribLocation_native_GLuint_GLuint_const_char_ptr(long __this__nativeId, int program, int index, java.lang.String name);
    
    /**
     * See QOpenGLFunctions::glBindBuffer(GLenum,GLuint)
     */
    @QtUninvokable
    public final void glBindBuffer(int target, int buffer){
        glBindBuffer_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, buffer);
    }
    
    @QtUninvokable
    private native void glBindBuffer_native_GLenum_GLuint(long __this__nativeId, int target, int buffer);
    
    /**
     * See QOpenGLFunctions::glBindFramebuffer(GLenum,GLuint)
     */
    @QtUninvokable
    public final void glBindFramebuffer(int target, int framebuffer){
        glBindFramebuffer_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, framebuffer);
    }
    
    @QtUninvokable
    private native void glBindFramebuffer_native_GLenum_GLuint(long __this__nativeId, int target, int framebuffer);
    
    /**
     * See QOpenGLFunctions::glBindRenderbuffer(GLenum,GLuint)
     */
    @QtUninvokable
    public final void glBindRenderbuffer(int target, int renderbuffer){
        glBindRenderbuffer_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, renderbuffer);
    }
    
    @QtUninvokable
    private native void glBindRenderbuffer_native_GLenum_GLuint(long __this__nativeId, int target, int renderbuffer);
    
    /**
     * See QOpenGLFunctions::glBindTexture(GLenum,GLuint)
     */
    @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::glBlendColor(GLclampf,GLclampf,GLclampf,GLclampf)
     */
    @QtUninvokable
    public final void glBlendColor(float red, float green, float blue, float alpha){
        glBlendColor_native_GLclampf_GLclampf_GLclampf_GLclampf(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue, alpha);
    }
    
    @QtUninvokable
    private native void glBlendColor_native_GLclampf_GLclampf_GLclampf_GLclampf(long __this__nativeId, float red, float green, float blue, float alpha);
    
    /**
     * See QOpenGLFunctions::glBlendEquation(GLenum)
     */
    @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::glBlendEquationSeparate(GLenum,GLenum)
     */
    @QtUninvokable
    public final void glBlendEquationSeparate(int modeRGB, int modeAlpha){
        glBlendEquationSeparate_native_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), modeRGB, modeAlpha);
    }
    
    @QtUninvokable
    private native void glBlendEquationSeparate_native_GLenum_GLenum(long __this__nativeId, int modeRGB, int modeAlpha);
    
    /**
     * See QOpenGLFunctions::glBlendFunc(GLenum,GLenum)
     */
    @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::glBlendFuncSeparate(GLenum,GLenum,GLenum,GLenum)
     */
    @QtUninvokable
    public final void glBlendFuncSeparate(int srcRGB, int dstRGB, int srcAlpha, int dstAlpha){
        glBlendFuncSeparate_native_GLenum_GLenum_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), srcRGB, dstRGB, srcAlpha, dstAlpha);
    }
    
    @QtUninvokable
    private native void glBlendFuncSeparate_native_GLenum_GLenum_GLenum_GLenum(long __this__nativeId, int srcRGB, int dstRGB, int srcAlpha, int dstAlpha);
    
    /**
     * See QOpenGLFunctions::glBufferData(GLenum,qopengl_GLsizeiptr,const void*,GLenum)
     */
    @QtUninvokable
    public final void glBufferData(int target, long size, java.nio.@Nullable Buffer data, int usage){
        glBufferData_native_GLenum_qopengl_GLsizeiptr_const_void_ptr_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target, size, data, usage);
    }
    
    @QtUninvokable
    private native void glBufferData_native_GLenum_qopengl_GLsizeiptr_const_void_ptr_GLenum(long __this__nativeId, int target, long size, java.nio.Buffer data, int usage);
    
    /**
     * See QOpenGLFunctions::glBufferSubData(GLenum,qopengl_GLintptr,qopengl_GLsizeiptr,const void*)
     */
    @QtUninvokable
    public final void glBufferSubData(int target, long offset, long size, java.nio.@Nullable Buffer data){
        glBufferSubData_native_GLenum_qopengl_GLintptr_qopengl_GLsizeiptr_const_void_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, offset, size, data);
    }
    
    @QtUninvokable
    private native void glBufferSubData_native_GLenum_qopengl_GLintptr_qopengl_GLsizeiptr_const_void_ptr(long __this__nativeId, int target, long offset, long size, java.nio.Buffer data);
    
    /**
     * See QOpenGLFunctions::glCheckFramebufferStatus(GLenum)
     */
    @QtUninvokable
    public final int glCheckFramebufferStatus(int target){
        return glCheckFramebufferStatus_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target);
    }
    
    @QtUninvokable
    private native int glCheckFramebufferStatus_native_GLenum(long __this__nativeId, int target);
    
    /**
     * See QOpenGLFunctions::glClear(GLbitfield)
     */
    @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::glClearColor(GLclampf,GLclampf,GLclampf,GLclampf)
     */
    @QtUninvokable
    public final void glClearColor(float red, float green, float blue, float alpha){
        glClearColor_native_GLclampf_GLclampf_GLclampf_GLclampf(QtJambi_LibraryUtilities.internal.nativeId(this), red, green, blue, alpha);
    }
    
    @QtUninvokable
    private native void glClearColor_native_GLclampf_GLclampf_GLclampf_GLclampf(long __this__nativeId, float red, float green, float blue, float alpha);
    
    /**
     * See QOpenGLFunctions::glClearDepthf(GLclampf)
     */
    @QtUninvokable
    public final void glClearDepthf(float depth){
        glClearDepthf_native_GLclampf(QtJambi_LibraryUtilities.internal.nativeId(this), depth);
    }
    
    @QtUninvokable
    private native void glClearDepthf_native_GLclampf(long __this__nativeId, float depth);
    
    /**
     * See QOpenGLFunctions::glClearStencil(GLint)
     */
    @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::glColorMask(GLboolean,GLboolean,GLboolean,GLboolean)
     */
    @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::glCompileShader(GLuint)
     */
    @QtUninvokable
    public final void glCompileShader(int shader){
        glCompileShader_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), shader);
    }
    
    @QtUninvokable
    private native void glCompileShader_native_GLuint(long __this__nativeId, int shader);
    
    /**
     * See QOpenGLFunctions::glCompressedTexImage2D(GLenum,GLint,GLenum,GLsizei,GLsizei,GLint,GLsizei,const void*)
     */
    @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_void_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_void_ptr(long __this__nativeId, int target, int level, int internalformat, int width, int height, int border, int imageSize, java.nio.Buffer data);
    
    /**
     * See QOpenGLFunctions::glCompressedTexSubImage2D(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLsizei,const void*)
     */
    @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_void_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_void_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::glCopyTexImage2D(GLenum,GLint,GLenum,GLint,GLint,GLsizei,GLsizei,GLint)
     */
    @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::glCopyTexSubImage2D(GLenum,GLint,GLint,GLint,GLint,GLint,GLsizei,GLsizei)
     */
    @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::glCreateProgram()
     */
    @QtUninvokable
    public final int glCreateProgram(){
        return glCreateProgram_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int glCreateProgram_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions::glCreateShader(GLenum)
     */
    @QtUninvokable
    public final int glCreateShader(int type){
        return glCreateShader_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), type);
    }
    
    @QtUninvokable
    private native int glCreateShader_native_GLenum(long __this__nativeId, int type);
    
    /**
     * See QOpenGLFunctions::glCullFace(GLenum)
     */
    @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::glDeleteBuffers(GLsizei,const GLuint*)
     */
    @QtUninvokable
    public final void glDeleteBuffers(int n, java.nio.@Nullable IntBuffer buffers){
        glDeleteBuffers_native_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, buffers);
    }
    
    @QtUninvokable
    private native void glDeleteBuffers_native_GLsizei_const_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer buffers);
    
    /**
     * See QOpenGLFunctions::glDeleteFramebuffers(GLsizei,const GLuint*)
     */
    @QtUninvokable
    public final void glDeleteFramebuffers(int n, java.nio.@Nullable IntBuffer framebuffers){
        glDeleteFramebuffers_native_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, framebuffers);
    }
    
    @QtUninvokable
    private native void glDeleteFramebuffers_native_GLsizei_const_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer framebuffers);
    
    /**
     * See QOpenGLFunctions::glDeleteProgram(GLuint)
     */
    @QtUninvokable
    public final void glDeleteProgram(int program){
        glDeleteProgram_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program);
    }
    
    @QtUninvokable
    private native void glDeleteProgram_native_GLuint(long __this__nativeId, int program);
    
    /**
     * See QOpenGLFunctions::glDeleteRenderbuffers(GLsizei,const GLuint*)
     */
    @QtUninvokable
    public final void glDeleteRenderbuffers(int n, java.nio.@Nullable IntBuffer renderbuffers){
        glDeleteRenderbuffers_native_GLsizei_const_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, renderbuffers);
    }
    
    @QtUninvokable
    private native void glDeleteRenderbuffers_native_GLsizei_const_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer renderbuffers);
    
    /**
     * See QOpenGLFunctions::glDeleteShader(GLuint)
     */
    @QtUninvokable
    public final void glDeleteShader(int shader){
        glDeleteShader_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), shader);
    }
    
    @QtUninvokable
    private native void glDeleteShader_native_GLuint(long __this__nativeId, int shader);
    
    /**
     * See QOpenGLFunctions::glDeleteTextures(GLsizei,const GLuint*)
     */
    @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::glDepthFunc(GLenum)
     */
    @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::glDepthMask(GLboolean)
     */
    @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::glDepthRangef(GLclampf,GLclampf)
     */
    @QtUninvokable
    public final void glDepthRangef(float zNear, float zFar){
        glDepthRangef_native_GLclampf_GLclampf(QtJambi_LibraryUtilities.internal.nativeId(this), zNear, zFar);
    }
    
    @QtUninvokable
    private native void glDepthRangef_native_GLclampf_GLclampf(long __this__nativeId, float zNear, float zFar);
    
    /**
     * See QOpenGLFunctions::glDetachShader(GLuint,GLuint)
     */
    @QtUninvokable
    public final void glDetachShader(int program, int shader){
        glDetachShader_native_GLuint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program, shader);
    }
    
    @QtUninvokable
    private native void glDetachShader_native_GLuint_GLuint(long __this__nativeId, int program, int shader);
    
    /**
     * See QOpenGLFunctions::glDisable(GLenum)
     */
    @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::glDisableVertexAttribArray(GLuint)
     */
    @QtUninvokable
    public final void glDisableVertexAttribArray(int index){
        glDisableVertexAttribArray_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index);
    }
    
    @QtUninvokable
    private native void glDisableVertexAttribArray_native_GLuint(long __this__nativeId, int index);
    
    /**
     * See QOpenGLFunctions::glDrawArrays(GLenum,GLint,GLsizei)
     */
    @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::glDrawElements(GLenum,GLsizei,GLenum,const GLvoid*)
     */
    @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::glEnable(GLenum)
     */
    @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::glEnableVertexAttribArray(GLuint)
     */
    @QtUninvokable
    public final void glEnableVertexAttribArray(int index){
        glEnableVertexAttribArray_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), index);
    }
    
    @QtUninvokable
    private native void glEnableVertexAttribArray_native_GLuint(long __this__nativeId, int index);
    
    /**
     * See QOpenGLFunctions::glFinish()
     */
    @QtUninvokable
    public final void glFinish(){
        glFinish_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glFinish_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions::glFlush()
     */
    @QtUninvokable
    public final void glFlush(){
        glFlush_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glFlush_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions::glFramebufferRenderbuffer(GLenum,GLenum,GLenum,GLuint)
     */
    @QtUninvokable
    public final void glFramebufferRenderbuffer(int target, int attachment, int renderbuffertarget, int renderbuffer){
        glFramebufferRenderbuffer_native_GLenum_GLenum_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), target, attachment, renderbuffertarget, renderbuffer);
    }
    
    @QtUninvokable
    private native void glFramebufferRenderbuffer_native_GLenum_GLenum_GLenum_GLuint(long __this__nativeId, int target, int attachment, int renderbuffertarget, int renderbuffer);
    
    /**
     * See QOpenGLFunctions::glFramebufferTexture2D(GLenum,GLenum,GLenum,GLuint,GLint)
     */
    @QtUninvokable
    public final void glFramebufferTexture2D(int target, int attachment, int textarget, int texture, int level){
        glFramebufferTexture2D_native_GLenum_GLenum_GLenum_GLuint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), target, attachment, textarget, texture, level);
    }
    
    @QtUninvokable
    private native void glFramebufferTexture2D_native_GLenum_GLenum_GLenum_GLuint_GLint(long __this__nativeId, int target, int attachment, int textarget, int texture, int level);
    
    /**
     * See QOpenGLFunctions::glFrontFace(GLenum)
     */
    @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::glGenBuffers(GLsizei,GLuint*)
     */
    @QtUninvokable
    public final void glGenBuffers(int n, java.nio.@Nullable IntBuffer buffers){
        glGenBuffers_native_GLsizei_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, buffers);
    }
    
    @QtUninvokable
    private native void glGenBuffers_native_GLsizei_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer buffers);
    
    /**
     * See QOpenGLFunctions::glGenFramebuffers(GLsizei,GLuint*)
     */
    @QtUninvokable
    public final void glGenFramebuffers(int n, java.nio.@Nullable IntBuffer framebuffers){
        glGenFramebuffers_native_GLsizei_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, framebuffers);
    }
    
    @QtUninvokable
    private native void glGenFramebuffers_native_GLsizei_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer framebuffers);
    
    /**
     * See QOpenGLFunctions::glGenRenderbuffers(GLsizei,GLuint*)
     */
    @QtUninvokable
    public final void glGenRenderbuffers(int n, java.nio.@Nullable IntBuffer renderbuffers){
        glGenRenderbuffers_native_GLsizei_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), n, renderbuffers);
    }
    
    @QtUninvokable
    private native void glGenRenderbuffers_native_GLsizei_GLuint_ptr(long __this__nativeId, int n, java.nio.IntBuffer renderbuffers);
    
    /**
     * See QOpenGLFunctions::glGenTextures(GLsizei,GLuint*)
     */
    @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::glGenerateMipmap(GLenum)
     */
    @QtUninvokable
    public final void glGenerateMipmap(int target){
        glGenerateMipmap_native_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), target);
    }
    
    @QtUninvokable
    private native void glGenerateMipmap_native_GLenum(long __this__nativeId, int target);
    
    /**
     * See QOpenGLFunctions::glGetActiveAttrib(GLuint,GLuint,GLsizei,GLsizei*,GLint*,GLenum*,char*)
     */
    @QtUninvokable
    public final void glGetActiveAttrib(int program, int index, int bufsize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable IntBuffer size, java.nio.@Nullable IntBuffer type, java.nio.@Nullable ByteBuffer name){
        glGetActiveAttrib_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLint_ptr_GLenum_ptr_char_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, index, bufsize, length, size, type, name);
    }
    
    @QtUninvokable
    private native void glGetActiveAttrib_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLint_ptr_GLenum_ptr_char_ptr(long __this__nativeId, int program, int index, int bufsize, java.nio.IntBuffer length, java.nio.IntBuffer size, java.nio.IntBuffer type, java.nio.ByteBuffer name);
    
    /**
     * See QOpenGLFunctions::glGetActiveUniform(GLuint,GLuint,GLsizei,GLsizei*,GLint*,GLenum*,char*)
     */
    @QtUninvokable
    public final void glGetActiveUniform(int program, int index, int bufsize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable IntBuffer size, java.nio.@Nullable IntBuffer type, java.nio.@Nullable ByteBuffer name){
        glGetActiveUniform_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLint_ptr_GLenum_ptr_char_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, index, bufsize, length, size, type, name);
    }
    
    @QtUninvokable
    private native void glGetActiveUniform_native_GLuint_GLuint_GLsizei_GLsizei_ptr_GLint_ptr_GLenum_ptr_char_ptr(long __this__nativeId, int program, int index, int bufsize, java.nio.IntBuffer length, java.nio.IntBuffer size, java.nio.IntBuffer type, java.nio.ByteBuffer name);
    
    /**
     * See QOpenGLFunctions::glGetAttachedShaders(GLuint,GLsizei,GLsizei*,GLuint*)
     */
    @QtUninvokable
    public final void glGetAttachedShaders(int program, int maxcount, java.nio.@Nullable IntBuffer count, java.nio.@Nullable IntBuffer shaders){
        glGetAttachedShaders_native_GLuint_GLsizei_GLsizei_ptr_GLuint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, maxcount, count, shaders);
    }
    
    @QtUninvokable
    private native void glGetAttachedShaders_native_GLuint_GLsizei_GLsizei_ptr_GLuint_ptr(long __this__nativeId, int program, int maxcount, java.nio.IntBuffer count, java.nio.IntBuffer shaders);
    
    /**
     * See QOpenGLFunctions::glGetAttribLocation(GLuint,const char*)
     */
    @QtUninvokable
    public final int glGetAttribLocation(int program, java.lang.@Nullable String name){
        return glGetAttribLocation_native_GLuint_const_char_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, name);
    }
    
    @QtUninvokable
    private native int glGetAttribLocation_native_GLuint_const_char_ptr(long __this__nativeId, int program, java.lang.String name);
    
    /**
     * See QOpenGLFunctions::glGetBooleanv(GLenum,GLboolean*)
     */
    @QtUninvokable
    public final void glGetBooleanv(int pname, java.nio.@Nullable Buffer params){
        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, java.nio.Buffer params);
    
    /**
     * See QOpenGLFunctions::glGetBufferParameteriv(GLenum,GLenum,GLint*)
     */
    @QtUninvokable
    public final void glGetBufferParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetBufferParameteriv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetBufferParameteriv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions::glGetError()
     */
    @QtUninvokable
    public final int glGetError(){
        return glGetError_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native int glGetError_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions::glGetFloatv(GLenum,GLfloat*)
     */
    @QtUninvokable
    public final void glGetFloatv(int pname, java.nio.@Nullable FloatBuffer params){
        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, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions::glGetFramebufferAttachmentParameteriv(GLenum,GLenum,GLenum,GLint*)
     */
    @QtUninvokable
    public final void glGetFramebufferAttachmentParameteriv(int target, int attachment, int pname, java.nio.@Nullable IntBuffer params){
        glGetFramebufferAttachmentParameteriv_native_GLenum_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, attachment, pname, params);
    }
    
    @QtUninvokable
    private native void glGetFramebufferAttachmentParameteriv_native_GLenum_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int attachment, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions::glGetIntegerv(GLenum,GLint*)
     */
    @QtUninvokable
    public final void glGetIntegerv(int pname, java.nio.@Nullable IntBuffer params){
        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, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions::glGetProgramInfoLog(GLuint,GLsizei,GLsizei*,char*)
     */
    @QtUninvokable
    public final void glGetProgramInfoLog(int program, int bufsize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable ByteBuffer infolog){
        glGetProgramInfoLog_native_GLuint_GLsizei_GLsizei_ptr_char_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, bufsize, length, infolog);
    }
    
    @QtUninvokable
    private native void glGetProgramInfoLog_native_GLuint_GLsizei_GLsizei_ptr_char_ptr(long __this__nativeId, int program, int bufsize, java.nio.IntBuffer length, java.nio.ByteBuffer infolog);
    
    /**
     * See QOpenGLFunctions::glGetProgramiv(GLuint,GLenum,GLint*)
     */
    @QtUninvokable
    public final void glGetProgramiv(int program, int pname, java.nio.@Nullable IntBuffer params){
        glGetProgramiv_native_GLuint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, pname, params);
    }
    
    @QtUninvokable
    private native void glGetProgramiv_native_GLuint_GLenum_GLint_ptr(long __this__nativeId, int program, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions::glGetRenderbufferParameteriv(GLenum,GLenum,GLint*)
     */
    @QtUninvokable
    public final void glGetRenderbufferParameteriv(int target, int pname, java.nio.@Nullable IntBuffer params){
        glGetRenderbufferParameteriv_native_GLenum_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), target, pname, params);
    }
    
    @QtUninvokable
    private native void glGetRenderbufferParameteriv_native_GLenum_GLenum_GLint_ptr(long __this__nativeId, int target, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions::glGetShaderInfoLog(GLuint,GLsizei,GLsizei*,char*)
     */
    @QtUninvokable
    public final void glGetShaderInfoLog(int shader, int bufsize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable ByteBuffer infolog){
        glGetShaderInfoLog_native_GLuint_GLsizei_GLsizei_ptr_char_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), shader, bufsize, length, infolog);
    }
    
    @QtUninvokable
    private native void glGetShaderInfoLog_native_GLuint_GLsizei_GLsizei_ptr_char_ptr(long __this__nativeId, int shader, int bufsize, java.nio.IntBuffer length, java.nio.ByteBuffer infolog);
    
    /**
     * See QOpenGLFunctions::glGetShaderPrecisionFormat(GLenum,GLenum,GLint*,GLint*)
     */
    @QtUninvokable
    public final void glGetShaderPrecisionFormat(int shadertype, int precisiontype, java.nio.@Nullable IntBuffer range, java.nio.@Nullable IntBuffer precision){
        glGetShaderPrecisionFormat_native_GLenum_GLenum_GLint_ptr_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), shadertype, precisiontype, range, precision);
    }
    
    @QtUninvokable
    private native void glGetShaderPrecisionFormat_native_GLenum_GLenum_GLint_ptr_GLint_ptr(long __this__nativeId, int shadertype, int precisiontype, java.nio.IntBuffer range, java.nio.IntBuffer precision);
    
    /**
     * See QOpenGLFunctions::glGetShaderSource(GLuint,GLsizei,GLsizei*,char*)
     */
    @QtUninvokable
    public final void glGetShaderSource(int shader, int bufsize, java.nio.@Nullable IntBuffer length, java.nio.@Nullable ByteBuffer source){
        glGetShaderSource_native_GLuint_GLsizei_GLsizei_ptr_char_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), shader, bufsize, length, source);
    }
    
    @QtUninvokable
    private native void glGetShaderSource_native_GLuint_GLsizei_GLsizei_ptr_char_ptr(long __this__nativeId, int shader, int bufsize, java.nio.IntBuffer length, java.nio.ByteBuffer source);
    
    /**
     * See QOpenGLFunctions::glGetShaderiv(GLuint,GLenum,GLint*)
     */
    @QtUninvokable
    public final void glGetShaderiv(int shader, int pname, java.nio.@Nullable IntBuffer params){
        glGetShaderiv_native_GLuint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), shader, pname, params);
    }
    
    @QtUninvokable
    private native void glGetShaderiv_native_GLuint_GLenum_GLint_ptr(long __this__nativeId, int shader, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions::glGetString(GLenum)
     */
    @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::glGetTexParameterfv(GLenum,GLenum,GLfloat*)
     */
    @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::glGetTexParameteriv(GLenum,GLenum,GLint*)
     */
    @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::glGetUniformLocation(GLuint,const char*)
     */
    @QtUninvokable
    public final int glGetUniformLocation(int program, java.lang.@Nullable String name){
        return glGetUniformLocation_native_GLuint_const_char_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, name);
    }
    
    @QtUninvokable
    private native int glGetUniformLocation_native_GLuint_const_char_ptr(long __this__nativeId, int program, java.lang.String name);
    
    /**
     * See QOpenGLFunctions::glGetUniformfv(GLuint,GLint,GLfloat*)
     */
    @QtUninvokable
    public final void glGetUniformfv(int program, int location, java.nio.@Nullable FloatBuffer params){
        glGetUniformfv_native_GLuint_GLint_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, location, params);
    }
    
    @QtUninvokable
    private native void glGetUniformfv_native_GLuint_GLint_GLfloat_ptr(long __this__nativeId, int program, int location, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions::glGetUniformiv(GLuint,GLint,GLint*)
     */
    @QtUninvokable
    public final void glGetUniformiv(int program, int location, java.nio.@Nullable IntBuffer params){
        glGetUniformiv_native_GLuint_GLint_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), program, location, params);
    }
    
    @QtUninvokable
    private native void glGetUniformiv_native_GLuint_GLint_GLint_ptr(long __this__nativeId, int program, int location, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions::glGetVertexAttribPointerv(GLuint,GLenum,void**)
     */
    @QtUninvokable
    public final void glGetVertexAttribPointerv(int index, int pname, java.nio.@Nullable Buffer[] pointer){
        glGetVertexAttribPointerv_native_GLuint_GLenum_void_ptr_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, pname, pointer);
    }
    
    @QtUninvokable
    private native void glGetVertexAttribPointerv_native_GLuint_GLenum_void_ptr_ptr(long __this__nativeId, int index, int pname, java.nio.Buffer[] pointer);
    
    /**
     * See QOpenGLFunctions::glGetVertexAttribfv(GLuint,GLenum,GLfloat*)
     */
    @QtUninvokable
    public final void glGetVertexAttribfv(int index, int pname, java.nio.@Nullable FloatBuffer params){
        glGetVertexAttribfv_native_GLuint_GLenum_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, pname, params);
    }
    
    @QtUninvokable
    private native void glGetVertexAttribfv_native_GLuint_GLenum_GLfloat_ptr(long __this__nativeId, int index, int pname, java.nio.FloatBuffer params);
    
    /**
     * See QOpenGLFunctions::glGetVertexAttribiv(GLuint,GLenum,GLint*)
     */
    @QtUninvokable
    public final void glGetVertexAttribiv(int index, int pname, java.nio.@Nullable IntBuffer params){
        glGetVertexAttribiv_native_GLuint_GLenum_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), index, pname, params);
    }
    
    @QtUninvokable
    private native void glGetVertexAttribiv_native_GLuint_GLenum_GLint_ptr(long __this__nativeId, int index, int pname, java.nio.IntBuffer params);
    
    /**
     * See QOpenGLFunctions::glHint(GLenum,GLenum)
     */
    @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::glIsBuffer(GLuint)
     */
    @QtUninvokable
    public final boolean glIsBuffer(int buffer){
        return glIsBuffer_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), buffer);
    }
    
    @QtUninvokable
    private native boolean glIsBuffer_native_GLuint(long __this__nativeId, int buffer);
    
    /**
     * See QOpenGLFunctions::glIsEnabled(GLenum)
     */
    @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::glIsFramebuffer(GLuint)
     */
    @QtUninvokable
    public final boolean glIsFramebuffer(int framebuffer){
        return glIsFramebuffer_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), framebuffer);
    }
    
    @QtUninvokable
    private native boolean glIsFramebuffer_native_GLuint(long __this__nativeId, int framebuffer);
    
    /**
     * See QOpenGLFunctions::glIsProgram(GLuint)
     */
    @QtUninvokable
    public final boolean glIsProgram(int program){
        return glIsProgram_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program);
    }
    
    @QtUninvokable
    private native boolean glIsProgram_native_GLuint(long __this__nativeId, int program);
    
    /**
     * See QOpenGLFunctions::glIsRenderbuffer(GLuint)
     */
    @QtUninvokable
    public final boolean glIsRenderbuffer(int renderbuffer){
        return glIsRenderbuffer_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), renderbuffer);
    }
    
    @QtUninvokable
    private native boolean glIsRenderbuffer_native_GLuint(long __this__nativeId, int renderbuffer);
    
    /**
     * See QOpenGLFunctions::glIsShader(GLuint)
     */
    @QtUninvokable
    public final boolean glIsShader(int shader){
        return glIsShader_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), shader);
    }
    
    @QtUninvokable
    private native boolean glIsShader_native_GLuint(long __this__nativeId, int shader);
    
    /**
     * See QOpenGLFunctions::glIsTexture(GLuint)
     */
    @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::glLineWidth(GLfloat)
     */
    @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::glLinkProgram(GLuint)
     */
    @QtUninvokable
    public final void glLinkProgram(int program){
        glLinkProgram_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program);
    }
    
    @QtUninvokable
    private native void glLinkProgram_native_GLuint(long __this__nativeId, int program);
    
    /**
     * See QOpenGLFunctions::glPixelStorei(GLenum,GLint)
     */
    @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::glPolygonOffset(GLfloat,GLfloat)
     */
    @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::glReadPixels(GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,GLvoid*)
     */
    @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::glReleaseShaderCompiler()
     */
    @QtUninvokable
    public final void glReleaseShaderCompiler(){
        glReleaseShaderCompiler_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void glReleaseShaderCompiler_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions::glRenderbufferStorage(GLenum,GLenum,GLsizei,GLsizei)
     */
    @QtUninvokable
    public final void glRenderbufferStorage(int target, int internalformat, int width, int height){
        glRenderbufferStorage_native_GLenum_GLenum_GLsizei_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), target, internalformat, width, height);
    }
    
    @QtUninvokable
    private native void glRenderbufferStorage_native_GLenum_GLenum_GLsizei_GLsizei(long __this__nativeId, int target, int internalformat, int width, int height);
    
    /**
     * See QOpenGLFunctions::glSampleCoverage(GLclampf,GLboolean)
     */
    @QtUninvokable
    public final void glSampleCoverage(float value, boolean invert){
        glSampleCoverage_native_GLclampf_GLboolean(QtJambi_LibraryUtilities.internal.nativeId(this), value, invert);
    }
    
    @QtUninvokable
    private native void glSampleCoverage_native_GLclampf_GLboolean(long __this__nativeId, float value, boolean invert);
    
    /**
     * See QOpenGLFunctions::glScissor(GLint,GLint,GLsizei,GLsizei)
     */
    @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::glShaderBinary(GLint,const GLuint*,GLenum,const void*,GLint)
     */
    @QtUninvokable
    public final void glShaderBinary(int n, java.nio.@Nullable IntBuffer shaders, int binaryformat, java.nio.@Nullable Buffer binary, int length){
        glShaderBinary_native_GLint_const_GLuint_ptr_GLenum_const_void_ptr_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), n, shaders, binaryformat, binary, length);
    }
    
    @QtUninvokable
    private native void glShaderBinary_native_GLint_const_GLuint_ptr_GLenum_const_void_ptr_GLint(long __this__nativeId, int n, java.nio.IntBuffer shaders, int binaryformat, java.nio.Buffer binary, int length);
    
    /**
     * See QOpenGLFunctions::glShaderSource(GLuint,GLsizei,const char**,const GLint*)
     */
    @QtUninvokable
    public final void glShaderSource(int shader, java.lang.String[] string){
        glShaderSource_native_GLuint_GLsizei_const_char_ptr_ptr_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), shader, string);
    }
    
    @QtUninvokable
    private native void glShaderSource_native_GLuint_GLsizei_const_char_ptr_ptr_const_GLint_ptr(long __this__nativeId, int shader, java.lang.String[] string);
    
    /**
     * See QOpenGLFunctions::glStencilFunc(GLenum,GLint,GLuint)
     */
    @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::glStencilFuncSeparate(GLenum,GLenum,GLint,GLuint)
     */
    @QtUninvokable
    public final void glStencilFuncSeparate(int face, int func, int ref, int mask){
        glStencilFuncSeparate_native_GLenum_GLenum_GLint_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), face, func, ref, mask);
    }
    
    @QtUninvokable
    private native void glStencilFuncSeparate_native_GLenum_GLenum_GLint_GLuint(long __this__nativeId, int face, int func, int ref, int mask);
    
    /**
     * See QOpenGLFunctions::glStencilMask(GLuint)
     */
    @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::glStencilMaskSeparate(GLenum,GLuint)
     */
    @QtUninvokable
    public final void glStencilMaskSeparate(int face, int mask){
        glStencilMaskSeparate_native_GLenum_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), face, mask);
    }
    
    @QtUninvokable
    private native void glStencilMaskSeparate_native_GLenum_GLuint(long __this__nativeId, int face, int mask);
    
    /**
     * See QOpenGLFunctions::glStencilOp(GLenum,GLenum,GLenum)
     */
    @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::glStencilOpSeparate(GLenum,GLenum,GLenum,GLenum)
     */
    @QtUninvokable
    public final void glStencilOpSeparate(int face, int fail, int zfail, int zpass){
        glStencilOpSeparate_native_GLenum_GLenum_GLenum_GLenum(QtJambi_LibraryUtilities.internal.nativeId(this), face, fail, zfail, zpass);
    }
    
    @QtUninvokable
    private native void glStencilOpSeparate_native_GLenum_GLenum_GLenum_GLenum(long __this__nativeId, int face, int fail, int zfail, int zpass);
    
    /**
     * See QOpenGLFunctions::glTexImage2D(GLenum,GLint,GLint,GLsizei,GLsizei,GLint,GLenum,GLenum,const GLvoid*)
     */
    @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::glTexParameterf(GLenum,GLenum,GLfloat)
     */
    @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::glTexParameterfv(GLenum,GLenum,const GLfloat*)
     */
    @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::glTexParameteri(GLenum,GLenum,GLint)
     */
    @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::glTexParameteriv(GLenum,GLenum,const GLint*)
     */
    @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::glTexSubImage2D(GLenum,GLint,GLint,GLint,GLsizei,GLsizei,GLenum,GLenum,const GLvoid*)
     */
    @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::glUniform1f(GLint,GLfloat)
     */
    @QtUninvokable
    public final void glUniform1f(int location, float x){
        glUniform1f_native_GLint_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), location, x);
    }
    
    @QtUninvokable
    private native void glUniform1f_native_GLint_GLfloat(long __this__nativeId, int location, float x);
    
    /**
     * See QOpenGLFunctions::glUniform1fv(GLint,GLsizei,const GLfloat*)
     */
    @QtUninvokable
    public final void glUniform1fv(int location, int count, java.nio.@Nullable FloatBuffer v){
        glUniform1fv_native_GLint_GLsizei_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, v);
    }
    
    @QtUninvokable
    private native void glUniform1fv_native_GLint_GLsizei_const_GLfloat_ptr(long __this__nativeId, int location, int count, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions::glUniform1i(GLint,GLint)
     */
    @QtUninvokable
    public final void glUniform1i(int location, int x){
        glUniform1i_native_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), location, x);
    }
    
    @QtUninvokable
    private native void glUniform1i_native_GLint_GLint(long __this__nativeId, int location, int x);
    
    /**
     * See QOpenGLFunctions::glUniform1iv(GLint,GLsizei,const GLint*)
     */
    @QtUninvokable
    public final void glUniform1iv(int location, int count, java.nio.@Nullable IntBuffer v){
        glUniform1iv_native_GLint_GLsizei_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, v);
    }
    
    @QtUninvokable
    private native void glUniform1iv_native_GLint_GLsizei_const_GLint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions::glUniform2f(GLint,GLfloat,GLfloat)
     */
    @QtUninvokable
    public final void glUniform2f(int location, float x, float y){
        glUniform2f_native_GLint_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), location, x, y);
    }
    
    @QtUninvokable
    private native void glUniform2f_native_GLint_GLfloat_GLfloat(long __this__nativeId, int location, float x, float y);
    
    /**
     * See QOpenGLFunctions::glUniform2fv(GLint,GLsizei,const GLfloat*)
     */
    @QtUninvokable
    public final void glUniform2fv(int location, int count, java.nio.@Nullable FloatBuffer v){
        glUniform2fv_native_GLint_GLsizei_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, v);
    }
    
    @QtUninvokable
    private native void glUniform2fv_native_GLint_GLsizei_const_GLfloat_ptr(long __this__nativeId, int location, int count, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions::glUniform2i(GLint,GLint,GLint)
     */
    @QtUninvokable
    public final void glUniform2i(int location, int x, int y){
        glUniform2i_native_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), location, x, y);
    }
    
    @QtUninvokable
    private native void glUniform2i_native_GLint_GLint_GLint(long __this__nativeId, int location, int x, int y);
    
    /**
     * See QOpenGLFunctions::glUniform2iv(GLint,GLsizei,const GLint*)
     */
    @QtUninvokable
    public final void glUniform2iv(int location, int count, java.nio.@Nullable IntBuffer v){
        glUniform2iv_native_GLint_GLsizei_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, v);
    }
    
    @QtUninvokable
    private native void glUniform2iv_native_GLint_GLsizei_const_GLint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions::glUniform3f(GLint,GLfloat,GLfloat,GLfloat)
     */
    @QtUninvokable
    public final void glUniform3f(int location, float x, float y, float z){
        glUniform3f_native_GLint_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), location, x, y, z);
    }
    
    @QtUninvokable
    private native void glUniform3f_native_GLint_GLfloat_GLfloat_GLfloat(long __this__nativeId, int location, float x, float y, float z);
    
    /**
     * See QOpenGLFunctions::glUniform3fv(GLint,GLsizei,const GLfloat*)
     */
    @QtUninvokable
    public final void glUniform3fv(int location, int count, java.nio.@Nullable FloatBuffer v){
        glUniform3fv_native_GLint_GLsizei_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, v);
    }
    
    @QtUninvokable
    private native void glUniform3fv_native_GLint_GLsizei_const_GLfloat_ptr(long __this__nativeId, int location, int count, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions::glUniform3i(GLint,GLint,GLint,GLint)
     */
    @QtUninvokable
    public final void glUniform3i(int location, int x, int y, int z){
        glUniform3i_native_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), location, x, y, z);
    }
    
    @QtUninvokable
    private native void glUniform3i_native_GLint_GLint_GLint_GLint(long __this__nativeId, int location, int x, int y, int z);
    
    /**
     * See QOpenGLFunctions::glUniform3iv(GLint,GLsizei,const GLint*)
     */
    @QtUninvokable
    public final void glUniform3iv(int location, int count, java.nio.@Nullable IntBuffer v){
        glUniform3iv_native_GLint_GLsizei_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, v);
    }
    
    @QtUninvokable
    private native void glUniform3iv_native_GLint_GLsizei_const_GLint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions::glUniform4f(GLint,GLfloat,GLfloat,GLfloat,GLfloat)
     */
    @QtUninvokable
    public final void glUniform4f(int location, float x, float y, float z, float w){
        glUniform4f_native_GLint_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), location, x, y, z, w);
    }
    
    @QtUninvokable
    private native void glUniform4f_native_GLint_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, int location, float x, float y, float z, float w);
    
    /**
     * See QOpenGLFunctions::glUniform4fv(GLint,GLsizei,const GLfloat*)
     */
    @QtUninvokable
    public final void glUniform4fv(int location, int count, java.nio.@Nullable FloatBuffer v){
        glUniform4fv_native_GLint_GLsizei_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, v);
    }
    
    @QtUninvokable
    private native void glUniform4fv_native_GLint_GLsizei_const_GLfloat_ptr(long __this__nativeId, int location, int count, java.nio.FloatBuffer v);
    
    /**
     * See QOpenGLFunctions::glUniform4i(GLint,GLint,GLint,GLint,GLint)
     */
    @QtUninvokable
    public final void glUniform4i(int location, int x, int y, int z, int w){
        glUniform4i_native_GLint_GLint_GLint_GLint_GLint(QtJambi_LibraryUtilities.internal.nativeId(this), location, x, y, z, w);
    }
    
    @QtUninvokable
    private native void glUniform4i_native_GLint_GLint_GLint_GLint_GLint(long __this__nativeId, int location, int x, int y, int z, int w);
    
    /**
     * See QOpenGLFunctions::glUniform4iv(GLint,GLsizei,const GLint*)
     */
    @QtUninvokable
    public final void glUniform4iv(int location, int count, java.nio.@Nullable IntBuffer v){
        glUniform4iv_native_GLint_GLsizei_const_GLint_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, v);
    }
    
    @QtUninvokable
    private native void glUniform4iv_native_GLint_GLsizei_const_GLint_ptr(long __this__nativeId, int location, int count, java.nio.IntBuffer v);
    
    /**
     * See QOpenGLFunctions::glUniformMatrix2fv(GLint,GLsizei,GLboolean,const GLfloat*)
     */
    @QtUninvokable
    public final void glUniformMatrix2fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix2fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix2fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions::glUniformMatrix3fv(GLint,GLsizei,GLboolean,const GLfloat*)
     */
    @QtUninvokable
    public final void glUniformMatrix3fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix3fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix3fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions::glUniformMatrix4fv(GLint,GLsizei,GLboolean,const GLfloat*)
     */
    @QtUninvokable
    public final void glUniformMatrix4fv(int location, int count, boolean transpose, java.nio.@Nullable FloatBuffer value){
        glUniformMatrix4fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), location, count, transpose, value);
    }
    
    @QtUninvokable
    private native void glUniformMatrix4fv_native_GLint_GLsizei_GLboolean_const_GLfloat_ptr(long __this__nativeId, int location, int count, boolean transpose, java.nio.FloatBuffer value);
    
    /**
     * See QOpenGLFunctions::glUseProgram(GLuint)
     */
    @QtUninvokable
    public final void glUseProgram(int program){
        glUseProgram_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program);
    }
    
    @QtUninvokable
    private native void glUseProgram_native_GLuint(long __this__nativeId, int program);
    
    /**
     * See QOpenGLFunctions::glValidateProgram(GLuint)
     */
    @QtUninvokable
    public final void glValidateProgram(int program){
        glValidateProgram_native_GLuint(QtJambi_LibraryUtilities.internal.nativeId(this), program);
    }
    
    @QtUninvokable
    private native void glValidateProgram_native_GLuint(long __this__nativeId, int program);
    
    /**
     * See QOpenGLFunctions::glVertexAttrib1f(GLuint,GLfloat)
     */
    @QtUninvokable
    public final void glVertexAttrib1f(int indx, float x){
        glVertexAttrib1f_native_GLuint_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), indx, x);
    }
    
    @QtUninvokable
    private native void glVertexAttrib1f_native_GLuint_GLfloat(long __this__nativeId, int indx, float x);
    
    /**
     * See QOpenGLFunctions::glVertexAttrib1fv(GLuint,const GLfloat*)
     */
    @QtUninvokable
    public final void glVertexAttrib1fv(int indx, java.nio.@Nullable FloatBuffer values){
        glVertexAttrib1fv_native_GLuint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), indx, values);
    }
    
    @QtUninvokable
    private native void glVertexAttrib1fv_native_GLuint_const_GLfloat_ptr(long __this__nativeId, int indx, java.nio.FloatBuffer values);
    
    /**
     * See QOpenGLFunctions::glVertexAttrib2f(GLuint,GLfloat,GLfloat)
     */
    @QtUninvokable
    public final void glVertexAttrib2f(int indx, float x, float y){
        glVertexAttrib2f_native_GLuint_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), indx, x, y);
    }
    
    @QtUninvokable
    private native void glVertexAttrib2f_native_GLuint_GLfloat_GLfloat(long __this__nativeId, int indx, float x, float y);
    
    /**
     * See QOpenGLFunctions::glVertexAttrib2fv(GLuint,const GLfloat*)
     */
    @QtUninvokable
    public final void glVertexAttrib2fv(int indx, java.nio.@Nullable FloatBuffer values){
        glVertexAttrib2fv_native_GLuint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), indx, values);
    }
    
    @QtUninvokable
    private native void glVertexAttrib2fv_native_GLuint_const_GLfloat_ptr(long __this__nativeId, int indx, java.nio.FloatBuffer values);
    
    /**
     * See QOpenGLFunctions::glVertexAttrib3f(GLuint,GLfloat,GLfloat,GLfloat)
     */
    @QtUninvokable
    public final void glVertexAttrib3f(int indx, float x, float y, float z){
        glVertexAttrib3f_native_GLuint_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), indx, x, y, z);
    }
    
    @QtUninvokable
    private native void glVertexAttrib3f_native_GLuint_GLfloat_GLfloat_GLfloat(long __this__nativeId, int indx, float x, float y, float z);
    
    /**
     * See QOpenGLFunctions::glVertexAttrib3fv(GLuint,const GLfloat*)
     */
    @QtUninvokable
    public final void glVertexAttrib3fv(int indx, java.nio.@Nullable FloatBuffer values){
        glVertexAttrib3fv_native_GLuint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), indx, values);
    }
    
    @QtUninvokable
    private native void glVertexAttrib3fv_native_GLuint_const_GLfloat_ptr(long __this__nativeId, int indx, java.nio.FloatBuffer values);
    
    /**
     * See QOpenGLFunctions::glVertexAttrib4f(GLuint,GLfloat,GLfloat,GLfloat,GLfloat)
     */
    @QtUninvokable
    public final void glVertexAttrib4f(int indx, float x, float y, float z, float w){
        glVertexAttrib4f_native_GLuint_GLfloat_GLfloat_GLfloat_GLfloat(QtJambi_LibraryUtilities.internal.nativeId(this), indx, x, y, z, w);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4f_native_GLuint_GLfloat_GLfloat_GLfloat_GLfloat(long __this__nativeId, int indx, float x, float y, float z, float w);
    
    /**
     * See QOpenGLFunctions::glVertexAttrib4fv(GLuint,const GLfloat*)
     */
    @QtUninvokable
    public final void glVertexAttrib4fv(int indx, java.nio.@Nullable FloatBuffer values){
        glVertexAttrib4fv_native_GLuint_const_GLfloat_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), indx, values);
    }
    
    @QtUninvokable
    private native void glVertexAttrib4fv_native_GLuint_const_GLfloat_ptr(long __this__nativeId, int indx, java.nio.FloatBuffer values);
    
    /**
     * See QOpenGLFunctions::glVertexAttribPointer(GLuint,GLint,GLenum,GLboolean,GLsizei,const void*)
     */
    @QtUninvokable
    public final void glVertexAttribPointer(int indx, int size, int type, boolean normalized, int stride, java.nio.@Nullable Buffer ptr){
        glVertexAttribPointer_native_GLuint_GLint_GLenum_GLboolean_GLsizei_const_void_ptr(QtJambi_LibraryUtilities.internal.nativeId(this), indx, size, type, normalized, stride, ptr);
    }
    
    @QtUninvokable
    private native void glVertexAttribPointer_native_GLuint_GLint_GLenum_GLboolean_GLsizei_const_void_ptr(long __this__nativeId, int indx, int size, int type, boolean normalized, int stride, java.nio.Buffer ptr);
    
    /**
     * See QOpenGLFunctions::glViewport(GLint,GLint,GLsizei,GLsizei)
     */
    @QtUninvokable
    public final void glViewport(int x, int y, int width, int height){
        glViewport_native_GLint_GLint_GLsizei_GLsizei(QtJambi_LibraryUtilities.internal.nativeId(this), x, y, width, height);
    }
    
    @QtUninvokable
    private native void glViewport_native_GLint_GLint_GLsizei_GLsizei(long __this__nativeId, int x, int y, int width, int height);
    
    /**
     * See QOpenGLFunctions::hasOpenGLFeature(QOpenGLFunctions::OpenGLFeature)const
     */
    @QtUninvokable
    public final boolean hasOpenGLFeature(io.qt.gui.QOpenGLFunctions.@NonNull OpenGLFeature feature){
        return hasOpenGLFeature_native_QOpenGLFunctions_OpenGLFeature_constfct(QtJambi_LibraryUtilities.internal.nativeId(this), feature.value());
    }
    
    @QtUninvokable
    private native boolean hasOpenGLFeature_native_QOpenGLFunctions_OpenGLFeature_constfct(long __this__nativeId, int feature);
    
    /**
     * See QOpenGLFunctions::initializeOpenGLFunctions()
     */
    @QtUninvokable
    public final void initializeOpenGLFunctions(){
        initializeOpenGLFunctions_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    
    @QtUninvokable
    private native void initializeOpenGLFunctions_native(long __this__nativeId);
    
    /**
     * See QOpenGLFunctions::openGLFeatures()const
     */
    @QtUninvokable
    public final io.qt.gui.QOpenGLFunctions.@NonNull OpenGLFeatures openGLFeatures(){
        return new io.qt.gui.QOpenGLFunctions.OpenGLFeatures(openGLFeatures_native_constfct(QtJambi_LibraryUtilities.internal.nativeId(this)));
    }
    
    @QtUninvokable
    private native int openGLFeatures_native_constfct(long __this__nativeId);
    
    /**
     * Constructor for internal use only.
     * @param p expected to be null.
     * @hidden
     */
    @NativeAccess
    protected QOpenGLFunctions(QPrivateConstructor p) { super(p); } 
    
    
    /**
     * Creates and returns a copy of this object.
    See QOpenGLFunctions::QOpenGLFunctions(QOpenGLFunctions)
     */
    @QtUninvokable
    @Override
    public QOpenGLFunctions clone() {
        return clone_native(QtJambi_LibraryUtilities.internal.nativeId(this));
    }
    private static native QOpenGLFunctions clone_native(long __this_nativeId);
}