From 471be64a8ec1912bf0e3131751dd84e201b669e8 Mon Sep 17 00:00:00 2001 From: squid233 <60126026+squid233@users.noreply.github.com> Date: Sat, 9 Dec 2023 11:31:32 +0800 Subject: [PATCH] [OpenGL] Update extensions --- .../kotlin/overrungl/opengl/GLEXT.kt | 2176 +++++++++++++++++ .../overrungl/opengl/OpenGLGenerator.kt | 10 - .../main/java/overrungl/opengl/GLExtCaps.java | 133 +- .../overrungl/opengl/ext/ext/GLEXTAbgr.java | 32 + .../overrungl/opengl/ext/ext/GLEXTBgra.java | 33 + .../opengl/ext/ext/GLEXTBindableUniform.java | 67 + .../opengl/ext/ext/GLEXTBlendColor.java | 48 + .../ext/ext/GLEXTBlendEquationSeparate.java | 45 + .../ext/ext/GLEXTBlendFuncSeparate.java | 47 + .../opengl/ext/ext/GLEXTBlendMinmax.java | 47 + .../opengl/ext/ext/GLEXTBlendSubtract.java | 33 + .../opengl/ext/ext/GLEXTClipVolumeHint.java | 32 + .../overrungl/opengl/ext/ext/GLEXTCmyka.java | 35 + .../opengl/ext/ext/GLEXTColorSubtable.java | 51 + .../ext/ext/GLEXTCompiledVertexArray.java | 53 + .../opengl/ext/ext/GLEXTConvolution.java | 159 ++ .../opengl/ext/ext/GLEXTCoordinateFrame.java | 225 ++ .../opengl/ext/ext/GLEXTCopyTexture.java | 75 + .../opengl/ext/ext/GLEXTCullVertex.java | 54 + .../opengl/ext/ext/GLEXTDebugLabel.java | 57 + .../opengl/ext/ext/GLEXTDebugMarker.java | 59 + .../opengl/ext/ext/GLEXTDepthBoundsTest.java | 45 + .../ext/ext/GLEXTDirectStateAccess.java | 2082 ++++++++++++++++ .../opengl/ext/ext/GLEXTDrawBuffers2.java | 43 + .../opengl/ext/ext/GLEXTDrawInstanced.java | 51 + .../ext/ext/GLEXTDrawRangedElements.java | 45 + .../opengl/ext/ext/GLEXTEGLImageStorage.java | 51 + .../opengl/ext/ext/GLEXTExternalBuffer.java | 51 + .../opengl/ext/ext/GLEXTFogCoord.java | 83 + .../opengl/ext/ext/GLEXTFramebufferBlit.java | 47 + .../ext/ext/GLEXTFramebufferBlitLayers.java | 51 + .../ext/ext/GLEXTFramebufferMultisample.java | 46 + ...GLEXTFramebufferMultisampleBlitScaled.java | 33 + .../ext/ext/GLEXTFramebufferObject.java | 225 ++ .../overrungl/opengl/ext/ext/GLEXTSrgb.java | 33 + 35 files changed, 6304 insertions(+), 53 deletions(-) create mode 100644 modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/GLEXT.kt create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTAbgr.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBgra.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBindableUniform.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendColor.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendEquationSeparate.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendFuncSeparate.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendMinmax.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendSubtract.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTClipVolumeHint.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCmyka.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTColorSubtable.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCompiledVertexArray.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTConvolution.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCoordinateFrame.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCopyTexture.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCullVertex.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDebugLabel.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDebugMarker.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDepthBoundsTest.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDirectStateAccess.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawBuffers2.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawInstanced.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawRangedElements.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTEGLImageStorage.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTExternalBuffer.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFogCoord.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferBlit.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferBlitLayers.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferMultisample.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferMultisampleBlitScaled.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferObject.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTSrgb.java diff --git a/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/GLEXT.kt b/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/GLEXT.kt new file mode 100644 index 00000000..2c15a919 --- /dev/null +++ b/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/GLEXT.kt @@ -0,0 +1,2176 @@ +/* + * MIT License + * + * Copyright (c) 2023 Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +package overrungl.opengl + +import overrungl.opengl.OpenGLExt.EXT + +/** + * @author squid233 + * @since 0.1.0 + */ +fun ext() { + file( + "422Pixels", EXT, "GL_EXT_422_pixels", + "GL_422_EXT" to "0x80CC", + "GL_422_REV_EXT" to "0x80CD", + "GL_422_AVERAGE_EXT" to "0x80CE", + "GL_422_REV_AVERAGE_EXT" to "0x80CF" + ) + file("EGLImageStorage", EXT, "GL_EXT_EGL_image_storage") { + "glEGLImageTargetTexStorageEXT"( + void, + GLenum("target"), + address("image", "GLeglImageOES"), + address("attrib_list", "const GLint*") + ) + "glEGLImageTargetTextureStorageEXT"( + void, + GLuint("texture"), + address("image", "GLeglImageOES"), + address("attrib_list", "const GLint*") + ) + } + file("Abgr", EXT, "GL_EXT_abgr", "GL_ABGR_EXT" to "0x8000") + file( + "Bgra", EXT, "GL_EXT_bgra", + "GL_BGR_EXT" to "0x80E0", + "GL_BGRA_EXT" to "0x80E1" + ) + file("BindableUniform", EXT, "GL_EXT_bindable_uniform") { + "GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT"("0x8DE2") + "GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT"("0x8DE3") + "GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT"("0x8DE4") + "GL_MAX_BINDABLE_UNIFORM_SIZE_EXT"("0x8DED") + "GL_UNIFORM_BUFFER_EXT"("0x8DEE") + "GL_UNIFORM_BUFFER_BINDING_EXT"("0x8DEF") + "glUniformBufferEXT"(void, GLuint("program"), GLint("location"), GLuint("buffer")) + "glGetUniformBufferSizeEXT"(GLint, GLuint("program"), GLint("location")) + "glGetUniformOffsetEXT"(GLintptr, GLuint("program"), GLint("location")) + } + file("BlendColor", EXT, "GL_EXT_blend_color") { + "GL_CONSTANT_COLOR_EXT"("0x8001") + "GL_ONE_MINUS_CONSTANT_COLOR_EXT"("0x8002") + "GL_CONSTANT_ALPHA_EXT"("0x8003") + "GL_ONE_MINUS_CONSTANT_ALPHA_EXT"("0x8004") + "GL_BLEND_COLOR_EXT"("0x8005") + "glBlendColorEXT"(void, GLfloat("red"), GLfloat("green"), GLfloat("blue"), GLfloat("alpha")) + } + file("BlendEquationSeparate", EXT, "GL_EXT_blend_equation_separate") { + "GL_BLEND_EQUATION_RGB_EXT"("0x8009") + "GL_BLEND_EQUATION_ALPHA_EXT"("0x883D") + "glBlendEquationSeparateEXT"(void, GLenum("modeRGB"), GLenum("modeAlpha")) + } + file("BlendFuncSeparate", EXT, "GL_EXT_blend_func_separate") { + "GL_BLEND_DST_RGB_EXT"("0x80C8") + "GL_BLEND_SRC_RGB_EXT"("0x80C9") + "GL_BLEND_DST_ALPHA_EXT"("0x80CA") + "GL_BLEND_SRC_ALPHA_EXT"("0x80CB") + "glBlendFuncSeparateEXT"( + void, + GLenum("sfactorRGB"), + GLenum("dfactorRGB"), + GLenum("sfactorAlpha"), + GLenum("dfactorAlpha") + ) + } + file("BlendMinmax", EXT, "GL_EXT_blend_minmax") { + "GL_MIN_EXT"("0x8007") + "GL_MAX_EXT"("0x8008") + "GL_FUNC_ADD_EXT"("0x8006") + "GL_BLEND_EQUATION_EXT"("0x8009") + "glBlendEquationEXT"(void, GLenum("mode")) + } + file( + "BlendSubtract", EXT, "GL_EXT_blend_subtract", + "GL_FUNC_SUBTRACT_EXT" to "0x800A", + "GL_FUNC_REVERSE_SUBTRACT_EXT" to "0x800B" + ) + file("ClipVolumeHint", EXT, "GL_EXT_clip_volume_hint", "GL_CLIP_VOLUME_CLIPPING_HINT_EXT" to "0x80F0") + file( + "Cmyka", EXT, "GL_EXT_cmyka", + "GL_CMYK_EXT" to "0x800C", + "GL_CMYKA_EXT" to "0x800D", + "GL_PACK_CMYK_HINT_EXT" to "0x800E", + "GL_UNPACK_CMYK_HINT_EXT" to "0x800F" + ) + file("ColorSubtable", EXT, "GL_EXT_color_subtable") { + "glColorSubTableEXT"( + void, + GLenum("target"), + GLsizei("start"), + GLsizei("count"), + GLenum("format"), + GLenum("type"), + address("data", "const void *") + ) + "glCopyColorSubTableEXT"(void, GLenum("target"), GLsizei("start"), GLint("x"), GLint("y"), GLsizei("width")) + } + file("CompiledVertexArray", EXT, "GL_EXT_compiled_vertex_array") { + "GL_ARRAY_ELEMENT_LOCK_FIRST_EXT"("0x81A8") + "GL_ARRAY_ELEMENT_LOCK_COUNT_EXT"("0x81A9") + "glLockArraysEXT"(void, GLint("first"), GLsizei("count")) + "glUnlockArraysEXT"(void) + } + file("Convolution", EXT, "GL_EXT_convolution") { + "GL_CONVOLUTION_1D_EXT"("0x8010") + "GL_CONVOLUTION_2D_EXT"("0x8011") + "GL_SEPARABLE_2D_EXT"("0x8012") + "GL_CONVOLUTION_BORDER_MODE_EXT"("0x8013") + "GL_CONVOLUTION_FILTER_SCALE_EXT"("0x8014") + "GL_CONVOLUTION_FILTER_BIAS_EXT"("0x8015") + "GL_REDUCE_EXT"("0x8016") + "GL_CONVOLUTION_FORMAT_EXT"("0x8017") + "GL_CONVOLUTION_WIDTH_EXT"("0x8018") + "GL_CONVOLUTION_HEIGHT_EXT"("0x8019") + "GL_MAX_CONVOLUTION_WIDTH_EXT"("0x801A") + "GL_MAX_CONVOLUTION_HEIGHT_EXT"("0x801B") + "GL_POST_CONVOLUTION_RED_SCALE_EXT"("0x801C") + "GL_POST_CONVOLUTION_GREEN_SCALE_EXT"("0x801D") + "GL_POST_CONVOLUTION_BLUE_SCALE_EXT"("0x801E") + "GL_POST_CONVOLUTION_ALPHA_SCALE_EXT"("0x801F") + "GL_POST_CONVOLUTION_RED_BIAS_EXT"("0x8020") + "GL_POST_CONVOLUTION_GREEN_BIAS_EXT"("0x8021") + "GL_POST_CONVOLUTION_BLUE_BIAS_EXT"("0x8022") + "GL_POST_CONVOLUTION_ALPHA_BIAS_EXT"("0x8023") + "glConvolutionFilter1DEXT"( + void, + GLenum("target"), + GLenum("internalformat"), + GLsizei("width"), + GLenum("format"), + GLenum("type"), + address("image", "const void *") + ) + "glConvolutionFilter2DEXT"( + void, + GLenum("target"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLenum("format"), + GLenum("type"), + address("image", "const void *") + ) + "glConvolutionParameterfEXT"(void, GLenum("target"), GLenum("pname"), GLfloat("params")) + "glConvolutionParameterfvEXT"(void, GLenum("target"), GLenum("pname"), address("params", "const GLfloat *")) + "glConvolutionParameteriEXT"(void, GLenum("target"), GLenum("pname"), GLint("params")) + "glConvolutionParameterivEXT"(void, GLenum("target"), GLenum("pname"), address("params", "const GLint *")) + "glCopyConvolutionFilter1DEXT"( + void, + GLenum("target"), + GLenum("internalformat"), + GLint("x"), + GLint("y"), + GLsizei("width") + ) + "glCopyConvolutionFilter2DEXT"( + void, + GLenum("target"), + GLenum("internalformat"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLsizei("height") + ) + "glGetConvolutionFilterEXT"( + void, + GLenum("target"), + GLenum("format"), + GLenum("type"), + address("image", "void *") + ) + "glGetConvolutionParameterfvEXT"(void, GLenum("target"), GLenum("pname"), address("params", "GLfloat *")) + "glGetConvolutionParameterivEXT"(void, GLenum("target"), GLenum("pname"), address("params", "GLint *")) + "glGetSeparableFilterEXT"( + void, + GLenum("target"), + GLenum("format"), + GLenum("type"), + address("row", "void *"), + address("column", "void *"), + address("span", "void *") + ) + "glSeparableFilter2DEXT"( + void, + GLenum("target"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLenum("format"), + GLenum("type"), + address("row", "const void *"), + address("column", "const void *") + ) + } + file("CoordinateFrame", EXT, "GL_EXT_coordinate_frame") { + "GL_TANGENT_ARRAY_EXT"("0x8439") + "GL_BINORMAL_ARRAY_EXT"("0x843A") + "GL_CURRENT_TANGENT_EXT"("0x843B") + "GL_CURRENT_BINORMAL_EXT"("0x843C") + "GL_TANGENT_ARRAY_TYPE_EXT"("0x843E") + "GL_TANGENT_ARRAY_STRIDE_EXT"("0x843F") + "GL_BINORMAL_ARRAY_TYPE_EXT"("0x8440") + "GL_BINORMAL_ARRAY_STRIDE_EXT"("0x8441") + "GL_TANGENT_ARRAY_POINTER_EXT"("0x8442") + "GL_BINORMAL_ARRAY_POINTER_EXT"("0x8443") + "GL_MAP1_TANGENT_EXT"("0x8444") + "GL_MAP2_TANGENT_EXT"("0x8445") + "GL_MAP1_BINORMAL_EXT"("0x8446") + "GL_MAP2_BINORMAL_EXT"("0x8447") + "glTangent3bEXT"(void, GLbyte("tx"), GLbyte("ty"), GLbyte("tz")) + "glTangent3bvEXT"(void, address("v", "const GLbyte *")) + "glTangent3dEXT"(void, GLdouble("tx"), GLdouble("ty"), GLdouble("tz")) + "glTangent3dvEXT"(void, address("v", "const GLdouble *")) + "glTangent3fEXT"(void, GLfloat("tx"), GLfloat("ty"), GLfloat("tz")) + "glTangent3fvEXT"(void, address("v", "const GLfloat *")) + "glTangent3iEXT"(void, GLint("tx"), GLint("ty"), GLint("tz")) + "glTangent3ivEXT"(void, address("v", "const GLint *")) + "glTangent3sEXT"(void, GLshort("tx"), GLshort("ty"), GLshort("tz")) + "glTangent3svEXT"(void, address("v", "const GLshort *")) + "glBinormal3bEXT"(void, GLbyte("bx"), GLbyte("by"), GLbyte("bz")) + "glBinormal3bvEXT"(void, address("v", "const GLbyte *")) + "glBinormal3dEXT"(void, GLdouble("bx"), GLdouble("by"), GLdouble("bz")) + "glBinormal3dvEXT"(void, address("v", "const GLdouble *")) + "glBinormal3fEXT"(void, GLfloat("bx"), GLfloat("by"), GLfloat("bz")) + "glBinormal3fvEXT"(void, address("v", "const GLfloat *")) + "glBinormal3iEXT"(void, GLint("bx"), GLint("by"), GLint("bz")) + "glBinormal3ivEXT"(void, address("v", "const GLint *")) + "glBinormal3sEXT"(void, GLshort("bx"), GLshort("by"), GLshort("bz")) + "glBinormal3svEXT"(void, address("v", "const GLshort *")) + "glTangentPointerEXT"(void, GLenum("type"), GLsizei("stride"), address("pointer", "const void *")) + "glBinormalPointerEXT"(void, GLenum("type"), GLsizei("stride"), address("pointer", "const void *")) + } + file("CopyTexture", EXT, "GL_EXT_copy_texture") { + "glCopyTexImage1DEXT"( + void, + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLint("border") + ) + "glCopyTexImage2DEXT"( + void, + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLsizei("height"), + GLint("border") + ) + "glCopyTexSubImage1DEXT"( + void, + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("x"), + GLint("y"), + GLsizei("width") + ) + "glCopyTexSubImage2DEXT"( + void, + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLsizei("height") + ) + "glCopyTexSubImage3DEXT"( + void, + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLint("zoffset"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLsizei("height") + ) + } + file("CullVertex", EXT, "GL_EXT_cull_vertex") { + "GL_CULL_VERTEX_EXT"("0x81AA") + "GL_CULL_VERTEX_EYE_POSITION_EXT"("0x81AB") + "GL_CULL_VERTEX_OBJECT_POSITION_EXT"("0x81AC") + "glCullParameterdvEXT"(void, GLenum("pname"), address("params", "GLdouble *")) + "glCullParameterfvEXT"(void, GLenum("pname"), address("params", "GLfloat *")) + } + file("DebugLabel", EXT, "GL_EXT_debug_label") { + "GL_PROGRAM_PIPELINE_OBJECT_EXT"("0x8A4F") + "GL_PROGRAM_OBJECT_EXT"("0x8B40") + "GL_SHADER_OBJECT_EXT"("0x8B48") + "GL_BUFFER_OBJECT_EXT"("0x9151") + "GL_QUERY_OBJECT_EXT"("0x9153") + "GL_VERTEX_ARRAY_OBJECT_EXT"("0x9154") + "glLabelObjectEXT"( + void, + GLenum("type"), + GLuint("object"), + GLsizei("length"), + address("label", "const GLchar *") + ) + "glGetObjectLabelEXT"( + void, + GLenum("type"), + GLuint("object"), + GLsizei("bufSize"), + address("length", "GLsizei *"), + address("label", "GLchar *") + ) + } + file("DebugMarker", EXT, "GL_EXT_debug_marker") { + "glInsertEventMarkerEXT"(void, GLsizei("length"), address("marker", "const GLchar *")) + "glPushGroupMarkerEXT"(void, GLsizei("length"), address("marker", "const GLchar *")) + "glPopGroupMarkerEXT"(void) + } + file("DepthBoundsTest", EXT, "GL_EXT_depth_bounds_test") { + "GL_DEPTH_BOUNDS_TEST_EXT"("0x8890") + "GL_DEPTH_BOUNDS_EXT"("0x8891") + "glDepthBoundsEXT"(void, GLclampd("zmin"), GLclampd("zmax")) + } + file("DirectStateAccess", EXT, "GL_EXT_direct_state_access") { + "GL_PROGRAM_MATRIX_EXT"("0x8E2D") + "GL_TRANSPOSE_PROGRAM_MATRIX_EXT"("0x8E2E") + "GL_PROGRAM_MATRIX_STACK_DEPTH_EXT"("0x8E2F") + "glMatrixLoadfEXT"(void, GLenum("mode"), address("m", "const GLfloat *")) + "glMatrixLoaddEXT"(void, GLenum("mode"), address("m", "const GLdouble *")) + "glMatrixMultfEXT"(void, GLenum("mode"), address("m", "const GLfloat *")) + "glMatrixMultdEXT"(void, GLenum("mode"), address("m", "const GLdouble *")) + "glMatrixLoadIdentityEXT"(void, GLenum("mode")) + "glMatrixRotatefEXT"(void, GLenum("mode"), GLfloat("angle"), GLfloat("x"), GLfloat("y"), GLfloat("z")) + "glMatrixRotatedEXT"(void, GLenum("mode"), GLdouble("angle"), GLdouble("x"), GLdouble("y"), GLdouble("z")) + "glMatrixScalefEXT"(void, GLenum("mode"), GLfloat("x"), GLfloat("y"), GLfloat("z")) + "glMatrixScaledEXT"(void, GLenum("mode"), GLdouble("x"), GLdouble("y"), GLdouble("z")) + "glMatrixTranslatefEXT"(void, GLenum("mode"), GLfloat("x"), GLfloat("y"), GLfloat("z")) + "glMatrixTranslatedEXT"(void, GLenum("mode"), GLdouble("x"), GLdouble("y"), GLdouble("z")) + "glMatrixFrustumEXT"( + void, + GLenum("mode"), + GLdouble("left"), + GLdouble("right"), + GLdouble("bottom"), + GLdouble("top"), + GLdouble("zNear"), + GLdouble("zFar") + ) + "glMatrixOrthoEXT"( + void, + GLenum("mode"), + GLdouble("left"), + GLdouble("right"), + GLdouble("bottom"), + GLdouble("top"), + GLdouble("zNear"), + GLdouble("zFar") + ) + "glMatrixPopEXT"(void, GLenum("mode")) + "glMatrixPushEXT"(void, GLenum("mode")) + "glClientAttribDefaultEXT"(void, GLbitfield("mask")) + "glPushClientAttribDefaultEXT"(void, GLbitfield("mask")) + "glTextureParameterfEXT"(void, GLuint("texture"), GLenum("target"), GLenum("pname"), GLfloat("param")) + "glTextureParameterfvEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLenum("pname"), + address("params", "const GLfloat *") + ) + "glTextureParameteriEXT"(void, GLuint("texture"), GLenum("target"), GLenum("pname"), GLint("param")) + "glTextureParameterivEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLenum("pname"), + address("params", "const GLint *") + ) + "glTextureImage1DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("internalformat"), + GLsizei("width"), + GLint("border"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glTextureImage2DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLint("border"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glTextureSubImage1DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLsizei("width"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glTextureSubImage2DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLsizei("width"), + GLsizei("height"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glCopyTextureImage1DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLint("border") + ) + "glCopyTextureImage2DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLsizei("height"), + GLint("border") + ) + "glCopyTextureSubImage1DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("x"), + GLint("y"), + GLsizei("width") + ) + "glCopyTextureSubImage2DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLsizei("height") + ) + "glGetTextureImageEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLenum("format"), + GLenum("type"), + address("pixels", "void *") + ) + "glGetTextureParameterfvEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLenum("pname"), + address("params", "GLfloat *") + ) + "glGetTextureParameterivEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLenum("pname"), + address("params", "GLint *") + ) + "glGetTextureLevelParameterfvEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLenum("pname"), + address("params", "GLfloat *") + ) + "glGetTextureLevelParameterivEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLenum("pname"), + address("params", "GLint *") + ) + "glTextureImage3DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLsizei("depth"), + GLint("border"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glTextureSubImage3DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLint("zoffset"), + GLsizei("width"), + GLsizei("height"), + GLsizei("depth"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glCopyTextureSubImage3DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLint("zoffset"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLsizei("height") + ) + "glBindMultiTextureEXT"(void, GLenum("texunit"), GLenum("target"), GLuint("texture")) + "glMultiTexCoordPointerEXT"( + void, + GLenum("texunit"), + GLint("size"), + GLenum("type"), + GLsizei("stride"), + address("pointer", "const void *") + ) + "glMultiTexEnvfEXT"(void, GLenum("texunit"), GLenum("target"), GLenum("pname"), GLfloat("param")) + "glMultiTexEnvfvEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "const GLfloat *") + ) + "glMultiTexEnviEXT"(void, GLenum("texunit"), GLenum("target"), GLenum("pname"), GLint("param")) + "glMultiTexEnvivEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "const GLint *") + ) + "glMultiTexGendEXT"(void, GLenum("texunit"), GLenum("coord"), GLenum("pname"), GLdouble("param")) + "glMultiTexGendvEXT"( + void, + GLenum("texunit"), + GLenum("coord"), + GLenum("pname"), + address("params", "const GLdouble *") + ) + "glMultiTexGenfEXT"(void, GLenum("texunit"), GLenum("coord"), GLenum("pname"), GLfloat("param")) + "glMultiTexGenfvEXT"( + void, + GLenum("texunit"), + GLenum("coord"), + GLenum("pname"), + address("params", "const GLfloat *") + ) + "glMultiTexGeniEXT"(void, GLenum("texunit"), GLenum("coord"), GLenum("pname"), GLint("param")) + "glMultiTexGenivEXT"( + void, + GLenum("texunit"), + GLenum("coord"), + GLenum("pname"), + address("params", "const GLint *") + ) + "glGetMultiTexEnvfvEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "GLfloat *") + ) + "glGetMultiTexEnvivEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "GLint *") + ) + "glGetMultiTexGendvEXT"( + void, + GLenum("texunit"), + GLenum("coord"), + GLenum("pname"), + address("params", "GLdouble *") + ) + "glGetMultiTexGenfvEXT"( + void, + GLenum("texunit"), + GLenum("coord"), + GLenum("pname"), + address("params", "GLfloat *") + ) + "glGetMultiTexGenivEXT"(void, GLenum("texunit"), GLenum("coord"), GLenum("pname"), address("params", "GLint *")) + "glMultiTexParameteriEXT"(void, GLenum("texunit"), GLenum("target"), GLenum("pname"), GLint("param")) + "glMultiTexParameterivEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "const GLint *") + ) + "glMultiTexParameterfEXT"(void, GLenum("texunit"), GLenum("target"), GLenum("pname"), GLfloat("param")) + "glMultiTexParameterfvEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "const GLfloat *") + ) + "glMultiTexImage1DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("internalformat"), + GLsizei("width"), + GLint("border"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glMultiTexImage2DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLint("border"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glMultiTexSubImage1DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLsizei("width"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glMultiTexSubImage2DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLsizei("width"), + GLsizei("height"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glCopyMultiTexImage1DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLint("border") + ) + "glCopyMultiTexImage2DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLsizei("height"), + GLint("border") + ) + "glCopyMultiTexSubImage1DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("x"), + GLint("y"), + GLsizei("width") + ) + "glCopyMultiTexSubImage2DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLsizei("height") + ) + "glGetMultiTexImageEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLenum("format"), + GLenum("type"), + address("pixels", "void *") + ) + "glGetMultiTexParameterfvEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "GLfloat *") + ) + "glGetMultiTexParameterivEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "GLint *") + ) + "glGetMultiTexLevelParameterfvEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLenum("pname"), + address("params", "GLfloat *") + ) + "glGetMultiTexLevelParameterivEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLenum("pname"), + address("params", "GLint *") + ) + "glMultiTexImage3DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLsizei("depth"), + GLint("border"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glMultiTexSubImage3DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLint("zoffset"), + GLsizei("width"), + GLsizei("height"), + GLsizei("depth"), + GLenum("format"), + GLenum("type"), + address("pixels", "const void *") + ) + "glCopyMultiTexSubImage3DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLint("zoffset"), + GLint("x"), + GLint("y"), + GLsizei("width"), + GLsizei("height") + ) + "glEnableClientStateIndexedEXT"(void, GLenum("array"), GLuint("index")) + "glDisableClientStateIndexedEXT"(void, GLenum("array"), GLuint("index")) + "glGetFloatIndexedvEXT"(void, GLenum("target"), GLuint("index"), address("data", "GLfloat *")) + "glGetDoubleIndexedvEXT"(void, GLenum("target"), GLuint("index"), address("data", "GLdouble *")) + "glGetPointerIndexedvEXT"(void, GLenum("target"), GLuint("index"), address("data", "void **")) + "glEnableIndexedEXT"(void, GLenum("target"), GLuint("index")) + "glDisableIndexedEXT"(void, GLenum("target"), GLuint("index")) + "glIsEnabledIndexedEXT"(GLboolean, GLenum("target"), GLuint("index")) + "glGetIntegerIndexedvEXT"(void, GLenum("target"), GLuint("index"), address("data", "GLint *")) + "glGetBooleanIndexedvEXT"(void, GLenum("target"), GLuint("index"), address("data", "GLboolean *")) + "glCompressedTextureImage3DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLsizei("depth"), + GLint("border"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glCompressedTextureImage2DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLint("border"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glCompressedTextureImage1DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLsizei("width"), + GLint("border"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glCompressedTextureSubImage3DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLint("zoffset"), + GLsizei("width"), + GLsizei("height"), + GLsizei("depth"), + GLenum("format"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glCompressedTextureSubImage2DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLsizei("width"), + GLsizei("height"), + GLenum("format"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glCompressedTextureSubImage1DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLsizei("width"), + GLenum("format"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glGetCompressedTextureImageEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLint("lod"), + address("img", "void *") + ) + "glCompressedMultiTexImage3DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLsizei("depth"), + GLint("border"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glCompressedMultiTexImage2DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLint("border"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glCompressedMultiTexImage1DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLenum("internalformat"), + GLsizei("width"), + GLint("border"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glCompressedMultiTexSubImage3DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLint("zoffset"), + GLsizei("width"), + GLsizei("height"), + GLsizei("depth"), + GLenum("format"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glCompressedMultiTexSubImage2DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLsizei("width"), + GLsizei("height"), + GLenum("format"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glCompressedMultiTexSubImage1DEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("level"), + GLint("xoffset"), + GLsizei("width"), + GLenum("format"), + GLsizei("imageSize"), + address("bits", "const void *") + ) + "glGetCompressedMultiTexImageEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLint("lod"), + address("img", "void *") + ) + "glMatrixLoadTransposefEXT"(void, GLenum("mode"), address("m", "const GLfloat *")) + "glMatrixLoadTransposedEXT"(void, GLenum("mode"), address("m", "const GLdouble *")) + "glMatrixMultTransposefEXT"(void, GLenum("mode"), address("m", "const GLfloat *")) + "glMatrixMultTransposedEXT"(void, GLenum("mode"), address("m", "const GLdouble *")) + "glNamedBufferDataEXT"( + void, + GLuint("buffer"), + GLsizeiptr("size"), + address("data", "const void *"), + GLenum("usage") + ) + "glNamedBufferSubDataEXT"( + void, + GLuint("buffer"), + GLintptr("offset"), + GLsizeiptr("size"), + address("data", "const void *") + ) + "glMapNamedBufferEXT"(address, GLuint("buffer"), GLenum("access"), nativeType = "void *") + "glUnmapNamedBufferEXT"(GLboolean, GLuint("buffer")) + "glGetNamedBufferParameterivEXT"(void, GLuint("buffer"), GLenum("pname"), address("params", "GLint *")) + "glGetNamedBufferPointervEXT"(void, GLuint("buffer"), GLenum("pname"), address("params", "void **")) + "glGetNamedBufferSubDataEXT"( + void, + GLuint("buffer"), + GLintptr("offset"), + GLsizeiptr("size"), + address("data", "void *") + ) + "glProgramUniform1fEXT"(void, GLuint("program"), GLint("location"), GLfloat("v0")) + "glProgramUniform2fEXT"(void, GLuint("program"), GLint("location"), GLfloat("v0"), GLfloat("v1")) + "glProgramUniform3fEXT"(void, GLuint("program"), GLint("location"), GLfloat("v0"), GLfloat("v1"), GLfloat("v2")) + "glProgramUniform4fEXT"( + void, + GLuint("program"), + GLint("location"), + GLfloat("v0"), + GLfloat("v1"), + GLfloat("v2"), + GLfloat("v3") + ) + "glProgramUniform1iEXT"(void, GLuint("program"), GLint("location"), GLint("v0")) + "glProgramUniform2iEXT"(void, GLuint("program"), GLint("location"), GLint("v0"), GLint("v1")) + "glProgramUniform3iEXT"(void, GLuint("program"), GLint("location"), GLint("v0"), GLint("v1"), GLint("v2")) + "glProgramUniform4iEXT"( + void, + GLuint("program"), + GLint("location"), + GLint("v0"), + GLint("v1"), + GLint("v2"), + GLint("v3") + ) + "glProgramUniform1fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLfloat *") + ) + "glProgramUniform2fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLfloat *") + ) + "glProgramUniform3fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLfloat *") + ) + "glProgramUniform4fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLfloat *") + ) + "glProgramUniform1ivEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLint *") + ) + "glProgramUniform2ivEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLint *") + ) + "glProgramUniform3ivEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLint *") + ) + "glProgramUniform4ivEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLint *") + ) + "glProgramUniformMatrix2fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLfloat *") + ) + "glProgramUniformMatrix3fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLfloat *") + ) + "glProgramUniformMatrix4fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLfloat *") + ) + "glProgramUniformMatrix2x3fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLfloat *") + ) + "glProgramUniformMatrix3x2fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLfloat *") + ) + "glProgramUniformMatrix2x4fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLfloat *") + ) + "glProgramUniformMatrix4x2fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLfloat *") + ) + "glProgramUniformMatrix3x4fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLfloat *") + ) + "glProgramUniformMatrix4x3fvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLfloat *") + ) + "glTextureBufferEXT"(void, GLuint("texture"), GLenum("target"), GLenum("internalformat"), GLuint("buffer")) + "glMultiTexBufferEXT"(void, GLenum("texunit"), GLenum("target"), GLenum("internalformat"), GLuint("buffer")) + "glTextureParameterIivEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLenum("pname"), + address("params", "const GLint *") + ) + "glTextureParameterIuivEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLenum("pname"), + address("params", "const GLuint *") + ) + "glGetTextureParameterIivEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLenum("pname"), + address("params", "GLint *") + ) + "glGetTextureParameterIuivEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLenum("pname"), + address("params", "GLuint *") + ) + "glMultiTexParameterIivEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "const GLint *") + ) + "glMultiTexParameterIuivEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "const GLuint *") + ) + "glGetMultiTexParameterIivEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "GLint *") + ) + "glGetMultiTexParameterIuivEXT"( + void, + GLenum("texunit"), + GLenum("target"), + GLenum("pname"), + address("params", "GLuint *") + ) + "glProgramUniform1uiEXT"(void, GLuint("program"), GLint("location"), GLuint("v0")) + "glProgramUniform2uiEXT"(void, GLuint("program"), GLint("location"), GLuint("v0"), GLuint("v1")) + "glProgramUniform3uiEXT"(void, GLuint("program"), GLint("location"), GLuint("v0"), GLuint("v1"), GLuint("v2")) + "glProgramUniform4uiEXT"( + void, + GLuint("program"), + GLint("location"), + GLuint("v0"), + GLuint("v1"), + GLuint("v2"), + GLuint("v3") + ) + "glProgramUniform1uivEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLuint *") + ) + "glProgramUniform2uivEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLuint *") + ) + "glProgramUniform3uivEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLuint *") + ) + "glProgramUniform4uivEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLuint *") + ) + "glNamedProgramLocalParameters4fvEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + GLsizei("count"), + address("params", "const GLfloat *") + ) + "glNamedProgramLocalParameterI4iEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + GLint("x"), + GLint("y"), + GLint("z"), + GLint("w") + ) + "glNamedProgramLocalParameterI4ivEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + address("params", "const GLint *") + ) + "glNamedProgramLocalParametersI4ivEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + GLsizei("count"), + address("params", "const GLint *") + ) + "glNamedProgramLocalParameterI4uiEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + GLuint("x"), + GLuint("y"), + GLuint("z"), + GLuint("w") + ) + "glNamedProgramLocalParameterI4uivEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + address("params", "const GLuint *") + ) + "glNamedProgramLocalParametersI4uivEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + GLsizei("count"), + address("params", "const GLuint *") + ) + "glGetNamedProgramLocalParameterIivEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + address("params", "GLint *") + ) + "glGetNamedProgramLocalParameterIuivEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + address("params", "GLuint *") + ) + "glEnableClientStateiEXT"(void, GLenum("array"), GLuint("index")) + "glDisableClientStateiEXT"(void, GLenum("array"), GLuint("index")) + "glGetFloati_vEXT"(void, GLenum("pname"), GLuint("index"), address("params", "GLfloat *")) + "glGetDoublei_vEXT"(void, GLenum("pname"), GLuint("index"), address("params", "GLdouble *")) + "glGetPointeri_vEXT"(void, GLenum("pname"), GLuint("index"), address("params", "void **")) + "glNamedProgramStringEXT"( + void, + GLuint("program"), + GLenum("target"), + GLenum("format"), + GLsizei("len"), + address("string", "const void *") + ) + "glNamedProgramLocalParameter4dEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + GLdouble("x"), + GLdouble("y"), + GLdouble("z"), + GLdouble("w") + ) + "glNamedProgramLocalParameter4dvEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + address("params", "const GLdouble *") + ) + "glNamedProgramLocalParameter4fEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + GLfloat("x"), + GLfloat("y"), + GLfloat("z"), + GLfloat("w") + ) + "glNamedProgramLocalParameter4fvEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + address("params", "const GLfloat *") + ) + "glGetNamedProgramLocalParameterdvEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + address("params", "GLdouble *") + ) + "glGetNamedProgramLocalParameterfvEXT"( + void, + GLuint("program"), + GLenum("target"), + GLuint("index"), + address("params", "GLfloat *") + ) + "glGetNamedProgramivEXT"( + void, + GLuint("program"), + GLenum("target"), + GLenum("pname"), + address("params", "GLint *") + ) + "glGetNamedProgramStringEXT"( + void, + GLuint("program"), + GLenum("target"), + GLenum("pname"), + address("string", "void *") + ) + "glNamedRenderbufferStorageEXT"( + void, + GLuint("renderbuffer"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height") + ) + "glGetNamedRenderbufferParameterivEXT"( + void, + GLuint("renderbuffer"), + GLenum("pname"), + address("params", "GLint *") + ) + "glNamedRenderbufferStorageMultisampleEXT"( + void, + GLuint("renderbuffer"), + GLsizei("samples"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height") + ) + "glNamedRenderbufferStorageMultisampleCoverageEXT"( + void, + GLuint("renderbuffer"), + GLsizei("coverageSamples"), + GLsizei("colorSamples"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height") + ) + "glCheckNamedFramebufferStatusEXT"(GLenum, GLuint("framebuffer"), GLenum("target")) + "glNamedFramebufferTexture1DEXT"( + void, + GLuint("framebuffer"), + GLenum("attachment"), + GLenum("textarget"), + GLuint("texture"), + GLint("level") + ) + "glNamedFramebufferTexture2DEXT"( + void, + GLuint("framebuffer"), + GLenum("attachment"), + GLenum("textarget"), + GLuint("texture"), + GLint("level") + ) + "glNamedFramebufferTexture3DEXT"( + void, + GLuint("framebuffer"), + GLenum("attachment"), + GLenum("textarget"), + GLuint("texture"), + GLint("level"), + GLint("zoffset") + ) + "glNamedFramebufferRenderbufferEXT"( + void, + GLuint("framebuffer"), + GLenum("attachment"), + GLenum("renderbuffertarget"), + GLuint("renderbuffer") + ) + "glGetNamedFramebufferAttachmentParameterivEXT"( + void, + GLuint("framebuffer"), + GLenum("attachment"), + GLenum("pname"), + address("params", "GLint *") + ) + "glGenerateTextureMipmapEXT"(void, GLuint("texture"), GLenum("target")) + "glGenerateMultiTexMipmapEXT"(void, GLenum("texunit"), GLenum("target")) + "glFramebufferDrawBufferEXT"(void, GLuint("framebuffer"), GLenum("mode")) + "glFramebufferDrawBuffersEXT"(void, GLuint("framebuffer"), GLsizei("n"), address("bufs", "const GLenum *")) + "glFramebufferReadBufferEXT"(void, GLuint("framebuffer"), GLenum("mode")) + "glGetFramebufferParameterivEXT"(void, GLuint("framebuffer"), GLenum("pname"), address("params", "GLint *")) + "glNamedCopyBufferSubDataEXT"( + void, + GLuint("readBuffer"), + GLuint("writeBuffer"), + GLintptr("readOffset"), + GLintptr("writeOffset"), + GLsizeiptr("size") + ) + "glNamedFramebufferTextureEXT"( + void, + GLuint("framebuffer"), + GLenum("attachment"), + GLuint("texture"), + GLint("level") + ) + "glNamedFramebufferTextureLayerEXT"( + void, + GLuint("framebuffer"), + GLenum("attachment"), + GLuint("texture"), + GLint("level"), + GLint("layer") + ) + "glNamedFramebufferTextureFaceEXT"( + void, + GLuint("framebuffer"), + GLenum("attachment"), + GLuint("texture"), + GLint("level"), + GLenum("face") + ) + "glTextureRenderbufferEXT"(void, GLuint("texture"), GLenum("target"), GLuint("renderbuffer")) + "glMultiTexRenderbufferEXT"(void, GLenum("texunit"), GLenum("target"), GLuint("renderbuffer")) + "glVertexArrayVertexOffsetEXT"( + void, + GLuint("vaobj"), + GLuint("buffer"), + GLint("size"), + GLenum("type"), + GLsizei("stride"), + GLintptr("offset") + ) + "glVertexArrayColorOffsetEXT"( + void, + GLuint("vaobj"), + GLuint("buffer"), + GLint("size"), + GLenum("type"), + GLsizei("stride"), + GLintptr("offset") + ) + "glVertexArrayEdgeFlagOffsetEXT"(void, GLuint("vaobj"), GLuint("buffer"), GLsizei("stride"), GLintptr("offset")) + "glVertexArrayIndexOffsetEXT"( + void, + GLuint("vaobj"), + GLuint("buffer"), + GLenum("type"), + GLsizei("stride"), + GLintptr("offset") + ) + "glVertexArrayNormalOffsetEXT"( + void, + GLuint("vaobj"), + GLuint("buffer"), + GLenum("type"), + GLsizei("stride"), + GLintptr("offset") + ) + "glVertexArrayTexCoordOffsetEXT"( + void, + GLuint("vaobj"), + GLuint("buffer"), + GLint("size"), + GLenum("type"), + GLsizei("stride"), + GLintptr("offset") + ) + "glVertexArrayMultiTexCoordOffsetEXT"( + void, + GLuint("vaobj"), + GLuint("buffer"), + GLenum("texunit"), + GLint("size"), + GLenum("type"), + GLsizei("stride"), + GLintptr("offset") + ) + "glVertexArrayFogCoordOffsetEXT"( + void, + GLuint("vaobj"), + GLuint("buffer"), + GLenum("type"), + GLsizei("stride"), + GLintptr("offset") + ) + "glVertexArraySecondaryColorOffsetEXT"( + void, + GLuint("vaobj"), + GLuint("buffer"), + GLint("size"), + GLenum("type"), + GLsizei("stride"), + GLintptr("offset") + ) + "glVertexArrayVertexAttribOffsetEXT"( + void, + GLuint("vaobj"), + GLuint("buffer"), + GLuint("index"), + GLint("size"), + GLenum("type"), + GLboolean("normalized"), + GLsizei("stride"), + GLintptr("offset") + ) + "glVertexArrayVertexAttribIOffsetEXT"( + void, + GLuint("vaobj"), + GLuint("buffer"), + GLuint("index"), + GLint("size"), + GLenum("type"), + GLsizei("stride"), + GLintptr("offset") + ) + "glEnableVertexArrayEXT"(void, GLuint("vaobj"), GLenum("array")) + "glDisableVertexArrayEXT"(void, GLuint("vaobj"), GLenum("array")) + "glEnableVertexArrayAttribEXT"(void, GLuint("vaobj"), GLuint("index")) + "glDisableVertexArrayAttribEXT"(void, GLuint("vaobj"), GLuint("index")) + "glGetVertexArrayIntegervEXT"(void, GLuint("vaobj"), GLenum("pname"), address("param", "GLint *")) + "glGetVertexArrayPointervEXT"(void, GLuint("vaobj"), GLenum("pname"), address("param", "void **")) + "glGetVertexArrayIntegeri_vEXT"( + void, + GLuint("vaobj"), + GLuint("index"), + GLenum("pname"), + address("param", "GLint *") + ) + "glGetVertexArrayPointeri_vEXT"( + void, + GLuint("vaobj"), + GLuint("index"), + GLenum("pname"), + address("param", "void **") + ) + "glMapNamedBufferRangeEXT"( + void, + GLuint("buffer"), + GLintptr("offset"), + GLsizeiptr("length"), + GLbitfield("access") + ) + "glFlushMappedNamedBufferRangeEXT"(void, GLuint("buffer"), GLintptr("offset"), GLsizeiptr("length")) + "glNamedBufferStorageEXT"( + void, + GLuint("buffer"), + GLsizeiptr("size"), + address("data", "const void *"), + GLbitfield("flags") + ) + "glClearNamedBufferDataEXT"( + void, + GLuint("buffer"), + GLenum("internalformat"), + GLenum("format"), + GLenum("type"), + address("data", "const void *") + ) + "glClearNamedBufferSubDataEXT"( + void, + GLuint("buffer"), + GLenum("internalformat"), + GLsizeiptr("offset"), + GLsizeiptr("size"), + GLenum("format"), + GLenum("type"), + address("data", "const void *") + ) + "glNamedFramebufferParameteriEXT"(void, GLuint("framebuffer"), GLenum("pname"), GLint("param")) + "glGetNamedFramebufferParameterivEXT"( + void, + GLuint("framebuffer"), + GLenum("pname"), + address("params", "GLint *") + ) + "glProgramUniform1dEXT"(void, GLuint("program"), GLint("location"), GLdouble("x")) + "glProgramUniform2dEXT"(void, GLuint("program"), GLint("location"), GLdouble("x"), GLdouble("y")) + "glProgramUniform3dEXT"(void, GLuint("program"), GLint("location"), GLdouble("x"), GLdouble("y"), GLdouble("z")) + "glProgramUniform4dEXT"( + void, + GLuint("program"), + GLint("location"), + GLdouble("x"), + GLdouble("y"), + GLdouble("z"), + GLdouble("w") + ) + "glProgramUniform1dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLdouble *") + ) + "glProgramUniform2dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLdouble *") + ) + "glProgramUniform3dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLdouble *") + ) + "glProgramUniform4dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + address("value", "const GLdouble *") + ) + "glProgramUniformMatrix2dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLdouble *") + ) + "glProgramUniformMatrix3dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLdouble *") + ) + "glProgramUniformMatrix4dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLdouble *") + ) + "glProgramUniformMatrix2x3dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLdouble *") + ) + "glProgramUniformMatrix2x4dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLdouble *") + ) + "glProgramUniformMatrix3x2dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLdouble *") + ) + "glProgramUniformMatrix3x4dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLdouble *") + ) + "glProgramUniformMatrix4x2dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLdouble *") + ) + "glProgramUniformMatrix4x3dvEXT"( + void, + GLuint("program"), + GLint("location"), + GLsizei("count"), + GLboolean("transpose"), + address("value", "const GLdouble *") + ) + "glTextureBufferRangeEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLenum("internalformat"), + GLuint("buffer"), + GLintptr("offset"), + GLsizeiptr("size") + ) + "glTextureStorage1DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLsizei("levels"), + GLenum("internalformat"), + GLsizei("width") + ) + "glTextureStorage2DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLsizei("levels"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height") + ) + "glTextureStorage3DEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLsizei("levels"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLsizei("depth") + ) + "glTextureStorage2DMultisampleEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLsizei("samples"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLboolean("fixedsamplelocations") + ) + "glTextureStorage3DMultisampleEXT"( + void, + GLuint("texture"), + GLenum("target"), + GLsizei("samples"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height"), + GLsizei("depth"), + GLboolean("fixedsamplelocations") + ) + "glVertexArrayBindVertexBufferEXT"( + void, + GLuint("vaobj"), + GLuint("bindingindex"), + GLuint("buffer"), + GLintptr("offset"), + GLsizei("stride") + ) + "glVertexArrayVertexAttribFormatEXT"( + void, + GLuint("vaobj"), + GLuint("attribindex"), + GLint("size"), + GLenum("type"), + GLboolean("normalized"), + GLuint("relativeoffset") + ) + "glVertexArrayVertexAttribIFormatEXT"( + void, + GLuint("vaobj"), + GLuint("attribindex"), + GLint("size"), + GLenum("type"), + GLuint("relativeoffset") + ) + "glVertexArrayVertexAttribLFormatEXT"( + void, + GLuint("vaobj"), + GLuint("attribindex"), + GLint("size"), + GLenum("type"), + GLuint("relativeoffset") + ) + "glVertexArrayVertexAttribBindingEXT"(void, GLuint("vaobj"), GLuint("attribindex"), GLuint("bindingindex")) + "glVertexArrayVertexBindingDivisorEXT"(void, GLuint("vaobj"), GLuint("bindingindex"), GLuint("divisor")) + "glVertexArrayVertexAttribLOffsetEXT"( + void, + GLuint("vaobj"), + GLuint("buffer"), + GLuint("index"), + GLint("size"), + GLenum("type"), + GLsizei("stride"), + GLintptr("offset") + ) + "glTexturePageCommitmentEXT"( + void, + GLuint("texture"), + GLint("level"), + GLint("xoffset"), + GLint("yoffset"), + GLint("zoffset"), + GLsizei("width"), + GLsizei("height"), + GLsizei("depth"), + GLboolean("commit") + ) + "glVertexArrayVertexAttribDivisorEXT"(void, GLuint("vaobj"), GLuint("index"), GLuint("divisor")) + } + file("DrawBuffers2", EXT, "GL_EXT_draw_buffers2") { + "glColorMaskIndexedEXT"(void, GLuint("index"), GLboolean("r"), GLboolean("g"), GLboolean("b"), GLboolean("a")) + } + file("DrawInstanced", EXT, "GL_EXT_draw_instanced") { + "glDrawArraysInstancedEXT"(void, GLenum("mode"), GLint("start"), GLsizei("count"), GLsizei("primcount")) + "glDrawElementsInstancedEXT"( + void, + GLenum("mode"), + GLsizei("count"), + GLenum("type"), + address("indices", "const void *"), + GLsizei("primcount") + ) + } + file("DrawRangedElements", EXT, "GL_EXT_draw_range_elements") { + "GL_MAX_ELEMENTS_VERTICES_EXT"("0x80E8") + "GL_MAX_ELEMENTS_INDICES_EXT"("0x80E9") + "glDrawRangeElementsEXT"( + void, + GLenum("mode"), + GLuint("start"), + GLuint("end"), + GLsizei("count"), + GLenum("type"), + address("indices", "const void *") + ) + } + file("ExternalBuffer", EXT, "GL_EXT_external_buffer") { + "glBufferStorageExternalEXT"( + void, + GLenum("target"), + GLintptr("offset"), + GLsizeiptr("size"), + address("clientBuffer", "GLeglClientBufferEXT"), + GLbitfield("flags") + ) + "glNamedBufferStorageExternalEXT"( + void, + GLuint("buffer"), + GLintptr("offset"), + GLsizeiptr("size"), + address("clientBuffer", "GLeglClientBufferEXT"), + GLbitfield("flags") + ) + } + file("FogCoord", EXT, "GL_EXT_fog_coord") { + "GL_FOG_COORDINATE_SOURCE_EXT"("0x8450") + "GL_FOG_COORDINATE_EXT"("0x8451") + "GL_FRAGMENT_DEPTH_EXT"("0x8452") + "GL_CURRENT_FOG_COORDINATE_EXT"("0x8453") + "GL_FOG_COORDINATE_ARRAY_TYPE_EXT"("0x8454") + "GL_FOG_COORDINATE_ARRAY_STRIDE_EXT"("0x8455") + "GL_FOG_COORDINATE_ARRAY_POINTER_EXT"("0x8456") + "GL_FOG_COORDINATE_ARRAY_EXT"("0x8457") + "glFogCoordfEXT"(void, GLfloat("coord")) + "glFogCoordfvEXT"(void, address("coord", "const GLfloat *")) + "glFogCoorddEXT"(void, GLdouble("coord")) + "glFogCoorddvEXT"(void, address("coord", "const GLdouble *")) + "glFogCoordPointerEXT"(void, GLenum("type"), GLsizei("stride"), address("pointer", "const void *")) + } + file("FramebufferBlit", EXT, "GL_EXT_framebuffer_blit") { + "GL_READ_FRAMEBUFFER_EXT"("0x8CA8") + "GL_DRAW_FRAMEBUFFER_EXT"("0x8CA9") + "GL_DRAW_FRAMEBUFFER_BINDING_EXT"("0x8CA6") + "GL_READ_FRAMEBUFFER_BINDING_EXT"("0x8CAA") + "glBlitFramebufferEXT"( + void, + GLint("srcX0"), + GLint("srcY0"), + GLint("srcX1"), + GLint("srcY1"), + GLint("dstX0"), + GLint("dstY0"), + GLint("dstX1"), + GLint("dstY1"), + GLbitfield("mask"), + GLenum("filter") + ) + } + file("FramebufferBlitLayers", EXT, "GL_EXT_framebuffer_blit_layers") { + "glBlitFramebufferLayersEXT"( + void, + GLint("srcX0"), + GLint("srcY0"), + GLint("srcX1"), + GLint("srcY1"), + GLint("dstX0"), + GLint("dstY0"), + GLint("dstX1"), + GLint("dstY1"), + GLbitfield("mask"), + GLenum("filter") + ) + "glBlitFramebufferLayerEXT"( + void, + GLint("srcX0"), + GLint("srcY0"), + GLint("srcX1"), + GLint("srcY1"), + GLint("srcLayer"), + GLint("dstX0"), + GLint("dstY0"), + GLint("dstX1"), + GLint("dstY1"), + GLint("dstLayer"), + GLbitfield("mask"), + GLenum("filter") + ) + } + file("FramebufferMultisample", EXT, "GL_EXT_framebuffer_multisample") { + "GL_RENDERBUFFER_SAMPLES_EXT"("0x8CAB") + "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT"("0x8D56") + "GL_MAX_SAMPLES_EXT"("0x8D57") + "glRenderbufferStorageMultisampleEXT"( + void, + GLenum("target"), + GLsizei("samples"), + GLenum("internalformat"), + GLsizei("width"), + GLsizei("height") + ) + } + file( + "FramebufferMultisampleBlitScaled", EXT, "GL_EXT_framebuffer_multisample_blit_scaled", + "GL_SCALED_RESOLVE_FASTEST_EXT" to "0x90BA", + "GL_SCALED_RESOLVE_NICEST_EXT" to "0x90BB" + ) + file("FramebufferObject", EXT, "GL_EXT_framebuffer_object") { + "GL_INVALID_FRAMEBUFFER_OPERATION_EXT"("0x0506") + "GL_MAX_RENDERBUFFER_SIZE_EXT"("0x84E8") + "GL_FRAMEBUFFER_BINDING_EXT"("0x8CA6") + "GL_RENDERBUFFER_BINDING_EXT"("0x8CA7") + "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT"("0x8CD0") + "GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT"("0x8CD1") + "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT"("0x8CD2") + "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT"("0x8CD3") + "GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT"("0x8CD4") + "GL_FRAMEBUFFER_COMPLETE_EXT"("0x8CD5") + "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT"("0x8CD6") + "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT"("0x8CD7") + "GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT"("0x8CD9") + "GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT"("0x8CDA") + "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT"("0x8CDB") + "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT"("0x8CDC") + "GL_FRAMEBUFFER_UNSUPPORTED_EXT"("0x8CDD") + "GL_MAX_COLOR_ATTACHMENTS_EXT"("0x8CDF") + "GL_COLOR_ATTACHMENT0_EXT"("0x8CE0") + "GL_COLOR_ATTACHMENT1_EXT"("0x8CE1") + "GL_COLOR_ATTACHMENT2_EXT"("0x8CE2") + "GL_COLOR_ATTACHMENT3_EXT"("0x8CE3") + "GL_COLOR_ATTACHMENT4_EXT"("0x8CE4") + "GL_COLOR_ATTACHMENT5_EXT"("0x8CE5") + "GL_COLOR_ATTACHMENT6_EXT"("0x8CE6") + "GL_COLOR_ATTACHMENT7_EXT"("0x8CE7") + "GL_COLOR_ATTACHMENT8_EXT"("0x8CE8") + "GL_COLOR_ATTACHMENT9_EXT"("0x8CE9") + "GL_COLOR_ATTACHMENT10_EXT"("0x8CEA") + "GL_COLOR_ATTACHMENT11_EXT"("0x8CEB") + "GL_COLOR_ATTACHMENT12_EXT"("0x8CEC") + "GL_COLOR_ATTACHMENT13_EXT"("0x8CED") + "GL_COLOR_ATTACHMENT14_EXT"("0x8CEE") + "GL_COLOR_ATTACHMENT15_EXT"("0x8CEF") + "GL_DEPTH_ATTACHMENT_EXT"("0x8D00") + "GL_STENCIL_ATTACHMENT_EXT"("0x8D20") + "GL_FRAMEBUFFER_EXT"("0x8D40") + "GL_RENDERBUFFER_EXT"("0x8D41") + "GL_RENDERBUFFER_WIDTH_EXT"("0x8D42") + "GL_RENDERBUFFER_HEIGHT_EXT"("0x8D43") + "GL_RENDERBUFFER_INTERNAL_FORMAT_EXT"("0x8D44") + "GL_STENCIL_INDEX1_EXT"("0x8D46") + "GL_STENCIL_INDEX4_EXT"("0x8D47") + "GL_STENCIL_INDEX8_EXT"("0x8D48") + "GL_STENCIL_INDEX16_EXT"("0x8D49") + "GL_RENDERBUFFER_RED_SIZE_EXT"("0x8D50") + "GL_RENDERBUFFER_GREEN_SIZE_EXT"("0x8D51") + "GL_RENDERBUFFER_BLUE_SIZE_EXT"("0x8D52") + "GL_RENDERBUFFER_ALPHA_SIZE_EXT"("0x8D53") + "GL_RENDERBUFFER_DEPTH_SIZE_EXT"("0x8D54") + "GL_RENDERBUFFER_STENCIL_SIZE_EXT"("0x8D55") + "glIsRenderbufferEXT"(GLboolean, GLuint("renderbuffer")) + "glBindRenderbufferEXT"(void, GLenum("target"), GLuint("renderbuffer")) + "glDeleteRenderbuffersEXT"(void, GLsizei("n"), address("renderbuffers", "const GLuint *")) + "glGenRenderbuffersEXT"(void, GLsizei("n"), address("renderbuffers", "GLuint *")) + "glRenderbufferStorageEXT"(void, GLenum("target"), GLenum("internalformat"), GLsizei("width"), GLsizei("height")) + "glGetRenderbufferParameterivEXT"(void, GLenum("target"), GLenum("pname"), address("params", "GLint *")) + "glIsFramebufferEXT"(GLboolean, GLuint("framebuffer")) + "glBindFramebufferEXT"(void, GLenum("target"), GLuint("framebuffer")) + "glDeleteFramebuffersEXT"(void, GLsizei("n"), address("framebuffers", "const GLuint *")) + "glGenFramebuffersEXT"(void, GLsizei("n"), address("framebuffers", "GLuint *")) + "glCheckFramebufferStatusEXT"(GLenum, GLenum("target")) + "glFramebufferTexture1DEXT"( + void, + GLenum("target"), + GLenum("attachment"), + GLenum("textarget"), + GLuint("texture"), + GLint("level") + ) + "glFramebufferTexture2DEXT"( + void, + GLenum("target"), + GLenum("attachment"), + GLenum("textarget"), + GLuint("texture"), + GLint("level") + ) + "glFramebufferTexture3DEXT"( + void, + GLenum("target"), + GLenum("attachment"), + GLenum("textarget"), + GLuint("texture"), + GLint("level"), + GLint("zoffset") + ) + "glFramebufferRenderbufferEXT"( + void, + GLenum("target"), + GLenum("attachment"), + GLenum("renderbuffertarget"), + GLuint("renderbuffer") + ) + "glGetFramebufferAttachmentParameterivEXT"( + void, + GLenum("target"), + GLenum("attachment"), + GLenum("pname"), + address("params", "GLint *") + ) + "glGenerateMipmapEXT"(void, GLenum("target")) + } + file( + "Srgb", EXT, "GL_EXT_framebuffer_sRGB", + "GL_FRAMEBUFFER_SRGB_EXT" to "0x8DB9", + "GL_FRAMEBUFFER_SRGB_CAPABLE_EXT" to "0x8DBA" + ) +} diff --git a/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/OpenGLGenerator.kt b/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/OpenGLGenerator.kt index 10ae12f3..426e915e 100644 --- a/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/OpenGLGenerator.kt +++ b/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/OpenGLGenerator.kt @@ -1199,16 +1199,6 @@ fun ati() { } } -fun ext() { - file( - "422Pixels", EXT, "GL_EXT_422_pixels", - "GL_422_EXT" to "0x80CC", - "GL_422_REV_EXT" to "0x80CD", - "GL_422_AVERAGE_EXT" to "0x80CE", - "GL_422_REV_AVERAGE_EXT" to "0x80CF" - ) -} - fun gremedy() { file("FrameTerminator", GREMEDY, "GL_GREMEDY_frame_terminator") { "glFrameTerminatorGREMEDY"(void) diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/GLExtCaps.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/GLExtCaps.java index f3b9985a..16b84e3c 100644 --- a/modules/overrungl.opengl/src/main/java/overrungl/opengl/GLExtCaps.java +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/GLExtCaps.java @@ -103,49 +103,71 @@ public GLExtCaps(GLCapabilities caps) { glGetObjectBufferivATI, glFreeObjectBufferATI, glArrayObjectATI, glGetArrayObjectfvATI, glGetArrayObjectivATI, glVariantArrayObjectATI, glGetVariantArrayObjectfvATI, glGetVariantArrayObjectivATI, glVertexAttribArrayObjectATI, glGetVertexAttribArrayObjectfvATI, glGetVertexAttribArrayObjectivATI, glVertexStream1sATI, glVertexStream1svATI, glVertexStream1iATI, glVertexStream1ivATI, glVertexStream1fATI, glVertexStream1fvATI, glVertexStream1dATI, glVertexStream1dvATI, glVertexStream2sATI, glVertexStream2svATI, glVertexStream2iATI, glVertexStream2ivATI, glVertexStream2fATI, glVertexStream2fvATI, glVertexStream2dATI, glVertexStream2dvATI, glVertexStream3sATI, glVertexStream3svATI, glVertexStream3iATI, glVertexStream3ivATI, glVertexStream3fATI, glVertexStream3fvATI, glVertexStream3dATI, glVertexStream3dvATI, glVertexStream4sATI, glVertexStream4svATI, glVertexStream4iATI, glVertexStream4ivATI, glVertexStream4fATI, glVertexStream4fvATI, glVertexStream4dATI, glVertexStream4dvATI, glNormalStream3bATI, glNormalStream3bvATI, glNormalStream3sATI, glNormalStream3svATI, glNormalStream3iATI, - glNormalStream3ivATI, glNormalStream3fATI, glNormalStream3fvATI, glNormalStream3dATI, glNormalStream3dvATI, glClientActiveVertexStreamATI, glVertexBlendEnviATI, glVertexBlendEnvfATI, glFrameTerminatorGREMEDY, glStringMarkerGREMEDY, glImageTransformParameteriHP, glImageTransformParameterfHP, glImageTransformParameterivHP, glImageTransformParameterfvHP, glGetImageTransformParameterivHP, glGetImageTransformParameterfvHP, - glMultiModeDrawArraysIBM, glMultiModeDrawElementsIBM, glFlushStaticDataIBM, glColorPointerListIBM, glSecondaryColorPointerListIBM, glEdgeFlagPointerListIBM, glFogCoordPointerListIBM, glIndexPointerListIBM, glNormalPointerListIBM, glTexCoordPointerListIBM, glVertexPointerListIBM, glBlendFuncSeparateINGR, glApplyFramebufferAttachmentCMAAINTEL, glSyncTextureINTEL, glUnmapTexture2DINTEL, glMapTexture2DINTEL, - glVertexPointervINTEL, glNormalPointervINTEL, glColorPointervINTEL, glTexCoordPointervINTEL, glBeginPerfQueryINTEL, glCreatePerfQueryINTEL, glDeletePerfQueryINTEL, glEndPerfQueryINTEL, glGetFirstPerfQueryIdINTEL, glGetNextPerfQueryIdINTEL, glGetPerfCounterInfoINTEL, glGetPerfQueryDataINTEL, glGetPerfQueryIdByNameINTEL, glGetPerfQueryInfoINTEL, glFramebufferParameteriMESA, glGetFramebufferParameterivMESA, - glResizeBuffersMESA, glWindowPos2dMESA, glWindowPos2dvMESA, glWindowPos2fMESA, glWindowPos2fvMESA, glWindowPos2iMESA, glWindowPos2ivMESA, glWindowPos2sMESA, glWindowPos2svMESA, glWindowPos3dMESA, glWindowPos3dvMESA, glWindowPos3fMESA, glWindowPos3fvMESA, glWindowPos3iMESA, glWindowPos3ivMESA, glWindowPos3sMESA, - glWindowPos3svMESA, glWindowPos4dMESA, glWindowPos4dvMESA, glWindowPos4fMESA, glWindowPos4fvMESA, glWindowPos4iMESA, glWindowPos4ivMESA, glWindowPos4sMESA, glWindowPos4svMESA, glBeginConditionalRenderNVX, glEndConditionalRenderNVX, glUploadGpuMaskNVX, glMulticastViewportArrayvNVX, glMulticastViewportPositionWScaleNVX, glMulticastScissorArrayvNVX, glAsyncCopyBufferSubDataNVX, - glAsyncCopyImageSubDataNVX, glLGPUNamedBufferSubDataNVX, glLGPUCopyImageSubDataNVX, glLGPUInterlockNVX, glCreateProgressFenceNVX, glSignalSemaphoreui64NVX, glWaitSemaphoreui64NVX, glClientWaitSemaphoreui64NVX, glAlphaToCoverageDitherControlNV, glMultiDrawArraysIndirectBindlessNV, glMultiDrawElementsIndirectBindlessNV, glMultiDrawArraysIndirectBindlessCountNV, glMultiDrawElementsIndirectBindlessCountNV, glGetTextureHandleNV, glGetTextureSamplerHandleNV, glMakeTextureHandleResidentNV, - glMakeTextureHandleNonResidentNV, glGetImageHandleNV, glMakeImageHandleResidentNV, glMakeImageHandleNonResidentNV, glUniformHandleui64NV, glUniformHandleui64vNV, glProgramUniformHandleui64NV, glProgramUniformHandleui64vNV, glIsTextureHandleResidentNV, glIsImageHandleResidentNV, glBlendParameteriNV, glBlendBarrierNV, glViewportPositionWScaleNV, glCreateStatesNV, glDeleteStatesNV, glIsStateNV, - glStateCaptureNV, glGetCommandHeaderNV, glGetStageIndexNV, glDrawCommandsNV, glDrawCommandsAddressNV, glDrawCommandsStatesNV, glDrawCommandsStatesAddressNV, glCreateCommandListsNV, glDeleteCommandListsNV, glIsCommandListNV, glListDrawCommandsStatesClientNV, glCommandListSegmentsNV, glCompileCommandListNV, glCallCommandListNV, glBeginConditionalRenderNV, glEndConditionalRenderNV, - glSubpixelPrecisionBiasNV, glConservativeRasterParameterfNV, glConservativeRasterParameteriNV, glCopyImageSubDataNV, glDepthRangedNV, glClearDepthdNV, glDepthBoundsdNV, glDrawTextureNV, glDrawVkImageNV, glGetVkProcAddrNV, glWaitVkSemaphoreNV, glSignalVkSemaphoreNV, glSignalVkFenceNV, glMapControlPointsNV, glMapParameterivNV, glMapParameterfvNV, - glGetMapControlPointsNV, glGetMapParameterivNV, glGetMapParameterfvNV, glGetMapAttribParameterivNV, glGetMapAttribParameterfvNV, glEvalMapsNV, glGetMultisamplefvNV, glSampleMaskIndexedNV, glTexRenderbufferNV, glDeleteFencesNV, glGenFencesNV, glIsFenceNV, glTestFenceNV, glGetFenceivNV, glFinishFenceNV, glSetFenceNV, - glFragmentCoverageColorNV, glProgramNamedParameter4fNV, glProgramNamedParameter4fvNV, glProgramNamedParameter4dNV, glProgramNamedParameter4dvNV, glGetProgramNamedParameterfvNV, glGetProgramNamedParameterdvNV, glCoverageModulationTableNV, glGetCoverageModulationTableNV, glCoverageModulationNV, glRenderbufferStorageMultisampleCoverageNV, glProgramVertexLimitNV, glFramebufferTextureEXT, glFramebufferTextureFaceEXT, glRenderGpuMaskNV, glMulticastBufferSubDataNV, - glMulticastCopyBufferSubDataNV, glMulticastCopyImageSubDataNV, glMulticastBlitFramebufferNV, glMulticastFramebufferSampleLocationsfvNV, glMulticastBarrierNV, glMulticastWaitSyncNV, glMulticastGetQueryObjectivNV, glMulticastGetQueryObjectuivNV, glMulticastGetQueryObjecti64vNV, glMulticastGetQueryObjectui64vNV, glProgramLocalParameterI4iNV, glProgramLocalParameterI4ivNV, glProgramLocalParametersI4ivNV, glProgramLocalParameterI4uiNV, glProgramLocalParameterI4uivNV, glProgramLocalParametersI4uivNV, - glProgramEnvParameterI4iNV, glProgramEnvParameterI4ivNV, glProgramEnvParametersI4ivNV, glProgramEnvParameterI4uiNV, glProgramEnvParameterI4uivNV, glProgramEnvParametersI4uivNV, glGetProgramLocalParameterIivNV, glGetProgramLocalParameterIuivNV, glGetProgramEnvParameterIivNV, glGetProgramEnvParameterIuivNV, glProgramSubroutineParametersuivNV, glGetProgramSubroutineParameteruivNV, glVertex2hNV, glVertex2hvNV, glVertex3hNV, glVertex3hvNV, - glVertex4hNV, glVertex4hvNV, glNormal3hNV, glNormal3hvNV, glColor3hNV, glColor3hvNV, glColor4hNV, glColor4hvNV, glTexCoord1hNV, glTexCoord1hvNV, glTexCoord2hNV, glTexCoord2hvNV, glTexCoord3hNV, glTexCoord3hvNV, glTexCoord4hNV, glTexCoord4hvNV, - glMultiTexCoord1hNV, glMultiTexCoord1hvNV, glMultiTexCoord2hNV, glMultiTexCoord2hvNV, glMultiTexCoord3hNV, glMultiTexCoord3hvNV, glMultiTexCoord4hNV, glMultiTexCoord4hvNV, glVertexAttrib1hNV, glVertexAttrib1hvNV, glVertexAttrib2hNV, glVertexAttrib2hvNV, glVertexAttrib3hNV, glVertexAttrib3hvNV, glVertexAttrib4hNV, glVertexAttrib4hvNV, - glVertexAttribs1hvNV, glVertexAttribs2hvNV, glVertexAttribs3hvNV, glVertexAttribs4hvNV, glFogCoordhNV, glFogCoordhvNV, glSecondaryColor3hNV, glSecondaryColor3hvNV, glVertexWeighthNV, glVertexWeighthvNV, glGetInternalformatSampleivNV, glGetMemoryObjectDetachedResourcesuivNV, glResetMemoryObjectParameterNV, glTexAttachMemoryNV, glBufferAttachMemoryNV, glTextureAttachMemoryNV, - glNamedBufferAttachMemoryNV, glBufferPageCommitmentMemNV, glTexPageCommitmentMemNV, glNamedBufferPageCommitmentMemNV, glTexturePageCommitmentMemNV, glDrawMeshTasksNV, glDrawMeshTasksIndirectNV, glMultiDrawMeshTasksIndirectNV, glMultiDrawMeshTasksIndirectCountNV, glGenOcclusionQueriesNV, glDeleteOcclusionQueriesNV, glIsOcclusionQueryNV, glBeginOcclusionQueryNV, glEndOcclusionQueryNV, glGetOcclusionQueryivNV, glGetOcclusionQueryuivNV, - glProgramBufferParametersfvNV, glProgramBufferParametersIivNV, glProgramBufferParametersIuivNV, glGenPathsNV, glDeletePathsNV, glIsPathNV, glPathCommandsNV, glPathCoordsNV, glPathSubCommandsNV, glPathSubCoordsNV, glPathStringNV, glPathGlyphsNV, glPathGlyphRangeNV, glWeightPathsNV, glCopyPathNV, glInterpolatePathsNV, - glTransformPathNV, glPathParameterivNV, glPathParameteriNV, glPathParameterfvNV, glPathParameterfNV, glPathDashArrayNV, glPathStencilFuncNV, glPathStencilDepthOffsetNV, glStencilFillPathNV, glStencilStrokePathNV, glStencilFillPathInstancedNV, glStencilStrokePathInstancedNV, glPathCoverDepthFuncNV, glCoverFillPathNV, glCoverStrokePathNV, glCoverFillPathInstancedNV, - glCoverStrokePathInstancedNV, glGetPathParameterivNV, glGetPathParameterfvNV, glGetPathCommandsNV, glGetPathCoordsNV, glGetPathDashArrayNV, glGetPathMetricsNV, glGetPathMetricRangeNV, glGetPathSpacingNV, glIsPointInFillPathNV, glIsPointInStrokePathNV, glGetPathLengthNV, glPointAlongPathNV, glMatrixLoad3x2fNV, glMatrixLoad3x3fNV, glMatrixLoadTranspose3x3fNV, - glMatrixMult3x2fNV, glMatrixMult3x3fNV, glMatrixMultTranspose3x3fNV, glStencilThenCoverFillPathNV, glStencilThenCoverStrokePathNV, glStencilThenCoverFillPathInstancedNV, glStencilThenCoverStrokePathInstancedNV, glPathGlyphIndexRangeNV, glPathGlyphIndexArrayNV, glPathMemoryGlyphIndexArrayNV, glProgramPathFragmentInputGenNV, glGetProgramResourcefvNV, glPathColorGenNV, glPathTexGenNV, glPathFogGenNV, glGetPathColorGenivNV, - glGetPathColorGenfvNV, glGetPathTexGenivNV, glGetPathTexGenfvNV, glPixelDataRangeNV, glFlushPixelDataRangeNV, glPointParameteriNV, glPointParameterivNV, glPresentFrameKeyedNV, glPresentFrameDualFillNV, glGetVideoivNV, glGetVideouivNV, glGetVideoi64vNV, glGetVideoui64vNV, glPrimitiveRestartNV, glPrimitiveRestartIndexNV, glQueryResourceNV, - glGenQueryResourceTagNV, glDeleteQueryResourceTagNV, glQueryResourceTagNV, glCombinerParameterfvNV, glCombinerParameterfNV, glCombinerParameterivNV, glCombinerParameteriNV, glCombinerInputNV, glCombinerOutputNV, glFinalCombinerInputNV, glGetCombinerInputParameterfvNV, glGetCombinerInputParameterivNV, glGetCombinerOutputParameterfvNV, glGetCombinerOutputParameterivNV, glGetFinalCombinerInputParameterfvNV, glGetFinalCombinerInputParameterivNV, - glCombinerStageParameterfvNV, glGetCombinerStageParameterfvNV, glFramebufferSampleLocationsfvNV, glNamedFramebufferSampleLocationsfvNV, glResolveDepthValuesNV, glScissorExclusiveNV, glScissorExclusiveArrayvNV, glMakeBufferResidentNV, glMakeBufferNonResidentNV, glIsBufferResidentNV, glMakeNamedBufferResidentNV, glMakeNamedBufferNonResidentNV, glIsNamedBufferResidentNV, glGetBufferParameterui64vNV, glGetNamedBufferParameterui64vNV, glGetIntegerui64vNV, - glUniformui64NV, glUniformui64vNV, glProgramUniformui64NV, glProgramUniformui64vNV, glBindShadingRateImageNV, glGetShadingRateImagePaletteNV, glGetShadingRateSampleLocationivNV, glShadingRateImageBarrierNV, glShadingRateImagePaletteNV, glShadingRateSampleOrderNV, glShadingRateSampleOrderCustomNV, glTextureBarrierNV, glTexImage2DMultisampleCoverageNV, glTexImage3DMultisampleCoverageNV, glTextureImage2DMultisampleNV, glTextureImage3DMultisampleNV, - glTextureImage2DMultisampleCoverageNV, glTextureImage3DMultisampleCoverageNV, glCreateSemaphoresNV, glSemaphoreParameterivNV, glGetSemaphoreParameterivNV, glBeginTransformFeedbackNV, glEndTransformFeedbackNV, glTransformFeedbackAttribsNV, glBindBufferRangeNV, glBindBufferOffsetNV, glBindBufferBaseNV, glTransformFeedbackVaryingsNV, glActiveVaryingNV, glGetVaryingLocationNV, glGetActiveVaryingNV, glGetTransformFeedbackVaryingNV, - glTransformFeedbackStreamAttribsNV, glBindTransformFeedbackNV, glDeleteTransformFeedbacksNV, glGenTransformFeedbacksNV, glIsTransformFeedbackNV, glPauseTransformFeedbackNV, glResumeTransformFeedbackNV, glDrawTransformFeedbackNV, glVDPAUInitNV, glVDPAUFiniNV, glVDPAURegisterVideoSurfaceNV, glVDPAURegisterOutputSurfaceNV, glVDPAUIsSurfaceNV, glVDPAUUnregisterSurfaceNV, glVDPAUGetSurfaceivNV, glVDPAUSurfaceAccessNV, - glVDPAUMapSurfacesNV, glVDPAUUnmapSurfacesNV, glVDPAURegisterVideoSurfaceWithPictureStructureNV, glFlushVertexArrayRangeNV, glVertexArrayRangeNV, glVertexAttribL1i64NV, glVertexAttribL2i64NV, glVertexAttribL3i64NV, glVertexAttribL4i64NV, glVertexAttribL1i64vNV, glVertexAttribL2i64vNV, glVertexAttribL3i64vNV, glVertexAttribL4i64vNV, glVertexAttribL1ui64NV, glVertexAttribL2ui64NV, glVertexAttribL3ui64NV, - glVertexAttribL4ui64NV, glVertexAttribL1ui64vNV, glVertexAttribL2ui64vNV, glVertexAttribL3ui64vNV, glVertexAttribL4ui64vNV, glGetVertexAttribLi64vNV, glGetVertexAttribLui64vNV, glVertexAttribLFormatNV, glBufferAddressRangeNV, glVertexFormatNV, glNormalFormatNV, glColorFormatNV, glIndexFormatNV, glTexCoordFormatNV, glEdgeFlagFormatNV, glSecondaryColorFormatNV, - glFogCoordFormatNV, glVertexAttribFormatNV, glVertexAttribIFormatNV, glGetIntegerui64i_vNV, glAreProgramsResidentNV, glBindProgramNV, glDeleteProgramsNV, glExecuteProgramNV, glGenProgramsNV, glGetProgramParameterdvNV, glGetProgramParameterfvNV, glGetProgramivNV, glGetProgramStringNV, glGetTrackMatrixivNV, glGetVertexAttribdvNV, glGetVertexAttribfvNV, - glGetVertexAttribivNV, glGetVertexAttribPointervNV, glIsProgramNV, glLoadProgramNV, glProgramParameter4dNV, glProgramParameter4dvNV, glProgramParameter4fNV, glProgramParameter4fvNV, glProgramParameters4dvNV, glProgramParameters4fvNV, glRequestResidentProgramsNV, glTrackMatrixNV, glVertexAttribPointerNV, glVertexAttrib1dNV, glVertexAttrib1dvNV, glVertexAttrib1fNV, - glVertexAttrib1fvNV, glVertexAttrib1sNV, glVertexAttrib1svNV, glVertexAttrib2dNV, glVertexAttrib2dvNV, glVertexAttrib2fNV, glVertexAttrib2fvNV, glVertexAttrib2sNV, glVertexAttrib2svNV, glVertexAttrib3dNV, glVertexAttrib3dvNV, glVertexAttrib3fNV, glVertexAttrib3fvNV, glVertexAttrib3sNV, glVertexAttrib3svNV, glVertexAttrib4dNV, - glVertexAttrib4dvNV, glVertexAttrib4fNV, glVertexAttrib4fvNV, glVertexAttrib4sNV, glVertexAttrib4svNV, glVertexAttrib4ubNV, glVertexAttrib4ubvNV, glVertexAttribs1dvNV, glVertexAttribs1fvNV, glVertexAttribs1svNV, glVertexAttribs2dvNV, glVertexAttribs2fvNV, glVertexAttribs2svNV, glVertexAttribs3dvNV, glVertexAttribs3fvNV, glVertexAttribs3svNV, - glVertexAttribs4dvNV, glVertexAttribs4fvNV, glVertexAttribs4svNV, glVertexAttribs4ubvNV, glBeginVideoCaptureNV, glBindVideoCaptureStreamBufferNV, glBindVideoCaptureStreamTextureNV, glEndVideoCaptureNV, glGetVideoCaptureivNV, glGetVideoCaptureStreamivNV, glGetVideoCaptureStreamfvNV, glGetVideoCaptureStreamdvNV, glVideoCaptureNV, glVideoCaptureStreamParameterivNV, glVideoCaptureStreamParameterfvNV, glVideoCaptureStreamParameterdvNV, - glViewportSwizzleNV, glFramebufferTextureMultiviewOVR, glHintPGI, glDetailTexFuncSGIS, glGetDetailTexFuncSGIS, glFogFuncSGIS, glGetFogFuncSGIS, glSampleMaskSGIS, glSamplePatternSGIS, glPixelTexGenParameteriSGIS, glPixelTexGenParameterivSGIS, glPixelTexGenParameterfSGIS, glPixelTexGenParameterfvSGIS, glGetPixelTexGenParameterivSGIS, glGetPixelTexGenParameterfvSGIS, glPointParameterfSGIS, - glPointParameterfvSGIS, glSharpenTexFuncSGIS, glGetSharpenTexFuncSGIS, glTexImage4DSGIS, glTexSubImage4DSGIS, glTextureColorMaskSGIS, glGetTexFilterFuncSGIS, glTexFilterFuncSGIS, glAsyncMarkerSGIX, glFinishAsyncSGIX, glPollAsyncSGIX, glGenAsyncMarkersSGIX, glDeleteAsyncMarkersSGIX, glIsAsyncMarkerSGIX, glFlushRasterSGIX, glFragmentColorMaterialSGIX, - glFragmentLightfSGIX, glFragmentLightfvSGIX, glFragmentLightiSGIX, glFragmentLightivSGIX, glFragmentLightModelfSGIX, glFragmentLightModelfvSGIX, glFragmentLightModeliSGIX, glFragmentLightModelivSGIX, glFragmentMaterialfSGIX, glFragmentMaterialfvSGIX, glFragmentMaterialiSGIX, glFragmentMaterialivSGIX, glGetFragmentLightfvSGIX, glGetFragmentLightivSGIX, glGetFragmentMaterialfvSGIX, glGetFragmentMaterialivSGIX, - glLightEnviSGIX, glFrameZoomSGIX, glIglooInterfaceSGIX, glGetInstrumentsSGIX, glInstrumentsBufferSGIX, glPollInstrumentsSGIX, glReadInstrumentsSGIX, glStartInstrumentsSGIX, glStopInstrumentsSGIX, glGetListParameterfvSGIX, glGetListParameterivSGIX, glListParameterfSGIX, glListParameterfvSGIX, glListParameteriSGIX, glListParameterivSGIX, glPixelTexGenSGIX, - glDeformationMap3dSGIX, glDeformationMap3fSGIX, glDeformSGIX, glLoadIdentityDeformationMapSGIX, glReferencePlaneSGIX, glSpriteParameterfSGIX, glSpriteParameterfvSGIX, glSpriteParameteriSGIX, glSpriteParameterivSGIX, glTagSampleBufferSGIX, glColorTableSGI, glColorTableParameterfvSGI, glColorTableParameterivSGI, glCopyColorTableSGI, glGetColorTableSGI, glGetColorTableParameterfvSGI, - glGetColorTableParameterivSGI, glFinishTextureSUNX, glGlobalAlphaFactorbSUN, glGlobalAlphaFactorsSUN, glGlobalAlphaFactoriSUN, glGlobalAlphaFactorfSUN, glGlobalAlphaFactordSUN, glGlobalAlphaFactorubSUN, glGlobalAlphaFactorusSUN, glGlobalAlphaFactoruiSUN, glDrawMeshArraysSUN, glReplacementCodeuiSUN, glReplacementCodeusSUN, glReplacementCodeubSUN, glReplacementCodeuivSUN, glReplacementCodeusvSUN, - glReplacementCodeubvSUN, glReplacementCodePointerSUN, glColor4ubVertex2fSUN, glColor4ubVertex2fvSUN, glColor4ubVertex3fSUN, glColor4ubVertex3fvSUN, glColor3fVertex3fSUN, glColor3fVertex3fvSUN, glNormal3fVertex3fSUN, glNormal3fVertex3fvSUN, glColor4fNormal3fVertex3fSUN, glColor4fNormal3fVertex3fvSUN, glTexCoord2fVertex3fSUN, glTexCoord2fVertex3fvSUN, glTexCoord4fVertex4fSUN, glTexCoord4fVertex4fvSUN, - glTexCoord2fColor4ubVertex3fSUN, glTexCoord2fColor4ubVertex3fvSUN, glTexCoord2fColor3fVertex3fSUN, glTexCoord2fColor3fVertex3fvSUN, glTexCoord2fNormal3fVertex3fSUN, glTexCoord2fNormal3fVertex3fvSUN, glTexCoord2fColor4fNormal3fVertex3fSUN, glTexCoord2fColor4fNormal3fVertex3fvSUN, glTexCoord4fColor4fNormal3fVertex4fSUN, glTexCoord4fColor4fNormal3fVertex4fvSUN, glReplacementCodeuiVertex3fSUN, glReplacementCodeuiVertex3fvSUN, glReplacementCodeuiColor4ubVertex3fSUN, glReplacementCodeuiColor4ubVertex3fvSUN, glReplacementCodeuiColor3fVertex3fSUN, glReplacementCodeuiColor3fVertex3fvSUN, - glReplacementCodeuiNormal3fVertex3fSUN, glReplacementCodeuiNormal3fVertex3fvSUN, glReplacementCodeuiColor4fNormal3fVertex3fSUN, glReplacementCodeuiColor4fNormal3fVertex3fvSUN, glReplacementCodeuiTexCoord2fVertex3fSUN, glReplacementCodeuiTexCoord2fVertex3fvSUN, glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; + glNormalStream3ivATI, glNormalStream3fATI, glNormalStream3fvATI, glNormalStream3dATI, glNormalStream3dvATI, glClientActiveVertexStreamATI, glVertexBlendEnviATI, glVertexBlendEnvfATI, glEGLImageTargetTexStorageEXT, glEGLImageTargetTextureStorageEXT, glUniformBufferEXT, glGetUniformBufferSizeEXT, glGetUniformOffsetEXT, glBlendColorEXT, glBlendEquationSeparateEXT, glBlendFuncSeparateEXT, + glBlendEquationEXT, glColorSubTableEXT, glCopyColorSubTableEXT, glLockArraysEXT, glUnlockArraysEXT, glConvolutionFilter1DEXT, glConvolutionFilter2DEXT, glConvolutionParameterfEXT, glConvolutionParameterfvEXT, glConvolutionParameteriEXT, glConvolutionParameterivEXT, glCopyConvolutionFilter1DEXT, glCopyConvolutionFilter2DEXT, glGetConvolutionFilterEXT, glGetConvolutionParameterfvEXT, glGetConvolutionParameterivEXT, + glGetSeparableFilterEXT, glSeparableFilter2DEXT, glTangent3bEXT, glTangent3bvEXT, glTangent3dEXT, glTangent3dvEXT, glTangent3fEXT, glTangent3fvEXT, glTangent3iEXT, glTangent3ivEXT, glTangent3sEXT, glTangent3svEXT, glBinormal3bEXT, glBinormal3bvEXT, glBinormal3dEXT, glBinormal3dvEXT, + glBinormal3fEXT, glBinormal3fvEXT, glBinormal3iEXT, glBinormal3ivEXT, glBinormal3sEXT, glBinormal3svEXT, glTangentPointerEXT, glBinormalPointerEXT, glCopyTexImage1DEXT, glCopyTexImage2DEXT, glCopyTexSubImage1DEXT, glCopyTexSubImage2DEXT, glCopyTexSubImage3DEXT, glCullParameterdvEXT, glCullParameterfvEXT, glLabelObjectEXT, + glGetObjectLabelEXT, glInsertEventMarkerEXT, glPushGroupMarkerEXT, glPopGroupMarkerEXT, glDepthBoundsEXT, glMatrixLoadfEXT, glMatrixLoaddEXT, glMatrixMultfEXT, glMatrixMultdEXT, glMatrixLoadIdentityEXT, glMatrixRotatefEXT, glMatrixRotatedEXT, glMatrixScalefEXT, glMatrixScaledEXT, glMatrixTranslatefEXT, glMatrixTranslatedEXT, + glMatrixFrustumEXT, glMatrixOrthoEXT, glMatrixPopEXT, glMatrixPushEXT, glClientAttribDefaultEXT, glPushClientAttribDefaultEXT, glTextureParameterfEXT, glTextureParameterfvEXT, glTextureParameteriEXT, glTextureParameterivEXT, glTextureImage1DEXT, glTextureImage2DEXT, glTextureSubImage1DEXT, glTextureSubImage2DEXT, glCopyTextureImage1DEXT, glCopyTextureImage2DEXT, + glCopyTextureSubImage1DEXT, glCopyTextureSubImage2DEXT, glGetTextureImageEXT, glGetTextureParameterfvEXT, glGetTextureParameterivEXT, glGetTextureLevelParameterfvEXT, glGetTextureLevelParameterivEXT, glTextureImage3DEXT, glTextureSubImage3DEXT, glCopyTextureSubImage3DEXT, glBindMultiTextureEXT, glMultiTexCoordPointerEXT, glMultiTexEnvfEXT, glMultiTexEnvfvEXT, glMultiTexEnviEXT, glMultiTexEnvivEXT, + glMultiTexGendEXT, glMultiTexGendvEXT, glMultiTexGenfEXT, glMultiTexGenfvEXT, glMultiTexGeniEXT, glMultiTexGenivEXT, glGetMultiTexEnvfvEXT, glGetMultiTexEnvivEXT, glGetMultiTexGendvEXT, glGetMultiTexGenfvEXT, glGetMultiTexGenivEXT, glMultiTexParameteriEXT, glMultiTexParameterivEXT, glMultiTexParameterfEXT, glMultiTexParameterfvEXT, glMultiTexImage1DEXT, + glMultiTexImage2DEXT, glMultiTexSubImage1DEXT, glMultiTexSubImage2DEXT, glCopyMultiTexImage1DEXT, glCopyMultiTexImage2DEXT, glCopyMultiTexSubImage1DEXT, glCopyMultiTexSubImage2DEXT, glGetMultiTexImageEXT, glGetMultiTexParameterfvEXT, glGetMultiTexParameterivEXT, glGetMultiTexLevelParameterfvEXT, glGetMultiTexLevelParameterivEXT, glMultiTexImage3DEXT, glMultiTexSubImage3DEXT, glCopyMultiTexSubImage3DEXT, glEnableClientStateIndexedEXT, + glDisableClientStateIndexedEXT, glGetFloatIndexedvEXT, glGetDoubleIndexedvEXT, glGetPointerIndexedvEXT, glEnableIndexedEXT, glDisableIndexedEXT, glIsEnabledIndexedEXT, glGetIntegerIndexedvEXT, glGetBooleanIndexedvEXT, glCompressedTextureImage3DEXT, glCompressedTextureImage2DEXT, glCompressedTextureImage1DEXT, glCompressedTextureSubImage3DEXT, glCompressedTextureSubImage2DEXT, glCompressedTextureSubImage1DEXT, glGetCompressedTextureImageEXT, + glCompressedMultiTexImage3DEXT, glCompressedMultiTexImage2DEXT, glCompressedMultiTexImage1DEXT, glCompressedMultiTexSubImage3DEXT, glCompressedMultiTexSubImage2DEXT, glCompressedMultiTexSubImage1DEXT, glGetCompressedMultiTexImageEXT, glMatrixLoadTransposefEXT, glMatrixLoadTransposedEXT, glMatrixMultTransposefEXT, glMatrixMultTransposedEXT, glNamedBufferDataEXT, glNamedBufferSubDataEXT, glMapNamedBufferEXT, glUnmapNamedBufferEXT, glGetNamedBufferParameterivEXT, + glGetNamedBufferPointervEXT, glGetNamedBufferSubDataEXT, glProgramUniform1fEXT, glProgramUniform2fEXT, glProgramUniform3fEXT, glProgramUniform4fEXT, glProgramUniform1iEXT, glProgramUniform2iEXT, glProgramUniform3iEXT, glProgramUniform4iEXT, glProgramUniform1fvEXT, glProgramUniform2fvEXT, glProgramUniform3fvEXT, glProgramUniform4fvEXT, glProgramUniform1ivEXT, glProgramUniform2ivEXT, + glProgramUniform3ivEXT, glProgramUniform4ivEXT, glProgramUniformMatrix2fvEXT, glProgramUniformMatrix3fvEXT, glProgramUniformMatrix4fvEXT, glProgramUniformMatrix2x3fvEXT, glProgramUniformMatrix3x2fvEXT, glProgramUniformMatrix2x4fvEXT, glProgramUniformMatrix4x2fvEXT, glProgramUniformMatrix3x4fvEXT, glProgramUniformMatrix4x3fvEXT, glTextureBufferEXT, glMultiTexBufferEXT, glTextureParameterIivEXT, glTextureParameterIuivEXT, glGetTextureParameterIivEXT, + glGetTextureParameterIuivEXT, glMultiTexParameterIivEXT, glMultiTexParameterIuivEXT, glGetMultiTexParameterIivEXT, glGetMultiTexParameterIuivEXT, glProgramUniform1uiEXT, glProgramUniform2uiEXT, glProgramUniform3uiEXT, glProgramUniform4uiEXT, glProgramUniform1uivEXT, glProgramUniform2uivEXT, glProgramUniform3uivEXT, glProgramUniform4uivEXT, glNamedProgramLocalParameters4fvEXT, glNamedProgramLocalParameterI4iEXT, glNamedProgramLocalParameterI4ivEXT, + glNamedProgramLocalParametersI4ivEXT, glNamedProgramLocalParameterI4uiEXT, glNamedProgramLocalParameterI4uivEXT, glNamedProgramLocalParametersI4uivEXT, glGetNamedProgramLocalParameterIivEXT, glGetNamedProgramLocalParameterIuivEXT, glEnableClientStateiEXT, glDisableClientStateiEXT, glGetFloati_vEXT, glGetDoublei_vEXT, glGetPointeri_vEXT, glNamedProgramStringEXT, glNamedProgramLocalParameter4dEXT, glNamedProgramLocalParameter4dvEXT, glNamedProgramLocalParameter4fEXT, glNamedProgramLocalParameter4fvEXT, + glGetNamedProgramLocalParameterdvEXT, glGetNamedProgramLocalParameterfvEXT, glGetNamedProgramivEXT, glGetNamedProgramStringEXT, glNamedRenderbufferStorageEXT, glGetNamedRenderbufferParameterivEXT, glNamedRenderbufferStorageMultisampleEXT, glNamedRenderbufferStorageMultisampleCoverageEXT, glCheckNamedFramebufferStatusEXT, glNamedFramebufferTexture1DEXT, glNamedFramebufferTexture2DEXT, glNamedFramebufferTexture3DEXT, glNamedFramebufferRenderbufferEXT, glGetNamedFramebufferAttachmentParameterivEXT, glGenerateTextureMipmapEXT, glGenerateMultiTexMipmapEXT, + glFramebufferDrawBufferEXT, glFramebufferDrawBuffersEXT, glFramebufferReadBufferEXT, glGetFramebufferParameterivEXT, glNamedCopyBufferSubDataEXT, glNamedFramebufferTextureEXT, glNamedFramebufferTextureLayerEXT, glNamedFramebufferTextureFaceEXT, glTextureRenderbufferEXT, glMultiTexRenderbufferEXT, glVertexArrayVertexOffsetEXT, glVertexArrayColorOffsetEXT, glVertexArrayEdgeFlagOffsetEXT, glVertexArrayIndexOffsetEXT, glVertexArrayNormalOffsetEXT, glVertexArrayTexCoordOffsetEXT, + glVertexArrayMultiTexCoordOffsetEXT, glVertexArrayFogCoordOffsetEXT, glVertexArraySecondaryColorOffsetEXT, glVertexArrayVertexAttribOffsetEXT, glVertexArrayVertexAttribIOffsetEXT, glEnableVertexArrayEXT, glDisableVertexArrayEXT, glEnableVertexArrayAttribEXT, glDisableVertexArrayAttribEXT, glGetVertexArrayIntegervEXT, glGetVertexArrayPointervEXT, glGetVertexArrayIntegeri_vEXT, glGetVertexArrayPointeri_vEXT, glMapNamedBufferRangeEXT, glFlushMappedNamedBufferRangeEXT, glNamedBufferStorageEXT, + glClearNamedBufferDataEXT, glClearNamedBufferSubDataEXT, glNamedFramebufferParameteriEXT, glGetNamedFramebufferParameterivEXT, glProgramUniform1dEXT, glProgramUniform2dEXT, glProgramUniform3dEXT, glProgramUniform4dEXT, glProgramUniform1dvEXT, glProgramUniform2dvEXT, glProgramUniform3dvEXT, glProgramUniform4dvEXT, glProgramUniformMatrix2dvEXT, glProgramUniformMatrix3dvEXT, glProgramUniformMatrix4dvEXT, glProgramUniformMatrix2x3dvEXT, + glProgramUniformMatrix2x4dvEXT, glProgramUniformMatrix3x2dvEXT, glProgramUniformMatrix3x4dvEXT, glProgramUniformMatrix4x2dvEXT, glProgramUniformMatrix4x3dvEXT, glTextureBufferRangeEXT, glTextureStorage1DEXT, glTextureStorage2DEXT, glTextureStorage3DEXT, glTextureStorage2DMultisampleEXT, glTextureStorage3DMultisampleEXT, glVertexArrayBindVertexBufferEXT, glVertexArrayVertexAttribFormatEXT, glVertexArrayVertexAttribIFormatEXT, glVertexArrayVertexAttribLFormatEXT, glVertexArrayVertexAttribBindingEXT, + glVertexArrayVertexBindingDivisorEXT, glVertexArrayVertexAttribLOffsetEXT, glTexturePageCommitmentEXT, glVertexArrayVertexAttribDivisorEXT, glColorMaskIndexedEXT, glDrawArraysInstancedEXT, glDrawElementsInstancedEXT, glDrawRangeElementsEXT, glBufferStorageExternalEXT, glNamedBufferStorageExternalEXT, glFogCoordfEXT, glFogCoordfvEXT, glFogCoorddEXT, glFogCoorddvEXT, glFogCoordPointerEXT, glBlitFramebufferEXT, + glBlitFramebufferLayersEXT, glBlitFramebufferLayerEXT, glRenderbufferStorageMultisampleEXT, glIsRenderbufferEXT, glBindRenderbufferEXT, glDeleteRenderbuffersEXT, glGenRenderbuffersEXT, glRenderbufferStorageEXT, glGetRenderbufferParameterivEXT, glIsFramebufferEXT, glBindFramebufferEXT, glDeleteFramebuffersEXT, glGenFramebuffersEXT, glCheckFramebufferStatusEXT, glFramebufferTexture1DEXT, glFramebufferTexture2DEXT, + glFramebufferTexture3DEXT, glFramebufferRenderbufferEXT, glGetFramebufferAttachmentParameterivEXT, glGenerateMipmapEXT, glFrameTerminatorGREMEDY, glStringMarkerGREMEDY, glImageTransformParameteriHP, glImageTransformParameterfHP, glImageTransformParameterivHP, glImageTransformParameterfvHP, glGetImageTransformParameterivHP, glGetImageTransformParameterfvHP, glMultiModeDrawArraysIBM, glMultiModeDrawElementsIBM, glFlushStaticDataIBM, glColorPointerListIBM, + glSecondaryColorPointerListIBM, glEdgeFlagPointerListIBM, glFogCoordPointerListIBM, glIndexPointerListIBM, glNormalPointerListIBM, glTexCoordPointerListIBM, glVertexPointerListIBM, glBlendFuncSeparateINGR, glApplyFramebufferAttachmentCMAAINTEL, glSyncTextureINTEL, glUnmapTexture2DINTEL, glMapTexture2DINTEL, glVertexPointervINTEL, glNormalPointervINTEL, glColorPointervINTEL, glTexCoordPointervINTEL, + glBeginPerfQueryINTEL, glCreatePerfQueryINTEL, glDeletePerfQueryINTEL, glEndPerfQueryINTEL, glGetFirstPerfQueryIdINTEL, glGetNextPerfQueryIdINTEL, glGetPerfCounterInfoINTEL, glGetPerfQueryDataINTEL, glGetPerfQueryIdByNameINTEL, glGetPerfQueryInfoINTEL, glFramebufferParameteriMESA, glGetFramebufferParameterivMESA, glResizeBuffersMESA, glWindowPos2dMESA, glWindowPos2dvMESA, glWindowPos2fMESA, + glWindowPos2fvMESA, glWindowPos2iMESA, glWindowPos2ivMESA, glWindowPos2sMESA, glWindowPos2svMESA, glWindowPos3dMESA, glWindowPos3dvMESA, glWindowPos3fMESA, glWindowPos3fvMESA, glWindowPos3iMESA, glWindowPos3ivMESA, glWindowPos3sMESA, glWindowPos3svMESA, glWindowPos4dMESA, glWindowPos4dvMESA, glWindowPos4fMESA, + glWindowPos4fvMESA, glWindowPos4iMESA, glWindowPos4ivMESA, glWindowPos4sMESA, glWindowPos4svMESA, glBeginConditionalRenderNVX, glEndConditionalRenderNVX, glUploadGpuMaskNVX, glMulticastViewportArrayvNVX, glMulticastViewportPositionWScaleNVX, glMulticastScissorArrayvNVX, glAsyncCopyBufferSubDataNVX, glAsyncCopyImageSubDataNVX, glLGPUNamedBufferSubDataNVX, glLGPUCopyImageSubDataNVX, glLGPUInterlockNVX, + glCreateProgressFenceNVX, glSignalSemaphoreui64NVX, glWaitSemaphoreui64NVX, glClientWaitSemaphoreui64NVX, glAlphaToCoverageDitherControlNV, glMultiDrawArraysIndirectBindlessNV, glMultiDrawElementsIndirectBindlessNV, glMultiDrawArraysIndirectBindlessCountNV, glMultiDrawElementsIndirectBindlessCountNV, glGetTextureHandleNV, glGetTextureSamplerHandleNV, glMakeTextureHandleResidentNV, glMakeTextureHandleNonResidentNV, glGetImageHandleNV, glMakeImageHandleResidentNV, glMakeImageHandleNonResidentNV, + glUniformHandleui64NV, glUniformHandleui64vNV, glProgramUniformHandleui64NV, glProgramUniformHandleui64vNV, glIsTextureHandleResidentNV, glIsImageHandleResidentNV, glBlendParameteriNV, glBlendBarrierNV, glViewportPositionWScaleNV, glCreateStatesNV, glDeleteStatesNV, glIsStateNV, glStateCaptureNV, glGetCommandHeaderNV, glGetStageIndexNV, glDrawCommandsNV, + glDrawCommandsAddressNV, glDrawCommandsStatesNV, glDrawCommandsStatesAddressNV, glCreateCommandListsNV, glDeleteCommandListsNV, glIsCommandListNV, glListDrawCommandsStatesClientNV, glCommandListSegmentsNV, glCompileCommandListNV, glCallCommandListNV, glBeginConditionalRenderNV, glEndConditionalRenderNV, glSubpixelPrecisionBiasNV, glConservativeRasterParameterfNV, glConservativeRasterParameteriNV, glCopyImageSubDataNV, + glDepthRangedNV, glClearDepthdNV, glDepthBoundsdNV, glDrawTextureNV, glDrawVkImageNV, glGetVkProcAddrNV, glWaitVkSemaphoreNV, glSignalVkSemaphoreNV, glSignalVkFenceNV, glMapControlPointsNV, glMapParameterivNV, glMapParameterfvNV, glGetMapControlPointsNV, glGetMapParameterivNV, glGetMapParameterfvNV, glGetMapAttribParameterivNV, + glGetMapAttribParameterfvNV, glEvalMapsNV, glGetMultisamplefvNV, glSampleMaskIndexedNV, glTexRenderbufferNV, glDeleteFencesNV, glGenFencesNV, glIsFenceNV, glTestFenceNV, glGetFenceivNV, glFinishFenceNV, glSetFenceNV, glFragmentCoverageColorNV, glProgramNamedParameter4fNV, glProgramNamedParameter4fvNV, glProgramNamedParameter4dNV, + glProgramNamedParameter4dvNV, glGetProgramNamedParameterfvNV, glGetProgramNamedParameterdvNV, glCoverageModulationTableNV, glGetCoverageModulationTableNV, glCoverageModulationNV, glRenderbufferStorageMultisampleCoverageNV, glProgramVertexLimitNV, glFramebufferTextureEXT, glFramebufferTextureFaceEXT, glRenderGpuMaskNV, glMulticastBufferSubDataNV, glMulticastCopyBufferSubDataNV, glMulticastCopyImageSubDataNV, glMulticastBlitFramebufferNV, glMulticastFramebufferSampleLocationsfvNV, + glMulticastBarrierNV, glMulticastWaitSyncNV, glMulticastGetQueryObjectivNV, glMulticastGetQueryObjectuivNV, glMulticastGetQueryObjecti64vNV, glMulticastGetQueryObjectui64vNV, glProgramLocalParameterI4iNV, glProgramLocalParameterI4ivNV, glProgramLocalParametersI4ivNV, glProgramLocalParameterI4uiNV, glProgramLocalParameterI4uivNV, glProgramLocalParametersI4uivNV, glProgramEnvParameterI4iNV, glProgramEnvParameterI4ivNV, glProgramEnvParametersI4ivNV, glProgramEnvParameterI4uiNV, + glProgramEnvParameterI4uivNV, glProgramEnvParametersI4uivNV, glGetProgramLocalParameterIivNV, glGetProgramLocalParameterIuivNV, glGetProgramEnvParameterIivNV, glGetProgramEnvParameterIuivNV, glProgramSubroutineParametersuivNV, glGetProgramSubroutineParameteruivNV, glVertex2hNV, glVertex2hvNV, glVertex3hNV, glVertex3hvNV, glVertex4hNV, glVertex4hvNV, glNormal3hNV, glNormal3hvNV, + glColor3hNV, glColor3hvNV, glColor4hNV, glColor4hvNV, glTexCoord1hNV, glTexCoord1hvNV, glTexCoord2hNV, glTexCoord2hvNV, glTexCoord3hNV, glTexCoord3hvNV, glTexCoord4hNV, glTexCoord4hvNV, glMultiTexCoord1hNV, glMultiTexCoord1hvNV, glMultiTexCoord2hNV, glMultiTexCoord2hvNV, + glMultiTexCoord3hNV, glMultiTexCoord3hvNV, glMultiTexCoord4hNV, glMultiTexCoord4hvNV, glVertexAttrib1hNV, glVertexAttrib1hvNV, glVertexAttrib2hNV, glVertexAttrib2hvNV, glVertexAttrib3hNV, glVertexAttrib3hvNV, glVertexAttrib4hNV, glVertexAttrib4hvNV, glVertexAttribs1hvNV, glVertexAttribs2hvNV, glVertexAttribs3hvNV, glVertexAttribs4hvNV, + glFogCoordhNV, glFogCoordhvNV, glSecondaryColor3hNV, glSecondaryColor3hvNV, glVertexWeighthNV, glVertexWeighthvNV, glGetInternalformatSampleivNV, glGetMemoryObjectDetachedResourcesuivNV, glResetMemoryObjectParameterNV, glTexAttachMemoryNV, glBufferAttachMemoryNV, glTextureAttachMemoryNV, glNamedBufferAttachMemoryNV, glBufferPageCommitmentMemNV, glTexPageCommitmentMemNV, glNamedBufferPageCommitmentMemNV, + glTexturePageCommitmentMemNV, glDrawMeshTasksNV, glDrawMeshTasksIndirectNV, glMultiDrawMeshTasksIndirectNV, glMultiDrawMeshTasksIndirectCountNV, glGenOcclusionQueriesNV, glDeleteOcclusionQueriesNV, glIsOcclusionQueryNV, glBeginOcclusionQueryNV, glEndOcclusionQueryNV, glGetOcclusionQueryivNV, glGetOcclusionQueryuivNV, glProgramBufferParametersfvNV, glProgramBufferParametersIivNV, glProgramBufferParametersIuivNV, glGenPathsNV, + glDeletePathsNV, glIsPathNV, glPathCommandsNV, glPathCoordsNV, glPathSubCommandsNV, glPathSubCoordsNV, glPathStringNV, glPathGlyphsNV, glPathGlyphRangeNV, glWeightPathsNV, glCopyPathNV, glInterpolatePathsNV, glTransformPathNV, glPathParameterivNV, glPathParameteriNV, glPathParameterfvNV, + glPathParameterfNV, glPathDashArrayNV, glPathStencilFuncNV, glPathStencilDepthOffsetNV, glStencilFillPathNV, glStencilStrokePathNV, glStencilFillPathInstancedNV, glStencilStrokePathInstancedNV, glPathCoverDepthFuncNV, glCoverFillPathNV, glCoverStrokePathNV, glCoverFillPathInstancedNV, glCoverStrokePathInstancedNV, glGetPathParameterivNV, glGetPathParameterfvNV, glGetPathCommandsNV, + glGetPathCoordsNV, glGetPathDashArrayNV, glGetPathMetricsNV, glGetPathMetricRangeNV, glGetPathSpacingNV, glIsPointInFillPathNV, glIsPointInStrokePathNV, glGetPathLengthNV, glPointAlongPathNV, glMatrixLoad3x2fNV, glMatrixLoad3x3fNV, glMatrixLoadTranspose3x3fNV, glMatrixMult3x2fNV, glMatrixMult3x3fNV, glMatrixMultTranspose3x3fNV, glStencilThenCoverFillPathNV, + glStencilThenCoverStrokePathNV, glStencilThenCoverFillPathInstancedNV, glStencilThenCoverStrokePathInstancedNV, glPathGlyphIndexRangeNV, glPathGlyphIndexArrayNV, glPathMemoryGlyphIndexArrayNV, glProgramPathFragmentInputGenNV, glGetProgramResourcefvNV, glPathColorGenNV, glPathTexGenNV, glPathFogGenNV, glGetPathColorGenivNV, glGetPathColorGenfvNV, glGetPathTexGenivNV, glGetPathTexGenfvNV, glPixelDataRangeNV, + glFlushPixelDataRangeNV, glPointParameteriNV, glPointParameterivNV, glPresentFrameKeyedNV, glPresentFrameDualFillNV, glGetVideoivNV, glGetVideouivNV, glGetVideoi64vNV, glGetVideoui64vNV, glPrimitiveRestartNV, glPrimitiveRestartIndexNV, glQueryResourceNV, glGenQueryResourceTagNV, glDeleteQueryResourceTagNV, glQueryResourceTagNV, glCombinerParameterfvNV, + glCombinerParameterfNV, glCombinerParameterivNV, glCombinerParameteriNV, glCombinerInputNV, glCombinerOutputNV, glFinalCombinerInputNV, glGetCombinerInputParameterfvNV, glGetCombinerInputParameterivNV, glGetCombinerOutputParameterfvNV, glGetCombinerOutputParameterivNV, glGetFinalCombinerInputParameterfvNV, glGetFinalCombinerInputParameterivNV, glCombinerStageParameterfvNV, glGetCombinerStageParameterfvNV, glFramebufferSampleLocationsfvNV, glNamedFramebufferSampleLocationsfvNV, + glResolveDepthValuesNV, glScissorExclusiveNV, glScissorExclusiveArrayvNV, glMakeBufferResidentNV, glMakeBufferNonResidentNV, glIsBufferResidentNV, glMakeNamedBufferResidentNV, glMakeNamedBufferNonResidentNV, glIsNamedBufferResidentNV, glGetBufferParameterui64vNV, glGetNamedBufferParameterui64vNV, glGetIntegerui64vNV, glUniformui64NV, glUniformui64vNV, glProgramUniformui64NV, glProgramUniformui64vNV, + glBindShadingRateImageNV, glGetShadingRateImagePaletteNV, glGetShadingRateSampleLocationivNV, glShadingRateImageBarrierNV, glShadingRateImagePaletteNV, glShadingRateSampleOrderNV, glShadingRateSampleOrderCustomNV, glTextureBarrierNV, glTexImage2DMultisampleCoverageNV, glTexImage3DMultisampleCoverageNV, glTextureImage2DMultisampleNV, glTextureImage3DMultisampleNV, glTextureImage2DMultisampleCoverageNV, glTextureImage3DMultisampleCoverageNV, glCreateSemaphoresNV, glSemaphoreParameterivNV, + glGetSemaphoreParameterivNV, glBeginTransformFeedbackNV, glEndTransformFeedbackNV, glTransformFeedbackAttribsNV, glBindBufferRangeNV, glBindBufferOffsetNV, glBindBufferBaseNV, glTransformFeedbackVaryingsNV, glActiveVaryingNV, glGetVaryingLocationNV, glGetActiveVaryingNV, glGetTransformFeedbackVaryingNV, glTransformFeedbackStreamAttribsNV, glBindTransformFeedbackNV, glDeleteTransformFeedbacksNV, glGenTransformFeedbacksNV, + glIsTransformFeedbackNV, glPauseTransformFeedbackNV, glResumeTransformFeedbackNV, glDrawTransformFeedbackNV, glVDPAUInitNV, glVDPAUFiniNV, glVDPAURegisterVideoSurfaceNV, glVDPAURegisterOutputSurfaceNV, glVDPAUIsSurfaceNV, glVDPAUUnregisterSurfaceNV, glVDPAUGetSurfaceivNV, glVDPAUSurfaceAccessNV, glVDPAUMapSurfacesNV, glVDPAUUnmapSurfacesNV, glVDPAURegisterVideoSurfaceWithPictureStructureNV, glFlushVertexArrayRangeNV, + glVertexArrayRangeNV, glVertexAttribL1i64NV, glVertexAttribL2i64NV, glVertexAttribL3i64NV, glVertexAttribL4i64NV, glVertexAttribL1i64vNV, glVertexAttribL2i64vNV, glVertexAttribL3i64vNV, glVertexAttribL4i64vNV, glVertexAttribL1ui64NV, glVertexAttribL2ui64NV, glVertexAttribL3ui64NV, glVertexAttribL4ui64NV, glVertexAttribL1ui64vNV, glVertexAttribL2ui64vNV, glVertexAttribL3ui64vNV, + glVertexAttribL4ui64vNV, glGetVertexAttribLi64vNV, glGetVertexAttribLui64vNV, glVertexAttribLFormatNV, glBufferAddressRangeNV, glVertexFormatNV, glNormalFormatNV, glColorFormatNV, glIndexFormatNV, glTexCoordFormatNV, glEdgeFlagFormatNV, glSecondaryColorFormatNV, glFogCoordFormatNV, glVertexAttribFormatNV, glVertexAttribIFormatNV, glGetIntegerui64i_vNV, + glAreProgramsResidentNV, glBindProgramNV, glDeleteProgramsNV, glExecuteProgramNV, glGenProgramsNV, glGetProgramParameterdvNV, glGetProgramParameterfvNV, glGetProgramivNV, glGetProgramStringNV, glGetTrackMatrixivNV, glGetVertexAttribdvNV, glGetVertexAttribfvNV, glGetVertexAttribivNV, glGetVertexAttribPointervNV, glIsProgramNV, glLoadProgramNV, + glProgramParameter4dNV, glProgramParameter4dvNV, glProgramParameter4fNV, glProgramParameter4fvNV, glProgramParameters4dvNV, glProgramParameters4fvNV, glRequestResidentProgramsNV, glTrackMatrixNV, glVertexAttribPointerNV, glVertexAttrib1dNV, glVertexAttrib1dvNV, glVertexAttrib1fNV, glVertexAttrib1fvNV, glVertexAttrib1sNV, glVertexAttrib1svNV, glVertexAttrib2dNV, + glVertexAttrib2dvNV, glVertexAttrib2fNV, glVertexAttrib2fvNV, glVertexAttrib2sNV, glVertexAttrib2svNV, glVertexAttrib3dNV, glVertexAttrib3dvNV, glVertexAttrib3fNV, glVertexAttrib3fvNV, glVertexAttrib3sNV, glVertexAttrib3svNV, glVertexAttrib4dNV, glVertexAttrib4dvNV, glVertexAttrib4fNV, glVertexAttrib4fvNV, glVertexAttrib4sNV, + glVertexAttrib4svNV, glVertexAttrib4ubNV, glVertexAttrib4ubvNV, glVertexAttribs1dvNV, glVertexAttribs1fvNV, glVertexAttribs1svNV, glVertexAttribs2dvNV, glVertexAttribs2fvNV, glVertexAttribs2svNV, glVertexAttribs3dvNV, glVertexAttribs3fvNV, glVertexAttribs3svNV, glVertexAttribs4dvNV, glVertexAttribs4fvNV, glVertexAttribs4svNV, glVertexAttribs4ubvNV, + glBeginVideoCaptureNV, glBindVideoCaptureStreamBufferNV, glBindVideoCaptureStreamTextureNV, glEndVideoCaptureNV, glGetVideoCaptureivNV, glGetVideoCaptureStreamivNV, glGetVideoCaptureStreamfvNV, glGetVideoCaptureStreamdvNV, glVideoCaptureNV, glVideoCaptureStreamParameterivNV, glVideoCaptureStreamParameterfvNV, glVideoCaptureStreamParameterdvNV, glViewportSwizzleNV, glFramebufferTextureMultiviewOVR, glHintPGI, glDetailTexFuncSGIS, + glGetDetailTexFuncSGIS, glFogFuncSGIS, glGetFogFuncSGIS, glSampleMaskSGIS, glSamplePatternSGIS, glPixelTexGenParameteriSGIS, glPixelTexGenParameterivSGIS, glPixelTexGenParameterfSGIS, glPixelTexGenParameterfvSGIS, glGetPixelTexGenParameterivSGIS, glGetPixelTexGenParameterfvSGIS, glPointParameterfSGIS, glPointParameterfvSGIS, glSharpenTexFuncSGIS, glGetSharpenTexFuncSGIS, glTexImage4DSGIS, + glTexSubImage4DSGIS, glTextureColorMaskSGIS, glGetTexFilterFuncSGIS, glTexFilterFuncSGIS, glAsyncMarkerSGIX, glFinishAsyncSGIX, glPollAsyncSGIX, glGenAsyncMarkersSGIX, glDeleteAsyncMarkersSGIX, glIsAsyncMarkerSGIX, glFlushRasterSGIX, glFragmentColorMaterialSGIX, glFragmentLightfSGIX, glFragmentLightfvSGIX, glFragmentLightiSGIX, glFragmentLightivSGIX, + glFragmentLightModelfSGIX, glFragmentLightModelfvSGIX, glFragmentLightModeliSGIX, glFragmentLightModelivSGIX, glFragmentMaterialfSGIX, glFragmentMaterialfvSGIX, glFragmentMaterialiSGIX, glFragmentMaterialivSGIX, glGetFragmentLightfvSGIX, glGetFragmentLightivSGIX, glGetFragmentMaterialfvSGIX, glGetFragmentMaterialivSGIX, glLightEnviSGIX, glFrameZoomSGIX, glIglooInterfaceSGIX, glGetInstrumentsSGIX, + glInstrumentsBufferSGIX, glPollInstrumentsSGIX, glReadInstrumentsSGIX, glStartInstrumentsSGIX, glStopInstrumentsSGIX, glGetListParameterfvSGIX, glGetListParameterivSGIX, glListParameterfSGIX, glListParameterfvSGIX, glListParameteriSGIX, glListParameterivSGIX, glPixelTexGenSGIX, glDeformationMap3dSGIX, glDeformationMap3fSGIX, glDeformSGIX, glLoadIdentityDeformationMapSGIX, + glReferencePlaneSGIX, glSpriteParameterfSGIX, glSpriteParameterfvSGIX, glSpriteParameteriSGIX, glSpriteParameterivSGIX, glTagSampleBufferSGIX, glColorTableSGI, glColorTableParameterfvSGI, glColorTableParameterivSGI, glCopyColorTableSGI, glGetColorTableSGI, glGetColorTableParameterfvSGI, glGetColorTableParameterivSGI, glFinishTextureSUNX, glGlobalAlphaFactorbSUN, glGlobalAlphaFactorsSUN, + glGlobalAlphaFactoriSUN, glGlobalAlphaFactorfSUN, glGlobalAlphaFactordSUN, glGlobalAlphaFactorubSUN, glGlobalAlphaFactorusSUN, glGlobalAlphaFactoruiSUN, glDrawMeshArraysSUN, glReplacementCodeuiSUN, glReplacementCodeusSUN, glReplacementCodeubSUN, glReplacementCodeuivSUN, glReplacementCodeusvSUN, glReplacementCodeubvSUN, glReplacementCodePointerSUN, glColor4ubVertex2fSUN, glColor4ubVertex2fvSUN, + glColor4ubVertex3fSUN, glColor4ubVertex3fvSUN, glColor3fVertex3fSUN, glColor3fVertex3fvSUN, glNormal3fVertex3fSUN, glNormal3fVertex3fvSUN, glColor4fNormal3fVertex3fSUN, glColor4fNormal3fVertex3fvSUN, glTexCoord2fVertex3fSUN, glTexCoord2fVertex3fvSUN, glTexCoord4fVertex4fSUN, glTexCoord4fVertex4fvSUN, glTexCoord2fColor4ubVertex3fSUN, glTexCoord2fColor4ubVertex3fvSUN, glTexCoord2fColor3fVertex3fSUN, glTexCoord2fColor3fVertex3fvSUN, + glTexCoord2fNormal3fVertex3fSUN, glTexCoord2fNormal3fVertex3fvSUN, glTexCoord2fColor4fNormal3fVertex3fSUN, glTexCoord2fColor4fNormal3fVertex3fvSUN, glTexCoord4fColor4fNormal3fVertex4fSUN, glTexCoord4fColor4fNormal3fVertex4fvSUN, glReplacementCodeuiVertex3fSUN, glReplacementCodeuiVertex3fvSUN, glReplacementCodeuiColor4ubVertex3fSUN, glReplacementCodeuiColor4ubVertex3fvSUN, glReplacementCodeuiColor3fVertex3fSUN, glReplacementCodeuiColor3fVertex3fvSUN, glReplacementCodeuiNormal3fVertex3fSUN, glReplacementCodeuiNormal3fVertex3fvSUN, glReplacementCodeuiColor4fNormal3fVertex3fSUN, glReplacementCodeuiColor4fNormal3fVertex3fvSUN, + glReplacementCodeuiTexCoord2fVertex3fSUN, glReplacementCodeuiTexCoord2fVertex3fvSUN, glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN, glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN, glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN; void load(GLLoadFunc load) { GLARBES32Compatibility.load(this, load); @@ -225,6 +247,31 @@ void load(GLLoadFunc load) { GLATIVertexArrayObject.load(this, load); GLATIVertexAttribArrayObject.load(this, load); GLATIVertexStreams.load(this, load); + GLEXTEGLImageStorage.load(this, load); + GLEXTBindableUniform.load(this, load); + GLEXTBlendColor.load(this, load); + GLEXTBlendEquationSeparate.load(this, load); + GLEXTBlendFuncSeparate.load(this, load); + GLEXTBlendMinmax.load(this, load); + GLEXTColorSubtable.load(this, load); + GLEXTCompiledVertexArray.load(this, load); + GLEXTConvolution.load(this, load); + GLEXTCoordinateFrame.load(this, load); + GLEXTCopyTexture.load(this, load); + GLEXTCullVertex.load(this, load); + GLEXTDebugLabel.load(this, load); + GLEXTDebugMarker.load(this, load); + GLEXTDepthBoundsTest.load(this, load); + GLEXTDirectStateAccess.load(this, load); + GLEXTDrawBuffers2.load(this, load); + GLEXTDrawInstanced.load(this, load); + GLEXTDrawRangedElements.load(this, load); + GLEXTExternalBuffer.load(this, load); + GLEXTFogCoord.load(this, load); + GLEXTFramebufferBlit.load(this, load); + GLEXTFramebufferBlitLayers.load(this, load); + GLEXTFramebufferMultisample.load(this, load); + GLEXTFramebufferObject.load(this, load); GLGREMEDYFrameTerminator.load(this, load); GLGREMEDYStringMarker.load(this, load); GLHPImageTransform.load(this, load); diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTAbgr.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTAbgr.java new file mode 100644 index 00000000..09cc274f --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTAbgr.java @@ -0,0 +1,32 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_abgr} + */ +public final class GLEXTAbgr { + public static final int GL_ABGR_EXT = 0x8000; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBgra.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBgra.java new file mode 100644 index 00000000..b747954d --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBgra.java @@ -0,0 +1,33 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_bgra} + */ +public final class GLEXTBgra { + public static final int GL_BGR_EXT = 0x80E0; + public static final int GL_BGRA_EXT = 0x80E1; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBindableUniform.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBindableUniform.java new file mode 100644 index 00000000..f0078417 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBindableUniform.java @@ -0,0 +1,67 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_bindable_uniform} + */ +public final class GLEXTBindableUniform { + public static final int GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8DE2; + public static final int GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8DE3; + public static final int GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8DE4; + public static final int GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8DED; + public static final int GL_UNIFORM_BUFFER_EXT = 0x8DEE; + public static final int GL_UNIFORM_BUFFER_BINDING_EXT = 0x8DEF; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_bindable_uniform) return; + ext.glUniformBufferEXT = load.invoke("glUniformBufferEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glGetUniformBufferSizeEXT = load.invoke("glGetUniformBufferSizeEXT", of(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glGetUniformOffsetEXT = load.invoke("glGetUniformOffsetEXT", of(JAVA_LONG, JAVA_INT, JAVA_INT)); + } + + public static void glUniformBufferEXT(int program, int location, int buffer) { + final var ext = getExtCapabilities(); + try { + check(ext.glUniformBufferEXT).invokeExact(program, location, buffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static int glGetUniformBufferSizeEXT(int program, int location) { + final var ext = getExtCapabilities(); + try { + return (int) + check(ext.glGetUniformBufferSizeEXT).invokeExact(program, location); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static long glGetUniformOffsetEXT(int program, int location) { + final var ext = getExtCapabilities(); + try { + return (long) + check(ext.glGetUniformOffsetEXT).invokeExact(program, location); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendColor.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendColor.java new file mode 100644 index 00000000..9aacab36 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendColor.java @@ -0,0 +1,48 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_blend_color} + */ +public final class GLEXTBlendColor { + public static final int GL_CONSTANT_COLOR_EXT = 0x8001; + public static final int GL_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002; + public static final int GL_CONSTANT_ALPHA_EXT = 0x8003; + public static final int GL_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004; + public static final int GL_BLEND_COLOR_EXT = 0x8005; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_blend_color) return; + ext.glBlendColorEXT = load.invoke("glBlendColorEXT", ofVoid(JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + } + + public static void glBlendColorEXT(float red, float green, float blue, float alpha) { + final var ext = getExtCapabilities(); + try { + check(ext.glBlendColorEXT).invokeExact(red, green, blue, alpha); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendEquationSeparate.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendEquationSeparate.java new file mode 100644 index 00000000..6a1ad785 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendEquationSeparate.java @@ -0,0 +1,45 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_blend_equation_separate} + */ +public final class GLEXTBlendEquationSeparate { + public static final int GL_BLEND_EQUATION_RGB_EXT = 0x8009; + public static final int GL_BLEND_EQUATION_ALPHA_EXT = 0x883D; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_blend_equation_separate) return; + ext.glBlendEquationSeparateEXT = load.invoke("glBlendEquationSeparateEXT", ofVoid(JAVA_INT, JAVA_INT)); + } + + public static void glBlendEquationSeparateEXT(int modeRGB, int modeAlpha) { + final var ext = getExtCapabilities(); + try { + check(ext.glBlendEquationSeparateEXT).invokeExact(modeRGB, modeAlpha); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendFuncSeparate.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendFuncSeparate.java new file mode 100644 index 00000000..d5bd751a --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendFuncSeparate.java @@ -0,0 +1,47 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_blend_func_separate} + */ +public final class GLEXTBlendFuncSeparate { + public static final int GL_BLEND_DST_RGB_EXT = 0x80C8; + public static final int GL_BLEND_SRC_RGB_EXT = 0x80C9; + public static final int GL_BLEND_DST_ALPHA_EXT = 0x80CA; + public static final int GL_BLEND_SRC_ALPHA_EXT = 0x80CB; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_blend_func_separate) return; + ext.glBlendFuncSeparateEXT = load.invoke("glBlendFuncSeparateEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + } + + public static void glBlendFuncSeparateEXT(int sfactorRGB, int dfactorRGB, int sfactorAlpha, int dfactorAlpha) { + final var ext = getExtCapabilities(); + try { + check(ext.glBlendFuncSeparateEXT).invokeExact(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendMinmax.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendMinmax.java new file mode 100644 index 00000000..caa8ba1c --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendMinmax.java @@ -0,0 +1,47 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_blend_minmax} + */ +public final class GLEXTBlendMinmax { + public static final int GL_MIN_EXT = 0x8007; + public static final int GL_MAX_EXT = 0x8008; + public static final int GL_FUNC_ADD_EXT = 0x8006; + public static final int GL_BLEND_EQUATION_EXT = 0x8009; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_blend_minmax) return; + ext.glBlendEquationEXT = load.invoke("glBlendEquationEXT", ofVoid(JAVA_INT)); + } + + public static void glBlendEquationEXT(int mode) { + final var ext = getExtCapabilities(); + try { + check(ext.glBlendEquationEXT).invokeExact(mode); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendSubtract.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendSubtract.java new file mode 100644 index 00000000..cb713676 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTBlendSubtract.java @@ -0,0 +1,33 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_blend_subtract} + */ +public final class GLEXTBlendSubtract { + public static final int GL_FUNC_SUBTRACT_EXT = 0x800A; + public static final int GL_FUNC_REVERSE_SUBTRACT_EXT = 0x800B; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTClipVolumeHint.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTClipVolumeHint.java new file mode 100644 index 00000000..740364dc --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTClipVolumeHint.java @@ -0,0 +1,32 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_clip_volume_hint} + */ +public final class GLEXTClipVolumeHint { + public static final int GL_CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCmyka.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCmyka.java new file mode 100644 index 00000000..3d8b83a6 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCmyka.java @@ -0,0 +1,35 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_cmyka} + */ +public final class GLEXTCmyka { + public static final int GL_CMYK_EXT = 0x800C; + public static final int GL_CMYKA_EXT = 0x800D; + public static final int GL_PACK_CMYK_HINT_EXT = 0x800E; + public static final int GL_UNPACK_CMYK_HINT_EXT = 0x800F; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTColorSubtable.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTColorSubtable.java new file mode 100644 index 00000000..430ccd55 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTColorSubtable.java @@ -0,0 +1,51 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_color_subtable} + */ +public final class GLEXTColorSubtable { + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_color_subtable) return; + ext.glColorSubTableEXT = load.invoke("glColorSubTableEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCopyColorSubTableEXT = load.invoke("glCopyColorSubTableEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + } + + public static void glColorSubTableEXT(int target, int start, int count, int format, int type, @NativeType("const void *") MemorySegment data) { + final var ext = getExtCapabilities(); + try { + check(ext.glColorSubTableEXT).invokeExact(target, start, count, format, type, data); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyColorSubTableEXT(int target, int start, int x, int y, int width) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyColorSubTableEXT).invokeExact(target, start, x, y, width); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCompiledVertexArray.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCompiledVertexArray.java new file mode 100644 index 00000000..bf5df8e0 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCompiledVertexArray.java @@ -0,0 +1,53 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_compiled_vertex_array} + */ +public final class GLEXTCompiledVertexArray { + public static final int GL_ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8; + public static final int GL_ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_compiled_vertex_array) return; + ext.glLockArraysEXT = load.invoke("glLockArraysEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glUnlockArraysEXT = load.invoke("glUnlockArraysEXT", ofVoid()); + } + + public static void glLockArraysEXT(int first, int count) { + final var ext = getExtCapabilities(); + try { + check(ext.glLockArraysEXT).invokeExact(first, count); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glUnlockArraysEXT() { + final var ext = getExtCapabilities(); + try { + check(ext.glUnlockArraysEXT).invokeExact(); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTConvolution.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTConvolution.java new file mode 100644 index 00000000..45824b9a --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTConvolution.java @@ -0,0 +1,159 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_convolution} + */ +public final class GLEXTConvolution { + public static final int GL_CONVOLUTION_1D_EXT = 0x8010; + public static final int GL_CONVOLUTION_2D_EXT = 0x8011; + public static final int GL_SEPARABLE_2D_EXT = 0x8012; + public static final int GL_CONVOLUTION_BORDER_MODE_EXT = 0x8013; + public static final int GL_CONVOLUTION_FILTER_SCALE_EXT = 0x8014; + public static final int GL_CONVOLUTION_FILTER_BIAS_EXT = 0x8015; + public static final int GL_REDUCE_EXT = 0x8016; + public static final int GL_CONVOLUTION_FORMAT_EXT = 0x8017; + public static final int GL_CONVOLUTION_WIDTH_EXT = 0x8018; + public static final int GL_CONVOLUTION_HEIGHT_EXT = 0x8019; + public static final int GL_MAX_CONVOLUTION_WIDTH_EXT = 0x801A; + public static final int GL_MAX_CONVOLUTION_HEIGHT_EXT = 0x801B; + public static final int GL_POST_CONVOLUTION_RED_SCALE_EXT = 0x801C; + public static final int GL_POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D; + public static final int GL_POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E; + public static final int GL_POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F; + public static final int GL_POST_CONVOLUTION_RED_BIAS_EXT = 0x8020; + public static final int GL_POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021; + public static final int GL_POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022; + public static final int GL_POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_convolution) return; + ext.glConvolutionFilter1DEXT = load.invoke("glConvolutionFilter1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glConvolutionFilter2DEXT = load.invoke("glConvolutionFilter2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glConvolutionParameterfEXT = load.invoke("glConvolutionParameterfEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_FLOAT)); + ext.glConvolutionParameterfvEXT = load.invoke("glConvolutionParameterfvEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glConvolutionParameteriEXT = load.invoke("glConvolutionParameteriEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glConvolutionParameterivEXT = load.invoke("glConvolutionParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCopyConvolutionFilter1DEXT = load.invoke("glCopyConvolutionFilter1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCopyConvolutionFilter2DEXT = load.invoke("glCopyConvolutionFilter2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glGetConvolutionFilterEXT = load.invoke("glGetConvolutionFilterEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetConvolutionParameterfvEXT = load.invoke("glGetConvolutionParameterfvEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetConvolutionParameterivEXT = load.invoke("glGetConvolutionParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetSeparableFilterEXT = load.invoke("glGetSeparableFilterEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS, ADDRESS, ADDRESS)); + ext.glSeparableFilter2DEXT = load.invoke("glSeparableFilter2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS, ADDRESS)); + } + + public static void glConvolutionFilter1DEXT(int target, int internalformat, int width, int format, int type, @NativeType("const void *") MemorySegment image) { + final var ext = getExtCapabilities(); + try { + check(ext.glConvolutionFilter1DEXT).invokeExact(target, internalformat, width, format, type, image); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glConvolutionFilter2DEXT(int target, int internalformat, int width, int height, int format, int type, @NativeType("const void *") MemorySegment image) { + final var ext = getExtCapabilities(); + try { + check(ext.glConvolutionFilter2DEXT).invokeExact(target, internalformat, width, height, format, type, image); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glConvolutionParameterfEXT(int target, int pname, float params) { + final var ext = getExtCapabilities(); + try { + check(ext.glConvolutionParameterfEXT).invokeExact(target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glConvolutionParameterfvEXT(int target, int pname, @NativeType("const GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glConvolutionParameterfvEXT).invokeExact(target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glConvolutionParameteriEXT(int target, int pname, int params) { + final var ext = getExtCapabilities(); + try { + check(ext.glConvolutionParameteriEXT).invokeExact(target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glConvolutionParameterivEXT(int target, int pname, @NativeType("const GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glConvolutionParameterivEXT).invokeExact(target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyConvolutionFilter1DEXT(int target, int internalformat, int x, int y, int width) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyConvolutionFilter1DEXT).invokeExact(target, internalformat, x, y, width); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyConvolutionFilter2DEXT(int target, int internalformat, int x, int y, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyConvolutionFilter2DEXT).invokeExact(target, internalformat, x, y, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetConvolutionFilterEXT(int target, int format, int type, @NativeType("void *") MemorySegment image) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetConvolutionFilterEXT).invokeExact(target, format, type, image); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetConvolutionParameterfvEXT(int target, int pname, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetConvolutionParameterfvEXT).invokeExact(target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetConvolutionParameterivEXT(int target, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetConvolutionParameterivEXT).invokeExact(target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetSeparableFilterEXT(int target, int format, int type, @NativeType("void *") MemorySegment row, @NativeType("void *") MemorySegment column, @NativeType("void *") MemorySegment span) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetSeparableFilterEXT).invokeExact(target, format, type, row, column, span); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glSeparableFilter2DEXT(int target, int internalformat, int width, int height, int format, int type, @NativeType("const void *") MemorySegment row, @NativeType("const void *") MemorySegment column) { + final var ext = getExtCapabilities(); + try { + check(ext.glSeparableFilter2DEXT).invokeExact(target, internalformat, width, height, format, type, row, column); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCoordinateFrame.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCoordinateFrame.java new file mode 100644 index 00000000..28b59fc6 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCoordinateFrame.java @@ -0,0 +1,225 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_coordinate_frame} + */ +public final class GLEXTCoordinateFrame { + public static final int GL_TANGENT_ARRAY_EXT = 0x8439; + public static final int GL_BINORMAL_ARRAY_EXT = 0x843A; + public static final int GL_CURRENT_TANGENT_EXT = 0x843B; + public static final int GL_CURRENT_BINORMAL_EXT = 0x843C; + public static final int GL_TANGENT_ARRAY_TYPE_EXT = 0x843E; + public static final int GL_TANGENT_ARRAY_STRIDE_EXT = 0x843F; + public static final int GL_BINORMAL_ARRAY_TYPE_EXT = 0x8440; + public static final int GL_BINORMAL_ARRAY_STRIDE_EXT = 0x8441; + public static final int GL_TANGENT_ARRAY_POINTER_EXT = 0x8442; + public static final int GL_BINORMAL_ARRAY_POINTER_EXT = 0x8443; + public static final int GL_MAP1_TANGENT_EXT = 0x8444; + public static final int GL_MAP2_TANGENT_EXT = 0x8445; + public static final int GL_MAP1_BINORMAL_EXT = 0x8446; + public static final int GL_MAP2_BINORMAL_EXT = 0x8447; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_coordinate_frame) return; + ext.glTangent3bEXT = load.invoke("glTangent3bEXT", ofVoid(JAVA_BYTE, JAVA_BYTE, JAVA_BYTE)); + ext.glTangent3bvEXT = load.invoke("glTangent3bvEXT", ofVoid(ADDRESS)); + ext.glTangent3dEXT = load.invoke("glTangent3dEXT", ofVoid(JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glTangent3dvEXT = load.invoke("glTangent3dvEXT", ofVoid(ADDRESS)); + ext.glTangent3fEXT = load.invoke("glTangent3fEXT", ofVoid(JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glTangent3fvEXT = load.invoke("glTangent3fvEXT", ofVoid(ADDRESS)); + ext.glTangent3iEXT = load.invoke("glTangent3iEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glTangent3ivEXT = load.invoke("glTangent3ivEXT", ofVoid(ADDRESS)); + ext.glTangent3sEXT = load.invoke("glTangent3sEXT", ofVoid(JAVA_SHORT, JAVA_SHORT, JAVA_SHORT)); + ext.glTangent3svEXT = load.invoke("glTangent3svEXT", ofVoid(ADDRESS)); + ext.glBinormal3bEXT = load.invoke("glBinormal3bEXT", ofVoid(JAVA_BYTE, JAVA_BYTE, JAVA_BYTE)); + ext.glBinormal3bvEXT = load.invoke("glBinormal3bvEXT", ofVoid(ADDRESS)); + ext.glBinormal3dEXT = load.invoke("glBinormal3dEXT", ofVoid(JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glBinormal3dvEXT = load.invoke("glBinormal3dvEXT", ofVoid(ADDRESS)); + ext.glBinormal3fEXT = load.invoke("glBinormal3fEXT", ofVoid(JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glBinormal3fvEXT = load.invoke("glBinormal3fvEXT", ofVoid(ADDRESS)); + ext.glBinormal3iEXT = load.invoke("glBinormal3iEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glBinormal3ivEXT = load.invoke("glBinormal3ivEXT", ofVoid(ADDRESS)); + ext.glBinormal3sEXT = load.invoke("glBinormal3sEXT", ofVoid(JAVA_SHORT, JAVA_SHORT, JAVA_SHORT)); + ext.glBinormal3svEXT = load.invoke("glBinormal3svEXT", ofVoid(ADDRESS)); + ext.glTangentPointerEXT = load.invoke("glTangentPointerEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glBinormalPointerEXT = load.invoke("glBinormalPointerEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + } + + public static void glTangent3bEXT(byte tx, byte ty, byte tz) { + final var ext = getExtCapabilities(); + try { + check(ext.glTangent3bEXT).invokeExact(tx, ty, tz); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTangent3bvEXT(@NativeType("const GLbyte *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glTangent3bvEXT).invokeExact(v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTangent3dEXT(double tx, double ty, double tz) { + final var ext = getExtCapabilities(); + try { + check(ext.glTangent3dEXT).invokeExact(tx, ty, tz); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTangent3dvEXT(@NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glTangent3dvEXT).invokeExact(v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTangent3fEXT(float tx, float ty, float tz) { + final var ext = getExtCapabilities(); + try { + check(ext.glTangent3fEXT).invokeExact(tx, ty, tz); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTangent3fvEXT(@NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glTangent3fvEXT).invokeExact(v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTangent3iEXT(int tx, int ty, int tz) { + final var ext = getExtCapabilities(); + try { + check(ext.glTangent3iEXT).invokeExact(tx, ty, tz); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTangent3ivEXT(@NativeType("const GLint *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glTangent3ivEXT).invokeExact(v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTangent3sEXT(short tx, short ty, short tz) { + final var ext = getExtCapabilities(); + try { + check(ext.glTangent3sEXT).invokeExact(tx, ty, tz); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTangent3svEXT(@NativeType("const GLshort *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glTangent3svEXT).invokeExact(v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBinormal3bEXT(byte bx, byte by, byte bz) { + final var ext = getExtCapabilities(); + try { + check(ext.glBinormal3bEXT).invokeExact(bx, by, bz); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBinormal3bvEXT(@NativeType("const GLbyte *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glBinormal3bvEXT).invokeExact(v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBinormal3dEXT(double bx, double by, double bz) { + final var ext = getExtCapabilities(); + try { + check(ext.glBinormal3dEXT).invokeExact(bx, by, bz); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBinormal3dvEXT(@NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glBinormal3dvEXT).invokeExact(v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBinormal3fEXT(float bx, float by, float bz) { + final var ext = getExtCapabilities(); + try { + check(ext.glBinormal3fEXT).invokeExact(bx, by, bz); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBinormal3fvEXT(@NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glBinormal3fvEXT).invokeExact(v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBinormal3iEXT(int bx, int by, int bz) { + final var ext = getExtCapabilities(); + try { + check(ext.glBinormal3iEXT).invokeExact(bx, by, bz); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBinormal3ivEXT(@NativeType("const GLint *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glBinormal3ivEXT).invokeExact(v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBinormal3sEXT(short bx, short by, short bz) { + final var ext = getExtCapabilities(); + try { + check(ext.glBinormal3sEXT).invokeExact(bx, by, bz); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBinormal3svEXT(@NativeType("const GLshort *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glBinormal3svEXT).invokeExact(v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTangentPointerEXT(int type, int stride, @NativeType("const void *") MemorySegment pointer) { + final var ext = getExtCapabilities(); + try { + check(ext.glTangentPointerEXT).invokeExact(type, stride, pointer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBinormalPointerEXT(int type, int stride, @NativeType("const void *") MemorySegment pointer) { + final var ext = getExtCapabilities(); + try { + check(ext.glBinormalPointerEXT).invokeExact(type, stride, pointer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCopyTexture.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCopyTexture.java new file mode 100644 index 00000000..4cc5c38c --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCopyTexture.java @@ -0,0 +1,75 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_copy_texture} + */ +public final class GLEXTCopyTexture { + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_copy_texture) return; + ext.glCopyTexImage1DEXT = load.invoke("glCopyTexImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCopyTexImage2DEXT = load.invoke("glCopyTexImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCopyTexSubImage1DEXT = load.invoke("glCopyTexSubImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCopyTexSubImage2DEXT = load.invoke("glCopyTexSubImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCopyTexSubImage3DEXT = load.invoke("glCopyTexSubImage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + } + + public static void glCopyTexImage1DEXT(int target, int level, int internalformat, int x, int y, int width, int border) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyTexImage1DEXT).invokeExact(target, level, internalformat, x, y, width, border); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyTexImage2DEXT(int target, int level, int internalformat, int x, int y, int width, int height, int border) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyTexImage2DEXT).invokeExact(target, level, internalformat, x, y, width, height, border); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyTexSubImage1DEXT(int target, int level, int xoffset, int x, int y, int width) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyTexSubImage1DEXT).invokeExact(target, level, xoffset, x, y, width); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyTexSubImage2DEXT(int target, int level, int xoffset, int yoffset, int x, int y, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyTexSubImage2DEXT).invokeExact(target, level, xoffset, yoffset, x, y, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyTexSubImage3DEXT(int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyTexSubImage3DEXT).invokeExact(target, level, xoffset, yoffset, zoffset, x, y, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCullVertex.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCullVertex.java new file mode 100644 index 00000000..f963412a --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTCullVertex.java @@ -0,0 +1,54 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_cull_vertex} + */ +public final class GLEXTCullVertex { + public static final int GL_CULL_VERTEX_EXT = 0x81AA; + public static final int GL_CULL_VERTEX_EYE_POSITION_EXT = 0x81AB; + public static final int GL_CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_cull_vertex) return; + ext.glCullParameterdvEXT = load.invoke("glCullParameterdvEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glCullParameterfvEXT = load.invoke("glCullParameterfvEXT", ofVoid(JAVA_INT, ADDRESS)); + } + + public static void glCullParameterdvEXT(int pname, @NativeType("GLdouble *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glCullParameterdvEXT).invokeExact(pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCullParameterfvEXT(int pname, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glCullParameterfvEXT).invokeExact(pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDebugLabel.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDebugLabel.java new file mode 100644 index 00000000..c8abe18d --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDebugLabel.java @@ -0,0 +1,57 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_debug_label} + */ +public final class GLEXTDebugLabel { + public static final int GL_PROGRAM_PIPELINE_OBJECT_EXT = 0x8A4F; + public static final int GL_PROGRAM_OBJECT_EXT = 0x8B40; + public static final int GL_SHADER_OBJECT_EXT = 0x8B48; + public static final int GL_BUFFER_OBJECT_EXT = 0x9151; + public static final int GL_QUERY_OBJECT_EXT = 0x9153; + public static final int GL_VERTEX_ARRAY_OBJECT_EXT = 0x9154; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_debug_label) return; + ext.glLabelObjectEXT = load.invoke("glLabelObjectEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetObjectLabelEXT = load.invoke("glGetObjectLabelEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS, ADDRESS)); + } + + public static void glLabelObjectEXT(int type, int object, int length, @NativeType("const GLchar *") MemorySegment label) { + final var ext = getExtCapabilities(); + try { + check(ext.glLabelObjectEXT).invokeExact(type, object, length, label); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetObjectLabelEXT(int type, int object, int bufSize, @NativeType("GLsizei *") MemorySegment length, @NativeType("GLchar *") MemorySegment label) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetObjectLabelEXT).invokeExact(type, object, bufSize, length, label); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDebugMarker.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDebugMarker.java new file mode 100644 index 00000000..e0b582d3 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDebugMarker.java @@ -0,0 +1,59 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_debug_marker} + */ +public final class GLEXTDebugMarker { + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_debug_marker) return; + ext.glInsertEventMarkerEXT = load.invoke("glInsertEventMarkerEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glPushGroupMarkerEXT = load.invoke("glPushGroupMarkerEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glPopGroupMarkerEXT = load.invoke("glPopGroupMarkerEXT", ofVoid()); + } + + public static void glInsertEventMarkerEXT(int length, @NativeType("const GLchar *") MemorySegment marker) { + final var ext = getExtCapabilities(); + try { + check(ext.glInsertEventMarkerEXT).invokeExact(length, marker); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glPushGroupMarkerEXT(int length, @NativeType("const GLchar *") MemorySegment marker) { + final var ext = getExtCapabilities(); + try { + check(ext.glPushGroupMarkerEXT).invokeExact(length, marker); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glPopGroupMarkerEXT() { + final var ext = getExtCapabilities(); + try { + check(ext.glPopGroupMarkerEXT).invokeExact(); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDepthBoundsTest.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDepthBoundsTest.java new file mode 100644 index 00000000..873d6492 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDepthBoundsTest.java @@ -0,0 +1,45 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_depth_bounds_test} + */ +public final class GLEXTDepthBoundsTest { + public static final int GL_DEPTH_BOUNDS_TEST_EXT = 0x8890; + public static final int GL_DEPTH_BOUNDS_EXT = 0x8891; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_depth_bounds_test) return; + ext.glDepthBoundsEXT = load.invoke("glDepthBoundsEXT", ofVoid(JAVA_DOUBLE, JAVA_DOUBLE)); + } + + public static void glDepthBoundsEXT(double zmin, double zmax) { + final var ext = getExtCapabilities(); + try { + check(ext.glDepthBoundsEXT).invokeExact(zmin, zmax); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDirectStateAccess.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDirectStateAccess.java new file mode 100644 index 00000000..8c8711df --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDirectStateAccess.java @@ -0,0 +1,2082 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_direct_state_access} + */ +public final class GLEXTDirectStateAccess { + public static final int GL_PROGRAM_MATRIX_EXT = 0x8E2D; + public static final int GL_TRANSPOSE_PROGRAM_MATRIX_EXT = 0x8E2E; + public static final int GL_PROGRAM_MATRIX_STACK_DEPTH_EXT = 0x8E2F; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_direct_state_access) return; + ext.glMatrixLoadfEXT = load.invoke("glMatrixLoadfEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glMatrixLoaddEXT = load.invoke("glMatrixLoaddEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glMatrixMultfEXT = load.invoke("glMatrixMultfEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glMatrixMultdEXT = load.invoke("glMatrixMultdEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glMatrixLoadIdentityEXT = load.invoke("glMatrixLoadIdentityEXT", ofVoid(JAVA_INT)); + ext.glMatrixRotatefEXT = load.invoke("glMatrixRotatefEXT", ofVoid(JAVA_INT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glMatrixRotatedEXT = load.invoke("glMatrixRotatedEXT", ofVoid(JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glMatrixScalefEXT = load.invoke("glMatrixScalefEXT", ofVoid(JAVA_INT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glMatrixScaledEXT = load.invoke("glMatrixScaledEXT", ofVoid(JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glMatrixTranslatefEXT = load.invoke("glMatrixTranslatefEXT", ofVoid(JAVA_INT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glMatrixTranslatedEXT = load.invoke("glMatrixTranslatedEXT", ofVoid(JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glMatrixFrustumEXT = load.invoke("glMatrixFrustumEXT", ofVoid(JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glMatrixOrthoEXT = load.invoke("glMatrixOrthoEXT", ofVoid(JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glMatrixPopEXT = load.invoke("glMatrixPopEXT", ofVoid(JAVA_INT)); + ext.glMatrixPushEXT = load.invoke("glMatrixPushEXT", ofVoid(JAVA_INT)); + ext.glClientAttribDefaultEXT = load.invoke("glClientAttribDefaultEXT", ofVoid(JAVA_INT)); + ext.glPushClientAttribDefaultEXT = load.invoke("glPushClientAttribDefaultEXT", ofVoid(JAVA_INT)); + ext.glTextureParameterfEXT = load.invoke("glTextureParameterfEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_FLOAT)); + ext.glTextureParameterfvEXT = load.invoke("glTextureParameterfvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glTextureParameteriEXT = load.invoke("glTextureParameteriEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glTextureParameterivEXT = load.invoke("glTextureParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glTextureImage1DEXT = load.invoke("glTextureImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glTextureImage2DEXT = load.invoke("glTextureImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glTextureSubImage1DEXT = load.invoke("glTextureSubImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glTextureSubImage2DEXT = load.invoke("glTextureSubImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCopyTextureImage1DEXT = load.invoke("glCopyTextureImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCopyTextureImage2DEXT = load.invoke("glCopyTextureImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCopyTextureSubImage1DEXT = load.invoke("glCopyTextureSubImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCopyTextureSubImage2DEXT = load.invoke("glCopyTextureSubImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glGetTextureImageEXT = load.invoke("glGetTextureImageEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetTextureParameterfvEXT = load.invoke("glGetTextureParameterfvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetTextureParameterivEXT = load.invoke("glGetTextureParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetTextureLevelParameterfvEXT = load.invoke("glGetTextureLevelParameterfvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetTextureLevelParameterivEXT = load.invoke("glGetTextureLevelParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glTextureImage3DEXT = load.invoke("glTextureImage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glTextureSubImage3DEXT = load.invoke("glTextureSubImage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCopyTextureSubImage3DEXT = load.invoke("glCopyTextureSubImage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glBindMultiTextureEXT = load.invoke("glBindMultiTextureEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glMultiTexCoordPointerEXT = load.invoke("glMultiTexCoordPointerEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexEnvfEXT = load.invoke("glMultiTexEnvfEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_FLOAT)); + ext.glMultiTexEnvfvEXT = load.invoke("glMultiTexEnvfvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexEnviEXT = load.invoke("glMultiTexEnviEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glMultiTexEnvivEXT = load.invoke("glMultiTexEnvivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexGendEXT = load.invoke("glMultiTexGendEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_DOUBLE)); + ext.glMultiTexGendvEXT = load.invoke("glMultiTexGendvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexGenfEXT = load.invoke("glMultiTexGenfEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_FLOAT)); + ext.glMultiTexGenfvEXT = load.invoke("glMultiTexGenfvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexGeniEXT = load.invoke("glMultiTexGeniEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glMultiTexGenivEXT = load.invoke("glMultiTexGenivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetMultiTexEnvfvEXT = load.invoke("glGetMultiTexEnvfvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetMultiTexEnvivEXT = load.invoke("glGetMultiTexEnvivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetMultiTexGendvEXT = load.invoke("glGetMultiTexGendvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetMultiTexGenfvEXT = load.invoke("glGetMultiTexGenfvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetMultiTexGenivEXT = load.invoke("glGetMultiTexGenivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexParameteriEXT = load.invoke("glMultiTexParameteriEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glMultiTexParameterivEXT = load.invoke("glMultiTexParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexParameterfEXT = load.invoke("glMultiTexParameterfEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_FLOAT)); + ext.glMultiTexParameterfvEXT = load.invoke("glMultiTexParameterfvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexImage1DEXT = load.invoke("glMultiTexImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexImage2DEXT = load.invoke("glMultiTexImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexSubImage1DEXT = load.invoke("glMultiTexSubImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexSubImage2DEXT = load.invoke("glMultiTexSubImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCopyMultiTexImage1DEXT = load.invoke("glCopyMultiTexImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCopyMultiTexImage2DEXT = load.invoke("glCopyMultiTexImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCopyMultiTexSubImage1DEXT = load.invoke("glCopyMultiTexSubImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCopyMultiTexSubImage2DEXT = load.invoke("glCopyMultiTexSubImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glGetMultiTexImageEXT = load.invoke("glGetMultiTexImageEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetMultiTexParameterfvEXT = load.invoke("glGetMultiTexParameterfvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetMultiTexParameterivEXT = load.invoke("glGetMultiTexParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetMultiTexLevelParameterfvEXT = load.invoke("glGetMultiTexLevelParameterfvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetMultiTexLevelParameterivEXT = load.invoke("glGetMultiTexLevelParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexImage3DEXT = load.invoke("glMultiTexImage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexSubImage3DEXT = load.invoke("glMultiTexSubImage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCopyMultiTexSubImage3DEXT = load.invoke("glCopyMultiTexSubImage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glEnableClientStateIndexedEXT = load.invoke("glEnableClientStateIndexedEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glDisableClientStateIndexedEXT = load.invoke("glDisableClientStateIndexedEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glGetFloatIndexedvEXT = load.invoke("glGetFloatIndexedvEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetDoubleIndexedvEXT = load.invoke("glGetDoubleIndexedvEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetPointerIndexedvEXT = load.invoke("glGetPointerIndexedvEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glEnableIndexedEXT = load.invoke("glEnableIndexedEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glDisableIndexedEXT = load.invoke("glDisableIndexedEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glIsEnabledIndexedEXT = load.invoke("glIsEnabledIndexedEXT", of(JAVA_BYTE, JAVA_INT, JAVA_INT)); + ext.glGetIntegerIndexedvEXT = load.invoke("glGetIntegerIndexedvEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetBooleanIndexedvEXT = load.invoke("glGetBooleanIndexedvEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedTextureImage3DEXT = load.invoke("glCompressedTextureImage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedTextureImage2DEXT = load.invoke("glCompressedTextureImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedTextureImage1DEXT = load.invoke("glCompressedTextureImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedTextureSubImage3DEXT = load.invoke("glCompressedTextureSubImage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedTextureSubImage2DEXT = load.invoke("glCompressedTextureSubImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedTextureSubImage1DEXT = load.invoke("glCompressedTextureSubImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetCompressedTextureImageEXT = load.invoke("glGetCompressedTextureImageEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedMultiTexImage3DEXT = load.invoke("glCompressedMultiTexImage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedMultiTexImage2DEXT = load.invoke("glCompressedMultiTexImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedMultiTexImage1DEXT = load.invoke("glCompressedMultiTexImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedMultiTexSubImage3DEXT = load.invoke("glCompressedMultiTexSubImage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedMultiTexSubImage2DEXT = load.invoke("glCompressedMultiTexSubImage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glCompressedMultiTexSubImage1DEXT = load.invoke("glCompressedMultiTexSubImage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetCompressedMultiTexImageEXT = load.invoke("glGetCompressedMultiTexImageEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMatrixLoadTransposefEXT = load.invoke("glMatrixLoadTransposefEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glMatrixLoadTransposedEXT = load.invoke("glMatrixLoadTransposedEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glMatrixMultTransposefEXT = load.invoke("glMatrixMultTransposefEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glMatrixMultTransposedEXT = load.invoke("glMatrixMultTransposedEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glNamedBufferDataEXT = load.invoke("glNamedBufferDataEXT", ofVoid(JAVA_INT, JAVA_LONG, ADDRESS, JAVA_INT)); + ext.glNamedBufferSubDataEXT = load.invoke("glNamedBufferSubDataEXT", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG, ADDRESS)); + ext.glMapNamedBufferEXT = load.invoke("glMapNamedBufferEXT", of(ADDRESS, JAVA_INT, JAVA_INT)); + ext.glUnmapNamedBufferEXT = load.invoke("glUnmapNamedBufferEXT", of(JAVA_BYTE, JAVA_INT)); + ext.glGetNamedBufferParameterivEXT = load.invoke("glGetNamedBufferParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetNamedBufferPointervEXT = load.invoke("glGetNamedBufferPointervEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetNamedBufferSubDataEXT = load.invoke("glGetNamedBufferSubDataEXT", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG, ADDRESS)); + ext.glProgramUniform1fEXT = load.invoke("glProgramUniform1fEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_FLOAT)); + ext.glProgramUniform2fEXT = load.invoke("glProgramUniform2fEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glProgramUniform3fEXT = load.invoke("glProgramUniform3fEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glProgramUniform4fEXT = load.invoke("glProgramUniform4fEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glProgramUniform1iEXT = load.invoke("glProgramUniform1iEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glProgramUniform2iEXT = load.invoke("glProgramUniform2iEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glProgramUniform3iEXT = load.invoke("glProgramUniform3iEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glProgramUniform4iEXT = load.invoke("glProgramUniform4iEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glProgramUniform1fvEXT = load.invoke("glProgramUniform1fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform2fvEXT = load.invoke("glProgramUniform2fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform3fvEXT = load.invoke("glProgramUniform3fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform4fvEXT = load.invoke("glProgramUniform4fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform1ivEXT = load.invoke("glProgramUniform1ivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform2ivEXT = load.invoke("glProgramUniform2ivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform3ivEXT = load.invoke("glProgramUniform3ivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform4ivEXT = load.invoke("glProgramUniform4ivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniformMatrix2fvEXT = load.invoke("glProgramUniformMatrix2fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix3fvEXT = load.invoke("glProgramUniformMatrix3fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix4fvEXT = load.invoke("glProgramUniformMatrix4fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix2x3fvEXT = load.invoke("glProgramUniformMatrix2x3fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix3x2fvEXT = load.invoke("glProgramUniformMatrix3x2fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix2x4fvEXT = load.invoke("glProgramUniformMatrix2x4fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix4x2fvEXT = load.invoke("glProgramUniformMatrix4x2fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix3x4fvEXT = load.invoke("glProgramUniformMatrix3x4fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix4x3fvEXT = load.invoke("glProgramUniformMatrix4x3fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glTextureBufferEXT = load.invoke("glTextureBufferEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glMultiTexBufferEXT = load.invoke("glMultiTexBufferEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glTextureParameterIivEXT = load.invoke("glTextureParameterIivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glTextureParameterIuivEXT = load.invoke("glTextureParameterIuivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetTextureParameterIivEXT = load.invoke("glGetTextureParameterIivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetTextureParameterIuivEXT = load.invoke("glGetTextureParameterIuivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexParameterIivEXT = load.invoke("glMultiTexParameterIivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMultiTexParameterIuivEXT = load.invoke("glMultiTexParameterIuivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetMultiTexParameterIivEXT = load.invoke("glGetMultiTexParameterIivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetMultiTexParameterIuivEXT = load.invoke("glGetMultiTexParameterIuivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform1uiEXT = load.invoke("glProgramUniform1uiEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glProgramUniform2uiEXT = load.invoke("glProgramUniform2uiEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glProgramUniform3uiEXT = load.invoke("glProgramUniform3uiEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glProgramUniform4uiEXT = load.invoke("glProgramUniform4uiEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glProgramUniform1uivEXT = load.invoke("glProgramUniform1uivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform2uivEXT = load.invoke("glProgramUniform2uivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform3uivEXT = load.invoke("glProgramUniform3uivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform4uivEXT = load.invoke("glProgramUniform4uivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedProgramLocalParameters4fvEXT = load.invoke("glNamedProgramLocalParameters4fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedProgramLocalParameterI4iEXT = load.invoke("glNamedProgramLocalParameterI4iEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glNamedProgramLocalParameterI4ivEXT = load.invoke("glNamedProgramLocalParameterI4ivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedProgramLocalParametersI4ivEXT = load.invoke("glNamedProgramLocalParametersI4ivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedProgramLocalParameterI4uiEXT = load.invoke("glNamedProgramLocalParameterI4uiEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glNamedProgramLocalParameterI4uivEXT = load.invoke("glNamedProgramLocalParameterI4uivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedProgramLocalParametersI4uivEXT = load.invoke("glNamedProgramLocalParametersI4uivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetNamedProgramLocalParameterIivEXT = load.invoke("glGetNamedProgramLocalParameterIivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetNamedProgramLocalParameterIuivEXT = load.invoke("glGetNamedProgramLocalParameterIuivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glEnableClientStateiEXT = load.invoke("glEnableClientStateiEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glDisableClientStateiEXT = load.invoke("glDisableClientStateiEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glGetFloati_vEXT = load.invoke("glGetFloati_vEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetDoublei_vEXT = load.invoke("glGetDoublei_vEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetPointeri_vEXT = load.invoke("glGetPointeri_vEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedProgramStringEXT = load.invoke("glNamedProgramStringEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedProgramLocalParameter4dEXT = load.invoke("glNamedProgramLocalParameter4dEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glNamedProgramLocalParameter4dvEXT = load.invoke("glNamedProgramLocalParameter4dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedProgramLocalParameter4fEXT = load.invoke("glNamedProgramLocalParameter4fEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glNamedProgramLocalParameter4fvEXT = load.invoke("glNamedProgramLocalParameter4fvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetNamedProgramLocalParameterdvEXT = load.invoke("glGetNamedProgramLocalParameterdvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetNamedProgramLocalParameterfvEXT = load.invoke("glGetNamedProgramLocalParameterfvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetNamedProgramivEXT = load.invoke("glGetNamedProgramivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetNamedProgramStringEXT = load.invoke("glGetNamedProgramStringEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedRenderbufferStorageEXT = load.invoke("glNamedRenderbufferStorageEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glGetNamedRenderbufferParameterivEXT = load.invoke("glGetNamedRenderbufferParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedRenderbufferStorageMultisampleEXT = load.invoke("glNamedRenderbufferStorageMultisampleEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glNamedRenderbufferStorageMultisampleCoverageEXT = load.invoke("glNamedRenderbufferStorageMultisampleCoverageEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glCheckNamedFramebufferStatusEXT = load.invoke("glCheckNamedFramebufferStatusEXT", of(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glNamedFramebufferTexture1DEXT = load.invoke("glNamedFramebufferTexture1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glNamedFramebufferTexture2DEXT = load.invoke("glNamedFramebufferTexture2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glNamedFramebufferTexture3DEXT = load.invoke("glNamedFramebufferTexture3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glNamedFramebufferRenderbufferEXT = load.invoke("glNamedFramebufferRenderbufferEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glGetNamedFramebufferAttachmentParameterivEXT = load.invoke("glGetNamedFramebufferAttachmentParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGenerateTextureMipmapEXT = load.invoke("glGenerateTextureMipmapEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glGenerateMultiTexMipmapEXT = load.invoke("glGenerateMultiTexMipmapEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glFramebufferDrawBufferEXT = load.invoke("glFramebufferDrawBufferEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glFramebufferDrawBuffersEXT = load.invoke("glFramebufferDrawBuffersEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glFramebufferReadBufferEXT = load.invoke("glFramebufferReadBufferEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glGetFramebufferParameterivEXT = load.invoke("glGetFramebufferParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedCopyBufferSubDataEXT = load.invoke("glNamedCopyBufferSubDataEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_LONG, JAVA_LONG, JAVA_LONG)); + ext.glNamedFramebufferTextureEXT = load.invoke("glNamedFramebufferTextureEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glNamedFramebufferTextureLayerEXT = load.invoke("glNamedFramebufferTextureLayerEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glNamedFramebufferTextureFaceEXT = load.invoke("glNamedFramebufferTextureFaceEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glTextureRenderbufferEXT = load.invoke("glTextureRenderbufferEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glMultiTexRenderbufferEXT = load.invoke("glMultiTexRenderbufferEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glVertexArrayVertexOffsetEXT = load.invoke("glVertexArrayVertexOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glVertexArrayColorOffsetEXT = load.invoke("glVertexArrayColorOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glVertexArrayEdgeFlagOffsetEXT = load.invoke("glVertexArrayEdgeFlagOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glVertexArrayIndexOffsetEXT = load.invoke("glVertexArrayIndexOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glVertexArrayNormalOffsetEXT = load.invoke("glVertexArrayNormalOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glVertexArrayTexCoordOffsetEXT = load.invoke("glVertexArrayTexCoordOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glVertexArrayMultiTexCoordOffsetEXT = load.invoke("glVertexArrayMultiTexCoordOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glVertexArrayFogCoordOffsetEXT = load.invoke("glVertexArrayFogCoordOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glVertexArraySecondaryColorOffsetEXT = load.invoke("glVertexArraySecondaryColorOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glVertexArrayVertexAttribOffsetEXT = load.invoke("glVertexArrayVertexAttribOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, JAVA_INT, JAVA_LONG)); + ext.glVertexArrayVertexAttribIOffsetEXT = load.invoke("glVertexArrayVertexAttribIOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glEnableVertexArrayEXT = load.invoke("glEnableVertexArrayEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glDisableVertexArrayEXT = load.invoke("glDisableVertexArrayEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glEnableVertexArrayAttribEXT = load.invoke("glEnableVertexArrayAttribEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glDisableVertexArrayAttribEXT = load.invoke("glDisableVertexArrayAttribEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glGetVertexArrayIntegervEXT = load.invoke("glGetVertexArrayIntegervEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetVertexArrayPointervEXT = load.invoke("glGetVertexArrayPointervEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetVertexArrayIntegeri_vEXT = load.invoke("glGetVertexArrayIntegeri_vEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetVertexArrayPointeri_vEXT = load.invoke("glGetVertexArrayPointeri_vEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glMapNamedBufferRangeEXT = load.invoke("glMapNamedBufferRangeEXT", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG, JAVA_INT)); + ext.glFlushMappedNamedBufferRangeEXT = load.invoke("glFlushMappedNamedBufferRangeEXT", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG)); + ext.glNamedBufferStorageEXT = load.invoke("glNamedBufferStorageEXT", ofVoid(JAVA_INT, JAVA_LONG, ADDRESS, JAVA_INT)); + ext.glClearNamedBufferDataEXT = load.invoke("glClearNamedBufferDataEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glClearNamedBufferSubDataEXT = load.invoke("glClearNamedBufferSubDataEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_LONG, JAVA_LONG, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glNamedFramebufferParameteriEXT = load.invoke("glNamedFramebufferParameteriEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glGetNamedFramebufferParameterivEXT = load.invoke("glGetNamedFramebufferParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform1dEXT = load.invoke("glProgramUniform1dEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_DOUBLE)); + ext.glProgramUniform2dEXT = load.invoke("glProgramUniform2dEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glProgramUniform3dEXT = load.invoke("glProgramUniform3dEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glProgramUniform4dEXT = load.invoke("glProgramUniform4dEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glProgramUniform1dvEXT = load.invoke("glProgramUniform1dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform2dvEXT = load.invoke("glProgramUniform2dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform3dvEXT = load.invoke("glProgramUniform3dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniform4dvEXT = load.invoke("glProgramUniform4dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramUniformMatrix2dvEXT = load.invoke("glProgramUniformMatrix2dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix3dvEXT = load.invoke("glProgramUniformMatrix3dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix4dvEXT = load.invoke("glProgramUniformMatrix4dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix2x3dvEXT = load.invoke("glProgramUniformMatrix2x3dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix2x4dvEXT = load.invoke("glProgramUniformMatrix2x4dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix3x2dvEXT = load.invoke("glProgramUniformMatrix3x2dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix3x4dvEXT = load.invoke("glProgramUniformMatrix3x4dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix4x2dvEXT = load.invoke("glProgramUniformMatrix4x2dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glProgramUniformMatrix4x3dvEXT = load.invoke("glProgramUniformMatrix4x3dvEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, ADDRESS)); + ext.glTextureBufferRangeEXT = load.invoke("glTextureBufferRangeEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG, JAVA_LONG)); + ext.glTextureStorage1DEXT = load.invoke("glTextureStorage1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glTextureStorage2DEXT = load.invoke("glTextureStorage2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glTextureStorage3DEXT = load.invoke("glTextureStorage3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glTextureStorage2DMultisampleEXT = load.invoke("glTextureStorage2DMultisampleEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE)); + ext.glTextureStorage3DMultisampleEXT = load.invoke("glTextureStorage3DMultisampleEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE)); + ext.glVertexArrayBindVertexBufferEXT = load.invoke("glVertexArrayBindVertexBufferEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG, JAVA_INT)); + ext.glVertexArrayVertexAttribFormatEXT = load.invoke("glVertexArrayVertexAttribFormatEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, JAVA_INT)); + ext.glVertexArrayVertexAttribIFormatEXT = load.invoke("glVertexArrayVertexAttribIFormatEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glVertexArrayVertexAttribLFormatEXT = load.invoke("glVertexArrayVertexAttribLFormatEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glVertexArrayVertexAttribBindingEXT = load.invoke("glVertexArrayVertexAttribBindingEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glVertexArrayVertexBindingDivisorEXT = load.invoke("glVertexArrayVertexBindingDivisorEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glVertexArrayVertexAttribLOffsetEXT = load.invoke("glVertexArrayVertexAttribLOffsetEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glTexturePageCommitmentEXT = load.invoke("glTexturePageCommitmentEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE)); + ext.glVertexArrayVertexAttribDivisorEXT = load.invoke("glVertexArrayVertexAttribDivisorEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + } + + public static void glMatrixLoadfEXT(int mode, @NativeType("const GLfloat *") MemorySegment m) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixLoadfEXT).invokeExact(mode, m); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixLoaddEXT(int mode, @NativeType("const GLdouble *") MemorySegment m) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixLoaddEXT).invokeExact(mode, m); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixMultfEXT(int mode, @NativeType("const GLfloat *") MemorySegment m) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixMultfEXT).invokeExact(mode, m); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixMultdEXT(int mode, @NativeType("const GLdouble *") MemorySegment m) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixMultdEXT).invokeExact(mode, m); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixLoadIdentityEXT(int mode) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixLoadIdentityEXT).invokeExact(mode); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixRotatefEXT(int mode, float angle, float x, float y, float z) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixRotatefEXT).invokeExact(mode, angle, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixRotatedEXT(int mode, double angle, double x, double y, double z) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixRotatedEXT).invokeExact(mode, angle, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixScalefEXT(int mode, float x, float y, float z) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixScalefEXT).invokeExact(mode, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixScaledEXT(int mode, double x, double y, double z) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixScaledEXT).invokeExact(mode, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixTranslatefEXT(int mode, float x, float y, float z) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixTranslatefEXT).invokeExact(mode, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixTranslatedEXT(int mode, double x, double y, double z) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixTranslatedEXT).invokeExact(mode, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixFrustumEXT(int mode, double left, double right, double bottom, double top, double zNear, double zFar) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixFrustumEXT).invokeExact(mode, left, right, bottom, top, zNear, zFar); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixOrthoEXT(int mode, double left, double right, double bottom, double top, double zNear, double zFar) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixOrthoEXT).invokeExact(mode, left, right, bottom, top, zNear, zFar); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixPopEXT(int mode) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixPopEXT).invokeExact(mode); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixPushEXT(int mode) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixPushEXT).invokeExact(mode); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glClientAttribDefaultEXT(int mask) { + final var ext = getExtCapabilities(); + try { + check(ext.glClientAttribDefaultEXT).invokeExact(mask); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glPushClientAttribDefaultEXT(int mask) { + final var ext = getExtCapabilities(); + try { + check(ext.glPushClientAttribDefaultEXT).invokeExact(mask); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureParameterfEXT(int texture, int target, int pname, float param) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureParameterfEXT).invokeExact(texture, target, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureParameterfvEXT(int texture, int target, int pname, @NativeType("const GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureParameterfvEXT).invokeExact(texture, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureParameteriEXT(int texture, int target, int pname, int param) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureParameteriEXT).invokeExact(texture, target, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureParameterivEXT(int texture, int target, int pname, @NativeType("const GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureParameterivEXT).invokeExact(texture, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureImage1DEXT(int texture, int target, int level, int internalformat, int width, int border, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureImage1DEXT).invokeExact(texture, target, level, internalformat, width, border, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureImage2DEXT(int texture, int target, int level, int internalformat, int width, int height, int border, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureImage2DEXT).invokeExact(texture, target, level, internalformat, width, height, border, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureSubImage1DEXT(int texture, int target, int level, int xoffset, int width, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureSubImage1DEXT).invokeExact(texture, target, level, xoffset, width, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureSubImage2DEXT(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureSubImage2DEXT).invokeExact(texture, target, level, xoffset, yoffset, width, height, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyTextureImage1DEXT(int texture, int target, int level, int internalformat, int x, int y, int width, int border) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyTextureImage1DEXT).invokeExact(texture, target, level, internalformat, x, y, width, border); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyTextureImage2DEXT(int texture, int target, int level, int internalformat, int x, int y, int width, int height, int border) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyTextureImage2DEXT).invokeExact(texture, target, level, internalformat, x, y, width, height, border); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyTextureSubImage1DEXT(int texture, int target, int level, int xoffset, int x, int y, int width) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyTextureSubImage1DEXT).invokeExact(texture, target, level, xoffset, x, y, width); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyTextureSubImage2DEXT(int texture, int target, int level, int xoffset, int yoffset, int x, int y, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyTextureSubImage2DEXT).invokeExact(texture, target, level, xoffset, yoffset, x, y, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetTextureImageEXT(int texture, int target, int level, int format, int type, @NativeType("void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetTextureImageEXT).invokeExact(texture, target, level, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetTextureParameterfvEXT(int texture, int target, int pname, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetTextureParameterfvEXT).invokeExact(texture, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetTextureParameterivEXT(int texture, int target, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetTextureParameterivEXT).invokeExact(texture, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetTextureLevelParameterfvEXT(int texture, int target, int level, int pname, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetTextureLevelParameterfvEXT).invokeExact(texture, target, level, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetTextureLevelParameterivEXT(int texture, int target, int level, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetTextureLevelParameterivEXT).invokeExact(texture, target, level, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureImage3DEXT(int texture, int target, int level, int internalformat, int width, int height, int depth, int border, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureImage3DEXT).invokeExact(texture, target, level, internalformat, width, height, depth, border, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureSubImage3DEXT(int texture, int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureSubImage3DEXT).invokeExact(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyTextureSubImage3DEXT(int texture, int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyTextureSubImage3DEXT).invokeExact(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBindMultiTextureEXT(int texunit, int target, int texture) { + final var ext = getExtCapabilities(); + try { + check(ext.glBindMultiTextureEXT).invokeExact(texunit, target, texture); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexCoordPointerEXT(int texunit, int size, int type, int stride, @NativeType("const void *") MemorySegment pointer) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexCoordPointerEXT).invokeExact(texunit, size, type, stride, pointer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexEnvfEXT(int texunit, int target, int pname, float param) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexEnvfEXT).invokeExact(texunit, target, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexEnvfvEXT(int texunit, int target, int pname, @NativeType("const GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexEnvfvEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexEnviEXT(int texunit, int target, int pname, int param) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexEnviEXT).invokeExact(texunit, target, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexEnvivEXT(int texunit, int target, int pname, @NativeType("const GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexEnvivEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexGendEXT(int texunit, int coord, int pname, double param) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexGendEXT).invokeExact(texunit, coord, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexGendvEXT(int texunit, int coord, int pname, @NativeType("const GLdouble *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexGendvEXT).invokeExact(texunit, coord, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexGenfEXT(int texunit, int coord, int pname, float param) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexGenfEXT).invokeExact(texunit, coord, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexGenfvEXT(int texunit, int coord, int pname, @NativeType("const GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexGenfvEXT).invokeExact(texunit, coord, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexGeniEXT(int texunit, int coord, int pname, int param) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexGeniEXT).invokeExact(texunit, coord, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexGenivEXT(int texunit, int coord, int pname, @NativeType("const GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexGenivEXT).invokeExact(texunit, coord, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexEnvfvEXT(int texunit, int target, int pname, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexEnvfvEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexEnvivEXT(int texunit, int target, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexEnvivEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexGendvEXT(int texunit, int coord, int pname, @NativeType("GLdouble *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexGendvEXT).invokeExact(texunit, coord, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexGenfvEXT(int texunit, int coord, int pname, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexGenfvEXT).invokeExact(texunit, coord, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexGenivEXT(int texunit, int coord, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexGenivEXT).invokeExact(texunit, coord, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexParameteriEXT(int texunit, int target, int pname, int param) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexParameteriEXT).invokeExact(texunit, target, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexParameterivEXT(int texunit, int target, int pname, @NativeType("const GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexParameterivEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexParameterfEXT(int texunit, int target, int pname, float param) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexParameterfEXT).invokeExact(texunit, target, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexParameterfvEXT(int texunit, int target, int pname, @NativeType("const GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexParameterfvEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexImage1DEXT(int texunit, int target, int level, int internalformat, int width, int border, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexImage1DEXT).invokeExact(texunit, target, level, internalformat, width, border, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexImage2DEXT(int texunit, int target, int level, int internalformat, int width, int height, int border, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexImage2DEXT).invokeExact(texunit, target, level, internalformat, width, height, border, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexSubImage1DEXT(int texunit, int target, int level, int xoffset, int width, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexSubImage1DEXT).invokeExact(texunit, target, level, xoffset, width, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexSubImage2DEXT(int texunit, int target, int level, int xoffset, int yoffset, int width, int height, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexSubImage2DEXT).invokeExact(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyMultiTexImage1DEXT(int texunit, int target, int level, int internalformat, int x, int y, int width, int border) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyMultiTexImage1DEXT).invokeExact(texunit, target, level, internalformat, x, y, width, border); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyMultiTexImage2DEXT(int texunit, int target, int level, int internalformat, int x, int y, int width, int height, int border) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyMultiTexImage2DEXT).invokeExact(texunit, target, level, internalformat, x, y, width, height, border); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyMultiTexSubImage1DEXT(int texunit, int target, int level, int xoffset, int x, int y, int width) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyMultiTexSubImage1DEXT).invokeExact(texunit, target, level, xoffset, x, y, width); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyMultiTexSubImage2DEXT(int texunit, int target, int level, int xoffset, int yoffset, int x, int y, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyMultiTexSubImage2DEXT).invokeExact(texunit, target, level, xoffset, yoffset, x, y, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexImageEXT(int texunit, int target, int level, int format, int type, @NativeType("void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexImageEXT).invokeExact(texunit, target, level, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexParameterfvEXT(int texunit, int target, int pname, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexParameterfvEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexParameterivEXT(int texunit, int target, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexParameterivEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexLevelParameterfvEXT(int texunit, int target, int level, int pname, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexLevelParameterfvEXT).invokeExact(texunit, target, level, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexLevelParameterivEXT(int texunit, int target, int level, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexLevelParameterivEXT).invokeExact(texunit, target, level, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexImage3DEXT(int texunit, int target, int level, int internalformat, int width, int height, int depth, int border, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexImage3DEXT).invokeExact(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexSubImage3DEXT(int texunit, int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int type, @NativeType("const void *") MemorySegment pixels) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexSubImage3DEXT).invokeExact(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCopyMultiTexSubImage3DEXT(int texunit, int target, int level, int xoffset, int yoffset, int zoffset, int x, int y, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glCopyMultiTexSubImage3DEXT).invokeExact(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glEnableClientStateIndexedEXT(int array, int index) { + final var ext = getExtCapabilities(); + try { + check(ext.glEnableClientStateIndexedEXT).invokeExact(array, index); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glDisableClientStateIndexedEXT(int array, int index) { + final var ext = getExtCapabilities(); + try { + check(ext.glDisableClientStateIndexedEXT).invokeExact(array, index); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetFloatIndexedvEXT(int target, int index, @NativeType("GLfloat *") MemorySegment data) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetFloatIndexedvEXT).invokeExact(target, index, data); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetDoubleIndexedvEXT(int target, int index, @NativeType("GLdouble *") MemorySegment data) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetDoubleIndexedvEXT).invokeExact(target, index, data); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetPointerIndexedvEXT(int target, int index, @NativeType("void **") MemorySegment data) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetPointerIndexedvEXT).invokeExact(target, index, data); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glEnableIndexedEXT(int target, int index) { + final var ext = getExtCapabilities(); + try { + check(ext.glEnableIndexedEXT).invokeExact(target, index); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glDisableIndexedEXT(int target, int index) { + final var ext = getExtCapabilities(); + try { + check(ext.glDisableIndexedEXT).invokeExact(target, index); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static boolean glIsEnabledIndexedEXT(int target, int index) { + final var ext = getExtCapabilities(); + try { + return (boolean) + check(ext.glIsEnabledIndexedEXT).invokeExact(target, index); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetIntegerIndexedvEXT(int target, int index, @NativeType("GLint *") MemorySegment data) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetIntegerIndexedvEXT).invokeExact(target, index, data); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetBooleanIndexedvEXT(int target, int index, @NativeType("GLboolean *") MemorySegment data) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetBooleanIndexedvEXT).invokeExact(target, index, data); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedTextureImage3DEXT(int texture, int target, int level, int internalformat, int width, int height, int depth, int border, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedTextureImage3DEXT).invokeExact(texture, target, level, internalformat, width, height, depth, border, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedTextureImage2DEXT(int texture, int target, int level, int internalformat, int width, int height, int border, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedTextureImage2DEXT).invokeExact(texture, target, level, internalformat, width, height, border, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedTextureImage1DEXT(int texture, int target, int level, int internalformat, int width, int border, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedTextureImage1DEXT).invokeExact(texture, target, level, internalformat, width, border, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedTextureSubImage3DEXT(int texture, int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedTextureSubImage3DEXT).invokeExact(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedTextureSubImage2DEXT(int texture, int target, int level, int xoffset, int yoffset, int width, int height, int format, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedTextureSubImage2DEXT).invokeExact(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedTextureSubImage1DEXT(int texture, int target, int level, int xoffset, int width, int format, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedTextureSubImage1DEXT).invokeExact(texture, target, level, xoffset, width, format, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetCompressedTextureImageEXT(int texture, int target, int lod, @NativeType("void *") MemorySegment img) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetCompressedTextureImageEXT).invokeExact(texture, target, lod, img); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedMultiTexImage3DEXT(int texunit, int target, int level, int internalformat, int width, int height, int depth, int border, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedMultiTexImage3DEXT).invokeExact(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedMultiTexImage2DEXT(int texunit, int target, int level, int internalformat, int width, int height, int border, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedMultiTexImage2DEXT).invokeExact(texunit, target, level, internalformat, width, height, border, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedMultiTexImage1DEXT(int texunit, int target, int level, int internalformat, int width, int border, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedMultiTexImage1DEXT).invokeExact(texunit, target, level, internalformat, width, border, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedMultiTexSubImage3DEXT(int texunit, int target, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, int format, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedMultiTexSubImage3DEXT).invokeExact(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedMultiTexSubImage2DEXT(int texunit, int target, int level, int xoffset, int yoffset, int width, int height, int format, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedMultiTexSubImage2DEXT).invokeExact(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glCompressedMultiTexSubImage1DEXT(int texunit, int target, int level, int xoffset, int width, int format, int imageSize, @NativeType("const void *") MemorySegment bits) { + final var ext = getExtCapabilities(); + try { + check(ext.glCompressedMultiTexSubImage1DEXT).invokeExact(texunit, target, level, xoffset, width, format, imageSize, bits); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetCompressedMultiTexImageEXT(int texunit, int target, int lod, @NativeType("void *") MemorySegment img) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetCompressedMultiTexImageEXT).invokeExact(texunit, target, lod, img); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixLoadTransposefEXT(int mode, @NativeType("const GLfloat *") MemorySegment m) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixLoadTransposefEXT).invokeExact(mode, m); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixLoadTransposedEXT(int mode, @NativeType("const GLdouble *") MemorySegment m) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixLoadTransposedEXT).invokeExact(mode, m); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixMultTransposefEXT(int mode, @NativeType("const GLfloat *") MemorySegment m) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixMultTransposefEXT).invokeExact(mode, m); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMatrixMultTransposedEXT(int mode, @NativeType("const GLdouble *") MemorySegment m) { + final var ext = getExtCapabilities(); + try { + check(ext.glMatrixMultTransposedEXT).invokeExact(mode, m); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedBufferDataEXT(int buffer, long size, @NativeType("const void *") MemorySegment data, int usage) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedBufferDataEXT).invokeExact(buffer, size, data, usage); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedBufferSubDataEXT(int buffer, long offset, long size, @NativeType("const void *") MemorySegment data) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedBufferSubDataEXT).invokeExact(buffer, offset, size, data); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static @NativeType("void *") MemorySegment glMapNamedBufferEXT(int buffer, int access) { + final var ext = getExtCapabilities(); + try { + return (MemorySegment) + check(ext.glMapNamedBufferEXT).invokeExact(buffer, access); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static boolean glUnmapNamedBufferEXT(int buffer) { + final var ext = getExtCapabilities(); + try { + return (boolean) + check(ext.glUnmapNamedBufferEXT).invokeExact(buffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedBufferParameterivEXT(int buffer, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedBufferParameterivEXT).invokeExact(buffer, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedBufferPointervEXT(int buffer, int pname, @NativeType("void **") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedBufferPointervEXT).invokeExact(buffer, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedBufferSubDataEXT(int buffer, long offset, long size, @NativeType("void *") MemorySegment data) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedBufferSubDataEXT).invokeExact(buffer, offset, size, data); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform1fEXT(int program, int location, float v0) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform1fEXT).invokeExact(program, location, v0); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform2fEXT(int program, int location, float v0, float v1) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform2fEXT).invokeExact(program, location, v0, v1); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform3fEXT(int program, int location, float v0, float v1, float v2) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform3fEXT).invokeExact(program, location, v0, v1, v2); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform4fEXT(int program, int location, float v0, float v1, float v2, float v3) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform4fEXT).invokeExact(program, location, v0, v1, v2, v3); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform1iEXT(int program, int location, int v0) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform1iEXT).invokeExact(program, location, v0); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform2iEXT(int program, int location, int v0, int v1) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform2iEXT).invokeExact(program, location, v0, v1); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform3iEXT(int program, int location, int v0, int v1, int v2) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform3iEXT).invokeExact(program, location, v0, v1, v2); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform4iEXT(int program, int location, int v0, int v1, int v2, int v3) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform4iEXT).invokeExact(program, location, v0, v1, v2, v3); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform1fvEXT(int program, int location, int count, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform1fvEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform2fvEXT(int program, int location, int count, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform2fvEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform3fvEXT(int program, int location, int count, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform3fvEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform4fvEXT(int program, int location, int count, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform4fvEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform1ivEXT(int program, int location, int count, @NativeType("const GLint *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform1ivEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform2ivEXT(int program, int location, int count, @NativeType("const GLint *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform2ivEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform3ivEXT(int program, int location, int count, @NativeType("const GLint *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform3ivEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform4ivEXT(int program, int location, int count, @NativeType("const GLint *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform4ivEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix2fvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix2fvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix3fvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix3fvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix4fvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix4fvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix2x3fvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix2x3fvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix3x2fvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix3x2fvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix2x4fvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix2x4fvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix4x2fvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix4x2fvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix3x4fvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix3x4fvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix4x3fvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLfloat *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix4x3fvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureBufferEXT(int texture, int target, int internalformat, int buffer) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureBufferEXT).invokeExact(texture, target, internalformat, buffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexBufferEXT(int texunit, int target, int internalformat, int buffer) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexBufferEXT).invokeExact(texunit, target, internalformat, buffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureParameterIivEXT(int texture, int target, int pname, @NativeType("const GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureParameterIivEXT).invokeExact(texture, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureParameterIuivEXT(int texture, int target, int pname, @NativeType("const GLuint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureParameterIuivEXT).invokeExact(texture, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetTextureParameterIivEXT(int texture, int target, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetTextureParameterIivEXT).invokeExact(texture, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetTextureParameterIuivEXT(int texture, int target, int pname, @NativeType("GLuint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetTextureParameterIuivEXT).invokeExact(texture, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexParameterIivEXT(int texunit, int target, int pname, @NativeType("const GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexParameterIivEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexParameterIuivEXT(int texunit, int target, int pname, @NativeType("const GLuint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexParameterIuivEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexParameterIivEXT(int texunit, int target, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexParameterIivEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetMultiTexParameterIuivEXT(int texunit, int target, int pname, @NativeType("GLuint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetMultiTexParameterIuivEXT).invokeExact(texunit, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform1uiEXT(int program, int location, int v0) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform1uiEXT).invokeExact(program, location, v0); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform2uiEXT(int program, int location, int v0, int v1) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform2uiEXT).invokeExact(program, location, v0, v1); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform3uiEXT(int program, int location, int v0, int v1, int v2) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform3uiEXT).invokeExact(program, location, v0, v1, v2); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform4uiEXT(int program, int location, int v0, int v1, int v2, int v3) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform4uiEXT).invokeExact(program, location, v0, v1, v2, v3); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform1uivEXT(int program, int location, int count, @NativeType("const GLuint *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform1uivEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform2uivEXT(int program, int location, int count, @NativeType("const GLuint *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform2uivEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform3uivEXT(int program, int location, int count, @NativeType("const GLuint *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform3uivEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform4uivEXT(int program, int location, int count, @NativeType("const GLuint *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform4uivEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramLocalParameters4fvEXT(int program, int target, int index, int count, @NativeType("const GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramLocalParameters4fvEXT).invokeExact(program, target, index, count, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramLocalParameterI4iEXT(int program, int target, int index, int x, int y, int z, int w) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramLocalParameterI4iEXT).invokeExact(program, target, index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramLocalParameterI4ivEXT(int program, int target, int index, @NativeType("const GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramLocalParameterI4ivEXT).invokeExact(program, target, index, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramLocalParametersI4ivEXT(int program, int target, int index, int count, @NativeType("const GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramLocalParametersI4ivEXT).invokeExact(program, target, index, count, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramLocalParameterI4uiEXT(int program, int target, int index, int x, int y, int z, int w) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramLocalParameterI4uiEXT).invokeExact(program, target, index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramLocalParameterI4uivEXT(int program, int target, int index, @NativeType("const GLuint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramLocalParameterI4uivEXT).invokeExact(program, target, index, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramLocalParametersI4uivEXT(int program, int target, int index, int count, @NativeType("const GLuint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramLocalParametersI4uivEXT).invokeExact(program, target, index, count, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedProgramLocalParameterIivEXT(int program, int target, int index, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedProgramLocalParameterIivEXT).invokeExact(program, target, index, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedProgramLocalParameterIuivEXT(int program, int target, int index, @NativeType("GLuint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedProgramLocalParameterIuivEXT).invokeExact(program, target, index, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glEnableClientStateiEXT(int array, int index) { + final var ext = getExtCapabilities(); + try { + check(ext.glEnableClientStateiEXT).invokeExact(array, index); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glDisableClientStateiEXT(int array, int index) { + final var ext = getExtCapabilities(); + try { + check(ext.glDisableClientStateiEXT).invokeExact(array, index); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetFloati_vEXT(int pname, int index, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetFloati_vEXT).invokeExact(pname, index, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetDoublei_vEXT(int pname, int index, @NativeType("GLdouble *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetDoublei_vEXT).invokeExact(pname, index, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetPointeri_vEXT(int pname, int index, @NativeType("void **") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetPointeri_vEXT).invokeExact(pname, index, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramStringEXT(int program, int target, int format, int len, @NativeType("const void *") MemorySegment string) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramStringEXT).invokeExact(program, target, format, len, string); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramLocalParameter4dEXT(int program, int target, int index, double x, double y, double z, double w) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramLocalParameter4dEXT).invokeExact(program, target, index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramLocalParameter4dvEXT(int program, int target, int index, @NativeType("const GLdouble *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramLocalParameter4dvEXT).invokeExact(program, target, index, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramLocalParameter4fEXT(int program, int target, int index, float x, float y, float z, float w) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramLocalParameter4fEXT).invokeExact(program, target, index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedProgramLocalParameter4fvEXT(int program, int target, int index, @NativeType("const GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedProgramLocalParameter4fvEXT).invokeExact(program, target, index, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedProgramLocalParameterdvEXT(int program, int target, int index, @NativeType("GLdouble *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedProgramLocalParameterdvEXT).invokeExact(program, target, index, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedProgramLocalParameterfvEXT(int program, int target, int index, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedProgramLocalParameterfvEXT).invokeExact(program, target, index, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedProgramivEXT(int program, int target, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedProgramivEXT).invokeExact(program, target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedProgramStringEXT(int program, int target, int pname, @NativeType("void *") MemorySegment string) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedProgramStringEXT).invokeExact(program, target, pname, string); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedRenderbufferStorageEXT(int renderbuffer, int internalformat, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedRenderbufferStorageEXT).invokeExact(renderbuffer, internalformat, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedRenderbufferParameterivEXT(int renderbuffer, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedRenderbufferParameterivEXT).invokeExact(renderbuffer, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedRenderbufferStorageMultisampleEXT(int renderbuffer, int samples, int internalformat, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedRenderbufferStorageMultisampleEXT).invokeExact(renderbuffer, samples, internalformat, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedRenderbufferStorageMultisampleCoverageEXT(int renderbuffer, int coverageSamples, int colorSamples, int internalformat, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedRenderbufferStorageMultisampleCoverageEXT).invokeExact(renderbuffer, coverageSamples, colorSamples, internalformat, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static int glCheckNamedFramebufferStatusEXT(int framebuffer, int target) { + final var ext = getExtCapabilities(); + try { + return (int) + check(ext.glCheckNamedFramebufferStatusEXT).invokeExact(framebuffer, target); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedFramebufferTexture1DEXT(int framebuffer, int attachment, int textarget, int texture, int level) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedFramebufferTexture1DEXT).invokeExact(framebuffer, attachment, textarget, texture, level); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedFramebufferTexture2DEXT(int framebuffer, int attachment, int textarget, int texture, int level) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedFramebufferTexture2DEXT).invokeExact(framebuffer, attachment, textarget, texture, level); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedFramebufferTexture3DEXT(int framebuffer, int attachment, int textarget, int texture, int level, int zoffset) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedFramebufferTexture3DEXT).invokeExact(framebuffer, attachment, textarget, texture, level, zoffset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedFramebufferRenderbufferEXT(int framebuffer, int attachment, int renderbuffertarget, int renderbuffer) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedFramebufferRenderbufferEXT).invokeExact(framebuffer, attachment, renderbuffertarget, renderbuffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedFramebufferAttachmentParameterivEXT(int framebuffer, int attachment, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedFramebufferAttachmentParameterivEXT).invokeExact(framebuffer, attachment, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGenerateTextureMipmapEXT(int texture, int target) { + final var ext = getExtCapabilities(); + try { + check(ext.glGenerateTextureMipmapEXT).invokeExact(texture, target); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGenerateMultiTexMipmapEXT(int texunit, int target) { + final var ext = getExtCapabilities(); + try { + check(ext.glGenerateMultiTexMipmapEXT).invokeExact(texunit, target); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFramebufferDrawBufferEXT(int framebuffer, int mode) { + final var ext = getExtCapabilities(); + try { + check(ext.glFramebufferDrawBufferEXT).invokeExact(framebuffer, mode); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFramebufferDrawBuffersEXT(int framebuffer, int n, @NativeType("const GLenum *") MemorySegment bufs) { + final var ext = getExtCapabilities(); + try { + check(ext.glFramebufferDrawBuffersEXT).invokeExact(framebuffer, n, bufs); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFramebufferReadBufferEXT(int framebuffer, int mode) { + final var ext = getExtCapabilities(); + try { + check(ext.glFramebufferReadBufferEXT).invokeExact(framebuffer, mode); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetFramebufferParameterivEXT(int framebuffer, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetFramebufferParameterivEXT).invokeExact(framebuffer, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedCopyBufferSubDataEXT(int readBuffer, int writeBuffer, long readOffset, long writeOffset, long size) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedCopyBufferSubDataEXT).invokeExact(readBuffer, writeBuffer, readOffset, writeOffset, size); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedFramebufferTextureEXT(int framebuffer, int attachment, int texture, int level) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedFramebufferTextureEXT).invokeExact(framebuffer, attachment, texture, level); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedFramebufferTextureLayerEXT(int framebuffer, int attachment, int texture, int level, int layer) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedFramebufferTextureLayerEXT).invokeExact(framebuffer, attachment, texture, level, layer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedFramebufferTextureFaceEXT(int framebuffer, int attachment, int texture, int level, int face) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedFramebufferTextureFaceEXT).invokeExact(framebuffer, attachment, texture, level, face); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureRenderbufferEXT(int texture, int target, int renderbuffer) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureRenderbufferEXT).invokeExact(texture, target, renderbuffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMultiTexRenderbufferEXT(int texunit, int target, int renderbuffer) { + final var ext = getExtCapabilities(); + try { + check(ext.glMultiTexRenderbufferEXT).invokeExact(texunit, target, renderbuffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayVertexOffsetEXT(int vaobj, int buffer, int size, int type, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayVertexOffsetEXT).invokeExact(vaobj, buffer, size, type, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayColorOffsetEXT(int vaobj, int buffer, int size, int type, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayColorOffsetEXT).invokeExact(vaobj, buffer, size, type, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayEdgeFlagOffsetEXT(int vaobj, int buffer, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayEdgeFlagOffsetEXT).invokeExact(vaobj, buffer, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayIndexOffsetEXT(int vaobj, int buffer, int type, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayIndexOffsetEXT).invokeExact(vaobj, buffer, type, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayNormalOffsetEXT(int vaobj, int buffer, int type, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayNormalOffsetEXT).invokeExact(vaobj, buffer, type, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayTexCoordOffsetEXT(int vaobj, int buffer, int size, int type, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayTexCoordOffsetEXT).invokeExact(vaobj, buffer, size, type, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayMultiTexCoordOffsetEXT(int vaobj, int buffer, int texunit, int size, int type, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayMultiTexCoordOffsetEXT).invokeExact(vaobj, buffer, texunit, size, type, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayFogCoordOffsetEXT(int vaobj, int buffer, int type, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayFogCoordOffsetEXT).invokeExact(vaobj, buffer, type, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArraySecondaryColorOffsetEXT(int vaobj, int buffer, int size, int type, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArraySecondaryColorOffsetEXT).invokeExact(vaobj, buffer, size, type, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayVertexAttribOffsetEXT(int vaobj, int buffer, int index, int size, int type, boolean normalized, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayVertexAttribOffsetEXT).invokeExact(vaobj, buffer, index, size, type, normalized, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayVertexAttribIOffsetEXT(int vaobj, int buffer, int index, int size, int type, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayVertexAttribIOffsetEXT).invokeExact(vaobj, buffer, index, size, type, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glEnableVertexArrayEXT(int vaobj, int array) { + final var ext = getExtCapabilities(); + try { + check(ext.glEnableVertexArrayEXT).invokeExact(vaobj, array); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glDisableVertexArrayEXT(int vaobj, int array) { + final var ext = getExtCapabilities(); + try { + check(ext.glDisableVertexArrayEXT).invokeExact(vaobj, array); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glEnableVertexArrayAttribEXT(int vaobj, int index) { + final var ext = getExtCapabilities(); + try { + check(ext.glEnableVertexArrayAttribEXT).invokeExact(vaobj, index); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glDisableVertexArrayAttribEXT(int vaobj, int index) { + final var ext = getExtCapabilities(); + try { + check(ext.glDisableVertexArrayAttribEXT).invokeExact(vaobj, index); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVertexArrayIntegervEXT(int vaobj, int pname, @NativeType("GLint *") MemorySegment param) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVertexArrayIntegervEXT).invokeExact(vaobj, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVertexArrayPointervEXT(int vaobj, int pname, @NativeType("void **") MemorySegment param) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVertexArrayPointervEXT).invokeExact(vaobj, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVertexArrayIntegeri_vEXT(int vaobj, int index, int pname, @NativeType("GLint *") MemorySegment param) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVertexArrayIntegeri_vEXT).invokeExact(vaobj, index, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVertexArrayPointeri_vEXT(int vaobj, int index, int pname, @NativeType("void **") MemorySegment param) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVertexArrayPointeri_vEXT).invokeExact(vaobj, index, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glMapNamedBufferRangeEXT(int buffer, long offset, long length, int access) { + final var ext = getExtCapabilities(); + try { + check(ext.glMapNamedBufferRangeEXT).invokeExact(buffer, offset, length, access); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFlushMappedNamedBufferRangeEXT(int buffer, long offset, long length) { + final var ext = getExtCapabilities(); + try { + check(ext.glFlushMappedNamedBufferRangeEXT).invokeExact(buffer, offset, length); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedBufferStorageEXT(int buffer, long size, @NativeType("const void *") MemorySegment data, int flags) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedBufferStorageEXT).invokeExact(buffer, size, data, flags); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glClearNamedBufferDataEXT(int buffer, int internalformat, int format, int type, @NativeType("const void *") MemorySegment data) { + final var ext = getExtCapabilities(); + try { + check(ext.glClearNamedBufferDataEXT).invokeExact(buffer, internalformat, format, type, data); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glClearNamedBufferSubDataEXT(int buffer, int internalformat, long offset, long size, int format, int type, @NativeType("const void *") MemorySegment data) { + final var ext = getExtCapabilities(); + try { + check(ext.glClearNamedBufferSubDataEXT).invokeExact(buffer, internalformat, offset, size, format, type, data); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedFramebufferParameteriEXT(int framebuffer, int pname, int param) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedFramebufferParameteriEXT).invokeExact(framebuffer, pname, param); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetNamedFramebufferParameterivEXT(int framebuffer, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetNamedFramebufferParameterivEXT).invokeExact(framebuffer, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform1dEXT(int program, int location, double x) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform1dEXT).invokeExact(program, location, x); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform2dEXT(int program, int location, double x, double y) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform2dEXT).invokeExact(program, location, x, y); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform3dEXT(int program, int location, double x, double y, double z) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform3dEXT).invokeExact(program, location, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform4dEXT(int program, int location, double x, double y, double z, double w) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform4dEXT).invokeExact(program, location, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform1dvEXT(int program, int location, int count, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform1dvEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform2dvEXT(int program, int location, int count, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform2dvEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform3dvEXT(int program, int location, int count, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform3dvEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniform4dvEXT(int program, int location, int count, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniform4dvEXT).invokeExact(program, location, count, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix2dvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix2dvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix3dvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix3dvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix4dvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix4dvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix2x3dvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix2x3dvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix2x4dvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix2x4dvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix3x2dvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix3x2dvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix3x4dvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix3x4dvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix4x2dvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix4x2dvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramUniformMatrix4x3dvEXT(int program, int location, int count, boolean transpose, @NativeType("const GLdouble *") MemorySegment value) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramUniformMatrix4x3dvEXT).invokeExact(program, location, count, transpose, value); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureBufferRangeEXT(int texture, int target, int internalformat, int buffer, long offset, long size) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureBufferRangeEXT).invokeExact(texture, target, internalformat, buffer, offset, size); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureStorage1DEXT(int texture, int target, int levels, int internalformat, int width) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureStorage1DEXT).invokeExact(texture, target, levels, internalformat, width); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureStorage2DEXT(int texture, int target, int levels, int internalformat, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureStorage2DEXT).invokeExact(texture, target, levels, internalformat, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureStorage3DEXT(int texture, int target, int levels, int internalformat, int width, int height, int depth) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureStorage3DEXT).invokeExact(texture, target, levels, internalformat, width, height, depth); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureStorage2DMultisampleEXT(int texture, int target, int samples, int internalformat, int width, int height, boolean fixedsamplelocations) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureStorage2DMultisampleEXT).invokeExact(texture, target, samples, internalformat, width, height, fixedsamplelocations); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureStorage3DMultisampleEXT(int texture, int target, int samples, int internalformat, int width, int height, int depth, boolean fixedsamplelocations) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureStorage3DMultisampleEXT).invokeExact(texture, target, samples, internalformat, width, height, depth, fixedsamplelocations); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayBindVertexBufferEXT(int vaobj, int bindingindex, int buffer, long offset, int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayBindVertexBufferEXT).invokeExact(vaobj, bindingindex, buffer, offset, stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayVertexAttribFormatEXT(int vaobj, int attribindex, int size, int type, boolean normalized, int relativeoffset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayVertexAttribFormatEXT).invokeExact(vaobj, attribindex, size, type, normalized, relativeoffset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayVertexAttribIFormatEXT(int vaobj, int attribindex, int size, int type, int relativeoffset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayVertexAttribIFormatEXT).invokeExact(vaobj, attribindex, size, type, relativeoffset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayVertexAttribLFormatEXT(int vaobj, int attribindex, int size, int type, int relativeoffset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayVertexAttribLFormatEXT).invokeExact(vaobj, attribindex, size, type, relativeoffset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayVertexAttribBindingEXT(int vaobj, int attribindex, int bindingindex) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayVertexAttribBindingEXT).invokeExact(vaobj, attribindex, bindingindex); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayVertexBindingDivisorEXT(int vaobj, int bindingindex, int divisor) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayVertexBindingDivisorEXT).invokeExact(vaobj, bindingindex, divisor); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayVertexAttribLOffsetEXT(int vaobj, int buffer, int index, int size, int type, int stride, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayVertexAttribLOffsetEXT).invokeExact(vaobj, buffer, index, size, type, stride, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTexturePageCommitmentEXT(int texture, int level, int xoffset, int yoffset, int zoffset, int width, int height, int depth, boolean commit) { + final var ext = getExtCapabilities(); + try { + check(ext.glTexturePageCommitmentEXT).invokeExact(texture, level, xoffset, yoffset, zoffset, width, height, depth, commit); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayVertexAttribDivisorEXT(int vaobj, int index, int divisor) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayVertexAttribDivisorEXT).invokeExact(vaobj, index, divisor); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawBuffers2.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawBuffers2.java new file mode 100644 index 00000000..459b550c --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawBuffers2.java @@ -0,0 +1,43 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_draw_buffers2} + */ +public final class GLEXTDrawBuffers2 { + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_draw_buffers2) return; + ext.glColorMaskIndexedEXT = load.invoke("glColorMaskIndexedEXT", ofVoid(JAVA_INT, JAVA_BYTE, JAVA_BYTE, JAVA_BYTE, JAVA_BYTE)); + } + + public static void glColorMaskIndexedEXT(int index, boolean r, boolean g, boolean b, boolean a) { + final var ext = getExtCapabilities(); + try { + check(ext.glColorMaskIndexedEXT).invokeExact(index, r, g, b, a); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawInstanced.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawInstanced.java new file mode 100644 index 00000000..ad79bd07 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawInstanced.java @@ -0,0 +1,51 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_draw_instanced} + */ +public final class GLEXTDrawInstanced { + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_draw_instanced) return; + ext.glDrawArraysInstancedEXT = load.invoke("glDrawArraysInstancedEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glDrawElementsInstancedEXT = load.invoke("glDrawElementsInstancedEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS, JAVA_INT)); + } + + public static void glDrawArraysInstancedEXT(int mode, int start, int count, int primcount) { + final var ext = getExtCapabilities(); + try { + check(ext.glDrawArraysInstancedEXT).invokeExact(mode, start, count, primcount); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glDrawElementsInstancedEXT(int mode, int count, int type, @NativeType("const void *") MemorySegment indices, int primcount) { + final var ext = getExtCapabilities(); + try { + check(ext.glDrawElementsInstancedEXT).invokeExact(mode, count, type, indices, primcount); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawRangedElements.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawRangedElements.java new file mode 100644 index 00000000..b56c77fb --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTDrawRangedElements.java @@ -0,0 +1,45 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_draw_range_elements} + */ +public final class GLEXTDrawRangedElements { + public static final int GL_MAX_ELEMENTS_VERTICES_EXT = 0x80E8; + public static final int GL_MAX_ELEMENTS_INDICES_EXT = 0x80E9; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_draw_range_elements) return; + ext.glDrawRangeElementsEXT = load.invoke("glDrawRangeElementsEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + } + + public static void glDrawRangeElementsEXT(int mode, int start, int end, int count, int type, @NativeType("const void *") MemorySegment indices) { + final var ext = getExtCapabilities(); + try { + check(ext.glDrawRangeElementsEXT).invokeExact(mode, start, end, count, type, indices); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTEGLImageStorage.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTEGLImageStorage.java new file mode 100644 index 00000000..5f0d9b54 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTEGLImageStorage.java @@ -0,0 +1,51 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_EGL_image_storage} + */ +public final class GLEXTEGLImageStorage { + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_EGL_image_storage) return; + ext.glEGLImageTargetTexStorageEXT = load.invoke("glEGLImageTargetTexStorageEXT", ofVoid(JAVA_INT, ADDRESS, ADDRESS)); + ext.glEGLImageTargetTextureStorageEXT = load.invoke("glEGLImageTargetTextureStorageEXT", ofVoid(JAVA_INT, ADDRESS, ADDRESS)); + } + + public static void glEGLImageTargetTexStorageEXT(int target, @NativeType("GLeglImageOES") MemorySegment image, @NativeType("const GLint*") MemorySegment attrib_list) { + final var ext = getExtCapabilities(); + try { + check(ext.glEGLImageTargetTexStorageEXT).invokeExact(target, image, attrib_list); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glEGLImageTargetTextureStorageEXT(int texture, @NativeType("GLeglImageOES") MemorySegment image, @NativeType("const GLint*") MemorySegment attrib_list) { + final var ext = getExtCapabilities(); + try { + check(ext.glEGLImageTargetTextureStorageEXT).invokeExact(texture, image, attrib_list); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTExternalBuffer.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTExternalBuffer.java new file mode 100644 index 00000000..99d76dc8 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTExternalBuffer.java @@ -0,0 +1,51 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_external_buffer} + */ +public final class GLEXTExternalBuffer { + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_external_buffer) return; + ext.glBufferStorageExternalEXT = load.invoke("glBufferStorageExternalEXT", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG, ADDRESS, JAVA_INT)); + ext.glNamedBufferStorageExternalEXT = load.invoke("glNamedBufferStorageExternalEXT", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG, ADDRESS, JAVA_INT)); + } + + public static void glBufferStorageExternalEXT(int target, long offset, long size, @NativeType("GLeglClientBufferEXT") MemorySegment clientBuffer, int flags) { + final var ext = getExtCapabilities(); + try { + check(ext.glBufferStorageExternalEXT).invokeExact(target, offset, size, clientBuffer, flags); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNamedBufferStorageExternalEXT(int buffer, long offset, long size, @NativeType("GLeglClientBufferEXT") MemorySegment clientBuffer, int flags) { + final var ext = getExtCapabilities(); + try { + check(ext.glNamedBufferStorageExternalEXT).invokeExact(buffer, offset, size, clientBuffer, flags); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFogCoord.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFogCoord.java new file mode 100644 index 00000000..504a14d3 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFogCoord.java @@ -0,0 +1,83 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_fog_coord} + */ +public final class GLEXTFogCoord { + public static final int GL_FOG_COORDINATE_SOURCE_EXT = 0x8450; + public static final int GL_FOG_COORDINATE_EXT = 0x8451; + public static final int GL_FRAGMENT_DEPTH_EXT = 0x8452; + public static final int GL_CURRENT_FOG_COORDINATE_EXT = 0x8453; + public static final int GL_FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454; + public static final int GL_FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455; + public static final int GL_FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456; + public static final int GL_FOG_COORDINATE_ARRAY_EXT = 0x8457; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_fog_coord) return; + ext.glFogCoordfEXT = load.invoke("glFogCoordfEXT", ofVoid(JAVA_FLOAT)); + ext.glFogCoordfvEXT = load.invoke("glFogCoordfvEXT", ofVoid(ADDRESS)); + ext.glFogCoorddEXT = load.invoke("glFogCoorddEXT", ofVoid(JAVA_DOUBLE)); + ext.glFogCoorddvEXT = load.invoke("glFogCoorddvEXT", ofVoid(ADDRESS)); + ext.glFogCoordPointerEXT = load.invoke("glFogCoordPointerEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + } + + public static void glFogCoordfEXT(float coord) { + final var ext = getExtCapabilities(); + try { + check(ext.glFogCoordfEXT).invokeExact(coord); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFogCoordfvEXT(@NativeType("const GLfloat *") MemorySegment coord) { + final var ext = getExtCapabilities(); + try { + check(ext.glFogCoordfvEXT).invokeExact(coord); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFogCoorddEXT(double coord) { + final var ext = getExtCapabilities(); + try { + check(ext.glFogCoorddEXT).invokeExact(coord); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFogCoorddvEXT(@NativeType("const GLdouble *") MemorySegment coord) { + final var ext = getExtCapabilities(); + try { + check(ext.glFogCoorddvEXT).invokeExact(coord); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFogCoordPointerEXT(int type, int stride, @NativeType("const void *") MemorySegment pointer) { + final var ext = getExtCapabilities(); + try { + check(ext.glFogCoordPointerEXT).invokeExact(type, stride, pointer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferBlit.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferBlit.java new file mode 100644 index 00000000..44ff831f --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferBlit.java @@ -0,0 +1,47 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_framebuffer_blit} + */ +public final class GLEXTFramebufferBlit { + public static final int GL_READ_FRAMEBUFFER_EXT = 0x8CA8; + public static final int GL_DRAW_FRAMEBUFFER_EXT = 0x8CA9; + public static final int GL_DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CA6; + public static final int GL_READ_FRAMEBUFFER_BINDING_EXT = 0x8CAA; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_framebuffer_blit) return; + ext.glBlitFramebufferEXT = load.invoke("glBlitFramebufferEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + } + + public static void glBlitFramebufferEXT(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, int mask, int filter) { + final var ext = getExtCapabilities(); + try { + check(ext.glBlitFramebufferEXT).invokeExact(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferBlitLayers.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferBlitLayers.java new file mode 100644 index 00000000..583ad66f --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferBlitLayers.java @@ -0,0 +1,51 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_framebuffer_blit_layers} + */ +public final class GLEXTFramebufferBlitLayers { + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_framebuffer_blit_layers) return; + ext.glBlitFramebufferLayersEXT = load.invoke("glBlitFramebufferLayersEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glBlitFramebufferLayerEXT = load.invoke("glBlitFramebufferLayerEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + } + + public static void glBlitFramebufferLayersEXT(int srcX0, int srcY0, int srcX1, int srcY1, int dstX0, int dstY0, int dstX1, int dstY1, int mask, int filter) { + final var ext = getExtCapabilities(); + try { + check(ext.glBlitFramebufferLayersEXT).invokeExact(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBlitFramebufferLayerEXT(int srcX0, int srcY0, int srcX1, int srcY1, int srcLayer, int dstX0, int dstY0, int dstX1, int dstY1, int dstLayer, int mask, int filter) { + final var ext = getExtCapabilities(); + try { + check(ext.glBlitFramebufferLayerEXT).invokeExact(srcX0, srcY0, srcX1, srcY1, srcLayer, dstX0, dstY0, dstX1, dstY1, dstLayer, mask, filter); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferMultisample.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferMultisample.java new file mode 100644 index 00000000..c444ff59 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferMultisample.java @@ -0,0 +1,46 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_framebuffer_multisample} + */ +public final class GLEXTFramebufferMultisample { + public static final int GL_RENDERBUFFER_SAMPLES_EXT = 0x8CAB; + public static final int GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 0x8D56; + public static final int GL_MAX_SAMPLES_EXT = 0x8D57; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_framebuffer_multisample) return; + ext.glRenderbufferStorageMultisampleEXT = load.invoke("glRenderbufferStorageMultisampleEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + } + + public static void glRenderbufferStorageMultisampleEXT(int target, int samples, int internalformat, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glRenderbufferStorageMultisampleEXT).invokeExact(target, samples, internalformat, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferMultisampleBlitScaled.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferMultisampleBlitScaled.java new file mode 100644 index 00000000..8f1ee6c1 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferMultisampleBlitScaled.java @@ -0,0 +1,33 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_framebuffer_multisample_blit_scaled} + */ +public final class GLEXTFramebufferMultisampleBlitScaled { + public static final int GL_SCALED_RESOLVE_FASTEST_EXT = 0x90BA; + public static final int GL_SCALED_RESOLVE_NICEST_EXT = 0x90BB; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferObject.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferObject.java new file mode 100644 index 00000000..ec1c2705 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTFramebufferObject.java @@ -0,0 +1,225 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_framebuffer_object} + */ +public final class GLEXTFramebufferObject { + public static final int GL_INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506; + public static final int GL_MAX_RENDERBUFFER_SIZE_EXT = 0x84E8; + public static final int GL_FRAMEBUFFER_BINDING_EXT = 0x8CA6; + public static final int GL_RENDERBUFFER_BINDING_EXT = 0x8CA7; + public static final int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0; + public static final int GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1; + public static final int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2; + public static final int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3; + public static final int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4; + public static final int GL_FRAMEBUFFER_COMPLETE_EXT = 0x8CD5; + public static final int GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6; + public static final int GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7; + public static final int GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9; + public static final int GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA; + public static final int GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB; + public static final int GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC; + public static final int GL_FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD; + public static final int GL_MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF; + public static final int GL_COLOR_ATTACHMENT0_EXT = 0x8CE0; + public static final int GL_COLOR_ATTACHMENT1_EXT = 0x8CE1; + public static final int GL_COLOR_ATTACHMENT2_EXT = 0x8CE2; + public static final int GL_COLOR_ATTACHMENT3_EXT = 0x8CE3; + public static final int GL_COLOR_ATTACHMENT4_EXT = 0x8CE4; + public static final int GL_COLOR_ATTACHMENT5_EXT = 0x8CE5; + public static final int GL_COLOR_ATTACHMENT6_EXT = 0x8CE6; + public static final int GL_COLOR_ATTACHMENT7_EXT = 0x8CE7; + public static final int GL_COLOR_ATTACHMENT8_EXT = 0x8CE8; + public static final int GL_COLOR_ATTACHMENT9_EXT = 0x8CE9; + public static final int GL_COLOR_ATTACHMENT10_EXT = 0x8CEA; + public static final int GL_COLOR_ATTACHMENT11_EXT = 0x8CEB; + public static final int GL_COLOR_ATTACHMENT12_EXT = 0x8CEC; + public static final int GL_COLOR_ATTACHMENT13_EXT = 0x8CED; + public static final int GL_COLOR_ATTACHMENT14_EXT = 0x8CEE; + public static final int GL_COLOR_ATTACHMENT15_EXT = 0x8CEF; + public static final int GL_DEPTH_ATTACHMENT_EXT = 0x8D00; + public static final int GL_STENCIL_ATTACHMENT_EXT = 0x8D20; + public static final int GL_FRAMEBUFFER_EXT = 0x8D40; + public static final int GL_RENDERBUFFER_EXT = 0x8D41; + public static final int GL_RENDERBUFFER_WIDTH_EXT = 0x8D42; + public static final int GL_RENDERBUFFER_HEIGHT_EXT = 0x8D43; + public static final int GL_RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44; + public static final int GL_STENCIL_INDEX1_EXT = 0x8D46; + public static final int GL_STENCIL_INDEX4_EXT = 0x8D47; + public static final int GL_STENCIL_INDEX8_EXT = 0x8D48; + public static final int GL_STENCIL_INDEX16_EXT = 0x8D49; + public static final int GL_RENDERBUFFER_RED_SIZE_EXT = 0x8D50; + public static final int GL_RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51; + public static final int GL_RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52; + public static final int GL_RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53; + public static final int GL_RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54; + public static final int GL_RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_EXT_framebuffer_object) return; + ext.glIsRenderbufferEXT = load.invoke("glIsRenderbufferEXT", of(JAVA_BYTE, JAVA_INT)); + ext.glBindRenderbufferEXT = load.invoke("glBindRenderbufferEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glDeleteRenderbuffersEXT = load.invoke("glDeleteRenderbuffersEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glGenRenderbuffersEXT = load.invoke("glGenRenderbuffersEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glRenderbufferStorageEXT = load.invoke("glRenderbufferStorageEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glGetRenderbufferParameterivEXT = load.invoke("glGetRenderbufferParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glIsFramebufferEXT = load.invoke("glIsFramebufferEXT", of(JAVA_BYTE, JAVA_INT)); + ext.glBindFramebufferEXT = load.invoke("glBindFramebufferEXT", ofVoid(JAVA_INT, JAVA_INT)); + ext.glDeleteFramebuffersEXT = load.invoke("glDeleteFramebuffersEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glGenFramebuffersEXT = load.invoke("glGenFramebuffersEXT", ofVoid(JAVA_INT, ADDRESS)); + ext.glCheckFramebufferStatusEXT = load.invoke("glCheckFramebufferStatusEXT", of(JAVA_INT, JAVA_INT)); + ext.glFramebufferTexture1DEXT = load.invoke("glFramebufferTexture1DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glFramebufferTexture2DEXT = load.invoke("glFramebufferTexture2DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glFramebufferTexture3DEXT = load.invoke("glFramebufferTexture3DEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glFramebufferRenderbufferEXT = load.invoke("glFramebufferRenderbufferEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glGetFramebufferAttachmentParameterivEXT = load.invoke("glGetFramebufferAttachmentParameterivEXT", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGenerateMipmapEXT = load.invoke("glGenerateMipmapEXT", ofVoid(JAVA_INT)); + } + + public static boolean glIsRenderbufferEXT(int renderbuffer) { + final var ext = getExtCapabilities(); + try { + return (boolean) + check(ext.glIsRenderbufferEXT).invokeExact(renderbuffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBindRenderbufferEXT(int target, int renderbuffer) { + final var ext = getExtCapabilities(); + try { + check(ext.glBindRenderbufferEXT).invokeExact(target, renderbuffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glDeleteRenderbuffersEXT(int n, @NativeType("const GLuint *") MemorySegment renderbuffers) { + final var ext = getExtCapabilities(); + try { + check(ext.glDeleteRenderbuffersEXT).invokeExact(n, renderbuffers); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGenRenderbuffersEXT(int n, @NativeType("GLuint *") MemorySegment renderbuffers) { + final var ext = getExtCapabilities(); + try { + check(ext.glGenRenderbuffersEXT).invokeExact(n, renderbuffers); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glRenderbufferStorageEXT(int target, int internalformat, int width, int height) { + final var ext = getExtCapabilities(); + try { + check(ext.glRenderbufferStorageEXT).invokeExact(target, internalformat, width, height); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetRenderbufferParameterivEXT(int target, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetRenderbufferParameterivEXT).invokeExact(target, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static boolean glIsFramebufferEXT(int framebuffer) { + final var ext = getExtCapabilities(); + try { + return (boolean) + check(ext.glIsFramebufferEXT).invokeExact(framebuffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBindFramebufferEXT(int target, int framebuffer) { + final var ext = getExtCapabilities(); + try { + check(ext.glBindFramebufferEXT).invokeExact(target, framebuffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glDeleteFramebuffersEXT(int n, @NativeType("const GLuint *") MemorySegment framebuffers) { + final var ext = getExtCapabilities(); + try { + check(ext.glDeleteFramebuffersEXT).invokeExact(n, framebuffers); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGenFramebuffersEXT(int n, @NativeType("GLuint *") MemorySegment framebuffers) { + final var ext = getExtCapabilities(); + try { + check(ext.glGenFramebuffersEXT).invokeExact(n, framebuffers); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static int glCheckFramebufferStatusEXT(int target) { + final var ext = getExtCapabilities(); + try { + return (int) + check(ext.glCheckFramebufferStatusEXT).invokeExact(target); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFramebufferTexture1DEXT(int target, int attachment, int textarget, int texture, int level) { + final var ext = getExtCapabilities(); + try { + check(ext.glFramebufferTexture1DEXT).invokeExact(target, attachment, textarget, texture, level); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFramebufferTexture2DEXT(int target, int attachment, int textarget, int texture, int level) { + final var ext = getExtCapabilities(); + try { + check(ext.glFramebufferTexture2DEXT).invokeExact(target, attachment, textarget, texture, level); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFramebufferTexture3DEXT(int target, int attachment, int textarget, int texture, int level, int zoffset) { + final var ext = getExtCapabilities(); + try { + check(ext.glFramebufferTexture3DEXT).invokeExact(target, attachment, textarget, texture, level, zoffset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFramebufferRenderbufferEXT(int target, int attachment, int renderbuffertarget, int renderbuffer) { + final var ext = getExtCapabilities(); + try { + check(ext.glFramebufferRenderbufferEXT).invokeExact(target, attachment, renderbuffertarget, renderbuffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetFramebufferAttachmentParameterivEXT(int target, int attachment, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetFramebufferAttachmentParameterivEXT).invokeExact(target, attachment, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGenerateMipmapEXT(int target) { + final var ext = getExtCapabilities(); + try { + check(ext.glGenerateMipmapEXT).invokeExact(target); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTSrgb.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTSrgb.java new file mode 100644 index 00000000..496cdbd6 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/ext/GLEXTSrgb.java @@ -0,0 +1,33 @@ +/* + * MIT License + * + * Copyright (c) 2022-present Overrun Organization + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + */ + +// This file is auto-generated. DO NOT EDIT! +package overrungl.opengl.ext.ext; + +import overrungl.*; +import overrungl.opengl.*; +import java.lang.foreign.*; +import static java.lang.foreign.FunctionDescriptor.*; +import static java.lang.foreign.ValueLayout.*; +import static overrungl.opengl.GLLoader.*; + +/** + * {@code GL_EXT_framebuffer_sRGB} + */ +public final class GLEXTSrgb { + public static final int GL_FRAMEBUFFER_SRGB_EXT = 0x8DB9; + public static final int GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8DBA; +}