diff --git a/src/generated/org/lwjgl/opengl/ContextCapabilities.java b/src/generated/org/lwjgl/opengl/ContextCapabilities.java index 030b3284..255b8ded 100644 --- a/src/generated/org/lwjgl/opengl/ContextCapabilities.java +++ b/src/generated/org/lwjgl/opengl/ContextCapabilities.java @@ -64,6 +64,7 @@ public class ContextCapabilities { public final boolean GL_ATI_vertex_streams; public final boolean GL_EXT_abgr; public final boolean GL_EXT_bgra; + public final boolean GL_EXT_bindable_uniform; public final boolean GL_EXT_blend_color; public final boolean GL_EXT_blend_equation_separate; public final boolean GL_EXT_blend_func_separate; @@ -72,14 +73,20 @@ public class ContextCapabilities { public final boolean GL_EXT_cg_shader; public final boolean GL_EXT_compiled_vertex_array; public final boolean GL_EXT_depth_bounds_test; + public final boolean GL_EXT_draw_buffers2; + public final boolean GL_EXT_draw_instanced; public final boolean GL_EXT_draw_range_elements; public final boolean GL_EXT_fog_coord; public final boolean GL_EXT_framebuffer_blit; public final boolean GL_EXT_framebuffer_multisample; public final boolean GL_EXT_framebuffer_object; + public final boolean GL_EXT_framebuffer_sRGB; + public final boolean GL_EXT_geometry_shader4; public final boolean GL_EXT_gpu_program_parameters; + public final boolean GL_EXT_gpu_shader4; public final boolean GL_EXT_multi_draw_arrays; public final boolean GL_EXT_packed_depth_stencil; + public final boolean GL_EXT_packed_float; public final boolean GL_EXT_packed_pixels; public final boolean GL_EXT_paletted_texture; public final boolean GL_EXT_pixel_buffer_object; @@ -93,14 +100,20 @@ public class ContextCapabilities { public final boolean GL_EXT_stencil_two_side; public final boolean GL_EXT_stencil_wrap; public final boolean GL_EXT_texture_3d; + public final boolean GL_EXT_texture_array; + public final boolean GL_EXT_texture_buffer_object; + public final boolean GL_EXT_texture_compression_latc; + public final boolean GL_EXT_texture_compression_rgtc; public final boolean GL_EXT_texture_compression_s3tc; public final boolean GL_EXT_texture_env_combine; public final boolean GL_EXT_texture_env_dot3; public final boolean GL_EXT_texture_filter_anisotropic; + public final boolean GL_EXT_texture_integer; public final boolean GL_EXT_texture_lod_bias; public final boolean GL_EXT_texture_mirror_clamp; public final boolean GL_EXT_texture_rectangle; public final boolean GL_EXT_texture_sRGB; + public final boolean GL_EXT_texture_shared_exponent; public final boolean GL_EXT_timer_query; public final boolean GL_EXT_vertex_shader; public final boolean GL_EXT_vertex_weighting; @@ -115,6 +128,7 @@ public class ContextCapabilities { public final boolean GL_IBM_rasterpos_clip; public final boolean GL_NV_blend_square; public final boolean GL_NV_copy_depth_to_color; + public final boolean GL_NV_depth_buffer_float; public final boolean GL_NV_depth_clamp; public final boolean GL_NV_evaluators; public final boolean GL_NV_fence; @@ -122,12 +136,17 @@ public class ContextCapabilities { public final boolean GL_NV_fog_distance; public final boolean GL_NV_fragment_program; public final boolean GL_NV_fragment_program2; + public final boolean GL_NV_fragment_program4; public final boolean GL_NV_fragment_program_option; + public final boolean GL_NV_framebuffer_multisample_coverage; + public final boolean GL_NV_geometry_program4; + public final boolean GL_NV_gpu_program4; public final boolean GL_NV_half_float; public final boolean GL_NV_light_max_exponent; public final boolean GL_NV_multisample_filter_hint; public final boolean GL_NV_occlusion_query; public final boolean GL_NV_packed_depth_stencil; + public final boolean GL_NV_parameter_buffer_object; public final boolean GL_NV_pixel_data_range; public final boolean GL_NV_point_sprite; public final boolean GL_NV_primitive_restart; @@ -141,6 +160,7 @@ public class ContextCapabilities { public final boolean GL_NV_texture_shader; public final boolean GL_NV_texture_shader2; public final boolean GL_NV_texture_shader3; + public final boolean GL_NV_transform_feeback; public final boolean GL_NV_vertex_array_range; public final boolean GL_NV_vertex_array_range2; public final boolean GL_NV_vertex_program; @@ -148,6 +168,7 @@ public class ContextCapabilities { public final boolean GL_NV_vertex_program2; public final boolean GL_NV_vertex_program2_option; public final boolean GL_NV_vertex_program3; + public final boolean GL_NV_vertex_program4; public final boolean GL_SGIS_generate_mipmap; public final boolean GL_SGIS_texture_lod; public final boolean GL_SUN_slice_accum; @@ -424,6 +445,9 @@ public class ContextCapabilities { long ATI_vertex_streams_glClientActiveVertexStreamATI_pointer; long ATI_vertex_streams_glVertexBlendEnvfATI_pointer; long ATI_vertex_streams_glVertexBlendEnviATI_pointer; + long EXT_bindable_uniform_glUniformBufferEXT_pointer; + long EXT_bindable_uniform_glGetUniformBufferSizeEXT_pointer; + long EXT_bindable_uniform_glGetUniformOffsetEXT_pointer; long EXT_blend_color_glBlendColorEXT_pointer; long EXT_blend_equation_separate_glBlendEquationSeparateEXT_pointer; long EXT_blend_func_separate_glBlendFuncSeparateEXT_pointer; @@ -431,6 +455,14 @@ public class ContextCapabilities { long EXT_compiled_vertex_array_glLockArraysEXT_pointer; long EXT_compiled_vertex_array_glUnlockArraysEXT_pointer; long EXT_depth_bounds_test_glDepthBoundsEXT_pointer; + long EXT_draw_buffers2_glColorMaskIndexedEXT_pointer; + long EXT_draw_buffers2_glGetBooleanIndexedvEXT_pointer; + long EXT_draw_buffers2_glGetIntegerIndexedvEXT_pointer; + long EXT_draw_buffers2_glEnableIndexedEXT_pointer; + long EXT_draw_buffers2_glDisableIndexedEXT_pointer; + long EXT_draw_buffers2_glIsEnabledIndexedEXT_pointer; + long EXT_draw_instanced_glDrawArraysInstancedEXT_pointer; + long EXT_draw_instanced_glDrawElementsInstancedEXT_pointer; long EXT_draw_range_elements_glDrawRangeElementsEXT_pointer; long EXT_fog_coord_glFogCoordfEXT_pointer; long EXT_fog_coord_glFogCoorddEXT_pointer; @@ -454,8 +486,46 @@ public class ContextCapabilities { long EXT_framebuffer_object_glFramebufferRenderbufferEXT_pointer; long EXT_framebuffer_object_glGetFramebufferAttachmentParameterivEXT_pointer; long EXT_framebuffer_object_glGenerateMipmapEXT_pointer; + long EXT_geometry_shader4_glProgramParameteriEXT_pointer; + long EXT_geometry_shader4_glFramebufferTextureEXT_pointer; + long EXT_geometry_shader4_glFramebufferTextureLayerEXT_pointer; + long EXT_geometry_shader4_glFramebufferTextureFaceEXT_pointer; long EXT_gpu_program_parameters_glProgramEnvParameter4fvEXT_pointer; long EXT_gpu_program_parameters_glProgramLocalParameter4fvEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI1iEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI2iEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI3iEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI4iEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI1uiEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI2uiEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI3uiEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI4uiEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI1ivEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI2ivEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI3ivEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI4ivEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI1uivEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI2uivEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI3uivEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI4uivEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI4bvEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI4svEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI4ubvEXT_pointer; + long EXT_gpu_shader4_glVertexAttribI4usvEXT_pointer; + long EXT_gpu_shader4_glVertexAttribIPointerEXT_pointer; + long EXT_gpu_shader4_glGetVertexAttribIivEXT_pointer; + long EXT_gpu_shader4_glGetVertexAttribIuivEXT_pointer; + long EXT_gpu_shader4_glUniform1uiEXT_pointer; + long EXT_gpu_shader4_glUniform2uiEXT_pointer; + long EXT_gpu_shader4_glUniform3uiEXT_pointer; + long EXT_gpu_shader4_glUniform4uiEXT_pointer; + long EXT_gpu_shader4_glUniform1uivEXT_pointer; + long EXT_gpu_shader4_glUniform2uivEXT_pointer; + long EXT_gpu_shader4_glUniform3uivEXT_pointer; + long EXT_gpu_shader4_glUniform4uivEXT_pointer; + long EXT_gpu_shader4_glGetUniformuivEXT_pointer; + long EXT_gpu_shader4_glBindFragDataLocationEXT_pointer; + long EXT_gpu_shader4_glGetFragDataLocationEXT_pointer; long EXT_multi_draw_arrays_glMultiDrawArraysEXT_pointer; long EXT_paletted_texture_glColorTableEXT_pointer; long EXT_paletted_texture_glColorSubTableEXT_pointer; @@ -471,6 +541,14 @@ public class ContextCapabilities { long EXT_secondary_color_glSecondaryColorPointerEXT_pointer; long EXT_stencil_clear_tag_glStencilClearTagEXT_pointer; long EXT_stencil_two_side_glActiveStencilFaceEXT_pointer; + long EXT_texture_array_glFramebufferTextureLayerEXT_pointer; + long EXT_texture_buffer_object_glTexBufferEXT_pointer; + long EXT_texture_integer_glClearColorIiEXT_pointer; + long EXT_texture_integer_glClearColorIuiEXT_pointer; + long EXT_texture_integer_glTexParameterIivEXT_pointer; + long EXT_texture_integer_glTexParameterIuivEXT_pointer; + long EXT_texture_integer_glGetTexParameterIivEXT_pointer; + long EXT_texture_integer_glGetTexParameterIuivEXT_pointer; long EXT_timer_query_glGetQueryObjecti64vEXT_pointer; long EXT_timer_query_glGetQueryObjectui64vEXT_pointer; long EXT_vertex_shader_glBeginVertexShaderEXT_pointer; @@ -888,6 +966,9 @@ public class ContextCapabilities { long GL21_glUniformMatrix4x2fv_pointer; long GL21_glUniformMatrix3x4fv_pointer; long GL21_glUniformMatrix4x3fv_pointer; + long NV_depth_buffer_float_glDepthRangedNV_pointer; + long NV_depth_buffer_float_glClearDepthdNV_pointer; + long NV_depth_buffer_float_glDepthBoundsdNV_pointer; long NV_evaluators_glGetMapControlPointsNV_pointer; long NV_evaluators_glMapControlPointsNV_pointer; long NV_evaluators_glMapParameterfvNV_pointer; @@ -908,6 +989,26 @@ public class ContextCapabilities { long NV_fragment_program_glProgramNamedParameter4dNV_pointer; long NV_fragment_program_glGetProgramNamedParameterfvNV_pointer; long NV_fragment_program_glGetProgramNamedParameterdvNV_pointer; + long NV_framebuffer_multisample_coverage_glRenderbufferStorageMultsampleCoverageNV_pointer; + long NV_geometry_program4_glProgramVertexLimitNV_pointer; + long NV_geometry_program4_glFramebufferTextureEXT_pointer; + long NV_geometry_program4_glFramebufferTextureLayerEXT_pointer; + long NV_gpu_program4_glProgramLocalParameterI4iNV_pointer; + long NV_gpu_program4_glProgramLocalParameterI4ivNV_pointer; + long NV_gpu_program4_glProgramLocalParametersI4ivNV_pointer; + long NV_gpu_program4_glProgramLocalParameterI4uiNV_pointer; + long NV_gpu_program4_glProgramLocalParameterI4uivNV_pointer; + long NV_gpu_program4_glProgramLocalParametersI4uivNV_pointer; + long NV_gpu_program4_glProgramEnvParameterI4iNV_pointer; + long NV_gpu_program4_glProgramEnvParameterI4ivNV_pointer; + long NV_gpu_program4_glProgramEnvParametersI4ivNV_pointer; + long NV_gpu_program4_glProgramEnvParameterI4uiNV_pointer; + long NV_gpu_program4_glProgramEnvParameterI4uivNV_pointer; + long NV_gpu_program4_glProgramEnvParametersI4uivNV_pointer; + long NV_gpu_program4_glGetProgramLocalParameterIivNV_pointer; + long NV_gpu_program4_glGetProgramLocalParameterIuivNV_pointer; + long NV_gpu_program4_glGetProgramEnvParameterIivNV_pointer; + long NV_gpu_program4_glGetProgramEnvParameterIuivNV_pointer; long NV_half_float_glVertex2hNV_pointer; long NV_half_float_glVertex3hNV_pointer; long NV_half_float_glVertex4hNV_pointer; @@ -939,6 +1040,12 @@ public class ContextCapabilities { long NV_occlusion_query_glEndOcclusionQueryNV_pointer; long NV_occlusion_query_glGetOcclusionQueryuivNV_pointer; long NV_occlusion_query_glGetOcclusionQueryivNV_pointer; + long NV_parameter_buffer_object_glBindBufferRangeNV_pointer; + long NV_parameter_buffer_object_glBindBufferOffsetNV_pointer; + long NV_parameter_buffer_object_glBindBufferBaseNV_pointer; + long NV_parameter_buffer_object_glProgramBufferParametersfvNV_pointer; + long NV_parameter_buffer_object_glProgramBufferParametersIivNV_pointer; + long NV_parameter_buffer_object_glProgramBufferParametersIuivNV_pointer; long NV_pixel_data_range_glPixelDataRangeNV_pointer; long NV_pixel_data_range_glFlushPixelDataRangeNV_pointer; long NV_point_sprite_glPointParameteriNV_pointer; @@ -969,6 +1076,17 @@ public class ContextCapabilities { long NV_register_combiners_glGetFinalCombinerInputParameterivNV_pointer; long NV_register_combiners2_glCombinerStageParameterfvNV_pointer; long NV_register_combiners2_glGetCombinerStageParameterfvNV_pointer; + long NV_transform_feeback_glBindBufferRangeNV_pointer; + long NV_transform_feeback_glBindBufferOffsetNV_pointer; + long NV_transform_feeback_glBindBufferBaseNV_pointer; + long NV_transform_feeback_glTransformFeedbackAttribsNV_pointer; + long NV_transform_feeback_glTransformFeedbackVaryingsNV_pointer; + long NV_transform_feeback_glBeginTransformFeedbackNV_pointer; + long NV_transform_feeback_glEndTransformFeedbackNV_pointer; + long NV_transform_feeback_glGetVaryingLocationNV_pointer; + long NV_transform_feeback_glGetActiveVaryingNV_pointer; + long NV_transform_feeback_glActiveVaryingNV_pointer; + long NV_transform_feeback_glGetTransformFeedbackVaryingNV_pointer; long NV_vertex_array_range_glVertexArrayRangeNV_pointer; long NV_vertex_array_range_glFlushVertexArrayRangeNV_pointer; long NV_vertex_array_range_glAllocateMemoryNV_pointer; @@ -1393,6 +1511,13 @@ public class ContextCapabilities { (ATI_vertex_streams_glVertexBlendEnviATI_pointer = GLContext.getFunctionAddress("glVertexBlendEnviATI")) != 0; } + private boolean EXT_bindable_uniform_initNativeFunctionAddresses() { + return + (EXT_bindable_uniform_glUniformBufferEXT_pointer = GLContext.getFunctionAddress("glUniformBufferEXT")) != 0 && + (EXT_bindable_uniform_glGetUniformBufferSizeEXT_pointer = GLContext.getFunctionAddress("glGetUniformBufferSizeEXT")) != 0 && + (EXT_bindable_uniform_glGetUniformOffsetEXT_pointer = GLContext.getFunctionAddress("glGetUniformOffsetEXT")) != 0; + } + private boolean EXT_blend_color_initNativeFunctionAddresses() { return (EXT_blend_color_glBlendColorEXT_pointer = GLContext.getFunctionAddress("glBlendColorEXT")) != 0; @@ -1424,6 +1549,22 @@ public class ContextCapabilities { (EXT_depth_bounds_test_glDepthBoundsEXT_pointer = GLContext.getFunctionAddress("glDepthBoundsEXT")) != 0; } + private boolean EXT_draw_buffers2_initNativeFunctionAddresses() { + return + (EXT_draw_buffers2_glColorMaskIndexedEXT_pointer = GLContext.getFunctionAddress("glColorMaskIndexedEXT")) != 0 && + (EXT_draw_buffers2_glGetBooleanIndexedvEXT_pointer = GLContext.getFunctionAddress("glGetBooleanIndexedvEXT")) != 0 && + (EXT_draw_buffers2_glGetIntegerIndexedvEXT_pointer = GLContext.getFunctionAddress("glGetIntegerIndexedvEXT")) != 0 && + (EXT_draw_buffers2_glEnableIndexedEXT_pointer = GLContext.getFunctionAddress("glEnableIndexedEXT")) != 0 && + (EXT_draw_buffers2_glDisableIndexedEXT_pointer = GLContext.getFunctionAddress("glDisableIndexedEXT")) != 0 && + (EXT_draw_buffers2_glIsEnabledIndexedEXT_pointer = GLContext.getFunctionAddress("glIsEnabledIndexedEXT")) != 0; + } + + private boolean EXT_draw_instanced_initNativeFunctionAddresses() { + return + (EXT_draw_instanced_glDrawArraysInstancedEXT_pointer = GLContext.getFunctionAddress("glDrawArraysInstancedEXT")) != 0 && + (EXT_draw_instanced_glDrawElementsInstancedEXT_pointer = GLContext.getFunctionAddress("glDrawElementsInstancedEXT")) != 0; + } + private boolean EXT_draw_range_elements_initNativeFunctionAddresses() { return (EXT_draw_range_elements_glDrawRangeElementsEXT_pointer = GLContext.getFunctionAddress("glDrawRangeElementsEXT")) != 0; @@ -1467,12 +1608,58 @@ public class ContextCapabilities { (EXT_framebuffer_object_glGenerateMipmapEXT_pointer = GLContext.getFunctionAddress("glGenerateMipmapEXT")) != 0; } + private boolean EXT_geometry_shader4_initNativeFunctionAddresses() { + return + (EXT_geometry_shader4_glProgramParameteriEXT_pointer = GLContext.getFunctionAddress("glProgramParameteriEXT")) != 0 && + (EXT_geometry_shader4_glFramebufferTextureEXT_pointer = GLContext.getFunctionAddress("glFramebufferTextureEXT")) != 0 && + (EXT_geometry_shader4_glFramebufferTextureLayerEXT_pointer = GLContext.getFunctionAddress("glFramebufferTextureLayerEXT")) != 0 && + (EXT_geometry_shader4_glFramebufferTextureFaceEXT_pointer = GLContext.getFunctionAddress("glFramebufferTextureFaceEXT")) != 0; + } + private boolean EXT_gpu_program_parameters_initNativeFunctionAddresses() { return (EXT_gpu_program_parameters_glProgramEnvParameter4fvEXT_pointer = GLContext.getFunctionAddress("glProgramEnvParameter4fvEXT")) != 0 && (EXT_gpu_program_parameters_glProgramLocalParameter4fvEXT_pointer = GLContext.getFunctionAddress("glProgramLocalParameter4fvEXT")) != 0; } + private boolean EXT_gpu_shader4_initNativeFunctionAddresses() { + return + (EXT_gpu_shader4_glVertexAttribI1iEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI1iEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI2iEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI2iEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI3iEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI3iEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI4iEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI4iEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI1uiEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI1uiEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI2uiEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI2uiEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI3uiEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI3uiEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI4uiEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI4uiEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI1ivEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI1ivEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI2ivEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI2ivEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI3ivEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI3ivEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI4ivEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI4ivEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI1uivEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI1uivEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI2uivEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI2uivEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI3uivEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI3uivEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI4uivEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI4uivEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI4bvEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI4bvEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI4svEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI4svEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI4ubvEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI4ubvEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribI4usvEXT_pointer = GLContext.getFunctionAddress("glVertexAttribI4usvEXT")) != 0 && + (EXT_gpu_shader4_glVertexAttribIPointerEXT_pointer = GLContext.getFunctionAddress("glVertexAttribIPointerEXT")) != 0 && + (EXT_gpu_shader4_glGetVertexAttribIivEXT_pointer = GLContext.getFunctionAddress("glGetVertexAttribIivEXT")) != 0 && + (EXT_gpu_shader4_glGetVertexAttribIuivEXT_pointer = GLContext.getFunctionAddress("glGetVertexAttribIuivEXT")) != 0 && + (EXT_gpu_shader4_glUniform1uiEXT_pointer = GLContext.getFunctionAddress("glUniform1uiEXT")) != 0 && + (EXT_gpu_shader4_glUniform2uiEXT_pointer = GLContext.getFunctionAddress("glUniform2uiEXT")) != 0 && + (EXT_gpu_shader4_glUniform3uiEXT_pointer = GLContext.getFunctionAddress("glUniform3uiEXT")) != 0 && + (EXT_gpu_shader4_glUniform4uiEXT_pointer = GLContext.getFunctionAddress("glUniform4uiEXT")) != 0 && + (EXT_gpu_shader4_glUniform1uivEXT_pointer = GLContext.getFunctionAddress("glUniform1uivEXT")) != 0 && + (EXT_gpu_shader4_glUniform2uivEXT_pointer = GLContext.getFunctionAddress("glUniform2uivEXT")) != 0 && + (EXT_gpu_shader4_glUniform3uivEXT_pointer = GLContext.getFunctionAddress("glUniform3uivEXT")) != 0 && + (EXT_gpu_shader4_glUniform4uivEXT_pointer = GLContext.getFunctionAddress("glUniform4uivEXT")) != 0 && + (EXT_gpu_shader4_glGetUniformuivEXT_pointer = GLContext.getFunctionAddress("glGetUniformuivEXT")) != 0 && + (EXT_gpu_shader4_glBindFragDataLocationEXT_pointer = GLContext.getFunctionAddress("glBindFragDataLocationEXT")) != 0 && + (EXT_gpu_shader4_glGetFragDataLocationEXT_pointer = GLContext.getFunctionAddress("glGetFragDataLocationEXT")) != 0; + } + private boolean EXT_multi_draw_arrays_initNativeFunctionAddresses() { return (EXT_multi_draw_arrays_glMultiDrawArraysEXT_pointer = GLContext.getFunctionAddress("glMultiDrawArraysEXT")) != 0; @@ -1512,6 +1699,26 @@ public class ContextCapabilities { (EXT_stencil_two_side_glActiveStencilFaceEXT_pointer = GLContext.getFunctionAddress("glActiveStencilFaceEXT")) != 0; } + private boolean EXT_texture_array_initNativeFunctionAddresses() { + return + (EXT_texture_array_glFramebufferTextureLayerEXT_pointer = GLContext.getFunctionAddress("glFramebufferTextureLayerEXT")) != 0; + } + + private boolean EXT_texture_buffer_object_initNativeFunctionAddresses() { + return + (EXT_texture_buffer_object_glTexBufferEXT_pointer = GLContext.getFunctionAddress("glTexBufferEXT")) != 0; + } + + private boolean EXT_texture_integer_initNativeFunctionAddresses() { + return + (EXT_texture_integer_glClearColorIiEXT_pointer = GLContext.getFunctionAddress("glClearColorIiEXT")) != 0 && + (EXT_texture_integer_glClearColorIuiEXT_pointer = GLContext.getFunctionAddress("glClearColorIuiEXT")) != 0 && + (EXT_texture_integer_glTexParameterIivEXT_pointer = GLContext.getFunctionAddress("glTexParameterIivEXT")) != 0 && + (EXT_texture_integer_glTexParameterIuivEXT_pointer = GLContext.getFunctionAddress("glTexParameterIuivEXT")) != 0 && + (EXT_texture_integer_glGetTexParameterIivEXT_pointer = GLContext.getFunctionAddress("glGetTexParameterIivEXT")) != 0 && + (EXT_texture_integer_glGetTexParameterIuivEXT_pointer = GLContext.getFunctionAddress("glGetTexParameterIuivEXT")) != 0; + } + private boolean EXT_timer_query_initNativeFunctionAddresses() { return (EXT_timer_query_glGetQueryObjecti64vEXT_pointer = GLContext.getFunctionAddress("glGetQueryObjecti64vEXT")) != 0 && @@ -1969,6 +2176,13 @@ public class ContextCapabilities { (GL21_glUniformMatrix4x3fv_pointer = GLContext.getFunctionAddress("glUniformMatrix4x3fv")) != 0; } + private boolean NV_depth_buffer_float_initNativeFunctionAddresses() { + return + (NV_depth_buffer_float_glDepthRangedNV_pointer = GLContext.getFunctionAddress("glDepthRangedNV")) != 0 && + (NV_depth_buffer_float_glClearDepthdNV_pointer = GLContext.getFunctionAddress("glClearDepthdNV")) != 0 && + (NV_depth_buffer_float_glDepthBoundsdNV_pointer = GLContext.getFunctionAddress("glDepthBoundsdNV")) != 0; + } + private boolean NV_evaluators_initNativeFunctionAddresses() { return (NV_evaluators_glGetMapControlPointsNV_pointer = GLContext.getFunctionAddress("glGetMapControlPointsNV")) != 0 && @@ -2001,6 +2215,38 @@ public class ContextCapabilities { (NV_fragment_program_glGetProgramNamedParameterdvNV_pointer = GLContext.getFunctionAddress("glGetProgramNamedParameterdvNV")) != 0; } + private boolean NV_framebuffer_multisample_coverage_initNativeFunctionAddresses() { + return + (NV_framebuffer_multisample_coverage_glRenderbufferStorageMultsampleCoverageNV_pointer = GLContext.getFunctionAddress("glRenderbufferStorageMultsampleCoverageNV")) != 0; + } + + private boolean NV_geometry_program4_initNativeFunctionAddresses() { + return + (NV_geometry_program4_glProgramVertexLimitNV_pointer = GLContext.getFunctionAddress("glProgramVertexLimitNV")) != 0 && + (NV_geometry_program4_glFramebufferTextureEXT_pointer = GLContext.getFunctionAddress("glFramebufferTextureEXT")) != 0 && + (NV_geometry_program4_glFramebufferTextureLayerEXT_pointer = GLContext.getFunctionAddress("glFramebufferTextureLayerEXT")) != 0; + } + + private boolean NV_gpu_program4_initNativeFunctionAddresses() { + return + (NV_gpu_program4_glProgramLocalParameterI4iNV_pointer = GLContext.getFunctionAddress("glProgramLocalParameterI4iNV")) != 0 && + (NV_gpu_program4_glProgramLocalParameterI4ivNV_pointer = GLContext.getFunctionAddress("glProgramLocalParameterI4ivNV")) != 0 && + (NV_gpu_program4_glProgramLocalParametersI4ivNV_pointer = GLContext.getFunctionAddress("glProgramLocalParametersI4ivNV")) != 0 && + (NV_gpu_program4_glProgramLocalParameterI4uiNV_pointer = GLContext.getFunctionAddress("glProgramLocalParameterI4uiNV")) != 0 && + (NV_gpu_program4_glProgramLocalParameterI4uivNV_pointer = GLContext.getFunctionAddress("glProgramLocalParameterI4uivNV")) != 0 && + (NV_gpu_program4_glProgramLocalParametersI4uivNV_pointer = GLContext.getFunctionAddress("glProgramLocalParametersI4uivNV")) != 0 && + (NV_gpu_program4_glProgramEnvParameterI4iNV_pointer = GLContext.getFunctionAddress("glProgramEnvParameterI4iNV")) != 0 && + (NV_gpu_program4_glProgramEnvParameterI4ivNV_pointer = GLContext.getFunctionAddress("glProgramEnvParameterI4ivNV")) != 0 && + (NV_gpu_program4_glProgramEnvParametersI4ivNV_pointer = GLContext.getFunctionAddress("glProgramEnvParametersI4ivNV")) != 0 && + (NV_gpu_program4_glProgramEnvParameterI4uiNV_pointer = GLContext.getFunctionAddress("glProgramEnvParameterI4uiNV")) != 0 && + (NV_gpu_program4_glProgramEnvParameterI4uivNV_pointer = GLContext.getFunctionAddress("glProgramEnvParameterI4uivNV")) != 0 && + (NV_gpu_program4_glProgramEnvParametersI4uivNV_pointer = GLContext.getFunctionAddress("glProgramEnvParametersI4uivNV")) != 0 && + (NV_gpu_program4_glGetProgramLocalParameterIivNV_pointer = GLContext.getFunctionAddress("glGetProgramLocalParameterIivNV")) != 0 && + (NV_gpu_program4_glGetProgramLocalParameterIuivNV_pointer = GLContext.getFunctionAddress("glGetProgramLocalParameterIuivNV")) != 0 && + (NV_gpu_program4_glGetProgramEnvParameterIivNV_pointer = GLContext.getFunctionAddress("glGetProgramEnvParameterIivNV")) != 0 && + (NV_gpu_program4_glGetProgramEnvParameterIuivNV_pointer = GLContext.getFunctionAddress("glGetProgramEnvParameterIuivNV")) != 0; + } + private boolean NV_half_float_initNativeFunctionAddresses() { return (NV_half_float_glVertex2hNV_pointer = GLContext.getFunctionAddress("glVertex2hNV")) != 0 && @@ -2040,6 +2286,16 @@ public class ContextCapabilities { (NV_occlusion_query_glGetOcclusionQueryivNV_pointer = GLContext.getFunctionAddress("glGetOcclusionQueryivNV")) != 0; } + private boolean NV_parameter_buffer_object_initNativeFunctionAddresses() { + return + (NV_parameter_buffer_object_glBindBufferRangeNV_pointer = GLContext.getFunctionAddress("glBindBufferRangeNV")) != 0 && + (NV_parameter_buffer_object_glBindBufferOffsetNV_pointer = GLContext.getFunctionAddress("glBindBufferOffsetNV")) != 0 && + (NV_parameter_buffer_object_glBindBufferBaseNV_pointer = GLContext.getFunctionAddress("glBindBufferBaseNV")) != 0 && + (NV_parameter_buffer_object_glProgramBufferParametersfvNV_pointer = GLContext.getFunctionAddress("glProgramBufferParametersfvNV")) != 0 && + (NV_parameter_buffer_object_glProgramBufferParametersIivNV_pointer = GLContext.getFunctionAddress("glProgramBufferParametersIivNV")) != 0 && + (NV_parameter_buffer_object_glProgramBufferParametersIuivNV_pointer = GLContext.getFunctionAddress("glProgramBufferParametersIuivNV")) != 0; + } + private boolean NV_pixel_data_range_initNativeFunctionAddresses() { return (NV_pixel_data_range_glPixelDataRangeNV_pointer = GLContext.getFunctionAddress("glPixelDataRangeNV")) != 0 && @@ -2094,6 +2350,21 @@ public class ContextCapabilities { (NV_register_combiners2_glGetCombinerStageParameterfvNV_pointer = GLContext.getFunctionAddress("glGetCombinerStageParameterfvNV")) != 0; } + private boolean NV_transform_feeback_initNativeFunctionAddresses() { + return + (NV_transform_feeback_glBindBufferRangeNV_pointer = GLContext.getFunctionAddress("glBindBufferRangeNV")) != 0 && + (NV_transform_feeback_glBindBufferOffsetNV_pointer = GLContext.getFunctionAddress("glBindBufferOffsetNV")) != 0 && + (NV_transform_feeback_glBindBufferBaseNV_pointer = GLContext.getFunctionAddress("glBindBufferBaseNV")) != 0 && + (NV_transform_feeback_glTransformFeedbackAttribsNV_pointer = GLContext.getFunctionAddress("glTransformFeedbackAttribsNV")) != 0 && + (NV_transform_feeback_glTransformFeedbackVaryingsNV_pointer = GLContext.getFunctionAddress("glTransformFeedbackVaryingsNV")) != 0 && + (NV_transform_feeback_glBeginTransformFeedbackNV_pointer = GLContext.getFunctionAddress("glBeginTransformFeedbackNV")) != 0 && + (NV_transform_feeback_glEndTransformFeedbackNV_pointer = GLContext.getFunctionAddress("glEndTransformFeedbackNV")) != 0 && + (NV_transform_feeback_glGetVaryingLocationNV_pointer = GLContext.getFunctionAddress("glGetVaryingLocationNV")) != 0 && + (NV_transform_feeback_glGetActiveVaryingNV_pointer = GLContext.getFunctionAddress("glGetActiveVaryingNV")) != 0 && + (NV_transform_feeback_glActiveVaryingNV_pointer = GLContext.getFunctionAddress("glActiveVaryingNV")) != 0 && + (NV_transform_feeback_glGetTransformFeedbackVaryingNV_pointer = GLContext.getFunctionAddress("glGetTransformFeedbackVaryingNV")) != 0; + } + private boolean NV_vertex_array_range_initNativeFunctionAddresses() { return (NV_vertex_array_range_glVertexArrayRangeNV_pointer = GLContext.getFunctionAddress("glVertexArrayRangeNV")) != 0 && @@ -2219,6 +2490,8 @@ public class ContextCapabilities { supported_extensions.remove("GL_ATI_vertex_attrib_array_object"); if (supported_extensions.contains("GL_ATI_vertex_streams") && !ATI_vertex_streams_initNativeFunctionAddresses()) supported_extensions.remove("GL_ATI_vertex_streams"); + if (supported_extensions.contains("GL_EXT_bindable_uniform") && !EXT_bindable_uniform_initNativeFunctionAddresses()) + supported_extensions.remove("GL_EXT_bindable_uniform"); if (supported_extensions.contains("GL_EXT_blend_color") && !EXT_blend_color_initNativeFunctionAddresses()) supported_extensions.remove("GL_EXT_blend_color"); if (supported_extensions.contains("GL_EXT_blend_equation_separate") && !EXT_blend_equation_separate_initNativeFunctionAddresses()) @@ -2231,6 +2504,10 @@ public class ContextCapabilities { supported_extensions.remove("GL_EXT_compiled_vertex_array"); if (supported_extensions.contains("GL_EXT_depth_bounds_test") && !EXT_depth_bounds_test_initNativeFunctionAddresses()) supported_extensions.remove("GL_EXT_depth_bounds_test"); + if (supported_extensions.contains("GL_EXT_draw_buffers2") && !EXT_draw_buffers2_initNativeFunctionAddresses()) + supported_extensions.remove("GL_EXT_draw_buffers2"); + if (supported_extensions.contains("GL_EXT_draw_instanced") && !EXT_draw_instanced_initNativeFunctionAddresses()) + supported_extensions.remove("GL_EXT_draw_instanced"); if (supported_extensions.contains("GL_EXT_draw_range_elements") && !EXT_draw_range_elements_initNativeFunctionAddresses()) supported_extensions.remove("GL_EXT_draw_range_elements"); if (supported_extensions.contains("GL_EXT_fog_coord") && !EXT_fog_coord_initNativeFunctionAddresses()) @@ -2241,8 +2518,12 @@ public class ContextCapabilities { supported_extensions.remove("GL_EXT_framebuffer_multisample"); if (supported_extensions.contains("GL_EXT_framebuffer_object") && !EXT_framebuffer_object_initNativeFunctionAddresses()) supported_extensions.remove("GL_EXT_framebuffer_object"); + if (supported_extensions.contains("GL_EXT_geometry_shader4") && !EXT_geometry_shader4_initNativeFunctionAddresses()) + supported_extensions.remove("GL_EXT_geometry_shader4"); if (supported_extensions.contains("GL_EXT_gpu_program_parameters") && !EXT_gpu_program_parameters_initNativeFunctionAddresses()) supported_extensions.remove("GL_EXT_gpu_program_parameters"); + if (supported_extensions.contains("GL_EXT_gpu_shader4") && !EXT_gpu_shader4_initNativeFunctionAddresses()) + supported_extensions.remove("GL_EXT_gpu_shader4"); if (supported_extensions.contains("GL_EXT_multi_draw_arrays") && !EXT_multi_draw_arrays_initNativeFunctionAddresses()) supported_extensions.remove("GL_EXT_multi_draw_arrays"); if (supported_extensions.contains("GL_EXT_paletted_texture") && !EXT_paletted_texture_initNativeFunctionAddresses()) @@ -2255,6 +2536,12 @@ public class ContextCapabilities { supported_extensions.remove("GL_EXT_stencil_clear_tag"); if (supported_extensions.contains("GL_EXT_stencil_two_side") && !EXT_stencil_two_side_initNativeFunctionAddresses()) supported_extensions.remove("GL_EXT_stencil_two_side"); + if (supported_extensions.contains("GL_EXT_texture_array") && !EXT_texture_array_initNativeFunctionAddresses()) + supported_extensions.remove("GL_EXT_texture_array"); + if (supported_extensions.contains("GL_EXT_texture_buffer_object") && !EXT_texture_buffer_object_initNativeFunctionAddresses()) + supported_extensions.remove("GL_EXT_texture_buffer_object"); + if (supported_extensions.contains("GL_EXT_texture_integer") && !EXT_texture_integer_initNativeFunctionAddresses()) + supported_extensions.remove("GL_EXT_texture_integer"); if (supported_extensions.contains("GL_EXT_timer_query") && !EXT_timer_query_initNativeFunctionAddresses()) supported_extensions.remove("GL_EXT_timer_query"); if (supported_extensions.contains("GL_EXT_vertex_shader") && !EXT_vertex_shader_initNativeFunctionAddresses()) @@ -2273,16 +2560,26 @@ public class ContextCapabilities { supported_extensions.remove("OpenGL20"); if (supported_extensions.contains("OpenGL21") && !GL21_initNativeFunctionAddresses()) supported_extensions.remove("OpenGL21"); + if (supported_extensions.contains("GL_NV_depth_buffer_float") && !NV_depth_buffer_float_initNativeFunctionAddresses()) + supported_extensions.remove("GL_NV_depth_buffer_float"); if (supported_extensions.contains("GL_NV_evaluators") && !NV_evaluators_initNativeFunctionAddresses()) supported_extensions.remove("GL_NV_evaluators"); if (supported_extensions.contains("GL_NV_fence") && !NV_fence_initNativeFunctionAddresses()) supported_extensions.remove("GL_NV_fence"); if (supported_extensions.contains("GL_NV_fragment_program") && !NV_fragment_program_initNativeFunctionAddresses()) supported_extensions.remove("GL_NV_fragment_program"); + if (supported_extensions.contains("GL_NV_framebuffer_multisample_coverage") && !NV_framebuffer_multisample_coverage_initNativeFunctionAddresses()) + supported_extensions.remove("GL_NV_framebuffer_multisample_coverage"); + if (supported_extensions.contains("GL_NV_geometry_program4") && !NV_geometry_program4_initNativeFunctionAddresses()) + supported_extensions.remove("GL_NV_geometry_program4"); + if (supported_extensions.contains("GL_NV_gpu_program4") && !NV_gpu_program4_initNativeFunctionAddresses()) + supported_extensions.remove("GL_NV_gpu_program4"); if (supported_extensions.contains("GL_NV_half_float") && !NV_half_float_initNativeFunctionAddresses()) supported_extensions.remove("GL_NV_half_float"); if (supported_extensions.contains("GL_NV_occlusion_query") && !NV_occlusion_query_initNativeFunctionAddresses()) supported_extensions.remove("GL_NV_occlusion_query"); + if (supported_extensions.contains("GL_NV_parameter_buffer_object") && !NV_parameter_buffer_object_initNativeFunctionAddresses()) + supported_extensions.remove("GL_NV_parameter_buffer_object"); if (supported_extensions.contains("GL_NV_pixel_data_range") && !NV_pixel_data_range_initNativeFunctionAddresses()) supported_extensions.remove("GL_NV_pixel_data_range"); if (supported_extensions.contains("GL_NV_point_sprite") && !NV_point_sprite_initNativeFunctionAddresses()) @@ -2295,6 +2592,8 @@ public class ContextCapabilities { supported_extensions.remove("GL_NV_register_combiners"); if (supported_extensions.contains("GL_NV_register_combiners2") && !NV_register_combiners2_initNativeFunctionAddresses()) supported_extensions.remove("GL_NV_register_combiners2"); + if (supported_extensions.contains("GL_NV_transform_feeback") && !NV_transform_feeback_initNativeFunctionAddresses()) + supported_extensions.remove("GL_NV_transform_feeback"); if (supported_extensions.contains("GL_NV_vertex_array_range") && !NV_vertex_array_range_initNativeFunctionAddresses()) supported_extensions.remove("GL_NV_vertex_array_range"); if (supported_extensions.contains("GL_NV_vertex_program") && !NV_vertex_program_initNativeFunctionAddresses()) @@ -2365,6 +2664,7 @@ public class ContextCapabilities { this.GL_ATI_vertex_streams = supported_extensions.contains("GL_ATI_vertex_streams"); this.GL_EXT_abgr = supported_extensions.contains("GL_EXT_abgr"); this.GL_EXT_bgra = supported_extensions.contains("GL_EXT_bgra"); + this.GL_EXT_bindable_uniform = supported_extensions.contains("GL_EXT_bindable_uniform"); this.GL_EXT_blend_color = supported_extensions.contains("GL_EXT_blend_color"); this.GL_EXT_blend_equation_separate = supported_extensions.contains("GL_EXT_blend_equation_separate"); this.GL_EXT_blend_func_separate = supported_extensions.contains("GL_EXT_blend_func_separate"); @@ -2373,14 +2673,20 @@ public class ContextCapabilities { this.GL_EXT_cg_shader = supported_extensions.contains("GL_EXT_cg_shader"); this.GL_EXT_compiled_vertex_array = supported_extensions.contains("GL_EXT_compiled_vertex_array"); this.GL_EXT_depth_bounds_test = supported_extensions.contains("GL_EXT_depth_bounds_test"); + this.GL_EXT_draw_buffers2 = supported_extensions.contains("GL_EXT_draw_buffers2"); + this.GL_EXT_draw_instanced = supported_extensions.contains("GL_EXT_draw_instanced"); this.GL_EXT_draw_range_elements = supported_extensions.contains("GL_EXT_draw_range_elements"); this.GL_EXT_fog_coord = supported_extensions.contains("GL_EXT_fog_coord"); this.GL_EXT_framebuffer_blit = supported_extensions.contains("GL_EXT_framebuffer_blit"); this.GL_EXT_framebuffer_multisample = supported_extensions.contains("GL_EXT_framebuffer_multisample"); this.GL_EXT_framebuffer_object = supported_extensions.contains("GL_EXT_framebuffer_object"); + this.GL_EXT_framebuffer_sRGB = supported_extensions.contains("GL_EXT_framebuffer_sRGB"); + this.GL_EXT_geometry_shader4 = supported_extensions.contains("GL_EXT_geometry_shader4"); this.GL_EXT_gpu_program_parameters = supported_extensions.contains("GL_EXT_gpu_program_parameters"); + this.GL_EXT_gpu_shader4 = supported_extensions.contains("GL_EXT_gpu_shader4"); this.GL_EXT_multi_draw_arrays = supported_extensions.contains("GL_EXT_multi_draw_arrays"); this.GL_EXT_packed_depth_stencil = supported_extensions.contains("GL_EXT_packed_depth_stencil"); + this.GL_EXT_packed_float = supported_extensions.contains("GL_EXT_packed_float"); this.GL_EXT_packed_pixels = supported_extensions.contains("GL_EXT_packed_pixels"); this.GL_EXT_paletted_texture = supported_extensions.contains("GL_EXT_paletted_texture"); this.GL_EXT_pixel_buffer_object = supported_extensions.contains("GL_EXT_pixel_buffer_object") @@ -2395,14 +2701,20 @@ public class ContextCapabilities { this.GL_EXT_stencil_two_side = supported_extensions.contains("GL_EXT_stencil_two_side"); this.GL_EXT_stencil_wrap = supported_extensions.contains("GL_EXT_stencil_wrap"); this.GL_EXT_texture_3d = supported_extensions.contains("GL_EXT_texture_3d"); + this.GL_EXT_texture_array = supported_extensions.contains("GL_EXT_texture_array"); + this.GL_EXT_texture_buffer_object = supported_extensions.contains("GL_EXT_texture_buffer_object"); + this.GL_EXT_texture_compression_latc = supported_extensions.contains("GL_EXT_texture_compression_latc"); + this.GL_EXT_texture_compression_rgtc = supported_extensions.contains("GL_EXT_texture_compression_rgtc"); this.GL_EXT_texture_compression_s3tc = supported_extensions.contains("GL_EXT_texture_compression_s3tc"); this.GL_EXT_texture_env_combine = supported_extensions.contains("GL_EXT_texture_env_combine"); this.GL_EXT_texture_env_dot3 = supported_extensions.contains("GL_EXT_texture_env_dot3"); this.GL_EXT_texture_filter_anisotropic = supported_extensions.contains("GL_EXT_texture_filter_anisotropic"); + this.GL_EXT_texture_integer = supported_extensions.contains("GL_EXT_texture_integer"); this.GL_EXT_texture_lod_bias = supported_extensions.contains("GL_EXT_texture_lod_bias"); this.GL_EXT_texture_mirror_clamp = supported_extensions.contains("GL_EXT_texture_mirror_clamp"); this.GL_EXT_texture_rectangle = supported_extensions.contains("GL_EXT_texture_rectangle"); this.GL_EXT_texture_sRGB = supported_extensions.contains("GL_EXT_texture_sRGB"); + this.GL_EXT_texture_shared_exponent = supported_extensions.contains("GL_EXT_texture_shared_exponent"); this.GL_EXT_timer_query = supported_extensions.contains("GL_EXT_timer_query"); this.GL_EXT_vertex_shader = supported_extensions.contains("GL_EXT_vertex_shader"); this.GL_EXT_vertex_weighting = supported_extensions.contains("GL_EXT_vertex_weighting"); @@ -2417,6 +2729,7 @@ public class ContextCapabilities { this.GL_IBM_rasterpos_clip = supported_extensions.contains("GL_IBM_rasterpos_clip"); this.GL_NV_blend_square = supported_extensions.contains("GL_NV_blend_square"); this.GL_NV_copy_depth_to_color = supported_extensions.contains("GL_NV_copy_depth_to_color"); + this.GL_NV_depth_buffer_float = supported_extensions.contains("GL_NV_depth_buffer_float"); this.GL_NV_depth_clamp = supported_extensions.contains("GL_NV_depth_clamp"); this.GL_NV_evaluators = supported_extensions.contains("GL_NV_evaluators"); this.GL_NV_fence = supported_extensions.contains("GL_NV_fence"); @@ -2425,12 +2738,17 @@ public class ContextCapabilities { this.GL_NV_fragment_program = supported_extensions.contains("GL_NV_fragment_program") && supported_extensions.contains("GL_NV_program"); this.GL_NV_fragment_program2 = supported_extensions.contains("GL_NV_fragment_program2"); + this.GL_NV_fragment_program4 = supported_extensions.contains("GL_NV_fragment_program4"); this.GL_NV_fragment_program_option = supported_extensions.contains("GL_NV_fragment_program_option"); + this.GL_NV_framebuffer_multisample_coverage = supported_extensions.contains("GL_NV_framebuffer_multisample_coverage"); + this.GL_NV_geometry_program4 = supported_extensions.contains("GL_NV_geometry_program4"); + this.GL_NV_gpu_program4 = supported_extensions.contains("GL_NV_gpu_program4"); this.GL_NV_half_float = supported_extensions.contains("GL_NV_half_float"); this.GL_NV_light_max_exponent = supported_extensions.contains("GL_NV_light_max_exponent"); this.GL_NV_multisample_filter_hint = supported_extensions.contains("GL_NV_multisample_filter_hint"); this.GL_NV_occlusion_query = supported_extensions.contains("GL_NV_occlusion_query"); this.GL_NV_packed_depth_stencil = supported_extensions.contains("GL_NV_packed_depth_stencil"); + this.GL_NV_parameter_buffer_object = supported_extensions.contains("GL_NV_parameter_buffer_object"); this.GL_NV_pixel_data_range = supported_extensions.contains("GL_NV_pixel_data_range"); this.GL_NV_point_sprite = supported_extensions.contains("GL_NV_point_sprite"); this.GL_NV_primitive_restart = supported_extensions.contains("GL_NV_primitive_restart"); @@ -2444,6 +2762,7 @@ public class ContextCapabilities { this.GL_NV_texture_shader = supported_extensions.contains("GL_NV_texture_shader"); this.GL_NV_texture_shader2 = supported_extensions.contains("GL_NV_texture_shader2"); this.GL_NV_texture_shader3 = supported_extensions.contains("GL_NV_texture_shader3"); + this.GL_NV_transform_feeback = supported_extensions.contains("GL_NV_transform_feeback"); this.GL_NV_vertex_array_range = supported_extensions.contains("GL_NV_vertex_array_range"); this.GL_NV_vertex_array_range2 = supported_extensions.contains("GL_NV_vertex_array_range2"); this.GL_NV_vertex_program = supported_extensions.contains("GL_NV_vertex_program") @@ -2452,6 +2771,7 @@ public class ContextCapabilities { this.GL_NV_vertex_program2 = supported_extensions.contains("GL_NV_vertex_program2"); this.GL_NV_vertex_program2_option = supported_extensions.contains("GL_NV_vertex_program2_option"); this.GL_NV_vertex_program3 = supported_extensions.contains("GL_NV_vertex_program3"); + this.GL_NV_vertex_program4 = supported_extensions.contains("GL_NV_vertex_program4"); this.GL_SGIS_generate_mipmap = supported_extensions.contains("GL_SGIS_generate_mipmap"); this.GL_SGIS_texture_lod = supported_extensions.contains("GL_SGIS_texture_lod"); this.GL_SUN_slice_accum = supported_extensions.contains("GL_SUN_slice_accum"); diff --git a/src/generated/org/lwjgl/opengl/EXTBindableUniform.java b/src/generated/org/lwjgl/opengl/EXTBindableUniform.java new file mode 100644 index 00000000..95ad7cea --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTBindableUniform.java @@ -0,0 +1,52 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTBindableUniform { + /** + * Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, + * and GetDoublev: + */ + public static final int GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8de2; + public static final int GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8de3; + public static final int GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8de4; + public static final int GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8ded; + public static final int GL_UNIFORM_BUFFER_BINDING_EXT = 0x8def; + /** + * Accepted by the <target> parameters of BindBuffer, BufferData, + * BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, and + * GetBufferPointerv: + */ + public static final int GL_UNIFORM_BUFFER_EXT = 0x8dee; + + private EXTBindableUniform() { + } + + + public static void glUniformBufferEXT(int program, int location, int buffer) { + long function_pointer = GLContext.getCapabilities().EXT_bindable_uniform_glUniformBufferEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglUniformBufferEXT(program, location, buffer, function_pointer); + } + private static native void nglUniformBufferEXT(int program, int location, int buffer, long function_pointer); + + public static int glGetUniformBufferSizeEXT(int program, int location) { + long function_pointer = GLContext.getCapabilities().EXT_bindable_uniform_glGetUniformBufferSizeEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + int __result = nglGetUniformBufferSizeEXT(program, location, function_pointer); + return __result; + } + private static native int nglGetUniformBufferSizeEXT(int program, int location, long function_pointer); + + public static long glGetUniformOffsetEXT(int program, int location) { + long function_pointer = GLContext.getCapabilities().EXT_bindable_uniform_glGetUniformOffsetEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + long __result = nglGetUniformOffsetEXT(program, location, function_pointer); + return __result; + } + private static native long nglGetUniformOffsetEXT(int program, int location, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/EXTDrawBuffers2.java b/src/generated/org/lwjgl/opengl/EXTDrawBuffers2.java new file mode 100644 index 00000000..8a094023 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTDrawBuffers2.java @@ -0,0 +1,59 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTDrawBuffers2 { + + private EXTDrawBuffers2() { + } + + + public static void glColorMaskIndexedEXT(int buf, boolean r, boolean g, boolean b, boolean a) { + long function_pointer = GLContext.getCapabilities().EXT_draw_buffers2_glColorMaskIndexedEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglColorMaskIndexedEXT(buf, r, g, b, a, function_pointer); + } + private static native void nglColorMaskIndexedEXT(int buf, boolean r, boolean g, boolean b, boolean a, long function_pointer); + + public static void glGetBooleanIndexedEXT(int value, int index, ByteBuffer data) { + long function_pointer = GLContext.getCapabilities().EXT_draw_buffers2_glGetBooleanIndexedvEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(data, 4); + nglGetBooleanIndexedvEXT(value, index, data, data.position(), function_pointer); + } + private static native void nglGetBooleanIndexedvEXT(int value, int index, ByteBuffer data, int data_position, long function_pointer); + + public static void glGetIntegerIndexedEXT(int value, int index, IntBuffer data) { + long function_pointer = GLContext.getCapabilities().EXT_draw_buffers2_glGetIntegerIndexedvEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(data, 4); + nglGetIntegerIndexedvEXT(value, index, data, data.position(), function_pointer); + } + private static native void nglGetIntegerIndexedvEXT(int value, int index, IntBuffer data, int data_position, long function_pointer); + + public static void glEnableIndexedEXT(int target, int index) { + long function_pointer = GLContext.getCapabilities().EXT_draw_buffers2_glEnableIndexedEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglEnableIndexedEXT(target, index, function_pointer); + } + private static native void nglEnableIndexedEXT(int target, int index, long function_pointer); + + public static void glDisableIndexedEXT(int target, int index) { + long function_pointer = GLContext.getCapabilities().EXT_draw_buffers2_glDisableIndexedEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglDisableIndexedEXT(target, index, function_pointer); + } + private static native void nglDisableIndexedEXT(int target, int index, long function_pointer); + + public static boolean glIsEnabledIndexedEXT(int target, int index) { + long function_pointer = GLContext.getCapabilities().EXT_draw_buffers2_glIsEnabledIndexedEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + boolean __result = nglIsEnabledIndexedEXT(target, index, function_pointer); + return __result; + } + private static native boolean nglIsEnabledIndexedEXT(int target, int index, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/EXTDrawInstanced.java b/src/generated/org/lwjgl/opengl/EXTDrawInstanced.java new file mode 100644 index 00000000..e4fa3640 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTDrawInstanced.java @@ -0,0 +1,51 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTDrawInstanced { + + private EXTDrawInstanced() { + } + + + public static void glDrawArraysInstancedEXT(int mode, int first, int count, int primcount) { + long function_pointer = GLContext.getCapabilities().EXT_draw_instanced_glDrawArraysInstancedEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglDrawArraysInstancedEXT(mode, first, count, primcount, function_pointer); + } + private static native void nglDrawArraysInstancedEXT(int mode, int first, int count, int primcount, long function_pointer); + + public static void glDrawElementsInstancedEXT(int mode, ByteBuffer indices, int primcount) { + long function_pointer = GLContext.getCapabilities().EXT_draw_instanced_glDrawElementsInstancedEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + GLChecks.ensureElementVBOdisabled(); + BufferChecks.checkDirect(indices); + nglDrawElementsInstancedEXT(mode, (indices.remaining()), GL11.GL_UNSIGNED_BYTE, indices, indices.position(), primcount, function_pointer); + } + public static void glDrawElementsInstancedEXT(int mode, IntBuffer indices, int primcount) { + long function_pointer = GLContext.getCapabilities().EXT_draw_instanced_glDrawElementsInstancedEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + GLChecks.ensureElementVBOdisabled(); + BufferChecks.checkDirect(indices); + nglDrawElementsInstancedEXT(mode, (indices.remaining()), GL11.GL_UNSIGNED_INT, indices, indices.position() << 2, primcount, function_pointer); + } + public static void glDrawElementsInstancedEXT(int mode, ShortBuffer indices, int primcount) { + long function_pointer = GLContext.getCapabilities().EXT_draw_instanced_glDrawElementsInstancedEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + GLChecks.ensureElementVBOdisabled(); + BufferChecks.checkDirect(indices); + nglDrawElementsInstancedEXT(mode, (indices.remaining()), GL11.GL_UNSIGNED_SHORT, indices, indices.position() << 1, primcount, function_pointer); + } + private static native void nglDrawElementsInstancedEXT(int mode, int count, int type, Buffer indices, int indices_position, int primcount, long function_pointer); + public static void glDrawElementsInstancedEXT(int mode, int count, int type, long indices_buffer_offset, int primcount) { + long function_pointer = GLContext.getCapabilities().EXT_draw_instanced_glDrawElementsInstancedEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + GLChecks.ensureElementVBOenabled(); + nglDrawElementsInstancedEXTBO(mode, count, type, indices_buffer_offset, primcount, function_pointer); + } + private static native void nglDrawElementsInstancedEXTBO(int mode, int count, int type, long indices_buffer_offset, int primcount, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/EXTFramebufferSRGB.java b/src/generated/org/lwjgl/opengl/EXTFramebufferSRGB.java new file mode 100644 index 00000000..454b66bc --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTFramebufferSRGB.java @@ -0,0 +1,36 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTFramebufferSRGB { + /** + * Accepted by the <attribList> parameter of glXChooseVisual, and by + * the <attrib> parameter of glXGetConfig: + */ + public static final int GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x20b2; + /** + * Accepted by the <piAttributes> parameter of + * wglGetPixelFormatAttribivEXT, wglGetPixelFormatAttribfvEXT, and + * the <piAttribIList> and <pfAttribIList> of wglChoosePixelFormatEXT: + */ + public static final int WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x20a9; + /** + * Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, + * and by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, + * and GetDoublev: + */ + public static final int GL_FRAMEBUFFER_SRGB_EXT = 0x8db9; + /** + * Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, + * GetFloatv, and GetDoublev: + */ + public static final int GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8dba; + + private EXTFramebufferSRGB() { + } + +} diff --git a/src/generated/org/lwjgl/opengl/EXTGeometryShader4.java b/src/generated/org/lwjgl/opengl/EXTGeometryShader4.java new file mode 100644 index 00000000..764950d6 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTGeometryShader4.java @@ -0,0 +1,91 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTGeometryShader4 { + /** + * Accepted by the <type> parameter of CreateShader and returned by the + * <params> parameter of GetShaderiv: + */ + public static final int GL_GEOMETRY_SHADER_EXT = 0x8dd9; + /** + * Accepted by the <pname> parameter of ProgramParameteriEXT and + * GetProgramiv: + */ + public static final int GL_GEOMETRY_VERTICES_OUT_EXT = 0x8dda; + public static final int GL_GEOMETRY_INPUT_TYPE_EXT = 0x8ddb; + public static final int GL_GEOMETRY_OUTPUT_TYPE_EXT = 0x8ddc; + /** + * Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, + * GetFloatv, and GetDoublev: + */ + public static final int GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8c29; + public static final int GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 0x8ddd; + public static final int GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = 0x8dde; + public static final int GL_MAX_VARYING_COMPONENTS_EXT = 0x8b4b; + public static final int GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8ddf; + public static final int GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8de0; + public static final int GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8de1; + /** + * Accepted by the <mode> parameter of Begin, DrawArrays, + * MultiDrawArrays, DrawElements, MultiDrawElements, and + * DrawRangeElements: + */ + public static final int GL_LINES_ADJACENCY_EXT = 0xa; + public static final int GL_LINE_STRIP_ADJACENCY_EXT = 0xb; + public static final int GL_TRIANGLES_ADJACENCY_EXT = 0xc; + public static final int GL_TRIANGLE_STRIP_ADJACENCY_EXT = 0xd; + /** + *Returned by CheckFramebufferStatusEXT: + */ + public static final int GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8da8; + public static final int GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 0x8da9; + /** + * Accepted by the <pname> parameter of GetFramebufferAttachment- + * ParameterivEXT: + */ + public static final int GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8da7; + public static final int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8cd4; + /** + * Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, + * and by the <pname> parameter of GetIntegerv, GetFloatv, GetDoublev, + * and GetBooleanv: + */ + public static final int GL_PROGRAM_POINT_SIZE_EXT = 0x8642; + + private EXTGeometryShader4() { + } + + + public static void glProgramParameteriEXT(int program, int pname, int value) { + long function_pointer = GLContext.getCapabilities().EXT_geometry_shader4_glProgramParameteriEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglProgramParameteriEXT(program, pname, value, function_pointer); + } + private static native void nglProgramParameteriEXT(int program, int pname, int value, long function_pointer); + + public static void glFramebufferTextureEXT(int target, int attachment, int texture, int level) { + long function_pointer = GLContext.getCapabilities().EXT_geometry_shader4_glFramebufferTextureEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglFramebufferTextureEXT(target, attachment, texture, level, function_pointer); + } + private static native void nglFramebufferTextureEXT(int target, int attachment, int texture, int level, long function_pointer); + + public static void glFramebufferTextureLayerEXT(int target, int attachment, int texture, int level, int layer) { + long function_pointer = GLContext.getCapabilities().EXT_geometry_shader4_glFramebufferTextureLayerEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglFramebufferTextureLayerEXT(target, attachment, texture, level, layer, function_pointer); + } + private static native void nglFramebufferTextureLayerEXT(int target, int attachment, int texture, int level, int layer, long function_pointer); + + public static void glFramebufferTextureFaceEXT(int target, int attachment, int texture, int level, int face) { + long function_pointer = GLContext.getCapabilities().EXT_geometry_shader4_glFramebufferTextureFaceEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglFramebufferTextureFaceEXT(target, attachment, texture, level, face, function_pointer); + } + private static native void nglFramebufferTextureFaceEXT(int target, int attachment, int texture, int level, int face, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/EXTGpuShader4.java b/src/generated/org/lwjgl/opengl/EXTGpuShader4.java new file mode 100644 index 00000000..75e82001 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTGpuShader4.java @@ -0,0 +1,343 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTGpuShader4 { + /** + * Accepted by the <pname> parameters of GetVertexAttribdv, + * GetVertexAttribfv, GetVertexAttribiv, GetVertexAttribIivEXT, and + * GetVertexAttribIuivEXT: + */ + public static final int GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = 0x88fd; + /** + *Returned by the <type> parameter of GetActiveUniform: + */ + public static final int GL_SAMPLER_1D_ARRAY_EXT = 0x8dc0; + public static final int GL_SAMPLER_2D_ARRAY_EXT = 0x8dc1; + public static final int GL_SAMPLER_BUFFER_EXT = 0x8dc2; + public static final int GL_SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8dc3; + public static final int GL_SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8dc4; + public static final int GL_SAMPLER_CUBE_SHADOW_EXT = 0x8dc5; + public static final int GL_UNSIGNED_INT = 0x1405; + public static final int GL_UNSIGNED_INT_VEC2_EXT = 0x8dc6; + public static final int GL_UNSIGNED_INT_VEC3_EXT = 0x8dc7; + public static final int GL_UNSIGNED_INT_VEC4_EXT = 0x8dc8; + public static final int GL_INT_SAMPLER_1D_EXT = 0x8dc9; + public static final int GL_INT_SAMPLER_2D_EXT = 0x8dca; + public static final int GL_INT_SAMPLER_3D_EXT = 0x8dcb; + public static final int GL_INT_SAMPLER_CUBE_EXT = 0x8dcc; + public static final int GL_INT_SAMPLER_2D_RECT_EXT = 0x8dcd; + public static final int GL_INT_SAMPLER_1D_ARRAY_EXT = 0x8dce; + public static final int GL_INT_SAMPLER_2D_ARRAY_EXT = 0x8dcf; + public static final int GL_INT_SAMPLER_BUFFER_EXT = 0x8dd0; + public static final int GL_UNSIGNED_INT_SAMPLER_1D_EXT = 0x8dd1; + public static final int GL_UNSIGNED_INT_SAMPLER_2D_EXT = 0x8dd2; + public static final int GL_UNSIGNED_INT_SAMPLER_3D_EXT = 0x8dd3; + public static final int GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = 0x8dd4; + public static final int GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 0x8dd5; + public static final int GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 0x8dd6; + public static final int GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 0x8dd7; + public static final int GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8dd8; + /** + * Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, + * and GetDoublev: + */ + public static final int GL_MIN_PROGRAM_TEXEL_OFFSET_EXT = 0x8904; + public static final int GL_MAX_PROGRAM_TEXEL_OFFSET_EXT = 0x8905; + + private EXTGpuShader4() { + } + + + public static void glVertexAttribI1iEXT(int index, int x) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI1iEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglVertexAttribI1iEXT(index, x, function_pointer); + } + private static native void nglVertexAttribI1iEXT(int index, int x, long function_pointer); + + public static void glVertexAttribI2iEXT(int index, int x, int y) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI2iEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglVertexAttribI2iEXT(index, x, y, function_pointer); + } + private static native void nglVertexAttribI2iEXT(int index, int x, int y, long function_pointer); + + public static void glVertexAttribI3iEXT(int index, int x, int y, int z) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI3iEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglVertexAttribI3iEXT(index, x, y, z, function_pointer); + } + private static native void nglVertexAttribI3iEXT(int index, int x, int y, int z, long function_pointer); + + public static void glVertexAttribI4iEXT(int index, int x, int y, int z, int w) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI4iEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglVertexAttribI4iEXT(index, x, y, z, w, function_pointer); + } + private static native void nglVertexAttribI4iEXT(int index, int x, int y, int z, int w, long function_pointer); + + public static void glVertexAttribI1uiEXT(int index, int x) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI1uiEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglVertexAttribI1uiEXT(index, x, function_pointer); + } + private static native void nglVertexAttribI1uiEXT(int index, int x, long function_pointer); + + public static void glVertexAttribI2uiEXT(int index, int x, int y) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI2uiEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglVertexAttribI2uiEXT(index, x, y, function_pointer); + } + private static native void nglVertexAttribI2uiEXT(int index, int x, int y, long function_pointer); + + public static void glVertexAttribI3uiEXT(int index, int x, int y, int z) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI3uiEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglVertexAttribI3uiEXT(index, x, y, z, function_pointer); + } + private static native void nglVertexAttribI3uiEXT(int index, int x, int y, int z, long function_pointer); + + public static void glVertexAttribI4uiEXT(int index, int x, int y, int z, int w) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI4uiEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglVertexAttribI4uiEXT(index, x, y, z, w, function_pointer); + } + private static native void nglVertexAttribI4uiEXT(int index, int x, int y, int z, int w, long function_pointer); + + public static void glVertexAttribI1EXT(int index, IntBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI1ivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 1); + nglVertexAttribI1ivEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI1ivEXT(int index, IntBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribI2EXT(int index, IntBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI2ivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 2); + nglVertexAttribI2ivEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI2ivEXT(int index, IntBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribI3EXT(int index, IntBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI3ivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 3); + nglVertexAttribI3ivEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI3ivEXT(int index, IntBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribI4EXT(int index, IntBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI4ivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 4); + nglVertexAttribI4ivEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI4ivEXT(int index, IntBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribI1uEXT(int index, IntBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI1uivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 1); + nglVertexAttribI1uivEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI1uivEXT(int index, IntBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribI2uEXT(int index, IntBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI2uivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 2); + nglVertexAttribI2uivEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI2uivEXT(int index, IntBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribI3uEXT(int index, IntBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI3uivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 3); + nglVertexAttribI3uivEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI3uivEXT(int index, IntBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribI4uEXT(int index, IntBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI4uivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 4); + nglVertexAttribI4uivEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI4uivEXT(int index, IntBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribI4EXT(int index, ByteBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI4bvEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 4); + nglVertexAttribI4bvEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI4bvEXT(int index, ByteBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribI4EXT(int index, ShortBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI4svEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 4); + nglVertexAttribI4svEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI4svEXT(int index, ShortBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribI4uEXT(int index, ByteBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI4ubvEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 4); + nglVertexAttribI4ubvEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI4ubvEXT(int index, ByteBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribI4uEXT(int index, ShortBuffer v) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribI4usvEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(v, 4); + nglVertexAttribI4usvEXT(index, v, v.position(), function_pointer); + } + private static native void nglVertexAttribI4usvEXT(int index, ShortBuffer v, int v_position, long function_pointer); + + public static void glVertexAttribIPointerEXT(int index, int size, int type, int stride, ByteBuffer buffer) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribIPointerEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + GLChecks.ensureArrayVBOdisabled(); + BufferChecks.checkDirect(buffer); + GLChecks.getReferences().EXT_gpu_shader4_glVertexAttribIPointerEXT_buffer = buffer; + nglVertexAttribIPointerEXT(index, size, type, stride, buffer, buffer.position(), function_pointer); + } + public static void glVertexAttribIPointerEXT(int index, int size, int type, int stride, IntBuffer buffer) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribIPointerEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + GLChecks.ensureArrayVBOdisabled(); + BufferChecks.checkDirect(buffer); + GLChecks.getReferences().EXT_gpu_shader4_glVertexAttribIPointerEXT_buffer = buffer; + nglVertexAttribIPointerEXT(index, size, type, stride, buffer, buffer.position() << 2, function_pointer); + } + public static void glVertexAttribIPointerEXT(int index, int size, int type, int stride, ShortBuffer buffer) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribIPointerEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + GLChecks.ensureArrayVBOdisabled(); + BufferChecks.checkDirect(buffer); + GLChecks.getReferences().EXT_gpu_shader4_glVertexAttribIPointerEXT_buffer = buffer; + nglVertexAttribIPointerEXT(index, size, type, stride, buffer, buffer.position() << 1, function_pointer); + } + private static native void nglVertexAttribIPointerEXT(int index, int size, int type, int stride, Buffer buffer, int buffer_position, long function_pointer); + public static void glVertexAttribIPointerEXT(int index, int size, int type, int stride, long buffer_buffer_offset) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glVertexAttribIPointerEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + GLChecks.ensureArrayVBOenabled(); + nglVertexAttribIPointerEXTBO(index, size, type, stride, buffer_buffer_offset, function_pointer); + } + private static native void nglVertexAttribIPointerEXTBO(int index, int size, int type, int stride, long buffer_buffer_offset, long function_pointer); + + public static void glGetVertexAttribIEXT(int index, int pname, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glGetVertexAttribIivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglGetVertexAttribIivEXT(index, pname, params, params.position(), function_pointer); + } + private static native void nglGetVertexAttribIivEXT(int index, int pname, IntBuffer params, int params_position, long function_pointer); + + public static void glGetVertexAttribIuEXT(int index, int pname, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glGetVertexAttribIuivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglGetVertexAttribIuivEXT(index, pname, params, params.position(), function_pointer); + } + private static native void nglGetVertexAttribIuivEXT(int index, int pname, IntBuffer params, int params_position, long function_pointer); + + public static void glUniform1uiEXT(int location, int v0) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glUniform1uiEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglUniform1uiEXT(location, v0, function_pointer); + } + private static native void nglUniform1uiEXT(int location, int v0, long function_pointer); + + public static void glUniform2uiEXT(int location, int v0, int v1) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glUniform2uiEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglUniform2uiEXT(location, v0, v1, function_pointer); + } + private static native void nglUniform2uiEXT(int location, int v0, int v1, long function_pointer); + + public static void glUniform3uiEXT(int location, int v0, int v1, int v2) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glUniform3uiEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglUniform3uiEXT(location, v0, v1, v2, function_pointer); + } + private static native void nglUniform3uiEXT(int location, int v0, int v1, int v2, long function_pointer); + + public static void glUniform4uiEXT(int location, int v0, int v1, int v2, int v3) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glUniform4uiEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglUniform4uiEXT(location, v0, v1, v2, v3, function_pointer); + } + private static native void nglUniform4uiEXT(int location, int v0, int v1, int v2, int v3, long function_pointer); + + public static void glUniform1uEXT(int location, IntBuffer value) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glUniform1uivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(value); + nglUniform1uivEXT(location, (value.remaining()), value, value.position(), function_pointer); + } + private static native void nglUniform1uivEXT(int location, int count, IntBuffer value, int value_position, long function_pointer); + + public static void glUniform2uEXT(int location, IntBuffer value) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glUniform2uivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(value); + nglUniform2uivEXT(location, (value.remaining()) >> 1, value, value.position(), function_pointer); + } + private static native void nglUniform2uivEXT(int location, int count, IntBuffer value, int value_position, long function_pointer); + + public static void glUniform3uEXT(int location, IntBuffer value) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glUniform3uivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(value); + nglUniform3uivEXT(location, (value.remaining()) / 3, value, value.position(), function_pointer); + } + private static native void nglUniform3uivEXT(int location, int count, IntBuffer value, int value_position, long function_pointer); + + public static void glUniform4uEXT(int location, IntBuffer value) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glUniform4uivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(value); + nglUniform4uivEXT(location, (value.remaining()) >> 2, value, value.position(), function_pointer); + } + private static native void nglUniform4uivEXT(int location, int count, IntBuffer value, int value_position, long function_pointer); + + public static void glGetUniformuEXT(int program, int location, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glGetUniformuivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(params); + nglGetUniformuivEXT(program, location, params, params.position(), function_pointer); + } + private static native void nglGetUniformuivEXT(int program, int location, IntBuffer params, int params_position, long function_pointer); + + public static void glBindFragDataLocationEXT(int program, int colorNumber, ByteBuffer name) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glBindFragDataLocationEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(name); + BufferChecks.checkNullTerminated(name); + nglBindFragDataLocationEXT(program, colorNumber, name, name.position(), function_pointer); + } + private static native void nglBindFragDataLocationEXT(int program, int colorNumber, ByteBuffer name, int name_position, long function_pointer); + + public static int glGetFragDataLocationEXT(int program, ByteBuffer name) { + long function_pointer = GLContext.getCapabilities().EXT_gpu_shader4_glGetFragDataLocationEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(name); + BufferChecks.checkNullTerminated(name); + int __result = nglGetFragDataLocationEXT(program, name, name.position(), function_pointer); + return __result; + } + private static native int nglGetFragDataLocationEXT(int program, ByteBuffer name, int name_position, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/EXTPackedFloat.java b/src/generated/org/lwjgl/opengl/EXTPackedFloat.java new file mode 100644 index 00000000..4646bed8 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTPackedFloat.java @@ -0,0 +1,52 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTPackedFloat { + /** + * Accepted by the <internalformat> parameter of TexImage1D, + * TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, and + * RenderbufferStorageEXT: + */ + public static final int GL_R11F_G11F_B10F_EXT = 0x8c3a; + /** + * Accepted by the <type> parameter of DrawPixels, ReadPixels, + * TexImage1D, TexImage2D, GetTexImage, TexImage3D, TexSubImage1D, + * TexSubImage2D, TexSubImage3D, GetHistogram, GetMinmax, + * ConvolutionFilter1D, ConvolutionFilter2D, ConvolutionFilter3D, + * GetConvolutionFilter, SeparableFilter2D, GetSeparableFilter, + * ColorTable, ColorSubTable, and GetColorTable: + */ + public static final int GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8c3b; + /** + * Accepted by the <pname> parameters of GetIntegerv, GetFloatv, and + * GetDoublev: + */ + public static final int GL_RGBA_SIGNED_COMPONENTS_EXT = 0x8c3c; + /** + * Accepted as a value in the <piAttribIList> and <pfAttribFList> + * parameter arrays of wglChoosePixelFormatARB, and returned in the + * <piValues> parameter array of wglGetPixelFormatAttribivARB, and the + * <pfValues> parameter array of wglGetPixelFormatAttribfvARB: + */ + public static final int WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = 0x20a8; + /** + * Accepted as values of the <render_type> arguments in the + * glXCreateNewContext and glXCreateContext functions + */ + public static final int GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = 0x20b1; + /** + * Returned by glXGetFBConfigAttrib (when <attribute> is set to + * GLX_RENDER_TYPE) and accepted by the <attrib_list> parameter of + * glXChooseFBConfig (following the GLX_RENDER_TYPE token): + */ + public static final int GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = 0x8; + + private EXTPackedFloat() { + } + +} diff --git a/src/generated/org/lwjgl/opengl/EXTTextureArray.java b/src/generated/org/lwjgl/opengl/EXTTextureArray.java new file mode 100644 index 00000000..9fd12976 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTTextureArray.java @@ -0,0 +1,63 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTTextureArray { + /** + * Accepted by the <target> parameter of TexParameteri, TexParameteriv, + * TexParameterf, TexParameterfv, and BindTexture: + */ + public static final int GL_TEXTURE_1D_ARRAY_EXT = 0x8c18; + public static final int GL_TEXTURE_2D_ARRAY_EXT = 0x8c1a; + /** + * Accepted by the <target> parameter of TexImage3D, TexSubImage3D, + * CopyTexSubImage3D, CompressedTexImage3D, and CompressedTexSubImage3D: + */ + public static final int GL_PROXY_TEXTURE_2D_ARRAY_EXT = 0x8c1b; + /** + * Accepted by the <target> parameter of TexImage2D, TexSubImage2D, + * CopyTexImage2D, CopyTexSubImage2D, CompressedTexImage2D, and + * CompressedTexSubImage2D: + */ + public static final int GL_PROXY_TEXTURE_1D_ARRAY_EXT = 0x8c19; + /** + * Accepted by the <pname> parameter of GetBooleanv, GetDoublev, GetIntegerv + * and GetFloatv: + */ + public static final int GL_TEXTURE_BINDING_1D_ARRAY_EXT = 0x8c1c; + public static final int GL_TEXTURE_BINDING_2D_ARRAY_EXT = 0x8c1d; + public static final int GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = 0x88ff; + /** + * Accepted by the <param> parameter of TexParameterf, TexParameteri, + * TexParameterfv, and TexParameteriv when the <pname> parameter is + * TEXTURE_COMPARE_MODE_ARB: + */ + public static final int GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 0x884e; + /** + * Accepted by the <pname> parameter of + * GetFramebufferAttachmentParameterivEXT: + */ + public static final int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8cd4; + /** + *Returned by the <type> parameter of GetActiveUniform: + */ + public static final int GL_SAMPLER_1D_ARRAY_EXT = 0x8dc0; + public static final int GL_SAMPLER_2D_ARRAY_EXT = 0x8dc1; + public static final int GL_SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8dc3; + public static final int GL_SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8dc4; + + private EXTTextureArray() { + } + + + public static void glFramebufferTextureLayerEXT(int target, int attachment, int texture, int level, int layer) { + long function_pointer = GLContext.getCapabilities().EXT_texture_array_glFramebufferTextureLayerEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglFramebufferTextureLayerEXT(target, attachment, texture, level, layer, function_pointer); + } + private static native void nglFramebufferTextureLayerEXT(int target, int attachment, int texture, int level, int layer, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/EXTTextureBufferObject.java b/src/generated/org/lwjgl/opengl/EXTTextureBufferObject.java new file mode 100644 index 00000000..6b743a20 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTTextureBufferObject.java @@ -0,0 +1,37 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTTextureBufferObject { + /** + * Accepted by the <target> parameter of BindBuffer, BufferData, + * BufferSubData, MapBuffer, BindTexture, UnmapBuffer, GetBufferSubData, + * GetBufferParameteriv, GetBufferPointerv, and TexBufferEXT, and + * the <pname> parameter of GetBooleanv, GetDoublev, GetFloatv, and + * GetIntegerv: + */ + public static final int GL_TEXTURE_BUFFER_EXT = 0x8c2a; + /** + * Accepted by the <pname> parameters of GetBooleanv, GetDoublev, + * GetFloatv, and GetIntegerv: + */ + public static final int GL_MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8c2b; + public static final int GL_TEXTURE_BINDING_BUFFER_EXT = 0x8c2c; + public static final int GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8c2d; + public static final int GL_TEXTURE_BUFFER_FORMAT_EXT = 0x8c2e; + + private EXTTextureBufferObject() { + } + + + public static void glTexBufferEXT(int target, int internalformat, int buffer) { + long function_pointer = GLContext.getCapabilities().EXT_texture_buffer_object_glTexBufferEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglTexBufferEXT(target, internalformat, buffer, function_pointer); + } + private static native void nglTexBufferEXT(int target, int internalformat, int buffer, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/EXTTextureCompressionLATC.java b/src/generated/org/lwjgl/opengl/EXTTextureCompressionLATC.java new file mode 100644 index 00000000..32cb67c6 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTTextureCompressionLATC.java @@ -0,0 +1,23 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTTextureCompressionLATC { + /** + * Accepted by the <internalformat> parameter of TexImage2D, + * CopyTexImage2D, and CompressedTexImage2D and the <format> parameter + * of CompressedTexSubImage2D: + */ + public static final int GL_COMPRESSED_LUMINANCE_LATC1_EXT = 0x8c70; + public static final int GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 0x8c71; + public static final int GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 0x8c72; + public static final int GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 0x8c73; + + private EXTTextureCompressionLATC() { + } + +} diff --git a/src/generated/org/lwjgl/opengl/EXTTextureCompressionRGTC.java b/src/generated/org/lwjgl/opengl/EXTTextureCompressionRGTC.java new file mode 100644 index 00000000..1747b05c --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTTextureCompressionRGTC.java @@ -0,0 +1,23 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTTextureCompressionRGTC { + /** + * Accepted by the <internalformat> parameter of TexImage2D, + * CopyTexImage2D, and CompressedTexImage2D and the <format> parameter + * of CompressedTexSubImage2D: + */ + public static final int GL_COMPRESSED_RED_RGTC1_EXT = 0x8dbb; + public static final int GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8dbc; + public static final int GL_COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8dbd; + public static final int GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8dbe; + + private EXTTextureCompressionRGTC() { + } + +} diff --git a/src/generated/org/lwjgl/opengl/EXTTextureInteger.java b/src/generated/org/lwjgl/opengl/EXTTextureInteger.java new file mode 100644 index 00000000..0c65aa15 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTTextureInteger.java @@ -0,0 +1,120 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTTextureInteger { + /** + * Accepted by the <pname> parameters of GetBooleanv, GetIntegerv, + * GetFloatv, and GetDoublev: + */ + public static final int GL_RGBA_INTEGER_MODE_EXT = 0x8d9e; + /** + * Accepted by the <internalFormat> parameter of TexImage1D, + * TexImage2D, and TexImage3D: + */ + public static final int GL_RGBA32UI_EXT = 0x8d70; + public static final int GL_RGB32UI_EXT = 0x8d71; + public static final int GL_ALPHA32UI_EXT = 0x8d72; + public static final int GL_INTENSITY32UI_EXT = 0x8d73; + public static final int GL_LUMINANCE32UI_EXT = 0x8d74; + public static final int GL_LUMINANCE_ALPHA32UI_EXT = 0x8d75; + public static final int GL_RGBA16UI_EXT = 0x8d76; + public static final int GL_RGB16UI_EXT = 0x8d77; + public static final int GL_ALPHA16UI_EXT = 0x8d78; + public static final int GL_INTENSITY16UI_EXT = 0x8d79; + public static final int GL_LUMINANCE16UI_EXT = 0x8d7a; + public static final int GL_LUMINANCE_ALPHA16UI_EXT = 0x8d7b; + public static final int GL_RGBA8UI_EXT = 0x8d7c; + public static final int GL_RGB8UI_EXT = 0x8d7d; + public static final int GL_ALPHA8UI_EXT = 0x8d7e; + public static final int GL_INTENSITY8UI_EXT = 0x8d7f; + public static final int GL_LUMINANCE8UI_EXT = 0x8d80; + public static final int GL_LUMINANCE_ALPHA8UI_EXT = 0x8d81; + public static final int GL_RGBA32I_EXT = 0x8d82; + public static final int GL_RGB32I_EXT = 0x8d83; + public static final int GL_ALPHA32I_EXT = 0x8d84; + public static final int GL_INTENSITY32I_EXT = 0x8d85; + public static final int GL_LUMINANCE32I_EXT = 0x8d86; + public static final int GL_LUMINANCE_ALPHA32I_EXT = 0x8d87; + public static final int GL_RGBA16I_EXT = 0x8d88; + public static final int GL_RGB16I_EXT = 0x8d89; + public static final int GL_ALPHA16I_EXT = 0x8d8a; + public static final int GL_INTENSITY16I_EXT = 0x8d8b; + public static final int GL_LUMINANCE16I_EXT = 0x8d8c; + public static final int GL_LUMINANCE_ALPHA16I_EXT = 0x8d8d; + public static final int GL_RGBA8I_EXT = 0x8d8e; + public static final int GL_RGB8I_EXT = 0x8d8f; + public static final int GL_ALPHA8I_EXT = 0x8d90; + public static final int GL_INTENSITY8I_EXT = 0x8d91; + public static final int GL_LUMINANCE8I_EXT = 0x8d92; + public static final int GL_LUMINANCE_ALPHA8I_EXT = 0x8d93; + /** + * Accepted by the <format> parameter of TexImage1D, TexImage2D, + * TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, + * DrawPixels and ReadPixels: + */ + public static final int GL_RED_INTEGER_EXT = 0x8d94; + public static final int GL_GREEN_INTEGER_EXT = 0x8d95; + public static final int GL_BLUE_INTEGER_EXT = 0x8d96; + public static final int GL_ALPHA_INTEGER_EXT = 0x8d97; + public static final int GL_RGB_INTEGER_EXT = 0x8d98; + public static final int GL_RGBA_INTEGER_EXT = 0x8d99; + public static final int GL_BGR_INTEGER_EXT = 0x8d9a; + public static final int GL_BGRA_INTEGER_EXT = 0x8d9b; + public static final int GL_LUMINANCE_INTEGER_EXT = 0x8d9c; + public static final int GL_LUMINANCE_ALPHA_INTEGER_EXT = 0x8d9d; + + private EXTTextureInteger() { + } + + + public static void glClearColorIiEXT(int r, int g, int b, int a) { + long function_pointer = GLContext.getCapabilities().EXT_texture_integer_glClearColorIiEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglClearColorIiEXT(r, g, b, a, function_pointer); + } + private static native void nglClearColorIiEXT(int r, int g, int b, int a, long function_pointer); + + public static void glClearColorIuiEXT(int r, int g, int b, int a) { + long function_pointer = GLContext.getCapabilities().EXT_texture_integer_glClearColorIuiEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglClearColorIuiEXT(r, g, b, a, function_pointer); + } + private static native void nglClearColorIuiEXT(int r, int g, int b, int a, long function_pointer); + + public static void glTexParameterIEXT(int target, int pname, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().EXT_texture_integer_glTexParameterIivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglTexParameterIivEXT(target, pname, params, params.position(), function_pointer); + } + private static native void nglTexParameterIivEXT(int target, int pname, IntBuffer params, int params_position, long function_pointer); + + public static void glTexParameterIuEXT(int target, int pname, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().EXT_texture_integer_glTexParameterIuivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglTexParameterIuivEXT(target, pname, params, params.position(), function_pointer); + } + private static native void nglTexParameterIuivEXT(int target, int pname, IntBuffer params, int params_position, long function_pointer); + + public static void glGetTexParameterIEXT(int target, int pname, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().EXT_texture_integer_glGetTexParameterIivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglGetTexParameterIivEXT(target, pname, params, params.position(), function_pointer); + } + private static native void nglGetTexParameterIivEXT(int target, int pname, IntBuffer params, int params_position, long function_pointer); + + public static void glGetTexParameterIuEXT(int target, int pname, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().EXT_texture_integer_glGetTexParameterIuivEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglGetTexParameterIuivEXT(target, pname, params, params.position(), function_pointer); + } + private static native void nglGetTexParameterIuivEXT(int target, int pname, IntBuffer params, int params_position, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/EXTTextureSharedExponent.java b/src/generated/org/lwjgl/opengl/EXTTextureSharedExponent.java new file mode 100644 index 00000000..66fc99c0 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/EXTTextureSharedExponent.java @@ -0,0 +1,34 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class EXTTextureSharedExponent { + /** + * Accepted by the <internalformat> parameter of TexImage1D, + * TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, and + * RenderbufferStorageEXT: + */ + public static final int GL_RGB9_E5_EXT = 0x8c3d; + /** + * Accepted by the <type> parameter of DrawPixels, ReadPixels, + * TexImage1D, TexImage2D, GetTexImage, TexImage3D, TexSubImage1D, + * TexSubImage2D, TexSubImage3D, GetHistogram, GetMinmax, + * ConvolutionFilter1D, ConvolutionFilter2D, ConvolutionFilter3D, + * GetConvolutionFilter, SeparableFilter2D, GetSeparableFilter, + * ColorTable, ColorSubTable, and GetColorTable: + */ + public static final int GL_UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8c3e; + /** + * Accepted by the <pname> parameter of GetTexLevelParameterfv and + * GetTexLevelParameteriv: + */ + public static final int GL_TEXTURE_SHARED_SIZE_EXT = 0x8c3f; + + private EXTTextureSharedExponent() { + } + +} diff --git a/src/generated/org/lwjgl/opengl/NVDepthBufferFloat.java b/src/generated/org/lwjgl/opengl/NVDepthBufferFloat.java new file mode 100644 index 00000000..29afeeca --- /dev/null +++ b/src/generated/org/lwjgl/opengl/NVDepthBufferFloat.java @@ -0,0 +1,54 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class NVDepthBufferFloat { + /** + * Accepted by the <internalformat> parameter of TexImage1D, TexImage2D, + * TexImage3D, CopyTexImage1D, CopyTexImage2D, and RenderbufferStorageEXT, + * and returned in the <data> parameter of GetTexLevelParameter and + * GetRenderbufferParameterivEXT: + */ + public static final int GL_DEPTH_COMPONENT32F_NV = 0x8dab; + public static final int GL_DEPTH32F_STENCIL8_NV = 0x8dac; + /** + * Accepted by the <type> parameter of DrawPixels, ReadPixels, TexImage1D, + * TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and + * GetTexImage: + */ + public static final int GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8dad; + /** + * Accepted by the <pname> parameters of GetBooleanv, GetIntegerv, + * GetFloatv, and GetDoublev: + */ + public static final int GL_DEPTH_BUFFER_FLOAT_MODE_NV = 0x8daf; + + private NVDepthBufferFloat() { + } + + + public static void glDepthRangedNV(double n, double f) { + long function_pointer = GLContext.getCapabilities().NV_depth_buffer_float_glDepthRangedNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglDepthRangedNV(n, f, function_pointer); + } + private static native void nglDepthRangedNV(double n, double f, long function_pointer); + + public static void glClearDepthdNV(double d) { + long function_pointer = GLContext.getCapabilities().NV_depth_buffer_float_glClearDepthdNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglClearDepthdNV(d, function_pointer); + } + private static native void nglClearDepthdNV(double d, long function_pointer); + + public static void glDepthBoundsdNV(double zmin, double zmax) { + long function_pointer = GLContext.getCapabilities().NV_depth_buffer_float_glDepthBoundsdNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglDepthBoundsdNV(zmin, zmax, function_pointer); + } + private static native void nglDepthBoundsdNV(double zmin, double zmax, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/NVFramebufferMultisampleCoverage.java b/src/generated/org/lwjgl/opengl/NVFramebufferMultisampleCoverage.java new file mode 100644 index 00000000..5fed3110 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/NVFramebufferMultisampleCoverage.java @@ -0,0 +1,26 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class NVFramebufferMultisampleCoverage { + /** + *Accepted by the <pname> parameter of GetRenderbufferParameterivEXT: + */ + public static final int GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8cab; + public static final int GL_RENDERBUFFER_COLOR_SAMPLES_NV = 0x8e10; + + private NVFramebufferMultisampleCoverage() { + } + + + public static void glRenderbufferStorageMultsampleCoverageNV(int target, int coverageSamples, int colorSamples, int internalformat, int width, int height) { + long function_pointer = GLContext.getCapabilities().NV_framebuffer_multisample_coverage_glRenderbufferStorageMultsampleCoverageNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglRenderbufferStorageMultsampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height, function_pointer); + } + private static native void nglRenderbufferStorageMultsampleCoverageNV(int target, int coverageSamples, int colorSamples, int internalformat, int width, int height, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/NVGeometryProgram4.java b/src/generated/org/lwjgl/opengl/NVGeometryProgram4.java new file mode 100644 index 00000000..918e954e --- /dev/null +++ b/src/generated/org/lwjgl/opengl/NVGeometryProgram4.java @@ -0,0 +1,46 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class NVGeometryProgram4 { + /** + * Accepted by the <cap> parameter of Disable, Enable, and IsEnabled, and by + * the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev: + */ + public static final int GL_GEOMETRY_PROGRAM_NV = 0x8c26; + /** + *Accepted by the <pname> parameter of GetProgramivARB: + */ + public static final int GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = 0x8c27; + public static final int GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 0x8c28; + + private NVGeometryProgram4() { + } + + + public static void glProgramVertexLimitNV(int target, int limit) { + long function_pointer = GLContext.getCapabilities().NV_geometry_program4_glProgramVertexLimitNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglProgramVertexLimitNV(target, limit, function_pointer); + } + private static native void nglProgramVertexLimitNV(int target, int limit, long function_pointer); + + public static void glFramebufferTextureEXT(int target, int attachment, int texture, int level) { + long function_pointer = GLContext.getCapabilities().NV_geometry_program4_glFramebufferTextureEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglFramebufferTextureEXT(target, attachment, texture, level, function_pointer); + } + private static native void nglFramebufferTextureEXT(int target, int attachment, int texture, int level, long function_pointer); + + public static void glFramebufferTextureLayerEXT(int target, int attachment, int texture, int level, int layer) { + long function_pointer = GLContext.getCapabilities().NV_geometry_program4_glFramebufferTextureLayerEXT_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglFramebufferTextureLayerEXT(target, attachment, texture, level, layer, function_pointer); + } + private static native void nglFramebufferTextureLayerEXT(int target, int attachment, int texture, int level, int layer, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/NVGpuProgram4.java b/src/generated/org/lwjgl/opengl/NVGpuProgram4.java new file mode 100644 index 00000000..46d1d190 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/NVGpuProgram4.java @@ -0,0 +1,147 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class NVGpuProgram4 { + /** + *Accepted by the <pname> parameter of GetProgramivARB: + */ + public static final int GL_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8906; + public static final int GL_PROGRAM_RESULT_COMPONENTS_NV = 0x8907; + public static final int GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8908; + public static final int GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = 0x8909; + public static final int GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = 0x8da5; + public static final int GL_MAX_PROGRAM_GENERIC_RESULTS_NV = 0x8da6; + + private NVGpuProgram4() { + } + + + public static void glProgramLocalParameterI4iNV(int target, int index, int x, int y, int z, int w) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramLocalParameterI4iNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglProgramLocalParameterI4iNV(target, index, x, y, z, w, function_pointer); + } + private static native void nglProgramLocalParameterI4iNV(int target, int index, int x, int y, int z, int w, long function_pointer); + + public static void glProgramLocalParameterI4NV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramLocalParameterI4ivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglProgramLocalParameterI4ivNV(target, index, params, params.position(), function_pointer); + } + private static native void nglProgramLocalParameterI4ivNV(int target, int index, IntBuffer params, int params_position, long function_pointer); + + public static void glProgramLocalParametersI4NV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramLocalParametersI4ivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(params); + nglProgramLocalParametersI4ivNV(target, index, (params.remaining()) >> 2, params, params.position(), function_pointer); + } + private static native void nglProgramLocalParametersI4ivNV(int target, int index, int count, IntBuffer params, int params_position, long function_pointer); + + public static void glProgramLocalParameterI4uiNV(int target, int index, int x, int y, int z, int w) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramLocalParameterI4uiNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglProgramLocalParameterI4uiNV(target, index, x, y, z, w, function_pointer); + } + private static native void nglProgramLocalParameterI4uiNV(int target, int index, int x, int y, int z, int w, long function_pointer); + + public static void glProgramLocalParameterI4uNV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramLocalParameterI4uivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglProgramLocalParameterI4uivNV(target, index, params, params.position(), function_pointer); + } + private static native void nglProgramLocalParameterI4uivNV(int target, int index, IntBuffer params, int params_position, long function_pointer); + + public static void glProgramLocalParametersI4uNV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramLocalParametersI4uivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(params); + nglProgramLocalParametersI4uivNV(target, index, (params.remaining()) >> 2, params, params.position(), function_pointer); + } + private static native void nglProgramLocalParametersI4uivNV(int target, int index, int count, IntBuffer params, int params_position, long function_pointer); + + public static void glProgramEnvParameterI4iNV(int target, int index, int x, int y, int z, int w) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramEnvParameterI4iNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglProgramEnvParameterI4iNV(target, index, x, y, z, w, function_pointer); + } + private static native void nglProgramEnvParameterI4iNV(int target, int index, int x, int y, int z, int w, long function_pointer); + + public static void glProgramEnvParameterI4NV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramEnvParameterI4ivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglProgramEnvParameterI4ivNV(target, index, params, params.position(), function_pointer); + } + private static native void nglProgramEnvParameterI4ivNV(int target, int index, IntBuffer params, int params_position, long function_pointer); + + public static void glProgramEnvParametersI4NV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramEnvParametersI4ivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(params); + nglProgramEnvParametersI4ivNV(target, index, (params.remaining()) >> 2, params, params.position(), function_pointer); + } + private static native void nglProgramEnvParametersI4ivNV(int target, int index, int count, IntBuffer params, int params_position, long function_pointer); + + public static void glProgramEnvParameterI4uiNV(int target, int index, int x, int y, int z, int w) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramEnvParameterI4uiNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglProgramEnvParameterI4uiNV(target, index, x, y, z, w, function_pointer); + } + private static native void nglProgramEnvParameterI4uiNV(int target, int index, int x, int y, int z, int w, long function_pointer); + + public static void glProgramEnvParameterI4uNV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramEnvParameterI4uivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglProgramEnvParameterI4uivNV(target, index, params, params.position(), function_pointer); + } + private static native void nglProgramEnvParameterI4uivNV(int target, int index, IntBuffer params, int params_position, long function_pointer); + + public static void glProgramEnvParametersI4uNV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glProgramEnvParametersI4uivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(params); + nglProgramEnvParametersI4uivNV(target, index, (params.remaining()) >> 2, params, params.position(), function_pointer); + } + private static native void nglProgramEnvParametersI4uivNV(int target, int index, int count, IntBuffer params, int params_position, long function_pointer); + + public static void glGetProgramLocalParameterINV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glGetProgramLocalParameterIivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglGetProgramLocalParameterIivNV(target, index, params, params.position(), function_pointer); + } + private static native void nglGetProgramLocalParameterIivNV(int target, int index, IntBuffer params, int params_position, long function_pointer); + + public static void glGetProgramLocalParameterIuNV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glGetProgramLocalParameterIuivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglGetProgramLocalParameterIuivNV(target, index, params, params.position(), function_pointer); + } + private static native void nglGetProgramLocalParameterIuivNV(int target, int index, IntBuffer params, int params_position, long function_pointer); + + public static void glGetProgramEnvParameterINV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glGetProgramEnvParameterIivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglGetProgramEnvParameterIivNV(target, index, params, params.position(), function_pointer); + } + private static native void nglGetProgramEnvParameterIivNV(int target, int index, IntBuffer params, int params_position, long function_pointer); + + public static void glGetProgramEnvParameterIuNV(int target, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_gpu_program4_glGetProgramEnvParameterIuivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(params, 4); + nglGetProgramEnvParameterIuivNV(target, index, params, params.position(), function_pointer); + } + private static native void nglGetProgramEnvParameterIuivNV(int target, int index, IntBuffer params, int params_position, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/NVParameterBufferObject.java b/src/generated/org/lwjgl/opengl/NVParameterBufferObject.java new file mode 100644 index 00000000..4eea534c --- /dev/null +++ b/src/generated/org/lwjgl/opengl/NVParameterBufferObject.java @@ -0,0 +1,73 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class NVParameterBufferObject { + /** + *Accepted by the <pname> parameter of GetProgramivARB: + */ + public static final int GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 0x8da0; + public static final int GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 0x8da1; + /** + * Accepted by the <target> parameter of ProgramBufferParametersfvNV, + * ProgramBufferParametersIivNV, and ProgramBufferParametersIuivNV, + * BindBufferRangeNV, BindBufferOffsetNV, BindBufferBaseNV, and BindBuffer + * and the <value> parameter of GetIntegerIndexedvEXT: + */ + public static final int GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 0x8da2; + public static final int GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 0x8da3; + public static final int GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 0x8da4; + + private NVParameterBufferObject() { + } + + + public static void glBindBufferRangeNV(int target, int index, int buffer, long offset, long size) { + long function_pointer = GLContext.getCapabilities().NV_parameter_buffer_object_glBindBufferRangeNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglBindBufferRangeNV(target, index, buffer, offset, size, function_pointer); + } + private static native void nglBindBufferRangeNV(int target, int index, int buffer, long offset, long size, long function_pointer); + + public static void glBindBufferOffsetNV(int target, int index, int buffer, long offset) { + long function_pointer = GLContext.getCapabilities().NV_parameter_buffer_object_glBindBufferOffsetNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglBindBufferOffsetNV(target, index, buffer, offset, function_pointer); + } + private static native void nglBindBufferOffsetNV(int target, int index, int buffer, long offset, long function_pointer); + + public static void glBindBufferBaseNV(int target, int index, int buffer) { + long function_pointer = GLContext.getCapabilities().NV_parameter_buffer_object_glBindBufferBaseNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglBindBufferBaseNV(target, index, buffer, function_pointer); + } + private static native void nglBindBufferBaseNV(int target, int index, int buffer, long function_pointer); + + public static void glProgramBufferParametersNV(int target, int buffer, int index, FloatBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_parameter_buffer_object_glProgramBufferParametersfvNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(params); + nglProgramBufferParametersfvNV(target, buffer, index, (params.remaining()) >> 2, params, params.position(), function_pointer); + } + private static native void nglProgramBufferParametersfvNV(int target, int buffer, int index, int count, FloatBuffer params, int params_position, long function_pointer); + + public static void glProgramBufferParametersINV(int target, int buffer, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_parameter_buffer_object_glProgramBufferParametersIivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(params); + nglProgramBufferParametersIivNV(target, buffer, index, (params.remaining()) >> 2, params, params.position(), function_pointer); + } + private static native void nglProgramBufferParametersIivNV(int target, int buffer, int index, int count, IntBuffer params, int params_position, long function_pointer); + + public static void glProgramBufferParametersIuNV(int target, int buffer, int index, IntBuffer params) { + long function_pointer = GLContext.getCapabilities().NV_parameter_buffer_object_glProgramBufferParametersIuivNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(params); + nglProgramBufferParametersIuivNV(target, buffer, index, (params.remaining()) >> 2, params, params.position(), function_pointer); + } + private static native void nglProgramBufferParametersIuivNV(int target, int buffer, int index, int count, IntBuffer params, int params_position, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/NVTransformFeeback.java b/src/generated/org/lwjgl/opengl/NVTransformFeeback.java new file mode 100644 index 00000000..f292cb48 --- /dev/null +++ b/src/generated/org/lwjgl/opengl/NVTransformFeeback.java @@ -0,0 +1,170 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +package org.lwjgl.opengl; + +import org.lwjgl.LWJGLException; +import org.lwjgl.BufferChecks; +import java.nio.*; + +public final class NVTransformFeeback { + /** + * Accepted by the <target> parameters of BindBuffer, BufferData, + * BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, + * GetBufferPointerv, BindBufferRangeNV, BindBufferOffsetNV and + * BindBufferBaseNV: + */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_NV = 0x8c8e; + /** + * Accepted by the <param> parameter of GetIntegerIndexedvEXT and + * GetBooleanIndexedvEXT: + */ + 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; + /** + * Accepted by the <param> parameter of GetIntegerIndexedvEXT and + * GetBooleanIndexedvEXT, and by the <pname> parameter of GetBooleanv, + * GetDoublev, GetIntegerv, and GetFloatv: + */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8c8f; + /** + * Accepted by the <bufferMode> parameter of TransformFeedbackAttribsNV and + * TransformFeedbackVaryingsNV: + */ + public static final int GL_INTERLEAVED_ATTRIBS_NV = 0x8c8c; + public static final int GL_SEPARATE_ATTRIBS_NV = 0x8c8d; + /** + * Accepted by the <target> parameter of BeginQuery, EndQuery, and + * GetQueryiv: + */ + public static final int GL_PRIMITIVES_GENERATED_NV = 0x8c87; + public static final int GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8c88; + /** + * Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, and by + * the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev: + */ + public static final int GL_RASTERIZER_DISCARD_NV = 0x8c89; + /** + * Accepted by the <pname> parameter of GetBooleanv, GetDoublev, GetIntegerv, + * and GetFloatv: + */ + 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_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8c80; + public static final int GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8c7e; + /** + *Accepted by the <pname> parameter of GetProgramiv: + */ + 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; + /** + * Accepted by the <pname> parameter of GetBooleanv, GetDoublev, GetIntegerv, + * GetFloatv, and GetProgramiv: + */ + public static final int GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8c7f; + /** + *Accepted by the <attribs> parameter of TransformFeedbackAttribsNV: + */ + 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; + + private NVTransformFeeback() { + } + + + public static void glBindBufferRangeNV(int target, int index, int buffer, long offset, long size) { + long function_pointer = GLContext.getCapabilities().NV_transform_feeback_glBindBufferRangeNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglBindBufferRangeNV(target, index, buffer, offset, size, function_pointer); + } + private static native void nglBindBufferRangeNV(int target, int index, int buffer, long offset, long size, long function_pointer); + + public static void glBindBufferOffsetNV(int target, int index, int buffer, long offset) { + long function_pointer = GLContext.getCapabilities().NV_transform_feeback_glBindBufferOffsetNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglBindBufferOffsetNV(target, index, buffer, offset, function_pointer); + } + private static native void nglBindBufferOffsetNV(int target, int index, int buffer, long offset, long function_pointer); + + public static void glBindBufferBaseNV(int target, int index, int buffer) { + long function_pointer = GLContext.getCapabilities().NV_transform_feeback_glBindBufferBaseNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglBindBufferBaseNV(target, index, buffer, function_pointer); + } + private static native void nglBindBufferBaseNV(int target, int index, int buffer, long function_pointer); + + public static void glTransformFeedbackAttribsNV(IntBuffer attribs, int bufferMode) { + long function_pointer = GLContext.getCapabilities().NV_transform_feeback_glTransformFeedbackAttribsNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(attribs); + nglTransformFeedbackAttribsNV((attribs.remaining()), attribs, attribs.position(), bufferMode, function_pointer); + } + private static native void nglTransformFeedbackAttribsNV(int count, IntBuffer attribs, int attribs_position, int bufferMode, long function_pointer); + + public static void glTransformFeedbackVaryingsNV(int program, IntBuffer locations, int bufferMode) { + long function_pointer = GLContext.getCapabilities().NV_transform_feeback_glTransformFeedbackVaryingsNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(locations); + nglTransformFeedbackVaryingsNV(program, (locations.remaining()), locations, locations.position(), bufferMode, function_pointer); + } + private static native void nglTransformFeedbackVaryingsNV(int program, int count, IntBuffer locations, int locations_position, int bufferMode, long function_pointer); + + public static void glBeginTransformFeedbackNV(int primitiveMode) { + long function_pointer = GLContext.getCapabilities().NV_transform_feeback_glBeginTransformFeedbackNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglBeginTransformFeedbackNV(primitiveMode, function_pointer); + } + private static native void nglBeginTransformFeedbackNV(int primitiveMode, long function_pointer); + + public static void glEndTransformFeedbackNV() { + long function_pointer = GLContext.getCapabilities().NV_transform_feeback_glEndTransformFeedbackNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + nglEndTransformFeedbackNV(function_pointer); + } + private static native void nglEndTransformFeedbackNV(long function_pointer); + + public static int glGetVaryingLocationNV(int program, ByteBuffer name) { + long function_pointer = GLContext.getCapabilities().NV_transform_feeback_glGetVaryingLocationNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(name); + BufferChecks.checkNullTerminated(name); + int __result = nglGetVaryingLocationNV(program, name, name.position(), function_pointer); + return __result; + } + private static native int nglGetVaryingLocationNV(int program, ByteBuffer name, int name_position, long function_pointer); + + public static void glGetActiveVaryingNV(int program, int index, IntBuffer length, IntBuffer size, IntBuffer type, ByteBuffer name) { + long function_pointer = GLContext.getCapabilities().NV_transform_feeback_glGetActiveVaryingNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(length, 1); + BufferChecks.checkBuffer(size, 1); + BufferChecks.checkBuffer(type, 1); + BufferChecks.checkDirect(name); + nglGetActiveVaryingNV(program, index, (name.remaining()), length, length.position(), size, size.position(), type, type.position(), name, name.position(), function_pointer); + } + private static native void nglGetActiveVaryingNV(int program, int index, int bufSize, IntBuffer length, int length_position, IntBuffer size, int size_position, IntBuffer type, int type_position, ByteBuffer name, int name_position, long function_pointer); + + public static void glActiveVaryingNV(int program, ByteBuffer name) { + long function_pointer = GLContext.getCapabilities().NV_transform_feeback_glActiveVaryingNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkDirect(name); + BufferChecks.checkNullTerminated(name); + nglActiveVaryingNV(program, name, name.position(), function_pointer); + } + private static native void nglActiveVaryingNV(int program, ByteBuffer name, int name_position, long function_pointer); + + public static void glGetTransformFeedbackVaryingNV(int program, int index, IntBuffer location) { + long function_pointer = GLContext.getCapabilities().NV_transform_feeback_glGetTransformFeedbackVaryingNV_pointer; + BufferChecks.checkFunctionAddress(function_pointer); + BufferChecks.checkBuffer(location, 1); + nglGetTransformFeedbackVaryingNV(program, index, location, location.position(), function_pointer); + } + private static native void nglGetTransformFeedbackVaryingNV(int program, int index, IntBuffer location, int location_position, long function_pointer); +} diff --git a/src/generated/org/lwjgl/opengl/References.java b/src/generated/org/lwjgl/opengl/References.java index 8d0eb3a7..32a477bb 100644 --- a/src/generated/org/lwjgl/opengl/References.java +++ b/src/generated/org/lwjgl/opengl/References.java @@ -9,6 +9,7 @@ class References { java.nio.Buffer ARB_vertex_shader_glVertexAttribPointerARB_buffer; java.nio.Buffer ATI_element_array_glElementPointerATI_pPointer; java.nio.Buffer EXT_fog_coord_glFogCoordPointerEXT_data; + java.nio.Buffer EXT_gpu_shader4_glVertexAttribIPointerEXT_buffer; java.nio.Buffer EXT_secondary_color_glSecondaryColorPointerEXT_pPointer; java.nio.Buffer EXT_vertex_shader_glVariantPointerEXT_pAddr; java.nio.Buffer EXT_vertex_weighting_glVertexWeightPointerEXT_pPointer; @@ -29,6 +30,7 @@ class References { this.ARB_vertex_shader_glVertexAttribPointerARB_buffer = references.ARB_vertex_shader_glVertexAttribPointerARB_buffer; this.ATI_element_array_glElementPointerATI_pPointer = references.ATI_element_array_glElementPointerATI_pPointer; this.EXT_fog_coord_glFogCoordPointerEXT_data = references.EXT_fog_coord_glFogCoordPointerEXT_data; + this.EXT_gpu_shader4_glVertexAttribIPointerEXT_buffer = references.EXT_gpu_shader4_glVertexAttribIPointerEXT_buffer; this.EXT_secondary_color_glSecondaryColorPointerEXT_pPointer = references.EXT_secondary_color_glSecondaryColorPointerEXT_pPointer; this.EXT_vertex_shader_glVariantPointerEXT_pAddr = references.EXT_vertex_shader_glVariantPointerEXT_pAddr; this.EXT_vertex_weighting_glVertexWeightPointerEXT_pPointer = references.EXT_vertex_weighting_glVertexWeightPointerEXT_pPointer; @@ -49,6 +51,7 @@ class References { this.ARB_vertex_shader_glVertexAttribPointerARB_buffer = null; this.ATI_element_array_glElementPointerATI_pPointer = null; this.EXT_fog_coord_glFogCoordPointerEXT_data = null; + this.EXT_gpu_shader4_glVertexAttribIPointerEXT_buffer = null; this.EXT_secondary_color_glSecondaryColorPointerEXT_pPointer = null; this.EXT_vertex_shader_glVariantPointerEXT_pAddr = null; this.EXT_vertex_weighting_glVertexWeightPointerEXT_pPointer = null; diff --git a/src/native/generated/org_lwjgl_opengl_EXTBindableUniform.c b/src/native/generated/org_lwjgl_opengl_EXTBindableUniform.c new file mode 100644 index 00000000..23bbfeb4 --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_EXTBindableUniform.c @@ -0,0 +1,26 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glUniformBufferEXTPROC) (GLuint program, GLint location, GLuint buffer); +typedef GLint (APIENTRY *glGetUniformBufferSizeEXTPROC) (GLuint program, GLint location); +typedef GLintptr (APIENTRY *glGetUniformOffsetEXTPROC) (GLuint program, GLint location); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTBindableUniform_nglUniformBufferEXT(JNIEnv *env, jclass clazz, jint program, jint location, jint buffer, jlong function_pointer) { + glUniformBufferEXTPROC glUniformBufferEXT = (glUniformBufferEXTPROC)((intptr_t)function_pointer); + glUniformBufferEXT(program, location, buffer); +} + +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTBindableUniform_nglGetUniformBufferSizeEXT(JNIEnv *env, jclass clazz, jint program, jint location, jlong function_pointer) { + glGetUniformBufferSizeEXTPROC glGetUniformBufferSizeEXT = (glGetUniformBufferSizeEXTPROC)((intptr_t)function_pointer); + GLint __result = glGetUniformBufferSizeEXT(program, location); + return __result; +} + +JNIEXPORT jlong JNICALL Java_org_lwjgl_opengl_EXTBindableUniform_nglGetUniformOffsetEXT(JNIEnv *env, jclass clazz, jint program, jint location, jlong function_pointer) { + glGetUniformOffsetEXTPROC glGetUniformOffsetEXT = (glGetUniformOffsetEXTPROC)((intptr_t)function_pointer); + GLintptr __result = glGetUniformOffsetEXT(program, location); + return __result; +} + diff --git a/src/native/generated/org_lwjgl_opengl_EXTDrawBuffers2.c b/src/native/generated/org_lwjgl_opengl_EXTDrawBuffers2.c new file mode 100644 index 00000000..51b92bc1 --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_EXTDrawBuffers2.c @@ -0,0 +1,45 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glColorMaskIndexedEXTPROC) (GLuint buf, GLboolean r, GLboolean g, GLboolean b, GLboolean a); +typedef void (APIENTRY *glGetBooleanIndexedvEXTPROC) (GLenum value, GLuint index, GLboolean * data); +typedef void (APIENTRY *glGetIntegerIndexedvEXTPROC) (GLenum value, GLuint index, GLint * data); +typedef void (APIENTRY *glEnableIndexedEXTPROC) (GLenum target, GLuint index); +typedef void (APIENTRY *glDisableIndexedEXTPROC) (GLenum target, GLuint index); +typedef GLboolean (APIENTRY *glIsEnabledIndexedEXTPROC) (GLenum target, GLuint index); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglColorMaskIndexedEXT(JNIEnv *env, jclass clazz, jint buf, jboolean r, jboolean g, jboolean b, jboolean a, jlong function_pointer) { + glColorMaskIndexedEXTPROC glColorMaskIndexedEXT = (glColorMaskIndexedEXTPROC)((intptr_t)function_pointer); + glColorMaskIndexedEXT(buf, r, g, b, a); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglGetBooleanIndexedvEXT(JNIEnv *env, jclass clazz, jint value, jint index, jobject data, jint data_position, jlong function_pointer) { + GLboolean *data_address = ((GLboolean *)(*env)->GetDirectBufferAddress(env, data)) + data_position; + glGetBooleanIndexedvEXTPROC glGetBooleanIndexedvEXT = (glGetBooleanIndexedvEXTPROC)((intptr_t)function_pointer); + glGetBooleanIndexedvEXT(value, index, data_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglGetIntegerIndexedvEXT(JNIEnv *env, jclass clazz, jint value, jint index, jobject data, jint data_position, jlong function_pointer) { + GLint *data_address = ((GLint *)(*env)->GetDirectBufferAddress(env, data)) + data_position; + glGetIntegerIndexedvEXTPROC glGetIntegerIndexedvEXT = (glGetIntegerIndexedvEXTPROC)((intptr_t)function_pointer); + glGetIntegerIndexedvEXT(value, index, data_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglEnableIndexedEXT(JNIEnv *env, jclass clazz, jint target, jint index, jlong function_pointer) { + glEnableIndexedEXTPROC glEnableIndexedEXT = (glEnableIndexedEXTPROC)((intptr_t)function_pointer); + glEnableIndexedEXT(target, index); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglDisableIndexedEXT(JNIEnv *env, jclass clazz, jint target, jint index, jlong function_pointer) { + glDisableIndexedEXTPROC glDisableIndexedEXT = (glDisableIndexedEXTPROC)((intptr_t)function_pointer); + glDisableIndexedEXT(target, index); +} + +JNIEXPORT jboolean JNICALL Java_org_lwjgl_opengl_EXTDrawBuffers2_nglIsEnabledIndexedEXT(JNIEnv *env, jclass clazz, jint target, jint index, jlong function_pointer) { + glIsEnabledIndexedEXTPROC glIsEnabledIndexedEXT = (glIsEnabledIndexedEXTPROC)((intptr_t)function_pointer); + GLboolean __result = glIsEnabledIndexedEXT(target, index); + return __result; +} + diff --git a/src/native/generated/org_lwjgl_opengl_EXTDrawInstanced.c b/src/native/generated/org_lwjgl_opengl_EXTDrawInstanced.c new file mode 100644 index 00000000..44632e65 --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_EXTDrawInstanced.c @@ -0,0 +1,25 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glDrawArraysInstancedEXTPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount); +typedef void (APIENTRY *glDrawElementsInstancedEXTPROC) (GLenum mode, GLsizei count, GLenum type, const GLvoid * indices, GLsizei primcount); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawInstanced_nglDrawArraysInstancedEXT(JNIEnv *env, jclass clazz, jint mode, jint first, jint count, jint primcount, jlong function_pointer) { + glDrawArraysInstancedEXTPROC glDrawArraysInstancedEXT = (glDrawArraysInstancedEXTPROC)((intptr_t)function_pointer); + glDrawArraysInstancedEXT(mode, first, count, primcount); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawInstanced_nglDrawElementsInstancedEXT(JNIEnv *env, jclass clazz, jint mode, jint count, jint type, jobject indices, jint indices_position, jint primcount, jlong function_pointer) { + const GLvoid *indices_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, indices)) + indices_position)); + glDrawElementsInstancedEXTPROC glDrawElementsInstancedEXT = (glDrawElementsInstancedEXTPROC)((intptr_t)function_pointer); + glDrawElementsInstancedEXT(mode, count, type, indices_address, primcount); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTDrawInstanced_nglDrawElementsInstancedEXTBO(JNIEnv *env, jclass clazz, jint mode, jint count, jint type, jlong indices_buffer_offset, jint primcount, jlong function_pointer) { + const GLvoid *indices_address = ((const GLvoid *)offsetToPointer(indices_buffer_offset)); + glDrawElementsInstancedEXTPROC glDrawElementsInstancedEXT = (glDrawElementsInstancedEXTPROC)((intptr_t)function_pointer); + glDrawElementsInstancedEXT(mode, count, type, indices_address, primcount); +} + diff --git a/src/native/generated/org_lwjgl_opengl_EXTGeometryShader4.c b/src/native/generated/org_lwjgl_opengl_EXTGeometryShader4.c new file mode 100644 index 00000000..1bb78393 --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_EXTGeometryShader4.c @@ -0,0 +1,30 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glProgramParameteriEXTPROC) (GLuint program, GLenum pname, GLint value); +typedef void (APIENTRY *glFramebufferTextureEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); +typedef void (APIENTRY *glFramebufferTextureLayerEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); +typedef void (APIENTRY *glFramebufferTextureFaceEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGeometryShader4_nglProgramParameteriEXT(JNIEnv *env, jclass clazz, jint program, jint pname, jint value, jlong function_pointer) { + glProgramParameteriEXTPROC glProgramParameteriEXT = (glProgramParameteriEXTPROC)((intptr_t)function_pointer); + glProgramParameteriEXT(program, pname, value); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGeometryShader4_nglFramebufferTextureEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jlong function_pointer) { + glFramebufferTextureEXTPROC glFramebufferTextureEXT = (glFramebufferTextureEXTPROC)((intptr_t)function_pointer); + glFramebufferTextureEXT(target, attachment, texture, level); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGeometryShader4_nglFramebufferTextureLayerEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jint layer, jlong function_pointer) { + glFramebufferTextureLayerEXTPROC glFramebufferTextureLayerEXT = (glFramebufferTextureLayerEXTPROC)((intptr_t)function_pointer); + glFramebufferTextureLayerEXT(target, attachment, texture, level, layer); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGeometryShader4_nglFramebufferTextureFaceEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jint face, jlong function_pointer) { + glFramebufferTextureFaceEXTPROC glFramebufferTextureFaceEXT = (glFramebufferTextureFaceEXTPROC)((intptr_t)function_pointer); + glFramebufferTextureFaceEXT(target, attachment, texture, level, face); +} + diff --git a/src/native/generated/org_lwjgl_opengl_EXTGpuShader4.c b/src/native/generated/org_lwjgl_opengl_EXTGpuShader4.c new file mode 100644 index 00000000..9df12a8f --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_EXTGpuShader4.c @@ -0,0 +1,239 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glVertexAttribI1iEXTPROC) (GLuint index, GLint x); +typedef void (APIENTRY *glVertexAttribI2iEXTPROC) (GLuint index, GLint x, GLint y); +typedef void (APIENTRY *glVertexAttribI3iEXTPROC) (GLuint index, GLint x, GLint y, GLint z); +typedef void (APIENTRY *glVertexAttribI4iEXTPROC) (GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (APIENTRY *glVertexAttribI1uiEXTPROC) (GLuint index, GLuint x); +typedef void (APIENTRY *glVertexAttribI2uiEXTPROC) (GLuint index, GLuint x, GLuint y); +typedef void (APIENTRY *glVertexAttribI3uiEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z); +typedef void (APIENTRY *glVertexAttribI4uiEXTPROC) (GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (APIENTRY *glVertexAttribI1ivEXTPROC) (GLuint index, const GLint * v); +typedef void (APIENTRY *glVertexAttribI2ivEXTPROC) (GLuint index, const GLint * v); +typedef void (APIENTRY *glVertexAttribI3ivEXTPROC) (GLuint index, const GLint * v); +typedef void (APIENTRY *glVertexAttribI4ivEXTPROC) (GLuint index, const GLint * v); +typedef void (APIENTRY *glVertexAttribI1uivEXTPROC) (GLuint index, const GLuint * v); +typedef void (APIENTRY *glVertexAttribI2uivEXTPROC) (GLuint index, const GLuint * v); +typedef void (APIENTRY *glVertexAttribI3uivEXTPROC) (GLuint index, const GLuint * v); +typedef void (APIENTRY *glVertexAttribI4uivEXTPROC) (GLuint index, const GLuint * v); +typedef void (APIENTRY *glVertexAttribI4bvEXTPROC) (GLuint index, const GLbyte * v); +typedef void (APIENTRY *glVertexAttribI4svEXTPROC) (GLuint index, const GLshort * v); +typedef void (APIENTRY *glVertexAttribI4ubvEXTPROC) (GLuint index, const GLubyte * v); +typedef void (APIENTRY *glVertexAttribI4usvEXTPROC) (GLuint index, const GLushort * v); +typedef void (APIENTRY *glVertexAttribIPointerEXTPROC) (GLuint index, GLint size, GLenum type, GLsizei stride, const GLvoid * buffer); +typedef void (APIENTRY *glGetVertexAttribIivEXTPROC) (GLuint index, GLenum pname, GLint * params); +typedef void (APIENTRY *glGetVertexAttribIuivEXTPROC) (GLuint index, GLenum pname, GLuint * params); +typedef void (APIENTRY *glUniform1uiEXTPROC) (GLint location, GLuint v0); +typedef void (APIENTRY *glUniform2uiEXTPROC) (GLint location, GLuint v0, GLuint v1); +typedef void (APIENTRY *glUniform3uiEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2); +typedef void (APIENTRY *glUniform4uiEXTPROC) (GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3); +typedef void (APIENTRY *glUniform1uivEXTPROC) (GLint location, GLsizei count, const GLuint * value); +typedef void (APIENTRY *glUniform2uivEXTPROC) (GLint location, GLsizei count, const GLuint * value); +typedef void (APIENTRY *glUniform3uivEXTPROC) (GLint location, GLsizei count, const GLuint * value); +typedef void (APIENTRY *glUniform4uivEXTPROC) (GLint location, GLsizei count, const GLuint * value); +typedef void (APIENTRY *glGetUniformuivEXTPROC) (GLuint program, GLint location, GLuint * params); +typedef void (APIENTRY *glBindFragDataLocationEXTPROC) (GLuint program, GLuint colorNumber, const GLchar * name); +typedef GLint (APIENTRY *glGetFragDataLocationEXTPROC) (GLuint program, const GLchar * name); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI1iEXT(JNIEnv *env, jclass clazz, jint index, jint x, jlong function_pointer) { + glVertexAttribI1iEXTPROC glVertexAttribI1iEXT = (glVertexAttribI1iEXTPROC)((intptr_t)function_pointer); + glVertexAttribI1iEXT(index, x); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI2iEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jlong function_pointer) { + glVertexAttribI2iEXTPROC glVertexAttribI2iEXT = (glVertexAttribI2iEXTPROC)((intptr_t)function_pointer); + glVertexAttribI2iEXT(index, x, y); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI3iEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jint z, jlong function_pointer) { + glVertexAttribI3iEXTPROC glVertexAttribI3iEXT = (glVertexAttribI3iEXTPROC)((intptr_t)function_pointer); + glVertexAttribI3iEXT(index, x, y, z); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4iEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) { + glVertexAttribI4iEXTPROC glVertexAttribI4iEXT = (glVertexAttribI4iEXTPROC)((intptr_t)function_pointer); + glVertexAttribI4iEXT(index, x, y, z, w); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI1uiEXT(JNIEnv *env, jclass clazz, jint index, jint x, jlong function_pointer) { + glVertexAttribI1uiEXTPROC glVertexAttribI1uiEXT = (glVertexAttribI1uiEXTPROC)((intptr_t)function_pointer); + glVertexAttribI1uiEXT(index, x); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI2uiEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jlong function_pointer) { + glVertexAttribI2uiEXTPROC glVertexAttribI2uiEXT = (glVertexAttribI2uiEXTPROC)((intptr_t)function_pointer); + glVertexAttribI2uiEXT(index, x, y); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI3uiEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jint z, jlong function_pointer) { + glVertexAttribI3uiEXTPROC glVertexAttribI3uiEXT = (glVertexAttribI3uiEXTPROC)((intptr_t)function_pointer); + glVertexAttribI3uiEXT(index, x, y, z); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4uiEXT(JNIEnv *env, jclass clazz, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) { + glVertexAttribI4uiEXTPROC glVertexAttribI4uiEXT = (glVertexAttribI4uiEXTPROC)((intptr_t)function_pointer); + glVertexAttribI4uiEXT(index, x, y, z, w); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI1ivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLint *v_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI1ivEXTPROC glVertexAttribI1ivEXT = (glVertexAttribI1ivEXTPROC)((intptr_t)function_pointer); + glVertexAttribI1ivEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI2ivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLint *v_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI2ivEXTPROC glVertexAttribI2ivEXT = (glVertexAttribI2ivEXTPROC)((intptr_t)function_pointer); + glVertexAttribI2ivEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI3ivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLint *v_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI3ivEXTPROC glVertexAttribI3ivEXT = (glVertexAttribI3ivEXTPROC)((intptr_t)function_pointer); + glVertexAttribI3ivEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4ivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLint *v_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI4ivEXTPROC glVertexAttribI4ivEXT = (glVertexAttribI4ivEXTPROC)((intptr_t)function_pointer); + glVertexAttribI4ivEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI1uivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLuint *v_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI1uivEXTPROC glVertexAttribI1uivEXT = (glVertexAttribI1uivEXTPROC)((intptr_t)function_pointer); + glVertexAttribI1uivEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI2uivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLuint *v_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI2uivEXTPROC glVertexAttribI2uivEXT = (glVertexAttribI2uivEXTPROC)((intptr_t)function_pointer); + glVertexAttribI2uivEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI3uivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLuint *v_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI3uivEXTPROC glVertexAttribI3uivEXT = (glVertexAttribI3uivEXTPROC)((intptr_t)function_pointer); + glVertexAttribI3uivEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4uivEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLuint *v_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI4uivEXTPROC glVertexAttribI4uivEXT = (glVertexAttribI4uivEXTPROC)((intptr_t)function_pointer); + glVertexAttribI4uivEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4bvEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLbyte *v_address = ((const GLbyte *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI4bvEXTPROC glVertexAttribI4bvEXT = (glVertexAttribI4bvEXTPROC)((intptr_t)function_pointer); + glVertexAttribI4bvEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4svEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLshort *v_address = ((const GLshort *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI4svEXTPROC glVertexAttribI4svEXT = (glVertexAttribI4svEXTPROC)((intptr_t)function_pointer); + glVertexAttribI4svEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4ubvEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLubyte *v_address = ((const GLubyte *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI4ubvEXTPROC glVertexAttribI4ubvEXT = (glVertexAttribI4ubvEXTPROC)((intptr_t)function_pointer); + glVertexAttribI4ubvEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribI4usvEXT(JNIEnv *env, jclass clazz, jint index, jobject v, jint v_position, jlong function_pointer) { + const GLushort *v_address = ((const GLushort *)(*env)->GetDirectBufferAddress(env, v)) + v_position; + glVertexAttribI4usvEXTPROC glVertexAttribI4usvEXT = (glVertexAttribI4usvEXTPROC)((intptr_t)function_pointer); + glVertexAttribI4usvEXT(index, v_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribIPointerEXT(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jint stride, jobject buffer, jint buffer_position, jlong function_pointer) { + const GLvoid *buffer_address = ((const GLvoid *)(((char *)(*env)->GetDirectBufferAddress(env, buffer)) + buffer_position)); + glVertexAttribIPointerEXTPROC glVertexAttribIPointerEXT = (glVertexAttribIPointerEXTPROC)((intptr_t)function_pointer); + glVertexAttribIPointerEXT(index, size, type, stride, buffer_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglVertexAttribIPointerEXTBO(JNIEnv *env, jclass clazz, jint index, jint size, jint type, jint stride, jlong buffer_buffer_offset, jlong function_pointer) { + const GLvoid *buffer_address = ((const GLvoid *)offsetToPointer(buffer_buffer_offset)); + glVertexAttribIPointerEXTPROC glVertexAttribIPointerEXT = (glVertexAttribIPointerEXTPROC)((intptr_t)function_pointer); + glVertexAttribIPointerEXT(index, size, type, stride, buffer_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglGetVertexAttribIivEXT(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) { + GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glGetVertexAttribIivEXTPROC glGetVertexAttribIivEXT = (glGetVertexAttribIivEXTPROC)((intptr_t)function_pointer); + glGetVertexAttribIivEXT(index, pname, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglGetVertexAttribIuivEXT(JNIEnv *env, jclass clazz, jint index, jint pname, jobject params, jint params_position, jlong function_pointer) { + GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glGetVertexAttribIuivEXTPROC glGetVertexAttribIuivEXT = (glGetVertexAttribIuivEXTPROC)((intptr_t)function_pointer); + glGetVertexAttribIuivEXT(index, pname, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform1uiEXT(JNIEnv *env, jclass clazz, jint location, jint v0, jlong function_pointer) { + glUniform1uiEXTPROC glUniform1uiEXT = (glUniform1uiEXTPROC)((intptr_t)function_pointer); + glUniform1uiEXT(location, v0); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform2uiEXT(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jlong function_pointer) { + glUniform2uiEXTPROC glUniform2uiEXT = (glUniform2uiEXTPROC)((intptr_t)function_pointer); + glUniform2uiEXT(location, v0, v1); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform3uiEXT(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jint v2, jlong function_pointer) { + glUniform3uiEXTPROC glUniform3uiEXT = (glUniform3uiEXTPROC)((intptr_t)function_pointer); + glUniform3uiEXT(location, v0, v1, v2); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform4uiEXT(JNIEnv *env, jclass clazz, jint location, jint v0, jint v1, jint v2, jint v3, jlong function_pointer) { + glUniform4uiEXTPROC glUniform4uiEXT = (glUniform4uiEXTPROC)((intptr_t)function_pointer); + glUniform4uiEXT(location, v0, v1, v2, v3); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform1uivEXT(JNIEnv *env, jclass clazz, jint location, jint count, jobject value, jint value_position, jlong function_pointer) { + const GLuint *value_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, value)) + value_position; + glUniform1uivEXTPROC glUniform1uivEXT = (glUniform1uivEXTPROC)((intptr_t)function_pointer); + glUniform1uivEXT(location, count, value_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform2uivEXT(JNIEnv *env, jclass clazz, jint location, jint count, jobject value, jint value_position, jlong function_pointer) { + const GLuint *value_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, value)) + value_position; + glUniform2uivEXTPROC glUniform2uivEXT = (glUniform2uivEXTPROC)((intptr_t)function_pointer); + glUniform2uivEXT(location, count, value_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform3uivEXT(JNIEnv *env, jclass clazz, jint location, jint count, jobject value, jint value_position, jlong function_pointer) { + const GLuint *value_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, value)) + value_position; + glUniform3uivEXTPROC glUniform3uivEXT = (glUniform3uivEXTPROC)((intptr_t)function_pointer); + glUniform3uivEXT(location, count, value_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglUniform4uivEXT(JNIEnv *env, jclass clazz, jint location, jint count, jobject value, jint value_position, jlong function_pointer) { + const GLuint *value_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, value)) + value_position; + glUniform4uivEXTPROC glUniform4uivEXT = (glUniform4uivEXTPROC)((intptr_t)function_pointer); + glUniform4uivEXT(location, count, value_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglGetUniformuivEXT(JNIEnv *env, jclass clazz, jint program, jint location, jobject params, jint params_position, jlong function_pointer) { + GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glGetUniformuivEXTPROC glGetUniformuivEXT = (glGetUniformuivEXTPROC)((intptr_t)function_pointer); + glGetUniformuivEXT(program, location, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglBindFragDataLocationEXT(JNIEnv *env, jclass clazz, jint program, jint colorNumber, jobject name, jint name_position, jlong function_pointer) { + const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position; + glBindFragDataLocationEXTPROC glBindFragDataLocationEXT = (glBindFragDataLocationEXTPROC)((intptr_t)function_pointer); + glBindFragDataLocationEXT(program, colorNumber, name_address); +} + +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_EXTGpuShader4_nglGetFragDataLocationEXT(JNIEnv *env, jclass clazz, jint program, jobject name, jint name_position, jlong function_pointer) { + const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position; + glGetFragDataLocationEXTPROC glGetFragDataLocationEXT = (glGetFragDataLocationEXTPROC)((intptr_t)function_pointer); + GLint __result = glGetFragDataLocationEXT(program, name_address); + return __result; +} + diff --git a/src/native/generated/org_lwjgl_opengl_EXTTextureArray.c b/src/native/generated/org_lwjgl_opengl_EXTTextureArray.c new file mode 100644 index 00000000..057df6da --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_EXTTextureArray.c @@ -0,0 +1,12 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glFramebufferTextureLayerEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureArray_nglFramebufferTextureLayerEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jint layer, jlong function_pointer) { + glFramebufferTextureLayerEXTPROC glFramebufferTextureLayerEXT = (glFramebufferTextureLayerEXTPROC)((intptr_t)function_pointer); + glFramebufferTextureLayerEXT(target, attachment, texture, level, layer); +} + diff --git a/src/native/generated/org_lwjgl_opengl_EXTTextureBufferObject.c b/src/native/generated/org_lwjgl_opengl_EXTTextureBufferObject.c new file mode 100644 index 00000000..301d2e1f --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_EXTTextureBufferObject.c @@ -0,0 +1,12 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glTexBufferEXTPROC) (GLenum target, GLenum internalformat, GLuint buffer); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureBufferObject_nglTexBufferEXT(JNIEnv *env, jclass clazz, jint target, jint internalformat, jint buffer, jlong function_pointer) { + glTexBufferEXTPROC glTexBufferEXT = (glTexBufferEXTPROC)((intptr_t)function_pointer); + glTexBufferEXT(target, internalformat, buffer); +} + diff --git a/src/native/generated/org_lwjgl_opengl_EXTTextureInteger.c b/src/native/generated/org_lwjgl_opengl_EXTTextureInteger.c new file mode 100644 index 00000000..75cf6923 --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_EXTTextureInteger.c @@ -0,0 +1,46 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glClearColorIiEXTPROC) (GLint r, GLint g, GLint b, GLint a); +typedef void (APIENTRY *glClearColorIuiEXTPROC) (GLuint r, GLuint g, GLuint b, GLuint a); +typedef void (APIENTRY *glTexParameterIivEXTPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (APIENTRY *glTexParameterIuivEXTPROC) (GLenum target, GLenum pname, GLuint * params); +typedef void (APIENTRY *glGetTexParameterIivEXTPROC) (GLenum target, GLenum pname, GLint * params); +typedef void (APIENTRY *glGetTexParameterIuivEXTPROC) (GLenum target, GLenum pname, GLuint * params); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglClearColorIiEXT(JNIEnv *env, jclass clazz, jint r, jint g, jint b, jint a, jlong function_pointer) { + glClearColorIiEXTPROC glClearColorIiEXT = (glClearColorIiEXTPROC)((intptr_t)function_pointer); + glClearColorIiEXT(r, g, b, a); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglClearColorIuiEXT(JNIEnv *env, jclass clazz, jint r, jint g, jint b, jint a, jlong function_pointer) { + glClearColorIuiEXTPROC glClearColorIuiEXT = (glClearColorIuiEXTPROC)((intptr_t)function_pointer); + glClearColorIuiEXT(r, g, b, a); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglTexParameterIivEXT(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) { + GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glTexParameterIivEXTPROC glTexParameterIivEXT = (glTexParameterIivEXTPROC)((intptr_t)function_pointer); + glTexParameterIivEXT(target, pname, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglTexParameterIuivEXT(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) { + GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glTexParameterIuivEXTPROC glTexParameterIuivEXT = (glTexParameterIuivEXTPROC)((intptr_t)function_pointer); + glTexParameterIuivEXT(target, pname, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglGetTexParameterIivEXT(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) { + GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glGetTexParameterIivEXTPROC glGetTexParameterIivEXT = (glGetTexParameterIivEXTPROC)((intptr_t)function_pointer); + glGetTexParameterIivEXT(target, pname, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_EXTTextureInteger_nglGetTexParameterIuivEXT(JNIEnv *env, jclass clazz, jint target, jint pname, jobject params, jint params_position, jlong function_pointer) { + GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glGetTexParameterIuivEXTPROC glGetTexParameterIuivEXT = (glGetTexParameterIuivEXTPROC)((intptr_t)function_pointer); + glGetTexParameterIuivEXT(target, pname, params_address); +} + diff --git a/src/native/generated/org_lwjgl_opengl_NVDepthBufferFloat.c b/src/native/generated/org_lwjgl_opengl_NVDepthBufferFloat.c new file mode 100644 index 00000000..f7db3eed --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_NVDepthBufferFloat.c @@ -0,0 +1,24 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glDepthRangedNVPROC) (GLdouble n, GLdouble f); +typedef void (APIENTRY *glClearDepthdNVPROC) (GLdouble d); +typedef void (APIENTRY *glDepthBoundsdNVPROC) (GLdouble zmin, GLdouble zmax); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVDepthBufferFloat_nglDepthRangedNV(JNIEnv *env, jclass clazz, jdouble n, jdouble f, jlong function_pointer) { + glDepthRangedNVPROC glDepthRangedNV = (glDepthRangedNVPROC)((intptr_t)function_pointer); + glDepthRangedNV(n, f); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVDepthBufferFloat_nglClearDepthdNV(JNIEnv *env, jclass clazz, jdouble d, jlong function_pointer) { + glClearDepthdNVPROC glClearDepthdNV = (glClearDepthdNVPROC)((intptr_t)function_pointer); + glClearDepthdNV(d); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVDepthBufferFloat_nglDepthBoundsdNV(JNIEnv *env, jclass clazz, jdouble zmin, jdouble zmax, jlong function_pointer) { + glDepthBoundsdNVPROC glDepthBoundsdNV = (glDepthBoundsdNVPROC)((intptr_t)function_pointer); + glDepthBoundsdNV(zmin, zmax); +} + diff --git a/src/native/generated/org_lwjgl_opengl_NVFramebufferMultisampleCoverage.c b/src/native/generated/org_lwjgl_opengl_NVFramebufferMultisampleCoverage.c new file mode 100644 index 00000000..38b37402 --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_NVFramebufferMultisampleCoverage.c @@ -0,0 +1,12 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glRenderbufferStorageMultsampleCoverageNVPROC) (GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVFramebufferMultisampleCoverage_nglRenderbufferStorageMultsampleCoverageNV(JNIEnv *env, jclass clazz, jint target, jint coverageSamples, jint colorSamples, jint internalformat, jint width, jint height, jlong function_pointer) { + glRenderbufferStorageMultsampleCoverageNVPROC glRenderbufferStorageMultsampleCoverageNV = (glRenderbufferStorageMultsampleCoverageNVPROC)((intptr_t)function_pointer); + glRenderbufferStorageMultsampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height); +} + diff --git a/src/native/generated/org_lwjgl_opengl_NVGeometryProgram4.c b/src/native/generated/org_lwjgl_opengl_NVGeometryProgram4.c new file mode 100644 index 00000000..8f81748d --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_NVGeometryProgram4.c @@ -0,0 +1,24 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glProgramVertexLimitNVPROC) (GLenum target, GLint limit); +typedef void (APIENTRY *glFramebufferTextureEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level); +typedef void (APIENTRY *glFramebufferTextureLayerEXTPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGeometryProgram4_nglProgramVertexLimitNV(JNIEnv *env, jclass clazz, jint target, jint limit, jlong function_pointer) { + glProgramVertexLimitNVPROC glProgramVertexLimitNV = (glProgramVertexLimitNVPROC)((intptr_t)function_pointer); + glProgramVertexLimitNV(target, limit); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGeometryProgram4_nglFramebufferTextureEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jlong function_pointer) { + glFramebufferTextureEXTPROC glFramebufferTextureEXT = (glFramebufferTextureEXTPROC)((intptr_t)function_pointer); + glFramebufferTextureEXT(target, attachment, texture, level); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGeometryProgram4_nglFramebufferTextureLayerEXT(JNIEnv *env, jclass clazz, jint target, jint attachment, jint texture, jint level, jint layer, jlong function_pointer) { + glFramebufferTextureLayerEXTPROC glFramebufferTextureLayerEXT = (glFramebufferTextureLayerEXTPROC)((intptr_t)function_pointer); + glFramebufferTextureLayerEXT(target, attachment, texture, level, layer); +} + diff --git a/src/native/generated/org_lwjgl_opengl_NVGpuProgram4.c b/src/native/generated/org_lwjgl_opengl_NVGpuProgram4.c new file mode 100644 index 00000000..f0a05c07 --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_NVGpuProgram4.c @@ -0,0 +1,114 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glProgramLocalParameterI4iNVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (APIENTRY *glProgramLocalParameterI4ivNVPROC) (GLenum target, GLuint index, const GLint * params); +typedef void (APIENTRY *glProgramLocalParametersI4ivNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint * params); +typedef void (APIENTRY *glProgramLocalParameterI4uiNVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (APIENTRY *glProgramLocalParameterI4uivNVPROC) (GLenum target, GLuint index, const GLuint * params); +typedef void (APIENTRY *glProgramLocalParametersI4uivNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint * params); +typedef void (APIENTRY *glProgramEnvParameterI4iNVPROC) (GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w); +typedef void (APIENTRY *glProgramEnvParameterI4ivNVPROC) (GLenum target, GLuint index, const GLint * params); +typedef void (APIENTRY *glProgramEnvParametersI4ivNVPROC) (GLenum target, GLuint index, GLsizei count, const GLint * params); +typedef void (APIENTRY *glProgramEnvParameterI4uiNVPROC) (GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w); +typedef void (APIENTRY *glProgramEnvParameterI4uivNVPROC) (GLenum target, GLuint index, const GLuint * params); +typedef void (APIENTRY *glProgramEnvParametersI4uivNVPROC) (GLenum target, GLuint index, GLsizei count, const GLuint * params); +typedef void (APIENTRY *glGetProgramLocalParameterIivNVPROC) (GLenum target, GLuint index, GLint * params); +typedef void (APIENTRY *glGetProgramLocalParameterIuivNVPROC) (GLenum target, GLuint index, GLuint * params); +typedef void (APIENTRY *glGetProgramEnvParameterIivNVPROC) (GLenum target, GLuint index, GLint * params); +typedef void (APIENTRY *glGetProgramEnvParameterIuivNVPROC) (GLenum target, GLuint index, GLuint * params); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParameterI4iNV(JNIEnv *env, jclass clazz, jint target, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) { + glProgramLocalParameterI4iNVPROC glProgramLocalParameterI4iNV = (glProgramLocalParameterI4iNVPROC)((intptr_t)function_pointer); + glProgramLocalParameterI4iNV(target, index, x, y, z, w); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParameterI4ivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) { + const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glProgramLocalParameterI4ivNVPROC glProgramLocalParameterI4ivNV = (glProgramLocalParameterI4ivNVPROC)((intptr_t)function_pointer); + glProgramLocalParameterI4ivNV(target, index, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParametersI4ivNV(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) { + const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glProgramLocalParametersI4ivNVPROC glProgramLocalParametersI4ivNV = (glProgramLocalParametersI4ivNVPROC)((intptr_t)function_pointer); + glProgramLocalParametersI4ivNV(target, index, count, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParameterI4uiNV(JNIEnv *env, jclass clazz, jint target, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) { + glProgramLocalParameterI4uiNVPROC glProgramLocalParameterI4uiNV = (glProgramLocalParameterI4uiNVPROC)((intptr_t)function_pointer); + glProgramLocalParameterI4uiNV(target, index, x, y, z, w); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParameterI4uivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) { + const GLuint *params_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glProgramLocalParameterI4uivNVPROC glProgramLocalParameterI4uivNV = (glProgramLocalParameterI4uivNVPROC)((intptr_t)function_pointer); + glProgramLocalParameterI4uivNV(target, index, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramLocalParametersI4uivNV(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) { + const GLuint *params_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glProgramLocalParametersI4uivNVPROC glProgramLocalParametersI4uivNV = (glProgramLocalParametersI4uivNVPROC)((intptr_t)function_pointer); + glProgramLocalParametersI4uivNV(target, index, count, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParameterI4iNV(JNIEnv *env, jclass clazz, jint target, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) { + glProgramEnvParameterI4iNVPROC glProgramEnvParameterI4iNV = (glProgramEnvParameterI4iNVPROC)((intptr_t)function_pointer); + glProgramEnvParameterI4iNV(target, index, x, y, z, w); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParameterI4ivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) { + const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glProgramEnvParameterI4ivNVPROC glProgramEnvParameterI4ivNV = (glProgramEnvParameterI4ivNVPROC)((intptr_t)function_pointer); + glProgramEnvParameterI4ivNV(target, index, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParametersI4ivNV(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) { + const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glProgramEnvParametersI4ivNVPROC glProgramEnvParametersI4ivNV = (glProgramEnvParametersI4ivNVPROC)((intptr_t)function_pointer); + glProgramEnvParametersI4ivNV(target, index, count, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParameterI4uiNV(JNIEnv *env, jclass clazz, jint target, jint index, jint x, jint y, jint z, jint w, jlong function_pointer) { + glProgramEnvParameterI4uiNVPROC glProgramEnvParameterI4uiNV = (glProgramEnvParameterI4uiNVPROC)((intptr_t)function_pointer); + glProgramEnvParameterI4uiNV(target, index, x, y, z, w); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParameterI4uivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) { + const GLuint *params_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glProgramEnvParameterI4uivNVPROC glProgramEnvParameterI4uivNV = (glProgramEnvParameterI4uivNVPROC)((intptr_t)function_pointer); + glProgramEnvParameterI4uivNV(target, index, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglProgramEnvParametersI4uivNV(JNIEnv *env, jclass clazz, jint target, jint index, jint count, jobject params, jint params_position, jlong function_pointer) { + const GLuint *params_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glProgramEnvParametersI4uivNVPROC glProgramEnvParametersI4uivNV = (glProgramEnvParametersI4uivNVPROC)((intptr_t)function_pointer); + glProgramEnvParametersI4uivNV(target, index, count, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglGetProgramLocalParameterIivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) { + GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glGetProgramLocalParameterIivNVPROC glGetProgramLocalParameterIivNV = (glGetProgramLocalParameterIivNVPROC)((intptr_t)function_pointer); + glGetProgramLocalParameterIivNV(target, index, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglGetProgramLocalParameterIuivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) { + GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glGetProgramLocalParameterIuivNVPROC glGetProgramLocalParameterIuivNV = (glGetProgramLocalParameterIuivNVPROC)((intptr_t)function_pointer); + glGetProgramLocalParameterIuivNV(target, index, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglGetProgramEnvParameterIivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) { + GLint *params_address = ((GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glGetProgramEnvParameterIivNVPROC glGetProgramEnvParameterIivNV = (glGetProgramEnvParameterIivNVPROC)((intptr_t)function_pointer); + glGetProgramEnvParameterIivNV(target, index, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVGpuProgram4_nglGetProgramEnvParameterIuivNV(JNIEnv *env, jclass clazz, jint target, jint index, jobject params, jint params_position, jlong function_pointer) { + GLuint *params_address = ((GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glGetProgramEnvParameterIuivNVPROC glGetProgramEnvParameterIuivNV = (glGetProgramEnvParameterIuivNVPROC)((intptr_t)function_pointer); + glGetProgramEnvParameterIuivNV(target, index, params_address); +} + diff --git a/src/native/generated/org_lwjgl_opengl_NVParameterBufferObject.c b/src/native/generated/org_lwjgl_opengl_NVParameterBufferObject.c new file mode 100644 index 00000000..a9fc08c5 --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_NVParameterBufferObject.c @@ -0,0 +1,45 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glBindBufferRangeNVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +typedef void (APIENTRY *glBindBufferOffsetNVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset); +typedef void (APIENTRY *glBindBufferBaseNVPROC) (GLenum target, GLuint index, GLuint buffer); +typedef void (APIENTRY *glProgramBufferParametersfvNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLfloat * params); +typedef void (APIENTRY *glProgramBufferParametersIivNVPROC) (GLenum target, GLuint buffer, GLuint index, GLsizei count, const GLint * params); +typedef void (APIENTRY *glProgramBufferParametersIuivNVPROC) (GLenum target, GLuint buffer, GLuint index, GLuint count, const GLuint * params); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVParameterBufferObject_nglBindBufferRangeNV(JNIEnv *env, jclass clazz, jint target, jint index, jint buffer, jlong offset, jlong size, jlong function_pointer) { + glBindBufferRangeNVPROC glBindBufferRangeNV = (glBindBufferRangeNVPROC)((intptr_t)function_pointer); + glBindBufferRangeNV(target, index, buffer, offset, size); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVParameterBufferObject_nglBindBufferOffsetNV(JNIEnv *env, jclass clazz, jint target, jint index, jint buffer, jlong offset, jlong function_pointer) { + glBindBufferOffsetNVPROC glBindBufferOffsetNV = (glBindBufferOffsetNVPROC)((intptr_t)function_pointer); + glBindBufferOffsetNV(target, index, buffer, offset); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVParameterBufferObject_nglBindBufferBaseNV(JNIEnv *env, jclass clazz, jint target, jint index, jint buffer, jlong function_pointer) { + glBindBufferBaseNVPROC glBindBufferBaseNV = (glBindBufferBaseNVPROC)((intptr_t)function_pointer); + glBindBufferBaseNV(target, index, buffer); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVParameterBufferObject_nglProgramBufferParametersfvNV(JNIEnv *env, jclass clazz, jint target, jint buffer, jint index, jint count, jobject params, jint params_position, jlong function_pointer) { + const GLfloat *params_address = ((const GLfloat *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glProgramBufferParametersfvNVPROC glProgramBufferParametersfvNV = (glProgramBufferParametersfvNVPROC)((intptr_t)function_pointer); + glProgramBufferParametersfvNV(target, buffer, index, count, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVParameterBufferObject_nglProgramBufferParametersIivNV(JNIEnv *env, jclass clazz, jint target, jint buffer, jint index, jint count, jobject params, jint params_position, jlong function_pointer) { + const GLint *params_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glProgramBufferParametersIivNVPROC glProgramBufferParametersIivNV = (glProgramBufferParametersIivNVPROC)((intptr_t)function_pointer); + glProgramBufferParametersIivNV(target, buffer, index, count, params_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVParameterBufferObject_nglProgramBufferParametersIuivNV(JNIEnv *env, jclass clazz, jint target, jint buffer, jint index, jint count, jobject params, jint params_position, jlong function_pointer) { + const GLuint *params_address = ((const GLuint *)(*env)->GetDirectBufferAddress(env, params)) + params_position; + glProgramBufferParametersIuivNVPROC glProgramBufferParametersIuivNV = (glProgramBufferParametersIuivNVPROC)((intptr_t)function_pointer); + glProgramBufferParametersIuivNV(target, buffer, index, count, params_address); +} + diff --git a/src/native/generated/org_lwjgl_opengl_NVTransformFeeback.c b/src/native/generated/org_lwjgl_opengl_NVTransformFeeback.c new file mode 100644 index 00000000..7cb5a1a1 --- /dev/null +++ b/src/native/generated/org_lwjgl_opengl_NVTransformFeeback.c @@ -0,0 +1,82 @@ +/* MACHINE GENERATED FILE, DO NOT EDIT */ + +#include +#include "extgl.h" + +typedef void (APIENTRY *glBindBufferRangeNVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size); +typedef void (APIENTRY *glBindBufferOffsetNVPROC) (GLenum target, GLuint index, GLuint buffer, GLintptr offset); +typedef void (APIENTRY *glBindBufferBaseNVPROC) (GLenum target, GLuint index, GLuint buffer); +typedef void (APIENTRY *glTransformFeedbackAttribsNVPROC) (GLsizei count, const GLint * attribs, GLenum bufferMode); +typedef void (APIENTRY *glTransformFeedbackVaryingsNVPROC) (GLuint program, GLsizei count, const GLint * locations, GLenum bufferMode); +typedef void (APIENTRY *glBeginTransformFeedbackNVPROC) (GLenum primitiveMode); +typedef void (APIENTRY *glEndTransformFeedbackNVPROC) (); +typedef GLint (APIENTRY *glGetVaryingLocationNVPROC) (GLuint program, const GLchar * name); +typedef void (APIENTRY *glGetActiveVaryingNVPROC) (GLuint program, GLuint index, GLsizei bufSize, GLsizei * length, GLsizei * size, GLenum * type, GLchar * name); +typedef void (APIENTRY *glActiveVaryingNVPROC) (GLuint program, const GLchar * name); +typedef void (APIENTRY *glGetTransformFeedbackVaryingNVPROC) (GLuint program, GLuint index, GLint * location); + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeeback_nglBindBufferRangeNV(JNIEnv *env, jclass clazz, jint target, jint index, jint buffer, jlong offset, jlong size, jlong function_pointer) { + glBindBufferRangeNVPROC glBindBufferRangeNV = (glBindBufferRangeNVPROC)((intptr_t)function_pointer); + glBindBufferRangeNV(target, index, buffer, offset, size); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeeback_nglBindBufferOffsetNV(JNIEnv *env, jclass clazz, jint target, jint index, jint buffer, jlong offset, jlong function_pointer) { + glBindBufferOffsetNVPROC glBindBufferOffsetNV = (glBindBufferOffsetNVPROC)((intptr_t)function_pointer); + glBindBufferOffsetNV(target, index, buffer, offset); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeeback_nglBindBufferBaseNV(JNIEnv *env, jclass clazz, jint target, jint index, jint buffer, jlong function_pointer) { + glBindBufferBaseNVPROC glBindBufferBaseNV = (glBindBufferBaseNVPROC)((intptr_t)function_pointer); + glBindBufferBaseNV(target, index, buffer); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeeback_nglTransformFeedbackAttribsNV(JNIEnv *env, jclass clazz, jint count, jobject attribs, jint attribs_position, jint bufferMode, jlong function_pointer) { + const GLint *attribs_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, attribs)) + attribs_position; + glTransformFeedbackAttribsNVPROC glTransformFeedbackAttribsNV = (glTransformFeedbackAttribsNVPROC)((intptr_t)function_pointer); + glTransformFeedbackAttribsNV(count, attribs_address, bufferMode); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeeback_nglTransformFeedbackVaryingsNV(JNIEnv *env, jclass clazz, jint program, jint count, jobject locations, jint locations_position, jint bufferMode, jlong function_pointer) { + const GLint *locations_address = ((const GLint *)(*env)->GetDirectBufferAddress(env, locations)) + locations_position; + glTransformFeedbackVaryingsNVPROC glTransformFeedbackVaryingsNV = (glTransformFeedbackVaryingsNVPROC)((intptr_t)function_pointer); + glTransformFeedbackVaryingsNV(program, count, locations_address, bufferMode); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeeback_nglBeginTransformFeedbackNV(JNIEnv *env, jclass clazz, jint primitiveMode, jlong function_pointer) { + glBeginTransformFeedbackNVPROC glBeginTransformFeedbackNV = (glBeginTransformFeedbackNVPROC)((intptr_t)function_pointer); + glBeginTransformFeedbackNV(primitiveMode); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeeback_nglEndTransformFeedbackNV(JNIEnv *env, jclass clazz, jlong function_pointer) { + glEndTransformFeedbackNVPROC glEndTransformFeedbackNV = (glEndTransformFeedbackNVPROC)((intptr_t)function_pointer); + glEndTransformFeedbackNV(); +} + +JNIEXPORT jint JNICALL Java_org_lwjgl_opengl_NVTransformFeeback_nglGetVaryingLocationNV(JNIEnv *env, jclass clazz, jint program, jobject name, jint name_position, jlong function_pointer) { + const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position; + glGetVaryingLocationNVPROC glGetVaryingLocationNV = (glGetVaryingLocationNVPROC)((intptr_t)function_pointer); + GLint __result = glGetVaryingLocationNV(program, name_address); + return __result; +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeeback_nglGetActiveVaryingNV(JNIEnv *env, jclass clazz, jint program, jint index, jint bufSize, jobject length, jint length_position, jobject size, jint size_position, jobject type, jint type_position, jobject name, jint name_position, jlong function_pointer) { + GLsizei *length_address = ((GLsizei *)(*env)->GetDirectBufferAddress(env, length)) + length_position; + GLsizei *size_address = ((GLsizei *)(*env)->GetDirectBufferAddress(env, size)) + size_position; + GLenum *type_address = ((GLenum *)(*env)->GetDirectBufferAddress(env, type)) + type_position; + GLchar *name_address = ((GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position; + glGetActiveVaryingNVPROC glGetActiveVaryingNV = (glGetActiveVaryingNVPROC)((intptr_t)function_pointer); + glGetActiveVaryingNV(program, index, bufSize, length_address, size_address, type_address, name_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeeback_nglActiveVaryingNV(JNIEnv *env, jclass clazz, jint program, jobject name, jint name_position, jlong function_pointer) { + const GLchar *name_address = ((const GLchar *)(*env)->GetDirectBufferAddress(env, name)) + name_position; + glActiveVaryingNVPROC glActiveVaryingNV = (glActiveVaryingNVPROC)((intptr_t)function_pointer); + glActiveVaryingNV(program, name_address); +} + +JNIEXPORT void JNICALL Java_org_lwjgl_opengl_NVTransformFeeback_nglGetTransformFeedbackVaryingNV(JNIEnv *env, jclass clazz, jint program, jint index, jobject location, jint location_position, jlong function_pointer) { + GLint *location_address = ((GLint *)(*env)->GetDirectBufferAddress(env, location)) + location_position; + glGetTransformFeedbackVaryingNVPROC glGetTransformFeedbackVaryingNV = (glGetTransformFeedbackVaryingNVPROC)((intptr_t)function_pointer); + glGetTransformFeedbackVaryingNV(program, index, location_address); +} + diff --git a/src/templates/org/lwjgl/opengl/EXT_bindable_uniform.java b/src/templates/org/lwjgl/opengl/EXT_bindable_uniform.java new file mode 100644 index 00000000..30ebaaa3 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_bindable_uniform.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.GLintptr; +import org.lwjgl.util.generator.GLuint; + +public interface EXT_bindable_uniform { + + /** + * Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, + * and GetDoublev: + */ + int GL_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8DE2; + int GL_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8DE3; + int GL_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8DE4; + int GL_MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8DED; + int GL_UNIFORM_BUFFER_BINDING_EXT = 0x8DEF; + + /** + * Accepted by the <target> parameters of BindBuffer, BufferData, + * BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, and + * GetBufferPointerv: + */ + int GL_UNIFORM_BUFFER_EXT = 0x8DEE; + + void glUniformBufferEXT(@GLuint int program, int location, @GLuint int buffer); + + int glGetUniformBufferSizeEXT(@GLuint int program, int location); + + @GLintptr + long glGetUniformOffsetEXT(@GLuint int program, int location); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/EXT_draw_buffers2.java b/src/templates/org/lwjgl/opengl/EXT_draw_buffers2.java new file mode 100644 index 00000000..8091c1ff --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_draw_buffers2.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.*; + +import java.nio.IntBuffer; +import java.nio.ByteBuffer; + +public interface EXT_draw_buffers2 { + + void glColorMaskIndexedEXT(@GLuint int buf, boolean r, boolean g, boolean b, boolean a); + + @StripPostfix("data") + void glGetBooleanIndexedvEXT(@GLenum int value, @GLuint int index, @Check("4") @GLboolean ByteBuffer data); + + @StripPostfix("data") + void glGetIntegerIndexedvEXT(@GLenum int value, @GLuint int index, @Check("4") IntBuffer data); + + void glEnableIndexedEXT(@GLenum int target, @GLuint int index); + + void glDisableIndexedEXT(@GLenum int target, @GLuint int index); + + boolean glIsEnabledIndexedEXT(@GLenum int target, @GLuint int index); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/EXT_draw_instanced.java b/src/templates/org/lwjgl/opengl/EXT_draw_instanced.java new file mode 100644 index 00000000..b79806a0 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_draw_instanced.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.*; + +import java.nio.Buffer; + +public interface EXT_draw_instanced { + + void glDrawArraysInstancedEXT(@GLenum int mode, int first, @GLsizei int count, @GLsizei int primcount); + + void glDrawElementsInstancedEXT(@GLenum int mode, @AutoSize("indices") @GLsizei int count, @AutoType("indices") @GLenum int type, + @BufferObject(BufferKind.ElementVBO) + @Const + @GLubyte + @GLushort + @GLuint Buffer indices, @GLsizei int primcount); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/EXT_framebuffer_sRGB.java b/src/templates/org/lwjgl/opengl/EXT_framebuffer_sRGB.java new file mode 100644 index 00000000..502e125b --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_framebuffer_sRGB.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +public interface EXT_framebuffer_sRGB { + + /** + * Accepted by the <attribList> parameter of glXChooseVisual, and by + * the <attrib> parameter of glXGetConfig: + */ + int GLX_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x20B2; + + /** + * Accepted by the <piAttributes> parameter of + * wglGetPixelFormatAttribivEXT, wglGetPixelFormatAttribfvEXT, and + * the <piAttribIList> and <pfAttribIList> of wglChoosePixelFormatEXT: + */ + int WGL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x20A9; + + /** + * Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, + * and by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, + * and GetDoublev: + */ + int GL_FRAMEBUFFER_SRGB_EXT = 0x8DB9; + + /** + * Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, + * GetFloatv, and GetDoublev: + */ + int GL_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8DBA; + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/EXT_geometry_shader4.java b/src/templates/org/lwjgl/opengl/EXT_geometry_shader4.java new file mode 100644 index 00000000..fa77fcee --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_geometry_shader4.java @@ -0,0 +1,101 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.GLenum; +import org.lwjgl.util.generator.GLuint; + +public interface EXT_geometry_shader4 { + + /** + * Accepted by the <type> parameter of CreateShader and returned by the + * <params> parameter of GetShaderiv: + */ + int GL_GEOMETRY_SHADER_EXT = 0x8DD9; + + /** + * Accepted by the <pname> parameter of ProgramParameteriEXT and + * GetProgramiv: + */ + int GL_GEOMETRY_VERTICES_OUT_EXT = 0x8DDA; + int GL_GEOMETRY_INPUT_TYPE_EXT = 0x8DDB; + int GL_GEOMETRY_OUTPUT_TYPE_EXT = 0x8DDC; + + /** + * Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, + * GetFloatv, and GetDoublev: + */ + int GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8C29; + int GL_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 0x8DDD; + int GL_MAX_VERTEX_VARYING_COMPONENTS_EXT = 0x8DDE; + int GL_MAX_VARYING_COMPONENTS_EXT = 0x8B4B; + int GL_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8DDF; + int GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8DE0; + int GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8DE1; + + /** + * Accepted by the <mode> parameter of Begin, DrawArrays, + * MultiDrawArrays, DrawElements, MultiDrawElements, and + * DrawRangeElements: + */ + int GL_LINES_ADJACENCY_EXT = 0xA; + int GL_LINE_STRIP_ADJACENCY_EXT = 0xB; + int GL_TRIANGLES_ADJACENCY_EXT = 0xC; + int GL_TRIANGLE_STRIP_ADJACENCY_EXT = 0xD; + + /** Returned by CheckFramebufferStatusEXT: */ + int GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8DA8; + int GL_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 0x8DA9; + + /** + * Accepted by the <pname> parameter of GetFramebufferAttachment- + * ParameterivEXT: + */ + int GL_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8DA7; + int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4; + + /** + * Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, + * and by the <pname> parameter of GetIntegerv, GetFloatv, GetDoublev, + * and GetBooleanv: + */ + int GL_PROGRAM_POINT_SIZE_EXT = 0x8642; + + void glProgramParameteriEXT(@GLuint int program, @GLenum int pname, int value); + + void glFramebufferTextureEXT(@GLenum int target, @GLenum int attachment, @GLuint int texture, int level); + + void glFramebufferTextureLayerEXT(@GLenum int target, @GLenum int attachment, @GLuint int texture, int level, int layer); + + void glFramebufferTextureFaceEXT(@GLenum int target, @GLenum int attachment, @GLuint int texture, int level, @GLenum int face); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/EXT_gpu_shader4.java b/src/templates/org/lwjgl/opengl/EXT_gpu_shader4.java new file mode 100644 index 00000000..fb812ce6 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_gpu_shader4.java @@ -0,0 +1,183 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.*; + +import java.nio.Buffer; +import java.nio.ByteBuffer; +import java.nio.IntBuffer; +import java.nio.ShortBuffer; + +public interface EXT_gpu_shader4 { + + /** + * Accepted by the <pname> parameters of GetVertexAttribdv, + * GetVertexAttribfv, GetVertexAttribiv, GetVertexAttribIivEXT, and + * GetVertexAttribIuivEXT: + */ + int GL_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = 0x88FD; + + /** Returned by the <type> parameter of GetActiveUniform: */ + + int GL_SAMPLER_1D_ARRAY_EXT = 0x8DC0; + int GL_SAMPLER_2D_ARRAY_EXT = 0x8DC1; + int GL_SAMPLER_BUFFER_EXT = 0x8DC2; + int GL_SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3; + int GL_SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4; + int GL_SAMPLER_CUBE_SHADOW_EXT = 0x8DC5; + int GL_UNSIGNED_INT = 0x1405; + int GL_UNSIGNED_INT_VEC2_EXT = 0x8DC6; + int GL_UNSIGNED_INT_VEC3_EXT = 0x8DC7; + int GL_UNSIGNED_INT_VEC4_EXT = 0x8DC8; + int GL_INT_SAMPLER_1D_EXT = 0x8DC9; + int GL_INT_SAMPLER_2D_EXT = 0x8DCA; + int GL_INT_SAMPLER_3D_EXT = 0x8DCB; + int GL_INT_SAMPLER_CUBE_EXT = 0x8DCC; + int GL_INT_SAMPLER_2D_RECT_EXT = 0x8DCD; + int GL_INT_SAMPLER_1D_ARRAY_EXT = 0x8DCE; + int GL_INT_SAMPLER_2D_ARRAY_EXT = 0x8DCF; + int GL_INT_SAMPLER_BUFFER_EXT = 0x8DD0; + int GL_UNSIGNED_INT_SAMPLER_1D_EXT = 0x8DD1; + int GL_UNSIGNED_INT_SAMPLER_2D_EXT = 0x8DD2; + int GL_UNSIGNED_INT_SAMPLER_3D_EXT = 0x8DD3; + int GL_UNSIGNED_INT_SAMPLER_CUBE_EXT = 0x8DD4; + int GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 0x8DD5; + int GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 0x8DD6; + int GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 0x8DD7; + int GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8DD8; + + /** + * Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, + * and GetDoublev: + */ + int GL_MIN_PROGRAM_TEXEL_OFFSET_EXT = 0x8904; + int GL_MAX_PROGRAM_TEXEL_OFFSET_EXT = 0x8905; + + void glVertexAttribI1iEXT(@GLuint int index, int x); + + void glVertexAttribI2iEXT(@GLuint int index, int x, int y); + + void glVertexAttribI3iEXT(@GLuint int index, int x, int y, int z); + + void glVertexAttribI4iEXT(@GLuint int index, int x, int y, int z, int w); + + void glVertexAttribI1uiEXT(@GLuint int index, @GLuint int x); + + void glVertexAttribI2uiEXT(@GLuint int index, @GLuint int x, @GLuint int y); + + void glVertexAttribI3uiEXT(@GLuint int index, @GLuint int x, @GLuint int y, @GLuint int z); + + void glVertexAttribI4uiEXT(@GLuint int index, @GLuint int x, @GLuint int y, @GLuint int z, @GLuint int w); + + @StripPostfix("v") + void glVertexAttribI1ivEXT(@GLuint int index, @Check("1") @Const IntBuffer v); + + @StripPostfix("v") + void glVertexAttribI2ivEXT(@GLuint int index, @Check("2") @Const IntBuffer v); + + @StripPostfix("v") + void glVertexAttribI3ivEXT(@GLuint int index, @Check("3") @Const IntBuffer v); + + @StripPostfix("v") + void glVertexAttribI4ivEXT(@GLuint int index, @Check("4") @Const IntBuffer v); + + @StripPostfix("v") + void glVertexAttribI1uivEXT(@GLuint int index, @Check("1") @Const @GLuint IntBuffer v); + + @StripPostfix("v") + void glVertexAttribI2uivEXT(@GLuint int index, @Check("2") @Const @GLuint IntBuffer v); + + @StripPostfix("v") + void glVertexAttribI3uivEXT(@GLuint int index, @Check("3") @Const @GLuint IntBuffer v); + + @StripPostfix("v") + void glVertexAttribI4uivEXT(@GLuint int index, @Check("4") @Const @GLuint IntBuffer v); + + @StripPostfix("v") + void glVertexAttribI4bvEXT(@GLuint int index, @Check("4") @Const ByteBuffer v); + + @StripPostfix("v") + void glVertexAttribI4svEXT(@GLuint int index, @Check("4") @Const ShortBuffer v); + + @StripPostfix("v") + void glVertexAttribI4ubvEXT(@GLuint int index, @Check("4") @Const @GLubyte ByteBuffer v); + + @StripPostfix("v") + void glVertexAttribI4usvEXT(@GLuint int index, @Check("4") @Const @GLushort ShortBuffer v); + + void glVertexAttribIPointerEXT(@GLuint int index, int size, @GLenum int type, @GLsizei int stride, + @CachedReference + @BufferObject(BufferKind.ArrayVBO) + @Check + @Const + @GLbyte + @GLubyte + @GLshort + @GLushort + @GLint + @GLuint Buffer buffer); + + @StripPostfix("params") + void glGetVertexAttribIivEXT(@GLuint int index, @GLenum int pname, @Check("4")IntBuffer params); + + @StripPostfix("params") + void glGetVertexAttribIuivEXT(@GLuint int index, @GLenum int pname, @Check("4") @GLuint IntBuffer params); + + void glUniform1uiEXT(int location, @GLuint int v0); + + void glUniform2uiEXT(int location, @GLuint int v0, @GLuint int v1); + + void glUniform3uiEXT(int location, @GLuint int v0, @GLuint int v1, @GLuint int v2); + + void glUniform4uiEXT(int location, @GLuint int v0, @GLuint int v1, @GLuint int v2, @GLuint int v3); + + @StripPostfix("value") + void glUniform1uivEXT(int location, @AutoSize("value") @GLsizei int count, @Const @GLuint IntBuffer value); + + @StripPostfix("value") + void glUniform2uivEXT(int location, @AutoSize(value = "value", expression = " >> 1") @GLsizei int count, @Const @GLuint IntBuffer value); + + @StripPostfix("value") + void glUniform3uivEXT(int location, @AutoSize(value = "value", expression = " / 3") @GLsizei int count, @Const @GLuint IntBuffer value); + + @StripPostfix("value") + void glUniform4uivEXT(int location, @AutoSize(value = "value", expression = " >> 2") @GLsizei int count, @Const @GLuint IntBuffer value); + + @StripPostfix("params") + void glGetUniformuivEXT(@GLuint int program, int location, @Check @GLuint IntBuffer params); + + void glBindFragDataLocationEXT(@GLuint int program, @GLuint int colorNumber, @NullTerminated @Const @GLchar ByteBuffer name); + + int glGetFragDataLocationEXT(@GLuint int program, @NullTerminated @Const @GLchar ByteBuffer name); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/EXT_packed_float.java b/src/templates/org/lwjgl/opengl/EXT_packed_float.java new file mode 100644 index 00000000..5fbd0510 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_packed_float.java @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +public interface EXT_packed_float { + + /** + * Accepted by the <internalformat> parameter of TexImage1D, + * TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, and + * RenderbufferStorageEXT: + */ + int GL_R11F_G11F_B10F_EXT = 0x8C3A; + + /** + * Accepted by the <type> parameter of DrawPixels, ReadPixels, + * TexImage1D, TexImage2D, GetTexImage, TexImage3D, TexSubImage1D, + * TexSubImage2D, TexSubImage3D, GetHistogram, GetMinmax, + * ConvolutionFilter1D, ConvolutionFilter2D, ConvolutionFilter3D, + * GetConvolutionFilter, SeparableFilter2D, GetSeparableFilter, + * ColorTable, ColorSubTable, and GetColorTable: + */ + int GL_UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B; + + /** + * Accepted by the <pname> parameters of GetIntegerv, GetFloatv, and + * GetDoublev: + */ + int GL_RGBA_SIGNED_COMPONENTS_EXT = 0x8C3C; + + /** + * Accepted as a value in the <piAttribIList> and <pfAttribFList> + * parameter arrays of wglChoosePixelFormatARB, and returned in the + * <piValues> parameter array of wglGetPixelFormatAttribivARB, and the + * <pfValues> parameter array of wglGetPixelFormatAttribfvARB: + */ + int WGL_TYPE_RGBA_UNSIGNED_FLOAT_EXT = 0x20A8; + + /** + * Accepted as values of the <render_type> arguments in the + * glXCreateNewContext and glXCreateContext functions + */ + int GLX_RGBA_UNSIGNED_FLOAT_TYPE_EXT = 0x20B1; + + /** + * Returned by glXGetFBConfigAttrib (when <attribute> is set to + * GLX_RENDER_TYPE) and accepted by the <attrib_list> parameter of + * glXChooseFBConfig (following the GLX_RENDER_TYPE token): + */ + int GLX_RGBA_UNSIGNED_FLOAT_BIT_EXT = 0x00000008; + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/EXT_texture_array.java b/src/templates/org/lwjgl/opengl/EXT_texture_array.java new file mode 100644 index 00000000..04b18ef7 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_texture_array.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.GLenum; +import org.lwjgl.util.generator.GLuint; + +public interface EXT_texture_array { + + /** + * Accepted by the <target> parameter of TexParameteri, TexParameteriv, + * TexParameterf, TexParameterfv, and BindTexture: + */ + int GL_TEXTURE_1D_ARRAY_EXT = 0x8C18; + int GL_TEXTURE_2D_ARRAY_EXT = 0x8C1A; + + /** + * Accepted by the <target> parameter of TexImage3D, TexSubImage3D, + * CopyTexSubImage3D, CompressedTexImage3D, and CompressedTexSubImage3D: + */ + int GL_PROXY_TEXTURE_2D_ARRAY_EXT = 0x8C1B; + + /** + * Accepted by the <target> parameter of TexImage2D, TexSubImage2D, + * CopyTexImage2D, CopyTexSubImage2D, CompressedTexImage2D, and + * CompressedTexSubImage2D: + */ + int GL_PROXY_TEXTURE_1D_ARRAY_EXT = 0x8C19; + + /** + * Accepted by the <pname> parameter of GetBooleanv, GetDoublev, GetIntegerv + * and GetFloatv: + */ + int GL_TEXTURE_BINDING_1D_ARRAY_EXT = 0x8C1C; + int GL_TEXTURE_BINDING_2D_ARRAY_EXT = 0x8C1D; + int GL_MAX_ARRAY_TEXTURE_LAYERS_EXT = 0x88FF; + + /** + * Accepted by the <param> parameter of TexParameterf, TexParameteri, + * TexParameterfv, and TexParameteriv when the <pname> parameter is + * TEXTURE_COMPARE_MODE_ARB: + */ + int GL_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 0x884E; + + /** + * Accepted by the <pname> parameter of + * GetFramebufferAttachmentParameterivEXT: + */ + int GL_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4; + + /** Returned by the <type> parameter of GetActiveUniform: */ + int GL_SAMPLER_1D_ARRAY_EXT = 0x8DC0; + int GL_SAMPLER_2D_ARRAY_EXT = 0x8DC1; + int GL_SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3; + int GL_SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4; + + void glFramebufferTextureLayerEXT(@GLenum int target, @GLenum int attachment, @GLuint int texture, int level, int layer); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/EXT_texture_buffer_object.java b/src/templates/org/lwjgl/opengl/EXT_texture_buffer_object.java new file mode 100644 index 00000000..09bc607e --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_texture_buffer_object.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.GLenum; +import org.lwjgl.util.generator.GLuint; + +public interface EXT_texture_buffer_object { + + /** + * Accepted by the <target> parameter of BindBuffer, BufferData, + * BufferSubData, MapBuffer, BindTexture, UnmapBuffer, GetBufferSubData, + * GetBufferParameteriv, GetBufferPointerv, and TexBufferEXT, and + * the <pname> parameter of GetBooleanv, GetDoublev, GetFloatv, and + * GetIntegerv: + */ + int GL_TEXTURE_BUFFER_EXT = 0x8C2A; + + /** + * Accepted by the <pname> parameters of GetBooleanv, GetDoublev, + * GetFloatv, and GetIntegerv: + */ + int GL_MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8C2B; + int GL_TEXTURE_BINDING_BUFFER_EXT = 0x8C2C; + int GL_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8C2D; + int GL_TEXTURE_BUFFER_FORMAT_EXT = 0x8C2E; + + void glTexBufferEXT(@GLenum int target, @GLenum int internalformat, @GLuint int buffer); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/EXT_texture_compression_latc.java b/src/templates/org/lwjgl/opengl/EXT_texture_compression_latc.java new file mode 100644 index 00000000..f6ad3ab4 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_texture_compression_latc.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.Extension; + +@Extension(postfix = "EXT", className = "EXTTextureCompressionLATC") +public interface EXT_texture_compression_latc { + + /** + * Accepted by the <internalformat> parameter of TexImage2D, + * CopyTexImage2D, and CompressedTexImage2D and the <format> parameter + * of CompressedTexSubImage2D: + */ + int GL_COMPRESSED_LUMINANCE_LATC1_EXT = 0x8C70; + int GL_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 0x8C71; + int GL_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C72; + int GL_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C73; + +} diff --git a/src/templates/org/lwjgl/opengl/EXT_texture_compression_rgtc.java b/src/templates/org/lwjgl/opengl/EXT_texture_compression_rgtc.java new file mode 100644 index 00000000..4bf5eff7 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_texture_compression_rgtc.java @@ -0,0 +1,49 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.Extension; + +@Extension(postfix = "EXT", className = "EXTTextureCompressionRGTC") +public interface EXT_texture_compression_rgtc { + + /** + * Accepted by the <internalformat> parameter of TexImage2D, + * CopyTexImage2D, and CompressedTexImage2D and the <format> parameter + * of CompressedTexSubImage2D: + */ + int GL_COMPRESSED_RED_RGTC1_EXT = 0x8DBB; + int GL_COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8DBC; + int GL_COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8DBD; + int GL_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8DBE; + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/EXT_texture_integer.java b/src/templates/org/lwjgl/opengl/EXT_texture_integer.java new file mode 100644 index 00000000..e0dc078e --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_texture_integer.java @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.Check; +import org.lwjgl.util.generator.GLenum; +import org.lwjgl.util.generator.GLuint; +import org.lwjgl.util.generator.StripPostfix; + +import java.nio.IntBuffer; + +public interface EXT_texture_integer { + + /** + * Accepted by the <pname> parameters of GetBooleanv, GetIntegerv, + * GetFloatv, and GetDoublev: + */ + int GL_RGBA_INTEGER_MODE_EXT = 0x8D9E; + + /** + * Accepted by the <internalFormat> parameter of TexImage1D, + * TexImage2D, and TexImage3D: + */ + int GL_RGBA32UI_EXT = 0x8D70; + int GL_RGB32UI_EXT = 0x8D71; + int GL_ALPHA32UI_EXT = 0x8D72; + int GL_INTENSITY32UI_EXT = 0x8D73; + int GL_LUMINANCE32UI_EXT = 0x8D74; + int GL_LUMINANCE_ALPHA32UI_EXT = 0x8D75; + + int GL_RGBA16UI_EXT = 0x8D76; + int GL_RGB16UI_EXT = 0x8D77; + int GL_ALPHA16UI_EXT = 0x8D78; + int GL_INTENSITY16UI_EXT = 0x8D79; + int GL_LUMINANCE16UI_EXT = 0x8D7A; + int GL_LUMINANCE_ALPHA16UI_EXT = 0x8D7B; + + int GL_RGBA8UI_EXT = 0x8D7C; + int GL_RGB8UI_EXT = 0x8D7D; + int GL_ALPHA8UI_EXT = 0x8D7E; + int GL_INTENSITY8UI_EXT = 0x8D7F; + int GL_LUMINANCE8UI_EXT = 0x8D80; + int GL_LUMINANCE_ALPHA8UI_EXT = 0x8D81; + + int GL_RGBA32I_EXT = 0x8D82; + int GL_RGB32I_EXT = 0x8D83; + int GL_ALPHA32I_EXT = 0x8D84; + int GL_INTENSITY32I_EXT = 0x8D85; + int GL_LUMINANCE32I_EXT = 0x8D86; + int GL_LUMINANCE_ALPHA32I_EXT = 0x8D87; + + int GL_RGBA16I_EXT = 0x8D88; + int GL_RGB16I_EXT = 0x8D89; + int GL_ALPHA16I_EXT = 0x8D8A; + int GL_INTENSITY16I_EXT = 0x8D8B; + int GL_LUMINANCE16I_EXT = 0x8D8C; + int GL_LUMINANCE_ALPHA16I_EXT = 0x8D8D; + + int GL_RGBA8I_EXT = 0x8D8E; + int GL_RGB8I_EXT = 0x8D8F; + int GL_ALPHA8I_EXT = 0x8D90; + int GL_INTENSITY8I_EXT = 0x8D91; + int GL_LUMINANCE8I_EXT = 0x8D92; + int GL_LUMINANCE_ALPHA8I_EXT = 0x8D93; + + /** + * Accepted by the <format> parameter of TexImage1D, TexImage2D, + * TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, + * DrawPixels and ReadPixels: + */ + int GL_RED_INTEGER_EXT = 0x8D94; + int GL_GREEN_INTEGER_EXT = 0x8D95; + int GL_BLUE_INTEGER_EXT = 0x8D96; + int GL_ALPHA_INTEGER_EXT = 0x8D97; + int GL_RGB_INTEGER_EXT = 0x8D98; + int GL_RGBA_INTEGER_EXT = 0x8D99; + int GL_BGR_INTEGER_EXT = 0x8D9A; + int GL_BGRA_INTEGER_EXT = 0x8D9B; + int GL_LUMINANCE_INTEGER_EXT = 0x8D9C; + int GL_LUMINANCE_ALPHA_INTEGER_EXT = 0x8D9D; + + void glClearColorIiEXT(int r, int g, int b, int a); + + void glClearColorIuiEXT(@GLuint int r, @GLuint int g, @GLuint int b, @GLuint int a); + + @StripPostfix("params") + void glTexParameterIivEXT(@GLenum int target, @GLenum int pname, @Check("4")IntBuffer params); + + @StripPostfix("params") + void glTexParameterIuivEXT(@GLenum int target, @GLenum int pname, @Check("4") @GLuint IntBuffer params); + + @StripPostfix("params") + void glGetTexParameterIivEXT(@GLenum int target, @GLenum int pname, @Check("4")IntBuffer params); + + @StripPostfix("params") + void glGetTexParameterIuivEXT(@GLenum int target, @GLenum int pname, @Check("4") @GLuint IntBuffer params); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/EXT_texture_shared_exponent.java b/src/templates/org/lwjgl/opengl/EXT_texture_shared_exponent.java new file mode 100644 index 00000000..ac352f09 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/EXT_texture_shared_exponent.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +public interface EXT_texture_shared_exponent { + + /** + * Accepted by the <internalformat> parameter of TexImage1D, + * TexImage2D, TexImage3D, CopyTexImage1D, CopyTexImage2D, and + * RenderbufferStorageEXT: + */ + int GL_RGB9_E5_EXT = 0x8C3D; + + /** + * Accepted by the <type> parameter of DrawPixels, ReadPixels, + * TexImage1D, TexImage2D, GetTexImage, TexImage3D, TexSubImage1D, + * TexSubImage2D, TexSubImage3D, GetHistogram, GetMinmax, + * ConvolutionFilter1D, ConvolutionFilter2D, ConvolutionFilter3D, + * GetConvolutionFilter, SeparableFilter2D, GetSeparableFilter, + * ColorTable, ColorSubTable, and GetColorTable: + */ + int GL_UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E; + + /** + * Accepted by the <pname> parameter of GetTexLevelParameterfv and + * GetTexLevelParameteriv: + */ + int GL_TEXTURE_SHARED_SIZE_EXT = 0x8C3F; + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/NV_depth_buffer_float.java b/src/templates/org/lwjgl/opengl/NV_depth_buffer_float.java new file mode 100644 index 00000000..7b804d7b --- /dev/null +++ b/src/templates/org/lwjgl/opengl/NV_depth_buffer_float.java @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +public interface NV_depth_buffer_float { + + /** + * Accepted by the <internalformat> parameter of TexImage1D, TexImage2D, + * TexImage3D, CopyTexImage1D, CopyTexImage2D, and RenderbufferStorageEXT, + * and returned in the <data> parameter of GetTexLevelParameter and + * GetRenderbufferParameterivEXT: + */ + int GL_DEPTH_COMPONENT32F_NV = 0x8DAB; + int GL_DEPTH32F_STENCIL8_NV = 0x8DAC; + + /** + * Accepted by the <type> parameter of DrawPixels, ReadPixels, TexImage1D, + * TexImage2D, TexImage3D, TexSubImage1D, TexSubImage2D, TexSubImage3D, and + * GetTexImage: + */ + int GL_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8DAD; + + /** + * Accepted by the <pname> parameters of GetBooleanv, GetIntegerv, + * GetFloatv, and GetDoublev: + */ + int GL_DEPTH_BUFFER_FLOAT_MODE_NV = 0x8DAF; + + void glDepthRangedNV(double n, double f); + + void glClearDepthdNV(double d); + + void glDepthBoundsdNV(double zmin, double zmax); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/NV_fragment_program4.java b/src/templates/org/lwjgl/opengl/NV_fragment_program4.java new file mode 100644 index 00000000..1f970d90 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/NV_fragment_program4.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +public interface NV_fragment_program4 { + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/NV_framebuffer_multisample_coverage.java b/src/templates/org/lwjgl/opengl/NV_framebuffer_multisample_coverage.java new file mode 100644 index 00000000..ca1a270d --- /dev/null +++ b/src/templates/org/lwjgl/opengl/NV_framebuffer_multisample_coverage.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.GLenum; +import org.lwjgl.util.generator.GLsizei; + +public interface NV_framebuffer_multisample_coverage { + + /** Accepted by the <pname> parameter of GetRenderbufferParameterivEXT: */ + int GL_RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8CAB; + int GL_RENDERBUFFER_COLOR_SAMPLES_NV = 0x8E10; + + void glRenderbufferStorageMultsampleCoverageNV(@GLenum int target, @GLsizei int coverageSamples, @GLsizei int colorSamples, + @GLenum int internalformat, @GLsizei int width, @GLsizei int height); +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/NV_geometry_program4.java b/src/templates/org/lwjgl/opengl/NV_geometry_program4.java new file mode 100644 index 00000000..3c9733f3 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/NV_geometry_program4.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.GLenum; +import org.lwjgl.util.generator.GLuint; + +public interface NV_geometry_program4 { + + /** + * Accepted by the <cap> parameter of Disable, Enable, and IsEnabled, and by + * the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev: + */ + int GL_GEOMETRY_PROGRAM_NV = 0x8C26; + + /** Accepted by the <pname> parameter of GetProgramivARB: */ + int GL_MAX_PROGRAM_OUTPUT_VERTICES_NV = 0x8C27; + int GL_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 0x8C28; + + void glProgramVertexLimitNV(@GLenum int target, int limit); + + void glFramebufferTextureEXT(@GLenum int target, @GLenum int attachment, @GLuint int texture, int level); + + void glFramebufferTextureLayerEXT(@GLenum int target, @GLenum int attachment, @GLuint int texture, int level, int layer); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/NV_gpu_program4.java b/src/templates/org/lwjgl/opengl/NV_gpu_program4.java new file mode 100644 index 00000000..04aafa49 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/NV_gpu_program4.java @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.*; + +import java.nio.IntBuffer; + +public interface NV_gpu_program4 { + + /** Accepted by the <pname> parameter of GetProgramivARB: */ + int GL_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8906; + int GL_PROGRAM_RESULT_COMPONENTS_NV = 0x8907; + int GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8908; + int GL_MAX_PROGRAM_RESULT_COMPONENTS_NV = 0x8909; + int GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV = 0x8DA5; + int GL_MAX_PROGRAM_GENERIC_RESULTS_NV = 0x8DA6; + + // --- + + void glProgramLocalParameterI4iNV(@GLenum int target, @GLuint int index, int x, int y, int z, int w); + + @StripPostfix("params") + void glProgramLocalParameterI4ivNV(@GLenum int target, @GLuint int index, @Check("4") @Const IntBuffer params); + + @StripPostfix("params") + void glProgramLocalParametersI4ivNV(@GLenum int target, @GLuint int index, + @AutoSize(value = "params", expression = " >> 2") @GLsizei int count, @Const IntBuffer params); + + // --- + + void glProgramLocalParameterI4uiNV(@GLenum int target, @GLuint int index, @GLuint int x, @GLuint int y, @GLuint int z, @GLuint int w); + + @StripPostfix("params") + void glProgramLocalParameterI4uivNV(@GLenum int target, @GLuint int index, @Check("4") @Const @GLuint IntBuffer params); + + @StripPostfix("params") + void glProgramLocalParametersI4uivNV(@GLenum int target, @GLuint int index, + @AutoSize(value = "params", expression = " >> 2") @GLsizei int count, @Const @GLuint IntBuffer params); + + // --- + + void glProgramEnvParameterI4iNV(@GLenum int target, @GLuint int index, int x, int y, int z, int w); + + @StripPostfix("params") + void glProgramEnvParameterI4ivNV(@GLenum int target, @GLuint int index, @Check("4") @Const IntBuffer params); + + @StripPostfix("params") + void glProgramEnvParametersI4ivNV(@GLenum int target, @GLuint int index, + @AutoSize(value = "params", expression = " >> 2") @GLsizei int count, @Const IntBuffer params); + + // --- + + void glProgramEnvParameterI4uiNV(@GLenum int target, @GLuint int index, @GLuint int x, @GLuint int y, @GLuint int z, @GLuint int w); + + @StripPostfix("params") + void glProgramEnvParameterI4uivNV(@GLenum int target, @GLuint int index, @Check("4") @Const @GLuint IntBuffer params); + + @StripPostfix("params") + void glProgramEnvParametersI4uivNV(@GLenum int target, @GLuint int index, + @AutoSize(value = "params", expression = " >> 2") @GLsizei int count, @Const @GLuint IntBuffer params); + + // --- + + @StripPostfix("params") + void glGetProgramLocalParameterIivNV(@GLenum int target, @GLuint int index, @Check("4") IntBuffer params); + + @StripPostfix("params") + void glGetProgramLocalParameterIuivNV(@GLenum int target, @GLuint int index, @Check("4") @GLuint IntBuffer params); + + // --- + + @StripPostfix("params") + void glGetProgramEnvParameterIivNV(@GLenum int target, @GLuint int index, @Check("4")IntBuffer params); + + @StripPostfix("params") + void glGetProgramEnvParameterIuivNV(@GLenum int target, @GLuint int index, @Check("4") @GLuint IntBuffer params); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/NV_parameter_buffer_object.java b/src/templates/org/lwjgl/opengl/NV_parameter_buffer_object.java new file mode 100644 index 00000000..a53bb6da --- /dev/null +++ b/src/templates/org/lwjgl/opengl/NV_parameter_buffer_object.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.*; + +import java.nio.FloatBuffer; +import java.nio.IntBuffer; + +public interface NV_parameter_buffer_object { + + /** Accepted by the <pname> parameter of GetProgramivARB: */ + int GL_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 0x8DA0; + int GL_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 0x8DA1; + + /** + * Accepted by the <target> parameter of ProgramBufferParametersfvNV, + * ProgramBufferParametersIivNV, and ProgramBufferParametersIuivNV, + * BindBufferRangeNV, BindBufferOffsetNV, BindBufferBaseNV, and BindBuffer + * and the <value> parameter of GetIntegerIndexedvEXT: + */ + int GL_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA2; + int GL_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA3; + int GL_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA4; + + void glBindBufferRangeNV(@GLenum int target, @GLuint int index, @GLuint int buffer, @GLintptr long offset, @GLsizeiptr long size); + + void glBindBufferOffsetNV(@GLenum int target, @GLuint int index, @GLuint int buffer, @GLintptr long offset); + + void glBindBufferBaseNV(@GLenum int target, @GLuint int index, @GLuint int buffer); + + @StripPostfix("params") + void glProgramBufferParametersfvNV(@GLenum int target, @GLuint int buffer, @GLuint int index, + @AutoSize(value = "params", expression = " >> 2") @GLsizei int count, @Const FloatBuffer params); + + @StripPostfix("params") + void glProgramBufferParametersIivNV(@GLenum int target, @GLuint int buffer, @GLuint int index, + @AutoSize(value = "params", expression = " >> 2") @GLsizei int count, @Const IntBuffer params); + + @StripPostfix("params") + void glProgramBufferParametersIuivNV(@GLenum int target, @GLuint int buffer, @GLuint int index, + @AutoSize(value = "params", expression = " >> 2") @GLuint int count, @Const @GLuint IntBuffer params); + + // TODO: This is weird and breaks the generator, re-examine when the spec's final version is out + //@StripPostfix("data") + //void glGetIntegerIndexedvEXT(@GLenum int value, @GLuint int index, @Check("4") @GLboolean ByteBuffer data); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/NV_transform_feeback.java b/src/templates/org/lwjgl/opengl/NV_transform_feeback.java new file mode 100644 index 00000000..25ea3258 --- /dev/null +++ b/src/templates/org/lwjgl/opengl/NV_transform_feeback.java @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +import org.lwjgl.util.generator.*; + +import java.nio.IntBuffer; +import java.nio.ByteBuffer; + +public interface NV_transform_feeback { + + /** + * Accepted by the <target> parameters of BindBuffer, BufferData, + * BufferSubData, MapBuffer, UnmapBuffer, GetBufferSubData, + * GetBufferPointerv, BindBufferRangeNV, BindBufferOffsetNV and + * BindBufferBaseNV: + */ + int GL_TRANSFORM_FEEDBACK_BUFFER_NV = 0x8C8E; + + /** + * Accepted by the <param> parameter of GetIntegerIndexedvEXT and + * GetBooleanIndexedvEXT: + */ + int GL_TRANSFORM_FEEDBACK_BUFFER_START_NV = 0x8C84; + int GL_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 0x8C85; + int GL_TRANSFORM_FEEDBACK_RECORD_NV = 0x8C86; + + /** + * Accepted by the <param> parameter of GetIntegerIndexedvEXT and + * GetBooleanIndexedvEXT, and by the <pname> parameter of GetBooleanv, + * GetDoublev, GetIntegerv, and GetFloatv: + */ + int GL_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8C8F; + + /** + * Accepted by the <bufferMode> parameter of TransformFeedbackAttribsNV and + * TransformFeedbackVaryingsNV: + */ + int GL_INTERLEAVED_ATTRIBS_NV = 0x8C8C; + int GL_SEPARATE_ATTRIBS_NV = 0x8C8D; + + /** + * Accepted by the <target> parameter of BeginQuery, EndQuery, and + * GetQueryiv: + */ + int GL_PRIMITIVES_GENERATED_NV = 0x8C87; + int GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8C88; + + /** + * Accepted by the <cap> parameter of Enable, Disable, and IsEnabled, and by + * the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv, and + * GetDoublev: + */ + int GL_RASTERIZER_DISCARD_NV = 0x8C89; + + /** + * Accepted by the <pname> parameter of GetBooleanv, GetDoublev, GetIntegerv, + * and GetFloatv: + */ + int GL_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = 0x8C8A; + int GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 0x8C8B; + int GL_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8C80; + int GL_TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8C7E; + + /** Accepted by the <pname> parameter of GetProgramiv: */ + int GL_ACTIVE_VARYINGS_NV = 0x8C81; + int GL_ACTIVE_VARYING_MAX_LENGTH_NV = 0x8C82; + int GL_TRANSFORM_FEEDBACK_VARYINGS_NV = 0x8C83; + + /** + * Accepted by the <pname> parameter of GetBooleanv, GetDoublev, GetIntegerv, + * GetFloatv, and GetProgramiv: + */ + int GL_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8C7F; + + /** Accepted by the <attribs> parameter of TransformFeedbackAttribsNV: */ + int GL_BACK_PRIMARY_COLOR_NV = 0x8C77; + int GL_BACK_SECONDARY_COLOR_NV = 0x8C78; + int GL_TEXTURE_COORD_NV = 0x8C79; + int GL_CLIP_DISTANCE_NV = 0x8C7A; + int GL_VERTEX_ID_NV = 0x8C7B; + int GL_PRIMITIVE_ID_NV = 0x8C7C; + int GL_GENERIC_ATTRIB_NV = 0x8C7D; + + void glBindBufferRangeNV(@GLenum int target, @GLuint int index, @GLuint int buffer, @GLintptr long offset, @GLsizeiptr long size); + + void glBindBufferOffsetNV(@GLenum int target, @GLuint int index, @GLuint int buffer, @GLintptr long offset); + + void glBindBufferBaseNV(@GLenum int target, @GLuint int index, @GLuint int buffer); + + void glTransformFeedbackAttribsNV(@AutoSize("attribs") @GLsizei int count, @Const IntBuffer attribs, @GLenum int bufferMode); + + void glTransformFeedbackVaryingsNV(@GLuint int program, @AutoSize("locations") @GLsizei int count, @Const IntBuffer locations, @GLenum int bufferMode); + + void glBeginTransformFeedbackNV(@GLenum int primitiveMode); + + void glEndTransformFeedbackNV(); + + int glGetVaryingLocationNV(@GLuint int program, @NullTerminated @Const @GLchar ByteBuffer name); + + void glGetActiveVaryingNV(@GLuint int program, @GLuint int index, @AutoSize("name") @GLsizei int bufSize, + @Check("1") @GLsizei IntBuffer length, + @Check("1") @GLsizei IntBuffer size, + @Check("1") @GLenum IntBuffer type, @GLchar ByteBuffer name); + + void glActiveVaryingNV(@GLuint int program, @NullTerminated @Const @GLchar ByteBuffer name); + + void glGetTransformFeedbackVaryingNV(@GLuint int program, @GLuint int index, @Check("1") IntBuffer location); + +} \ No newline at end of file diff --git a/src/templates/org/lwjgl/opengl/NV_vertex_program4.java b/src/templates/org/lwjgl/opengl/NV_vertex_program4.java new file mode 100644 index 00000000..1eded45c --- /dev/null +++ b/src/templates/org/lwjgl/opengl/NV_vertex_program4.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2002-2004 LWJGL Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * * Neither the name of 'LWJGL' nor the names of + * its contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED + * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +package org.lwjgl.opengl; + +public interface NV_vertex_program4 { + +} \ No newline at end of file