From: Zack Rusin Date: Wed, 21 Sep 2011 04:30:58 +0000 (-0400) Subject: Merge branch 'on-demand-loading' X-Git-Url: https://git.cworth.org/git?a=commitdiff_plain;h=1c35c914cf934c957664d9692a099634aacc4e44;hp=081e59db6cf60b3b39d6b6ce58b4a1b2ff96020e;p=apitrace Merge branch 'on-demand-loading' Fixes #36 --- diff --git a/BUGS.markdown b/BUGS.markdown new file mode 100644 index 0000000..2b8483d --- /dev/null +++ b/BUGS.markdown @@ -0,0 +1,115 @@ +Reporting bugs +============== + +Please report any issues on +[github](https://github.com/apitrace/apitrace/issues). + +Always include the following information: + +* operating system name and version + +* OpenGL/D3D driver name and version + + +Proprietary/confidential applications +===================================== + +Issues should be preferably filed on github to facilitate collaborative +development and for future reference. + +Access to applications source code is not required -- binaries are sufficient. + +If the bug happens with a proprietary application, and you don't want to +publicly release the application and/or any data collected from it, then +alternatively you can provide the necessary application and/or data via e-mail, +to *jose dot r dot fonseca at gmail dot com*. + +If it is not technically/legally feasible for you to provide application and/or +data at all, then you must be either: + +* develop and provide a test application, stripped-down of all + proprietary/confidential data, but that can reproduce the issue; + +* be willing/able to do the investigation of the issue, namely to identify the + root cause of the issue (e.g., which OpenGL call is not properly handled and + why), using all necessary tools (such as debuggers). + +Failure to do so will render the apitrace authors powerless to address the +issue. + + +Attachments +=========== + +github issue tracker doesn't support attachments. + +Please attach long logs to https://gist.github.com/ and paste the URL into the +issue description. + +For big attachments, such as traces, please upload it temporarily to a web +server you control, or use a file upload service such as +http://www.megaupload.com/ or http://dropbox.com/ and paste the URL into the +issue description. + +Trace files are only slightly compressed (for performance reasons). You can +further reduce their size when attaching/uploading by compressing with +[XZ](http://tukaani.org/xz/) or [7-Zip](http://www.7-zip.org/). + + +Bugs on tracing +=============== + +For bugs that happen while tracing (e.g., crashes while tracing the +application, or incorrect traces) please: + +* provide information on how to obtain the application; + +* describe how you were using it when the issue happened. + + +Bugs on retracing/GUI +===================== + +For bugs on retracing (e.g. crashes when retracing the application, +incorrect inconsistent rendering, or viewing with the GUI) please: + +* provide the trace file; + +* describe the results you got, and what results you were expecting. + + +Obtaining stack back-traces +=========================== + + +Linux/MacOSX +------------ + +Please rebuild apitrace with debugging information, by passing +`-DCMAKE_BUILD_TYPE=Debug` to cmake. + +To obtain a stack back-trace, run the application with gdb from a terminal: + + $ gdb --args application arg1 arg2 ... + (gdb) run + ... + (gdb) bt + + +See also more detailed and Distro specific instructions: + +* http://wiki.debian.org/HowToGetABacktrace + +* https://wiki.ubuntu.com/Backtrace + +* http://fedoraproject.org/wiki/StackTraces + +* http://live.gnome.org/GettingTraces + + +Windows +------- + +WRITEME + + diff --git a/CMakeLists.txt b/CMakeLists.txt index e327e28..9c91c90 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -425,7 +425,14 @@ endif () ############################################################################## # Packaging -install (FILES LICENSE README.markdown TODO.markdown DESTINATION doc) +install ( + FILES + BUGS.markdown + LICENSE + NEWS.markdown + README.markdown + TODO.markdown + DESTINATION doc) set (CPACK_PACKAGE_VERSION_MAJOR "1") set (CPACK_PACKAGE_VERSION_MINOR "0") diff --git a/NEWS.markdown b/NEWS.markdown new file mode 100644 index 0000000..2d8db5c --- /dev/null +++ b/NEWS.markdown @@ -0,0 +1,31 @@ +This file lists the major user visible improvments. For a full list of changes +and their authors see the git history. + + +Recent developments +=================== + +* Flush/sync trace file only when there is an uncaught signal/exception, + yielding a 5x speed up while tracing. + +* Employ [snappy compression library](http://code.google.com/p/snappy/) instead + of zlib, yielding a 2x speed up while tracing. + +* Implement and advertise `GL_GREMEDY_string_marker` and + `GL_GREMEDY_frame_terminator` extensions. + +* Mac OS X support. + +* Support up-to OpenGL 4.2 calls. + + +Version 1.0 +=========== + +* Qt GUI, capable of visualizing the calls, the state, and editing the state. + + +Pre-history +=========== + +* OpenGL retrace support. diff --git a/README.markdown b/README.markdown index f56412a..82f5e97 100644 --- a/README.markdown +++ b/README.markdown @@ -97,6 +97,39 @@ Advanced command line usage =========================== +Emitting annotations to the trace from GL applications +------------------------------------------------------ + +You can emit string and frame annotations through the +[`GL_GREMEDY_string_marker`](http://www.opengl.org/registry/specs/GREMEDY/string_marker.txt) +and +[`GL_GREMEDY_frame_terminator`](http://www.opengl.org/registry/specs/GREMEDY/frame_terminator.txt) +GL extensions. + +*apitrace* will advertise and intercept these GL extensions independently of +the GL implementation. So all you have to do is to use these extensions when +available. + +For example, if you use [GLEW](http://glew.sourceforge.net/) to dynamically +detect and use GL extensions, you could easily accomplish this by doing: + + void foo() { + + if (GLEW_GREMEDY_string_marker) { + glStringMarkerGREMEDY(0, __FUNCTION__ ": enter"); + } + + ... + + if (GLEW_GREMEDY_string_marker) { + glStringMarkerGREMEDY(0, __FUNCTION__ ": leave"); + } + + } + +This has the added advantage of working equally well with gDEBugger. + + Dump GL state at a particular call ---------------------------------- @@ -132,13 +165,13 @@ You can make a video of the output by doing Advanced usage for OpenGL implementors ====================================== -There are several avanced usage examples meant for OpenGL implementors. +There are several advanced usage examples meant for OpenGL implementors. Regression testing ------------------ -These are the steps to create a regression testsuite around apitrace: +These are the steps to create a regression test-suite around apitrace: * obtain a trace @@ -209,7 +242,7 @@ failures. The `--gl-renderer` option will also cause a commit to be skipped if the `GL_RENDERER` is unexpected (e.g., when a software renderer or another GL -driver is unintentianlly loaded due to missing symbol in the DRI driver, or +driver is unintentionally loaded due to missing symbol in the DRI driver, or another runtime fault). @@ -217,11 +250,11 @@ Side by side retracing ---------------------- In order to determine which draw call a regression first manifests one could -generate snapshots for every draw call, using the -S option. That is, however, +generate snapshots for every draw call, using the `-S` option. That is, however, very inefficient for big traces with many draw calls. A faster approach is to run both the bad and a good GL driver side-by-side. -The latter can be either a preivously known good build of the GL driver, or a +The latter can be either a previously known good build of the GL driver, or a reference software renderer. This can be achieved with retracediff.py script, which invokes glretrace with diff --git a/glapi.py b/glapi.py index 62e4638..a3a0b58 100644 --- a/glapi.py +++ b/glapi.py @@ -664,7 +664,7 @@ glapi.add_functions([ GlFunction(Void, "glEnablei", [(GLenum, "target"), (GLuint, "index")]), GlFunction(Void, "glDisablei", [(GLenum, "target"), (GLuint, "index")]), GlFunction(GLboolean, "glIsEnabledi", [(GLenum, "target"), (GLuint, "index")], sideeffects=False), - GlFunction(Void, "glBeginTransformFeedback", [(GLenum, "primitiveMode")]), + GlFunction(Void, "glBeginTransformFeedback", [(GLenum_mode, "primitiveMode")]), GlFunction(Void, "glEndTransformFeedback", []), GlFunction(Void, "glBindBufferRange", [(GLenum, "target"), (GLuint, "index"), (GLbuffer, "buffer"), (GLintptr, "offset"), (GLsizeiptr, "size")]), GlFunction(Void, "glBindBufferBase", [(GLenum, "target"), (GLuint, "index"), (GLbuffer, "buffer")]), @@ -1177,17 +1177,17 @@ glapi.add_functions([ GlFunction(Void, "glPatchParameterfv", [(GLenum, "pname"), (Const(Array(GLfloat, "__gl_param_size(pname)")), "values")]), # GL_ARB_transform_feedback2 - GlFunction(Void, "glBindTransformFeedback", [(GLenum, "target"), (GLuint, "id")]), - GlFunction(Void, "glDeleteTransformFeedbacks", [(GLsizei, "n"), (Const(Array(GLuint, "n")), "ids")]), - GlFunction(Void, "glGenTransformFeedbacks", [(GLsizei, "n"), Out(Array(GLuint, "n"), "ids")]), - GlFunction(GLboolean, "glIsTransformFeedback", [(GLuint, "id")], sideeffects=False), + GlFunction(Void, "glBindTransformFeedback", [(GLenum, "target"), (GLfeedback, "id")]), + GlFunction(Void, "glDeleteTransformFeedbacks", [(GLsizei, "n"), (Const(Array(GLfeedback, "n")), "ids")]), + GlFunction(Void, "glGenTransformFeedbacks", [(GLsizei, "n"), Out(Array(GLfeedback, "n"), "ids")]), + GlFunction(GLboolean, "glIsTransformFeedback", [(GLfeedback, "id")], sideeffects=False), GlFunction(Void, "glPauseTransformFeedback", []), GlFunction(Void, "glResumeTransformFeedback", []), - GlFunction(Void, "glDrawTransformFeedback", [(GLenum, "mode"), (GLuint, "id")]), + GlFunction(Void, "glDrawTransformFeedback", [(GLenum_mode, "mode"), (GLfeedback, "id")]), # GL_ARB_transform_feedback3 - GlFunction(Void, "glDrawTransformFeedbackStream", [(GLenum, "mode"), (GLuint, "id"), (GLuint, "stream")]), - GlFunction(Void, "glBeginQueryIndexed", [(GLenum, "target"), (GLuint, "index"), (GLuint, "id")]), + GlFunction(Void, "glDrawTransformFeedbackStream", [(GLenum_mode, "mode"), (GLfeedback, "id"), (GLuint, "stream")]), + GlFunction(Void, "glBeginQueryIndexed", [(GLenum, "target"), (GLuint, "index"), (GLfeedback, "id")]), GlFunction(Void, "glEndQueryIndexed", [(GLenum, "target"), (GLuint, "index")]), GlFunction(Void, "glGetQueryIndexediv", [(GLenum, "target"), (GLuint, "index"), (GLenum, "pname"), Out(OpaqueArray(GLint, "__glGetQueryIndexediv_size(pname)"), "params")], sideeffects=False), @@ -1317,6 +1317,33 @@ glapi.add_functions([ GlFunction(Void, "glGetnUniformuivARB", [(GLprogram, "program"), (GLlocation, "location"), (GLsizei, "bufSize"), Out(Array(GLuint, "bufSize"), "params")], sideeffects=False), GlFunction(Void, "glGetnUniformdvARB", [(GLprogram, "program"), (GLlocation, "location"), (GLsizei, "bufSize"), Out(Array(GLdouble, "bufSize"), "params")], sideeffects=False), + # GL_ARB_base_instance + GlFunction(Void, "glDrawArraysInstancedBaseInstance", [(GLenum_mode, "mode"), (GLint, "first"), (GLsizei, "count"), (GLsizei, "primcount"), (GLuint, "baseinstance")]), + GlFunction(Void, "glDrawElementsInstancedBaseInstance", [(GLenum_mode, "mode"), (GLsizei, "count"), (GLenum, "type"), (OpaquePointer(Const(GLvoid)), "indices"), (GLsizei, "primcount"), (GLuint, "baseinstance")]), + GlFunction(Void, "glDrawElementsInstancedBaseVertexBaseInstance", [(GLenum_mode, "mode"), (GLsizei, "count"), (GLenum, "type"), (OpaquePointer(Const(GLvoid)), "indices"), (GLsizei, "primcount"), (GLint, "basevertex"), (GLuint, "baseinstance")]), + + # GL_ARB_transform_feedback_instanced + GlFunction(Void, "glDrawTransformFeedbackInstanced", [(GLenum_mode, "mode"), (GLfeedback, "id"), (GLsizei, "primcount")]), + GlFunction(Void, "glDrawTransformFeedbackStreamInstanced", [(GLenum_mode, "mode"), (GLfeedback, "id"), (GLuint, "stream"), (GLsizei, "primcount")]), + + # GL_ARB_internalformat_query + GlFunction(Void, "glGetInternalformativ", [(GLenum, "target"), (GLenum, "internalformat"), (GLenum, "pname"), (GLsizei, "bufSize"), Out(Array(GLint, "bufSize"), "params")], sideeffects=False), + + # GL_ARB_shader_atomic_counters + GlFunction(Void, "glGetActiveAtomicCounterBufferiv", [(GLprogram, "program"), (GLuint, "bufferIndex"), (GLenum, "pname"), Out(OpaqueArray(GLint, "__glGetActiveAtomicCounterBufferiv_size(pname)"), "params")], sideeffects=False), + + # GL_ARB_shader_image_load_store + GlFunction(Void, "glBindImageTexture", [(GLuint, "unit"), (GLtexture, "texture"), (GLint, "level"), (GLboolean, "layered"), (GLint, "layer"), (GLenum, "access"), (GLenum, "format")]), + GlFunction(Void, "glMemoryBarrier", [(GLbitfield_barrier, "barriers")]), + + # GL_ARB_texture_storage + GlFunction(Void, "glTexStorage1D", [(GLenum, "target"), (GLsizei, "levels"), (GLenum, "internalformat"), (GLsizei, "width")]), + GlFunction(Void, "glTexStorage2D", [(GLenum, "target"), (GLsizei, "levels"), (GLenum, "internalformat"), (GLsizei, "width"), (GLsizei, "height")]), + GlFunction(Void, "glTexStorage3D", [(GLenum, "target"), (GLsizei, "levels"), (GLenum, "internalformat"), (GLsizei, "width"), (GLsizei, "height"), (GLsizei, "depth")]), + GlFunction(Void, "glTextureStorage1DEXT", [(GLtexture, "texture"), (GLenum, "target"), (GLsizei, "levels"), (GLenum, "internalformat"), (GLsizei, "width")]), + GlFunction(Void, "glTextureStorage2DEXT", [(GLtexture, "texture"), (GLenum, "target"), (GLsizei, "levels"), (GLenum, "internalformat"), (GLsizei, "width"), (GLsizei, "height")]), + GlFunction(Void, "glTextureStorage3DEXT", [(GLtexture, "texture"), (GLenum, "target"), (GLsizei, "levels"), (GLenum, "internalformat"), (GLsizei, "width"), (GLsizei, "height"), (GLsizei, "depth")]), + # GL_EXT_blend_color GlFunction(Void, "glBlendColorEXT", [(GLclampf, "red"), (GLclampf, "green"), (GLclampf, "blue"), (GLclampf, "alpha")]), @@ -1992,11 +2019,11 @@ glapi.add_functions([ # GL_ATI_element_array GlFunction(Void, "glElementPointerATI", [(GLenum, "type"), (Const(OpaquePointer(GLvoid)), "pointer")]), - GlFunction(Void, "glDrawElementArrayATI", [(GLenum, "mode"), (GLsizei, "count")]), - GlFunction(Void, "glDrawRangeElementArrayATI", [(GLenum, "mode"), (GLuint, "start"), (GLuint, "end"), (GLsizei, "count")]), + GlFunction(Void, "glDrawElementArrayATI", [(GLenum_mode, "mode"), (GLsizei, "count")]), + GlFunction(Void, "glDrawRangeElementArrayATI", [(GLenum_mode, "mode"), (GLuint, "start"), (GLuint, "end"), (GLsizei, "count")]), # GL_SUN_mesh_array - GlFunction(Void, "glDrawMeshArraysSUN", [(GLenum, "mode"), (GLint, "first"), (GLsizei, "count"), (GLsizei, "width")]), + GlFunction(Void, "glDrawMeshArraysSUN", [(GLenum_mode, "mode"), (GLint, "first"), (GLsizei, "count"), (GLsizei, "width")]), # GL_NV_occlusion_query GlFunction(Void, "glGenOcclusionQueriesNV", [(GLsizei, "n"), Out(Array(GLquery, "n"), "ids")]), @@ -2016,10 +2043,10 @@ glapi.add_functions([ # GL_APPLE_element_array GlFunction(Void, "glElementPointerAPPLE", [(GLenum, "type"), (Const(Blob(GLvoid, "type")), "pointer")]), - GlFunction(Void, "glDrawElementArrayAPPLE", [(GLenum, "mode"), (GLint, "first"), (GLsizei, "count")]), - GlFunction(Void, "glDrawRangeElementArrayAPPLE", [(GLenum, "mode"), (GLuint, "start"), (GLuint, "end"), (GLint, "first"), (GLsizei, "count")]), - GlFunction(Void, "glMultiDrawElementArrayAPPLE", [(GLenum, "mode"), (Const(Array(GLint, "primcount")), "first"), (Const(Array(GLsizei, "primcount")), "count"), (GLsizei, "primcount")]), - GlFunction(Void, "glMultiDrawRangeElementArrayAPPLE", [(GLenum, "mode"), (GLuint, "start"), (GLuint, "end"), (Const(Array(GLint, "primcount")), "first"), (Const(Array(GLsizei, "primcount")), "count"), (GLsizei, "primcount")]), + GlFunction(Void, "glDrawElementArrayAPPLE", [(GLenum_mode, "mode"), (GLint, "first"), (GLsizei, "count")]), + GlFunction(Void, "glDrawRangeElementArrayAPPLE", [(GLenum_mode, "mode"), (GLuint, "start"), (GLuint, "end"), (GLint, "first"), (GLsizei, "count")]), + GlFunction(Void, "glMultiDrawElementArrayAPPLE", [(GLenum_mode, "mode"), (Const(Array(GLint, "primcount")), "first"), (Const(Array(GLsizei, "primcount")), "count"), (GLsizei, "primcount")]), + GlFunction(Void, "glMultiDrawRangeElementArrayAPPLE", [(GLenum_mode, "mode"), (GLuint, "start"), (GLuint, "end"), (Const(Array(GLint, "primcount")), "first"), (Const(Array(GLsizei, "primcount")), "count"), (GLsizei, "primcount")]), # GL_APPLE_fence GlFunction(Void, "glGenFencesAPPLE", [(GLsizei, "n"), Out(Array(GLuint, "n"), "fences")]), @@ -2270,7 +2297,7 @@ glapi.add_functions([ GlFunction(GLboolean, "glIsEnabledIndexedEXT", [(GLenum, "target"), (GLuint, "index")], sideeffects=False), # GL_NV_transform_feedback - GlFunction(Void, "glBeginTransformFeedbackNV", [(GLenum, "primitiveMode")]), + GlFunction(Void, "glBeginTransformFeedbackNV", [(GLenum_mode, "primitiveMode")]), GlFunction(Void, "glEndTransformFeedbackNV", []), GlFunction(Void, "glTransformFeedbackAttribsNV", [(GLuint, "count"), (Const(OpaqueArray(GLint, "__glTransformFeedbackAttribsNV_size(count)")), "attribs"), (GLenum, "bufferMode")]), GlFunction(Void, "glBindBufferRangeNV", [(GLenum, "target"), (GLuint, "index"), (GLbuffer, "buffer"), (GLintptr, "offset"), (GLsizeiptr, "size")]), @@ -2312,7 +2339,7 @@ glapi.add_functions([ GlFunction(Void, "glGetVideoui64vNV", [(GLuint, "video_slot"), (GLenum, "pname"), Out(OpaqueArray(GLuint64EXT, "__glGetVideoui64vNV_size(pname)"), "params")], sideeffects=False), # GL_EXT_transform_feedback - GlFunction(Void, "glBeginTransformFeedbackEXT", [(GLenum, "primitiveMode")]), + GlFunction(Void, "glBeginTransformFeedbackEXT", [(GLenum_mode, "primitiveMode")]), GlFunction(Void, "glEndTransformFeedbackEXT", []), GlFunction(Void, "glBindBufferRangeEXT", [(GLenum, "target"), (GLuint, "index"), (GLbuffer, "buffer"), (GLintptr, "offset"), (GLsizeiptr, "size")]), GlFunction(Void, "glBindBufferOffsetEXT", [(GLenum, "target"), (GLuint, "index"), (GLbuffer, "buffer"), (GLintptr, "offset")]), @@ -2527,25 +2554,25 @@ glapi.add_functions([ GlFunction(Void, "glProgramUniformMatrix3x4dvEXT", [(GLprogram, "program"), (GLlocation, "location"), (GLsizei, "count"), (GLboolean, "transpose"), (Const(Array(GLdouble, "count*3*4")), "value")]), GlFunction(Void, "glProgramUniformMatrix4x2dvEXT", [(GLprogram, "program"), (GLlocation, "location"), (GLsizei, "count"), (GLboolean, "transpose"), (Const(Array(GLdouble, "count*4*2")), "value")]), GlFunction(Void, "glProgramUniformMatrix4x3dvEXT", [(GLprogram, "program"), (GLlocation, "location"), (GLsizei, "count"), (GLboolean, "transpose"), (Const(Array(GLdouble, "count*4*3")), "value")]), - Function(Void, "glVertexArrayVertexOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), - Function(Void, "glVertexArrayColorOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), - Function(Void, "glVertexArrayEdgeFlagOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLsizei, "stride"), (GLintptr, "offset")]), - Function(Void, "glVertexArrayIndexOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), - Function(Void, "glVertexArrayNormalOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), - Function(Void, "glVertexArrayTexCoordOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), - Function(Void, "glVertexArrayMultiTexCoordOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLenum, "texunit"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), - Function(Void, "glVertexArrayFogCoordOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), - Function(Void, "glVertexArraySecondaryColorOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), - Function(Void, "glVertexArrayVertexAttribOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLuint, "index"), (GLint, "size"), (GLenum, "type"), (GLboolean, "normalized"), (GLsizei, "stride"), (GLintptr, "offset")]), - Function(Void, "glVertexArrayVertexAttribIOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLuint, "index"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), - Function(Void, "glEnableVertexArrayEXT", [(GLuint, "vaobj"), (GLenum, "array")]), - Function(Void, "glDisableVertexArrayEXT", [(GLuint, "vaobj"), (GLenum, "array")]), - Function(Void, "glEnableVertexArrayAttribEXT", [(GLuint, "vaobj"), (GLuint, "index")]), - Function(Void, "glDisableVertexArrayAttribEXT", [(GLuint, "vaobj"), (GLuint, "index")]), - Function(Void, "glGetVertexArrayIntegervEXT", [(GLuint, "vaobj"), (GLenum, "pname"), Out(Pointer(GLint), "param")]), - Function(Void, "glGetVertexArrayPointervEXT", [(GLuint, "vaobj"), (GLenum, "pname"), Out(Pointer(OpaquePointer(GLvoid)), "param")]), - Function(Void, "glGetVertexArrayIntegeri_vEXT", [(GLuint, "vaobj"), (GLuint, "index"), (GLenum, "pname"), Out(Pointer(GLint), "param")]), - Function(Void, "glGetVertexArrayPointeri_vEXT", [(GLuint, "vaobj"), (GLuint, "index"), (GLenum, "pname"), Out(Pointer(OpaquePointer(GLvoid)), "param")]), + GlFunction(Void, "glVertexArrayVertexOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glVertexArrayColorOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glVertexArrayEdgeFlagOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glVertexArrayIndexOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glVertexArrayNormalOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glVertexArrayTexCoordOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glVertexArrayMultiTexCoordOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLenum, "texunit"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glVertexArrayFogCoordOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glVertexArraySecondaryColorOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glVertexArrayVertexAttribOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLuint, "index"), (GLint, "size"), (GLenum, "type"), (GLboolean, "normalized"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glVertexArrayVertexAttribIOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLuint, "index"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glEnableVertexArrayEXT", [(GLarray, "vaobj"), (GLenum, "array")]), + GlFunction(Void, "glDisableVertexArrayEXT", [(GLarray, "vaobj"), (GLenum, "array")]), + GlFunction(Void, "glEnableVertexArrayAttribEXT", [(GLarray, "vaobj"), (GLuint, "index")]), + GlFunction(Void, "glDisableVertexArrayAttribEXT", [(GLarray, "vaobj"), (GLuint, "index")]), + GlFunction(Void, "glGetVertexArrayIntegervEXT", [(GLarray, "vaobj"), (GLenum, "pname"), Out(Pointer(GLint), "param")]), + GlFunction(Void, "glGetVertexArrayPointervEXT", [(GLarray, "vaobj"), (GLenum, "pname"), Out(Pointer(OpaquePointer(GLvoid)), "param")]), + GlFunction(Void, "glGetVertexArrayIntegeri_vEXT", [(GLarray, "vaobj"), (GLuint, "index"), (GLenum, "pname"), Out(Pointer(GLint), "param")]), + GlFunction(Void, "glGetVertexArrayPointeri_vEXT", [(GLarray, "vaobj"), (GLuint, "index"), (GLenum, "pname"), Out(Pointer(OpaquePointer(GLvoid)), "param")]), # GL_NV_explicit_multisample GlFunction(Void, "glGetMultisamplefvNV", [(GLenum, "pname"), (GLuint, "index"), Out(Array(GLfloat, "2"), "val")], sideeffects=False), @@ -2553,13 +2580,13 @@ glapi.add_functions([ GlFunction(Void, "glTexRenderbufferNV", [(GLenum, "target"), (GLuint, "renderbuffer")]), # GL_NV_transform_feedback2 - GlFunction(Void, "glBindTransformFeedbackNV", [(GLenum, "target"), (GLuint, "id")]), - GlFunction(Void, "glDeleteTransformFeedbacksNV", [(GLsizei, "n"), (Const(Array(GLuint, "n")), "ids")]), - GlFunction(Void, "glGenTransformFeedbacksNV", [(GLsizei, "n"), Out(Array(GLuint, "n"), "ids")]), - GlFunction(GLboolean, "glIsTransformFeedbackNV", [(GLuint, "id")], sideeffects=False), + GlFunction(Void, "glBindTransformFeedbackNV", [(GLenum, "target"), (GLfeedback, "id")]), + GlFunction(Void, "glDeleteTransformFeedbacksNV", [(GLsizei, "n"), (Const(Array(GLfeedback, "n")), "ids")]), + GlFunction(Void, "glGenTransformFeedbacksNV", [(GLsizei, "n"), Out(Array(GLfeedback, "n"), "ids")]), + GlFunction(GLboolean, "glIsTransformFeedbackNV", [(GLfeedback, "id")], sideeffects=False), GlFunction(Void, "glPauseTransformFeedbackNV", []), GlFunction(Void, "glResumeTransformFeedbackNV", []), - GlFunction(Void, "glDrawTransformFeedbackNV", [(GLenum, "mode"), (GLuint, "id")]), + GlFunction(Void, "glDrawTransformFeedbackNV", [(GLenum_mode, "mode"), (GLfeedback, "id")]), # GL_AMD_performance_monitor GlFunction(Void, "glGetPerfMonitorGroupsAMD", [Out(Pointer(GLint), "numGroups"), (GLsizei, "groupsSize"), Out(Array(GLuint, "groupsSize"), "groups")], sideeffects=False), @@ -2661,8 +2688,8 @@ glapi.add_functions([ GlFunction(Void, "glTextureBarrierNV", []), # GL_EXT_shader_image_load_store - GlFunction(Void, "glBindImageTextureEXT", [(GLuint, "index"), (GLuint, "texture"), (GLint, "level"), (GLboolean, "layered"), (GLint, "layer"), (GLenum, "access"), (GLint, "format")]), - GlFunction(Void, "glMemoryBarrierEXT", [(GLbitfield, "barriers")]), + GlFunction(Void, "glBindImageTextureEXT", [(GLuint, "index"), (GLtexture, "texture"), (GLint, "level"), (GLboolean, "layered"), (GLint, "layer"), (GLenum, "access"), (GLint, "format")]), + GlFunction(Void, "glMemoryBarrierEXT", [(GLbitfield_barrier, "barriers")]), # GL_EXT_vertex_attrib_64bit GlFunction(Void, "glVertexAttribL1dEXT", [(GLuint, "index"), (GLdouble, "x")]), @@ -2675,7 +2702,7 @@ glapi.add_functions([ GlFunction(Void, "glVertexAttribL4dvEXT", [(GLuint, "index"), (Const(Array(GLdouble, "4")), "v")]), GlFunction(Void, "glVertexAttribLPointerEXT", [(GLuint, "index"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (Const(Blob(GLvoid, "size")), "pointer")]), GlFunction(Void, "glGetVertexAttribLdvEXT", [(GLuint, "index"), (GLenum, "pname"), Out(OpaqueArray(GLdouble, "__glGetVertexAttribLdvEXT_size(pname)"), "params")], sideeffects=False), - GlFunction(Void, "glVertexArrayVertexAttribLOffsetEXT", [(GLuint, "vaobj"), (GLuint, "buffer"), (GLuint, "index"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), + GlFunction(Void, "glVertexArrayVertexAttribLOffsetEXT", [(GLarray, "vaobj"), (GLuint, "buffer"), (GLuint, "index"), (GLint, "size"), (GLenum, "type"), (GLsizei, "stride"), (GLintptr, "offset")]), # GL_NV_gpu_program5 GlFunction(Void, "glProgramSubroutineParametersuivNV", [(GLenum, "target"), (GLsizei, "count"), (Const(Array(GLuint, "count")), "params")]), @@ -2763,8 +2790,8 @@ glapi.add_functions([ GlFunction(GLsync, "glImportSyncEXT", [(GLenum, "external_sync_type"), (GLintptr, "external_sync"), (GLbitfield, "flags")]), # GL_AMD_multi_draw_indirect - GlFunction(Void, "glMultiDrawArraysIndirectAMD", [(GLenum, "mode"), (Const(OpaquePointer(GLvoid)), "indirect"), (GLsizei, "primcount"), (GLsizei, "stride")]), - GlFunction(Void, "glMultiDrawElementsIndirectAMD", [(GLenum, "mode"), (GLenum, "type"), (Const(OpaquePointer(GLvoid)), "indirect"), (GLsizei, "primcount"), (GLsizei, "stride")]), + GlFunction(Void, "glMultiDrawArraysIndirectAMD", [(GLenum_mode, "mode"), (Const(OpaquePointer(GLvoid)), "indirect"), (GLsizei, "primcount"), (GLsizei, "stride")]), + GlFunction(Void, "glMultiDrawElementsIndirectAMD", [(GLenum_mode, "mode"), (GLenum, "type"), (Const(OpaquePointer(GLvoid)), "indirect"), (GLsizei, "primcount"), (GLsizei, "stride")]), # GL_KTX_buffer_region # XXX: http://www.west.net/~brittain/3dsmax2.htm does not mention EXT suffix @@ -2781,7 +2808,7 @@ glapi.add_functions([ GlFunction(GLuint, "glBufferRegionEnabledEXT", [], sideeffects=False), # GL_WIN_swap_hint - Function(Void, "glAddSwapHintRectWIN", [(GLint, "x"), (GLint, "y"), (GLsizei, "width"), (GLsizei, "height")]), + GlFunction(Void, "glAddSwapHintRectWIN", [(GLint, "x"), (GLint, "y"), (GLsizei, "width"), (GLsizei, "height")]), ]) diff --git a/glparams.py b/glparams.py index fd8c002..8636877 100644 --- a/glparams.py +++ b/glparams.py @@ -33,7 +33,7 @@ from gltypes import * # Shorthands for the types -X = None # To be determined +X = None # To be determined, merely an enum B = GLboolean I = GLint I64 = GLint64 @@ -44,6 +44,8 @@ P = OpaquePointer(Void) S = CString H = GLhandleARB +# A underscore prefix (e.g., _glGet) is used to skip automatic code generation +# for parameters that are obtained through other ways. parameters = [ # (functions, type, count, name) # value @@ -285,7 +287,7 @@ parameters = [ ("glGet", F, 1, "GL_DEPTH_BIAS"), # 0x0D1F ("glGet", I, 1, "GL_MAX_EVAL_ORDER"), # 0x0D30 ("glGet", I, 1, "GL_MAX_LIGHTS"), # 0x0D31 - ("glGet", I, 1, "GL_MAX_CLIP_PLANES"), # 0x0D32 + ("glGet", I, 1, "GL_MAX_CLIP_DISTANCES"), # 0x0D32 ("glGet", I, 1, "GL_MAX_TEXTURE_SIZE"), # 0x0D33 ("glGet", I, 1, "GL_MAX_PIXEL_MAP_TABLE"), # 0x0D34 ("glGet", I, 1, "GL_MAX_ATTRIB_STACK_DEPTH"), # 0x0D35 @@ -497,14 +499,14 @@ parameters = [ ("", X, 1, "GL_T2F_N3F_V3F"), # 0x2A2B ("", X, 1, "GL_T2F_C4F_N3F_V3F"), # 0x2A2C ("", X, 1, "GL_T4F_C4F_N3F_V4F"), # 0x2A2D - ("glGet", B, 1, "GL_CLIP_PLANE0"), # 0x3000 - ("glGet", B, 1, "GL_CLIP_PLANE1"), # 0x3001 - ("glGet", B, 1, "GL_CLIP_PLANE2"), # 0x3002 - ("glGet", B, 1, "GL_CLIP_PLANE3"), # 0x3003 - ("glGet", B, 1, "GL_CLIP_PLANE4"), # 0x3004 - ("glGet", B, 1, "GL_CLIP_PLANE5"), # 0x3005 - ("", X, 1, "GL_CLIP_DISTANCE6"), # 0x3006 - ("", X, 1, "GL_CLIP_DISTANCE7"), # 0x3007 + ("glGet", B, 1, "GL_CLIP_DISTANCE0"), # 0x3000 + ("glGet", B, 1, "GL_CLIP_DISTANCE1"), # 0x3001 + ("glGet", B, 1, "GL_CLIP_DISTANCE2"), # 0x3002 + ("glGet", B, 1, "GL_CLIP_DISTANCE3"), # 0x3003 + ("glGet", B, 1, "GL_CLIP_DISTANCE4"), # 0x3004 + ("glGet", B, 1, "GL_CLIP_DISTANCE5"), # 0x3005 + ("glGet", B, 1, "GL_CLIP_DISTANCE6"), # 0x3006 + ("glGet", B, 1, "GL_CLIP_DISTANCE7"), # 0x3007 ("_glGet", B, 1, "GL_LIGHT0"), # 0x4000 ("_glGet", B, 1, "GL_LIGHT1"), # 0x4001 ("_glGet", B, 1, "GL_LIGHT2"), # 0x4002 @@ -1233,8 +1235,8 @@ parameters = [ ("", X, 1, "GL_VARIABLE_E_NV"), # 0x8527 ("", X, 1, "GL_VARIABLE_F_NV"), # 0x8528 ("", X, 1, "GL_VARIABLE_G_NV"), # 0x8529 - ("", X, 1, "GL_CONSTANT_COLOR0_NV"), # 0x852A - ("", X, 1, "GL_CONSTANT_COLOR1_NV"), # 0x852B + ("glGet", F, 4, "GL_CONSTANT_COLOR0_NV"), # 0x852A + ("glGet", F, 4, "GL_CONSTANT_COLOR1_NV"), # 0x852B ("", X, 1, "GL_PRIMARY_COLOR_NV"), # 0x852C ("", X, 1, "GL_SECONDARY_COLOR_NV"), # 0x852D ("", X, 1, "GL_SPARE0_NV"), # 0x852E @@ -1268,9 +1270,9 @@ parameters = [ ("", X, 1, "GL_COMBINER_AB_OUTPUT_NV"), # 0x854A ("", X, 1, "GL_COMBINER_CD_OUTPUT_NV"), # 0x854B ("", X, 1, "GL_COMBINER_SUM_OUTPUT_NV"), # 0x854C - ("", X, 1, "GL_MAX_GENERAL_COMBINERS_NV"), # 0x854D - ("", X, 1, "GL_NUM_GENERAL_COMBINERS_NV"), # 0x854E - ("", X, 1, "GL_COLOR_SUM_CLAMP_NV"), # 0x854F + ("glGet", I, 1, "GL_MAX_GENERAL_COMBINERS_NV"), # 0x854D + ("glGet", I, 1, "GL_NUM_GENERAL_COMBINERS_NV"), # 0x854E + ("glGet", B, 1, "GL_COLOR_SUM_CLAMP_NV"), # 0x854F ("", X, 1, "GL_COMBINER0_NV"), # 0x8550 ("", X, 1, "GL_COMBINER1_NV"), # 0x8551 ("", X, 1, "GL_COMBINER2_NV"), # 0x8552 @@ -1384,7 +1386,7 @@ parameters = [ ("", X, 1, "GL_MATRIX7_NV"), # 0x8637 ("glGet", I, 1, "GL_CURRENT_MATRIX_STACK_DEPTH_ARB"), # 0x8640 ("glGet", F, 16, "GL_CURRENT_MATRIX_ARB"), # 0x8641 - ("glGet", B, 1, "GL_VERTEX_PROGRAM_POINT_SIZE"), # 0x8642 + ("glGet", B, 1, "GL_PROGRAM_POINT_SIZE"), # 0x8642 ("glGet", B, 1, "GL_VERTEX_PROGRAM_TWO_SIDE"), # 0x8643 ("", X, 1, "GL_PROGRAM_PARAMETER_NV"), # 0x8644 ("glGetVertexAttrib", P, 1, "GL_VERTEX_ATTRIB_ARRAY_POINTER"), # 0x8645 @@ -1825,7 +1827,7 @@ parameters = [ ("glGetTexParameter", E, 1, "GL_DEPTH_TEXTURE_MODE"), # 0x884B ("glGetTexParameter", E, 1, "GL_TEXTURE_COMPARE_MODE"), # 0x884C ("glGetTexParameter", E, 1, "GL_TEXTURE_COMPARE_FUNC"), # 0x884D - ("", X, 1, "GL_COMPARE_R_TO_TEXTURE"), # 0x884E + ("", X, 1, "GL_COMPARE_REF_TO_TEXTURE"), # 0x884E ("glGet", B, 1, "GL_TEXTURE_CUBE_MAP_SEAMLESS"), # 0x884F ("", X, 1, "GL_OFFSET_PROJECTIVE_TEXTURE_2D_NV"), # 0x8850 ("", X, 1, "GL_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV"), # 0x8851 @@ -2118,6 +2120,12 @@ parameters = [ ("", X, 1, "GL_RESAMPLE_ZERO_FILL_OML"), # 0x8987 ("", X, 1, "GL_RESAMPLE_AVERAGE_OML"), # 0x8988 ("", X, 1, "GL_RESAMPLE_DECIMATE_OML"), # 0x8989 + #("", X, 1, "GL_POINT_SIZE_ARRAY_TYPE_OES"), # 0x898A + #("", X, 1, "GL_POINT_SIZE_ARRAY_STRIDE_OES"), # 0x898B + #("", X, 1, "GL_POINT_SIZE_ARRAY_POINTER_OES"), # 0x898C + #("", X, 1, "GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES"), # 0x898D + #("", X, 1, "GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES"), # 0x898E + #("", X, 1, "GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES"), # 0x898F ("", X, 1, "GL_VERTEX_ATTRIB_MAP1_APPLE"), # 0x8A00 ("", X, 1, "GL_VERTEX_ATTRIB_MAP2_APPLE"), # 0x8A01 ("", X, 1, "GL_VERTEX_ATTRIB_MAP1_SIZE_APPLE"), # 0x8A02 @@ -2177,9 +2185,9 @@ parameters = [ ("glGetActiveUniformBlock", B, 1, "GL_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER"), # 0x8A44 ("glGetActiveUniformBlock", B, 1, "GL_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER"), # 0x8A45 ("glGetActiveUniformBlock", B, 1, "GL_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER"), # 0x8A46 - #"glGet", (X, 1, "GL_TEXTURE_SRGB_DECODE_EXT"), # 0x8A48 - #"glGet", (X, 1, "GL_DECODE_EXT"), # 0x8A49 - #"glGet", (X, 1, "GL_SKIP_DECODE_EXT"), # 0x8A4A + ("glGetTexParameter", E, 1, "GL_TEXTURE_SRGB_DECODE_EXT"), # 0x8A48 + ("", X, 1, "GL_DECODE_EXT"), # 0x8A49 + ("", X, 1, "GL_SKIP_DECODE_EXT"), # 0x8A4A ("", X, 1, "GL_FRAGMENT_SHADER"), # 0x8B30 ("", X, 1, "GL_VERTEX_SHADER"), # 0x8B31 ("", H, 1, "GL_PROGRAM_OBJECT_ARB"), # 0x8B40 @@ -2232,8 +2240,30 @@ parameters = [ ("", X, 1, "GL_FRAGMENT_SHADER_DERIVATIVE_HINT"), # 0x8B8B ("", X, 1, "GL_SHADING_LANGUAGE_VERSION"), # 0x8B8C ("glGet", I, 1, "GL_CURRENT_PROGRAM"), # 0x8B8D + #("", X, 1, "GL_PALETTE4_RGB8_OES"), # 0x8B90 + #("", X, 1, "GL_PALETTE4_RGBA8_OES"), # 0x8B91 + #("", X, 1, "GL_PALETTE4_R5_G6_B5_OES"), # 0x8B92 + #("", X, 1, "GL_PALETTE4_RGBA4_OES"), # 0x8B93 + #("", X, 1, "GL_PALETTE4_RGB5_A1_OES"), # 0x8B94 + #("", X, 1, "GL_PALETTE8_RGB8_OES"), # 0x8B95 + #("", X, 1, "GL_PALETTE8_RGBA8_OES"), # 0x8B96 + #("", X, 1, "GL_PALETTE8_R5_G6_B5_OES"), # 0x8B97 + #("", X, 1, "GL_PALETTE8_RGBA4_OES"), # 0x8B98 + #("", X, 1, "GL_PALETTE8_RGB5_A1_OES"), # 0x8B99 ("", X, 1, "GL_IMPLEMENTATION_COLOR_READ_TYPE"), # 0x8B9A ("", X, 1, "GL_IMPLEMENTATION_COLOR_READ_FORMAT"), # 0x8B9B + #("", X, 1, "GL_POINT_SIZE_ARRAY_OES"), # 0x8B9C + #("", X, 1, "GL_TEXTURE_CROP_RECT_OES"), # 0x8B9D + #("", X, 1, "GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES"), # 0x8B9E + #("", X, 1, "GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES"), # 0x8B9F + #("", X, 1, "GL_FRAGMENT_PROGRAM_POSITION_MESA"), # 0x8BB0 + #("", X, 1, "GL_FRAGMENT_PROGRAM_CALLBACK_MESA"), # 0x8BB1 + #("", X, 1, "GL_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA"), # 0x8BB2 + #("", X, 1, "GL_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA"), # 0x8BB3 + #("", X, 1, "GL_VERTEX_PROGRAM_CALLBACK_MESA"), # 0x8BB4 + #("", X, 1, "GL_VERTEX_PROGRAM_POSITION_MESA"), # 0x8BB4 + #("", X, 1, "GL_VERTEX_PROGRAM_CALLBACK_FUNC_MESA"), # 0x8BB6 + #("", X, 1, "GL_VERTEX_PROGRAM_CALLBACK_DATA_MESA"), # 0x8BB7 ("", X, 1, "GL_COUNTER_TYPE_AMD"), # 0x8BC0 ("", X, 1, "GL_COUNTER_RANGE_AMD"), # 0x8BC1 ("", X, 1, "GL_UNSIGNED_INT64_AMD"), # 0x8BC2 @@ -2241,6 +2271,28 @@ parameters = [ ("", X, 1, "GL_PERFMON_RESULT_AVAILABLE_AMD"), # 0x8BC4 ("", X, 1, "GL_PERFMON_RESULT_SIZE_AMD"), # 0x8BC5 ("", X, 1, "GL_PERFMON_RESULT_AMD"), # 0x8BC6 + #("", X, 1, "GL_TEXTURE_WIDTH_QCOM"), # 0x8BD2 + #("", X, 1, "GL_TEXTURE_HEIGHT_QCOM"), # 0x8BD3 + #("", X, 1, "GL_TEXTURE_DEPTH_QCOM"), # 0x8BD4 + #("", X, 1, "GL_TEXTURE_INTERNAL_FORMAT_QCOM"), # 0x8BD5 + #("", X, 1, "GL_TEXTURE_FORMAT_QCOM"), # 0x8BD6 + #("", X, 1, "GL_TEXTURE_TYPE_QCOM"), # 0x8BD7 + #("", X, 1, "GL_TEXTURE_IMAGE_VALID_QCOM"), # 0x8BD8 + #("", X, 1, "GL_TEXTURE_NUM_LEVELS_QCOM"), # 0x8BD9 + #("", X, 1, "GL_TEXTURE_TARGET_QCOM"), # 0x8BDA + #("", X, 1, "GL_TEXTURE_OBJECT_VALID_QCOM"), # 0x8BDB + #("", X, 1, "GL_STATE_RESTORE"), # 0x8BDC + #("", X, 1, "GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG"), # 0x8C00 + #("", X, 1, "GL_COMPRESSED_RGB_PVRTC_2BPPV1_IMG"), # 0x8C01 + #("", X, 1, "GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG"), # 0x8C02 + #("", X, 1, "GL_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG"), # 0x8C03 + #("", X, 1, "GL_MODULATE_COLOR_IMG"), # 0x8C04 + #("", X, 1, "GL_RECIP_ADD_SIGNED_ALPHA_IMG"), # 0x8C05 + #("", X, 1, "GL_TEXTURE_ALPHA_MODULATE_IMG"), # 0x8C06 + #("", X, 1, "GL_FACTOR_ALPHA_MODULATE_IMG"), # 0x8C07 + #("", X, 1, "GL_FRAGMENT_ALPHA_MODULATE_IMG"), # 0x8C08 + #("", X, 1, "GL_ADD_BLEND_IMG"), # 0x8C09 + #("", X, 1, "GL_SGX_BINARY_IMG"), # 0x8C0A ("", X, 1, "GL_TEXTURE_RED_TYPE"), # 0x8C10 ("", X, 1, "GL_TEXTURE_GREEN_TYPE"), # 0x8C11 ("", X, 1, "GL_TEXTURE_BLUE_TYPE"), # 0x8C12 @@ -2321,6 +2373,8 @@ parameters = [ ("", X, 1, "GL_SEPARATE_ATTRIBS"), # 0x8C8D ("", X, 1, "GL_TRANSFORM_FEEDBACK_BUFFER"), # 0x8C8E ("glGet", I, 1, "GL_TRANSFORM_FEEDBACK_BUFFER_BINDING"), # 0x8C8F + #("", X, 1, "GL_ATC_RGB_AMD"), # 0x8C92 + #("", X, 1, "GL_ATC_RGBA_EXPLICIT_ALPHA_AMD"), # 0x8C93 ("glGet", E, 1, "GL_POINT_SPRITE_COORD_ORIGIN"), # 0x8CA0 ("", X, 1, "GL_LOWER_LEFT"), # 0x8CA1 ("", X, 1, "GL_UPPER_LEFT"), # 0x8CA2 @@ -2384,6 +2438,14 @@ parameters = [ ("glGetRenderbufferParameter", I, 1, "GL_RENDERBUFFER_STENCIL_SIZE"), # 0x8D55 ("", X, 1, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE"), # 0x8D56 ("glGet", I, 1, "GL_MAX_SAMPLES"), # 0x8D57 + #("", X, 1, "GL_TEXTURE_GEN_STR_OES"), # 0x8D60 + #("", X, 1, "GL_HALF_FLOAT_OES"), # 0x8D61 + #("", X, 1, "GL_RGB565_OES"), # 0x8D62 + #("", X, 1, "GL_ETC1_RGB8_OES"), # 0x8D64 + #("", X, 1, "GL_TEXTURE_EXTERNAL_OES"), # 0x8D65 + #("", X, 1, "GL_SAMPLER_EXTERNAL_OES"), # 0x8D66 + #("", X, 1, "GL_TEXTURE_BINDING_EXTERNAL_OES"), # 0x8D67 + #("", X, 1, "GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES"), # 0x8D68 ("", X, 1, "GL_RGBA32UI"), # 0x8D70 ("", X, 1, "GL_RGB32UI"), # 0x8D71 ("", X, 1, "GL_ALPHA32UI_EXT"), # 0x8D72 @@ -2595,6 +2657,14 @@ parameters = [ ("", X, 1, "GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB"), # 0x8E8D ("", X, 1, "GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB"), # 0x8E8E ("", X, 1, "GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB"), # 0x8E8F + #("", X, 1, "GL_COVERAGE_COMPONENT_NV"), # 0x8ED0 + #("", X, 1, "GL_COVERAGE_COMPONENT4_NV"), # 0x8ED1 + #("", X, 1, "GL_COVERAGE_ATTACHMENT_NV"), # 0x8ED2 + #("", X, 1, "GL_COVERAGE_BUFFERS_NV"), # 0x8ED3 + #("", X, 1, "GL_COVERAGE_SAMPLES_NV"), # 0x8ED4 + #("", X, 1, "GL_COVERAGE_ALL_FRAGMENTS_NV"), # 0x8ED5 + #("", X, 1, "GL_COVERAGE_EDGE_FRAGMENTS_NV"), # 0x8ED6 + #("", X, 1, "GL_COVERAGE_AUTOMATIC_NV"), # 0x8ED7 ("", X, 1, "GL_BUFFER_GPU_ADDRESS_NV"), # 0x8F1D ("", X, 1, "GL_VERTEX_ATTRIB_ARRAY_UNIFIED_NV"), # 0x8F1E ("", X, 1, "GL_ELEMENT_ARRAY_UNIFIED_NV"), # 0x8F1F @@ -2622,13 +2692,13 @@ parameters = [ ("", X, 1, "GL_MAX_SHADER_BUFFER_ADDRESS_NV"), # 0x8F35 ("", X, 1, "GL_COPY_READ_BUFFER"), # 0x8F36 ("", X, 1, "GL_COPY_WRITE_BUFFER"), # 0x8F37 - ("", X, 1, "GL_MAX_IMAGE_UNITS_EXT"), # 0x8F38 - ("", X, 1, "GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT"), # 0x8F39 - ("", X, 1, "GL_IMAGE_BINDING_NAME_EXT"), # 0x8F3A - ("", X, 1, "GL_IMAGE_BINDING_LEVEL_EXT"), # 0x8F3B - ("", X, 1, "GL_IMAGE_BINDING_LAYERED_EXT"), # 0x8F3C - ("", X, 1, "GL_IMAGE_BINDING_LAYER_EXT"), # 0x8F3D - ("", X, 1, "GL_IMAGE_BINDING_ACCESS_EXT"), # 0x8F3E + ("", X, 1, "GL_MAX_IMAGE_UNITS"), # 0x8F38 + ("", X, 1, "GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS"), # 0x8F39 + ("", X, 1, "GL_IMAGE_BINDING_NAME"), # 0x8F3A + ("", X, 1, "GL_IMAGE_BINDING_LEVEL"), # 0x8F3B + ("", X, 1, "GL_IMAGE_BINDING_LAYERED"), # 0x8F3C + ("", X, 1, "GL_IMAGE_BINDING_LAYER"), # 0x8F3D + ("", X, 1, "GL_IMAGE_BINDING_ACCESS"), # 0x8F3E ("", X, 1, "GL_DRAW_INDIRECT_BUFFER"), # 0x8F3F ("", X, 1, "GL_DRAW_INDIRECT_UNIFIED_NV"), # 0x8F40 ("", X, 1, "GL_DRAW_INDIRECT_ADDRESS_NV"), # 0x8F41 @@ -2645,6 +2715,7 @@ parameters = [ ("", X, 1, "GL_DOUBLE_MAT3x4"), # 0x8F4C ("", X, 1, "GL_DOUBLE_MAT4x2"), # 0x8F4D ("", X, 1, "GL_DOUBLE_MAT4x3"), # 0x8F4E + #("", X, 1, "GL_MALI_SHADER_BINARY_ARM"), # 0x8F60 ("", X, 1, "GL_RED_SNORM"), # 0x8F90 ("", X, 1, "GL_RG_SNORM"), # 0x8F91 ("", X, 1, "GL_RGB_SNORM"), # 0x8F92 @@ -2660,6 +2731,9 @@ parameters = [ ("", X, 1, "GL_SIGNED_NORMALIZED"), # 0x8F9C ("glGet", B, 1, "GL_PRIMITIVE_RESTART"), # 0x8F9D ("glGet", I, 1, "GL_PRIMITIVE_RESTART_INDEX"), # 0x8F9E + #("", X, 1, "GL_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS"), # 0x8F9F + #("", X, 1, "GL_PERFMON_GLOBAL_MODE_QCOM"), # 0x8FA0 + #("", X, 1, "GL_SHADER_BINARY_VIV"), # 0x8FC4 ("", X, 1, "GL_INT8_NV"), # 0x8FE0 ("", X, 1, "GL_INT8_VEC2_NV"), # 0x8FE1 ("", X, 1, "GL_INT8_VEC3_NV"), # 0x8FE2 @@ -2715,6 +2789,8 @@ parameters = [ ("", X, 1, "GL_LUMINANCE16_SNORM"), # 0x9019 ("", X, 1, "GL_LUMINANCE16_ALPHA16_SNORM"), # 0x901A ("", X, 1, "GL_INTENSITY16_SNORM"), # 0x901B + ("", X, 1, "GL_FACTOR_MIN_AMD"), # 0x901C + ("", X, 1, "GL_FACTOR_MAX_AMD"), # 0x901D ("", B, 1, "GL_DEPTH_CLAMP_NEAR_AMD"), # 0x901E ("", B, 1, "GL_DEPTH_CLAMP_FAR_AMD"), # 0x901F ("", X, 1, "GL_VIDEO_BUFFER_NV"), # 0x9020 @@ -2746,42 +2822,57 @@ parameters = [ ("", X, 1, "GL_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV"), # 0x903A ("", X, 1, "GL_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV"), # 0x903B ("", X, 1, "GL_VIDEO_CAPTURE_SURFACE_ORIGIN_NV"), # 0x903C - ("", X, 1, "GL_IMAGE_1D_EXT"), # 0x904C - ("", X, 1, "GL_IMAGE_2D_EXT"), # 0x904D - ("", X, 1, "GL_IMAGE_3D_EXT"), # 0x904E - ("", X, 1, "GL_IMAGE_2D_RECT_EXT"), # 0x904F - ("", X, 1, "GL_IMAGE_CUBE_EXT"), # 0x9050 - ("", X, 1, "GL_IMAGE_BUFFER_EXT"), # 0x9051 - ("", X, 1, "GL_IMAGE_1D_ARRAY_EXT"), # 0x9052 - ("", X, 1, "GL_IMAGE_2D_ARRAY_EXT"), # 0x9053 - ("", X, 1, "GL_IMAGE_CUBE_MAP_ARRAY_EXT"), # 0x9054 - ("", X, 1, "GL_IMAGE_2D_MULTISAMPLE_EXT"), # 0x9055 - ("", X, 1, "GL_IMAGE_2D_MULTISAMPLE_ARRAY_EXT"), # 0x9056 - ("", X, 1, "GL_INT_IMAGE_1D_EXT"), # 0x9057 - ("", X, 1, "GL_INT_IMAGE_2D_EXT"), # 0x9058 - ("", X, 1, "GL_INT_IMAGE_3D_EXT"), # 0x9059 - ("", X, 1, "GL_INT_IMAGE_2D_RECT_EXT"), # 0x905A - ("", X, 1, "GL_INT_IMAGE_CUBE_EXT"), # 0x905B - ("", X, 1, "GL_INT_IMAGE_BUFFER_EXT"), # 0x905C - ("", X, 1, "GL_INT_IMAGE_1D_ARRAY_EXT"), # 0x905D - ("", X, 1, "GL_INT_IMAGE_2D_ARRAY_EXT"), # 0x905E - ("", X, 1, "GL_INT_IMAGE_CUBE_MAP_ARRAY_EXT"), # 0x905F - ("", X, 1, "GL_INT_IMAGE_2D_MULTISAMPLE_EXT"), # 0x9060 - ("", X, 1, "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT"), # 0x9061 - ("", X, 1, "GL_UNSIGNED_INT_IMAGE_1D_EXT"), # 0x9062 - ("", X, 1, "GL_UNSIGNED_INT_IMAGE_2D_EXT"), # 0x9063 - ("", X, 1, "GL_UNSIGNED_INT_IMAGE_3D_EXT"), # 0x9064 - ("", X, 1, "GL_UNSIGNED_INT_IMAGE_2D_RECT_EXT"), # 0x9065 - ("", X, 1, "GL_UNSIGNED_INT_IMAGE_CUBE_EXT"), # 0x9066 - ("", X, 1, "GL_UNSIGNED_INT_IMAGE_BUFFER_EXT"), # 0x9067 - ("", X, 1, "GL_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT"), # 0x9068 - ("", X, 1, "GL_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT"), # 0x9069 - ("", X, 1, "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT"), # 0x906A - ("", X, 1, "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT"), # 0x906B - ("", X, 1, "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT"), # 0x906C - ("", X, 1, "GL_MAX_IMAGE_SAMPLES_EXT"), # 0x906D - ("", X, 1, "GL_IMAGE_BINDING_FORMAT_EXT"), # 0x906E + ("", X, 1, "GL_TEXTURE_COVERAGE_SAMPLES_NV"), # 0x9045 + ("", X, 1, "GL_TEXTURE_COLOR_SAMPLES_NV"), # 0x9046 + ("", X, 1, "GL_IMAGE_1D"), # 0x904C + ("", X, 1, "GL_IMAGE_2D"), # 0x904D + ("", X, 1, "GL_IMAGE_3D"), # 0x904E + ("", X, 1, "GL_IMAGE_2D_RECT"), # 0x904F + ("", X, 1, "GL_IMAGE_CUBE"), # 0x9050 + ("", X, 1, "GL_IMAGE_BUFFER"), # 0x9051 + ("", X, 1, "GL_IMAGE_1D_ARRAY"), # 0x9052 + ("", X, 1, "GL_IMAGE_2D_ARRAY"), # 0x9053 + ("", X, 1, "GL_IMAGE_CUBE_MAP_ARRAY"), # 0x9054 + ("", X, 1, "GL_IMAGE_2D_MULTISAMPLE"), # 0x9055 + ("", X, 1, "GL_IMAGE_2D_MULTISAMPLE_ARRAY"), # 0x9056 + ("", X, 1, "GL_INT_IMAGE_1D"), # 0x9057 + ("", X, 1, "GL_INT_IMAGE_2D"), # 0x9058 + ("", X, 1, "GL_INT_IMAGE_3D"), # 0x9059 + ("", X, 1, "GL_INT_IMAGE_2D_RECT"), # 0x905A + ("", X, 1, "GL_INT_IMAGE_CUBE"), # 0x905B + ("", X, 1, "GL_INT_IMAGE_BUFFER"), # 0x905C + ("", X, 1, "GL_INT_IMAGE_1D_ARRAY"), # 0x905D + ("", X, 1, "GL_INT_IMAGE_2D_ARRAY"), # 0x905E + ("", X, 1, "GL_INT_IMAGE_CUBE_MAP_ARRAY"), # 0x905F + ("", X, 1, "GL_INT_IMAGE_2D_MULTISAMPLE"), # 0x9060 + ("", X, 1, "GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY"), # 0x9061 + ("", X, 1, "GL_UNSIGNED_INT_IMAGE_1D"), # 0x9062 + ("", X, 1, "GL_UNSIGNED_INT_IMAGE_2D"), # 0x9063 + ("", X, 1, "GL_UNSIGNED_INT_IMAGE_3D"), # 0x9064 + ("", X, 1, "GL_UNSIGNED_INT_IMAGE_2D_RECT"), # 0x9065 + ("", X, 1, "GL_UNSIGNED_INT_IMAGE_CUBE"), # 0x9066 + ("", X, 1, "GL_UNSIGNED_INT_IMAGE_BUFFER"), # 0x9067 + ("", X, 1, "GL_UNSIGNED_INT_IMAGE_1D_ARRAY"), # 0x9068 + ("", X, 1, "GL_UNSIGNED_INT_IMAGE_2D_ARRAY"), # 0x9069 + ("", X, 1, "GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY"), # 0x906A + ("", X, 1, "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE"), # 0x906B + ("", X, 1, "GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY"), # 0x906C + ("", X, 1, "GL_MAX_IMAGE_SAMPLES"), # 0x906D + ("", X, 1, "GL_IMAGE_BINDING_FORMAT"), # 0x906E ("", X, 1, "GL_RGB10_A2UI"), # 0x906F + ("", X, 1, "GL_SCALED_RESOLVE_FASTEST_EXT"), # 0x90BA + ("", X, 1, "GL_SCALED_RESOLVE_NICEST_EXT"), # 0x90BB + ("", X, 1, "GL_MIN_MAP_BUFFER_ALIGNMENT"), # 0x90BC + ("", X, 1, "GL_IMAGE_FORMAT_COMPATIBILITY_TYPE"), # 0x90C7 + ("", X, 1, "GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE"), # 0x90C8 + ("", X, 1, "GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS"), # 0x90C9 + ("", X, 1, "GL_MAX_VERTEX_IMAGE_UNIFORMS"), # 0x90CA + ("", X, 1, "GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS"), # 0x90CB + ("", X, 1, "GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS"), # 0x90CC + ("", X, 1, "GL_MAX_GEOMETRY_IMAGE_UNIFORMS"), # 0x90CD + ("", X, 1, "GL_MAX_FRAGMENT_IMAGE_UNIFORMS"), # 0x90CE + ("", X, 1, "GL_MAX_COMBINED_IMAGE_UNIFORMS"), # 0x90CF + ("", X, 1, "GL_SYNC_X11_FENCE_EXT"), # 0x90E1 ("", X, 1, "GL_TEXTURE_2D_MULTISAMPLE"), # 0x9100 ("", X, 1, "GL_PROXY_TEXTURE_2D_MULTISAMPLE"), # 0x9101 ("", X, 1, "GL_TEXTURE_2D_MULTISAMPLE_ARRAY"), # 0x9102 @@ -2820,6 +2911,20 @@ parameters = [ ("", X, 1, "GL_MAX_GEOMETRY_OUTPUT_COMPONENTS"), # 0x9124 ("", X, 1, "GL_MAX_FRAGMENT_INPUT_COMPONENTS"), # 0x9125 ("glGet", I, 1, "GL_CONTEXT_PROFILE_MASK"), # 0x9126 + ("", X, 1, "GL_UNPACK_COMPRESSED_BLOCK_WIDTH"), # 0x9127 + ("", X, 1, "GL_UNPACK_COMPRESSED_BLOCK_HEIGHT"), # 0x9128 + ("", X, 1, "GL_UNPACK_COMPRESSED_BLOCK_DEPTH"), # 0x9129 + ("", X, 1, "GL_UNPACK_COMPRESSED_BLOCK_SIZE"), # 0x912A + ("", X, 1, "GL_PACK_COMPRESSED_BLOCK_WIDTH"), # 0x912B + ("", X, 1, "GL_PACK_COMPRESSED_BLOCK_HEIGHT"), # 0x912C + ("", X, 1, "GL_PACK_COMPRESSED_BLOCK_DEPTH"), # 0x912D + ("", X, 1, "GL_PACK_COMPRESSED_BLOCK_SIZE"), # 0x912E + ("", X, 1, "GL_TEXTURE_IMMUTABLE_FORMAT"), # 0x912F + #("", X, 1, "GL_SGX_PROGRAM_BINARY_IMG"), # 0x9130 + #("", X, 1, "GL_RENDERBUFFER_SAMPLES_IMG"), # 0x9133 + #("", X, 1, "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG"), # 0x9134 + #("", X, 1, "GL_MAX_SAMPLES_IMG"), # 0x9135 + #("", X, 1, "GL_TEXTURE_SAMPLES_IMG"), # 0x9136 ("", X, 1, "GL_MAX_DEBUG_MESSAGE_LENGTH_ARB"), # 0x9143 ("", X, 1, "GL_MAX_DEBUG_LOGGED_MESSAGES_ARB"), # 0x9144 ("", X, 1, "GL_DEBUG_LOGGED_MESSAGES_ARB"), # 0x9145 @@ -2839,6 +2944,37 @@ parameters = [ ("", X, 1, "GL_QUERY_OBJECT_AMD"), # 0x9153 ("", X, 1, "GL_VERTEX_ARRAY_OBJECT_AMD"), # 0x9154 ("", X, 1, "GL_SAMPLER_OBJECT_AMD"), # 0x9155 + #("", X, 1, "GL_SHADER_BINARY_DMP"), # 0x9250 + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER"), # 0x92C0 + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER_BINDING"), # 0x92C1 + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER_START"), # 0x92C2 + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER_SIZE"), # 0x92C3 + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE"), # 0x92C4 + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS"), # 0x92C5 + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES"), # 0x92C6 + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER"), # 0x92C7 + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER"), # 0x92C8 + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER"), # 0x92C9 + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER"), # 0x92CA + ("", X, 1, "GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER"), # 0x92CB + ("", X, 1, "GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS"), # 0x92CC + ("", X, 1, "GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS"), # 0x92CD + ("", X, 1, "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS"), # 0x92CE + ("", X, 1, "GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS"), # 0x92CF + ("", X, 1, "GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS"), # 0x92D0 + ("", X, 1, "GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS"), # 0x92D1 + ("", X, 1, "GL_MAX_VERTEX_ATOMIC_COUNTERS"), # 0x92D2 + ("", X, 1, "GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS"), # 0x92D3 + ("", X, 1, "GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS"), # 0x92D4 + ("", X, 1, "GL_MAX_GEOMETRY_ATOMIC_COUNTERS"), # 0x92D5 + ("", X, 1, "GL_MAX_FRAGMENT_ATOMIC_COUNTERS"), # 0x92D6 + ("", X, 1, "GL_MAX_COMBINED_ATOMIC_COUNTERS"), # 0x92D7 + ("", X, 1, "GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE"), # 0x92D8 + ("", X, 1, "GL_ACTIVE_ATOMIC_COUNTER_BUFFERS"), # 0x92D9 + ("", X, 1, "GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX"), # 0x92DA + ("", X, 1, "GL_UNSIGNED_INT_ATOMIC_COUNTER"), # 0x92DB + ("", X, 1, "GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS"), # 0x92DC + ("", X, 1, "GL_NUM_SAMPLE_COUNTS"), # 0x9380 ("", X, 1, "GL_INVALID_INDEX"), # 0xFFFFFFFFu ] diff --git a/glretrace.hpp b/glretrace.hpp index 255dd6f..5b93f2d 100644 --- a/glretrace.hpp +++ b/glretrace.hpp @@ -69,6 +69,7 @@ void retrace_call_wgl(Trace::Call &call); void snapshot(unsigned call_no); void frame_complete(unsigned call_no); +void updateDrawable(int width, int height); } /* namespace glretrace */ diff --git a/glretrace.py b/glretrace.py index b6dac92..356659a 100644 --- a/glretrace.py +++ b/glretrace.py @@ -99,6 +99,11 @@ class GlRetracer(Retracer): "glMultiModeDrawElementsIBM", ]) + draw_indirect_function_names = set([ + "glDrawArraysIndirect", + "glDrawElementsIndirect", + ]) + misc_draw_function_names = set([ "glClear", "glEnd", @@ -202,23 +207,13 @@ class GlRetracer(Retracer): def call_function(self, function): + # Infer the drawable size from GL calls if function.name == "glViewport": - print ' GLint draw_framebuffer = 0;' - print ' glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &draw_framebuffer);' - print ' if (draw_framebuffer == 0) {' - print ' if (glretrace::drawable) {' - print ' int drawable_width = x + width;' - print ' int drawable_height = y + height;' - print ' if (drawable_width > (int)glretrace::drawable->width ||' - print ' drawable_height > (int)glretrace::drawable->height) {' - print ' glretrace::drawable->resize(drawable_width, drawable_height);' - print ' if (!glretrace::drawable->visible) {' - print ' glretrace::drawable->show();' - print ' }' - print ' glScissor(0, 0, drawable_width, drawable_height);' - print ' }' - print ' }' - print ' }' + print ' glretrace::updateDrawable(x + width, y + height);' + if function.name in ('glBlitFramebuffer', 'glBlitFramebufferEXT'): + # Some applications do all their rendering in a framebuffer, and + # then just blit to the drawable without ever calling glViewport. + print ' glretrace::updateDrawable(std::max(dstX0, dstX1), std::max(dstY0, dstY1));' if function.name == "glEnd": print ' glretrace::insideGlBeginEnd = false;' @@ -293,13 +288,13 @@ class GlRetracer(Retracer): if function.name in ('glGetAttribLocation', 'glGetAttribLocationARB'): print r' GLint __orig_result = call.ret->toSInt();' print r' if (__result != __orig_result) {' - print r' std::cerr << call.no << ": warning vertex attrib location mismatch " << __orig_result << " -> " << __result << "\n";' + print r' std::cerr << call.no << ": warning: vertex attrib location mismatch " << __orig_result << " -> " << __result << "\n";' print r' }' if function.name in ('glCheckFramebufferStatus', 'glCheckFramebufferStatusEXT', 'glCheckNamedFramebufferStatusEXT'): print r' GLint __orig_result = call.ret->toSInt();' print r' if (__orig_result == GL_FRAMEBUFFER_COMPLETE &&' print r' __result != GL_FRAMEBUFFER_COMPLETE) {' - print r' std::cerr << call.no << ": incomplete framebuffer (" << __result << ")\n";' + print r' std::cerr << call.no << ": warning: incomplete framebuffer (" << glstate::enumToString(__result) << ")\n";' print r' }' print ' }' @@ -308,7 +303,8 @@ class GlRetracer(Retracer): print ' %s = static_cast<%s>(%s.toPointer(true));' % (lvalue, arg_type, rvalue) return - if function.name in self.draw_elements_function_names and arg.name == 'indices': + if function.name in self.draw_elements_function_names and arg.name == 'indices' or\ + function.name in self.draw_indirect_function_names and arg.name == 'indirect': self.extract_opaque_arg(function, arg, arg_type, lvalue, rvalue) return @@ -345,6 +341,7 @@ if __name__ == '__main__': #include "glproc.hpp" #include "glretrace.hpp" +#include "glstate.hpp" ''' diff --git a/glretrace_main.cpp b/glretrace_main.cpp index 3a90092..cd35889 100644 --- a/glretrace_main.cpp +++ b/glretrace_main.cpp @@ -103,6 +103,37 @@ checkGlError(Trace::Call &call) { std::cerr << "\n"; } +/** + * Grow the current drawble. + * + * We need to infer the drawable size from GL calls because the drawable sizes + * are specified by OS specific calls which we do not trace. + */ +void +updateDrawable(int width, int height) { + if (!drawable) { + return; + } + + if (width <= glretrace::drawable->width && + height <= glretrace::drawable->height) { + return; + } + + // Check for bound framebuffer last, as this may have a performance impact. + GLint draw_framebuffer = 0; + glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &draw_framebuffer); + if (draw_framebuffer != 0) { + return; + } + + glretrace::drawable->resize(width, height); + if (!drawable->visible) { + drawable->show(); + } + glScissor(0, 0, width, height); +} + void snapshot(unsigned call_no) { if (!drawable || diff --git a/glsize.hpp b/glsize.hpp index a58b41e..257d599 100644 --- a/glsize.hpp +++ b/glsize.hpp @@ -610,14 +610,18 @@ __gl_format_channels(GLenum format) { case GL_DEPTH_STENCIL: case GL_LUMINANCE_ALPHA: case GL_RG: + case GL_HILO_NV: + case GL_DSDT_NV: return 2; case GL_RGB: case GL_BGR: + case GL_DSDT_MAG_NV: return 3; case GL_RGBA: case GL_BGRA: case GL_ABGR_EXT: case GL_CMYK_EXT: + case GL_DSDT_MAG_VIB_NV: return 4; case GL_CMYKA_EXT: return 5; diff --git a/gltypes.py b/gltypes.py index 32a6ca8..e25cd7e 100644 --- a/gltypes.py +++ b/gltypes.py @@ -82,6 +82,7 @@ GLregion = Handle("region", GLuint) GLmap = Handle("map", OpaquePointer(GLvoid)) GLpipeline = Handle("pipeline", GLuint) GLsampler = Handle("sampler", GLuint) +GLfeedback = Handle("feedback", GLuint) GLsync_ = Opaque("GLsync") GLsync = Handle("sync", GLsync_) @@ -182,3 +183,21 @@ GLbitfield_access = Flags(GLbitfield, [ GLbitfield_sync_flush = Flags(GLbitfield, [ "GL_SYNC_FLUSH_COMMANDS_BIT", # 0x00000001 ]) + +GLbitfield_barrier = Flags(GLbitfield, [ + "GL_ALL_BARRIER_BITS", # 0xFFFFFFFF + "GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT", # 0x00000001 + "GL_ELEMENT_ARRAY_BARRIER_BIT", # 0x00000002 + "GL_UNIFORM_BARRIER_BIT", # 0x00000004 + "GL_TEXTURE_FETCH_BARRIER_BIT", # 0x00000008 + "GL_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV", # 0x00000010 + "GL_SHADER_IMAGE_ACCESS_BARRIER_BIT", # 0x00000020 + "GL_COMMAND_BARRIER_BIT", # 0x00000040 + "GL_PIXEL_BUFFER_BARRIER_BIT", # 0x00000080 + "GL_TEXTURE_UPDATE_BARRIER_BIT", # 0x00000100 + "GL_BUFFER_UPDATE_BARRIER_BIT", # 0x00000200 + "GL_FRAMEBUFFER_BARRIER_BIT", # 0x00000400 + "GL_TRANSFORM_FEEDBACK_BARRIER_BIT", # 0x00000800 + "GL_ATOMIC_COUNTER_BARRIER_BIT", # 0x00001000 +]) + diff --git a/glxapi.py b/glxapi.py index 7c389b6..4a35ce1 100644 --- a/glxapi.py +++ b/glxapi.py @@ -433,6 +433,10 @@ glxapi.add_functions([ # GLX_NV_copy_image Function(Void, "glXCopyImageSubDataNV", [(Display, "dpy"), (GLXContext, "srcCtx"), (GLuint, "srcName"), (GLenum, "srcTarget"), (GLint, "srcLevel"), (GLint, "srcX"), (GLint, "srcY"), (GLint, "srcZ"), (GLXContext, "dstCtx"), (GLuint, "dstName"), (GLenum, "dstTarget"), (GLint, "dstLevel"), (GLint, "dstX"), (GLint, "dstY"), (GLint, "dstZ"), (GLsizei, "width"), (GLsizei, "height"), (GLsizei, "depth")]), + # GLX_NV_vertex_array_range + Function(OpaquePointer(Void), "glXAllocateMemoryNV", [(GLsizei, "size"), (GLfloat, "readfreq"), (GLfloat, "writefreq"), (GLfloat, "priority")]), + Function(Void, "glXFreeMemoryNV", [(OpaquePointer(Void), "pointer")]), + # Must be last Function(PROC, "glXGetProcAddressARB", [(Alias("const GLubyte *", CString), "procName")]), Function(PROC, "glXGetProcAddress", [(Alias("const GLubyte *", CString), "procName")]), diff --git a/gui/loaderthread.cpp b/gui/loaderthread.cpp index 03f0ccd..10a787b 100644 --- a/gui/loaderthread.cpp +++ b/gui/loaderthread.cpp @@ -91,14 +91,9 @@ void LoaderThread::run() call = p.parse_call(); } } - //last frames won't have markers - // it's just a bunch of Delete calls for every object - // after the last SwapBuffers if (currentFrame) { - if (!frames.count()) { - calls.squeeze(); - currentFrame->setCalls(calls, binaryDataSize); - } + calls.squeeze(); + currentFrame->setCalls(calls, binaryDataSize); frames.append(currentFrame); currentFrame = 0; } diff --git a/os_posix.cpp b/os_posix.cpp index 991ad0e..98a790b 100644 --- a/os_posix.cpp +++ b/os_posix.cpp @@ -145,6 +145,12 @@ static void (*gCallback)(void) = NULL; struct sigaction old_actions[NUM_SIGNALS]; + +/* + * See also: + * - http://sourceware.org/git/?p=glibc.git;a=blob;f=debug/segfault.c + * - http://ggi.cvs.sourceforge.net/viewvc/ggi/ggi-core/libgg/gg/cleanup.c?view=markup + */ static void signal_handler(int sig, siginfo_t *info, void *context) { static int recursion_count = 0; diff --git a/thirdparty/glext/glext.h b/thirdparty/glext/glext.h index 555e670..0940021 100644 --- a/thirdparty/glext/glext.h +++ b/thirdparty/glext/glext.h @@ -6,7 +6,7 @@ extern "C" { #endif /* -** Copyright (c) 2007-2010 The Khronos Group Inc. +** Copyright (c) 2007-2011 The Khronos Group Inc. ** ** Permission is hereby granted, free of charge, to any person obtaining a ** copy of this software and/or associated documentation files (the @@ -29,9 +29,9 @@ extern "C" { */ /* Header file version number, required by OpenGL ABI for Linux */ -/* glext.h last updated $Date: 2011-06-06 12:06:38 -0700 (Mon, 06 Jun 2011) $ */ +/* glext.h last updated $Date: 2011-08-08 00:34:29 -0700 (Mon, 08 Aug 2011) $ */ /* Current version at http://www.opengl.org/registry/ */ -#define GL_GLEXT_VERSION 70 +#define GL_GLEXT_VERSION 72 /* Function declaration macros - to move into glplatform.h */ #if defined(_WIN32) && !defined(APIENTRY) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) @@ -1047,6 +1047,124 @@ extern "C" { /* reuse GL_UNDEFINED_VERTEX */ #endif +#ifndef GL_VERSION_4_2 +/* Reuse tokens from ARB_base_instance (none) */ +/* Reuse tokens from ARB_shading_language_420pack (none) */ +/* Reuse tokens from ARB_transform_feedback_instanced (none) */ +/* Reuse tokens from ARB_compressed_texture_pixel_storage */ +/* reuse GL_UNPACK_COMPRESSED_BLOCK_WIDTH */ +/* reuse GL_UNPACK_COMPRESSED_BLOCK_HEIGHT */ +/* reuse GL_UNPACK_COMPRESSED_BLOCK_DEPTH */ +/* reuse GL_UNPACK_COMPRESSED_BLOCK_SIZE */ +/* reuse GL_PACK_COMPRESSED_BLOCK_WIDTH */ +/* reuse GL_PACK_COMPRESSED_BLOCK_HEIGHT */ +/* reuse GL_PACK_COMPRESSED_BLOCK_DEPTH */ +/* reuse GL_PACK_COMPRESSED_BLOCK_SIZE */ +/* Reuse tokens from ARB_conservative_depth (none) */ +/* Reuse tokens from ARB_internalformat_query */ +/* reuse GL_NUM_SAMPLE_COUNTS */ +/* Reuse tokens from ARB_map_buffer_alignment */ +/* reuse GL_MIN_MAP_BUFFER_ALIGNMENT */ +/* Reuse tokens from ARB_shader_atomic_counters */ +/* reuse GL_ATOMIC_COUNTER_BUFFER */ +/* reuse GL_ATOMIC_COUNTER_BUFFER_BINDING */ +/* reuse GL_ATOMIC_COUNTER_BUFFER_START */ +/* reuse GL_ATOMIC_COUNTER_BUFFER_SIZE */ +/* reuse GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE */ +/* reuse GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS */ +/* reuse GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES */ +/* reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER */ +/* reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER */ +/* reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER */ +/* reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER */ +/* reuse GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER */ +/* reuse GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS */ +/* reuse GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS */ +/* reuse GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS */ +/* reuse GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS */ +/* reuse GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS */ +/* reuse GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS */ +/* reuse GL_MAX_VERTEX_ATOMIC_COUNTERS */ +/* reuse GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS */ +/* reuse GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS */ +/* reuse GL_MAX_GEOMETRY_ATOMIC_COUNTERS */ +/* reuse GL_MAX_FRAGMENT_ATOMIC_COUNTERS */ +/* reuse GL_MAX_COMBINED_ATOMIC_COUNTERS */ +/* reuse GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE */ +/* reuse GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS */ +/* reuse GL_ACTIVE_ATOMIC_COUNTER_BUFFERS */ +/* reuse GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX */ +/* reuse GL_UNSIGNED_INT_ATOMIC_COUNTER */ +/* Reuse tokens from ARB_shader_image_load_store */ +/* reuse GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT */ +/* reuse GL_ELEMENT_ARRAY_BARRIER_BIT */ +/* reuse GL_UNIFORM_BARRIER_BIT */ +/* reuse GL_TEXTURE_FETCH_BARRIER_BIT */ +/* reuse GL_SHADER_IMAGE_ACCESS_BARRIER_BIT */ +/* reuse GL_COMMAND_BARRIER_BIT */ +/* reuse GL_PIXEL_BUFFER_BARRIER_BIT */ +/* reuse GL_TEXTURE_UPDATE_BARRIER_BIT */ +/* reuse GL_BUFFER_UPDATE_BARRIER_BIT */ +/* reuse GL_FRAMEBUFFER_BARRIER_BIT */ +/* reuse GL_TRANSFORM_FEEDBACK_BARRIER_BIT */ +/* reuse GL_ATOMIC_COUNTER_BARRIER_BIT */ +/* reuse GL_ALL_BARRIER_BITS */ +/* reuse GL_MAX_IMAGE_UNITS */ +/* reuse GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS */ +/* reuse GL_IMAGE_BINDING_NAME */ +/* reuse GL_IMAGE_BINDING_LEVEL */ +/* reuse GL_IMAGE_BINDING_LAYERED */ +/* reuse GL_IMAGE_BINDING_LAYER */ +/* reuse GL_IMAGE_BINDING_ACCESS */ +/* reuse GL_IMAGE_1D */ +/* reuse GL_IMAGE_2D */ +/* reuse GL_IMAGE_3D */ +/* reuse GL_IMAGE_2D_RECT */ +/* reuse GL_IMAGE_CUBE */ +/* reuse GL_IMAGE_BUFFER */ +/* reuse GL_IMAGE_1D_ARRAY */ +/* reuse GL_IMAGE_2D_ARRAY */ +/* reuse GL_IMAGE_CUBE_MAP_ARRAY */ +/* reuse GL_IMAGE_2D_MULTISAMPLE */ +/* reuse GL_IMAGE_2D_MULTISAMPLE_ARRAY */ +/* reuse GL_INT_IMAGE_1D */ +/* reuse GL_INT_IMAGE_2D */ +/* reuse GL_INT_IMAGE_3D */ +/* reuse GL_INT_IMAGE_2D_RECT */ +/* reuse GL_INT_IMAGE_CUBE */ +/* reuse GL_INT_IMAGE_BUFFER */ +/* reuse GL_INT_IMAGE_1D_ARRAY */ +/* reuse GL_INT_IMAGE_2D_ARRAY */ +/* reuse GL_INT_IMAGE_CUBE_MAP_ARRAY */ +/* reuse GL_INT_IMAGE_2D_MULTISAMPLE */ +/* reuse GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY */ +/* reuse GL_UNSIGNED_INT_IMAGE_1D */ +/* reuse GL_UNSIGNED_INT_IMAGE_2D */ +/* reuse GL_UNSIGNED_INT_IMAGE_3D */ +/* reuse GL_UNSIGNED_INT_IMAGE_2D_RECT */ +/* reuse GL_UNSIGNED_INT_IMAGE_CUBE */ +/* reuse GL_UNSIGNED_INT_IMAGE_BUFFER */ +/* reuse GL_UNSIGNED_INT_IMAGE_1D_ARRAY */ +/* reuse GL_UNSIGNED_INT_IMAGE_2D_ARRAY */ +/* reuse GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY */ +/* reuse GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE */ +/* reuse GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY */ +/* reuse GL_MAX_IMAGE_SAMPLES */ +/* reuse GL_IMAGE_BINDING_FORMAT */ +/* reuse GL_IMAGE_FORMAT_COMPATIBILITY_TYPE */ +/* reuse GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE */ +/* reuse GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS */ +/* reuse GL_MAX_VERTEX_IMAGE_UNIFORMS */ +/* reuse GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS */ +/* reuse GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS */ +/* reuse GL_MAX_GEOMETRY_IMAGE_UNIFORMS */ +/* reuse GL_MAX_FRAGMENT_IMAGE_UNIFORMS */ +/* reuse GL_MAX_COMBINED_IMAGE_UNIFORMS */ +/* Reuse tokens from ARB_shading_language_packing (none) */ +/* Reuse tokens from ARB_texture_storage */ +/* reuse GL_TEXTURE_IMMUTABLE_FORMAT */ +#endif + #ifndef GL_ARB_multitexture #define GL_TEXTURE0_ARB 0x84C0 #define GL_TEXTURE1_ARB 0x84C1 @@ -2140,6 +2258,143 @@ extern "C" { #ifndef GL_ARB_shader_stencil_export #endif +#ifndef GL_ARB_base_instance +#endif + +#ifndef GL_ARB_shading_language_420pack +#endif + +#ifndef GL_ARB_transform_feedback_instanced +#endif + +#ifndef GL_ARB_compressed_texture_pixel_storage +#define GL_UNPACK_COMPRESSED_BLOCK_WIDTH 0x9127 +#define GL_UNPACK_COMPRESSED_BLOCK_HEIGHT 0x9128 +#define GL_UNPACK_COMPRESSED_BLOCK_DEPTH 0x9129 +#define GL_UNPACK_COMPRESSED_BLOCK_SIZE 0x912A +#define GL_PACK_COMPRESSED_BLOCK_WIDTH 0x912B +#define GL_PACK_COMPRESSED_BLOCK_HEIGHT 0x912C +#define GL_PACK_COMPRESSED_BLOCK_DEPTH 0x912D +#define GL_PACK_COMPRESSED_BLOCK_SIZE 0x912E +#endif + +#ifndef GL_ARB_conservative_depth +#endif + +#ifndef GL_ARB_internalformat_query +#define GL_NUM_SAMPLE_COUNTS 0x9380 +#endif + +#ifndef GL_ARB_map_buffer_alignment +#define GL_MIN_MAP_BUFFER_ALIGNMENT 0x90BC +#endif + +#ifndef GL_ARB_shader_atomic_counters +#define GL_ATOMIC_COUNTER_BUFFER 0x92C0 +#define GL_ATOMIC_COUNTER_BUFFER_BINDING 0x92C1 +#define GL_ATOMIC_COUNTER_BUFFER_START 0x92C2 +#define GL_ATOMIC_COUNTER_BUFFER_SIZE 0x92C3 +#define GL_ATOMIC_COUNTER_BUFFER_DATA_SIZE 0x92C4 +#define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS 0x92C5 +#define GL_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES 0x92C6 +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER 0x92C7 +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER 0x92C8 +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER 0x92C9 +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER 0x92CA +#define GL_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER 0x92CB +#define GL_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS 0x92CC +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS 0x92CD +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS 0x92CE +#define GL_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS 0x92CF +#define GL_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS 0x92D0 +#define GL_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS 0x92D1 +#define GL_MAX_VERTEX_ATOMIC_COUNTERS 0x92D2 +#define GL_MAX_TESS_CONTROL_ATOMIC_COUNTERS 0x92D3 +#define GL_MAX_TESS_EVALUATION_ATOMIC_COUNTERS 0x92D4 +#define GL_MAX_GEOMETRY_ATOMIC_COUNTERS 0x92D5 +#define GL_MAX_FRAGMENT_ATOMIC_COUNTERS 0x92D6 +#define GL_MAX_COMBINED_ATOMIC_COUNTERS 0x92D7 +#define GL_MAX_ATOMIC_COUNTER_BUFFER_SIZE 0x92D8 +#define GL_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS 0x92DC +#define GL_ACTIVE_ATOMIC_COUNTER_BUFFERS 0x92D9 +#define GL_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX 0x92DA +#define GL_UNSIGNED_INT_ATOMIC_COUNTER 0x92DB +#endif + +#ifndef GL_ARB_shader_image_load_store +#define GL_VERTEX_ATTRIB_ARRAY_BARRIER_BIT 0x00000001 +#define GL_ELEMENT_ARRAY_BARRIER_BIT 0x00000002 +#define GL_UNIFORM_BARRIER_BIT 0x00000004 +#define GL_TEXTURE_FETCH_BARRIER_BIT 0x00000008 +#define GL_SHADER_IMAGE_ACCESS_BARRIER_BIT 0x00000020 +#define GL_COMMAND_BARRIER_BIT 0x00000040 +#define GL_PIXEL_BUFFER_BARRIER_BIT 0x00000080 +#define GL_TEXTURE_UPDATE_BARRIER_BIT 0x00000100 +#define GL_BUFFER_UPDATE_BARRIER_BIT 0x00000200 +#define GL_FRAMEBUFFER_BARRIER_BIT 0x00000400 +#define GL_TRANSFORM_FEEDBACK_BARRIER_BIT 0x00000800 +#define GL_ATOMIC_COUNTER_BARRIER_BIT 0x00001000 +#define GL_ALL_BARRIER_BITS 0xFFFFFFFF +#define GL_MAX_IMAGE_UNITS 0x8F38 +#define GL_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS 0x8F39 +#define GL_IMAGE_BINDING_NAME 0x8F3A +#define GL_IMAGE_BINDING_LEVEL 0x8F3B +#define GL_IMAGE_BINDING_LAYERED 0x8F3C +#define GL_IMAGE_BINDING_LAYER 0x8F3D +#define GL_IMAGE_BINDING_ACCESS 0x8F3E +#define GL_IMAGE_1D 0x904C +#define GL_IMAGE_2D 0x904D +#define GL_IMAGE_3D 0x904E +#define GL_IMAGE_2D_RECT 0x904F +#define GL_IMAGE_CUBE 0x9050 +#define GL_IMAGE_BUFFER 0x9051 +#define GL_IMAGE_1D_ARRAY 0x9052 +#define GL_IMAGE_2D_ARRAY 0x9053 +#define GL_IMAGE_CUBE_MAP_ARRAY 0x9054 +#define GL_IMAGE_2D_MULTISAMPLE 0x9055 +#define GL_IMAGE_2D_MULTISAMPLE_ARRAY 0x9056 +#define GL_INT_IMAGE_1D 0x9057 +#define GL_INT_IMAGE_2D 0x9058 +#define GL_INT_IMAGE_3D 0x9059 +#define GL_INT_IMAGE_2D_RECT 0x905A +#define GL_INT_IMAGE_CUBE 0x905B +#define GL_INT_IMAGE_BUFFER 0x905C +#define GL_INT_IMAGE_1D_ARRAY 0x905D +#define GL_INT_IMAGE_2D_ARRAY 0x905E +#define GL_INT_IMAGE_CUBE_MAP_ARRAY 0x905F +#define GL_INT_IMAGE_2D_MULTISAMPLE 0x9060 +#define GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x9061 +#define GL_UNSIGNED_INT_IMAGE_1D 0x9062 +#define GL_UNSIGNED_INT_IMAGE_2D 0x9063 +#define GL_UNSIGNED_INT_IMAGE_3D 0x9064 +#define GL_UNSIGNED_INT_IMAGE_2D_RECT 0x9065 +#define GL_UNSIGNED_INT_IMAGE_CUBE 0x9066 +#define GL_UNSIGNED_INT_IMAGE_BUFFER 0x9067 +#define GL_UNSIGNED_INT_IMAGE_1D_ARRAY 0x9068 +#define GL_UNSIGNED_INT_IMAGE_2D_ARRAY 0x9069 +#define GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY 0x906A +#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE 0x906B +#define GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY 0x906C +#define GL_MAX_IMAGE_SAMPLES 0x906D +#define GL_IMAGE_BINDING_FORMAT 0x906E +#define GL_IMAGE_FORMAT_COMPATIBILITY_TYPE 0x90C7 +#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE 0x90C8 +#define GL_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS 0x90C9 +#define GL_MAX_VERTEX_IMAGE_UNIFORMS 0x90CA +#define GL_MAX_TESS_CONTROL_IMAGE_UNIFORMS 0x90CB +#define GL_MAX_TESS_EVALUATION_IMAGE_UNIFORMS 0x90CC +#define GL_MAX_GEOMETRY_IMAGE_UNIFORMS 0x90CD +#define GL_MAX_FRAGMENT_IMAGE_UNIFORMS 0x90CE +#define GL_MAX_COMBINED_IMAGE_UNIFORMS 0x90CF +#endif + +#ifndef GL_ARB_shading_language_packing +#endif + +#ifndef GL_ARB_texture_storage +#define GL_TEXTURE_IMMUTABLE_FORMAT 0x912F +#endif + #ifndef GL_EXT_abgr #define GL_ABGR_EXT 0x8000 #endif @@ -5053,6 +5308,11 @@ extern "C" { #ifndef GL_AMD_multi_draw_indirect #endif +#ifndef GL_EXT_framebuffer_multisample_blit_scaled +#define GL_SCALED_RESOLVE_FASTEST_EXT 0x90BA +#define GL_SCALED_RESOLVE_NICEST_EXT 0x90BB +#endif + /*************************************************************/ @@ -5912,7 +6172,7 @@ typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEIPROC) (GLuint buf, GLenum srcRGB, #ifndef GL_VERSION_4_1 #define GL_VERSION_4_1 1 -/* OpenGL 4.1 also reuses entry points from these extensions: */ +/* OpenGL 4.1 reuses entry points from these extensions: */ /* ARB_ES2_compatibility */ /* ARB_get_program_binary */ /* ARB_separate_shader_objects */ @@ -5921,6 +6181,22 @@ typedef void (APIENTRYP PFNGLBLENDFUNCSEPARATEIPROC) (GLuint buf, GLenum srcRGB, /* ARB_viewport_array */ #endif +#ifndef GL_VERSION_4_2 +#define GL_VERSION_4_2 1 +/* OpenGL 4.2 reuses entry points from these extensions: */ +/* ARB_base_instance */ +/* ARB_shading_language_420pack (no entry points) */ +/* ARB_transform_feedback_instanced */ +/* ARB_compressed_texture_pixel_storage (no entry points) */ +/* ARB_conservative_depth (no entry points) */ +/* ARB_internalformat_query */ +/* ARB_map_buffer_alignment (no entry points) */ +/* ARB_shader_atomic_counters */ +/* ARB_shader_image_load_store */ +/* ARB_shading_language_packing (no entry points) */ +/* ARB_texture_storage */ +#endif + #ifndef GL_ARB_multitexture #define GL_ARB_multitexture 1 #ifdef GL_GLEXT_PROTOTYPES @@ -6846,6 +7122,10 @@ typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERFVPROC) (GLuint sampler, GLenum typedef void (APIENTRYP PFNGLGETSAMPLERPARAMETERIUIVPROC) (GLuint sampler, GLenum pname, GLuint *params); #endif +#ifndef GL_ARB_shader_bit_encoding +#define GL_ARB_shader_bit_encoding 1 +#endif + #ifndef GL_ARB_texture_rgb10_a2ui #define GL_ARB_texture_rgb10_a2ui 1 #endif @@ -7352,6 +7632,92 @@ typedef void (APIENTRYP PFNGLGETNUNIFORMDVARBPROC) (GLuint program, GLint locati #define GL_ARB_shader_stencil_export 1 #endif +#ifndef GL_ARB_base_instance +#define GL_ARB_base_instance 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDrawArraysInstancedBaseInstance (GLenum mode, GLint first, GLsizei count, GLsizei primcount, GLuint baseinstance); +GLAPI void APIENTRY glDrawElementsInstancedBaseInstance (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount, GLuint baseinstance); +GLAPI void APIENTRY glDrawElementsInstancedBaseVertexBaseInstance (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount, GLint basevertex, GLuint baseinstance); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLDRAWARRAYSINSTANCEDBASEINSTANCEPROC) (GLenum mode, GLint first, GLsizei count, GLsizei primcount, GLuint baseinstance); +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEINSTANCEPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount, GLuint baseinstance); +typedef void (APIENTRYP PFNGLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCEPROC) (GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount, GLint basevertex, GLuint baseinstance); +#endif + +#ifndef GL_ARB_shading_language_420pack +#define GL_ARB_shading_language_420pack 1 +#endif + +#ifndef GL_ARB_transform_feedback_instanced +#define GL_ARB_transform_feedback_instanced 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glDrawTransformFeedbackInstanced (GLenum mode, GLuint id, GLsizei primcount); +GLAPI void APIENTRY glDrawTransformFeedbackStreamInstanced (GLenum mode, GLuint id, GLuint stream, GLsizei primcount); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLDRAWTRANSFORMFEEDBACKINSTANCEDPROC) (GLenum mode, GLuint id, GLsizei primcount); +typedef void (APIENTRYP PFNGLDRAWTRANSFORMFEEDBACKSTREAMINSTANCEDPROC) (GLenum mode, GLuint id, GLuint stream, GLsizei primcount); +#endif + +#ifndef GL_ARB_compressed_texture_pixel_storage +#define GL_ARB_compressed_texture_pixel_storage 1 +#endif + +#ifndef GL_ARB_conservative_depth +#define GL_ARB_conservative_depth 1 +#endif + +#ifndef GL_ARB_internalformat_query +#define GL_ARB_internalformat_query 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGetInternalformativ (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLGETINTERNALFORMATIVPROC) (GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params); +#endif + +#ifndef GL_ARB_map_buffer_alignment +#define GL_ARB_map_buffer_alignment 1 +#endif + +#ifndef GL_ARB_shader_atomic_counters +#define GL_ARB_shader_atomic_counters 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glGetActiveAtomicCounterBufferiv (GLuint program, GLuint bufferIndex, GLenum pname, GLint *params); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLGETACTIVEATOMICCOUNTERBUFFERIVPROC) (GLuint program, GLuint bufferIndex, GLenum pname, GLint *params); +#endif + +#ifndef GL_ARB_shader_image_load_store +#define GL_ARB_shader_image_load_store 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glBindImageTexture (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); +GLAPI void APIENTRY glMemoryBarrier (GLbitfield barriers); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLBINDIMAGETEXTUREPROC) (GLuint unit, GLuint texture, GLint level, GLboolean layered, GLint layer, GLenum access, GLenum format); +typedef void (APIENTRYP PFNGLMEMORYBARRIERPROC) (GLbitfield barriers); +#endif + +#ifndef GL_ARB_shading_language_packing +#define GL_ARB_shading_language_packing 1 +#endif + +#ifndef GL_ARB_texture_storage +#define GL_ARB_texture_storage 1 +#ifdef GL_GLEXT_PROTOTYPES +GLAPI void APIENTRY glTexStorage1D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); +GLAPI void APIENTRY glTexStorage2D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI void APIENTRY glTexStorage3D (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); +GLAPI void APIENTRY glTextureStorage1DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); +GLAPI void APIENTRY glTextureStorage2DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +GLAPI void APIENTRY glTextureStorage3DEXT (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); +#endif /* GL_GLEXT_PROTOTYPES */ +typedef void (APIENTRYP PFNGLTEXSTORAGE1DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); +typedef void (APIENTRYP PFNGLTEXSTORAGE2DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (APIENTRYP PFNGLTEXSTORAGE3DPROC) (GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); +typedef void (APIENTRYP PFNGLTEXTURESTORAGE1DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width); +typedef void (APIENTRYP PFNGLTEXTURESTORAGE2DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height); +typedef void (APIENTRYP PFNGLTEXTURESTORAGE3DEXTPROC) (GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth); +#endif + #ifndef GL_EXT_abgr #define GL_EXT_abgr 1 #endif @@ -11110,6 +11476,10 @@ typedef void (APIENTRYP PFNGLMULTIDRAWARRAYSINDIRECTAMDPROC) (GLenum mode, const typedef void (APIENTRYP PFNGLMULTIDRAWELEMENTSINDIRECTAMDPROC) (GLenum mode, GLenum type, const GLvoid *indirect, GLsizei primcount, GLsizei stride); #endif +#ifndef GL_EXT_framebuffer_multisample_blit_scaled +#define GL_EXT_framebuffer_multisample_blit_scaled 1 +#endif + #ifdef __cplusplus }