diff options
Diffstat (limited to 'make/config/jogl/gl-common.cfg')
| -rw-r--r-- | make/config/jogl/gl-common.cfg | 641 |
1 files changed, 641 insertions, 0 deletions
diff --git a/make/config/jogl/gl-common.cfg b/make/config/jogl/gl-common.cfg new file mode 100644 index 000000000..50c2ff004 --- /dev/null +++ b/make/config/jogl/gl-common.cfg @@ -0,0 +1,641 @@ +# This .cfg file provides common options used among all glue code +# generated for Jogl on all platforms. + +# Raise GLException instead of RuntimeException in glue code +RuntimeExceptionType GLException +UnsupportedExceptionType GLException + +# Imports needed by all glue code +Import java.nio.* +Import java.util.* +Import javax.media.opengl.* +Import javax.media.opengl.fixedfunc.* +Import com.sun.opengl.impl.* + +##################################################################### +# Mostly desktop OpenGL stuff below +# + +# Don't output #defines of GL version identifier strings as constants, +# because we don't need them java-side. +Ignore GL_VERSION_.+ + +# There are a few routines we don't handle yet +Ignore glGetBufferPointerivNV +Ignore glGetBufferPointerv + +# Ignore GL functions that deal with explicit pointer values in such a +# way that we cannot implement the functionality in Java +Ignore glGetBufferPointerv +Ignore glGetBufferPointervARB +Ignore glGetPointerv +Ignore glGetPointervEXT +Ignore glGetTexParameterPointervAPPLE +Ignore glGetVertexAttribPointerv +Ignore glGetVertexAttribPointervARB +Ignore glGetVertexAttribPointervNV +Ignore glTracePointerRangeMESA + +# Manually implement glMapBuffer as the size of the returned buffer +# can only be computed by calling another routine +ManuallyImplement glMapBuffer +ManuallyImplement glMapBufferOES + +# Ignore the ATI_map_object_buffer extension for now unless someone +# claims they need it, as it will undoubtedly require a similar +# construct to glMapBuffer +Ignore glMapObjectBufferATI +Ignore glUnmapObjectBufferATI + +# Ignore some GL functions that have outgoing void** parameters; we cannot yet deal with them +Ignore glGetVariantPointervEXT + +# Don't output #defines of GL name strings as constants, because we +# don't need them java-side. +# Format of name strings is found at: +# http://oss.sgi.com/projects/ogl-sample/registry/doc/template.txt + +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_EXT_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_ARB_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_OES_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_PGI_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_SGI_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_SGIS_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_SGIX_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_MESA_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_HP_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_ATI_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_NV_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_IBM_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_WIN_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_REND_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_APPLE_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_INTEL_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_INGR_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_SUN_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_SUNX_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_3DFX_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_OML_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_I3D_.+ +Ignore (GL|GLU|GLX|WGL|AGL|CGL)_S3_.+ +Ignore GL_KTX_buffer_region + +# FIXME: these extensions require either a handle to a device context +# or take void** parameters or both. Until we think through the +# semantics of each of these individually we need to disable them. +# WGL_ARB_buffer_region +Ignore wglCreateBufferRegion +Ignore wglDeleteBufferRegion +Ignore wglSaveBufferRegion +Ignore wglRestoreBufferRegion +Ignore wglGetSyncValuesOML +Ignore wglGetMscRateOML +Ignore wglSwapBuffersMscOML +Ignore wglSwapLayerBuffersMscOML +Ignore wglWaitForMscOML +Ignore wglWaitForSbcOML +Ignore wglGetDigitalVideoParametersI3D +Ignore wglSetDigitalVideoParametersI3D +Ignore wglGetGammaTableParametersI3D +Ignore wglSetGammaTableParametersI3D +Ignore wglGetGammaTableI3D +Ignore wglSetGammaTableI3D +Ignore wglEnableGenlockI3D +Ignore wglDisableGenlockI3D +Ignore wglIsEnabledGenlockI3D +Ignore wglGenlockSourceI3D +Ignore wglGetGenlockSourceI3D +Ignore wglGenlockSourceEdgeI3D +Ignore wglGetGenlockSourceEdgeI3D +Ignore wglGenlockSampleRateI3D +Ignore wglGetGenlockSampleRateI3D +Ignore wglGenlockSourceDelayI3D +Ignore wglGetGenlockSourceDelayI3D +Ignore wglQueryGenlockMaxSourceDelayI3D +Ignore wglCreateImageBufferI3D +Ignore wglDestroyImageBufferI3D +Ignore wglAssociateImageBufferEventsI3D +Ignore wglReleaseImageBufferEventsI3D + +# +# IgnoreExtension directives +# + +# Ignore extensions requiring persistent pointer-to-pointer storage as +# there is no such thing as a direct "BufferBuffer" +IgnoreExtension GL_IBM_vertex_array_lists +IgnoreExtension GL_INTEL_parallel_arrays +IgnoreExtension GL_SUN_triangle_list + +# Ignore extensions never approved by the ARB +IgnoreExtension GL_EXT_coordinate_frame + +# Ignore discontinued extensions +IgnoreExtension GL_NV_element_array + +# Ignore extensions subsumed in OpenGL 1.1 (from OpenGL 1.1 spec, Appendix C) +IgnoreExtension GL_EXT_vertex_array +IgnoreExtension GL_EXT_blend_logic_op +IgnoreExtension GL_EXT_copy_texture +IgnoreExtension GL_EXT_polygon_offset +IgnoreExtension GL_EXT_subtexture +IgnoreExtension GL_EXT_texture +IgnoreExtension GL_EXT_texture_object + +# Ignore extensions subsumed in OpenGL 1.2 and 1.2.1 (from OpenGL 1.2.1 spec, Appendix D) +IgnoreExtension GL_EXT_bgra +IgnoreExtension GL_EXT_blend_color +IgnoreExtension GL_EXT_blend_minmax +IgnoreExtension GL_EXT_blend_subtract +IgnoreExtension GL_EXT_color_subtable +IgnoreExtension GL_EXT_convolution +IgnoreExtension GL_EXT_draw_range_elements +IgnoreExtension GL_EXT_histogram +IgnoreExtension GL_EXT_packed_pixels +# NOTE: also ignoring GL_EXT_paletted_texture because it appears that it was subsumed +# into the core even though that isn't stated explicitly in the spec +IgnoreExtension GL_EXT_paletted_texture +IgnoreExtension GL_EXT_rescale_normal +IgnoreExtension GL_EXT_separate_specular_color +IgnoreExtension GL_EXT_texture3D +IgnoreExtension GL_HP_convolution_border_modes +IgnoreExtension GL_SGI_color_matrix +IgnoreExtension GL_SGI_color_table +IgnoreExtension GL_SGIS_texture_edge_clamp +IgnoreExtension GL_SGIS_texture_lod + +# Ignore extensions subsumed in OpenGL 1.3 (from OpenGL 1.3 spec, Appendix F) +IgnoreExtension GL_ARB_multisample +IgnoreExtension GL_ARB_multitexture +IgnoreExtension GL_ARB_texture_compression +IgnoreExtension GL_ARB_texture_cube_map +IgnoreExtension GL_ARB_texture_border_clamp +IgnoreExtension GL_ARB_texture_env_add +IgnoreExtension GL_ARB_texture_env_combine +IgnoreExtension GL_ARB_texture_env_dot3 +IgnoreExtension GL_ARB_transpose_matrix +IgnoreExtension GL_EXT_texture_cube_map +IgnoreExtension GL_EXT_texture_env_add +IgnoreExtension GL_EXT_texture_env_combine +IgnoreExtension GL_EXT_texture_env_dot3 +IgnoreExtension GL_SGIS_texture_border_clamp + +# Ignore extensions subsumed in OpenGL 1.4 (from OpenGL 1.4 spec, Appendix G) +IgnoreExtension GL_ARB_depth_texture +IgnoreExtension GL_ARB_point_parameters +IgnoreExtension GL_ARB_shadow +IgnoreExtension GL_ARB_texture_env_crossbar +IgnoreExtension GL_ARB_texture_mirrored_repeat +IgnoreExtension GL_ARB_window_pos +IgnoreExtension GL_EXT_blend_func_separate +IgnoreExtension GL_EXT_fog_coord +IgnoreExtension GL_EXT_texture_lod_bias +IgnoreExtension GL_EXT_multi_draw_arrays +IgnoreExtension GL_EXT_secondary_color +IgnoreExtension GL_EXT_stencil_wrap +IgnoreExtension GL_NV_blend_square +IgnoreExtension GL_SGIS_generate_mipmap + +# Ignore extensions subsumed in OpenGL 1.5 (from OpenGL 1.5 spec, Appendix H) +IgnoreExtension GL_ARB_occlusion_query +IgnoreExtension GL_ARB_vertex_buffer_object +IgnoreExtension GL_EXT_shadow_funcs + +# Ignore extensions subsumed in OpenGL 2.0 (from OpenGL 2.0 spec, Appendix I) +# NOTE that GL_ARB_shader_objects is NOT ignored here, because the +# naming convention is too different for us to pick up the entry +# points automatically (e.g. glCreateShaderObjectARB was exposed as +# glCreateShader) +IgnoreExtension GL_ARB_vertex_shader +IgnoreExtension GL_ARB_fragment_shader +IgnoreExtension GL_ARB_draw_buffers +IgnoreExtension GL_ARB_texture_non_power_of_two +IgnoreExtension GL_ARB_point_sprite +IgnoreExtension GL_EXT_blend_equation_separate +# Don't ignore the following one since the entry point is different from anything in the core +# IgnoreExtension GL_EXT_stencil_two_side + +# Ignore extensions subsumed in OpenGL 2.1 (from OpenGL 2.1 spec, Appendix J) +IgnoreExtension GL_ARB_pixel_buffer_object +IgnoreExtension GL_EXT_texture_sRGB + +# Ignore a few obsolete versions of extensions that have been subsumed into the core or ARB extensions +IgnoreExtension GL_EXT_multisample +IgnoreExtension GL_EXT_point_parameters +IgnoreExtension GL_EXT_texture_rectangle + +# +# Opaques and other directives for platform-independent routines +# + +Opaque boolean GLboolean +ReturnsString glGetString + +# Experimental: Only NIO function, no arrays .. +# NIOOnly __ALL__ + +# +# NIODirectOnly directives for vertex arrays and other core routines +# + +NIODirectOnly glColorPointer +NIODirectOnly glEdgeFlagPointer +NIODirectOnly glFeedbackBuffer +NIODirectOnly glIndexPointer +NIODirectOnly glNormalPointer +NIODirectOnly glSelectBuffer +NIODirectOnly glTexCoordPointer +NIODirectOnly glVertexPointer +# +# FIXME: we should probably be ignoring the "EXT" variants of these +# +NIODirectOnly glColorPointerEXT +NIODirectOnly glEdgeFlagPointerEXT +NIODirectOnly glIndexPointerEXT +NIODirectOnly glNormalPointerEXT +NIODirectOnly glTexCoordPointerEXT +NIODirectOnly glVertexPointerEXT +# +# NIODirectOnly directives for other extensions +# +NIODirectOnly glBinormalPointerEXT +NIODirectOnly glGetBufferSubDataARB +# FIXME: should add way to restrict argument to be a direct ByteBuffer +NIODirectOnly glGetProgramStringARB +NIODirectOnly glElementPointerATI +NIODirectOnly glElementPointerNV +NIODirectOnly glElementPointerAPPLE +NIODirectOnly glFogCoordPointer +NIODirectOnly glFogCoordPointerEXT +NIODirectOnly glMatrixIndexPointerARB +NIODirectOnly glPixelDataRangeNV +NIODirectOnly glSecondaryColorPointer +NIODirectOnly glSecondaryColorPointerEXT +NIODirectOnly glTangentPointerEXT +NIODirectOnly glVertexArrayRangeNV +NIODirectOnly glVertexArrayRangeApple +NIODirectOnly glVertexAttribPointerARB +NIODirectOnly glVertexAttribPointerNV +NIODirectOnly glVertexWeightPointerEXT +NIODirectOnly glWeightPointerARB +NIODirectOnly wglFreeMemoryNV +NIODirectOnly glXFreeMemoryNV + +# Capacity of wglAllocateMemoryNV/glXAllocateMemoryNV return value is +# same as value of first argument +ReturnValueCapacity wglAllocateMemoryNV {0} +ReturnValueCapacity glXAllocateMemoryNV {0} + +# Pass arguments to ARB_vertex_program, ARB_fragment_program, +# ARB_shader_objects, NV_vertex_program, NV_fragment_program, and +# ARB_vertex_shader as Strings +ArgumentIsString glLoadProgramNV 3 +ArgumentIsString glProgramString 3 +ArgumentIsString glProgramStringARB 3 +ArgumentIsString glProgramNamedParameter4fNV 2 +ArgumentIsString glProgramNamedParameter4dNV 2 +ArgumentIsString glProgramNamedParameter4fvNV 2 +ArgumentIsString glProgramNamedParameter4dvNV 2 +ArgumentIsString glGetProgramNamedParameterfvNV 2 +ArgumentIsString glGetProgramNamedParameterdvNV 2 +ArgumentIsString glShaderSource 2 +ArgumentIsString glShaderSourceARB 2 +ArgumentIsString glGetUniformLocation 1 +ArgumentIsString glGetUniformLocationARB 1 +ArgumentIsString glBindAttribLocation 2 +ArgumentIsString glBindAttribLocationARB 2 +ArgumentIsString glGetAttribLocation 1 +ArgumentIsString glGetAttribLocationARB 1 + +# +# Directives for Vertex Buffer Object and Pixel Buffer Object checking +# +# NOTE: we currently don't emit glue code for some of these but +# include them for completeness. +# +# FIXME: what about glMultiDrawElements? Do we want to add a VBO +# variant for that, or simply add checks to the top of the current +# implementation? +# +JavaPrologue glBegin inBeginEndPair = true; +JavaEpilogue glEnd inBeginEndPair = false; +JavaEpilogue glBindBuffer bufferStateTracker.setBoundBufferObject({0}, {1}); +JavaEpilogue glBindBufferARB bufferStateTracker.setBoundBufferObject({0}, {1}); +JavaEpilogue glPushClientAttrib bufferStateTracker.clearBufferObjectState(); +JavaEpilogue glPopClientAttrib bufferStateTracker.clearBufferObjectState(); +JavaEpilogue glBufferData bufferSizeTracker.setBufferSize(bufferStateTracker, {0}, this, {1}); + +BufferObjectKind Array glColorPointer +BufferObjectKind Array glEdgeFlagPointer +BufferObjectKind Array glElementPointerATI +BufferObjectKind Array glFogCoordPointer +BufferObjectKind Array glFogCoordPointerEXT +# The next one is problematic. It isn't discussed by the specs and +# doesn't have any associated state. +BufferObjectKind Array glInterleavedArrays +BufferObjectKind Array glMatrixIndexPointerARB +BufferObjectKind Array glNormalPointer +BufferObjectKind Array glSecondaryColorPointer +BufferObjectKind Array glSecondaryColorPointerEXT +BufferObjectKind Array glTexCoordPointer +BufferObjectKind Array glVariantPointerEXT +BufferObjectKind Array glVertexPointer +BufferObjectKind Array glVertexAttribPointer +BufferObjectKind Array glVertexAttribPointerARB +BufferObjectKind Array glVertexAttribPointerNV +BufferObjectKind Array glVertexWeightPointerEXT +BufferObjectKind Array glWeightPointerARB + +BufferObjectKind Element glDrawElements +BufferObjectKind Element glDrawRangeElements +BufferObjectKind Element glDrawRangeElementsEXT + +# There are no PBOs in the embedded OpenGL variants right now +BufferObjectKind UnpackPixel glBitmap +BufferObjectKind UnpackPixel glColorTable +BufferObjectKind UnpackPixel glColorSubTable +BufferObjectKind UnpackPixel glCompressedTexImage1D +BufferObjectKind UnpackPixel glCompressedTexImage1DARB +BufferObjectKind UnpackPixel glCompressedTexImage2D +BufferObjectKind UnpackPixel glCompressedTexImage2DARB +BufferObjectKind UnpackPixel glCompressedTexImage3D +BufferObjectKind UnpackPixel glCompressedTexImage3DARB +BufferObjectKind UnpackPixel glCompressedTexSubImage1D +BufferObjectKind UnpackPixel glCompressedTexSubImage1DARB +BufferObjectKind UnpackPixel glCompressedTexSubImage2D +BufferObjectKind UnpackPixel glCompressedTexSubImage2DARB +BufferObjectKind UnpackPixel glCompressedTexSubImage3D +BufferObjectKind UnpackPixel glCompressedTexSubImage3DARB +BufferObjectKind UnpackPixel glConvolutionFilter1D +BufferObjectKind UnpackPixel glConvolutionFilter2D +BufferObjectKind UnpackPixel glDrawPixels +BufferObjectKind UnpackPixel glPixelMapfv +BufferObjectKind UnpackPixel glPixelMapuiv +BufferObjectKind UnpackPixel glPixelMapusv +BufferObjectKind UnpackPixel glPolygonStipple +BufferObjectKind UnpackPixel glSeparableFilter2D +BufferObjectKind UnpackPixel glTexImage1D +BufferObjectKind UnpackPixel glTexImage2D +BufferObjectKind UnpackPixel glTexImage3D +BufferObjectKind UnpackPixel glTexSubImage1D +BufferObjectKind UnpackPixel glTexSubImage2D +BufferObjectKind UnpackPixel glTexSubImage3D + +BufferObjectKind PackPixel glGetColorTable +BufferObjectKind PackPixel glGetCompressedTexImage +BufferObjectKind PackPixel glGetCompressedTexImageARB +BufferObjectKind PackPixel glGetConvolutionFilter +BufferObjectKind PackPixel glGetHistogram +BufferObjectKind PackPixel glGetMinmax +BufferObjectKind PackPixel glGetPixelMapfv +BufferObjectKind PackPixel glGetPixelMapuiv +BufferObjectKind PackPixel glGetPixelMapusv +BufferObjectKind PackPixel glGetPolygonStipple +BufferObjectKind PackPixel glGetSeparableFilter +BufferObjectKind PackPixel glGetTexImage +BufferObjectKind PackPixel glReadPixels + +# Range check directives for various routines +# FIXME: some of these are really the bare minimum and won't catch +# many classes of errors. Should extend the DebugGL to perform much +# more error checking with e.g. glDrawElements. +RangeCheck glColorPointer 3 1 +RangeCheck glDrawElements 3 {1} +RangeCheck glDrawRangeElements 5 {3} +RangeCheck glEdgeFlagPointer 1 1 +RangeCheck glElementPointerATI 1 1 +RangeCheck glFogCoordPointer 2 1 +RangeCheck glFogCoordPointerEXT 2 1 +RangeCheck glInterleavedArrays 2 1 +RangeCheck glMatrixIndexPointerARB 3 1 +RangeCheck glNormalPointer 2 1 +RangeCheck glSecondaryColorPointer 3 1 +RangeCheck glSecondaryColorPointerEXT 3 1 +RangeCheck glTexCoordPointer 3 1 +RangeCheck glVariantPointerEXT 3 1 +RangeCheck glVertexPointer 3 1 +RangeCheck glVertexAttribPointer 5 1 +RangeCheck glVertexAttribPointerARB 5 1 +RangeCheck glWeightPointerARB 3 1 + +# Give ourselves the texture width and height for range checking inside glGetTexImage +JavaPrologue glGetTexImage int width = 0, height = 0, depth = 1; +JavaPrologue glGetTexImage int[] tmp = new int[1]; +JavaPrologue glGetTexImage glGetTexLevelParameteriv(target, level, GL_TEXTURE_WIDTH, tmp, 0); +JavaPrologue glGetTexImage width = tmp[0]; +JavaPrologue glGetTexImage glGetTexLevelParameteriv(target, level, GL_TEXTURE_HEIGHT, tmp, 0); +JavaPrologue glGetTexImage height = tmp[0]; +JavaPrologue glGetTexImage if (target == GL_TEXTURE_3D) { +JavaPrologue glGetTexImage glGetTexLevelParameteriv(target, level, GL_TEXTURE_DEPTH, tmp, 0); +JavaPrologue glGetTexImage depth = tmp[0]; +JavaPrologue glGetTexImage } + +# Range check directives for various image-related routines +RangeCheckBytes glColorTable 5 imageSizeInBytes({3}, {4}, {2} , 1 , 1 , 1, false) +RangeCheckBytes glColorTableEXT 5 imageSizeInBytes({3}, {4}, {2} , 1 , 1 , 1, false) +RangeCheckBytes glConvolutionFilter1D 5 imageSizeInBytes({3}, {4}, {2} , 1 , 1 , 1, false) +RangeCheckBytes glConvolutionFilter2D 6 imageSizeInBytes({4}, {5}, {2} , {3} , 1 , 2, false) +RangeCheckBytes glDrawPixels 4 imageSizeInBytes({2}, {3}, {0} , {1} , 1 , 2, false) +RangeCheckBytes glReadPixels 6 imageSizeInBytes({4}, {5}, {2} , {3} , 1 , 2, true) +RangeCheckBytes glTexImage1D 7 imageSizeInBytes({5}, {6}, {3} , 1 , 1 , 1, false) +RangeCheckBytes glTexImage2D 8 imageSizeInBytes({6}, {7}, {3} , {4} , 1 , 2, false) +RangeCheckBytes glTexImage3D 9 imageSizeInBytes({7}, {8}, {3} , {4} , {5} , 3, false) +RangeCheckBytes glTexSubImage1D 6 imageSizeInBytes({4}, {5}, {3} , 1 , 1 , 1, false) +RangeCheckBytes glTexSubImage2D 8 imageSizeInBytes({6}, {7}, {4} , {5} , 1 , 2, false) +RangeCheckBytes glTexSubImage3D 10 imageSizeInBytes({8}, {9}, {5} , {6} , {7} , 3, false) +# This may produce wrong answers for 1D textures +RangeCheckBytes glGetTexImage 4 imageSizeInBytes({2}, {3}, width , height , depth, ((depth > 1) ? 3 : 2), true) +# Note we don't support glTexImage4DSGIS / glTexSubImage4DSGIS +# FIXME: add the following unpack operations: +# glBitmap, glPolygonStipple +# and the following pack operations: +# glGetColorTable, glGetConvolutionFilter, glGetSeparableFilter, glGetHistogram, glGetMinmax + +# Range checks for server-side object creation and deletion methods +RangeCheck glGenBuffers 1 {0} +RangeCheck glDeleteBuffers 1 {0} +RangeCheck glGenBuffersARB 1 {0} +RangeCheck glDeleteBuffersARB 1 {0} +RangeCheck glGenFencesAPPLE 1 {0} +RangeCheck glDeleteFencesAPPLE 1 {0} +RangeCheck glGenFencesNV 1 {0} +RangeCheck glDeleteFencesNV 1 {0} +RangeCheck glGenFramebuffersEXT 1 {0} +RangeCheck glDeleteFramebuffersEXT 1 {0} +RangeCheck glGenOcclusionQueriesNV 1 {0} +RangeCheck glDeleteOcclusionQueriesNV 1 {0} +RangeCheck glGenProgramsARB 1 {0} +RangeCheck glDeleteProgramsARB 1 {0} +RangeCheck glGenProgramsNV 1 {0} +RangeCheck glDeleteProgramsNV 1 {0} +RangeCheck glGenQueries 1 {0} +RangeCheck glDeleteQueries 1 {0} +RangeCheck glGenQueriesARB 1 {0} +RangeCheck glDeleteQueriesARB 1 {0} +RangeCheck glGenRenderbuffersEXT 1 {0} +RangeCheck glDeleteRenderbuffersEXT 1 {0} +RangeCheck glGenTextures 1 {0} +RangeCheck glDeleteTextures 1 {0} +RangeCheck glGenVertexArraysAPPLE 1 {0} +RangeCheck glDeleteVertexArraysAPPLE 1 {0} + +# Javadoc for the GL class +ClassJavadoc GL /** +ClassJavadoc GL * <P> The basic interface to OpenGL, providing access to core +ClassJavadoc GL * functionality up through the OpenGL 2.0 specification as well as +ClassJavadoc GL * all vendor extensions. </P> +ClassJavadoc GL * +ClassJavadoc GL * <P> While the APIs for vendor extensions are unconditionally +ClassJavadoc GL * exposed, the underlying functions may not be present. The method +ClassJavadoc GL * {@link #isFunctionAvailable} should be used to query the +ClassJavadoc GL * availability of any non-core function before it is used for the +ClassJavadoc GL * first time; for example, +ClassJavadoc GL * <code>gl.isFunctionAvailable("glProgramStringARB")</code>. On +ClassJavadoc GL * certain platforms (Windows in particular), the most "core" +ClassJavadoc GL * functionality is only OpenGL 1.1, so in theory any routines first +ClassJavadoc GL * exposed in OpenGL 1.2, 1.3, and 1.4, 1.5, or 2.0 as well as vendor +ClassJavadoc GL * extensions should all be queried. Calling an unavailable function +ClassJavadoc GL * will cause a {@link GLException} to be raised. </P> +ClassJavadoc GL * +ClassJavadoc GL * {@link #isExtensionAvailable} may also be used to determine whether +ClassJavadoc GL * a specific extension is available before calling the routines or +ClassJavadoc GL * using the functionality it exposes: for example, +ClassJavadoc GL * <code>gl.isExtensionAvailable("GL_ARB_vertex_program");</code>. +ClassJavadoc GL * However, in this case it is up to the end user to know which +ClassJavadoc GL * routines or functionality are associated with which OpenGL +ClassJavadoc GL * extensions. It may also be used to test for the availability of a +ClassJavadoc GL * particular version of OpenGL: for example, +ClassJavadoc GL * <code>gl.isExtensionAvailable("GL_VERSION_1_5");</code>. +ClassJavadoc GL * +ClassJavadoc GL * <P> Exceptions to the window system extension naming rules: +ClassJavadoc GL * +ClassJavadoc GL * <UL> +ClassJavadoc GL * +ClassJavadoc GL * <LI> The memory allocators for the NVidia vertex_array_range (VAR) +ClassJavadoc GL * extension, in particular <code>wglAllocateMemoryNV</code> / +ClassJavadoc GL * <code>glXAllocateMemoryNV</code> and associated routines. {@link +ClassJavadoc GL * #glAllocateMemoryNV} has been provided for window system-independent +ClassJavadoc GL * access to VAR. {@link #isFunctionAvailable} will translate an argument +ClassJavadoc GL * of "glAllocateMemoryNV" or "glFreeMemoryNV" into the appropriate +ClassJavadoc GL * window system-specific name. </P> +ClassJavadoc GL * +ClassJavadoc GL * <LI> WGL_ARB_pbuffer, WGL_ARB_pixel_format, and other +ClassJavadoc GL * platform-specific pbuffer functionality; the availability of +ClassJavadoc GL * pbuffers can be queried on Windows, X11 and Mac OS X platforms by +ClassJavadoc GL * querying {@link #isExtensionAvailable} with an argument of +ClassJavadoc GL * "GL_ARB_pbuffer" or "GL_ARB_pixel_format". +ClassJavadoc GL * +ClassJavadoc GL * </UL> <P> +ClassJavadoc GL * +ClassJavadoc GL */ + +# Javadoc for the WGL class +ClassJavadoc WGL /** +ClassJavadoc WGL * Provides access to the Windows-specific OpenGL vendor extensions. +ClassJavadoc WGL * See {@link GL} for more information. +ClassJavadoc WGL */ + +# Javadoc for the GLX class +ClassJavadoc GLX /** +ClassJavadoc GLX * Provides access to the X11-specific OpenGL vendor extensions. +ClassJavadoc GLX * See {@link GL} for more information. +ClassJavadoc GLX */ + +# Javadoc for the CGL class +ClassJavadoc CGL /** +ClassJavadoc CGL * Provides access to the MacOSX-specific OpenGL vendor extensions. +ClassJavadoc CGL * See {@link GL} for more information. +ClassJavadoc CGL */ + +# Javadoc for the XVisualInfo class +ClassJavadoc XVisualInfo /** +ClassJavadoc XVisualInfo * Wrapper for the XVisualInfo data structure, referenced by some GLX OpenGL +ClassJavadoc XVisualInfo * extensions. No other access is provided to these data structures so currently +ClassJavadoc XVisualInfo * this wrapper is not useful to end users, though it is used in the implementation. +ClassJavadoc XVisualInfo */ + +# Custom code for querying extensions and exposing +# wglAllocateMemoryNV/glXAllocateMemoryNV +CustomJavaCode GL /** +CustomJavaCode GL * Returns true if the specified OpenGL core- or extension-function can be +CustomJavaCode GL * used successfully through this GL instance given the current host (OpenGL +CustomJavaCode GL * <i>client</i>) and display (OpenGL <i>server</i>) configuration.<P> +CustomJavaCode GL * By "successfully" we mean that the function is both <i>callable</i> +CustomJavaCode GL * on the machine running the program and <i>available</i> on the current +CustomJavaCode GL * display.<P> +CustomJavaCode GL * +CustomJavaCode GL * In order to call a function successfully, the function must be both +CustomJavaCode GL * <i>callable</i> on the machine running the program and <i>available</i> on +CustomJavaCode GL * the display device that is rendering the output (note: on non-networked, +CustomJavaCode GL * single-display machines these two conditions are identical; on networked and/or +CustomJavaCode GL * multi-display machines this becomes more complicated). These conditions are +CustomJavaCode GL * met if the function is either part of the core OpenGL version supported by +CustomJavaCode GL * both the host and display, or it is an OpenGL extension function that both +CustomJavaCode GL * the host and display support. <P> +CustomJavaCode GL * +CustomJavaCode GL * A GL function is <i>callable</i> if it is successfully linked at runtime, +CustomJavaCode GL * hence the GLContext must be made current at least once. +CustomJavaCode GL * +CustomJavaCode GL * @param glFunctionName the name of the OpenGL function (e.g., use +CustomJavaCode GL * "glBindRenderbufferEXT" or "glBindRenderbuffer" to check if {@link +CustomJavaCode GL * #glBindRenderbuffer(int,int)} is available). +CustomJavaCode GL */ +CustomJavaCode GL public boolean isFunctionAvailable(String glFunctionName); + +CustomJavaCode GL /** +CustomJavaCode GL * Returns true if the specified OpenGL extension can be +CustomJavaCode GL * used successfully through this GL instance given the current host (OpenGL +CustomJavaCode GL * <i>client</i>) and display (OpenGL <i>server</i>) configuration.<P> +CustomJavaCode GL * +CustomJavaCode GL * @param glExtensionName the name of the OpenGL extension (e.g., +CustomJavaCode GL * "GL_ARB_vertex_program"). +CustomJavaCode GL */ +CustomJavaCode GL public boolean isExtensionAvailable(String glExtensionName); + +CustomJavaCode GL /** +CustomJavaCode GL * Provides platform-independent access to the <code>wglAllocateMemoryNV</code> / +CustomJavaCode GL * <code>glXAllocateMemoryNV</code> extension. +CustomJavaCode GL */ +CustomJavaCode GL public java.nio.ByteBuffer glAllocateMemoryNV(int arg0, float arg1, float arg2, float arg3); + +CustomJavaCode GL /** Provides a platform-independent way to specify the minimum swap +CustomJavaCode GL interval for buffer swaps. An argument of 0 disables +CustomJavaCode GL sync-to-vertical-refresh completely, while an argument of 1 +CustomJavaCode GL causes the application to wait until the next vertical refresh +CustomJavaCode GL until swapping buffers. The default, which is platform-specific, +CustomJavaCode GL is usually either 0 or 1. This function is not guaranteed to +CustomJavaCode GL have an effect, and in particular only affects heavyweight +CustomJavaCode GL onscreen components. */ +CustomJavaCode GL public void setSwapInterval(int interval); + +CustomJavaCode GL /** +CustomJavaCode GL * Returns an object through which platform-specific OpenGL extensions +CustomJavaCode GL * (WGL, GLX, etc.) may be accessed. The data type of the returned +CustomJavaCode GL * object and its associated capabilities are undefined. Most +CustomJavaCode GL * applications will never need to call this method. It is highly +CustomJavaCode GL * recommended that any applications which do call this method perform +CustomJavaCode GL * all accesses on the returned object reflectively to guard +CustomJavaCode GL * themselves against changes to the implementation. +CustomJavaCode GL */ +CustomJavaCode GL public Object getPlatformGLExtensions(); + +CustomJavaCode GL /** +CustomJavaCode GL * Returns an object providing access to the specified OpenGL +CustomJavaCode GL * extension. This is intended to provide a mechanism for vendors who +CustomJavaCode GL * which to provide access to new OpenGL extensions without changing +CustomJavaCode GL * the public API of the core package. For example, a user may request +CustomJavaCode GL * access to extension "GL_VENDOR_foo" and receive back an object +CustomJavaCode GL * which implements a vendor-specified interface which can call the +CustomJavaCode GL * OpenGL extension functions corresponding to that extension. It is +CustomJavaCode GL * up to the vendor to specify both the extension name and Java API +CustomJavaCode GL * for accessing it, including which class or interface contains the +CustomJavaCode GL * functions. +CustomJavaCode GL * +CustomJavaCode GL * <P> +CustomJavaCode GL * +CustomJavaCode GL * Note: it is the intent to add new extensions as quickly as possible +CustomJavaCode GL * to the core GL API. Therefore it is unlikely that most vendors will +CustomJavaCode GL * use this extension mechanism, but it is being provided for +CustomJavaCode GL * completeness. +CustomJavaCode GL */ +CustomJavaCode GL public Object getExtension(String extensionName); |