From f927dbdcee9c53494c6bf3bdf82b3449e4ddb0c8 Mon Sep 17 00:00:00 2001 From: squid233 <60126026+squid233@users.noreply.github.com> Date: Sat, 2 Dec 2023 10:01:44 +0800 Subject: [PATCH] Update extensions --- build.gradle.kts | 3 +- gradle.properties | 1 + modules/overrungl.opengl/build.gradle.kts | 3 +- .../generator/kotlin/overrungl/opengl/GLNV.kt | 688 ++++++++++++++++++ .../overrungl/opengl/OpenGLGenerator.kt | 1 + .../main/java/overrungl/opengl/GLExtCaps.java | 41 +- .../main/java/overrungl/opengl/GLLoader.java | 14 +- .../opengl/ext/nv/GLNVTextureEnvCombine4.java | 36 + .../ext/nv/GLNVTextureExpandNormal.java | 32 + .../opengl/ext/nv/GLNVTextureMultisample.java | 85 +++ .../opengl/ext/nv/GLNVTextureRectangle.java | 35 + .../opengl/ext/nv/GLNVTextureShader.java | 104 +++ .../opengl/ext/nv/GLNVTextureShader2.java | 32 + .../opengl/ext/nv/GLNVTextureShader3.java | 48 ++ .../opengl/ext/nv/GLNVTimelineSemaphore.java | 64 ++ .../opengl/ext/nv/GLNVTransformFeedback.java | 163 +++++ .../opengl/ext/nv/GLNVTransformFeedback2.java | 96 +++ .../nv/GLNVUniformBufferUnifiedMemory.java | 34 + .../opengl/ext/nv/GLNVVDPAUInterop.java | 122 ++++ .../opengl/ext/nv/GLNVVDPAUInterop2.java | 44 ++ .../opengl/ext/nv/GLNVVertexArrayRange.java | 56 ++ .../opengl/ext/nv/GLNVVertexArrayRange2.java | 32 + .../ext/nv/GLNVVertexAttribInteger64bit.java | 187 +++++ .../ext/nv/GLNVVertexBufferUnifiedMemory.java | 156 ++++ .../opengl/ext/nv/GLNVVertexProgram.java | 632 ++++++++++++++++ .../opengl/ext/nv/GLNVVertexProgram4.java | 32 + .../opengl/ext/nv/GLNVVideoCapture.java | 161 ++++ .../opengl/ext/nv/GLNVViewportSwizzle.java | 55 ++ 28 files changed, 2944 insertions(+), 13 deletions(-) create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureEnvCombine4.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureExpandNormal.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureMultisample.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureRectangle.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader2.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader3.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTimelineSemaphore.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTransformFeedback.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTransformFeedback2.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVUniformBufferUnifiedMemory.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVDPAUInterop.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVDPAUInterop2.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexArrayRange.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexArrayRange2.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexAttribInteger64bit.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexBufferUnifiedMemory.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexProgram.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexProgram4.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVideoCapture.java create mode 100644 modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVViewportSwizzle.java diff --git a/build.gradle.kts b/build.gradle.kts index 8122b7e3..f6afbbbe 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -24,6 +24,7 @@ val developers: String by project val jdkVersion: String by rootProject val jdkEnablePreview: String by rootProject val jdkEarlyAccessDoc: String? by rootProject +val kotlinTargetJdkVersion: String by rootProject val targetJavaVersion = jdkVersion.toInt() @@ -155,7 +156,7 @@ subprojects { } tasks.withType { - kotlinOptions { jvmTarget = "20" } + kotlinOptions { jvmTarget = kotlinTargetJdkVersion } } tasks.withType { diff --git a/gradle.properties b/gradle.properties index 9ff50500..480434e8 100644 --- a/gradle.properties +++ b/gradle.properties @@ -15,5 +15,6 @@ orgUrl=https://over-run.github.io/ jdkVersion=21 jdkEnablePreview=true #jdkEarlyAccessDoc=jdk22 +kotlinTargetJdkVersion=21 projModules=core, glfw, nfd, joml, opengl, stb diff --git a/modules/overrungl.opengl/build.gradle.kts b/modules/overrungl.opengl/build.gradle.kts index b65b0a4a..e57ac47c 100644 --- a/modules/overrungl.opengl/build.gradle.kts +++ b/modules/overrungl.opengl/build.gradle.kts @@ -1,5 +1,6 @@ val jdkVersion: String by rootProject val jdkEnablePreview: String by rootProject +val kotlinTargetJdkVersion: String by rootProject sourceSets { create("generator") @@ -7,7 +8,7 @@ sourceSets { tasks.named("compileGeneratorJava") { javaCompiler.set(javaToolchains.compilerFor { - targetCompatibility = "20" + targetCompatibility = kotlinTargetJdkVersion languageVersion.set(JavaLanguageVersion.of(jdkVersion)) }) } diff --git a/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/GLNV.kt b/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/GLNV.kt index c3938ce8..7b7e5441 100644 --- a/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/GLNV.kt +++ b/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/GLNV.kt @@ -1966,4 +1966,692 @@ fun nv() { file("TextureBarrier", NV, "GL_NV_texture_barrier") { "glTextureBarrierNV"(void) } + file( + "TextureEnvCombine4", NV, "GL_NV_texture_env_combine4", + "GL_COMBINE4_NV" to "0x8503", + "GL_SOURCE3_RGB_NV" to "0x8583", + "GL_SOURCE3_ALPHA_NV" to "0x858B", + "GL_OPERAND3_RGB_NV" to "0x8593", + "GL_OPERAND3_ALPHA_NV" to "0x859B" + ) + file("TextureExpandNormal", NV, "GL_NV_texture_expand_normal", "GL_TEXTURE_UNSIGNED_REMAP_MODE_NV" to "0x888F") + file("TextureMultisample", NV, "GL_NV_texture_multisample") { + "GL_TEXTURE_COVERAGE_SAMPLES_NV" ("0x9045") + "GL_TEXTURE_COLOR_SAMPLES_NV" ("0x9046") + "glTexImage2DMultisampleCoverageNV" (void, GLenum ("target"), GLsizei ("coverageSamples"), GLsizei ("colorSamples"), GLint ("internalFormat"), GLsizei ("width"), GLsizei ("height"), GLboolean ("fixedSampleLocations")) + "glTexImage3DMultisampleCoverageNV" (void, GLenum ("target"), GLsizei ("coverageSamples"), GLsizei ("colorSamples"), GLint ("internalFormat"), GLsizei ("width"), GLsizei ("height"), GLsizei ("depth"), GLboolean ("fixedSampleLocations")) + "glTextureImage2DMultisampleNV" (void, GLuint ("texture"), GLenum ("target"), GLsizei ("samples"), GLint ("internalFormat"), GLsizei ("width"), GLsizei ("height"), GLboolean ("fixedSampleLocations")) + "glTextureImage3DMultisampleNV" (void, GLuint ("texture"), GLenum ("target"), GLsizei ("samples"), GLint ("internalFormat"), GLsizei ("width"), GLsizei ("height"), GLsizei ("depth"), GLboolean ("fixedSampleLocations")) + "glTextureImage2DMultisampleCoverageNV" (void, GLuint ("texture"), GLenum ("target"), GLsizei ("coverageSamples"), GLsizei ("colorSamples"), GLint ("internalFormat"), GLsizei ("width"), GLsizei ("height"), GLboolean ("fixedSampleLocations")) + "glTextureImage3DMultisampleCoverageNV" (void, GLuint ("texture"), GLenum ("target"), GLsizei ("coverageSamples"), GLsizei ("colorSamples"), GLint ("internalFormat"), GLsizei ("width"), GLsizei ("height"), GLsizei ("depth"), GLboolean ("fixedSampleLocations")) + } + file( + "TextureRectangle", NV, "GL_NV_texture_rectangle", + "GL_TEXTURE_RECTANGLE_NV" to "0x84F5", + "GL_TEXTURE_BINDING_RECTANGLE_NV" to "0x84F6", + "GL_PROXY_TEXTURE_RECTANGLE_NV" to "0x84F7", + "GL_MAX_RECTANGLE_TEXTURE_SIZE_NV" to "0x84F8" + ) + file( + "TextureShader", NV, "GL_NV_texture_shader", + "GL_OFFSET_TEXTURE_RECTANGLE_NV" to "0x864C", + "GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV" to "0x864D", + "GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV" to "0x864E", + "GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV" to "0x86D9", + "GL_UNSIGNED_INT_S8_S8_8_8_NV" to "0x86DA", + "GL_UNSIGNED_INT_8_8_S8_S8_REV_NV" to "0x86DB", + "GL_DSDT_MAG_INTENSITY_NV" to "0x86DC", + "GL_SHADER_CONSISTENT_NV" to "0x86DD", + "GL_TEXTURE_SHADER_NV" to "0x86DE", + "GL_SHADER_OPERATION_NV" to "0x86DF", + "GL_CULL_MODES_NV" to "0x86E0", + "GL_OFFSET_TEXTURE_MATRIX_NV" to "0x86E1", + "GL_OFFSET_TEXTURE_SCALE_NV" to "0x86E2", + "GL_OFFSET_TEXTURE_BIAS_NV" to "0x86E3", + "GL_OFFSET_TEXTURE_2D_MATRIX_NV" to "0x86E1", + "GL_OFFSET_TEXTURE_2D_SCALE_NV" to "0x86E2", + "GL_OFFSET_TEXTURE_2D_BIAS_NV" to "0x86E3", + "GL_PREVIOUS_TEXTURE_INPUT_NV" to "0x86E4", + "GL_CONST_EYE_NV" to "0x86E5", + "GL_PASS_THROUGH_NV" to "0x86E6", + "GL_CULL_FRAGMENT_NV" to "0x86E7", + "GL_OFFSET_TEXTURE_2D_NV" to "0x86E8", + "GL_DEPENDENT_AR_TEXTURE_2D_NV" to "0x86E9", + "GL_DEPENDENT_GB_TEXTURE_2D_NV" to "0x86EA", + "GL_DOT_PRODUCT_NV" to "0x86EC", + "GL_DOT_PRODUCT_DEPTH_REPLACE_NV" to "0x86ED", + "GL_DOT_PRODUCT_TEXTURE_2D_NV" to "0x86EE", + "GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV" to "0x86F0", + "GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV" to "0x86F1", + "GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV" to "0x86F2", + "GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV" to "0x86F3", + "GL_HILO_NV" to "0x86F4", + "GL_DSDT_NV" to "0x86F5", + "GL_DSDT_MAG_NV" to "0x86F6", + "GL_DSDT_MAG_VIB_NV" to "0x86F7", + "GL_HILO16_NV" to "0x86F8", + "GL_SIGNED_HILO_NV" to "0x86F9", + "GL_SIGNED_HILO16_NV" to "0x86FA", + "GL_SIGNED_RGBA_NV" to "0x86FB", + "GL_SIGNED_RGBA8_NV" to "0x86FC", + "GL_SIGNED_RGB_NV" to "0x86FE", + "GL_SIGNED_RGB8_NV" to "0x86FF", + "GL_SIGNED_LUMINANCE_NV" to "0x8701", + "GL_SIGNED_LUMINANCE8_NV" to "0x8702", + "GL_SIGNED_LUMINANCE_ALPHA_NV" to "0x8703", + "GL_SIGNED_LUMINANCE8_ALPHA8_NV" to "0x8704", + "GL_SIGNED_ALPHA_NV" to "0x8705", + "GL_SIGNED_ALPHA8_NV" to "0x8706", + "GL_SIGNED_INTENSITY_NV" to "0x8707", + "GL_SIGNED_INTENSITY8_NV" to "0x8708", + "GL_DSDT8_NV" to "0x8709", + "GL_DSDT8_MAG8_NV" to "0x870A", + "GL_DSDT8_MAG8_INTENSITY8_NV" to "0x870B", + "GL_SIGNED_RGB_UNSIGNED_ALPHA_NV" to "0x870C", + "GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV" to "0x870D", + "GL_HI_SCALE_NV" to "0x870E", + "GL_LO_SCALE_NV" to "0x870F", + "GL_DS_SCALE_NV" to "0x8710", + "GL_DT_SCALE_NV" to "0x8711", + "GL_MAGNITUDE_SCALE_NV" to "0x8712", + "GL_VIBRANCE_SCALE_NV" to "0x8713", + "GL_HI_BIAS_NV" to "0x8714", + "GL_LO_BIAS_NV" to "0x8715", + "GL_DS_BIAS_NV" to "0x8716", + "GL_DT_BIAS_NV" to "0x8717", + "GL_MAGNITUDE_BIAS_NV" to "0x8718", + "GL_VIBRANCE_BIAS_NV" to "0x8719", + "GL_TEXTURE_BORDER_VALUES_NV" to "0x871A", + "GL_TEXTURE_HI_SIZE_NV" to "0x871B", + "GL_TEXTURE_LO_SIZE_NV" to "0x871C", + "GL_TEXTURE_DS_SIZE_NV" to "0x871D", + "GL_TEXTURE_DT_SIZE_NV" to "0x871E", + "GL_TEXTURE_MAG_SIZE_NV" to "0x871F" + ) + file("TextureShader2", NV, "GL_NV_texture_shader2", "GL_DOT_PRODUCT_TEXTURE_3D_NV" to "0x86EF") + file( + "TextureShader3", NV, "GL_NV_texture_shader3", + "GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV" to "0x8850", + "GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV" to "0x8851", + "GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV" to "0x8852", + "GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV" to "0x8853", + "GL_OFFSET_HILO_TEXTURE_2D_NV" to "0x8854", + "GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV" to "0x8855", + "GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV" to "0x8856", + "GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV" to "0x8857", + "GL_DEPENDENT_HILO_TEXTURE_2D_NV" to "0x8858", + "GL_DEPENDENT_RGB_TEXTURE_3D_NV" to "0x8859", + "GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV" to "0x885A", + "GL_DOT_PRODUCT_PASS_THROUGH_NV" to "0x885B", + "GL_DOT_PRODUCT_TEXTURE_1D_NV" to "0x885C", + "GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV" to "0x885D", + "GL_HILO8_NV" to "0x885E", + "GL_SIGNED_HILO8_NV" to "0x885F", + "GL_FORCE_BLUE_TO_ONE_NV" to "0x8860" + ) + file("TimelineSemaphore", NV, "GL_NV_timeline_semaphore") { + "GL_TIMELINE_SEMAPHORE_VALUE_NV"("0x9595") + "GL_SEMAPHORE_TYPE_NV"("0x95B3") + "GL_SEMAPHORE_TYPE_BINARY_NV"("0x95B4") + "GL_SEMAPHORE_TYPE_TIMELINE_NV"("0x95B5") + "GL_MAX_TIMELINE_SEMAPHORE_VALUE_DIFFERENCE_NV"("0x95B6") + "glCreateSemaphoresNV"(void, GLsizei("n"), address("semaphores", "GLuint *")) + "glSemaphoreParameterivNV"(void, GLuint("semaphore"), GLenum("pname"), address("params", "const GLint *")) + "glGetSemaphoreParameterivNV"(void, GLuint("semaphore"), GLenum("pname"), address("params", "GLint *")) + } + file("TransformFeedback", NV, "GL_NV_transform_feedback") { + "GL_BACK_PRIMARY_COLOR_NV"("0x8C77") + "GL_BACK_SECONDARY_COLOR_NV"("0x8C78") + "GL_TEXTURE_COORD_NV"("0x8C79") + "GL_CLIP_DISTANCE_NV"("0x8C7A") + "GL_VERTEX_ID_NV"("0x8C7B") + "GL_PRIMITIVE_ID_NV"("0x8C7C") + "GL_GENERIC_ATTRIB_NV"("0x8C7D") + "GL_TRANSFORM_FEEDBACK_ATTRIBS_NV"("0x8C7E") + "GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV"("0x8C7F") + "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV"("0x8C80") + "GL_ACTIVE_VARYINGS_NV"("0x8C81") + "GL_ACTIVE_VARYING_MAX_LENGTH_NV"("0x8C82") + "GL_TRANSFORM_FEEDBACK_VARYINGS_NV"("0x8C83") + "GL_TRANSFORM_FEEDBACK_BUFFER_START_NV"("0x8C84") + "GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV"("0x8C85") + "GL_TRANSFORM_FEEDBACK_RECORD_NV"("0x8C86") + "GL_PRIMITIVES_GENERATED_NV"("0x8C87") + "GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV"("0x8C88") + "GL_RASTERIZER_DISCARD_NV"("0x8C89") + "GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV"("0x8C8A") + "GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV"("0x8C8B") + "GL_INTERLEAVED_ATTRIBS_NV"("0x8C8C") + "GL_SEPARATE_ATTRIBS_NV"("0x8C8D") + "GL_TRANSFORM_FEEDBACK_BUFFER_NV"("0x8C8E") + "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV"("0x8C8F") + "GL_LAYER_NV"("0x8DAA") + "GL_NEXT_BUFFER_NV"("-2") + "GL_SKIP_COMPONENTS4_NV"("-3") + "GL_SKIP_COMPONENTS3_NV"("-4") + "GL_SKIP_COMPONENTS2_NV"("-5") + "GL_SKIP_COMPONENTS1_NV"("-6") + "glBeginTransformFeedbackNV"(void, GLenum("primitiveMode")) + "glEndTransformFeedbackNV"(void) + "glTransformFeedbackAttribsNV"( + void, + GLsizei("count"), + address("attribs", "const GLint *"), + GLenum("bufferMode") + ) + "glBindBufferRangeNV"( + void, + GLenum("target"), + GLuint("index"), + GLuint("buffer"), + GLintptr("offset"), + GLsizeiptr("size") + ) + "glBindBufferOffsetNV"(void, GLenum("target"), GLuint("index"), GLuint("buffer"), GLintptr("offset")) + "glBindBufferBaseNV"(void, GLenum("target"), GLuint("index"), GLuint("buffer")) + "glTransformFeedbackVaryingsNV"( + void, + GLuint("program"), + GLsizei("count"), + address("locations", "const GLint *"), + GLenum("bufferMode") + ) + "glActiveVaryingNV"(void, GLuint("program"), address("name", "const GLchar *")) + "glGetVaryingLocationNV"(GLint, GLuint("program"), address("name", "const GLchar *")) + "glGetActiveVaryingNV"( + void, + GLuint("program"), + GLuint("index"), + GLsizei("bufSize"), + address("length", "GLsizei *"), + address("size", "GLsizei *"), + address("type", "GLenum *"), + address("name", "GLchar *") + ) + "glGetTransformFeedbackVaryingNV"(void, GLuint("program"), GLuint("index"), address("location", "GLint *")) + "glTransformFeedbackStreamAttribsNV"( + void, + GLsizei("count"), + address("attribs", "const GLint *"), + GLsizei("nbuffers"), + address("bufstreams", "const GLint *"), + GLenum("bufferMode") + ) + } + file("TransformFeedback2", NV, "GL_NV_transform_feedback2") { + "GL_TRANSFORM_FEEDBACK_NV"("0x8E22") + "GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV"("0x8E23") + "GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV"("0x8E24") + "GL_TRANSFORM_FEEDBACK_BINDING_NV"("0x8E25") + "glBindTransformFeedbackNV"(void, GLenum("target"), GLuint("id")) + "glDeleteTransformFeedbacksNV"(void, GLsizei("n"), address("ids", "const GLuint *")) + "glGenTransformFeedbacksNV"(void, GLsizei("n"), address("ids", "GLuint *")) + "glIsTransformFeedbackNV"(GLboolean, GLuint("id")) + "glPauseTransformFeedbackNV"(void) + "glResumeTransformFeedbackNV"(void) + "glDrawTransformFeedbackNV"(void, GLenum("mode"), GLuint("id")) + } + file( + "UniformBufferUnifiedMemory", NV, "GL_NV_uniform_buffer_unified_memory", + "GL_UNIFORM_BUFFER_UNIFIED_NV" to "0x936E", + "GL_UNIFORM_BUFFER_ADDRESS_NV" to "0x936F", + "GL_UNIFORM_BUFFER_LENGTH_NV" to "0x9370" + ) + file("VDPAUInterop", NV, "GL_NV_vdpau_interop") { + "GL_SURFACE_STATE_NV"("0x86EB") + "GL_SURFACE_REGISTERED_NV"("0x86FD") + "GL_SURFACE_MAPPED_NV"("0x8700") + "GL_WRITE_DISCARD_NV"("0x88BE") + "glVDPAUInitNV"(void, address("vdpDevice", "const void *"), address("getProcAddress", "const void *")) + "glVDPAUFiniNV"(void) + "glVDPAURegisterVideoSurfaceNV"( + GLvdpauSurfaceNV, + address("vdpSurface", "const void *"), + GLenum("target"), + GLsizei("numTextureNames"), + address("textureNames", "const GLuint *") + ) + "glVDPAURegisterOutputSurfaceNV"( + GLvdpauSurfaceNV, + address("vdpSurface", "const void *"), + GLenum("target"), + GLsizei("numTextureNames"), + address("textureNames", "const GLuint *") + ) + "glVDPAUIsSurfaceNV"(GLboolean, GLvdpauSurfaceNV("surface")) + "glVDPAUUnregisterSurfaceNV"(void, GLvdpauSurfaceNV("surface")) + "glVDPAUGetSurfaceivNV"( + void, + GLvdpauSurfaceNV("surface"), + GLenum("pname"), + GLsizei("count"), + address("length", "GLsizei *"), + address("values", "GLint *") + ) + "glVDPAUSurfaceAccessNV"(void, GLvdpauSurfaceNV("surface"), GLenum("access")) + "glVDPAUMapSurfacesNV"(void, GLsizei("numSurfaces"), address("surfaces", "const GLvdpauSurfaceNV *")) + "glVDPAUUnmapSurfacesNV"(void, GLsizei("numSurface"), address("surfaces", "const GLvdpauSurfaceNV *")) + } + file("VDPAUInterop2", NV, "GL_NV_vdpau_interop2") { + "glVDPAURegisterVideoSurfaceWithPictureStructureNV"( + GLvdpauSurfaceNV, + address("vdpSurface", "const void *"), + GLenum("target"), + GLsizei("numTextureNames"), + address("textureNames", "const GLuint *"), + GLboolean("isFrameStructure") + ) + } + file("VertexArrayRange", NV, "GL_NV_vertex_array_range") { + "GL_VERTEX_ARRAY_RANGE_NV"("0x851D") + "GL_VERTEX_ARRAY_RANGE_LENGTH_NV"("0x851E") + "GL_VERTEX_ARRAY_RANGE_VALID_NV"("0x851F") + "GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV"("0x8520") + "GL_VERTEX_ARRAY_RANGE_POINTER_NV"("0x8521") + "glFlushVertexArrayRangeNV"(void) + "glVertexArrayRangeNV"(void, GLsizei("length"), address("pointer", "const void *")) + } + file("VertexArrayRange2", NV, "GL_NV_vertex_array_range2", "GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV" to "0x8533") + file("VertexAttribInteger64bit", NV, "GL_NV_vertex_attrib_integer_64bit") { + "glVertexAttribL1i64NV"(void, GLuint("index"), GLint64EXT("x")) + "glVertexAttribL2i64NV"(void, GLuint("index"), GLint64EXT("x"), GLint64EXT("y")) + "glVertexAttribL3i64NV"(void, GLuint("index"), GLint64EXT("x"), GLint64EXT("y"), GLint64EXT("z")) + "glVertexAttribL4i64NV"( + void, + GLuint("index"), + GLint64EXT("x"), + GLint64EXT("y"), + GLint64EXT("z"), + GLint64EXT("w") + ) + "glVertexAttribL1i64vNV"(void, GLuint("index"), address("v", "const GLint64EXT *")) + "glVertexAttribL2i64vNV"(void, GLuint("index"), address("v", "const GLint64EXT *")) + "glVertexAttribL3i64vNV"(void, GLuint("index"), address("v", "const GLint64EXT *")) + "glVertexAttribL4i64vNV"(void, GLuint("index"), address("v", "const GLint64EXT *")) + "glVertexAttribL1ui64NV"(void, GLuint("index"), GLuint64EXT("x")) + "glVertexAttribL2ui64NV"(void, GLuint("index"), GLuint64EXT("x"), GLuint64EXT("y")) + "glVertexAttribL3ui64NV"(void, GLuint("index"), GLuint64EXT("x"), GLuint64EXT("y"), GLuint64EXT("z")) + "glVertexAttribL4ui64NV"( + void, + GLuint("index"), + GLuint64EXT("x"), + GLuint64EXT("y"), + GLuint64EXT("z"), + GLuint64EXT("w") + ) + "glVertexAttribL1ui64vNV"(void, GLuint("index"), address("v", "const GLuint64EXT *")) + "glVertexAttribL2ui64vNV"(void, GLuint("index"), address("v", "const GLuint64EXT *")) + "glVertexAttribL3ui64vNV"(void, GLuint("index"), address("v", "const GLuint64EXT *")) + "glVertexAttribL4ui64vNV"(void, GLuint("index"), address("v", "const GLuint64EXT *")) + "glGetVertexAttribLi64vNV"(void, GLuint("index"), GLenum("pname"), address("params", "GLint64EXT *")) + "glGetVertexAttribLui64vNV"(void, GLuint("index"), GLenum("pname"), address("params", "GLuint64EXT *")) + "glVertexAttribLFormatNV"(void, GLuint("index"), GLint("size"), GLenum("type"), GLsizei("stride")) + } + file("VertexBufferUnifiedMemory", NV, "GL_NV_vertex_buffer_unified_memory") { + "GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV"("0x8F1E") + "GL_ELEMENT_ARRAY_UNIFIED_NV"("0x8F1F") + "GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV"("0x8F20") + "GL_VERTEX_ARRAY_ADDRESS_NV"("0x8F21") + "GL_NORMAL_ARRAY_ADDRESS_NV"("0x8F22") + "GL_COLOR_ARRAY_ADDRESS_NV"("0x8F23") + "GL_INDEX_ARRAY_ADDRESS_NV"("0x8F24") + "GL_TEXTURE_COORD_ARRAY_ADDRESS_NV"("0x8F25") + "GL_EDGE_FLAG_ARRAY_ADDRESS_NV"("0x8F26") + "GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV"("0x8F27") + "GL_FOG_COORD_ARRAY_ADDRESS_NV"("0x8F28") + "GL_ELEMENT_ARRAY_ADDRESS_NV"("0x8F29") + "GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV"("0x8F2A") + "GL_VERTEX_ARRAY_LENGTH_NV"("0x8F2B") + "GL_NORMAL_ARRAY_LENGTH_NV"("0x8F2C") + "GL_COLOR_ARRAY_LENGTH_NV"("0x8F2D") + "GL_INDEX_ARRAY_LENGTH_NV"("0x8F2E") + "GL_TEXTURE_COORD_ARRAY_LENGTH_NV"("0x8F2F") + "GL_EDGE_FLAG_ARRAY_LENGTH_NV"("0x8F30") + "GL_SECONDARY_COLOR_ARRAY_LENGTH_NV"("0x8F31") + "GL_FOG_COORD_ARRAY_LENGTH_NV"("0x8F32") + "GL_ELEMENT_ARRAY_LENGTH_NV"("0x8F33") + "GL_DRAW_INDIRECT_UNIFIED_NV"("0x8F40") + "GL_DRAW_INDIRECT_ADDRESS_NV"("0x8F41") + "GL_DRAW_INDIRECT_LENGTH_NV"("0x8F42") + "glBufferAddressRangeNV"(void, GLenum("pname"), GLuint("index"), GLuint64EXT("address"), GLsizeiptr("length")) + "glVertexFormatNV"(void, GLint("size"), GLenum("type"), GLsizei("stride")) + "glNormalFormatNV"(void, GLenum("type"), GLsizei("stride")) + "glColorFormatNV"(void, GLint("size"), GLenum("type"), GLsizei("stride")) + "glIndexFormatNV"(void, GLenum("type"), GLsizei("stride")) + "glTexCoordFormatNV"(void, GLint("size"), GLenum("type"), GLsizei("stride")) + "glEdgeFlagFormatNV"(void, GLsizei("stride")) + "glSecondaryColorFormatNV"(void, GLint("size"), GLenum("type"), GLsizei("stride")) + "glFogCoordFormatNV"(void, GLenum("type"), GLsizei("stride")) + "glVertexAttribFormatNV"( + void, + GLuint("index"), + GLint("size"), + GLenum("type"), + GLboolean("normalized"), + GLsizei("stride") + ) + "glVertexAttribIFormatNV"(void, GLuint("index"), GLint("size"), GLenum("type"), GLsizei("stride")) + "glGetIntegerui64i_vNV"(void, GLenum("value"), GLuint("index"), address("result", "GLuint64EXT *")) + } + file("VertexProgram", NV, "GL_NV_vertex_program") { + "GL_VERTEX_PROGRAM_NV"("0x8620") + "GL_VERTEX_STATE_PROGRAM_NV"("0x8621") + "GL_ATTRIB_ARRAY_SIZE_NV"("0x8623") + "GL_ATTRIB_ARRAY_STRIDE_NV"("0x8624") + "GL_ATTRIB_ARRAY_TYPE_NV"("0x8625") + "GL_CURRENT_ATTRIB_NV"("0x8626") + "GL_PROGRAM_LENGTH_NV"("0x8627") + "GL_PROGRAM_STRING_NV"("0x8628") + "GL_MODELVIEW_PROJECTION_NV"("0x8629") + "GL_IDENTITY_NV"("0x862A") + "GL_INVERSE_NV"("0x862B") + "GL_TRANSPOSE_NV"("0x862C") + "GL_INVERSE_TRANSPOSE_NV"("0x862D") + "GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV"("0x862E") + "GL_MAX_TRACK_MATRICES_NV"("0x862F") + "GL_MATRIX0_NV"("0x8630") + "GL_MATRIX1_NV"("0x8631") + "GL_MATRIX2_NV"("0x8632") + "GL_MATRIX3_NV"("0x8633") + "GL_MATRIX4_NV"("0x8634") + "GL_MATRIX5_NV"("0x8635") + "GL_MATRIX6_NV"("0x8636") + "GL_MATRIX7_NV"("0x8637") + "GL_CURRENT_MATRIX_STACK_DEPTH_NV"("0x8640") + "GL_CURRENT_MATRIX_NV"("0x8641") + "GL_VERTEX_PROGRAM_POINT_SIZE_NV"("0x8642") + "GL_VERTEX_PROGRAM_TWO_SIDE_NV"("0x8643") + "GL_PROGRAM_PARAMETER_NV"("0x8644") + "GL_ATTRIB_ARRAY_POINTER_NV"("0x8645") + "GL_PROGRAM_TARGET_NV"("0x8646") + "GL_PROGRAM_RESIDENT_NV"("0x8647") + "GL_TRACK_MATRIX_NV"("0x8648") + "GL_TRACK_MATRIX_TRANSFORM_NV"("0x8649") + "GL_VERTEX_PROGRAM_BINDING_NV"("0x864A") + "GL_PROGRAM_ERROR_POSITION_NV"("0x864B") + "GL_VERTEX_ATTRIB_ARRAY0_NV"("0x8650") + "GL_VERTEX_ATTRIB_ARRAY1_NV"("0x8651") + "GL_VERTEX_ATTRIB_ARRAY2_NV"("0x8652") + "GL_VERTEX_ATTRIB_ARRAY3_NV"("0x8653") + "GL_VERTEX_ATTRIB_ARRAY4_NV"("0x8654") + "GL_VERTEX_ATTRIB_ARRAY5_NV"("0x8655") + "GL_VERTEX_ATTRIB_ARRAY6_NV"("0x8656") + "GL_VERTEX_ATTRIB_ARRAY7_NV"("0x8657") + "GL_VERTEX_ATTRIB_ARRAY8_NV"("0x8658") + "GL_VERTEX_ATTRIB_ARRAY9_NV"("0x8659") + "GL_VERTEX_ATTRIB_ARRAY10_NV"("0x865A") + "GL_VERTEX_ATTRIB_ARRAY11_NV"("0x865B") + "GL_VERTEX_ATTRIB_ARRAY12_NV"("0x865C") + "GL_VERTEX_ATTRIB_ARRAY13_NV"("0x865D") + "GL_VERTEX_ATTRIB_ARRAY14_NV"("0x865E") + "GL_VERTEX_ATTRIB_ARRAY15_NV"("0x865F") + "GL_MAP1_VERTEX_ATTRIB0_4_NV"("0x8660") + "GL_MAP1_VERTEX_ATTRIB1_4_NV"("0x8661") + "GL_MAP1_VERTEX_ATTRIB2_4_NV"("0x8662") + "GL_MAP1_VERTEX_ATTRIB3_4_NV"("0x8663") + "GL_MAP1_VERTEX_ATTRIB4_4_NV"("0x8664") + "GL_MAP1_VERTEX_ATTRIB5_4_NV"("0x8665") + "GL_MAP1_VERTEX_ATTRIB6_4_NV"("0x8666") + "GL_MAP1_VERTEX_ATTRIB7_4_NV"("0x8667") + "GL_MAP1_VERTEX_ATTRIB8_4_NV"("0x8668") + "GL_MAP1_VERTEX_ATTRIB9_4_NV"("0x8669") + "GL_MAP1_VERTEX_ATTRIB10_4_NV"("0x866A") + "GL_MAP1_VERTEX_ATTRIB11_4_NV"("0x866B") + "GL_MAP1_VERTEX_ATTRIB12_4_NV"("0x866C") + "GL_MAP1_VERTEX_ATTRIB13_4_NV"("0x866D") + "GL_MAP1_VERTEX_ATTRIB14_4_NV"("0x866E") + "GL_MAP1_VERTEX_ATTRIB15_4_NV"("0x866F") + "GL_MAP2_VERTEX_ATTRIB0_4_NV"("0x8670") + "GL_MAP2_VERTEX_ATTRIB1_4_NV"("0x8671") + "GL_MAP2_VERTEX_ATTRIB2_4_NV"("0x8672") + "GL_MAP2_VERTEX_ATTRIB3_4_NV"("0x8673") + "GL_MAP2_VERTEX_ATTRIB4_4_NV"("0x8674") + "GL_MAP2_VERTEX_ATTRIB5_4_NV"("0x8675") + "GL_MAP2_VERTEX_ATTRIB6_4_NV"("0x8676") + "GL_MAP2_VERTEX_ATTRIB7_4_NV"("0x8677") + "GL_MAP2_VERTEX_ATTRIB8_4_NV"("0x8678") + "GL_MAP2_VERTEX_ATTRIB9_4_NV"("0x8679") + "GL_MAP2_VERTEX_ATTRIB10_4_NV"("0x867A") + "GL_MAP2_VERTEX_ATTRIB11_4_NV"("0x867B") + "GL_MAP2_VERTEX_ATTRIB12_4_NV"("0x867C") + "GL_MAP2_VERTEX_ATTRIB13_4_NV"("0x867D") + "GL_MAP2_VERTEX_ATTRIB14_4_NV"("0x867E") + "GL_MAP2_VERTEX_ATTRIB15_4_NV"("0x867F") + "glAreProgramsResidentNV"( + GLboolean, + GLsizei("n"), + address("programs", "const GLuint *"), + address("residences", "GLboolean *") + ) + "glBindProgramNV"(void, GLenum("target"), GLuint("id")) + "glDeleteProgramsNV"(void, GLsizei("n"), address("programs", "const GLuint *")) + "glExecuteProgramNV"(void, GLenum("target"), GLuint("id"), address("params", "const GLfloat *")) + "glGenProgramsNV"(void, GLsizei("n"), address("programs", "GLuint *")) + "glGetProgramParameterdvNV"( + void, + GLenum("target"), + GLuint("index"), + GLenum("pname"), + address("params", "GLdouble *") + ) + "glGetProgramParameterfvNV"( + void, + GLenum("target"), + GLuint("index"), + GLenum("pname"), + address("params", "GLfloat *") + ) + "glGetProgramivNV"(void, GLuint("id"), GLenum("pname"), address("params", "GLint *")) + "glGetProgramStringNV"(void, GLuint("id"), GLenum("pname"), address("program", "GLubyte *")) + "glGetTrackMatrixivNV"(void, GLenum("target"), GLuint("address"), GLenum("pname"), address("params", "GLint *")) + "glGetVertexAttribdvNV"(void, GLuint("index"), GLenum("pname"), address("params", "GLdouble *")) + "glGetVertexAttribfvNV"(void, GLuint("index"), GLenum("pname"), address("params", "GLfloat *")) + "glGetVertexAttribivNV"(void, GLuint("index"), GLenum("pname"), address("params", "GLint *")) + "glGetVertexAttribPointervNV"(void, GLuint("index"), GLenum("pname"), address("pointer", "void **")) + "glIsProgramNV"(GLboolean, GLuint("id")) + "glLoadProgramNV"(void, GLenum("target"), GLuint("id"), GLsizei("len"), address("program", "const GLubyte *")) + "glProgramParameter4dNV"( + void, + GLenum("target"), + GLuint("index"), + GLdouble("x"), + GLdouble("y"), + GLdouble("z"), + GLdouble("w") + ) + "glProgramParameter4dvNV"(void, GLenum("target"), GLuint("index"), address("v", "const GLdouble *")) + "glProgramParameter4fNV"( + void, + GLenum("target"), + GLuint("index"), + GLfloat("x"), + GLfloat("y"), + GLfloat("z"), + GLfloat("w") + ) + "glProgramParameter4fvNV"(void, GLenum("target"), GLuint("index"), address("v", "const GLfloat *")) + "glProgramParameters4dvNV"( + void, + GLenum("target"), + GLuint("index"), + GLsizei("count"), + address("v", "const GLdouble *") + ) + "glProgramParameters4fvNV"( + void, + GLenum("target"), + GLuint("index"), + GLsizei("count"), + address("v", "const GLfloat *") + ) + "glRequestResidentProgramsNV"(void, GLsizei("n"), address("programs", "const GLuint *")) + "glTrackMatrixNV"(void, GLenum("target"), GLuint("address"), GLenum("matrix"), GLenum("transform")) + "glVertexAttribPointerNV"( + void, + GLuint("index"), + GLint("fsize"), + GLenum("type"), + GLsizei("stride"), + address("pointer", "const void *") + ) + "glVertexAttrib1dNV"(void, GLuint("index"), GLdouble("x")) + "glVertexAttrib1dvNV"(void, GLuint("index"), address("v", "const GLdouble *")) + "glVertexAttrib1fNV"(void, GLuint("index"), GLfloat("x")) + "glVertexAttrib1fvNV"(void, GLuint("index"), address("v", "const GLfloat *")) + "glVertexAttrib1sNV"(void, GLuint("index"), GLshort("x")) + "glVertexAttrib1svNV"(void, GLuint("index"), address("v", "const GLshort *")) + "glVertexAttrib2dNV"(void, GLuint("index"), GLdouble("x"), GLdouble("y")) + "glVertexAttrib2dvNV"(void, GLuint("index"), address("v", "const GLdouble *")) + "glVertexAttrib2fNV"(void, GLuint("index"), GLfloat("x"), GLfloat("y")) + "glVertexAttrib2fvNV"(void, GLuint("index"), address("v", "const GLfloat *")) + "glVertexAttrib2sNV"(void, GLuint("index"), GLshort("x"), GLshort("y")) + "glVertexAttrib2svNV"(void, GLuint("index"), address("v", "const GLshort *")) + "glVertexAttrib3dNV"(void, GLuint("index"), GLdouble("x"), GLdouble("y"), GLdouble("z")) + "glVertexAttrib3dvNV"(void, GLuint("index"), address("v", "const GLdouble *")) + "glVertexAttrib3fNV"(void, GLuint("index"), GLfloat("x"), GLfloat("y"), GLfloat("z")) + "glVertexAttrib3fvNV"(void, GLuint("index"), address("v", "const GLfloat *")) + "glVertexAttrib3sNV"(void, GLuint("index"), GLshort("x"), GLshort("y"), GLshort("z")) + "glVertexAttrib3svNV"(void, GLuint("index"), address("v", "const GLshort *")) + "glVertexAttrib4dNV"(void, GLuint("index"), GLdouble("x"), GLdouble("y"), GLdouble("z"), GLdouble("w")) + "glVertexAttrib4dvNV"(void, GLuint("index"), address("v", "const GLdouble *")) + "glVertexAttrib4fNV"(void, GLuint("index"), GLfloat("x"), GLfloat("y"), GLfloat("z"), GLfloat("w")) + "glVertexAttrib4fvNV"(void, GLuint("index"), address("v", "const GLfloat *")) + "glVertexAttrib4sNV"(void, GLuint("index"), GLshort("x"), GLshort("y"), GLshort("z"), GLshort("w")) + "glVertexAttrib4svNV"(void, GLuint("index"), address("v", "const GLshort *")) + "glVertexAttrib4ubNV"(void, GLuint("index"), GLubyte("x"), GLubyte("y"), GLubyte("z"), GLubyte("w")) + "glVertexAttrib4ubvNV"(void, GLuint("index"), address("v", "const GLubyte *")) + "glVertexAttribs1dvNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLdouble *")) + "glVertexAttribs1fvNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLfloat *")) + "glVertexAttribs1svNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLshort *")) + "glVertexAttribs2dvNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLdouble *")) + "glVertexAttribs2fvNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLfloat *")) + "glVertexAttribs2svNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLshort *")) + "glVertexAttribs3dvNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLdouble *")) + "glVertexAttribs3fvNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLfloat *")) + "glVertexAttribs3svNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLshort *")) + "glVertexAttribs4dvNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLdouble *")) + "glVertexAttribs4fvNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLfloat *")) + "glVertexAttribs4svNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLshort *")) + "glVertexAttribs4ubvNV"(void, GLuint("index"), GLsizei("count"), address("v", "const GLubyte *")) + } + file("VertexProgram4", NV, "GL_NV_vertex_program4", "GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV" to "0x88FD") + file("VideoCapture", NV, "GL_NV_video_capture") { + "GL_VIDEO_BUFFER_NV"("0x9020") + "GL_VIDEO_BUFFER_BINDING_NV"("0x9021") + "GL_FIELD_UPPER_NV"("0x9022") + "GL_FIELD_LOWER_NV"("0x9023") + "GL_NUM_VIDEO_CAPTURE_STREAMS_NV"("0x9024") + "GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV"("0x9025") + "GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV"("0x9026") + "GL_LAST_VIDEO_CAPTURE_STATUS_NV"("0x9027") + "GL_VIDEO_BUFFER_PITCH_NV"("0x9028") + "GL_VIDEO_COLOR_CONVERSION_MATRIX_NV"("0x9029") + "GL_VIDEO_COLOR_CONVERSION_MAX_NV"("0x902A") + "GL_VIDEO_COLOR_CONVERSION_MIN_NV"("0x902B") + "GL_VIDEO_COLOR_CONVERSION_OFFSET_NV"("0x902C") + "GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV"("0x902D") + "GL_PARTIAL_SUCCESS_NV"("0x902E") + "GL_SUCCESS_NV"("0x902F") + "GL_FAILURE_NV"("0x9030") + "GL_YCBYCR8_422_NV"("0x9031") + "GL_YCBAYCR8A_4224_NV"("0x9032") + "GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV"("0x9033") + "GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV"("0x9034") + "GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV"("0x9035") + "GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV"("0x9036") + "GL_Z4Y12Z4CB12Z4CR12_444_NV"("0x9037") + "GL_VIDEO_CAPTURE_FRAME_WIDTH_NV"("0x9038") + "GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV"("0x9039") + "GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV"("0x903A") + "GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV"("0x903B") + "GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV"("0x903C") + "glBeginVideoCaptureNV"(void, GLuint("video_capture_slot")) + "glBindVideoCaptureStreamBufferNV"( + void, + GLuint("video_capture_slot"), + GLuint("stream"), + GLenum("frame_region"), + GLintptrARB("offset") + ) + "glBindVideoCaptureStreamTextureNV"( + void, + GLuint("video_capture_slot"), + GLuint("stream"), + GLenum("frame_region"), + GLenum("target"), + GLuint("texture") + ) + "glEndVideoCaptureNV"(void, GLuint("video_capture_slot")) + "glGetVideoCaptureivNV"(void, GLuint("video_capture_slot"), GLenum("pname"), address("params", "GLint *")) + "glGetVideoCaptureStreamivNV"( + void, + GLuint("video_capture_slot"), + GLuint("stream"), + GLenum("pname"), + address("params", "GLint *") + ) + "glGetVideoCaptureStreamfvNV"( + void, + GLuint("video_capture_slot"), + GLuint("stream"), + GLenum("pname"), + address("params", "GLfloat *") + ) + "glGetVideoCaptureStreamdvNV"( + void, + GLuint("video_capture_slot"), + GLuint("stream"), + GLenum("pname"), + address("params", "GLdouble *") + ) + "glVideoCaptureNV"( + GLenum, + GLuint("video_capture_slot"), + address("sequence_num", "GLuint *"), + address("capture_time", "GLuint64EXT *") + ) + "glVideoCaptureStreamParameterivNV"( + void, + GLuint("video_capture_slot"), + GLuint("stream"), + GLenum("pname"), + address("params", "const GLint *") + ) + "glVideoCaptureStreamParameterfvNV"( + void, + GLuint("video_capture_slot"), + GLuint("stream"), + GLenum("pname"), + address("params", "const GLfloat *") + ) + "glVideoCaptureStreamParameterdvNV"( + void, + GLuint("video_capture_slot"), + GLuint("stream"), + GLenum("pname"), + address("params", "const GLdouble *") + ) + } + file("ViewportSwizzle", NV, "GL_NV_viewport_swizzle") { + "GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV"("0x9350") + "GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV"("0x9351") + "GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV"("0x9352") + "GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV"("0x9353") + "GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV"("0x9354") + "GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV"("0x9355") + "GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV"("0x9356") + "GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV"("0x9357") + "GL_VIEWPORT_SWIZZLE_X_NV"("0x9358") + "GL_VIEWPORT_SWIZZLE_Y_NV"("0x9359") + "GL_VIEWPORT_SWIZZLE_Z_NV"("0x935A") + "GL_VIEWPORT_SWIZZLE_W_NV"("0x935B") + "glViewportSwizzleNV"( + void, + GLuint("index"), + GLenum("swizzlex"), + GLenum("swizzley"), + GLenum("swizzlez"), + GLenum("swizzlew") + ) + } } 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 8e23425e..10ae12f3 100644 --- a/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/OpenGLGenerator.kt +++ b/modules/overrungl.opengl/src/generator/kotlin/overrungl/opengl/OpenGLGenerator.kt @@ -124,6 +124,7 @@ val GLcharARB = byte val GLint64EXT = long val GLuint64EXT = long val GLhalfNV = short +val GLvdpauSurfaceNV = GLintptr data class Parameter( val type: Type, 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 819a2286..f3b9985a 100644 --- a/modules/overrungl.opengl/src/main/java/overrungl/opengl/GLExtCaps.java +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/GLExtCaps.java @@ -127,16 +127,25 @@ public GLExtCaps(GLCapabilities caps) { 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, 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; + 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); @@ -281,6 +290,18 @@ void load(GLLoadFunc load) { GLNVShaderBufferLoad.load(this, load); GLNVShadingRateImage.load(this, load); GLNVTextureBarrier.load(this, load); + GLNVTextureMultisample.load(this, load); + GLNVTimelineSemaphore.load(this, load); + GLNVTransformFeedback.load(this, load); + GLNVTransformFeedback2.load(this, load); + GLNVVDPAUInterop.load(this, load); + GLNVVDPAUInterop2.load(this, load); + GLNVVertexArrayRange.load(this, load); + GLNVVertexAttribInteger64bit.load(this, load); + GLNVVertexBufferUnifiedMemory.load(this, load); + GLNVVertexProgram.load(this, load); + GLNVVideoCapture.load(this, load); + GLNVViewportSwizzle.load(this, load); GLOVRMultiview.load(this, load); GLPGIMiscHints.load(this, load); GLSGISDetailTexture.load(this, load); diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/GLLoader.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/GLLoader.java index 0d1e4d74..f1ece98f 100644 --- a/modules/overrungl.opengl/src/main/java/overrungl/opengl/GLLoader.java +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/GLLoader.java @@ -65,9 +65,21 @@ public static void setCapabilities(@Nullable GLCapabilities caps) { } /** - * {@return the {@link GLCapabilities} of the OpenGL context that is current in the current thread}. + * {@return the {@link GLCapabilities} of the OpenGL context that is current in the current thread} + *

+ * This method doesn't throw an exception when the capabilities are null. + * + * @see #getCapabilities() + */ + public static GLCapabilities getCapabilitiesSafe() { + return capabilitiesTLS.get(); + } + + /** + * {@return the {@link GLCapabilities} of the OpenGL context that is current in the current thread} * * @throws IllegalStateException if {@link #setCapabilities} has never been called in the current thread or was last called with a {@code null} value + * @see #getCapabilitiesSafe() */ public static GLCapabilities getCapabilities() { return checkCapabilities(capabilitiesTLS.get()); diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureEnvCombine4.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureEnvCombine4.java new file mode 100644 index 00000000..c6eb7080 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureEnvCombine4.java @@ -0,0 +1,36 @@ +/* + * 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.nv; + +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_NV_texture_env_combine4} + */ +public final class GLNVTextureEnvCombine4 { + public static final int GL_COMBINE4_NV = 0x8503; + public static final int GL_SOURCE3_RGB_NV = 0x8583; + public static final int GL_SOURCE3_ALPHA_NV = 0x858B; + public static final int GL_OPERAND3_RGB_NV = 0x8593; + public static final int GL_OPERAND3_ALPHA_NV = 0x859B; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureExpandNormal.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureExpandNormal.java new file mode 100644 index 00000000..2df5e36e --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureExpandNormal.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.nv; + +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_NV_texture_expand_normal} + */ +public final class GLNVTextureExpandNormal { + public static final int GL_TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureMultisample.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureMultisample.java new file mode 100644 index 00000000..b200a9bd --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureMultisample.java @@ -0,0 +1,85 @@ +/* + * 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.nv; + +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_NV_texture_multisample} + */ +public final class GLNVTextureMultisample { + public static final int GL_TEXTURE_COVERAGE_SAMPLES_NV = 0x9045; + public static final int GL_TEXTURE_COLOR_SAMPLES_NV = 0x9046; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_texture_multisample) return; + ext.glTexImage2DMultisampleCoverageNV = load.invoke("glTexImage2DMultisampleCoverageNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE)); + ext.glTexImage3DMultisampleCoverageNV = load.invoke("glTexImage3DMultisampleCoverageNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE)); + ext.glTextureImage2DMultisampleNV = load.invoke("glTextureImage2DMultisampleNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE)); + ext.glTextureImage3DMultisampleNV = load.invoke("glTextureImage3DMultisampleNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE)); + ext.glTextureImage2DMultisampleCoverageNV = load.invoke("glTextureImage2DMultisampleCoverageNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE)); + ext.glTextureImage3DMultisampleCoverageNV = load.invoke("glTextureImage3DMultisampleCoverageNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE)); + } + + public static void glTexImage2DMultisampleCoverageNV(int target, int coverageSamples, int colorSamples, int internalFormat, int width, int height, boolean fixedSampleLocations) { + final var ext = getExtCapabilities(); + try { + check(ext.glTexImage2DMultisampleCoverageNV).invokeExact(target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTexImage3DMultisampleCoverageNV(int target, int coverageSamples, int colorSamples, int internalFormat, int width, int height, int depth, boolean fixedSampleLocations) { + final var ext = getExtCapabilities(); + try { + check(ext.glTexImage3DMultisampleCoverageNV).invokeExact(target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureImage2DMultisampleNV(int texture, int target, int samples, int internalFormat, int width, int height, boolean fixedSampleLocations) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureImage2DMultisampleNV).invokeExact(texture, target, samples, internalFormat, width, height, fixedSampleLocations); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureImage3DMultisampleNV(int texture, int target, int samples, int internalFormat, int width, int height, int depth, boolean fixedSampleLocations) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureImage3DMultisampleNV).invokeExact(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureImage2DMultisampleCoverageNV(int texture, int target, int coverageSamples, int colorSamples, int internalFormat, int width, int height, boolean fixedSampleLocations) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureImage2DMultisampleCoverageNV).invokeExact(texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTextureImage3DMultisampleCoverageNV(int texture, int target, int coverageSamples, int colorSamples, int internalFormat, int width, int height, int depth, boolean fixedSampleLocations) { + final var ext = getExtCapabilities(); + try { + check(ext.glTextureImage3DMultisampleCoverageNV).invokeExact(texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureRectangle.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureRectangle.java new file mode 100644 index 00000000..b46ba94f --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureRectangle.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.nv; + +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_NV_texture_rectangle} + */ +public final class GLNVTextureRectangle { + public static final int GL_TEXTURE_RECTANGLE_NV = 0x84F5; + public static final int GL_TEXTURE_BINDING_RECTANGLE_NV = 0x84F6; + public static final int GL_PROXY_TEXTURE_RECTANGLE_NV = 0x84F7; + public static final int GL_MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader.java new file mode 100644 index 00000000..02e60038 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader.java @@ -0,0 +1,104 @@ +/* + * 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.nv; + +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_NV_texture_shader} + */ +public final class GLNVTextureShader { + public static final int GL_OFFSET_TEXTURE_RECTANGLE_NV = 0x864C; + public static final int GL_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D; + public static final int GL_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E; + public static final int GL_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9; + public static final int GL_UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA; + public static final int GL_UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB; + public static final int GL_DSDT_MAG_INTENSITY_NV = 0x86DC; + public static final int GL_SHADER_CONSISTENT_NV = 0x86DD; + public static final int GL_TEXTURE_SHADER_NV = 0x86DE; + public static final int GL_SHADER_OPERATION_NV = 0x86DF; + public static final int GL_CULL_MODES_NV = 0x86E0; + public static final int GL_OFFSET_TEXTURE_MATRIX_NV = 0x86E1; + public static final int GL_OFFSET_TEXTURE_SCALE_NV = 0x86E2; + public static final int GL_OFFSET_TEXTURE_BIAS_NV = 0x86E3; + public static final int GL_OFFSET_TEXTURE_2D_MATRIX_NV = 0x86E1; + public static final int GL_OFFSET_TEXTURE_2D_SCALE_NV = 0x86E2; + public static final int GL_OFFSET_TEXTURE_2D_BIAS_NV = 0x86E3; + public static final int GL_PREVIOUS_TEXTURE_INPUT_NV = 0x86E4; + public static final int GL_CONST_EYE_NV = 0x86E5; + public static final int GL_PASS_THROUGH_NV = 0x86E6; + public static final int GL_CULL_FRAGMENT_NV = 0x86E7; + public static final int GL_OFFSET_TEXTURE_2D_NV = 0x86E8; + public static final int GL_DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9; + public static final int GL_DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA; + public static final int GL_DOT_PRODUCT_NV = 0x86EC; + public static final int GL_DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED; + public static final int GL_DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE; + public static final int GL_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0; + public static final int GL_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1; + public static final int GL_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2; + public static final int GL_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3; + public static final int GL_HILO_NV = 0x86F4; + public static final int GL_DSDT_NV = 0x86F5; + public static final int GL_DSDT_MAG_NV = 0x86F6; + public static final int GL_DSDT_MAG_VIB_NV = 0x86F7; + public static final int GL_HILO16_NV = 0x86F8; + public static final int GL_SIGNED_HILO_NV = 0x86F9; + public static final int GL_SIGNED_HILO16_NV = 0x86FA; + public static final int GL_SIGNED_RGBA_NV = 0x86FB; + public static final int GL_SIGNED_RGBA8_NV = 0x86FC; + public static final int GL_SIGNED_RGB_NV = 0x86FE; + public static final int GL_SIGNED_RGB8_NV = 0x86FF; + public static final int GL_SIGNED_LUMINANCE_NV = 0x8701; + public static final int GL_SIGNED_LUMINANCE8_NV = 0x8702; + public static final int GL_SIGNED_LUMINANCE_ALPHA_NV = 0x8703; + public static final int GL_SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704; + public static final int GL_SIGNED_ALPHA_NV = 0x8705; + public static final int GL_SIGNED_ALPHA8_NV = 0x8706; + public static final int GL_SIGNED_INTENSITY_NV = 0x8707; + public static final int GL_SIGNED_INTENSITY8_NV = 0x8708; + public static final int GL_DSDT8_NV = 0x8709; + public static final int GL_DSDT8_MAG8_NV = 0x870A; + public static final int GL_DSDT8_MAG8_INTENSITY8_NV = 0x870B; + public static final int GL_SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C; + public static final int GL_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D; + public static final int GL_HI_SCALE_NV = 0x870E; + public static final int GL_LO_SCALE_NV = 0x870F; + public static final int GL_DS_SCALE_NV = 0x8710; + public static final int GL_DT_SCALE_NV = 0x8711; + public static final int GL_MAGNITUDE_SCALE_NV = 0x8712; + public static final int GL_VIBRANCE_SCALE_NV = 0x8713; + public static final int GL_HI_BIAS_NV = 0x8714; + public static final int GL_LO_BIAS_NV = 0x8715; + public static final int GL_DS_BIAS_NV = 0x8716; + public static final int GL_DT_BIAS_NV = 0x8717; + public static final int GL_MAGNITUDE_BIAS_NV = 0x8718; + public static final int GL_VIBRANCE_BIAS_NV = 0x8719; + public static final int GL_TEXTURE_BORDER_VALUES_NV = 0x871A; + public static final int GL_TEXTURE_HI_SIZE_NV = 0x871B; + public static final int GL_TEXTURE_LO_SIZE_NV = 0x871C; + public static final int GL_TEXTURE_DS_SIZE_NV = 0x871D; + public static final int GL_TEXTURE_DT_SIZE_NV = 0x871E; + public static final int GL_TEXTURE_MAG_SIZE_NV = 0x871F; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader2.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader2.java new file mode 100644 index 00000000..ea726fd6 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader2.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.nv; + +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_NV_texture_shader2} + */ +public final class GLNVTextureShader2 { + public static final int GL_DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader3.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader3.java new file mode 100644 index 00000000..6f6a10dc --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTextureShader3.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.nv; + +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_NV_texture_shader3} + */ +public final class GLNVTextureShader3 { + public static final int GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850; + public static final int GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851; + public static final int GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852; + public static final int GL_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853; + public static final int GL_OFFSET_HILO_TEXTURE_2D_NV = 0x8854; + public static final int GL_OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855; + public static final int GL_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856; + public static final int GL_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857; + public static final int GL_DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858; + public static final int GL_DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859; + public static final int GL_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A; + public static final int GL_DOT_PRODUCT_PASS_THROUGH_NV = 0x885B; + public static final int GL_DOT_PRODUCT_TEXTURE_1D_NV = 0x885C; + public static final int GL_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D; + public static final int GL_HILO8_NV = 0x885E; + public static final int GL_SIGNED_HILO8_NV = 0x885F; + public static final int GL_FORCE_BLUE_TO_ONE_NV = 0x8860; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTimelineSemaphore.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTimelineSemaphore.java new file mode 100644 index 00000000..488a483b --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTimelineSemaphore.java @@ -0,0 +1,64 @@ +/* + * 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.nv; + +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_NV_timeline_semaphore} + */ +public final class GLNVTimelineSemaphore { + public static final int GL_TIMELINE_SEMAPHORE_VALUE_NV = 0x9595; + public static final int GL_SEMAPHORE_TYPE_NV = 0x95B3; + public static final int GL_SEMAPHORE_TYPE_BINARY_NV = 0x95B4; + public static final int GL_SEMAPHORE_TYPE_TIMELINE_NV = 0x95B5; + public static final int GL_MAX_TIMELINE_SEMAPHORE_VALUE_DIFFERENCE_NV = 0x95B6; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_timeline_semaphore) return; + ext.glCreateSemaphoresNV = load.invoke("glCreateSemaphoresNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glSemaphoreParameterivNV = load.invoke("glSemaphoreParameterivNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetSemaphoreParameterivNV = load.invoke("glGetSemaphoreParameterivNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + } + + public static void glCreateSemaphoresNV(int n, @NativeType("GLuint *") MemorySegment semaphores) { + final var ext = getExtCapabilities(); + try { + check(ext.glCreateSemaphoresNV).invokeExact(n, semaphores); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glSemaphoreParameterivNV(int semaphore, int pname, @NativeType("const GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glSemaphoreParameterivNV).invokeExact(semaphore, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetSemaphoreParameterivNV(int semaphore, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetSemaphoreParameterivNV).invokeExact(semaphore, 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/nv/GLNVTransformFeedback.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTransformFeedback.java new file mode 100644 index 00000000..72367cb4 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTransformFeedback.java @@ -0,0 +1,163 @@ +/* + * 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.nv; + +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_NV_transform_feedback} + */ +public final class GLNVTransformFeedback { + public static final int GL_BACK_PRIMARY_COLOR_NV = 0x8C77; + public static final int GL_BACK_SECONDARY_COLOR_NV = 0x8C78; + public static final int GL_TEXTURE_COORD_NV = 0x8C79; + public static final int GL_CLIP_DISTANCE_NV = 0x8C7A; + public static final int GL_VERTEX_ID_NV = 0x8C7B; + public static final int GL_PRIMITIVE_ID_NV = 0x8C7C; + public static final int GL_GENERIC_ATTRIB_NV = 0x8C7D; + public static final int GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8C7E; + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8C7F; + public static final int GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8C80; + public static final int GL_ACTIVE_VARYINGS_NV = 0x8C81; + public static final int GL_ACTIVE_VARYING_MAX_LENGTH_NV = 0x8C82; + public static final int GL_TRANSFORM_FEEDBACK_VARYINGS_NV = 0x8C83; + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = 0x8C84; + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 0x8C85; + public static final int GL_TRANSFORM_FEEDBACK_RECORD_NV = 0x8C86; + public static final int GL_PRIMITIVES_GENERATED_NV = 0x8C87; + public static final int GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8C88; + public static final int GL_RASTERIZER_DISCARD_NV = 0x8C89; + public static final int GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = 0x8C8A; + public static final int GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 0x8C8B; + public static final int GL_INTERLEAVED_ATTRIBS_NV = 0x8C8C; + public static final int GL_SEPARATE_ATTRIBS_NV = 0x8C8D; + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_NV = 0x8C8E; + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8C8F; + public static final int GL_LAYER_NV = 0x8DAA; + public static final int GL_NEXT_BUFFER_NV = -2; + public static final int GL_SKIP_COMPONENTS4_NV = -3; + public static final int GL_SKIP_COMPONENTS3_NV = -4; + public static final int GL_SKIP_COMPONENTS2_NV = -5; + public static final int GL_SKIP_COMPONENTS1_NV = -6; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_transform_feedback) return; + ext.glBeginTransformFeedbackNV = load.invoke("glBeginTransformFeedbackNV", ofVoid(JAVA_INT)); + ext.glEndTransformFeedbackNV = load.invoke("glEndTransformFeedbackNV", ofVoid()); + ext.glTransformFeedbackAttribsNV = load.invoke("glTransformFeedbackAttribsNV", ofVoid(JAVA_INT, ADDRESS, JAVA_INT)); + ext.glBindBufferRangeNV = load.invoke("glBindBufferRangeNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG, JAVA_LONG)); + ext.glBindBufferOffsetNV = load.invoke("glBindBufferOffsetNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glBindBufferBaseNV = load.invoke("glBindBufferBaseNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glTransformFeedbackVaryingsNV = load.invoke("glTransformFeedbackVaryingsNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS, JAVA_INT)); + ext.glActiveVaryingNV = load.invoke("glActiveVaryingNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glGetVaryingLocationNV = load.invoke("glGetVaryingLocationNV", of(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetActiveVaryingNV = load.invoke("glGetActiveVaryingNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS, ADDRESS, ADDRESS, ADDRESS)); + ext.glGetTransformFeedbackVaryingNV = load.invoke("glGetTransformFeedbackVaryingNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glTransformFeedbackStreamAttribsNV = load.invoke("glTransformFeedbackStreamAttribsNV", ofVoid(JAVA_INT, ADDRESS, JAVA_INT, ADDRESS, JAVA_INT)); + } + + public static void glBeginTransformFeedbackNV(int primitiveMode) { + final var ext = getExtCapabilities(); + try { + check(ext.glBeginTransformFeedbackNV).invokeExact(primitiveMode); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glEndTransformFeedbackNV() { + final var ext = getExtCapabilities(); + try { + check(ext.glEndTransformFeedbackNV).invokeExact(); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTransformFeedbackAttribsNV(int count, @NativeType("const GLint *") MemorySegment attribs, int bufferMode) { + final var ext = getExtCapabilities(); + try { + check(ext.glTransformFeedbackAttribsNV).invokeExact(count, attribs, bufferMode); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBindBufferRangeNV(int target, int index, int buffer, long offset, long size) { + final var ext = getExtCapabilities(); + try { + check(ext.glBindBufferRangeNV).invokeExact(target, index, buffer, offset, size); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBindBufferOffsetNV(int target, int index, int buffer, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glBindBufferOffsetNV).invokeExact(target, index, buffer, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBindBufferBaseNV(int target, int index, int buffer) { + final var ext = getExtCapabilities(); + try { + check(ext.glBindBufferBaseNV).invokeExact(target, index, buffer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTransformFeedbackVaryingsNV(int program, int count, @NativeType("const GLint *") MemorySegment locations, int bufferMode) { + final var ext = getExtCapabilities(); + try { + check(ext.glTransformFeedbackVaryingsNV).invokeExact(program, count, locations, bufferMode); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glActiveVaryingNV(int program, @NativeType("const GLchar *") MemorySegment name) { + final var ext = getExtCapabilities(); + try { + check(ext.glActiveVaryingNV).invokeExact(program, name); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static int glGetVaryingLocationNV(int program, @NativeType("const GLchar *") MemorySegment name) { + final var ext = getExtCapabilities(); + try { + return (int) + check(ext.glGetVaryingLocationNV).invokeExact(program, name); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetActiveVaryingNV(int program, int index, int bufSize, @NativeType("GLsizei *") MemorySegment length, @NativeType("GLsizei *") MemorySegment size, @NativeType("GLenum *") MemorySegment type, @NativeType("GLchar *") MemorySegment name) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetActiveVaryingNV).invokeExact(program, index, bufSize, length, size, type, name); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetTransformFeedbackVaryingNV(int program, int index, @NativeType("GLint *") MemorySegment location) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetTransformFeedbackVaryingNV).invokeExact(program, index, location); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTransformFeedbackStreamAttribsNV(int count, @NativeType("const GLint *") MemorySegment attribs, int nbuffers, @NativeType("const GLint *") MemorySegment bufstreams, int bufferMode) { + final var ext = getExtCapabilities(); + try { + check(ext.glTransformFeedbackStreamAttribsNV).invokeExact(count, attribs, nbuffers, bufstreams, bufferMode); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTransformFeedback2.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTransformFeedback2.java new file mode 100644 index 00000000..2fd3afd2 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVTransformFeedback2.java @@ -0,0 +1,96 @@ +/* + * 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.nv; + +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_NV_transform_feedback2} + */ +public final class GLNVTransformFeedback2 { + public static final int GL_TRANSFORM_FEEDBACK_NV = 0x8E22; + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = 0x8E23; + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = 0x8E24; + public static final int GL_TRANSFORM_FEEDBACK_BINDING_NV = 0x8E25; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_transform_feedback2) return; + ext.glBindTransformFeedbackNV = load.invoke("glBindTransformFeedbackNV", ofVoid(JAVA_INT, JAVA_INT)); + ext.glDeleteTransformFeedbacksNV = load.invoke("glDeleteTransformFeedbacksNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glGenTransformFeedbacksNV = load.invoke("glGenTransformFeedbacksNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glIsTransformFeedbackNV = load.invoke("glIsTransformFeedbackNV", of(JAVA_BYTE, JAVA_INT)); + ext.glPauseTransformFeedbackNV = load.invoke("glPauseTransformFeedbackNV", ofVoid()); + ext.glResumeTransformFeedbackNV = load.invoke("glResumeTransformFeedbackNV", ofVoid()); + ext.glDrawTransformFeedbackNV = load.invoke("glDrawTransformFeedbackNV", ofVoid(JAVA_INT, JAVA_INT)); + } + + public static void glBindTransformFeedbackNV(int target, int id) { + final var ext = getExtCapabilities(); + try { + check(ext.glBindTransformFeedbackNV).invokeExact(target, id); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glDeleteTransformFeedbacksNV(int n, @NativeType("const GLuint *") MemorySegment ids) { + final var ext = getExtCapabilities(); + try { + check(ext.glDeleteTransformFeedbacksNV).invokeExact(n, ids); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGenTransformFeedbacksNV(int n, @NativeType("GLuint *") MemorySegment ids) { + final var ext = getExtCapabilities(); + try { + check(ext.glGenTransformFeedbacksNV).invokeExact(n, ids); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static boolean glIsTransformFeedbackNV(int id) { + final var ext = getExtCapabilities(); + try { + return (boolean) + check(ext.glIsTransformFeedbackNV).invokeExact(id); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glPauseTransformFeedbackNV() { + final var ext = getExtCapabilities(); + try { + check(ext.glPauseTransformFeedbackNV).invokeExact(); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glResumeTransformFeedbackNV() { + final var ext = getExtCapabilities(); + try { + check(ext.glResumeTransformFeedbackNV).invokeExact(); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glDrawTransformFeedbackNV(int mode, int id) { + final var ext = getExtCapabilities(); + try { + check(ext.glDrawTransformFeedbackNV).invokeExact(mode, id); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVUniformBufferUnifiedMemory.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVUniformBufferUnifiedMemory.java new file mode 100644 index 00000000..fe248618 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVUniformBufferUnifiedMemory.java @@ -0,0 +1,34 @@ +/* + * 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.nv; + +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_NV_uniform_buffer_unified_memory} + */ +public final class GLNVUniformBufferUnifiedMemory { + public static final int GL_UNIFORM_BUFFER_UNIFIED_NV = 0x936E; + public static final int GL_UNIFORM_BUFFER_ADDRESS_NV = 0x936F; + public static final int GL_UNIFORM_BUFFER_LENGTH_NV = 0x9370; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVDPAUInterop.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVDPAUInterop.java new file mode 100644 index 00000000..6737f5f8 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVDPAUInterop.java @@ -0,0 +1,122 @@ +/* + * 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.nv; + +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_NV_vdpau_interop} + */ +public final class GLNVVDPAUInterop { + public static final int GL_SURFACE_STATE_NV = 0x86EB; + public static final int GL_SURFACE_REGISTERED_NV = 0x86FD; + public static final int GL_SURFACE_MAPPED_NV = 0x8700; + public static final int GL_WRITE_DISCARD_NV = 0x88BE; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_vdpau_interop) return; + ext.glVDPAUInitNV = load.invoke("glVDPAUInitNV", ofVoid(ADDRESS, ADDRESS)); + ext.glVDPAUFiniNV = load.invoke("glVDPAUFiniNV", ofVoid()); + ext.glVDPAURegisterVideoSurfaceNV = load.invoke("glVDPAURegisterVideoSurfaceNV", of(JAVA_LONG, ADDRESS, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVDPAURegisterOutputSurfaceNV = load.invoke("glVDPAURegisterOutputSurfaceNV", of(JAVA_LONG, ADDRESS, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVDPAUIsSurfaceNV = load.invoke("glVDPAUIsSurfaceNV", of(JAVA_BYTE, JAVA_LONG)); + ext.glVDPAUUnregisterSurfaceNV = load.invoke("glVDPAUUnregisterSurfaceNV", ofVoid(JAVA_LONG)); + ext.glVDPAUGetSurfaceivNV = load.invoke("glVDPAUGetSurfaceivNV", ofVoid(JAVA_LONG, JAVA_INT, JAVA_INT, ADDRESS, ADDRESS)); + ext.glVDPAUSurfaceAccessNV = load.invoke("glVDPAUSurfaceAccessNV", ofVoid(JAVA_LONG, JAVA_INT)); + ext.glVDPAUMapSurfacesNV = load.invoke("glVDPAUMapSurfacesNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVDPAUUnmapSurfacesNV = load.invoke("glVDPAUUnmapSurfacesNV", ofVoid(JAVA_INT, ADDRESS)); + } + + public static void glVDPAUInitNV(@NativeType("const void *") MemorySegment vdpDevice, @NativeType("const void *") MemorySegment getProcAddress) { + final var ext = getExtCapabilities(); + try { + check(ext.glVDPAUInitNV).invokeExact(vdpDevice, getProcAddress); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVDPAUFiniNV() { + final var ext = getExtCapabilities(); + try { + check(ext.glVDPAUFiniNV).invokeExact(); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static long glVDPAURegisterVideoSurfaceNV(@NativeType("const void *") MemorySegment vdpSurface, int target, int numTextureNames, @NativeType("const GLuint *") MemorySegment textureNames) { + final var ext = getExtCapabilities(); + try { + return (long) + check(ext.glVDPAURegisterVideoSurfaceNV).invokeExact(vdpSurface, target, numTextureNames, textureNames); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static long glVDPAURegisterOutputSurfaceNV(@NativeType("const void *") MemorySegment vdpSurface, int target, int numTextureNames, @NativeType("const GLuint *") MemorySegment textureNames) { + final var ext = getExtCapabilities(); + try { + return (long) + check(ext.glVDPAURegisterOutputSurfaceNV).invokeExact(vdpSurface, target, numTextureNames, textureNames); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static boolean glVDPAUIsSurfaceNV(long surface) { + final var ext = getExtCapabilities(); + try { + return (boolean) + check(ext.glVDPAUIsSurfaceNV).invokeExact(surface); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVDPAUUnregisterSurfaceNV(long surface) { + final var ext = getExtCapabilities(); + try { + check(ext.glVDPAUUnregisterSurfaceNV).invokeExact(surface); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVDPAUGetSurfaceivNV(long surface, int pname, int count, @NativeType("GLsizei *") MemorySegment length, @NativeType("GLint *") MemorySegment values) { + final var ext = getExtCapabilities(); + try { + check(ext.glVDPAUGetSurfaceivNV).invokeExact(surface, pname, count, length, values); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVDPAUSurfaceAccessNV(long surface, int access) { + final var ext = getExtCapabilities(); + try { + check(ext.glVDPAUSurfaceAccessNV).invokeExact(surface, access); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVDPAUMapSurfacesNV(int numSurfaces, @NativeType("const GLvdpauSurfaceNV *") MemorySegment surfaces) { + final var ext = getExtCapabilities(); + try { + check(ext.glVDPAUMapSurfacesNV).invokeExact(numSurfaces, surfaces); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVDPAUUnmapSurfacesNV(int numSurface, @NativeType("const GLvdpauSurfaceNV *") MemorySegment surfaces) { + final var ext = getExtCapabilities(); + try { + check(ext.glVDPAUUnmapSurfacesNV).invokeExact(numSurface, surfaces); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVDPAUInterop2.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVDPAUInterop2.java new file mode 100644 index 00000000..20bd85f5 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVDPAUInterop2.java @@ -0,0 +1,44 @@ +/* + * 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.nv; + +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_NV_vdpau_interop2} + */ +public final class GLNVVDPAUInterop2 { + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_vdpau_interop2) return; + ext.glVDPAURegisterVideoSurfaceWithPictureStructureNV = load.invoke("glVDPAURegisterVideoSurfaceWithPictureStructureNV", of(JAVA_LONG, ADDRESS, JAVA_INT, JAVA_INT, ADDRESS, JAVA_BYTE)); + } + + public static long glVDPAURegisterVideoSurfaceWithPictureStructureNV(@NativeType("const void *") MemorySegment vdpSurface, int target, int numTextureNames, @NativeType("const GLuint *") MemorySegment textureNames, boolean isFrameStructure) { + final var ext = getExtCapabilities(); + try { + return (long) + check(ext.glVDPAURegisterVideoSurfaceWithPictureStructureNV).invokeExact(vdpSurface, target, numTextureNames, textureNames, isFrameStructure); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexArrayRange.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexArrayRange.java new file mode 100644 index 00000000..ece609da --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexArrayRange.java @@ -0,0 +1,56 @@ +/* + * 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.nv; + +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_NV_vertex_array_range} + */ +public final class GLNVVertexArrayRange { + public static final int GL_VERTEX_ARRAY_RANGE_NV = 0x851D; + public static final int GL_VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E; + public static final int GL_VERTEX_ARRAY_RANGE_VALID_NV = 0x851F; + public static final int GL_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520; + public static final int GL_VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_vertex_array_range) return; + ext.glFlushVertexArrayRangeNV = load.invoke("glFlushVertexArrayRangeNV", ofVoid()); + ext.glVertexArrayRangeNV = load.invoke("glVertexArrayRangeNV", ofVoid(JAVA_INT, ADDRESS)); + } + + public static void glFlushVertexArrayRangeNV() { + final var ext = getExtCapabilities(); + try { + check(ext.glFlushVertexArrayRangeNV).invokeExact(); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexArrayRangeNV(int length, @NativeType("const void *") MemorySegment pointer) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexArrayRangeNV).invokeExact(length, pointer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexArrayRange2.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexArrayRange2.java new file mode 100644 index 00000000..2b2dcb41 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexArrayRange2.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.nv; + +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_NV_vertex_array_range2} + */ +public final class GLNVVertexArrayRange2 { + public static final int GL_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexAttribInteger64bit.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexAttribInteger64bit.java new file mode 100644 index 00000000..59b9ad8f --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexAttribInteger64bit.java @@ -0,0 +1,187 @@ +/* + * 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.nv; + +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_NV_vertex_attrib_integer_64bit} + */ +public final class GLNVVertexAttribInteger64bit { + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_vertex_attrib_integer_64bit) return; + ext.glVertexAttribL1i64NV = load.invoke("glVertexAttribL1i64NV", ofVoid(JAVA_INT, JAVA_LONG)); + ext.glVertexAttribL2i64NV = load.invoke("glVertexAttribL2i64NV", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG)); + ext.glVertexAttribL3i64NV = load.invoke("glVertexAttribL3i64NV", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG, JAVA_LONG)); + ext.glVertexAttribL4i64NV = load.invoke("glVertexAttribL4i64NV", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG)); + ext.glVertexAttribL1i64vNV = load.invoke("glVertexAttribL1i64vNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttribL2i64vNV = load.invoke("glVertexAttribL2i64vNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttribL3i64vNV = load.invoke("glVertexAttribL3i64vNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttribL4i64vNV = load.invoke("glVertexAttribL4i64vNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttribL1ui64NV = load.invoke("glVertexAttribL1ui64NV", ofVoid(JAVA_INT, JAVA_LONG)); + ext.glVertexAttribL2ui64NV = load.invoke("glVertexAttribL2ui64NV", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG)); + ext.glVertexAttribL3ui64NV = load.invoke("glVertexAttribL3ui64NV", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG, JAVA_LONG)); + ext.glVertexAttribL4ui64NV = load.invoke("glVertexAttribL4ui64NV", ofVoid(JAVA_INT, JAVA_LONG, JAVA_LONG, JAVA_LONG, JAVA_LONG)); + ext.glVertexAttribL1ui64vNV = load.invoke("glVertexAttribL1ui64vNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttribL2ui64vNV = load.invoke("glVertexAttribL2ui64vNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttribL3ui64vNV = load.invoke("glVertexAttribL3ui64vNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttribL4ui64vNV = load.invoke("glVertexAttribL4ui64vNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glGetVertexAttribLi64vNV = load.invoke("glGetVertexAttribLi64vNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetVertexAttribLui64vNV = load.invoke("glGetVertexAttribLui64vNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribLFormatNV = load.invoke("glVertexAttribLFormatNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + } + + public static void glVertexAttribL1i64NV(int index, long x) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL1i64NV).invokeExact(index, x); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL2i64NV(int index, long x, long y) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL2i64NV).invokeExact(index, x, y); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL3i64NV(int index, long x, long y, long z) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL3i64NV).invokeExact(index, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL4i64NV(int index, long x, long y, long z, long w) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL4i64NV).invokeExact(index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL1i64vNV(int index, @NativeType("const GLint64EXT *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL1i64vNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL2i64vNV(int index, @NativeType("const GLint64EXT *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL2i64vNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL3i64vNV(int index, @NativeType("const GLint64EXT *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL3i64vNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL4i64vNV(int index, @NativeType("const GLint64EXT *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL4i64vNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL1ui64NV(int index, long x) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL1ui64NV).invokeExact(index, x); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL2ui64NV(int index, long x, long y) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL2ui64NV).invokeExact(index, x, y); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL3ui64NV(int index, long x, long y, long z) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL3ui64NV).invokeExact(index, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL4ui64NV(int index, long x, long y, long z, long w) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL4ui64NV).invokeExact(index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL1ui64vNV(int index, @NativeType("const GLuint64EXT *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL1ui64vNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL2ui64vNV(int index, @NativeType("const GLuint64EXT *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL2ui64vNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL3ui64vNV(int index, @NativeType("const GLuint64EXT *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL3ui64vNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribL4ui64vNV(int index, @NativeType("const GLuint64EXT *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribL4ui64vNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVertexAttribLi64vNV(int index, int pname, @NativeType("GLint64EXT *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVertexAttribLi64vNV).invokeExact(index, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVertexAttribLui64vNV(int index, int pname, @NativeType("GLuint64EXT *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVertexAttribLui64vNV).invokeExact(index, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribLFormatNV(int index, int size, int type, int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribLFormatNV).invokeExact(index, size, type, stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexBufferUnifiedMemory.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexBufferUnifiedMemory.java new file mode 100644 index 00000000..2989fad7 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexBufferUnifiedMemory.java @@ -0,0 +1,156 @@ +/* + * 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.nv; + +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_NV_vertex_buffer_unified_memory} + */ +public final class GLNVVertexBufferUnifiedMemory { + public static final int GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = 0x8F1E; + public static final int GL_ELEMENT_ARRAY_UNIFIED_NV = 0x8F1F; + public static final int GL_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = 0x8F20; + public static final int GL_VERTEX_ARRAY_ADDRESS_NV = 0x8F21; + public static final int GL_NORMAL_ARRAY_ADDRESS_NV = 0x8F22; + public static final int GL_COLOR_ARRAY_ADDRESS_NV = 0x8F23; + public static final int GL_INDEX_ARRAY_ADDRESS_NV = 0x8F24; + public static final int GL_TEXTURE_COORD_ARRAY_ADDRESS_NV = 0x8F25; + public static final int GL_EDGE_FLAG_ARRAY_ADDRESS_NV = 0x8F26; + public static final int GL_SECONDARY_COLOR_ARRAY_ADDRESS_NV = 0x8F27; + public static final int GL_FOG_COORD_ARRAY_ADDRESS_NV = 0x8F28; + public static final int GL_ELEMENT_ARRAY_ADDRESS_NV = 0x8F29; + public static final int GL_VERTEX_ATTRIB_ARRAY_LENGTH_NV = 0x8F2A; + public static final int GL_VERTEX_ARRAY_LENGTH_NV = 0x8F2B; + public static final int GL_NORMAL_ARRAY_LENGTH_NV = 0x8F2C; + public static final int GL_COLOR_ARRAY_LENGTH_NV = 0x8F2D; + public static final int GL_INDEX_ARRAY_LENGTH_NV = 0x8F2E; + public static final int GL_TEXTURE_COORD_ARRAY_LENGTH_NV = 0x8F2F; + public static final int GL_EDGE_FLAG_ARRAY_LENGTH_NV = 0x8F30; + public static final int GL_SECONDARY_COLOR_ARRAY_LENGTH_NV = 0x8F31; + public static final int GL_FOG_COORD_ARRAY_LENGTH_NV = 0x8F32; + public static final int GL_ELEMENT_ARRAY_LENGTH_NV = 0x8F33; + public static final int GL_DRAW_INDIRECT_UNIFIED_NV = 0x8F40; + public static final int GL_DRAW_INDIRECT_ADDRESS_NV = 0x8F41; + public static final int GL_DRAW_INDIRECT_LENGTH_NV = 0x8F42; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_vertex_buffer_unified_memory) return; + ext.glBufferAddressRangeNV = load.invoke("glBufferAddressRangeNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_LONG, JAVA_LONG)); + ext.glVertexFormatNV = load.invoke("glVertexFormatNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glNormalFormatNV = load.invoke("glNormalFormatNV", ofVoid(JAVA_INT, JAVA_INT)); + ext.glColorFormatNV = load.invoke("glColorFormatNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glIndexFormatNV = load.invoke("glIndexFormatNV", ofVoid(JAVA_INT, JAVA_INT)); + ext.glTexCoordFormatNV = load.invoke("glTexCoordFormatNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glEdgeFlagFormatNV = load.invoke("glEdgeFlagFormatNV", ofVoid(JAVA_INT)); + ext.glSecondaryColorFormatNV = load.invoke("glSecondaryColorFormatNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glFogCoordFormatNV = load.invoke("glFogCoordFormatNV", ofVoid(JAVA_INT, JAVA_INT)); + ext.glVertexAttribFormatNV = load.invoke("glVertexAttribFormatNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_BYTE, JAVA_INT)); + ext.glVertexAttribIFormatNV = load.invoke("glVertexAttribIFormatNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glGetIntegerui64i_vNV = load.invoke("glGetIntegerui64i_vNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + } + + public static void glBufferAddressRangeNV(int pname, int index, long address, long length) { + final var ext = getExtCapabilities(); + try { + check(ext.glBufferAddressRangeNV).invokeExact(pname, index, address, length); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexFormatNV(int size, int type, int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexFormatNV).invokeExact(size, type, stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glNormalFormatNV(int type, int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glNormalFormatNV).invokeExact(type, stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glColorFormatNV(int size, int type, int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glColorFormatNV).invokeExact(size, type, stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glIndexFormatNV(int type, int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glIndexFormatNV).invokeExact(type, stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTexCoordFormatNV(int size, int type, int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glTexCoordFormatNV).invokeExact(size, type, stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glEdgeFlagFormatNV(int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glEdgeFlagFormatNV).invokeExact(stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glSecondaryColorFormatNV(int size, int type, int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glSecondaryColorFormatNV).invokeExact(size, type, stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glFogCoordFormatNV(int type, int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glFogCoordFormatNV).invokeExact(type, stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribFormatNV(int index, int size, int type, boolean normalized, int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribFormatNV).invokeExact(index, size, type, normalized, stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribIFormatNV(int index, int size, int type, int stride) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribIFormatNV).invokeExact(index, size, type, stride); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetIntegerui64i_vNV(int value, int index, @NativeType("GLuint64EXT *") MemorySegment result) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetIntegerui64i_vNV).invokeExact(value, index, result); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexProgram.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexProgram.java new file mode 100644 index 00000000..529aad74 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexProgram.java @@ -0,0 +1,632 @@ +/* + * 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.nv; + +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_NV_vertex_program} + */ +public final class GLNVVertexProgram { + public static final int GL_VERTEX_PROGRAM_NV = 0x8620; + public static final int GL_VERTEX_STATE_PROGRAM_NV = 0x8621; + public static final int GL_ATTRIB_ARRAY_SIZE_NV = 0x8623; + public static final int GL_ATTRIB_ARRAY_STRIDE_NV = 0x8624; + public static final int GL_ATTRIB_ARRAY_TYPE_NV = 0x8625; + public static final int GL_CURRENT_ATTRIB_NV = 0x8626; + public static final int GL_PROGRAM_LENGTH_NV = 0x8627; + public static final int GL_PROGRAM_STRING_NV = 0x8628; + public static final int GL_MODELVIEW_PROJECTION_NV = 0x8629; + public static final int GL_IDENTITY_NV = 0x862A; + public static final int GL_INVERSE_NV = 0x862B; + public static final int GL_TRANSPOSE_NV = 0x862C; + public static final int GL_INVERSE_TRANSPOSE_NV = 0x862D; + public static final int GL_MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E; + public static final int GL_MAX_TRACK_MATRICES_NV = 0x862F; + public static final int GL_MATRIX0_NV = 0x8630; + public static final int GL_MATRIX1_NV = 0x8631; + public static final int GL_MATRIX2_NV = 0x8632; + public static final int GL_MATRIX3_NV = 0x8633; + public static final int GL_MATRIX4_NV = 0x8634; + public static final int GL_MATRIX5_NV = 0x8635; + public static final int GL_MATRIX6_NV = 0x8636; + public static final int GL_MATRIX7_NV = 0x8637; + public static final int GL_CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640; + public static final int GL_CURRENT_MATRIX_NV = 0x8641; + public static final int GL_VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642; + public static final int GL_VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643; + public static final int GL_PROGRAM_PARAMETER_NV = 0x8644; + public static final int GL_ATTRIB_ARRAY_POINTER_NV = 0x8645; + public static final int GL_PROGRAM_TARGET_NV = 0x8646; + public static final int GL_PROGRAM_RESIDENT_NV = 0x8647; + public static final int GL_TRACK_MATRIX_NV = 0x8648; + public static final int GL_TRACK_MATRIX_TRANSFORM_NV = 0x8649; + public static final int GL_VERTEX_PROGRAM_BINDING_NV = 0x864A; + public static final int GL_PROGRAM_ERROR_POSITION_NV = 0x864B; + public static final int GL_VERTEX_ATTRIB_ARRAY0_NV = 0x8650; + public static final int GL_VERTEX_ATTRIB_ARRAY1_NV = 0x8651; + public static final int GL_VERTEX_ATTRIB_ARRAY2_NV = 0x8652; + public static final int GL_VERTEX_ATTRIB_ARRAY3_NV = 0x8653; + public static final int GL_VERTEX_ATTRIB_ARRAY4_NV = 0x8654; + public static final int GL_VERTEX_ATTRIB_ARRAY5_NV = 0x8655; + public static final int GL_VERTEX_ATTRIB_ARRAY6_NV = 0x8656; + public static final int GL_VERTEX_ATTRIB_ARRAY7_NV = 0x8657; + public static final int GL_VERTEX_ATTRIB_ARRAY8_NV = 0x8658; + public static final int GL_VERTEX_ATTRIB_ARRAY9_NV = 0x8659; + public static final int GL_VERTEX_ATTRIB_ARRAY10_NV = 0x865A; + public static final int GL_VERTEX_ATTRIB_ARRAY11_NV = 0x865B; + public static final int GL_VERTEX_ATTRIB_ARRAY12_NV = 0x865C; + public static final int GL_VERTEX_ATTRIB_ARRAY13_NV = 0x865D; + public static final int GL_VERTEX_ATTRIB_ARRAY14_NV = 0x865E; + public static final int GL_VERTEX_ATTRIB_ARRAY15_NV = 0x865F; + public static final int GL_MAP1_VERTEX_ATTRIB0_4_NV = 0x8660; + public static final int GL_MAP1_VERTEX_ATTRIB1_4_NV = 0x8661; + public static final int GL_MAP1_VERTEX_ATTRIB2_4_NV = 0x8662; + public static final int GL_MAP1_VERTEX_ATTRIB3_4_NV = 0x8663; + public static final int GL_MAP1_VERTEX_ATTRIB4_4_NV = 0x8664; + public static final int GL_MAP1_VERTEX_ATTRIB5_4_NV = 0x8665; + public static final int GL_MAP1_VERTEX_ATTRIB6_4_NV = 0x8666; + public static final int GL_MAP1_VERTEX_ATTRIB7_4_NV = 0x8667; + public static final int GL_MAP1_VERTEX_ATTRIB8_4_NV = 0x8668; + public static final int GL_MAP1_VERTEX_ATTRIB9_4_NV = 0x8669; + public static final int GL_MAP1_VERTEX_ATTRIB10_4_NV = 0x866A; + public static final int GL_MAP1_VERTEX_ATTRIB11_4_NV = 0x866B; + public static final int GL_MAP1_VERTEX_ATTRIB12_4_NV = 0x866C; + public static final int GL_MAP1_VERTEX_ATTRIB13_4_NV = 0x866D; + public static final int GL_MAP1_VERTEX_ATTRIB14_4_NV = 0x866E; + public static final int GL_MAP1_VERTEX_ATTRIB15_4_NV = 0x866F; + public static final int GL_MAP2_VERTEX_ATTRIB0_4_NV = 0x8670; + public static final int GL_MAP2_VERTEX_ATTRIB1_4_NV = 0x8671; + public static final int GL_MAP2_VERTEX_ATTRIB2_4_NV = 0x8672; + public static final int GL_MAP2_VERTEX_ATTRIB3_4_NV = 0x8673; + public static final int GL_MAP2_VERTEX_ATTRIB4_4_NV = 0x8674; + public static final int GL_MAP2_VERTEX_ATTRIB5_4_NV = 0x8675; + public static final int GL_MAP2_VERTEX_ATTRIB6_4_NV = 0x8676; + public static final int GL_MAP2_VERTEX_ATTRIB7_4_NV = 0x8677; + public static final int GL_MAP2_VERTEX_ATTRIB8_4_NV = 0x8678; + public static final int GL_MAP2_VERTEX_ATTRIB9_4_NV = 0x8679; + public static final int GL_MAP2_VERTEX_ATTRIB10_4_NV = 0x867A; + public static final int GL_MAP2_VERTEX_ATTRIB11_4_NV = 0x867B; + public static final int GL_MAP2_VERTEX_ATTRIB12_4_NV = 0x867C; + public static final int GL_MAP2_VERTEX_ATTRIB13_4_NV = 0x867D; + public static final int GL_MAP2_VERTEX_ATTRIB14_4_NV = 0x867E; + public static final int GL_MAP2_VERTEX_ATTRIB15_4_NV = 0x867F; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_vertex_program) return; + ext.glAreProgramsResidentNV = load.invoke("glAreProgramsResidentNV", of(JAVA_BYTE, JAVA_INT, ADDRESS, ADDRESS)); + ext.glBindProgramNV = load.invoke("glBindProgramNV", ofVoid(JAVA_INT, JAVA_INT)); + ext.glDeleteProgramsNV = load.invoke("glDeleteProgramsNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glExecuteProgramNV = load.invoke("glExecuteProgramNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGenProgramsNV = load.invoke("glGenProgramsNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glGetProgramParameterdvNV = load.invoke("glGetProgramParameterdvNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetProgramParameterfvNV = load.invoke("glGetProgramParameterfvNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetProgramivNV = load.invoke("glGetProgramivNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetProgramStringNV = load.invoke("glGetProgramStringNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetTrackMatrixivNV = load.invoke("glGetTrackMatrixivNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetVertexAttribdvNV = load.invoke("glGetVertexAttribdvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetVertexAttribfvNV = load.invoke("glGetVertexAttribfvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetVertexAttribivNV = load.invoke("glGetVertexAttribivNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetVertexAttribPointervNV = load.invoke("glGetVertexAttribPointervNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glIsProgramNV = load.invoke("glIsProgramNV", of(JAVA_BYTE, JAVA_INT)); + ext.glLoadProgramNV = load.invoke("glLoadProgramNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramParameter4dNV = load.invoke("glProgramParameter4dNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glProgramParameter4dvNV = load.invoke("glProgramParameter4dvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramParameter4fNV = load.invoke("glProgramParameter4fNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glProgramParameter4fvNV = load.invoke("glProgramParameter4fvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramParameters4dvNV = load.invoke("glProgramParameters4dvNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glProgramParameters4fvNV = load.invoke("glProgramParameters4fvNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glRequestResidentProgramsNV = load.invoke("glRequestResidentProgramsNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glTrackMatrixNV = load.invoke("glTrackMatrixNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glVertexAttribPointerNV = load.invoke("glVertexAttribPointerNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttrib1dNV = load.invoke("glVertexAttrib1dNV", ofVoid(JAVA_INT, JAVA_DOUBLE)); + ext.glVertexAttrib1dvNV = load.invoke("glVertexAttrib1dvNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib1fNV = load.invoke("glVertexAttrib1fNV", ofVoid(JAVA_INT, JAVA_FLOAT)); + ext.glVertexAttrib1fvNV = load.invoke("glVertexAttrib1fvNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib1sNV = load.invoke("glVertexAttrib1sNV", ofVoid(JAVA_INT, JAVA_SHORT)); + ext.glVertexAttrib1svNV = load.invoke("glVertexAttrib1svNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib2dNV = load.invoke("glVertexAttrib2dNV", ofVoid(JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glVertexAttrib2dvNV = load.invoke("glVertexAttrib2dvNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib2fNV = load.invoke("glVertexAttrib2fNV", ofVoid(JAVA_INT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glVertexAttrib2fvNV = load.invoke("glVertexAttrib2fvNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib2sNV = load.invoke("glVertexAttrib2sNV", ofVoid(JAVA_INT, JAVA_SHORT, JAVA_SHORT)); + ext.glVertexAttrib2svNV = load.invoke("glVertexAttrib2svNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib3dNV = load.invoke("glVertexAttrib3dNV", ofVoid(JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glVertexAttrib3dvNV = load.invoke("glVertexAttrib3dvNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib3fNV = load.invoke("glVertexAttrib3fNV", ofVoid(JAVA_INT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glVertexAttrib3fvNV = load.invoke("glVertexAttrib3fvNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib3sNV = load.invoke("glVertexAttrib3sNV", ofVoid(JAVA_INT, JAVA_SHORT, JAVA_SHORT, JAVA_SHORT)); + ext.glVertexAttrib3svNV = load.invoke("glVertexAttrib3svNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib4dNV = load.invoke("glVertexAttrib4dNV", ofVoid(JAVA_INT, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE, JAVA_DOUBLE)); + ext.glVertexAttrib4dvNV = load.invoke("glVertexAttrib4dvNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib4fNV = load.invoke("glVertexAttrib4fNV", ofVoid(JAVA_INT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT, JAVA_FLOAT)); + ext.glVertexAttrib4fvNV = load.invoke("glVertexAttrib4fvNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib4sNV = load.invoke("glVertexAttrib4sNV", ofVoid(JAVA_INT, JAVA_SHORT, JAVA_SHORT, JAVA_SHORT, JAVA_SHORT)); + ext.glVertexAttrib4svNV = load.invoke("glVertexAttrib4svNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttrib4ubNV = load.invoke("glVertexAttrib4ubNV", ofVoid(JAVA_INT, JAVA_BYTE, JAVA_BYTE, JAVA_BYTE, JAVA_BYTE)); + ext.glVertexAttrib4ubvNV = load.invoke("glVertexAttrib4ubvNV", ofVoid(JAVA_INT, ADDRESS)); + ext.glVertexAttribs1dvNV = load.invoke("glVertexAttribs1dvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs1fvNV = load.invoke("glVertexAttribs1fvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs1svNV = load.invoke("glVertexAttribs1svNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs2dvNV = load.invoke("glVertexAttribs2dvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs2fvNV = load.invoke("glVertexAttribs2fvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs2svNV = load.invoke("glVertexAttribs2svNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs3dvNV = load.invoke("glVertexAttribs3dvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs3fvNV = load.invoke("glVertexAttribs3fvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs3svNV = load.invoke("glVertexAttribs3svNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs4dvNV = load.invoke("glVertexAttribs4dvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs4fvNV = load.invoke("glVertexAttribs4fvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs4svNV = load.invoke("glVertexAttribs4svNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVertexAttribs4ubvNV = load.invoke("glVertexAttribs4ubvNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + } + + public static boolean glAreProgramsResidentNV(int n, @NativeType("const GLuint *") MemorySegment programs, @NativeType("GLboolean *") MemorySegment residences) { + final var ext = getExtCapabilities(); + try { + return (boolean) + check(ext.glAreProgramsResidentNV).invokeExact(n, programs, residences); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBindProgramNV(int target, int id) { + final var ext = getExtCapabilities(); + try { + check(ext.glBindProgramNV).invokeExact(target, id); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glDeleteProgramsNV(int n, @NativeType("const GLuint *") MemorySegment programs) { + final var ext = getExtCapabilities(); + try { + check(ext.glDeleteProgramsNV).invokeExact(n, programs); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glExecuteProgramNV(int target, int id, @NativeType("const GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glExecuteProgramNV).invokeExact(target, id, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGenProgramsNV(int n, @NativeType("GLuint *") MemorySegment programs) { + final var ext = getExtCapabilities(); + try { + check(ext.glGenProgramsNV).invokeExact(n, programs); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetProgramParameterdvNV(int target, int index, int pname, @NativeType("GLdouble *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetProgramParameterdvNV).invokeExact(target, index, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetProgramParameterfvNV(int target, int index, int pname, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetProgramParameterfvNV).invokeExact(target, index, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetProgramivNV(int id, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetProgramivNV).invokeExact(id, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetProgramStringNV(int id, int pname, @NativeType("GLubyte *") MemorySegment program) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetProgramStringNV).invokeExact(id, pname, program); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetTrackMatrixivNV(int target, int address, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetTrackMatrixivNV).invokeExact(target, address, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVertexAttribdvNV(int index, int pname, @NativeType("GLdouble *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVertexAttribdvNV).invokeExact(index, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVertexAttribfvNV(int index, int pname, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVertexAttribfvNV).invokeExact(index, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVertexAttribivNV(int index, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVertexAttribivNV).invokeExact(index, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVertexAttribPointervNV(int index, int pname, @NativeType("void **") MemorySegment pointer) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVertexAttribPointervNV).invokeExact(index, pname, pointer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static boolean glIsProgramNV(int id) { + final var ext = getExtCapabilities(); + try { + return (boolean) + check(ext.glIsProgramNV).invokeExact(id); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glLoadProgramNV(int target, int id, int len, @NativeType("const GLubyte *") MemorySegment program) { + final var ext = getExtCapabilities(); + try { + check(ext.glLoadProgramNV).invokeExact(target, id, len, program); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramParameter4dNV(int target, int index, double x, double y, double z, double w) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramParameter4dNV).invokeExact(target, index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramParameter4dvNV(int target, int index, @NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramParameter4dvNV).invokeExact(target, index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramParameter4fNV(int target, int index, float x, float y, float z, float w) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramParameter4fNV).invokeExact(target, index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramParameter4fvNV(int target, int index, @NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramParameter4fvNV).invokeExact(target, index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramParameters4dvNV(int target, int index, int count, @NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramParameters4dvNV).invokeExact(target, index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glProgramParameters4fvNV(int target, int index, int count, @NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glProgramParameters4fvNV).invokeExact(target, index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glRequestResidentProgramsNV(int n, @NativeType("const GLuint *") MemorySegment programs) { + final var ext = getExtCapabilities(); + try { + check(ext.glRequestResidentProgramsNV).invokeExact(n, programs); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glTrackMatrixNV(int target, int address, int matrix, int transform) { + final var ext = getExtCapabilities(); + try { + check(ext.glTrackMatrixNV).invokeExact(target, address, matrix, transform); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribPointerNV(int index, int fsize, int type, int stride, @NativeType("const void *") MemorySegment pointer) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribPointerNV).invokeExact(index, fsize, type, stride, pointer); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib1dNV(int index, double x) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib1dNV).invokeExact(index, x); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib1dvNV(int index, @NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib1dvNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib1fNV(int index, float x) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib1fNV).invokeExact(index, x); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib1fvNV(int index, @NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib1fvNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib1sNV(int index, short x) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib1sNV).invokeExact(index, x); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib1svNV(int index, @NativeType("const GLshort *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib1svNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib2dNV(int index, double x, double y) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib2dNV).invokeExact(index, x, y); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib2dvNV(int index, @NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib2dvNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib2fNV(int index, float x, float y) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib2fNV).invokeExact(index, x, y); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib2fvNV(int index, @NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib2fvNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib2sNV(int index, short x, short y) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib2sNV).invokeExact(index, x, y); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib2svNV(int index, @NativeType("const GLshort *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib2svNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib3dNV(int index, double x, double y, double z) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib3dNV).invokeExact(index, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib3dvNV(int index, @NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib3dvNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib3fNV(int index, float x, float y, float z) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib3fNV).invokeExact(index, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib3fvNV(int index, @NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib3fvNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib3sNV(int index, short x, short y, short z) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib3sNV).invokeExact(index, x, y, z); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib3svNV(int index, @NativeType("const GLshort *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib3svNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib4dNV(int index, double x, double y, double z, double w) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib4dNV).invokeExact(index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib4dvNV(int index, @NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib4dvNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib4fNV(int index, float x, float y, float z, float w) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib4fNV).invokeExact(index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib4fvNV(int index, @NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib4fvNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib4sNV(int index, short x, short y, short z, short w) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib4sNV).invokeExact(index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib4svNV(int index, @NativeType("const GLshort *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib4svNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib4ubNV(int index, byte x, byte y, byte z, byte w) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib4ubNV).invokeExact(index, x, y, z, w); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttrib4ubvNV(int index, @NativeType("const GLubyte *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttrib4ubvNV).invokeExact(index, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs1dvNV(int index, int count, @NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs1dvNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs1fvNV(int index, int count, @NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs1fvNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs1svNV(int index, int count, @NativeType("const GLshort *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs1svNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs2dvNV(int index, int count, @NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs2dvNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs2fvNV(int index, int count, @NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs2fvNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs2svNV(int index, int count, @NativeType("const GLshort *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs2svNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs3dvNV(int index, int count, @NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs3dvNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs3fvNV(int index, int count, @NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs3fvNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs3svNV(int index, int count, @NativeType("const GLshort *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs3svNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs4dvNV(int index, int count, @NativeType("const GLdouble *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs4dvNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs4fvNV(int index, int count, @NativeType("const GLfloat *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs4fvNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs4svNV(int index, int count, @NativeType("const GLshort *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs4svNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVertexAttribs4ubvNV(int index, int count, @NativeType("const GLubyte *") MemorySegment v) { + final var ext = getExtCapabilities(); + try { + check(ext.glVertexAttribs4ubvNV).invokeExact(index, count, v); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexProgram4.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexProgram4.java new file mode 100644 index 00000000..775ada27 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVertexProgram4.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.nv; + +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_NV_vertex_program4} + */ +public final class GLNVVertexProgram4 { + public static final int GL_VERTEX_ATTRIB_ARRAY_INTEGER_NV = 0x88FD; +} diff --git a/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVideoCapture.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVideoCapture.java new file mode 100644 index 00000000..5a46913e --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVVideoCapture.java @@ -0,0 +1,161 @@ +/* + * 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.nv; + +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_NV_video_capture} + */ +public final class GLNVVideoCapture { + public static final int GL_VIDEO_BUFFER_NV = 0x9020; + public static final int GL_VIDEO_BUFFER_BINDING_NV = 0x9021; + public static final int GL_FIELD_UPPER_NV = 0x9022; + public static final int GL_FIELD_LOWER_NV = 0x9023; + public static final int GL_NUM_VIDEO_CAPTURE_STREAMS_NV = 0x9024; + public static final int GL_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = 0x9025; + public static final int GL_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = 0x9026; + public static final int GL_LAST_VIDEO_CAPTURE_STATUS_NV = 0x9027; + public static final int GL_VIDEO_BUFFER_PITCH_NV = 0x9028; + public static final int GL_VIDEO_COLOR_CONVERSION_MATRIX_NV = 0x9029; + public static final int GL_VIDEO_COLOR_CONVERSION_MAX_NV = 0x902A; + public static final int GL_VIDEO_COLOR_CONVERSION_MIN_NV = 0x902B; + public static final int GL_VIDEO_COLOR_CONVERSION_OFFSET_NV = 0x902C; + public static final int GL_VIDEO_BUFFER_INTERNAL_FORMAT_NV = 0x902D; + public static final int GL_PARTIAL_SUCCESS_NV = 0x902E; + public static final int GL_SUCCESS_NV = 0x902F; + public static final int GL_FAILURE_NV = 0x9030; + public static final int GL_YCBYCR8_422_NV = 0x9031; + public static final int GL_YCBAYCR8A_4224_NV = 0x9032; + public static final int GL_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = 0x9033; + public static final int GL_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = 0x9034; + public static final int GL_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = 0x9035; + public static final int GL_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = 0x9036; + public static final int GL_Z4Y12Z4CB12Z4CR12_444_NV = 0x9037; + public static final int GL_VIDEO_CAPTURE_FRAME_WIDTH_NV = 0x9038; + public static final int GL_VIDEO_CAPTURE_FRAME_HEIGHT_NV = 0x9039; + public static final int GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = 0x903A; + public static final int GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = 0x903B; + public static final int GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = 0x903C; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_video_capture) return; + ext.glBeginVideoCaptureNV = load.invoke("glBeginVideoCaptureNV", ofVoid(JAVA_INT)); + ext.glBindVideoCaptureStreamBufferNV = load.invoke("glBindVideoCaptureStreamBufferNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_LONG)); + ext.glBindVideoCaptureStreamTextureNV = load.invoke("glBindVideoCaptureStreamTextureNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + ext.glEndVideoCaptureNV = load.invoke("glEndVideoCaptureNV", ofVoid(JAVA_INT)); + ext.glGetVideoCaptureivNV = load.invoke("glGetVideoCaptureivNV", ofVoid(JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetVideoCaptureStreamivNV = load.invoke("glGetVideoCaptureStreamivNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetVideoCaptureStreamfvNV = load.invoke("glGetVideoCaptureStreamfvNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glGetVideoCaptureStreamdvNV = load.invoke("glGetVideoCaptureStreamdvNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVideoCaptureNV = load.invoke("glVideoCaptureNV", of(JAVA_INT, JAVA_INT, ADDRESS, ADDRESS)); + ext.glVideoCaptureStreamParameterivNV = load.invoke("glVideoCaptureStreamParameterivNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVideoCaptureStreamParameterfvNV = load.invoke("glVideoCaptureStreamParameterfvNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + ext.glVideoCaptureStreamParameterdvNV = load.invoke("glVideoCaptureStreamParameterdvNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, ADDRESS)); + } + + public static void glBeginVideoCaptureNV(int video_capture_slot) { + final var ext = getExtCapabilities(); + try { + check(ext.glBeginVideoCaptureNV).invokeExact(video_capture_slot); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBindVideoCaptureStreamBufferNV(int video_capture_slot, int stream, int frame_region, long offset) { + final var ext = getExtCapabilities(); + try { + check(ext.glBindVideoCaptureStreamBufferNV).invokeExact(video_capture_slot, stream, frame_region, offset); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glBindVideoCaptureStreamTextureNV(int video_capture_slot, int stream, int frame_region, int target, int texture) { + final var ext = getExtCapabilities(); + try { + check(ext.glBindVideoCaptureStreamTextureNV).invokeExact(video_capture_slot, stream, frame_region, target, texture); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glEndVideoCaptureNV(int video_capture_slot) { + final var ext = getExtCapabilities(); + try { + check(ext.glEndVideoCaptureNV).invokeExact(video_capture_slot); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVideoCaptureivNV(int video_capture_slot, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVideoCaptureivNV).invokeExact(video_capture_slot, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVideoCaptureStreamivNV(int video_capture_slot, int stream, int pname, @NativeType("GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVideoCaptureStreamivNV).invokeExact(video_capture_slot, stream, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVideoCaptureStreamfvNV(int video_capture_slot, int stream, int pname, @NativeType("GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVideoCaptureStreamfvNV).invokeExact(video_capture_slot, stream, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glGetVideoCaptureStreamdvNV(int video_capture_slot, int stream, int pname, @NativeType("GLdouble *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glGetVideoCaptureStreamdvNV).invokeExact(video_capture_slot, stream, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static int glVideoCaptureNV(int video_capture_slot, @NativeType("GLuint *") MemorySegment sequence_num, @NativeType("GLuint64EXT *") MemorySegment capture_time) { + final var ext = getExtCapabilities(); + try { + return (int) + check(ext.glVideoCaptureNV).invokeExact(video_capture_slot, sequence_num, capture_time); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVideoCaptureStreamParameterivNV(int video_capture_slot, int stream, int pname, @NativeType("const GLint *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glVideoCaptureStreamParameterivNV).invokeExact(video_capture_slot, stream, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVideoCaptureStreamParameterfvNV(int video_capture_slot, int stream, int pname, @NativeType("const GLfloat *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glVideoCaptureStreamParameterfvNV).invokeExact(video_capture_slot, stream, pname, params); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + + public static void glVideoCaptureStreamParameterdvNV(int video_capture_slot, int stream, int pname, @NativeType("const GLdouble *") MemorySegment params) { + final var ext = getExtCapabilities(); + try { + check(ext.glVideoCaptureStreamParameterdvNV).invokeExact(video_capture_slot, stream, 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/nv/GLNVViewportSwizzle.java b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVViewportSwizzle.java new file mode 100644 index 00000000..c3b1a994 --- /dev/null +++ b/modules/overrungl.opengl/src/main/java/overrungl/opengl/ext/nv/GLNVViewportSwizzle.java @@ -0,0 +1,55 @@ +/* + * 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.nv; + +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_NV_viewport_swizzle} + */ +public final class GLNVViewportSwizzle { + public static final int GL_VIEWPORT_SWIZZLE_POSITIVE_X_NV = 0x9350; + public static final int GL_VIEWPORT_SWIZZLE_NEGATIVE_X_NV = 0x9351; + public static final int GL_VIEWPORT_SWIZZLE_POSITIVE_Y_NV = 0x9352; + public static final int GL_VIEWPORT_SWIZZLE_NEGATIVE_Y_NV = 0x9353; + public static final int GL_VIEWPORT_SWIZZLE_POSITIVE_Z_NV = 0x9354; + public static final int GL_VIEWPORT_SWIZZLE_NEGATIVE_Z_NV = 0x9355; + public static final int GL_VIEWPORT_SWIZZLE_POSITIVE_W_NV = 0x9356; + public static final int GL_VIEWPORT_SWIZZLE_NEGATIVE_W_NV = 0x9357; + public static final int GL_VIEWPORT_SWIZZLE_X_NV = 0x9358; + public static final int GL_VIEWPORT_SWIZZLE_Y_NV = 0x9359; + public static final int GL_VIEWPORT_SWIZZLE_Z_NV = 0x935A; + public static final int GL_VIEWPORT_SWIZZLE_W_NV = 0x935B; + public static void load(GLExtCaps ext, GLLoadFunc load) { + if (!ext.GL_NV_viewport_swizzle) return; + ext.glViewportSwizzleNV = load.invoke("glViewportSwizzleNV", ofVoid(JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT, JAVA_INT)); + } + + public static void glViewportSwizzleNV(int index, int swizzlex, int swizzley, int swizzlez, int swizzlew) { + final var ext = getExtCapabilities(); + try { + check(ext.glViewportSwizzleNV).invokeExact(index, swizzlex, swizzley, swizzlez, swizzlew); + } catch (Throwable e) { throw new AssertionError("should not reach here", e); } + } + +}