All Downloads are FREE. Search and download functionalities are using the official Maven repository.

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

Go to download

QtJambi base module containing QtCore, QtGui and QtWidgets.

There is a newer version: 6.8.0
Show newest version
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}
         */
        @Override
        public int value() {
            return value;
        }

        /**
         * Create a QFlags of the enum entry.
         * @return QFlags
         */
        @Override
        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
         */
        @Override
        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
         */
        @Override
        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);
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy