diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,28 @@ +Copyright (c) 2009, Sven Panne +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +3. Neither the name of the author nor the names of its contributors may be + used to endorse or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE +ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE +LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/OpenGLRaw.cabal b/OpenGLRaw.cabal new file mode 100644 --- /dev/null +++ b/OpenGLRaw.cabal @@ -0,0 +1,135 @@ +name: OpenGLRaw +version: 1.0.0.0 +license: BSD3 +license-file: LICENSE +maintainer: Sven Panne +bug-reports: mailto:hopengl@haskell.org +homepage: http://www.haskell.org/HOpenGL/ +category: Graphics +synopsis: A raw binding for the OpenGL graphics system +description: + OpenGLRaw is a raw Haskell binding for the OpenGL 3.1 graphics system and + lots of OpenGL extensions. It is basically a 1:1 mapping of OpenGL's C API, + intended as a basis for a nicer interface. OpenGLRaw offers access to all + necessary functions, tokens and types plus a general facility for loading + extension entries. The module hierarchy closely mirrors the naming structure + of the OpenGL extensions, making it easy to find the right module to import. + All API entries are loaded dynamically, so no special C header files are + needed for building this package. If an API entry is not found at runtime, a + userError is thrown. + . + OpenGL is the industry's most widely used and supported 2D and 3D graphics + application programming interface (API), incorporating a broad set of + rendering, texture mapping, special effects, and other powerful visualization + functions. For more information about OpenGL and its various extensions, + please see + and . +build-type: Simple +cabal-version: >= 1.2 +extra-source-files: + include/HsOpenGLRaw.h + +flag UseNativeWindowsLibraries + description: + When compiling under Windows, use the native libraries instead of e.g. the + ones coming with Cygwin. + +flag UseGlXGetProcAddress + description: + Use glXGetProcAddress instead of dlsym on non-Windows/-Darwin platforms. + +library + exposed-modules: + Graphics.Rendering.OpenGL.Raw, + Graphics.Rendering.OpenGL.Raw.ARB, + Graphics.Rendering.OpenGL.Raw.ARB.Compatibility, + Graphics.Rendering.OpenGL.Raw.ARB.FragmentProgram, + Graphics.Rendering.OpenGL.Raw.ARB.GeometryShader4, + Graphics.Rendering.OpenGL.Raw.ARB.InstancedArrays, + Graphics.Rendering.OpenGL.Raw.ARB.MatrixPalette, + Graphics.Rendering.OpenGL.Raw.ARB.ShadowAmbient, + Graphics.Rendering.OpenGL.Raw.ARB.VertexBlend, + Graphics.Rendering.OpenGL.Raw.ARB.VertexProgram, + Graphics.Rendering.OpenGL.Raw.Core31, + Graphics.Rendering.OpenGL.Raw.EXT, + Graphics.Rendering.OpenGL.Raw.EXT.Abgr, + Graphics.Rendering.OpenGL.Raw.EXT.BindableUniform, + Graphics.Rendering.OpenGL.Raw.EXT.ClipVolumeHint, + Graphics.Rendering.OpenGL.Raw.EXT.Cmyka, + Graphics.Rendering.OpenGL.Raw.EXT.ColorSubtable, + Graphics.Rendering.OpenGL.Raw.EXT.CompiledVertexArray, + Graphics.Rendering.OpenGL.Raw.EXT.CoordinateFrame, + Graphics.Rendering.OpenGL.Raw.EXT.CullVertex, + Graphics.Rendering.OpenGL.Raw.EXT.DepthBoundsTest, + Graphics.Rendering.OpenGL.Raw.EXT.DirectStateAccess, + Graphics.Rendering.OpenGL.Raw.EXT.FogCoord, + Graphics.Rendering.OpenGL.Raw.EXT.FourTwoTwoPixels, + Graphics.Rendering.OpenGL.Raw.EXT.FragmentLighting, + Graphics.Rendering.OpenGL.Raw.EXT.FramebufferObject, + Graphics.Rendering.OpenGL.Raw.EXT.FramebufferSRGB, + Graphics.Rendering.OpenGL.Raw.EXT.GeometryShader4, + Graphics.Rendering.OpenGL.Raw.EXT.GpuProgramParameters, + Graphics.Rendering.OpenGL.Raw.EXT.IndexArrayFormats, + Graphics.Rendering.OpenGL.Raw.EXT.IndexFunc, + Graphics.Rendering.OpenGL.Raw.EXT.IndexMaterial, + Graphics.Rendering.OpenGL.Raw.EXT.LightTexture, + Graphics.Rendering.OpenGL.Raw.EXT.Multisample, + Graphics.Rendering.OpenGL.Raw.EXT.PackedFloat, + Graphics.Rendering.OpenGL.Raw.EXT.PalettedTexture, + Graphics.Rendering.OpenGL.Raw.EXT.PerturbNormal, + Graphics.Rendering.OpenGL.Raw.EXT.PixelTransform, + Graphics.Rendering.OpenGL.Raw.EXT.PointParameters, + Graphics.Rendering.OpenGL.Raw.EXT.PolygonOffset, + Graphics.Rendering.OpenGL.Raw.EXT.ProvokingVertex, + Graphics.Rendering.OpenGL.Raw.EXT.RescaleNormal, + Graphics.Rendering.OpenGL.Raw.EXT.SecondaryColor, + Graphics.Rendering.OpenGL.Raw.EXT.SeparateSpecularColor, + Graphics.Rendering.OpenGL.Raw.EXT.SharedTexturePalette, + Graphics.Rendering.OpenGL.Raw.EXT.StencilClearTag, + Graphics.Rendering.OpenGL.Raw.EXT.StencilTwoSide, + Graphics.Rendering.OpenGL.Raw.EXT.Texture, + Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionDxt1, + Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionLatc, + Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionS3tc, + Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvAdd, + Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvCombine, + Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvDot3, + Graphics.Rendering.OpenGL.Raw.EXT.TextureFilterAnisotropic, + Graphics.Rendering.OpenGL.Raw.EXT.TextureInteger, + Graphics.Rendering.OpenGL.Raw.EXT.TextureLodBias, + Graphics.Rendering.OpenGL.Raw.EXT.TextureMirrorClamp, + Graphics.Rendering.OpenGL.Raw.EXT.TextureObject, + Graphics.Rendering.OpenGL.Raw.EXT.TextureSRGB, + Graphics.Rendering.OpenGL.Raw.EXT.TextureSwizzle, + Graphics.Rendering.OpenGL.Raw.EXT.TimerQuery, + Graphics.Rendering.OpenGL.Raw.EXT.VertexArray, + Graphics.Rendering.OpenGL.Raw.EXT.VertexShader, + Graphics.Rendering.OpenGL.Raw.EXT.VertexWeighting, + Graphics.Rendering.OpenGL.Raw.GetProcAddress + other-modules: + Graphics.Rendering.OpenGL.Raw.ARB.Compatibility.Functions, + Graphics.Rendering.OpenGL.Raw.ARB.Compatibility.Tokens, + Graphics.Rendering.OpenGL.Raw.Core31.Functions, + Graphics.Rendering.OpenGL.Raw.Core31.Tokens, + Graphics.Rendering.OpenGL.Raw.Core31.Types, + Graphics.Rendering.OpenGL.Raw.Extensions + c-sources: + cbits/HsOpenGLRaw.c + hs-Source-Dirs: src + include-dirs: include + build-depends: base >= 3 && < 5 + ghc-options: -Wall -fno-warn-duplicate-exports + if os(windows) && flag(UseNativeWindowsLibraries) + cpp-options: "-DCALLCONV=stdcall" + extra-libraries: opengl32 + cc-options: "-DUSE_WGLGETPROCADDRESS" + else + cpp-options: "-DCALLCONV=ccall" + extra-libraries: GL + if os(darwin) + cc-options: "-DUSE_NSADDRESSOFSYMBOL" + else + if flag(UseGlXGetProcAddress) + cc-options: "-DUSE_GLXGETPROCADDRESS" + else + cc-options: "-DUSE_DLSYM" diff --git a/Setup.hs b/Setup.hs new file mode 100644 --- /dev/null +++ b/Setup.hs @@ -0,0 +1,2 @@ +import Distribution.Simple +main = defaultMain diff --git a/cbits/HsOpenGLRaw.c b/cbits/HsOpenGLRaw.c new file mode 100644 --- /dev/null +++ b/cbits/HsOpenGLRaw.c @@ -0,0 +1,136 @@ +/* ----------------------------------------------------------------------------- + * + * Module : C support for Graphics.Rendering.OpenGL.Raw.GetProcAddress.hs + * Copyright : (c) Sven Panne 2009 + * License : BSD-style (see the file LICENSE) + * + * Maintainer : sven.panne@aedion.de + * Stability : stable + * Portability : portable + * + * -------------------------------------------------------------------------- */ + +#if defined(USE_WGLGETPROCADDRESS) + +#define WIN32_LEAN_AND_MEAN +#include + +void* +hs_OpenGLRaw_getProcAddress(const char *name) +{ + return wglGetProcAddress((LPCSTR)name); +} + +/* -------------------------------------------------------------------------- */ +#elif defined(USE_NSADDRESSOFSYMBOL) + +#include +#include +#include + +void* +hs_OpenGLRaw_getProcAddress(const char *name) +{ + NSSymbol symbol; + + /* Prepend a '_' for the Unix C symbol mangling convention */ + char* symbolName = (char*)malloc(strlen(name) + 2); + if (!symbolName) { + return NULL; + } + symbolName[0] = '_'; + strcpy(symbolName + 1, name); + + if (!NSIsSymbolNameDefined(symbolName)) { + free(symbolName); + return NULL; + } + + symbol = NSLookupAndBindSymbol(symbolName); + free(symbolName); + if (!symbol) { + return NULL; + } + + return NSAddressOfSymbol(symbol); +} + +/* -------------------------------------------------------------------------- */ +#elif defined(USE_DLSYM) + +#include +#include + +/* Do not depend on */ +typedef unsigned char GLubyte; + +/* Do not depend on */ +typedef void (*genericFunctionPointer)(void); +typedef genericFunctionPointer (*PFNGLXGETPROCADDRESSARB)(const GLubyte *); + +static const char* gpaNames[] = { + "glXGetProcAddress", "glXGetProcAddressARB", "glXGetProcAddressEXT", + "_glXGetProcAddress", "_glXGetProcAddressARB", "_glXGetProcAddressEXT" +}; + +void* +hs_OpenGLRaw_getProcAddress(const char *name) +{ + static int firstTime = 1; + static void *handle = NULL; + static void *gpa = NULL; + + if (firstTime) { + firstTime = 0; + + /* Get a handle for our executable. */ + handle = dlopen(NULL, RTLD_LAZY); + /* If fail this early, there's not much we can do about it. */ + if (!handle) { + return NULL; + } + + { + /* Let's see if our platform supports a glXGetProcAddress() variant. */ + int numNames = (int)(sizeof(gpaNames) / sizeof(gpaNames[0])); + int i; + for (i = 0; (!gpa) && (i < numNames); ++i) { + gpa = dlsym(handle, gpaNames[i]); + } + } + } + + if (gpa) { + /* Fine, we seem to have some kind of glXGetProcAddress(), so use it. */ + return ((PFNGLXGETPROCADDRESSARB)gpa)(name); + } else if (handle) { + /* Fallback to dlsym() if we have no glXGetProcAddress(), although we then + ignore the fact that OpenGL entry points could be context dependent. */ + return dlsym(handle, name); + } else { + return NULL; + } +} + +/* -------------------------------------------------------------------------- */ +#elif defined(USE_GLXGETPROCADDRESS) + +/* Do not depend on */ +typedef unsigned char GLubyte; + +/* Do not depend on */ +typedef void (*genericFunctionPointer)(void); +extern genericFunctionPointer glXGetProcAddressARB(const GLubyte *); + +void* +hs_OpenGLRaw_getProcAddress(const char *name) +{ + return glXGetProcAddressARB((const GLubyte*)name); +} + +/* -------------------------------------------------------------------------- */ +#else + +#error "Don't know how to retrieve OpenGL extension entries" + +#endif diff --git a/include/HsOpenGLRaw.h b/include/HsOpenGLRaw.h new file mode 100644 --- /dev/null +++ b/include/HsOpenGLRaw.h @@ -0,0 +1,29 @@ +/* ----------------------------------------------------------------------------- + * + * Module : GL extension support for Graphics.Rendering.OpenGL.Raw + * Copyright : (c) Sven Panne 2009 + * License : BSD-style (see the file LICENSE) + * + * Maintainer : sven.panne@aedion.de + * Stability : stable + * Portability : portable + * + * This header should only define preprocessor macros! + * + * -------------------------------------------------------------------------- */ + +#ifndef HSOPENGLRAW_H +#define HSOPENGLRAW_H + +/* NOTE: The macro must immediately start with the foreign declaration, + otherwise the magic mangler (hack_foreign) in the Hugs build system + doesn't recognize it. */ +#define EXTENSION_ENTRY(_entry,_ty) \ +foreign import CALLCONV unsafe "dynamic" dyn_/**/_entry :: Graphics.Rendering.OpenGL.Raw.Extensions.Invoker (_ty) ; \ +_entry :: (_ty) ; \ +_entry = dyn_/**/_entry ptr_/**/_entry ; \ +ptr_/**/_entry :: FunPtr a ; \ +ptr_/**/_entry = unsafePerformIO (Graphics.Rendering.OpenGL.Raw.Extensions.getExtensionEntry extensionNameString "_entry") ; \ +{-# NOINLINE ptr_/**/_entry #-} + +#endif diff --git a/src/Graphics/Rendering/OpenGL/Raw.hs b/src/Graphics/Rendering/OpenGL/Raw.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw.hs @@ -0,0 +1,25 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- A convenience module, combining all raw OpenGL modules. +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw ( + module Graphics.Rendering.OpenGL.Raw.ARB, + module Graphics.Rendering.OpenGL.Raw.Core31, + module Graphics.Rendering.OpenGL.Raw.EXT, + module Graphics.Rendering.OpenGL.Raw.GetProcAddress +) where + +import Graphics.Rendering.OpenGL.Raw.ARB +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.EXT +import Graphics.Rendering.OpenGL.Raw.GetProcAddress diff --git a/src/Graphics/Rendering/OpenGL/Raw/ARB.hs b/src/Graphics/Rendering/OpenGL/Raw/ARB.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/ARB.hs @@ -0,0 +1,33 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.ARB +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- A convenience module, combining all raw modules containing ARB extensions. +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.ARB ( + module Graphics.Rendering.OpenGL.Raw.ARB.Compatibility, + module Graphics.Rendering.OpenGL.Raw.ARB.FragmentProgram, + module Graphics.Rendering.OpenGL.Raw.ARB.GeometryShader4, + module Graphics.Rendering.OpenGL.Raw.ARB.InstancedArrays, + module Graphics.Rendering.OpenGL.Raw.ARB.MatrixPalette, + module Graphics.Rendering.OpenGL.Raw.ARB.ShadowAmbient, + module Graphics.Rendering.OpenGL.Raw.ARB.VertexBlend, + module Graphics.Rendering.OpenGL.Raw.ARB.VertexProgram +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility +import Graphics.Rendering.OpenGL.Raw.ARB.GeometryShader4 +import Graphics.Rendering.OpenGL.Raw.ARB.InstancedArrays +import Graphics.Rendering.OpenGL.Raw.ARB.MatrixPalette +import Graphics.Rendering.OpenGL.Raw.ARB.ShadowAmbient +import Graphics.Rendering.OpenGL.Raw.ARB.VertexBlend +import Graphics.Rendering.OpenGL.Raw.ARB.VertexProgram +import Graphics.Rendering.OpenGL.Raw.ARB.FragmentProgram diff --git a/src/Graphics/Rendering/OpenGL/Raw/ARB/Compatibility.hs b/src/Graphics/Rendering/OpenGL/Raw/ARB/Compatibility.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/ARB/Compatibility.hs @@ -0,0 +1,25 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.ARB.Compatibility +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the ARB_compatibility extension not already +-- in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.ARB.Compatibility ( + -- * Functions + module Graphics.Rendering.OpenGL.Raw.ARB.Compatibility.Functions, + -- * Tokens + module Graphics.Rendering.OpenGL.Raw.ARB.Compatibility.Tokens +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility.Functions +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility.Tokens diff --git a/src/Graphics/Rendering/OpenGL/Raw/ARB/Compatibility/Functions.hs b/src/Graphics/Rendering/OpenGL/Raw/ARB/Compatibility/Functions.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/ARB/Compatibility/Functions.hs @@ -0,0 +1,793 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.ARB.Compatibility.Functions +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions from the ARB_compatibility extension, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.ARB.Compatibility.Functions ( + glAccum, + glAlphaFunc, + glAreTexturesResident, + glArrayElement, + glBegin, + glBitmap, + glCallList, + glCallLists, + glClearAccum, + glClearIndex, + glClientActiveTexture, + glClipPlane, + glColor3b, + glColor3bv, + glColor3d, + glColor3dv, + glColor3f, + glColor3fv, + glColor3i, + glColor3iv, + glColor3s, + glColor3sv, + glColor3ub, + glColor3ubv, + glColor3ui, + glColor3uiv, + glColor3us, + glColor3usv, + glColor4b, + glColor4bv, + glColor4d, + glColor4dv, + glColor4f, + glColor4fv, + glColor4i, + glColor4iv, + glColor4s, + glColor4sv, + glColor4ub, + glColor4ubv, + glColor4ui, + glColor4uiv, + glColor4us, + glColor4usv, + glColorMaterial, + glColorPointer, + glColorSubTable, + glColorTable, + glColorTableParameterfv, + glColorTableParameteriv, + glConvolutionFilter1D, + glConvolutionFilter2D, + glConvolutionParameterf, + glConvolutionParameterfv, + glConvolutionParameteri, + glConvolutionParameteriv, + glCopyColorSubTable, + glCopyColorTable, + glCopyConvolutionFilter1D, + glCopyConvolutionFilter2D, + glCopyPixels, + glDeleteLists, + glDisableClientState, + glDrawPixels, + glEdgeFlag, + glEdgeFlagPointer, + glEdgeFlagv, + glEnableClientState, + glEnd, + glEndList, + glEvalCoord1d, + glEvalCoord1dv, + glEvalCoord1f, + glEvalCoord1fv, + glEvalCoord2d, + glEvalCoord2dv, + glEvalCoord2f, + glEvalCoord2fv, + glEvalMesh1, + glEvalMesh2, + glEvalPoint1, + glEvalPoint2, + glFeedbackBuffer, + glFogCoordPointer, + glFogCoordd, + glFogCoorddv, + glFogCoordf, + glFogCoordfv, + glFogf, + glFogfv, + glFogi, + glFogiv, + glFrustum, + glGenLists, + glGetClipPlane, + glGetColorTable, + glGetColorTableParameterfv, + glGetColorTableParameteriv, + glGetConvolutionFilter, + glGetConvolutionParameterfv, + glGetConvolutionParameteriv, + glGetHistogram, + glGetHistogramParameterfv, + glGetHistogramParameteriv, + glGetLightfv, + glGetLightiv, + glGetMapdv, + glGetMapfv, + glGetMapiv, + glGetMaterialfv, + glGetMaterialiv, + glGetMinmax, + glGetMinmaxParameterfv, + glGetMinmaxParameteriv, + glGetPixelMapfv, + glGetPixelMapuiv, + glGetPixelMapusv, + glGetPolygonStipple, + glGetSeparableFilter, + glGetTexEnvfv, + glGetTexEnviv, + glGetTexGendv, + glGetTexGenfv, + glGetTexGeniv, + glHistogram, + glIndexMask, + glIndexPointer, + glIndexd, + glIndexdv, + glIndexf, + glIndexfv, + glIndexi, + glIndexiv, + glIndexs, + glIndexsv, + glIndexub, + glIndexubv, + glInitNames, + glInterleavedArrays, + glIsList, + glLightModelf, + glLightModelfv, + glLightModeli, + glLightModeliv, + glLightf, + glLightfv, + glLighti, + glLightiv, + glLineStipple, + glListBase, + glLoadIdentity, + glLoadMatrixd, + glLoadMatrixf, + glLoadName, + glLoadTransposeMatrixd, + glLoadTransposeMatrixf, + glMap1d, + glMap1f, + glMap2d, + glMap2f, + glMapGrid1d, + glMapGrid1f, + glMapGrid2d, + glMapGrid2f, + glMaterialf, + glMaterialfv, + glMateriali, + glMaterialiv, + glMatrixMode, + glMinmax, + glMultMatrixd, + glMultMatrixf, + glMultTransposeMatrixd, + glMultTransposeMatrixf, + glMultiTexCoord1d, + glMultiTexCoord1dv, + glMultiTexCoord1f, + glMultiTexCoord1fv, + glMultiTexCoord1i, + glMultiTexCoord1iv, + glMultiTexCoord1s, + glMultiTexCoord1sv, + glMultiTexCoord2d, + glMultiTexCoord2dv, + glMultiTexCoord2f, + glMultiTexCoord2fv, + glMultiTexCoord2i, + glMultiTexCoord2iv, + glMultiTexCoord2s, + glMultiTexCoord2sv, + glMultiTexCoord3d, + glMultiTexCoord3dv, + glMultiTexCoord3f, + glMultiTexCoord3fv, + glMultiTexCoord3i, + glMultiTexCoord3iv, + glMultiTexCoord3s, + glMultiTexCoord3sv, + glMultiTexCoord4d, + glMultiTexCoord4dv, + glMultiTexCoord4f, + glMultiTexCoord4fv, + glMultiTexCoord4i, + glMultiTexCoord4iv, + glMultiTexCoord4s, + glMultiTexCoord4sv, + glNewList, + glNormal3b, + glNormal3bv, + glNormal3d, + glNormal3dv, + glNormal3f, + glNormal3fv, + glNormal3i, + glNormal3iv, + glNormal3s, + glNormal3sv, + glNormalPointer, + glOrtho, + glPassThrough, + glPixelMapfv, + glPixelMapuiv, + glPixelMapusv, + glPixelTransferf, + glPixelTransferi, + glPixelZoom, + glPolygonStipple, + glPopAttrib, + glPopClientAttrib, + glPopMatrix, + glPopName, + glPrioritizeTextures, + glPushAttrib, + glPushClientAttrib, + glPushMatrix, + glPushName, + glRasterPos2d, + glRasterPos2dv, + glRasterPos2f, + glRasterPos2fv, + glRasterPos2i, + glRasterPos2iv, + glRasterPos2s, + glRasterPos2sv, + glRasterPos3d, + glRasterPos3dv, + glRasterPos3f, + glRasterPos3fv, + glRasterPos3i, + glRasterPos3iv, + glRasterPos3s, + glRasterPos3sv, + glRasterPos4d, + glRasterPos4dv, + glRasterPos4f, + glRasterPos4fv, + glRasterPos4i, + glRasterPos4iv, + glRasterPos4s, + glRasterPos4sv, + glRectd, + glRectdv, + glRectf, + glRectfv, + glRecti, + glRectiv, + glRects, + glRectsv, + glRenderMode, + glResetHistogram, + glResetMinmax, + glRotated, + glRotatef, + glSamplePass, + glScaled, + glScalef, + glSecondaryColor3b, + glSecondaryColor3bv, + glSecondaryColor3d, + glSecondaryColor3dv, + glSecondaryColor3f, + glSecondaryColor3fv, + glSecondaryColor3i, + glSecondaryColor3iv, + glSecondaryColor3s, + glSecondaryColor3sv, + glSecondaryColor3ub, + glSecondaryColor3ubv, + glSecondaryColor3ui, + glSecondaryColor3uiv, + glSecondaryColor3us, + glSecondaryColor3usv, + glSecondaryColorPointer, + glSelectBuffer, + glSeparableFilter2D, + glShadeModel, + glTexCoord1d, + glTexCoord1dv, + glTexCoord1f, + glTexCoord1fv, + glTexCoord1i, + glTexCoord1iv, + glTexCoord1s, + glTexCoord1sv, + glTexCoord2d, + glTexCoord2dv, + glTexCoord2f, + glTexCoord2fv, + glTexCoord2i, + glTexCoord2iv, + glTexCoord2s, + glTexCoord2sv, + glTexCoord3d, + glTexCoord3dv, + glTexCoord3f, + glTexCoord3fv, + glTexCoord3i, + glTexCoord3iv, + glTexCoord3s, + glTexCoord3sv, + glTexCoord4d, + glTexCoord4dv, + glTexCoord4f, + glTexCoord4fv, + glTexCoord4i, + glTexCoord4iv, + glTexCoord4s, + glTexCoord4sv, + glTexCoordPointer, + glTexEnvf, + glTexEnvfv, + glTexEnvi, + glTexEnviv, + glTexGend, + glTexGendv, + glTexGenf, + glTexGenfv, + glTexGeni, + glTexGeniv, + glTranslated, + glTranslatef, + glVertex2d, + glVertex2dv, + glVertex2f, + glVertex2fv, + glVertex2i, + glVertex2iv, + glVertex2s, + glVertex2sv, + glVertex3d, + glVertex3dv, + glVertex3f, + glVertex3fv, + glVertex3i, + glVertex3iv, + glVertex3s, + glVertex3sv, + glVertex4d, + glVertex4dv, + glVertex4f, + glVertex4fv, + glVertex4i, + glVertex4iv, + glVertex4s, + glVertex4sv, + glVertexPointer, + glWindowPos2d, + glWindowPos2dv, + glWindowPos2f, + glWindowPos2fv, + glWindowPos2i, + glWindowPos2iv, + glWindowPos2s, + glWindowPos2sv, + glWindowPos3d, + glWindowPos3dv, + glWindowPos3f, + glWindowPos3fv, + glWindowPos3i, + glWindowPos3iv, + glWindowPos3s, + glWindowPos3sv +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_ARB_compatibility" + +EXTENSION_ENTRY(glAccum,GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glAlphaFunc,GLenum -> GLclampf -> IO ()) +EXTENSION_ENTRY(glAreTexturesResident,GLsizei -> Ptr GLuint -> Ptr GLboolean -> IO GLboolean) +EXTENSION_ENTRY(glArrayElement,GLint -> IO ()) +EXTENSION_ENTRY(glBegin,GLenum -> IO ()) +EXTENSION_ENTRY(glBitmap,GLsizei -> GLsizei -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glCallList,GLuint -> IO ()) +EXTENSION_ENTRY(glCallLists,GLsizei -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glClearAccum,GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glClearIndex,GLfloat -> IO ()) +EXTENSION_ENTRY(glClientActiveTexture,GLenum -> IO ()) +EXTENSION_ENTRY(glClipPlane,GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glColor3b,GLbyte -> GLbyte -> GLbyte -> IO ()) +EXTENSION_ENTRY(glColor3bv,Ptr GLbyte -> IO ()) +EXTENSION_ENTRY(glColor3d,GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glColor3dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glColor3f,GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glColor3fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glColor3i,GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glColor3iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glColor3s,GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glColor3sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glColor3ub,GLubyte -> GLubyte -> GLubyte -> IO ()) +EXTENSION_ENTRY(glColor3ubv,Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glColor3ui,GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glColor3uiv,Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glColor3us,GLushort -> GLushort -> GLushort -> IO ()) +EXTENSION_ENTRY(glColor3usv,Ptr GLushort -> IO ()) +EXTENSION_ENTRY(glColor4b,GLbyte -> GLbyte -> GLbyte -> GLbyte -> IO ()) +EXTENSION_ENTRY(glColor4bv,Ptr GLbyte -> IO ()) +EXTENSION_ENTRY(glColor4d,GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glColor4dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glColor4f,GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glColor4fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glColor4i,GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glColor4iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glColor4s,GLshort -> GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glColor4sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glColor4ub,GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()) +EXTENSION_ENTRY(glColor4ubv,Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glColor4ui,GLuint -> GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glColor4uiv,Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glColor4us,GLushort -> GLushort -> GLushort -> GLushort -> IO ()) +EXTENSION_ENTRY(glColor4usv,Ptr GLushort -> IO ()) +EXTENSION_ENTRY(glColorMaterial,GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glColorPointer,GLint -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glColorSubTable,GLenum -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glColorTable,GLenum -> GLenum -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glColorTableParameterfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glColorTableParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glConvolutionFilter1D,GLenum -> GLenum -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glConvolutionFilter2D,GLenum -> GLenum -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glConvolutionParameterf,GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glConvolutionParameterfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glConvolutionParameteri,GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glConvolutionParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glCopyColorSubTable,GLenum -> GLsizei -> GLint -> GLint -> GLsizei -> IO ()) +EXTENSION_ENTRY(glCopyColorTable,GLenum -> GLenum -> GLint -> GLint -> GLsizei -> IO ()) +EXTENSION_ENTRY(glCopyConvolutionFilter1D,GLenum -> GLenum -> GLint -> GLint -> GLsizei -> IO ()) +EXTENSION_ENTRY(glCopyConvolutionFilter2D,GLenum -> GLenum -> GLint -> GLint -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glCopyPixels,GLint -> GLint -> GLsizei -> GLsizei -> GLenum -> IO ()) +EXTENSION_ENTRY(glDeleteLists,GLuint -> GLsizei -> IO ()) +EXTENSION_ENTRY(glDisableClientState,GLenum -> IO ()) +EXTENSION_ENTRY(glDrawPixels,GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glEdgeFlag,GLboolean -> IO ()) +EXTENSION_ENTRY(glEdgeFlagPointer,GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glEdgeFlagv,Ptr GLboolean -> IO ()) +EXTENSION_ENTRY(glEnableClientState,GLenum -> IO ()) +EXTENSION_ENTRY(glEnd,IO ()) +EXTENSION_ENTRY(glEndList,IO ()) +EXTENSION_ENTRY(glEvalCoord1d,GLdouble -> IO ()) +EXTENSION_ENTRY(glEvalCoord1dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glEvalCoord1f,GLfloat -> IO ()) +EXTENSION_ENTRY(glEvalCoord1fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glEvalCoord2d,GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glEvalCoord2dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glEvalCoord2f,GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glEvalCoord2fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glEvalMesh1,GLenum -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glEvalMesh2,GLenum -> GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glEvalPoint1,GLint -> IO ()) +EXTENSION_ENTRY(glEvalPoint2,GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glFeedbackBuffer,GLsizei -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glFogCoordPointer,GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glFogCoordd,GLdouble -> IO ()) +EXTENSION_ENTRY(glFogCoorddv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glFogCoordf,GLfloat -> IO ()) +EXTENSION_ENTRY(glFogCoordfv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glFogf,GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glFogfv,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glFogi,GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glFogiv,GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glFrustum,GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glGenLists,GLsizei -> IO GLuint) +EXTENSION_ENTRY(glGetClipPlane,GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glGetColorTable,GLenum -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetColorTableParameterfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetColorTableParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetConvolutionFilter,GLenum -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetConvolutionParameterfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetConvolutionParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetHistogram,GLenum -> GLboolean -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetHistogramParameterfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetHistogramParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetLightfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetLightiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetMapdv,GLenum -> GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glGetMapfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetMapiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetMaterialfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetMaterialiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetMinmax,GLenum -> GLboolean -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetMinmaxParameterfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetMinmaxParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetPixelMapfv,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetPixelMapuiv,GLenum -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGetPixelMapusv,GLenum -> Ptr GLushort -> IO ()) +EXTENSION_ENTRY(glGetPolygonStipple,Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glGetSeparableFilter,GLenum -> GLenum -> GLenum -> Ptr a -> Ptr a -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetTexEnvfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetTexEnviv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetTexGendv,GLenum -> GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glGetTexGenfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetTexGeniv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glHistogram,GLenum -> GLsizei -> GLenum -> GLboolean -> IO ()) +EXTENSION_ENTRY(glIndexMask,GLuint -> IO ()) +EXTENSION_ENTRY(glIndexPointer,GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glIndexd,GLdouble -> IO ()) +EXTENSION_ENTRY(glIndexdv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glIndexf,GLfloat -> IO ()) +EXTENSION_ENTRY(glIndexfv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glIndexi,GLint -> IO ()) +EXTENSION_ENTRY(glIndexiv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glIndexs,GLshort -> IO ()) +EXTENSION_ENTRY(glIndexsv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glIndexub,GLubyte -> IO ()) +EXTENSION_ENTRY(glIndexubv,Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glInitNames,IO ()) +EXTENSION_ENTRY(glInterleavedArrays,GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glIsList,GLuint -> IO GLboolean) +EXTENSION_ENTRY(glLightModelf,GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glLightModelfv,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glLightModeli,GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glLightModeliv,GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glLightf,GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glLightfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glLighti,GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glLightiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glLineStipple,GLint -> GLushort -> IO ()) +EXTENSION_ENTRY(glListBase,GLuint -> IO ()) +EXTENSION_ENTRY(glLoadIdentity,IO ()) +EXTENSION_ENTRY(glLoadMatrixd,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glLoadMatrixf,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glLoadName,GLuint -> IO ()) +EXTENSION_ENTRY(glLoadTransposeMatrixd,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glLoadTransposeMatrixf,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMap1d,GLenum -> GLdouble -> GLdouble -> GLint -> GLint -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMap1f,GLenum -> GLfloat -> GLfloat -> GLint -> GLint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMap2d,GLenum -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> GLint -> GLint -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMap2f,GLenum -> GLfloat -> GLfloat -> GLint -> GLint -> GLfloat -> GLfloat -> GLint -> GLint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMapGrid1d,GLint -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMapGrid1f,GLint -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMapGrid2d,GLint -> GLdouble -> GLdouble -> GLint -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMapGrid2f,GLint -> GLfloat -> GLfloat -> GLint -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMaterialf,GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMaterialfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMateriali,GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glMaterialiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glMatrixMode,GLenum -> IO ()) +EXTENSION_ENTRY(glMinmax,GLenum -> GLenum -> GLboolean -> IO ()) +EXTENSION_ENTRY(glMultMatrixd,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMultMatrixf,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMultTransposeMatrixd,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMultTransposeMatrixf,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord1d,GLenum -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord1dv,GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord1f,GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord1fv,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord1i,GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord1iv,GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord1s,GLenum -> GLshort -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord1sv,GLenum -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord2d,GLenum -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord2dv,GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord2f,GLenum -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord2fv,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord2i,GLenum -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord2iv,GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord2s,GLenum -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord2sv,GLenum -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord3d,GLenum -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord3dv,GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord3f,GLenum -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord3fv,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord3i,GLenum -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord3iv,GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord3s,GLenum -> GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord3sv,GLenum -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord4d,GLenum -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord4dv,GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord4f,GLenum -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord4fv,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord4i,GLenum -> GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord4iv,GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord4s,GLenum -> GLshort -> GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glMultiTexCoord4sv,GLenum -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glNewList,GLuint -> GLenum -> IO ()) +EXTENSION_ENTRY(glNormal3b,GLbyte -> GLbyte -> GLbyte -> IO ()) +EXTENSION_ENTRY(glNormal3bv,Ptr GLbyte -> IO ()) +EXTENSION_ENTRY(glNormal3d,GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glNormal3dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glNormal3f,GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glNormal3fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glNormal3i,GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glNormal3iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glNormal3s,GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glNormal3sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glNormalPointer,GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glOrtho,GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glPassThrough,GLfloat -> IO ()) +EXTENSION_ENTRY(glPixelMapfv,GLenum -> GLint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glPixelMapuiv,GLenum -> GLint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glPixelMapusv,GLenum -> GLint -> Ptr GLushort -> IO ()) +EXTENSION_ENTRY(glPixelTransferf,GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glPixelTransferi,GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glPixelZoom,GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glPolygonStipple,Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glPopAttrib,IO ()) +EXTENSION_ENTRY(glPopClientAttrib,IO ()) +EXTENSION_ENTRY(glPopMatrix,IO ()) +EXTENSION_ENTRY(glPopName,IO ()) +EXTENSION_ENTRY(glPrioritizeTextures,GLsizei -> Ptr GLuint -> Ptr GLclampf -> IO ()) +EXTENSION_ENTRY(glPushAttrib,GLbitfield -> IO ()) +EXTENSION_ENTRY(glPushClientAttrib,GLbitfield -> IO ()) +EXTENSION_ENTRY(glPushMatrix,IO ()) +EXTENSION_ENTRY(glPushName,GLuint -> IO ()) +EXTENSION_ENTRY(glRasterPos2d,GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glRasterPos2dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glRasterPos2f,GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glRasterPos2fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glRasterPos2i,GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glRasterPos2iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glRasterPos2s,GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glRasterPos2sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glRasterPos3d,GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glRasterPos3dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glRasterPos3f,GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glRasterPos3fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glRasterPos3i,GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glRasterPos3iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glRasterPos3s,GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glRasterPos3sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glRasterPos4d,GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glRasterPos4dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glRasterPos4f,GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glRasterPos4fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glRasterPos4i,GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glRasterPos4iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glRasterPos4s,GLshort -> GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glRasterPos4sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glRectd,GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glRectdv,Ptr GLdouble -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glRectf,GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glRectfv,Ptr GLfloat -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glRecti,GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glRectiv,Ptr GLint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glRects,GLshort -> GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glRectsv,Ptr GLshort -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glRenderMode,GLenum -> IO GLint) +EXTENSION_ENTRY(glResetHistogram,GLenum -> IO ()) +EXTENSION_ENTRY(glResetMinmax,GLenum -> IO ()) +EXTENSION_ENTRY(glRotated,GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glRotatef,GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glSamplePass,GLenum -> IO ()) +EXTENSION_ENTRY(glScaled,GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glScalef,GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3b,GLbyte -> GLbyte -> GLbyte -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3bv,Ptr GLbyte -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3d,GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3f,GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3i,GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3s,GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3ub,GLubyte -> GLubyte -> GLubyte -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3ubv,Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3ui,GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3uiv,Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3us,GLushort -> GLushort -> GLushort -> IO ()) +EXTENSION_ENTRY(glSecondaryColor3usv,Ptr GLushort -> IO ()) +EXTENSION_ENTRY(glSecondaryColorPointer,GLint -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glSelectBuffer,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glSeparableFilter2D,GLenum -> GLenum -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> Ptr a -> IO ()) +EXTENSION_ENTRY(glShadeModel,GLenum -> IO ()) +EXTENSION_ENTRY(glTexCoord1d,GLdouble -> IO ()) +EXTENSION_ENTRY(glTexCoord1dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glTexCoord1f,GLfloat -> IO ()) +EXTENSION_ENTRY(glTexCoord1fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glTexCoord1i,GLint -> IO ()) +EXTENSION_ENTRY(glTexCoord1iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTexCoord1s,GLshort -> IO ()) +EXTENSION_ENTRY(glTexCoord1sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glTexCoord2d,GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glTexCoord2dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glTexCoord2f,GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glTexCoord2fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glTexCoord2i,GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glTexCoord2iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTexCoord2s,GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glTexCoord2sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glTexCoord3d,GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glTexCoord3dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glTexCoord3f,GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glTexCoord3fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glTexCoord3i,GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glTexCoord3iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTexCoord3s,GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glTexCoord3sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glTexCoord4d,GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glTexCoord4dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glTexCoord4f,GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glTexCoord4fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glTexCoord4i,GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glTexCoord4iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTexCoord4s,GLshort -> GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glTexCoord4sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glTexCoordPointer,GLint -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glTexEnvf,GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glTexEnvfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glTexEnvi,GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glTexEnviv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTexGend,GLenum -> GLenum -> GLdouble -> IO ()) +EXTENSION_ENTRY(glTexGendv,GLenum -> GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glTexGenf,GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glTexGenfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glTexGeni,GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glTexGeniv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTranslated,GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glTranslatef,GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glVertex2d,GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glVertex2dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glVertex2f,GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glVertex2fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glVertex2i,GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glVertex2iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glVertex2s,GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glVertex2sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glVertex3d,GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glVertex3dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glVertex3f,GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glVertex3fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glVertex3i,GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glVertex3iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glVertex3s,GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glVertex3sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glVertex4d,GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glVertex4dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glVertex4f,GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glVertex4fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glVertex4i,GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glVertex4iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glVertex4s,GLshort -> GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glVertex4sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glVertexPointer,GLint -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glWindowPos2d,GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glWindowPos2dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glWindowPos2f,GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glWindowPos2fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glWindowPos2i,GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glWindowPos2iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glWindowPos2s,GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glWindowPos2sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glWindowPos3d,GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glWindowPos3dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glWindowPos3f,GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glWindowPos3fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glWindowPos3i,GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glWindowPos3iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glWindowPos3s,GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glWindowPos3sv,Ptr GLshort -> IO ()) diff --git a/src/Graphics/Rendering/OpenGL/Raw/ARB/Compatibility/Tokens.hs b/src/Graphics/Rendering/OpenGL/Raw/ARB/Compatibility/Tokens.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/ARB/Compatibility/Tokens.hs @@ -0,0 +1,1528 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.ARB.Compatibility.Tokens +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All tokens from the ARB_compatibility extension, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.ARB.Compatibility.Tokens where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_2D :: GLenum +gl_2D = 0x0600 + +gl_2_BYTES :: GLenum +gl_2_BYTES = 0x1407 + +gl_3D :: GLenum +gl_3D = 0x0601 + +gl_3D_COLOR :: GLenum +gl_3D_COLOR = 0x0602 + +gl_3D_COLOR_TEXTURE :: GLenum +gl_3D_COLOR_TEXTURE = 0x0603 + +gl_3_BYTES :: GLenum +gl_3_BYTES = 0x1408 + +gl_4D_COLOR_TEXTURE :: GLenum +gl_4D_COLOR_TEXTURE = 0x0604 + +gl_4_BYTES :: GLenum +gl_4_BYTES = 0x1409 + +gl_ACCUM :: GLenum +gl_ACCUM = 0x0100 + +gl_ACCUM_ALPHA_BITS :: GLenum +gl_ACCUM_ALPHA_BITS = 0x0D5B + +gl_ACCUM_BLUE_BITS :: GLenum +gl_ACCUM_BLUE_BITS = 0x0D5A + +gl_ACCUM_BUFFER_BIT :: GLenum +gl_ACCUM_BUFFER_BIT = 0x00000200 + +gl_ACCUM_CLEAR_VALUE :: GLenum +gl_ACCUM_CLEAR_VALUE = 0x0B80 + +gl_ACCUM_GREEN_BITS :: GLenum +gl_ACCUM_GREEN_BITS = 0x0D59 + +gl_ACCUM_RED_BITS :: GLenum +gl_ACCUM_RED_BITS = 0x0D58 + +gl_ADD :: GLenum +gl_ADD = 0x0104 + +gl_ADD_SIGNED :: GLenum +gl_ADD_SIGNED = 0x8574 + +gl_ALIASED_POINT_SIZE_RANGE :: GLenum +gl_ALIASED_POINT_SIZE_RANGE = 0x846D + +gl_ALL_ATTRIB_BITS :: GLenum +gl_ALL_ATTRIB_BITS = 0xFFFFFFFF + +gl_ALPHA12 :: GLenum +gl_ALPHA12 = 0x803D + +gl_ALPHA16 :: GLenum +gl_ALPHA16 = 0x803E + +gl_ALPHA4 :: GLenum +gl_ALPHA4 = 0x803B + +gl_ALPHA8 :: GLenum +gl_ALPHA8 = 0x803C + +gl_ALPHA_BIAS :: GLenum +gl_ALPHA_BIAS = 0x0D1D + +gl_ALPHA_BITS :: GLenum +gl_ALPHA_BITS = 0x0D55 + +gl_ALPHA_INTEGER :: GLenum +gl_ALPHA_INTEGER = 0x8D97 + +gl_ALPHA_SCALE :: GLenum +gl_ALPHA_SCALE = 0x0D1C + +gl_ALPHA_TEST :: GLenum +gl_ALPHA_TEST = 0x0BC0 + +gl_ALPHA_TEST_FUNC :: GLenum +gl_ALPHA_TEST_FUNC = 0x0BC1 + +gl_ALPHA_TEST_REF :: GLenum +gl_ALPHA_TEST_REF = 0x0BC2 + +gl_AMBIENT :: GLenum +gl_AMBIENT = 0x1200 + +gl_AMBIENT_AND_DIFFUSE :: GLenum +gl_AMBIENT_AND_DIFFUSE = 0x1602 + +gl_ATTRIB_STACK_DEPTH :: GLenum +gl_ATTRIB_STACK_DEPTH = 0x0BB0 + +gl_AUTO_NORMAL :: GLenum +gl_AUTO_NORMAL = 0x0D80 + +gl_AUX0 :: GLenum +gl_AUX0 = 0x0409 + +gl_AUX1 :: GLenum +gl_AUX1 = 0x040A + +gl_AUX2 :: GLenum +gl_AUX2 = 0x040B + +gl_AUX3 :: GLenum +gl_AUX3 = 0x040C + +gl_AUX_BUFFERS :: GLenum +gl_AUX_BUFFERS = 0x0C00 + +gl_BITMAP :: GLenum +gl_BITMAP = 0x1A00 + +gl_BITMAP_TOKEN :: GLenum +gl_BITMAP_TOKEN = 0x0704 + +gl_BLUE_BIAS :: GLenum +gl_BLUE_BIAS = 0x0D1B + +gl_BLUE_BITS :: GLenum +gl_BLUE_BITS = 0x0D54 + +gl_BLUE_SCALE :: GLenum +gl_BLUE_SCALE = 0x0D1A + +gl_C3F_V3F :: GLenum +gl_C3F_V3F = 0x2A24 + +gl_C4F_N3F_V3F :: GLenum +gl_C4F_N3F_V3F = 0x2A26 + +gl_C4UB_V2F :: GLenum +gl_C4UB_V2F = 0x2A22 + +gl_C4UB_V3F :: GLenum +gl_C4UB_V3F = 0x2A23 + +gl_CLAMP :: GLenum +gl_CLAMP = 0x2900 + +gl_CLAMP_FRAGMENT_COLOR :: GLenum +gl_CLAMP_FRAGMENT_COLOR = 0x891B + +gl_CLAMP_VERTEX_COLOR :: GLenum +gl_CLAMP_VERTEX_COLOR = 0x891A + +gl_CLIENT_ACTIVE_TEXTURE :: GLenum +gl_CLIENT_ACTIVE_TEXTURE = 0x84E1 + +gl_CLIENT_ALL_ATTRIB_BITS :: GLenum +gl_CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF + +gl_CLIENT_ATTRIB_STACK_DEPTH :: GLenum +gl_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 + +gl_CLIENT_PIXEL_STORE_BIT :: GLenum +gl_CLIENT_PIXEL_STORE_BIT = 0x00000001 + +gl_CLIENT_VERTEX_ARRAY_BIT :: GLenum +gl_CLIENT_VERTEX_ARRAY_BIT = 0x00000002 + +gl_CLIP_PLANE0 :: GLenum +gl_CLIP_PLANE0 = 0x3000 + +gl_CLIP_PLANE1 :: GLenum +gl_CLIP_PLANE1 = 0x3001 + +gl_CLIP_PLANE2 :: GLenum +gl_CLIP_PLANE2 = 0x3002 + +gl_CLIP_PLANE3 :: GLenum +gl_CLIP_PLANE3 = 0x3003 + +gl_CLIP_PLANE4 :: GLenum +gl_CLIP_PLANE4 = 0x3004 + +gl_CLIP_PLANE5 :: GLenum +gl_CLIP_PLANE5 = 0x3005 + +gl_COEFF :: GLenum +gl_COEFF = 0x0A00 + +gl_COLOR_ARRAY :: GLenum +gl_COLOR_ARRAY = 0x8076 + +gl_COLOR_ARRAY_BUFFER_BINDING :: GLenum +gl_COLOR_ARRAY_BUFFER_BINDING = 0x8898 + +gl_COLOR_ARRAY_COUNT :: GLenum +gl_COLOR_ARRAY_COUNT = 0x8084 + +gl_COLOR_ARRAY_POINTER :: GLenum +gl_COLOR_ARRAY_POINTER = 0x8090 + +gl_COLOR_ARRAY_SIZE :: GLenum +gl_COLOR_ARRAY_SIZE = 0x8081 + +gl_COLOR_ARRAY_STRIDE :: GLenum +gl_COLOR_ARRAY_STRIDE = 0x8083 + +gl_COLOR_ARRAY_TYPE :: GLenum +gl_COLOR_ARRAY_TYPE = 0x8082 + +gl_COLOR_INDEX :: GLenum +gl_COLOR_INDEX = 0x1900 + +gl_COLOR_INDEXES :: GLenum +gl_COLOR_INDEXES = 0x1603 + +gl_COLOR_MATERIAL :: GLenum +gl_COLOR_MATERIAL = 0x0B57 + +gl_COLOR_MATERIAL_FACE :: GLenum +gl_COLOR_MATERIAL_FACE = 0x0B55 + +gl_COLOR_MATERIAL_PARAMETER :: GLenum +gl_COLOR_MATERIAL_PARAMETER = 0x0B56 + +gl_COLOR_MATRIX :: GLenum +gl_COLOR_MATRIX = 0x80B1 + +gl_COLOR_MATRIX_STACK_DEPTH :: GLenum +gl_COLOR_MATRIX_STACK_DEPTH = 0x80B2 + +gl_COLOR_SUM :: GLenum +gl_COLOR_SUM = 0x8458 + +gl_COLOR_TABLE :: GLenum +gl_COLOR_TABLE = 0x80D0 + +gl_COLOR_TABLE_ALPHA_SIZE :: GLenum +gl_COLOR_TABLE_ALPHA_SIZE = 0x80DD + +gl_COLOR_TABLE_BIAS :: GLenum +gl_COLOR_TABLE_BIAS = 0x80D7 + +gl_COLOR_TABLE_BLUE_SIZE :: GLenum +gl_COLOR_TABLE_BLUE_SIZE = 0x80DC + +gl_COLOR_TABLE_FORMAT :: GLenum +gl_COLOR_TABLE_FORMAT = 0x80D8 + +gl_COLOR_TABLE_GREEN_SIZE :: GLenum +gl_COLOR_TABLE_GREEN_SIZE = 0x80DB + +gl_COLOR_TABLE_INTENSITY_SIZE :: GLenum +gl_COLOR_TABLE_INTENSITY_SIZE = 0x80DF + +gl_COLOR_TABLE_LUMINANCE_SIZE :: GLenum +gl_COLOR_TABLE_LUMINANCE_SIZE = 0x80DE + +gl_COLOR_TABLE_RED_SIZE :: GLenum +gl_COLOR_TABLE_RED_SIZE = 0x80DA + +gl_COLOR_TABLE_SCALE :: GLenum +gl_COLOR_TABLE_SCALE = 0x80D6 + +gl_COLOR_TABLE_WIDTH :: GLenum +gl_COLOR_TABLE_WIDTH = 0x80D9 + +gl_COMBINE :: GLenum +gl_COMBINE = 0x8570 + +gl_COMBINE_ALPHA :: GLenum +gl_COMBINE_ALPHA = 0x8572 + +gl_COMBINE_RGB :: GLenum +gl_COMBINE_RGB = 0x8571 + +gl_COMPARE_R_TO_TEXTURE :: GLenum +gl_COMPARE_R_TO_TEXTURE = 0x884E + +gl_COMPILE :: GLenum +gl_COMPILE = 0x1300 + +gl_COMPILE_AND_EXECUTE :: GLenum +gl_COMPILE_AND_EXECUTE = 0x1301 + +gl_COMPRESSED_ALPHA :: GLenum +gl_COMPRESSED_ALPHA = 0x84E9 + +gl_COMPRESSED_INTENSITY :: GLenum +gl_COMPRESSED_INTENSITY = 0x84EC + +gl_COMPRESSED_LUMINANCE :: GLenum +gl_COMPRESSED_LUMINANCE = 0x84EA + +gl_COMPRESSED_LUMINANCE_ALPHA :: GLenum +gl_COMPRESSED_LUMINANCE_ALPHA = 0x84EB + +gl_COMPRESSED_SLUMINANCE :: GLenum +gl_COMPRESSED_SLUMINANCE = 0x8C4A + +gl_COMPRESSED_SLUMINANCE_ALPHA :: GLenum +gl_COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B + +gl_CONSTANT :: GLenum +gl_CONSTANT = 0x8576 + +gl_CONSTANT_ATTENUATION :: GLenum +gl_CONSTANT_ATTENUATION = 0x1207 + +gl_CONSTANT_BORDER :: GLenum +gl_CONSTANT_BORDER = 0x8151 + +gl_CONVOLUTION_1D :: GLenum +gl_CONVOLUTION_1D = 0x8010 + +gl_CONVOLUTION_2D :: GLenum +gl_CONVOLUTION_2D = 0x8011 + +gl_CONVOLUTION_BORDER_COLOR :: GLenum +gl_CONVOLUTION_BORDER_COLOR = 0x8154 + +gl_CONVOLUTION_BORDER_MODE :: GLenum +gl_CONVOLUTION_BORDER_MODE = 0x8013 + +gl_CONVOLUTION_FILTER_BIAS :: GLenum +gl_CONVOLUTION_FILTER_BIAS = 0x8015 + +gl_CONVOLUTION_FILTER_SCALE :: GLenum +gl_CONVOLUTION_FILTER_SCALE = 0x8014 + +gl_CONVOLUTION_FORMAT :: GLenum +gl_CONVOLUTION_FORMAT = 0x8017 + +gl_CONVOLUTION_HEIGHT :: GLenum +gl_CONVOLUTION_HEIGHT = 0x8019 + +gl_CONVOLUTION_WIDTH :: GLenum +gl_CONVOLUTION_WIDTH = 0x8018 + +gl_COORD_REPLACE :: GLenum +gl_COORD_REPLACE = 0x8862 + +gl_COPY_PIXEL_TOKEN :: GLenum +gl_COPY_PIXEL_TOKEN = 0x0706 + +gl_CURRENT_BIT :: GLenum +gl_CURRENT_BIT = 0x00000001 + +gl_CURRENT_COLOR :: GLenum +gl_CURRENT_COLOR = 0x0B00 + +gl_CURRENT_FOG_COORD :: GLenum +gl_CURRENT_FOG_COORD = 0x8453 + +gl_CURRENT_FOG_COORDINATE :: GLenum +gl_CURRENT_FOG_COORDINATE = 0x8453 + +gl_CURRENT_INDEX :: GLenum +gl_CURRENT_INDEX = 0x0B01 + +gl_CURRENT_NORMAL :: GLenum +gl_CURRENT_NORMAL = 0x0B02 + +gl_CURRENT_RASTER_COLOR :: GLenum +gl_CURRENT_RASTER_COLOR = 0x0B04 + +gl_CURRENT_RASTER_DISTANCE :: GLenum +gl_CURRENT_RASTER_DISTANCE = 0x0B09 + +gl_CURRENT_RASTER_INDEX :: GLenum +gl_CURRENT_RASTER_INDEX = 0x0B05 + +gl_CURRENT_RASTER_POSITION :: GLenum +gl_CURRENT_RASTER_POSITION = 0x0B07 + +gl_CURRENT_RASTER_POSITION_VALID :: GLenum +gl_CURRENT_RASTER_POSITION_VALID = 0x0B08 + +gl_CURRENT_RASTER_SECONDARY_COLOR :: GLenum +gl_CURRENT_RASTER_SECONDARY_COLOR = 0x845F + +gl_CURRENT_RASTER_TEXTURE_COORDS :: GLenum +gl_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 + +gl_CURRENT_SECONDARY_COLOR :: GLenum +gl_CURRENT_SECONDARY_COLOR = 0x8459 + +gl_CURRENT_TEXTURE_COORDS :: GLenum +gl_CURRENT_TEXTURE_COORDS = 0x0B03 + +gl_DECAL :: GLenum +gl_DECAL = 0x2101 + +gl_DEPTH_BIAS :: GLenum +gl_DEPTH_BIAS = 0x0D1F + +gl_DEPTH_BITS :: GLenum +gl_DEPTH_BITS = 0x0D56 + +gl_DEPTH_SCALE :: GLenum +gl_DEPTH_SCALE = 0x0D1E + +gl_DEPTH_TEXTURE_MODE :: GLenum +gl_DEPTH_TEXTURE_MODE = 0x884B + +gl_DIFFUSE :: GLenum +gl_DIFFUSE = 0x1201 + +gl_DOMAIN :: GLenum +gl_DOMAIN = 0x0A02 + +gl_DOT3_RGB :: GLenum +gl_DOT3_RGB = 0x86AE + +gl_DOT3_RGBA :: GLenum +gl_DOT3_RGBA = 0x86AF + +gl_DRAW_PIXEL_TOKEN :: GLenum +gl_DRAW_PIXEL_TOKEN = 0x0705 + +gl_EDGE_FLAG :: GLenum +gl_EDGE_FLAG = 0x0B43 + +gl_EDGE_FLAG_ARRAY :: GLenum +gl_EDGE_FLAG_ARRAY = 0x8079 + +gl_EDGE_FLAG_ARRAY_BUFFER_BINDING :: GLenum +gl_EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B + +gl_EDGE_FLAG_ARRAY_COUNT :: GLenum +gl_EDGE_FLAG_ARRAY_COUNT = 0x808D + +gl_EDGE_FLAG_ARRAY_POINTER :: GLenum +gl_EDGE_FLAG_ARRAY_POINTER = 0x8093 + +gl_EDGE_FLAG_ARRAY_STRIDE :: GLenum +gl_EDGE_FLAG_ARRAY_STRIDE = 0x808C + +gl_EMISSION :: GLenum +gl_EMISSION = 0x1600 + +gl_ENABLE_BIT :: GLenum +gl_ENABLE_BIT = 0x00002000 + +gl_EVAL_BIT :: GLenum +gl_EVAL_BIT = 0x00010000 + +gl_EXP :: GLenum +gl_EXP = 0x0800 + +gl_EXP2 :: GLenum +gl_EXP2 = 0x0801 + +gl_EYE_LINEAR :: GLenum +gl_EYE_LINEAR = 0x2400 + +gl_EYE_PLANE :: GLenum +gl_EYE_PLANE = 0x2502 + +gl_FEEDBACK :: GLenum +gl_FEEDBACK = 0x1C01 + +gl_FEEDBACK_BUFFER_POINTER :: GLenum +gl_FEEDBACK_BUFFER_POINTER = 0x0DF0 + +gl_FEEDBACK_BUFFER_SIZE :: GLenum +gl_FEEDBACK_BUFFER_SIZE = 0x0DF1 + +gl_FEEDBACK_BUFFER_TYPE :: GLenum +gl_FEEDBACK_BUFFER_TYPE = 0x0DF2 + +gl_FLAT :: GLenum +gl_FLAT = 0x1D00 + +gl_FOG :: GLenum +gl_FOG = 0x0B60 + +gl_FOG_BIT :: GLenum +gl_FOG_BIT = 0x00000080 + +gl_FOG_COLOR :: GLenum +gl_FOG_COLOR = 0x0B66 + +gl_FOG_COORD :: GLenum +gl_FOG_COORD = 0x8451 + +gl_FOG_COORDINATE :: GLenum +gl_FOG_COORDINATE = 0x8451 + +gl_FOG_COORDINATE_ARRAY :: GLenum +gl_FOG_COORDINATE_ARRAY = 0x8457 + +gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING :: GLenum +gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D + +gl_FOG_COORDINATE_ARRAY_POINTER :: GLenum +gl_FOG_COORDINATE_ARRAY_POINTER = 0x8456 + +gl_FOG_COORDINATE_ARRAY_STRIDE :: GLenum +gl_FOG_COORDINATE_ARRAY_STRIDE = 0x8455 + +gl_FOG_COORDINATE_ARRAY_TYPE :: GLenum +gl_FOG_COORDINATE_ARRAY_TYPE = 0x8454 + +gl_FOG_COORDINATE_SOURCE :: GLenum +gl_FOG_COORDINATE_SOURCE = 0x8450 + +gl_FOG_COORD_ARRAY :: GLenum +gl_FOG_COORD_ARRAY = 0x8457 + +gl_FOG_COORD_ARRAY_BUFFER_BINDING :: GLenum +gl_FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D + +gl_FOG_COORD_ARRAY_POINTER :: GLenum +gl_FOG_COORD_ARRAY_POINTER = 0x8456 + +gl_FOG_COORD_ARRAY_STRIDE :: GLenum +gl_FOG_COORD_ARRAY_STRIDE = 0x8455 + +gl_FOG_COORD_ARRAY_TYPE :: GLenum +gl_FOG_COORD_ARRAY_TYPE = 0x8454 + +gl_FOG_COORD_SRC :: GLenum +gl_FOG_COORD_SRC = 0x8450 + +gl_FOG_DENSITY :: GLenum +gl_FOG_DENSITY = 0x0B62 + +gl_FOG_END :: GLenum +gl_FOG_END = 0x0B64 + +gl_FOG_HINT :: GLenum +gl_FOG_HINT = 0x0C54 + +gl_FOG_INDEX :: GLenum +gl_FOG_INDEX = 0x0B61 + +gl_FOG_MODE :: GLenum +gl_FOG_MODE = 0x0B65 + +gl_FOG_START :: GLenum +gl_FOG_START = 0x0B63 + +gl_FRAGMENT_DEPTH :: GLenum +gl_FRAGMENT_DEPTH = 0x8452 + +gl_GENERATE_MIPMAP :: GLenum +gl_GENERATE_MIPMAP = 0x8191 + +gl_GENERATE_MIPMAP_HINT :: GLenum +gl_GENERATE_MIPMAP_HINT = 0x8192 + +gl_GREEN_BIAS :: GLenum +gl_GREEN_BIAS = 0x0D19 + +gl_GREEN_BITS :: GLenum +gl_GREEN_BITS = 0x0D53 + +gl_GREEN_SCALE :: GLenum +gl_GREEN_SCALE = 0x0D18 + +gl_HINT_BIT :: GLenum +gl_HINT_BIT = 0x00008000 + +gl_HISTOGRAM :: GLenum +gl_HISTOGRAM = 0x8024 + +gl_HISTOGRAM_ALPHA_SIZE :: GLenum +gl_HISTOGRAM_ALPHA_SIZE = 0x802B + +gl_HISTOGRAM_BLUE_SIZE :: GLenum +gl_HISTOGRAM_BLUE_SIZE = 0x802A + +gl_HISTOGRAM_FORMAT :: GLenum +gl_HISTOGRAM_FORMAT = 0x8027 + +gl_HISTOGRAM_GREEN_SIZE :: GLenum +gl_HISTOGRAM_GREEN_SIZE = 0x8029 + +gl_HISTOGRAM_LUMINANCE_SIZE :: GLenum +gl_HISTOGRAM_LUMINANCE_SIZE = 0x802C + +gl_HISTOGRAM_RED_SIZE :: GLenum +gl_HISTOGRAM_RED_SIZE = 0x8028 + +gl_HISTOGRAM_SINK :: GLenum +gl_HISTOGRAM_SINK = 0x802D + +gl_HISTOGRAM_WIDTH :: GLenum +gl_HISTOGRAM_WIDTH = 0x8026 + +gl_INDEX :: GLenum +gl_INDEX = 0x8222 + +gl_INDEX_ARRAY :: GLenum +gl_INDEX_ARRAY = 0x8077 + +gl_INDEX_ARRAY_BUFFER_BINDING :: GLenum +gl_INDEX_ARRAY_BUFFER_BINDING = 0x8899 + +gl_INDEX_ARRAY_COUNT :: GLenum +gl_INDEX_ARRAY_COUNT = 0x8087 + +gl_INDEX_ARRAY_POINTER :: GLenum +gl_INDEX_ARRAY_POINTER = 0x8091 + +gl_INDEX_ARRAY_STRIDE :: GLenum +gl_INDEX_ARRAY_STRIDE = 0x8086 + +gl_INDEX_ARRAY_TYPE :: GLenum +gl_INDEX_ARRAY_TYPE = 0x8085 + +gl_INDEX_BITS :: GLenum +gl_INDEX_BITS = 0x0D51 + +gl_INDEX_CLEAR_VALUE :: GLenum +gl_INDEX_CLEAR_VALUE = 0x0C20 + +gl_INDEX_LOGIC_OP :: GLenum +gl_INDEX_LOGIC_OP = 0x0BF1 + +gl_INDEX_MODE :: GLenum +gl_INDEX_MODE = 0x0C30 + +gl_INDEX_OFFSET :: GLenum +gl_INDEX_OFFSET = 0x0D13 + +gl_INDEX_SHIFT :: GLenum +gl_INDEX_SHIFT = 0x0D12 + +gl_INDEX_WRITEMASK :: GLenum +gl_INDEX_WRITEMASK = 0x0C21 + +gl_INTENSITY :: GLenum +gl_INTENSITY = 0x8049 + +gl_INTENSITY12 :: GLenum +gl_INTENSITY12 = 0x804C + +gl_INTENSITY16 :: GLenum +gl_INTENSITY16 = 0x804D + +gl_INTENSITY4 :: GLenum +gl_INTENSITY4 = 0x804A + +gl_INTENSITY8 :: GLenum +gl_INTENSITY8 = 0x804B + +gl_INTERPOLATE :: GLenum +gl_INTERPOLATE = 0x8575 + +gl_LIGHT0 :: GLenum +gl_LIGHT0 = 0x4000 + +gl_LIGHT1 :: GLenum +gl_LIGHT1 = 0x4001 + +gl_LIGHT2 :: GLenum +gl_LIGHT2 = 0x4002 + +gl_LIGHT3 :: GLenum +gl_LIGHT3 = 0x4003 + +gl_LIGHT4 :: GLenum +gl_LIGHT4 = 0x4004 + +gl_LIGHT5 :: GLenum +gl_LIGHT5 = 0x4005 + +gl_LIGHT6 :: GLenum +gl_LIGHT6 = 0x4006 + +gl_LIGHT7 :: GLenum +gl_LIGHT7 = 0x4007 + +gl_LIGHTING :: GLenum +gl_LIGHTING = 0x0B50 + +gl_LIGHTING_BIT :: GLenum +gl_LIGHTING_BIT = 0x00000040 + +gl_LIGHT_MODEL_AMBIENT :: GLenum +gl_LIGHT_MODEL_AMBIENT = 0x0B53 + +gl_LIGHT_MODEL_COLOR_CONTROL :: GLenum +gl_LIGHT_MODEL_COLOR_CONTROL = 0x81F8 + +gl_LIGHT_MODEL_LOCAL_VIEWER :: GLenum +gl_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 + +gl_LIGHT_MODEL_TWO_SIDE :: GLenum +gl_LIGHT_MODEL_TWO_SIDE = 0x0B52 + +gl_LINEAR_ATTENUATION :: GLenum +gl_LINEAR_ATTENUATION = 0x1208 + +gl_LINE_BIT :: GLenum +gl_LINE_BIT = 0x00000004 + +gl_LINE_RESET_TOKEN :: GLenum +gl_LINE_RESET_TOKEN = 0x0707 + +gl_LINE_STIPPLE :: GLenum +gl_LINE_STIPPLE = 0x0B24 + +gl_LINE_STIPPLE_PATTERN :: GLenum +gl_LINE_STIPPLE_PATTERN = 0x0B25 + +gl_LINE_STIPPLE_REPEAT :: GLenum +gl_LINE_STIPPLE_REPEAT = 0x0B26 + +gl_LINE_TOKEN :: GLenum +gl_LINE_TOKEN = 0x0702 + +gl_LIST_BASE :: GLenum +gl_LIST_BASE = 0x0B32 + +gl_LIST_BIT :: GLenum +gl_LIST_BIT = 0x00020000 + +gl_LIST_INDEX :: GLenum +gl_LIST_INDEX = 0x0B33 + +gl_LIST_MODE :: GLenum +gl_LIST_MODE = 0x0B30 + +gl_LOAD :: GLenum +gl_LOAD = 0x0101 + +gl_LOGIC_OP :: GLenum +gl_LOGIC_OP = 0x0BF1 + +gl_LUMINANCE :: GLenum +gl_LUMINANCE = 0x1909 + +gl_LUMINANCE12 :: GLenum +gl_LUMINANCE12 = 0x8041 + +gl_LUMINANCE12_ALPHA12 :: GLenum +gl_LUMINANCE12_ALPHA12 = 0x8047 + +gl_LUMINANCE12_ALPHA4 :: GLenum +gl_LUMINANCE12_ALPHA4 = 0x8046 + +gl_LUMINANCE16 :: GLenum +gl_LUMINANCE16 = 0x8042 + +gl_LUMINANCE16_ALPHA16 :: GLenum +gl_LUMINANCE16_ALPHA16 = 0x8048 + +gl_LUMINANCE4 :: GLenum +gl_LUMINANCE4 = 0x803F + +gl_LUMINANCE4_ALPHA4 :: GLenum +gl_LUMINANCE4_ALPHA4 = 0x8043 + +gl_LUMINANCE6_ALPHA2 :: GLenum +gl_LUMINANCE6_ALPHA2 = 0x8044 + +gl_LUMINANCE8 :: GLenum +gl_LUMINANCE8 = 0x8040 + +gl_LUMINANCE8_ALPHA8 :: GLenum +gl_LUMINANCE8_ALPHA8 = 0x8045 + +gl_LUMINANCE_ALPHA :: GLenum +gl_LUMINANCE_ALPHA = 0x190A + +gl_MAP1_COLOR_4 :: GLenum +gl_MAP1_COLOR_4 = 0x0D90 + +gl_MAP1_GRID_DOMAIN :: GLenum +gl_MAP1_GRID_DOMAIN = 0x0DD0 + +gl_MAP1_GRID_SEGMENTS :: GLenum +gl_MAP1_GRID_SEGMENTS = 0x0DD1 + +gl_MAP1_INDEX :: GLenum +gl_MAP1_INDEX = 0x0D91 + +gl_MAP1_NORMAL :: GLenum +gl_MAP1_NORMAL = 0x0D92 + +gl_MAP1_TEXTURE_COORD_1 :: GLenum +gl_MAP1_TEXTURE_COORD_1 = 0x0D93 + +gl_MAP1_TEXTURE_COORD_2 :: GLenum +gl_MAP1_TEXTURE_COORD_2 = 0x0D94 + +gl_MAP1_TEXTURE_COORD_3 :: GLenum +gl_MAP1_TEXTURE_COORD_3 = 0x0D95 + +gl_MAP1_TEXTURE_COORD_4 :: GLenum +gl_MAP1_TEXTURE_COORD_4 = 0x0D96 + +gl_MAP1_VERTEX_3 :: GLenum +gl_MAP1_VERTEX_3 = 0x0D97 + +gl_MAP1_VERTEX_4 :: GLenum +gl_MAP1_VERTEX_4 = 0x0D98 + +gl_MAP2_COLOR_4 :: GLenum +gl_MAP2_COLOR_4 = 0x0DB0 + +gl_MAP2_GRID_DOMAIN :: GLenum +gl_MAP2_GRID_DOMAIN = 0x0DD2 + +gl_MAP2_GRID_SEGMENTS :: GLenum +gl_MAP2_GRID_SEGMENTS = 0x0DD3 + +gl_MAP2_INDEX :: GLenum +gl_MAP2_INDEX = 0x0DB1 + +gl_MAP2_NORMAL :: GLenum +gl_MAP2_NORMAL = 0x0DB2 + +gl_MAP2_TEXTURE_COORD_1 :: GLenum +gl_MAP2_TEXTURE_COORD_1 = 0x0DB3 + +gl_MAP2_TEXTURE_COORD_2 :: GLenum +gl_MAP2_TEXTURE_COORD_2 = 0x0DB4 + +gl_MAP2_TEXTURE_COORD_3 :: GLenum +gl_MAP2_TEXTURE_COORD_3 = 0x0DB5 + +gl_MAP2_TEXTURE_COORD_4 :: GLenum +gl_MAP2_TEXTURE_COORD_4 = 0x0DB6 + +gl_MAP2_VERTEX_3 :: GLenum +gl_MAP2_VERTEX_3 = 0x0DB7 + +gl_MAP2_VERTEX_4 :: GLenum +gl_MAP2_VERTEX_4 = 0x0DB8 + +gl_MAP_COLOR :: GLenum +gl_MAP_COLOR = 0x0D10 + +gl_MAP_STENCIL :: GLenum +gl_MAP_STENCIL = 0x0D11 + +gl_MATRIX_MODE :: GLenum +gl_MATRIX_MODE = 0x0BA0 + +gl_MAX_ATTRIB_STACK_DEPTH :: GLenum +gl_MAX_ATTRIB_STACK_DEPTH = 0x0D35 + +gl_MAX_CLIENT_ATTRIB_STACK_DEPTH :: GLenum +gl_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B + +gl_MAX_CLIP_PLANES :: GLenum +gl_MAX_CLIP_PLANES = 0x0D32 + +gl_MAX_COLOR_MATRIX_STACK_DEPTH :: GLenum +gl_MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3 + +gl_MAX_CONVOLUTION_HEIGHT :: GLenum +gl_MAX_CONVOLUTION_HEIGHT = 0x801B + +gl_MAX_CONVOLUTION_WIDTH :: GLenum +gl_MAX_CONVOLUTION_WIDTH = 0x801A + +gl_MAX_EVAL_ORDER :: GLenum +gl_MAX_EVAL_ORDER = 0x0D30 + +gl_MAX_LIGHTS :: GLenum +gl_MAX_LIGHTS = 0x0D31 + +gl_MAX_LIST_NESTING :: GLenum +gl_MAX_LIST_NESTING = 0x0B31 + +gl_MAX_MODELVIEW_STACK_DEPTH :: GLenum +gl_MAX_MODELVIEW_STACK_DEPTH = 0x0D36 + +gl_MAX_NAME_STACK_DEPTH :: GLenum +gl_MAX_NAME_STACK_DEPTH = 0x0D37 + +gl_MAX_PIXEL_MAP_TABLE :: GLenum +gl_MAX_PIXEL_MAP_TABLE = 0x0D34 + +gl_MAX_PROJECTION_STACK_DEPTH :: GLenum +gl_MAX_PROJECTION_STACK_DEPTH = 0x0D38 + +gl_MAX_TEXTURE_COORDS :: GLenum +gl_MAX_TEXTURE_COORDS = 0x8871 + +gl_MAX_TEXTURE_STACK_DEPTH :: GLenum +gl_MAX_TEXTURE_STACK_DEPTH = 0x0D39 + +gl_MAX_TEXTURE_UNITS :: GLenum +gl_MAX_TEXTURE_UNITS = 0x84E2 + +gl_MINMAX :: GLenum +gl_MINMAX = 0x802E + +gl_MINMAX_FORMAT :: GLenum +gl_MINMAX_FORMAT = 0x802F + +gl_MINMAX_SINK :: GLenum +gl_MINMAX_SINK = 0x8030 + +gl_MODELVIEW :: GLenum +gl_MODELVIEW = 0x1700 + +gl_MODELVIEW_MATRIX :: GLenum +gl_MODELVIEW_MATRIX = 0x0BA6 + +gl_MODELVIEW_STACK_DEPTH :: GLenum +gl_MODELVIEW_STACK_DEPTH = 0x0BA3 + +gl_MODULATE :: GLenum +gl_MODULATE = 0x2100 + +gl_MULT :: GLenum +gl_MULT = 0x0103 + +gl_MULTISAMPLE_BIT :: GLenum +gl_MULTISAMPLE_BIT = 0x20000000 + +gl_N3F_V3F :: GLenum +gl_N3F_V3F = 0x2A25 + +gl_NAME_STACK_DEPTH :: GLenum +gl_NAME_STACK_DEPTH = 0x0D70 + +gl_NORMALIZE :: GLenum +gl_NORMALIZE = 0x0BA1 + +gl_NORMAL_ARRAY :: GLenum +gl_NORMAL_ARRAY = 0x8075 + +gl_NORMAL_ARRAY_BUFFER_BINDING :: GLenum +gl_NORMAL_ARRAY_BUFFER_BINDING = 0x8897 + +gl_NORMAL_ARRAY_COUNT :: GLenum +gl_NORMAL_ARRAY_COUNT = 0x8080 + +gl_NORMAL_ARRAY_POINTER :: GLenum +gl_NORMAL_ARRAY_POINTER = 0x808F + +gl_NORMAL_ARRAY_STRIDE :: GLenum +gl_NORMAL_ARRAY_STRIDE = 0x807F + +gl_NORMAL_ARRAY_TYPE :: GLenum +gl_NORMAL_ARRAY_TYPE = 0x807E + +gl_NORMAL_MAP :: GLenum +gl_NORMAL_MAP = 0x8511 + +gl_OBJECT_LINEAR :: GLenum +gl_OBJECT_LINEAR = 0x2401 + +gl_OBJECT_PLANE :: GLenum +gl_OBJECT_PLANE = 0x2501 + +gl_OPERAND0_ALPHA :: GLenum +gl_OPERAND0_ALPHA = 0x8598 + +gl_OPERAND0_RGB :: GLenum +gl_OPERAND0_RGB = 0x8590 + +gl_OPERAND1_ALPHA :: GLenum +gl_OPERAND1_ALPHA = 0x8599 + +gl_OPERAND1_RGB :: GLenum +gl_OPERAND1_RGB = 0x8591 + +gl_OPERAND2_ALPHA :: GLenum +gl_OPERAND2_ALPHA = 0x859A + +gl_OPERAND2_RGB :: GLenum +gl_OPERAND2_RGB = 0x8592 + +gl_ORDER :: GLenum +gl_ORDER = 0x0A01 + +gl_PASS_THROUGH_TOKEN :: GLenum +gl_PASS_THROUGH_TOKEN = 0x0700 + +gl_PERSPECTIVE_CORRECTION_HINT :: GLenum +gl_PERSPECTIVE_CORRECTION_HINT = 0x0C50 + +gl_PIXEL_MAP_A_TO_A :: GLenum +gl_PIXEL_MAP_A_TO_A = 0x0C79 + +gl_PIXEL_MAP_A_TO_A_SIZE :: GLenum +gl_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 + +gl_PIXEL_MAP_B_TO_B :: GLenum +gl_PIXEL_MAP_B_TO_B = 0x0C78 + +gl_PIXEL_MAP_B_TO_B_SIZE :: GLenum +gl_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 + +gl_PIXEL_MAP_G_TO_G :: GLenum +gl_PIXEL_MAP_G_TO_G = 0x0C77 + +gl_PIXEL_MAP_G_TO_G_SIZE :: GLenum +gl_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 + +gl_PIXEL_MAP_I_TO_A :: GLenum +gl_PIXEL_MAP_I_TO_A = 0x0C75 + +gl_PIXEL_MAP_I_TO_A_SIZE :: GLenum +gl_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 + +gl_PIXEL_MAP_I_TO_B :: GLenum +gl_PIXEL_MAP_I_TO_B = 0x0C74 + +gl_PIXEL_MAP_I_TO_B_SIZE :: GLenum +gl_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 + +gl_PIXEL_MAP_I_TO_G :: GLenum +gl_PIXEL_MAP_I_TO_G = 0x0C73 + +gl_PIXEL_MAP_I_TO_G_SIZE :: GLenum +gl_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 + +gl_PIXEL_MAP_I_TO_I :: GLenum +gl_PIXEL_MAP_I_TO_I = 0x0C70 + +gl_PIXEL_MAP_I_TO_I_SIZE :: GLenum +gl_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 + +gl_PIXEL_MAP_I_TO_R :: GLenum +gl_PIXEL_MAP_I_TO_R = 0x0C72 + +gl_PIXEL_MAP_I_TO_R_SIZE :: GLenum +gl_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 + +gl_PIXEL_MAP_R_TO_R :: GLenum +gl_PIXEL_MAP_R_TO_R = 0x0C76 + +gl_PIXEL_MAP_R_TO_R_SIZE :: GLenum +gl_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 + +gl_PIXEL_MAP_S_TO_S :: GLenum +gl_PIXEL_MAP_S_TO_S = 0x0C71 + +gl_PIXEL_MAP_S_TO_S_SIZE :: GLenum +gl_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 + +gl_PIXEL_MODE_BIT :: GLenum +gl_PIXEL_MODE_BIT = 0x00000020 + +gl_POINT_BIT :: GLenum +gl_POINT_BIT = 0x00000002 + +gl_POINT_DISTANCE_ATTENUATION :: GLenum +gl_POINT_DISTANCE_ATTENUATION = 0x8129 + +gl_POINT_SIZE_MAX :: GLenum +gl_POINT_SIZE_MAX = 0x8127 + +gl_POINT_SIZE_MIN :: GLenum +gl_POINT_SIZE_MIN = 0x8126 + +gl_POINT_SMOOTH :: GLenum +gl_POINT_SMOOTH = 0x0B10 + +gl_POINT_SMOOTH_HINT :: GLenum +gl_POINT_SMOOTH_HINT = 0x0C51 + +gl_POINT_SPRITE :: GLenum +gl_POINT_SPRITE = 0x8861 + +gl_POINT_TOKEN :: GLenum +gl_POINT_TOKEN = 0x0701 + +gl_POLYGON :: GLenum +gl_POLYGON = 0x0009 + +gl_POLYGON_BIT :: GLenum +gl_POLYGON_BIT = 0x00000008 + +gl_POLYGON_MODE :: GLenum +gl_POLYGON_MODE = 0x0B40 + +gl_POLYGON_STIPPLE :: GLenum +gl_POLYGON_STIPPLE = 0x0B42 + +gl_POLYGON_STIPPLE_BIT :: GLenum +gl_POLYGON_STIPPLE_BIT = 0x00000010 + +gl_POLYGON_TOKEN :: GLenum +gl_POLYGON_TOKEN = 0x0703 + +gl_POSITION :: GLenum +gl_POSITION = 0x1203 + +gl_POST_COLOR_MATRIX_ALPHA_BIAS :: GLenum +gl_POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB + +gl_POST_COLOR_MATRIX_ALPHA_SCALE :: GLenum +gl_POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7 + +gl_POST_COLOR_MATRIX_BLUE_BIAS :: GLenum +gl_POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA + +gl_POST_COLOR_MATRIX_BLUE_SCALE :: GLenum +gl_POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6 + +gl_POST_COLOR_MATRIX_COLOR_TABLE :: GLenum +gl_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2 + +gl_POST_COLOR_MATRIX_GREEN_BIAS :: GLenum +gl_POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9 + +gl_POST_COLOR_MATRIX_GREEN_SCALE :: GLenum +gl_POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5 + +gl_POST_COLOR_MATRIX_RED_BIAS :: GLenum +gl_POST_COLOR_MATRIX_RED_BIAS = 0x80B8 + +gl_POST_COLOR_MATRIX_RED_SCALE :: GLenum +gl_POST_COLOR_MATRIX_RED_SCALE = 0x80B4 + +gl_POST_CONVOLUTION_ALPHA_BIAS :: GLenum +gl_POST_CONVOLUTION_ALPHA_BIAS = 0x8023 + +gl_POST_CONVOLUTION_ALPHA_SCALE :: GLenum +gl_POST_CONVOLUTION_ALPHA_SCALE = 0x801F + +gl_POST_CONVOLUTION_BLUE_BIAS :: GLenum +gl_POST_CONVOLUTION_BLUE_BIAS = 0x8022 + +gl_POST_CONVOLUTION_BLUE_SCALE :: GLenum +gl_POST_CONVOLUTION_BLUE_SCALE = 0x801E + +gl_POST_CONVOLUTION_COLOR_TABLE :: GLenum +gl_POST_CONVOLUTION_COLOR_TABLE = 0x80D1 + +gl_POST_CONVOLUTION_GREEN_BIAS :: GLenum +gl_POST_CONVOLUTION_GREEN_BIAS = 0x8021 + +gl_POST_CONVOLUTION_GREEN_SCALE :: GLenum +gl_POST_CONVOLUTION_GREEN_SCALE = 0x801D + +gl_POST_CONVOLUTION_RED_BIAS :: GLenum +gl_POST_CONVOLUTION_RED_BIAS = 0x8020 + +gl_POST_CONVOLUTION_RED_SCALE :: GLenum +gl_POST_CONVOLUTION_RED_SCALE = 0x801C + +gl_PREVIOUS :: GLenum +gl_PREVIOUS = 0x8578 + +gl_PRIMARY_COLOR :: GLenum +gl_PRIMARY_COLOR = 0x8577 + +gl_PROJECTION :: GLenum +gl_PROJECTION = 0x1701 + +gl_PROJECTION_MATRIX :: GLenum +gl_PROJECTION_MATRIX = 0x0BA7 + +gl_PROJECTION_STACK_DEPTH :: GLenum +gl_PROJECTION_STACK_DEPTH = 0x0BA4 + +gl_PROXY_COLOR_TABLE :: GLenum +gl_PROXY_COLOR_TABLE = 0x80D3 + +gl_PROXY_HISTOGRAM :: GLenum +gl_PROXY_HISTOGRAM = 0x8025 + +gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE :: GLenum +gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5 + +gl_PROXY_POST_CONVOLUTION_COLOR_TABLE :: GLenum +gl_PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4 + +gl_Q :: GLenum +gl_Q = 0x2003 + +gl_QUADRATIC_ATTENUATION :: GLenum +gl_QUADRATIC_ATTENUATION = 0x1209 + +gl_QUADS :: GLenum +gl_QUADS = 0x0007 + +gl_QUAD_STRIP :: GLenum +gl_QUAD_STRIP = 0x0008 + +gl_R :: GLenum +gl_R = 0x2002 + +gl_REDUCE :: GLenum +gl_REDUCE = 0x8016 + +gl_RED_BIAS :: GLenum +gl_RED_BIAS = 0x0D15 + +gl_RED_BITS :: GLenum +gl_RED_BITS = 0x0D52 + +gl_RED_SCALE :: GLenum +gl_RED_SCALE = 0x0D14 + +gl_REFLECTION_MAP :: GLenum +gl_REFLECTION_MAP = 0x8512 + +gl_RENDER :: GLenum +gl_RENDER = 0x1C00 + +gl_RENDER_MODE :: GLenum +gl_RENDER_MODE = 0x0C40 + +gl_REPLICATE_BORDER :: GLenum +gl_REPLICATE_BORDER = 0x8153 + +gl_RESCALE_NORMAL :: GLenum +gl_RESCALE_NORMAL = 0x803A + +gl_RETURN :: GLenum +gl_RETURN = 0x0102 + +gl_RGBA_MODE :: GLenum +gl_RGBA_MODE = 0x0C31 + +gl_RGB_SCALE :: GLenum +gl_RGB_SCALE = 0x8573 + +gl_S :: GLenum +gl_S = 0x2000 + +gl_SCISSOR_BIT :: GLenum +gl_SCISSOR_BIT = 0x00080000 + +gl_SECONDARY_COLOR_ARRAY :: GLenum +gl_SECONDARY_COLOR_ARRAY = 0x845E + +gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING :: GLenum +gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C + +gl_SECONDARY_COLOR_ARRAY_POINTER :: GLenum +gl_SECONDARY_COLOR_ARRAY_POINTER = 0x845D + +gl_SECONDARY_COLOR_ARRAY_SIZE :: GLenum +gl_SECONDARY_COLOR_ARRAY_SIZE = 0x845A + +gl_SECONDARY_COLOR_ARRAY_STRIDE :: GLenum +gl_SECONDARY_COLOR_ARRAY_STRIDE = 0x845C + +gl_SECONDARY_COLOR_ARRAY_TYPE :: GLenum +gl_SECONDARY_COLOR_ARRAY_TYPE = 0x845B + +gl_SELECT :: GLenum +gl_SELECT = 0x1C02 + +gl_SELECTION_BUFFER_POINTER :: GLenum +gl_SELECTION_BUFFER_POINTER = 0x0DF3 + +gl_SELECTION_BUFFER_SIZE :: GLenum +gl_SELECTION_BUFFER_SIZE = 0x0DF4 + +gl_SEPARABLE_2D :: GLenum +gl_SEPARABLE_2D = 0x8012 + +gl_SEPARATE_SPECULAR_COLOR :: GLenum +gl_SEPARATE_SPECULAR_COLOR = 0x81FA + +gl_SHADE_MODEL :: GLenum +gl_SHADE_MODEL = 0x0B54 + +gl_SHININESS :: GLenum +gl_SHININESS = 0x1601 + +gl_SINGLE_COLOR :: GLenum +gl_SINGLE_COLOR = 0x81F9 + +gl_SLUMINANCE :: GLenum +gl_SLUMINANCE = 0x8C46 + +gl_SLUMINANCE8 :: GLenum +gl_SLUMINANCE8 = 0x8C47 + +gl_SLUMINANCE8_ALPHA8 :: GLenum +gl_SLUMINANCE8_ALPHA8 = 0x8C45 + +gl_SLUMINANCE_ALPHA :: GLenum +gl_SLUMINANCE_ALPHA = 0x8C44 + +gl_SMOOTH :: GLenum +gl_SMOOTH = 0x1D01 + +gl_SOURCE0_ALPHA :: GLenum +gl_SOURCE0_ALPHA = 0x8588 + +gl_SOURCE0_RGB :: GLenum +gl_SOURCE0_RGB = 0x8580 + +gl_SOURCE1_ALPHA :: GLenum +gl_SOURCE1_ALPHA = 0x8589 + +gl_SOURCE1_RGB :: GLenum +gl_SOURCE1_RGB = 0x8581 + +gl_SOURCE2_ALPHA :: GLenum +gl_SOURCE2_ALPHA = 0x858A + +gl_SOURCE2_RGB :: GLenum +gl_SOURCE2_RGB = 0x8582 + +gl_SPECULAR :: GLenum +gl_SPECULAR = 0x1202 + +gl_SPHERE_MAP :: GLenum +gl_SPHERE_MAP = 0x2402 + +gl_SPOT_CUTOFF :: GLenum +gl_SPOT_CUTOFF = 0x1206 + +gl_SPOT_DIRECTION :: GLenum +gl_SPOT_DIRECTION = 0x1204 + +gl_SPOT_EXPONENT :: GLenum +gl_SPOT_EXPONENT = 0x1205 + +gl_SRC0_ALPHA :: GLenum +gl_SRC0_ALPHA = 0x8588 + +gl_SRC0_RGB :: GLenum +gl_SRC0_RGB = 0x8580 + +gl_SRC1_ALPHA :: GLenum +gl_SRC1_ALPHA = 0x8589 + +gl_SRC1_RGB :: GLenum +gl_SRC1_RGB = 0x8581 + +gl_SRC2_ALPHA :: GLenum +gl_SRC2_ALPHA = 0x858A + +gl_SRC2_RGB :: GLenum +gl_SRC2_RGB = 0x8582 + +gl_STACK_OVERFLOW :: GLenum +gl_STACK_OVERFLOW = 0x0503 + +gl_STACK_UNDERFLOW :: GLenum +gl_STACK_UNDERFLOW = 0x0504 + +gl_STENCIL_BITS :: GLenum +gl_STENCIL_BITS = 0x0D57 + +gl_SUBTRACT :: GLenum +gl_SUBTRACT = 0x84E7 + +gl_T :: GLenum +gl_T = 0x2001 + +gl_T2F_C3F_V3F :: GLenum +gl_T2F_C3F_V3F = 0x2A2A + +gl_T2F_C4F_N3F_V3F :: GLenum +gl_T2F_C4F_N3F_V3F = 0x2A2C + +gl_T2F_C4UB_V3F :: GLenum +gl_T2F_C4UB_V3F = 0x2A29 + +gl_T2F_N3F_V3F :: GLenum +gl_T2F_N3F_V3F = 0x2A2B + +gl_T2F_V3F :: GLenum +gl_T2F_V3F = 0x2A27 + +gl_T4F_C4F_N3F_V4F :: GLenum +gl_T4F_C4F_N3F_V4F = 0x2A2D + +gl_T4F_V4F :: GLenum +gl_T4F_V4F = 0x2A28 + +gl_TABLE_TOO_LARGE :: GLenum +gl_TABLE_TOO_LARGE = 0x8031 + +gl_TEXTURE_BIT :: GLenum +gl_TEXTURE_BIT = 0x00040000 + +gl_TEXTURE_COMPONENTS :: GLenum +gl_TEXTURE_COMPONENTS = 0x1003 + +gl_TEXTURE_COORD_ARRAY :: GLenum +gl_TEXTURE_COORD_ARRAY = 0x8078 + +gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING :: GLenum +gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A + +gl_TEXTURE_COORD_ARRAY_COUNT :: GLenum +gl_TEXTURE_COORD_ARRAY_COUNT = 0x808B + +gl_TEXTURE_COORD_ARRAY_POINTER :: GLenum +gl_TEXTURE_COORD_ARRAY_POINTER = 0x8092 + +gl_TEXTURE_COORD_ARRAY_SIZE :: GLenum +gl_TEXTURE_COORD_ARRAY_SIZE = 0x8088 + +gl_TEXTURE_COORD_ARRAY_STRIDE :: GLenum +gl_TEXTURE_COORD_ARRAY_STRIDE = 0x808A + +gl_TEXTURE_COORD_ARRAY_TYPE :: GLenum +gl_TEXTURE_COORD_ARRAY_TYPE = 0x8089 + +gl_TEXTURE_ENV :: GLenum +gl_TEXTURE_ENV = 0x2300 + +gl_TEXTURE_ENV_COLOR :: GLenum +gl_TEXTURE_ENV_COLOR = 0x2201 + +gl_TEXTURE_ENV_MODE :: GLenum +gl_TEXTURE_ENV_MODE = 0x2200 + +gl_TEXTURE_FILTER_CONTROL :: GLenum +gl_TEXTURE_FILTER_CONTROL = 0x8500 + +gl_TEXTURE_GEN_MODE :: GLenum +gl_TEXTURE_GEN_MODE = 0x2500 + +gl_TEXTURE_GEN_Q :: GLenum +gl_TEXTURE_GEN_Q = 0x0C63 + +gl_TEXTURE_GEN_R :: GLenum +gl_TEXTURE_GEN_R = 0x0C62 + +gl_TEXTURE_GEN_S :: GLenum +gl_TEXTURE_GEN_S = 0x0C60 + +gl_TEXTURE_GEN_T :: GLenum +gl_TEXTURE_GEN_T = 0x0C61 + +gl_TEXTURE_INTENSITY_SIZE :: GLenum +gl_TEXTURE_INTENSITY_SIZE = 0x8061 + +gl_TEXTURE_INTENSITY_TYPE :: GLenum +gl_TEXTURE_INTENSITY_TYPE = 0x8C15 + +gl_TEXTURE_LUMINANCE_SIZE :: GLenum +gl_TEXTURE_LUMINANCE_SIZE = 0x8060 + +gl_TEXTURE_LUMINANCE_TYPE :: GLenum +gl_TEXTURE_LUMINANCE_TYPE = 0x8C14 + +gl_TEXTURE_MATRIX :: GLenum +gl_TEXTURE_MATRIX = 0x0BA8 + +gl_TEXTURE_PRIORITY :: GLenum +gl_TEXTURE_PRIORITY = 0x8066 + +gl_TEXTURE_RESIDENT :: GLenum +gl_TEXTURE_RESIDENT = 0x8067 + +gl_TEXTURE_STACK_DEPTH :: GLenum +gl_TEXTURE_STACK_DEPTH = 0x0BA5 + +gl_TRANSFORM_BIT :: GLenum +gl_TRANSFORM_BIT = 0x00001000 + +gl_TRANSPOSE_COLOR_MATRIX :: GLenum +gl_TRANSPOSE_COLOR_MATRIX = 0x84E6 + +gl_TRANSPOSE_MODELVIEW_MATRIX :: GLenum +gl_TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 + +gl_TRANSPOSE_PROJECTION_MATRIX :: GLenum +gl_TRANSPOSE_PROJECTION_MATRIX = 0x84E4 + +gl_TRANSPOSE_TEXTURE_MATRIX :: GLenum +gl_TRANSPOSE_TEXTURE_MATRIX = 0x84E5 + +gl_V2F :: GLenum +gl_V2F = 0x2A20 + +gl_V3F :: GLenum +gl_V3F = 0x2A21 + +gl_VERTEX_ARRAY :: GLenum +gl_VERTEX_ARRAY = 0x8074 + +gl_VERTEX_ARRAY_BUFFER_BINDING :: GLenum +gl_VERTEX_ARRAY_BUFFER_BINDING = 0x8896 + +gl_VERTEX_ARRAY_COUNT :: GLenum +gl_VERTEX_ARRAY_COUNT = 0x807D + +gl_VERTEX_ARRAY_POINTER :: GLenum +gl_VERTEX_ARRAY_POINTER = 0x808E + +gl_VERTEX_ARRAY_SIZE :: GLenum +gl_VERTEX_ARRAY_SIZE = 0x807A + +gl_VERTEX_ARRAY_STRIDE :: GLenum +gl_VERTEX_ARRAY_STRIDE = 0x807C + +gl_VERTEX_ARRAY_TYPE :: GLenum +gl_VERTEX_ARRAY_TYPE = 0x807B + +gl_VERTEX_PROGRAM_TWO_SIDE :: GLenum +gl_VERTEX_PROGRAM_TWO_SIDE = 0x8643 + +gl_VIEWPORT_BIT :: GLenum +gl_VIEWPORT_BIT = 0x00000800 + +gl_WEIGHT_ARRAY_BUFFER_BINDING :: GLenum +gl_WEIGHT_ARRAY_BUFFER_BINDING = 0x889E + +gl_ZOOM_X :: GLenum +gl_ZOOM_X = 0x0D16 + +gl_ZOOM_Y :: GLenum +gl_ZOOM_Y = 0x0D17 diff --git a/src/Graphics/Rendering/OpenGL/Raw/ARB/FragmentProgram.hs b/src/Graphics/Rendering/OpenGL/Raw/ARB/FragmentProgram.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/ARB/FragmentProgram.hs @@ -0,0 +1,163 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.ARB.FragmentProgram +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the ARB_fragment_program extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.ARB.FragmentProgram ( + -- * Functions + glProgramString, + glBindProgram, + glDeletePrograms, + glGenPrograms, + glProgramEnvParameter4d, + glProgramEnvParameter4dv, + glProgramEnvParameter4f, + glProgramEnvParameter4fv, + glProgramLocalParameter4d, + glProgramLocalParameter4dv, + glProgramLocalParameter4f, + glProgramLocalParameter4fv, + glGetProgramEnvParameterdv, + glGetProgramEnvParameterfv, + glGetProgramLocalParameterdv, + glGetProgramLocalParameterfv, + glGetProgramString, + -- * Tokens + gl_FRAGMENT_PROGRAM, + gl_PROGRAM_FORMAT_ASCII, + gl_PROGRAM_LENGTH, + gl_PROGRAM_FORMAT, + gl_PROGRAM_BINDING, + gl_PROGRAM_INSTRUCTIONS, + gl_MAX_PROGRAM_INSTRUCTIONS, + gl_PROGRAM_NATIVE_INSTRUCTIONS, + gl_MAX_PROGRAM_NATIVE_INSTRUCTIONS, + gl_PROGRAM_TEMPORARIES, + gl_MAX_PROGRAM_TEMPORARIES, + gl_PROGRAM_NATIVE_TEMPORARIES, + gl_MAX_PROGRAM_NATIVE_TEMPORARIES, + gl_PROGRAM_PARAMETERS, + gl_MAX_PROGRAM_PARAMETERS, + gl_PROGRAM_NATIVE_PARAMETERS, + gl_MAX_PROGRAM_NATIVE_PARAMETERS, + gl_PROGRAM_ATTRIBS, + gl_MAX_PROGRAM_ATTRIBS, + gl_PROGRAM_NATIVE_ATTRIBS, + gl_MAX_PROGRAM_NATIVE_ATTRIBS, + gl_MAX_PROGRAM_LOCAL_PARAMETERS, + gl_MAX_PROGRAM_ENV_PARAMETERS, + gl_PROGRAM_UNDER_NATIVE_LIMITS, + gl_PROGRAM_ALU_INSTRUCTIONS, + gl_PROGRAM_TEX_INSTRUCTIONS, + gl_PROGRAM_TEX_INDIRECTIONS, + gl_PROGRAM_NATIVE_ALU_INSTRUCTIONS, + gl_PROGRAM_NATIVE_TEX_INSTRUCTIONS, + gl_PROGRAM_NATIVE_TEX_INDIRECTIONS, + gl_MAX_PROGRAM_ALU_INSTRUCTIONS, + gl_MAX_PROGRAM_TEX_INSTRUCTIONS, + gl_MAX_PROGRAM_TEX_INDIRECTIONS, + gl_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS, + gl_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS, + gl_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS, + gl_PROGRAM_STRING, + gl_PROGRAM_ERROR_POSITION, + gl_CURRENT_MATRIX, + gl_TRANSPOSE_CURRENT_MATRIX, + gl_CURRENT_MATRIX_STACK_DEPTH, + gl_MAX_PROGRAM_MATRICES, + gl_MAX_PROGRAM_MATRIX_STACK_DEPTH, + gl_MAX_TEXTURE_COORDS, + gl_PROGRAM_ERROR_STRING, + gl_MATRIX0, + gl_MATRIX1, + gl_MATRIX2, + gl_MATRIX3, + gl_MATRIX4, + gl_MATRIX5, + gl_MATRIX6, + gl_MATRIX7, + gl_MATRIX8, + gl_MATRIX9, + gl_MATRIX10, + gl_MATRIX11, + gl_MATRIX12, + gl_MATRIX13, + gl_MATRIX14, + gl_MATRIX15, + gl_MATRIX16, + gl_MATRIX17, + gl_MATRIX18, + gl_MATRIX19, + gl_MATRIX20, + gl_MATRIX21, + gl_MATRIX22, + gl_MATRIX23, + gl_MATRIX24, + gl_MATRIX25, + gl_MATRIX26, + gl_MATRIX27, + gl_MATRIX28, + gl_MATRIX29, + gl_MATRIX30, + gl_MATRIX31 +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility +import Graphics.Rendering.OpenGL.Raw.ARB.VertexProgram +import Graphics.Rendering.OpenGL.Raw.Core31 + +-- functions/tokens already in the OpenGL 3.1 core: +-- +-- glGetProgramiv +-- glIsProgram +-- gl_MAX_TEXTURE_IMAGE_UNITS + +gl_FRAGMENT_PROGRAM :: GLenum +gl_FRAGMENT_PROGRAM = 0x8804 + +gl_PROGRAM_ALU_INSTRUCTIONS :: GLenum +gl_PROGRAM_ALU_INSTRUCTIONS = 0x8805 + +gl_PROGRAM_TEX_INSTRUCTIONS :: GLenum +gl_PROGRAM_TEX_INSTRUCTIONS = 0x8806 + +gl_PROGRAM_TEX_INDIRECTIONS :: GLenum +gl_PROGRAM_TEX_INDIRECTIONS = 0x8807 + +gl_PROGRAM_NATIVE_ALU_INSTRUCTIONS :: GLenum +gl_PROGRAM_NATIVE_ALU_INSTRUCTIONS = 0x8808 + +gl_PROGRAM_NATIVE_TEX_INSTRUCTIONS :: GLenum +gl_PROGRAM_NATIVE_TEX_INSTRUCTIONS = 0x8809 + +gl_PROGRAM_NATIVE_TEX_INDIRECTIONS :: GLenum +gl_PROGRAM_NATIVE_TEX_INDIRECTIONS = 0x880A + +gl_MAX_PROGRAM_ALU_INSTRUCTIONS :: GLenum +gl_MAX_PROGRAM_ALU_INSTRUCTIONS = 0x880B + +gl_MAX_PROGRAM_TEX_INSTRUCTIONS :: GLenum +gl_MAX_PROGRAM_TEX_INSTRUCTIONS = 0x880C + +gl_MAX_PROGRAM_TEX_INDIRECTIONS :: GLenum +gl_MAX_PROGRAM_TEX_INDIRECTIONS = 0x880D + +gl_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS :: GLenum +gl_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS = 0x880E + +gl_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS :: GLenum +gl_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS = 0x880F + +gl_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS :: GLenum +gl_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS = 0x8810 diff --git a/src/Graphics/Rendering/OpenGL/Raw/ARB/GeometryShader4.hs b/src/Graphics/Rendering/OpenGL/Raw/ARB/GeometryShader4.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/ARB/GeometryShader4.hs @@ -0,0 +1,54 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.ARB.GeometryShader4 +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the ARB_geometry_shader4 extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.ARB.GeometryShader4 ( + -- * Functions + glProgramParameteri, + glFramebufferTexture, + glFramebufferTextureFace, + -- * Tokens + gl_MAX_GEOMETRY_UNIFORM_BLOCKS, + gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS, + gl_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_ARB_geometry_shader4" + +-- functions/tokens already in the OpenGL 3.1 core: +-- +-- glFramebufferTextureLayer +-- gl_MAX_VARYING_COMPONENTS +-- gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER + +EXTENSION_ENTRY(glProgramParameteri,GLuint -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glFramebufferTexture,GLenum -> GLenum -> GLuint -> GLint -> IO ()) +EXTENSION_ENTRY(glFramebufferTextureFace,GLenum -> GLenum -> GLuint -> GLint -> GLenum -> IO ()) + +gl_MAX_GEOMETRY_UNIFORM_BLOCKS :: GLenum +gl_MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C + +gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS :: GLenum +gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 + +gl_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER :: GLenum +gl_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 diff --git a/src/Graphics/Rendering/OpenGL/Raw/ARB/InstancedArrays.hs b/src/Graphics/Rendering/OpenGL/Raw/ARB/InstancedArrays.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/ARB/InstancedArrays.hs @@ -0,0 +1,36 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.ARB.InstancedArrays +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the ARB_instanced_arrays extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.ARB.InstancedArrays ( + -- * Functions + glVertexAttribDivisor, + -- * Tokens + gl_VERTEX_ATTRIB_ARRAY_DIVISOR +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_ARB_instanced_arrays" + +EXTENSION_ENTRY(glVertexAttribDivisor,GLuint -> GLuint -> IO ()) + +gl_VERTEX_ATTRIB_ARRAY_DIVISOR :: GLenum +gl_VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE diff --git a/src/Graphics/Rendering/OpenGL/Raw/ARB/MatrixPalette.hs b/src/Graphics/Rendering/OpenGL/Raw/ARB/MatrixPalette.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/ARB/MatrixPalette.hs @@ -0,0 +1,81 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.ARB.MatrixPalette +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the ARB_matrix_palette extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.ARB.MatrixPalette ( + -- * Functions + glCurrentPaletteMatrix, + glMatrixIndexubv, + glMatrixIndexusv, + glMatrixIndexuiv, + glMatrixIndexPointer, + -- * Tokens + gl_MATRIX_PALETTE, + gl_MAX_MATRIX_PALETTE_STACK_DEPTH, + gl_MAX_PALETTE_MATRICES, + gl_CURRENT_PALETTE_MATRIX, + gl_MATRIX_INDEX_ARRAY, + gl_CURRENT_MATRIX_INDEX, + gl_MATRIX_INDEX_ARRAY_SIZE, + gl_MATRIX_INDEX_ARRAY_TYPE, + gl_MATRIX_INDEX_ARRAY_STRIDE, + gl_MATRIX_INDEX_ARRAY_POINTER +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_ARB_matrix_palette" + +EXTENSION_ENTRY(glCurrentPaletteMatrix,GLint -> IO ()) +EXTENSION_ENTRY(glMatrixIndexubv,GLint -> Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glMatrixIndexusv,GLint -> Ptr GLushort -> IO ()) +EXTENSION_ENTRY(glMatrixIndexuiv,GLint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glMatrixIndexPointer,GLint -> GLenum -> GLsizei -> Ptr a -> IO ()) + +gl_MATRIX_PALETTE :: GLenum +gl_MATRIX_PALETTE = 0x8840 + +gl_MAX_MATRIX_PALETTE_STACK_DEPTH :: GLenum +gl_MAX_MATRIX_PALETTE_STACK_DEPTH = 0x8841 + +gl_MAX_PALETTE_MATRICES :: GLenum +gl_MAX_PALETTE_MATRICES = 0x8842 + +gl_CURRENT_PALETTE_MATRIX :: GLenum +gl_CURRENT_PALETTE_MATRIX = 0x8843 + +gl_MATRIX_INDEX_ARRAY :: GLenum +gl_MATRIX_INDEX_ARRAY = 0x8844 + +gl_CURRENT_MATRIX_INDEX :: GLenum +gl_CURRENT_MATRIX_INDEX = 0x8845 + +gl_MATRIX_INDEX_ARRAY_SIZE :: GLenum +gl_MATRIX_INDEX_ARRAY_SIZE = 0x8846 + +gl_MATRIX_INDEX_ARRAY_TYPE :: GLenum +gl_MATRIX_INDEX_ARRAY_TYPE = 0x8847 + +gl_MATRIX_INDEX_ARRAY_STRIDE :: GLenum +gl_MATRIX_INDEX_ARRAY_STRIDE = 0x8848 + +gl_MATRIX_INDEX_ARRAY_POINTER :: GLenum +gl_MATRIX_INDEX_ARRAY_POINTER = 0x8849 diff --git a/src/Graphics/Rendering/OpenGL/Raw/ARB/ShadowAmbient.hs b/src/Graphics/Rendering/OpenGL/Raw/ARB/ShadowAmbient.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/ARB/ShadowAmbient.hs @@ -0,0 +1,25 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.ARB.ShadowAmbient +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the ARB_shadow_ambient extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.ARB.ShadowAmbient ( + -- * Tokens + gl_TEXTURE_COMPARE_FAIL_VALUE +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_TEXTURE_COMPARE_FAIL_VALUE :: GLenum +gl_TEXTURE_COMPARE_FAIL_VALUE = 0x80BF diff --git a/src/Graphics/Rendering/OpenGL/Raw/ARB/VertexBlend.hs b/src/Graphics/Rendering/OpenGL/Raw/ARB/VertexBlend.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/ARB/VertexBlend.hs @@ -0,0 +1,219 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.ARB.VertexBlend +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the ARB_vertex_blend extension not already +-- in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.ARB.VertexBlend ( + -- * Functions + glWeightbv, + glWeightsv, + glWeightiv, + glWeightfv, + glWeightdv, + glWeightubv, + glWeightusv, + glWeightuiv, + glWeightPointer, + glVertexBlend, + -- * Tokens + gl_MAX_VERTEX_UNITS, + gl_ACTIVE_VERTEX_UNITS, + gl_WEIGHT_SUM_UNITY, + gl_VERTEX_BLEND, + gl_MODELVIEW0, + gl_MODELVIEW1, + gl_MODELVIEW2, + gl_MODELVIEW3, + gl_MODELVIEW4, + gl_MODELVIEW5, + gl_MODELVIEW6, + gl_MODELVIEW7, + gl_MODELVIEW8, + gl_MODELVIEW9, + gl_MODELVIEW10, + gl_MODELVIEW11, + gl_MODELVIEW12, + gl_MODELVIEW13, + gl_MODELVIEW14, + gl_MODELVIEW15, + gl_MODELVIEW16, + gl_MODELVIEW17, + gl_MODELVIEW18, + gl_MODELVIEW19, + gl_MODELVIEW20, + gl_MODELVIEW21, + gl_MODELVIEW22, + gl_MODELVIEW23, + gl_MODELVIEW24, + gl_MODELVIEW25, + gl_MODELVIEW26, + gl_MODELVIEW27, + gl_MODELVIEW28, + gl_MODELVIEW29, + gl_MODELVIEW30, + gl_MODELVIEW31, + gl_CURRENT_WEIGHT, + gl_WEIGHT_ARRAY_TYPE, + gl_WEIGHT_ARRAY_STRIDE, + gl_WEIGHT_ARRAY_SIZE, + gl_WEIGHT_ARRAY_POINTER, + gl_WEIGHT_ARRAY +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_ARB_vertex_blend" + +EXTENSION_ENTRY(glWeightbv,GLint -> Ptr GLbyte -> IO ()) +EXTENSION_ENTRY(glWeightsv,GLint -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glWeightiv,GLint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glWeightfv,GLint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glWeightdv,GLint -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glWeightubv,GLint -> Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glWeightusv,GLint -> Ptr GLushort -> IO ()) +EXTENSION_ENTRY(glWeightuiv,GLint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glWeightPointer,GLint -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glVertexBlend,GLint -> IO ()) + +gl_MAX_VERTEX_UNITS :: GLenum +gl_MAX_VERTEX_UNITS = 0x86A4 + +gl_ACTIVE_VERTEX_UNITS :: GLenum +gl_ACTIVE_VERTEX_UNITS = 0x86A5 + +gl_WEIGHT_SUM_UNITY :: GLenum +gl_WEIGHT_SUM_UNITY = 0x86A6 + +gl_VERTEX_BLEND :: GLenum +gl_VERTEX_BLEND = 0x86A7 + +gl_MODELVIEW0 :: GLenum +gl_MODELVIEW0 = 0x1700 + +gl_MODELVIEW1 :: GLenum +gl_MODELVIEW1 = 0x850a + +gl_MODELVIEW2 :: GLenum +gl_MODELVIEW2 = 0x8722 + +gl_MODELVIEW3 :: GLenum +gl_MODELVIEW3 = 0x8723 + +gl_MODELVIEW4 :: GLenum +gl_MODELVIEW4 = 0x8724 + +gl_MODELVIEW5 :: GLenum +gl_MODELVIEW5 = 0x8725 + +gl_MODELVIEW6 :: GLenum +gl_MODELVIEW6 = 0x8726 + +gl_MODELVIEW7 :: GLenum +gl_MODELVIEW7 = 0x8727 + +gl_MODELVIEW8 :: GLenum +gl_MODELVIEW8 = 0x8728 + +gl_MODELVIEW9 :: GLenum +gl_MODELVIEW9 = 0x8729 + +gl_MODELVIEW10 :: GLenum +gl_MODELVIEW10 = 0x872A + +gl_MODELVIEW11 :: GLenum +gl_MODELVIEW11 = 0x872B + +gl_MODELVIEW12 :: GLenum +gl_MODELVIEW12 = 0x872C + +gl_MODELVIEW13 :: GLenum +gl_MODELVIEW13 = 0x872D + +gl_MODELVIEW14 :: GLenum +gl_MODELVIEW14 = 0x872E + +gl_MODELVIEW15 :: GLenum +gl_MODELVIEW15 = 0x872F + +gl_MODELVIEW16 :: GLenum +gl_MODELVIEW16 = 0x8730 + +gl_MODELVIEW17 :: GLenum +gl_MODELVIEW17 = 0x8731 + +gl_MODELVIEW18 :: GLenum +gl_MODELVIEW18 = 0x8732 + +gl_MODELVIEW19 :: GLenum +gl_MODELVIEW19 = 0x8733 + +gl_MODELVIEW20 :: GLenum +gl_MODELVIEW20 = 0x8734 + +gl_MODELVIEW21 :: GLenum +gl_MODELVIEW21 = 0x8735 + +gl_MODELVIEW22 :: GLenum +gl_MODELVIEW22 = 0x8736 + +gl_MODELVIEW23 :: GLenum +gl_MODELVIEW23 = 0x8737 + +gl_MODELVIEW24 :: GLenum +gl_MODELVIEW24 = 0x8738 + +gl_MODELVIEW25 :: GLenum +gl_MODELVIEW25 = 0x8739 + +gl_MODELVIEW26 :: GLenum +gl_MODELVIEW26 = 0x873A + +gl_MODELVIEW27 :: GLenum +gl_MODELVIEW27 = 0x873B + +gl_MODELVIEW28 :: GLenum +gl_MODELVIEW28 = 0x873C + +gl_MODELVIEW29 :: GLenum +gl_MODELVIEW29 = 0x873D + +gl_MODELVIEW30 :: GLenum +gl_MODELVIEW30 = 0x873E + +gl_MODELVIEW31 :: GLenum +gl_MODELVIEW31 = 0x873F + +gl_CURRENT_WEIGHT :: GLenum +gl_CURRENT_WEIGHT = 0x86A8 + +gl_WEIGHT_ARRAY_TYPE :: GLenum +gl_WEIGHT_ARRAY_TYPE = 0x86A9 + +gl_WEIGHT_ARRAY_STRIDE :: GLenum +gl_WEIGHT_ARRAY_STRIDE = 0x86AA + +gl_WEIGHT_ARRAY_SIZE :: GLenum +gl_WEIGHT_ARRAY_SIZE = 0x86AB + +gl_WEIGHT_ARRAY_POINTER :: GLenum +gl_WEIGHT_ARRAY_POINTER = 0x86AC + +gl_WEIGHT_ARRAY :: GLenum +gl_WEIGHT_ARRAY = 0x86AD diff --git a/src/Graphics/Rendering/OpenGL/Raw/ARB/VertexProgram.hs b/src/Graphics/Rendering/OpenGL/Raw/ARB/VertexProgram.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/ARB/VertexProgram.hs @@ -0,0 +1,421 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.ARB.VertexProgram +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the ARB_vertex_program extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.ARB.VertexProgram ( + -- * Functions + glProgramString, + glBindProgram, + glDeletePrograms, + glGenPrograms, + glProgramEnvParameter4d, + glProgramEnvParameter4dv, + glProgramEnvParameter4f, + glProgramEnvParameter4fv, + glProgramLocalParameter4d, + glProgramLocalParameter4dv, + glProgramLocalParameter4f, + glProgramLocalParameter4fv, + glGetProgramEnvParameterdv, + glGetProgramEnvParameterfv, + glGetProgramLocalParameterdv, + glGetProgramLocalParameterfv, + glGetProgramString, + -- * Tokens + gl_VERTEX_PROGRAM, + gl_PROGRAM_FORMAT_ASCII, + gl_PROGRAM_LENGTH, + gl_PROGRAM_FORMAT, + gl_PROGRAM_BINDING, + gl_PROGRAM_INSTRUCTIONS, + gl_MAX_PROGRAM_INSTRUCTIONS, + gl_PROGRAM_NATIVE_INSTRUCTIONS, + gl_MAX_PROGRAM_NATIVE_INSTRUCTIONS, + gl_PROGRAM_TEMPORARIES, + gl_MAX_PROGRAM_TEMPORARIES, + gl_PROGRAM_NATIVE_TEMPORARIES, + gl_MAX_PROGRAM_NATIVE_TEMPORARIES, + gl_PROGRAM_PARAMETERS, + gl_MAX_PROGRAM_PARAMETERS, + gl_PROGRAM_NATIVE_PARAMETERS, + gl_MAX_PROGRAM_NATIVE_PARAMETERS, + gl_PROGRAM_ATTRIBS, + gl_MAX_PROGRAM_ATTRIBS, + gl_PROGRAM_NATIVE_ATTRIBS, + gl_MAX_PROGRAM_NATIVE_ATTRIBS, + gl_PROGRAM_ADDRESS_REGISTERS, + gl_MAX_PROGRAM_ADDRESS_REGISTERS, + gl_PROGRAM_NATIVE_ADDRESS_REGISTERS, + gl_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS, + gl_MAX_PROGRAM_LOCAL_PARAMETERS, + gl_MAX_PROGRAM_ENV_PARAMETERS, + gl_PROGRAM_UNDER_NATIVE_LIMITS, + gl_PROGRAM_STRING, + gl_PROGRAM_ERROR_POSITION, + gl_CURRENT_MATRIX, + gl_TRANSPOSE_CURRENT_MATRIX, + gl_CURRENT_MATRIX_STACK_DEPTH, + gl_MAX_PROGRAM_MATRICES, + gl_MAX_PROGRAM_MATRIX_STACK_DEPTH, + gl_PROGRAM_ERROR_STRING, + gl_MATRIX0, + gl_MATRIX1, + gl_MATRIX2, + gl_MATRIX3, + gl_MATRIX4, + gl_MATRIX5, + gl_MATRIX6, + gl_MATRIX7, + gl_MATRIX8, + gl_MATRIX9, + gl_MATRIX10, + gl_MATRIX11, + gl_MATRIX12, + gl_MATRIX13, + gl_MATRIX14, + gl_MATRIX15, + gl_MATRIX16, + gl_MATRIX17, + gl_MATRIX18, + gl_MATRIX19, + gl_MATRIX20, + gl_MATRIX21, + gl_MATRIX22, + gl_MATRIX23, + gl_MATRIX24, + gl_MATRIX25, + gl_MATRIX26, + gl_MATRIX27, + gl_MATRIX28, + gl_MATRIX29, + gl_MATRIX30, + gl_MATRIX31 +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 + +-- functions/tokens already in the OpenGL 3.1 core: +-- +-- glVertexAttrib1s +-- glVertexAttrib1f +-- glVertexAttrib1d +-- glVertexAttrib2s +-- glVertexAttrib2f +-- glVertexAttrib2d +-- glVertexAttrib3s +-- glVertexAttrib3f +-- glVertexAttrib3d +-- glVertexAttrib4s +-- glVertexAttrib4f +-- glVertexAttrib4d +-- glVertexAttrib4Nub +-- glVertexAttrib1sv +-- glVertexAttrib1fv +-- glVertexAttrib1dv +-- glVertexAttrib2sv +-- glVertexAttrib2fv +-- glVertexAttrib2dv +-- glVertexAttrib3sv +-- glVertexAttrib3fv +-- glVertexAttrib3dv +-- glVertexAttrib4bv +-- glVertexAttrib4sv +-- glVertexAttrib4iv +-- glVertexAttrib4ubv +-- glVertexAttrib4usv +-- glVertexAttrib4uiv +-- glVertexAttrib4fv +-- glVertexAttrib4dv +-- glVertexAttrib4Nbv +-- glVertexAttrib4Nsv +-- glVertexAttrib4Niv +-- glVertexAttrib4Nubv +-- glVertexAttrib4Nusv +-- glVertexAttrib4Nuiv +-- glVertexAttribPointer +-- glEnableVertexAttribArray +-- glDisableVertexAttribArray +-- glGetProgramiv +-- glGetVertexAttribdv +-- glGetVertexAttribfv +-- glGetVertexAttribiv +-- glGetVertexAttribPointerv +-- glIsProgram +-- gl_VERTEX_PROGRAM_POINT_SIZE +-- gl_VERTEX_ATTRIB_ARRAY_ENABLED +-- gl_VERTEX_ATTRIB_ARRAY_SIZE +-- gl_VERTEX_ATTRIB_ARRAY_STRIDE +-- gl_VERTEX_ATTRIB_ARRAY_TYPE +-- gl_VERTEX_ATTRIB_ARRAY_NORMALIZED +-- gl_CURRENT_VERTEX_ATTRIB +-- gl_VERTEX_ATTRIB_ARRAY_POINTER +-- gl_MAX_VERTEX_ATTRIBS + +glProgramString :: GLenum -> GLenum -> GLsizei -> Ptr a -> IO () +glProgramString = undefined + +glBindProgram :: GLenum -> GLuint -> IO () +glBindProgram = undefined + +glDeletePrograms :: GLsizei -> Ptr GLuint -> IO () +glDeletePrograms = undefined + +glGenPrograms :: GLsizei -> Ptr GLuint -> IO () +glGenPrograms = undefined + +glProgramEnvParameter4d :: GLenum -> GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO () +glProgramEnvParameter4d = undefined + +glProgramEnvParameter4dv :: GLenum -> GLuint -> Ptr GLdouble -> IO () +glProgramEnvParameter4dv = undefined + +glProgramEnvParameter4f :: GLenum -> GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO () +glProgramEnvParameter4f = undefined + +glProgramEnvParameter4fv :: GLenum -> GLuint -> Ptr GLfloat -> IO () +glProgramEnvParameter4fv = undefined + +glProgramLocalParameter4d :: GLenum -> GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO () +glProgramLocalParameter4d = undefined + +glProgramLocalParameter4dv :: GLenum -> GLuint -> Ptr GLdouble -> IO () +glProgramLocalParameter4dv = undefined + +glProgramLocalParameter4f :: GLenum -> GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO () +glProgramLocalParameter4f = undefined + +glProgramLocalParameter4fv :: GLenum -> GLuint -> Ptr GLfloat -> IO () +glProgramLocalParameter4fv = undefined + +glGetProgramEnvParameterdv :: GLenum -> GLuint -> Ptr GLdouble -> IO () +glGetProgramEnvParameterdv = undefined + +glGetProgramEnvParameterfv :: GLenum -> GLuint -> Ptr GLfloat -> IO () +glGetProgramEnvParameterfv = undefined + +glGetProgramLocalParameterdv :: GLenum -> GLuint -> Ptr GLdouble -> IO () +glGetProgramLocalParameterdv = undefined + +glGetProgramLocalParameterfv :: GLenum -> GLuint -> Ptr GLfloat -> IO () +glGetProgramLocalParameterfv = undefined + +glGetProgramString :: GLenum -> GLenum -> Ptr a -> IO () +glGetProgramString = undefined + +gl_VERTEX_PROGRAM :: GLenum +gl_VERTEX_PROGRAM = 0x8620 + +gl_PROGRAM_FORMAT_ASCII :: GLenum +gl_PROGRAM_FORMAT_ASCII = 0x8875 + +gl_PROGRAM_LENGTH :: GLenum +gl_PROGRAM_LENGTH = 0x8627 + +gl_PROGRAM_FORMAT :: GLenum +gl_PROGRAM_FORMAT = 0x8876 + +gl_PROGRAM_BINDING :: GLenum +gl_PROGRAM_BINDING = 0x8677 + +gl_PROGRAM_INSTRUCTIONS :: GLenum +gl_PROGRAM_INSTRUCTIONS = 0x88A0 + +gl_MAX_PROGRAM_INSTRUCTIONS :: GLenum +gl_MAX_PROGRAM_INSTRUCTIONS = 0x88A1 + +gl_PROGRAM_NATIVE_INSTRUCTIONS :: GLenum +gl_PROGRAM_NATIVE_INSTRUCTIONS = 0x88A2 + +gl_MAX_PROGRAM_NATIVE_INSTRUCTIONS :: GLenum +gl_MAX_PROGRAM_NATIVE_INSTRUCTIONS = 0x88A3 + +gl_PROGRAM_TEMPORARIES :: GLenum +gl_PROGRAM_TEMPORARIES = 0x88A4 + +gl_MAX_PROGRAM_TEMPORARIES :: GLenum +gl_MAX_PROGRAM_TEMPORARIES = 0x88A5 + +gl_PROGRAM_NATIVE_TEMPORARIES :: GLenum +gl_PROGRAM_NATIVE_TEMPORARIES = 0x88A6 + +gl_MAX_PROGRAM_NATIVE_TEMPORARIES :: GLenum +gl_MAX_PROGRAM_NATIVE_TEMPORARIES = 0x88A7 + +gl_PROGRAM_PARAMETERS :: GLenum +gl_PROGRAM_PARAMETERS = 0x88A8 + +gl_MAX_PROGRAM_PARAMETERS :: GLenum +gl_MAX_PROGRAM_PARAMETERS = 0x88A9 + +gl_PROGRAM_NATIVE_PARAMETERS :: GLenum +gl_PROGRAM_NATIVE_PARAMETERS = 0x88AA + +gl_MAX_PROGRAM_NATIVE_PARAMETERS :: GLenum +gl_MAX_PROGRAM_NATIVE_PARAMETERS = 0x88AB + +gl_PROGRAM_ATTRIBS :: GLenum +gl_PROGRAM_ATTRIBS = 0x88AC + +gl_MAX_PROGRAM_ATTRIBS :: GLenum +gl_MAX_PROGRAM_ATTRIBS = 0x88AD + +gl_PROGRAM_NATIVE_ATTRIBS :: GLenum +gl_PROGRAM_NATIVE_ATTRIBS = 0x88AE + +gl_MAX_PROGRAM_NATIVE_ATTRIBS :: GLenum +gl_MAX_PROGRAM_NATIVE_ATTRIBS = 0x88AF + +gl_PROGRAM_ADDRESS_REGISTERS :: GLenum +gl_PROGRAM_ADDRESS_REGISTERS = 0x88B0 + +gl_MAX_PROGRAM_ADDRESS_REGISTERS :: GLenum +gl_MAX_PROGRAM_ADDRESS_REGISTERS = 0x88B1 + +gl_PROGRAM_NATIVE_ADDRESS_REGISTERS :: GLenum +gl_PROGRAM_NATIVE_ADDRESS_REGISTERS = 0x88B2 + +gl_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS :: GLenum +gl_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS = 0x88B3 + +gl_MAX_PROGRAM_LOCAL_PARAMETERS :: GLenum +gl_MAX_PROGRAM_LOCAL_PARAMETERS = 0x88B4 + +gl_MAX_PROGRAM_ENV_PARAMETERS :: GLenum +gl_MAX_PROGRAM_ENV_PARAMETERS = 0x88B5 + +gl_PROGRAM_UNDER_NATIVE_LIMITS :: GLenum +gl_PROGRAM_UNDER_NATIVE_LIMITS = 0x88B6 + +gl_PROGRAM_STRING :: GLenum +gl_PROGRAM_STRING = 0x8628 + +gl_PROGRAM_ERROR_POSITION :: GLenum +gl_PROGRAM_ERROR_POSITION = 0x864B + +gl_CURRENT_MATRIX :: GLenum +gl_CURRENT_MATRIX = 0x8641 + +gl_TRANSPOSE_CURRENT_MATRIX :: GLenum +gl_TRANSPOSE_CURRENT_MATRIX = 0x88B7 + +gl_CURRENT_MATRIX_STACK_DEPTH :: GLenum +gl_CURRENT_MATRIX_STACK_DEPTH = 0x8640 + +gl_MAX_PROGRAM_MATRICES :: GLenum +gl_MAX_PROGRAM_MATRICES = 0x862F + +gl_MAX_PROGRAM_MATRIX_STACK_DEPTH :: GLenum +gl_MAX_PROGRAM_MATRIX_STACK_DEPTH = 0x862E + +gl_PROGRAM_ERROR_STRING :: GLenum +gl_PROGRAM_ERROR_STRING = 0x8874 + +gl_MATRIX0 :: GLenum +gl_MATRIX0 = 0x88C0 + +gl_MATRIX1 :: GLenum +gl_MATRIX1 = 0x88C1 + +gl_MATRIX2 :: GLenum +gl_MATRIX2 = 0x88C2 + +gl_MATRIX3 :: GLenum +gl_MATRIX3 = 0x88C3 + +gl_MATRIX4 :: GLenum +gl_MATRIX4 = 0x88C4 + +gl_MATRIX5 :: GLenum +gl_MATRIX5 = 0x88C5 + +gl_MATRIX6 :: GLenum +gl_MATRIX6 = 0x88C6 + +gl_MATRIX7 :: GLenum +gl_MATRIX7 = 0x88C7 + +gl_MATRIX8 :: GLenum +gl_MATRIX8 = 0x88C8 + +gl_MATRIX9 :: GLenum +gl_MATRIX9 = 0x88C9 + +gl_MATRIX10 :: GLenum +gl_MATRIX10 = 0x88CA + +gl_MATRIX11 :: GLenum +gl_MATRIX11 = 0x88CB + +gl_MATRIX12 :: GLenum +gl_MATRIX12 = 0x88CC + +gl_MATRIX13 :: GLenum +gl_MATRIX13 = 0x88CD + +gl_MATRIX14 :: GLenum +gl_MATRIX14 = 0x88CE + +gl_MATRIX15 :: GLenum +gl_MATRIX15 = 0x88CF + +gl_MATRIX16 :: GLenum +gl_MATRIX16 = 0x88D0 + +gl_MATRIX17 :: GLenum +gl_MATRIX17 = 0x88D1 + +gl_MATRIX18 :: GLenum +gl_MATRIX18 = 0x88D2 + +gl_MATRIX19 :: GLenum +gl_MATRIX19 = 0x88D3 + +gl_MATRIX20 :: GLenum +gl_MATRIX20 = 0x88D4 + +gl_MATRIX21 :: GLenum +gl_MATRIX21 = 0x88D5 + +gl_MATRIX22 :: GLenum +gl_MATRIX22 = 0x88D6 + +gl_MATRIX23 :: GLenum +gl_MATRIX23 = 0x88D7 + +gl_MATRIX24 :: GLenum +gl_MATRIX24 = 0x88D8 + +gl_MATRIX25 :: GLenum +gl_MATRIX25 = 0x88D9 + +gl_MATRIX26 :: GLenum +gl_MATRIX26 = 0x88DA + +gl_MATRIX27 :: GLenum +gl_MATRIX27 = 0x88DB + +gl_MATRIX28 :: GLenum +gl_MATRIX28 = 0x88DC + +gl_MATRIX29 :: GLenum +gl_MATRIX29 = 0x88DD + +gl_MATRIX30 :: GLenum +gl_MATRIX30 = 0x88DE + +gl_MATRIX31 :: GLenum +gl_MATRIX31 = 0x88DF diff --git a/src/Graphics/Rendering/OpenGL/Raw/Core31.hs b/src/Graphics/Rendering/OpenGL/Raw/Core31.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/Core31.hs @@ -0,0 +1,27 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.Core31 +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions, tokens and types from the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.Core31 ( + -- * Functions + module Graphics.Rendering.OpenGL.Raw.Core31.Functions, + -- * Tokens + module Graphics.Rendering.OpenGL.Raw.Core31.Tokens, + -- * Types + module Graphics.Rendering.OpenGL.Raw.Core31.Types +) where + +import Graphics.Rendering.OpenGL.Raw.Core31.Functions +import Graphics.Rendering.OpenGL.Raw.Core31.Tokens +import Graphics.Rendering.OpenGL.Raw.Core31.Types diff --git a/src/Graphics/Rendering/OpenGL/Raw/Core31/Functions.hs b/src/Graphics/Rendering/OpenGL/Raw/Core31/Functions.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/Core31/Functions.hs @@ -0,0 +1,625 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.Core31.Functions +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions from the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.Core31.Functions ( + glActiveTexture, + glAttachShader, + glBeginConditionalRender, + glBeginQuery, + glBeginTransformFeedback, + glBindAttribLocation, + glBindBuffer, + glBindBufferBase, + glBindBufferRange, + glBindFragDataLocation, + glBindFramebuffer, + glBindRenderbuffer, + glBindTexture, + glBindVertexArray, + glBlendColor, + glBlendEquation, + glBlendEquationSeparate, + glBlendFunc, + glBlendFuncSeparate, + glBlitFramebuffer, + glBufferData, + glBufferSubData, + glCheckFramebufferStatus, + glClampColor, + glClear, + glClearBufferfi, + glClearBufferfv, + glClearBufferiv, + glClearBufferuiv, + glClearColor, + glClearDepth, + glClearStencil, + glColorMask, + glColorMaski, + glCompileShader, + glCompressedTexImage1D, + glCompressedTexImage2D, + glCompressedTexImage3D, + glCompressedTexSubImage1D, + glCompressedTexSubImage2D, + glCompressedTexSubImage3D, + glCopyBufferSubData, + glCopyTexImage1D, + glCopyTexImage2D, + glCopyTexSubImage1D, + glCopyTexSubImage2D, + glCopyTexSubImage3D, + glCreateProgram, + glCreateShader, + glCullFace, + glDeleteBuffers, + glDeleteFramebuffers, + glDeleteProgram, + glDeleteQueries, + glDeleteRenderbuffers, + glDeleteShader, + glDeleteTextures, + glDeleteVertexArrays, + glDepthFunc, + glDepthMask, + glDepthRange, + glDetachShader, + glDisable, + glDisableVertexAttribArray, + glDisablei, + glDrawArrays, + glDrawArraysInstanced, + glDrawBuffer, + glDrawBuffers, + glDrawElements, + glDrawElementsInstanced, + glDrawRangeElements, + glEnable, + glEnableVertexAttribArray, + glEnablei, + glEndConditionalRender, + glEndQuery, + glEndTransformFeedback, + glFinish, + glFlush, + glFlushMappedBufferRange, + glFramebufferRenderbuffer, + glFramebufferTexture1D, + glFramebufferTexture2D, + glFramebufferTexture3D, + glFramebufferTextureLayer, + glFrontFace, + glGenBuffers, + glGenFramebuffers, + glGenQueries, + glGenRenderbuffers, + glGenTextures, + glGenVertexArrays, + glGenerateMipmap, + glGetActiveAttrib, + glGetActiveUniform, + glGetActiveUniformBlockName, + glGetActiveUniformBlockiv, + glGetActiveUniformName, + glGetActiveUniformsiv, + glGetAttachedShaders, + glGetAttribLocation, + glGetBooleani_v, + glGetBooleanv, + glGetBufferParameteriv, + glGetBufferPointerv, + glGetBufferSubData, + glGetCompressedTexImage, + glGetDoublev, + glGetError, + glGetFloatv, + glGetFragDataLocation, + glGetFramebufferAttachmentParameteriv, + glGetIntegeri_v, + glGetIntegerv, + glGetPointerv, + glGetProgramInfoLog, + glGetProgramiv, + glGetQueryObjectiv, + glGetQueryObjectuiv, + glGetQueryiv, + glGetRenderbufferParameteriv, + glGetShaderInfoLog, + glGetShaderSource, + glGetShaderiv, + glGetString, + glGetStringi, + glGetTexImage, + glGetTexLevelParameterfv, + glGetTexLevelParameteriv, + glGetTexParameterIiv, + glGetTexParameterIuiv, + glGetTexParameterfv, + glGetTexParameteriv, + glGetTransformFeedbackVarying, + glGetUniformBlockIndex, + glGetUniformIndices, + glGetUniformLocation, + glGetUniformfv, + glGetUniformiv, + glGetUniformuiv, + glGetVertexAttribIiv, + glGetVertexAttribIuiv, + glGetVertexAttribPointerv, + glGetVertexAttribdv, + glGetVertexAttribfv, + glGetVertexAttribiv, + glHint, + glIsBuffer, + glIsEnabled, + glIsEnabledi, + glIsFramebuffer, + glIsProgram, + glIsQuery, + glIsRenderbuffer, + glIsShader, + glIsTexture, + glIsVertexArray, + glLineWidth, + glLinkProgram, + glLogicOp, + glMapBuffer, + glMapBufferRange, + glMultiDrawArrays, + glMultiDrawElements, + glPixelStoref, + glPixelStorei, + glPointParameterf, + glPointParameterfv, + glPointParameteri, + glPointParameteriv, + glPointSize, + glPolygonMode, + glPolygonOffset, + glPrimitiveRestartIndex, + glReadBuffer, + glReadPixels, + glRenderbufferStorage, + glRenderbufferStorageMultisample, + glSampleCoverage, + glScissor, + glShaderSource, + glStencilFunc, + glStencilFuncSeparate, + glStencilMask, + glStencilMaskSeparate, + glStencilOp, + glStencilOpSeparate, + glTexBuffer, + glTexImage1D, + glTexImage2D, + glTexImage3D, + glTexParameterIiv, + glTexParameterIuiv, + glTexParameterf, + glTexParameterfv, + glTexParameteri, + glTexParameteriv, + glTexSubImage1D, + glTexSubImage2D, + glTexSubImage3D, + glTransformFeedbackVaryings, + glUniform1f, + glUniform1fv, + glUniform1i, + glUniform1iv, + glUniform1ui, + glUniform1uiv, + glUniform2f, + glUniform2fv, + glUniform2i, + glUniform2iv, + glUniform2ui, + glUniform2uiv, + glUniform3f, + glUniform3fv, + glUniform3i, + glUniform3iv, + glUniform3ui, + glUniform3uiv, + glUniform4f, + glUniform4fv, + glUniform4i, + glUniform4iv, + glUniform4ui, + glUniform4uiv, + glUniformBlockBinding, + glUniformMatrix2fv, + glUniformMatrix2x3fv, + glUniformMatrix2x4fv, + glUniformMatrix3fv, + glUniformMatrix3x2fv, + glUniformMatrix3x4fv, + glUniformMatrix4fv, + glUniformMatrix4x2fv, + glUniformMatrix4x3fv, + glUnmapBuffer, + glUseProgram, + glValidateProgram, + glVertexAttrib1d, + glVertexAttrib1dv, + glVertexAttrib1f, + glVertexAttrib1fv, + glVertexAttrib1s, + glVertexAttrib1sv, + glVertexAttrib2d, + glVertexAttrib2dv, + glVertexAttrib2f, + glVertexAttrib2fv, + glVertexAttrib2s, + glVertexAttrib2sv, + glVertexAttrib3d, + glVertexAttrib3dv, + glVertexAttrib3f, + glVertexAttrib3fv, + glVertexAttrib3s, + glVertexAttrib3sv, + glVertexAttrib4Nbv, + glVertexAttrib4Niv, + glVertexAttrib4Nsv, + glVertexAttrib4Nub, + glVertexAttrib4Nubv, + glVertexAttrib4Nuiv, + glVertexAttrib4Nusv, + glVertexAttrib4bv, + glVertexAttrib4d, + glVertexAttrib4dv, + glVertexAttrib4f, + glVertexAttrib4fv, + glVertexAttrib4iv, + glVertexAttrib4s, + glVertexAttrib4sv, + glVertexAttrib4ubv, + glVertexAttrib4uiv, + glVertexAttrib4usv, + glVertexAttribI1i, + glVertexAttribI1iv, + glVertexAttribI1ui, + glVertexAttribI1uiv, + glVertexAttribI2i, + glVertexAttribI2iv, + glVertexAttribI2ui, + glVertexAttribI2uiv, + glVertexAttribI3i, + glVertexAttribI3iv, + glVertexAttribI3ui, + glVertexAttribI3uiv, + glVertexAttribI4bv, + glVertexAttribI4i, + glVertexAttribI4iv, + glVertexAttribI4sv, + glVertexAttribI4ubv, + glVertexAttribI4ui, + glVertexAttribI4uiv, + glVertexAttribI4usv, + glVertexAttribIPointer, + glVertexAttribPointer, + glViewport +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31.Types +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "OpenGL 3.1" + +EXTENSION_ENTRY(glActiveTexture,GLenum -> IO ()) +EXTENSION_ENTRY(glAttachShader,GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glBeginConditionalRender,GLuint -> GLenum -> IO ()) +EXTENSION_ENTRY(glBeginQuery,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glBeginTransformFeedback,GLenum -> IO ()) +EXTENSION_ENTRY(glBindAttribLocation,GLuint -> GLuint -> Ptr GLchar -> IO ()) +EXTENSION_ENTRY(glBindBuffer,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glBindBufferBase,GLenum -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glBindBufferRange,GLenum -> GLuint -> GLuint -> GLintptr -> GLsizeiptr -> IO ()) +EXTENSION_ENTRY(glBindFragDataLocation,GLuint -> GLuint -> Ptr GLchar -> IO ()) +EXTENSION_ENTRY(glBindFramebuffer,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glBindRenderbuffer,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glBindTexture,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glBindVertexArray,GLuint -> IO ()) +EXTENSION_ENTRY(glBlendColor,GLclampf -> GLclampf -> GLclampf -> GLclampf -> IO ()) +EXTENSION_ENTRY(glBlendEquation,GLenum -> IO ()) +EXTENSION_ENTRY(glBlendEquationSeparate,GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glBlendFunc,GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glBlendFuncSeparate,GLenum -> GLenum -> GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glBlitFramebuffer,GLint -> GLint -> GLint -> GLint -> GLint -> GLint -> GLint -> GLint -> GLbitfield -> GLenum -> IO ()) +EXTENSION_ENTRY(glBufferData,GLenum -> GLsizeiptr -> Ptr a -> GLenum -> IO ()) +EXTENSION_ENTRY(glBufferSubData,GLenum -> GLintptr -> GLsizeiptr -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCheckFramebufferStatus,GLenum -> IO GLenum) +EXTENSION_ENTRY(glClampColor,GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glClear,GLbitfield -> IO ()) +EXTENSION_ENTRY(glClearBufferfi,GLenum -> GLint -> GLfloat -> GLint -> IO ()) +EXTENSION_ENTRY(glClearBufferfv,GLenum -> GLint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glClearBufferiv,GLenum -> GLint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glClearBufferuiv,GLenum -> GLint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glClearColor,GLclampf -> GLclampf -> GLclampf -> GLclampf -> IO ()) +EXTENSION_ENTRY(glClearDepth,GLclampd -> IO ()) +EXTENSION_ENTRY(glClearStencil,GLint -> IO ()) +EXTENSION_ENTRY(glColorMask,GLboolean -> GLboolean -> GLboolean -> GLboolean -> IO ()) +EXTENSION_ENTRY(glColorMaski,GLuint -> GLboolean -> GLboolean -> GLboolean -> GLboolean -> IO ()) +EXTENSION_ENTRY(glCompileShader,GLuint -> IO ()) +EXTENSION_ENTRY(glCompressedTexImage1D,GLenum -> GLint -> GLenum -> GLsizei -> GLint -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedTexImage2D,GLenum -> GLint -> GLenum -> GLsizei -> GLsizei -> GLint -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedTexImage3D,GLenum -> GLint -> GLenum -> GLsizei -> GLsizei -> GLsizei -> GLint -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedTexSubImage1D,GLenum -> GLint -> GLint -> GLsizei -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedTexSubImage2D,GLenum -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedTexSubImage3D,GLenum -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCopyBufferSubData,GLenum -> GLenum -> GLintptr -> GLintptr -> GLsizeiptr -> IO ()) +EXTENSION_ENTRY(glCopyTexImage1D,GLenum -> GLint -> GLenum -> GLint -> GLint -> GLsizei -> GLint -> IO ()) +EXTENSION_ENTRY(glCopyTexImage2D,GLenum -> GLint -> GLenum -> GLint -> GLint -> GLsizei -> GLsizei -> GLint -> IO ()) +EXTENSION_ENTRY(glCopyTexSubImage1D,GLenum -> GLint -> GLint -> GLint -> GLint -> GLsizei -> IO ()) +EXTENSION_ENTRY(glCopyTexSubImage2D,GLenum -> GLint -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glCopyTexSubImage3D,GLenum -> GLint -> GLint -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glCreateProgram,IO GLuint) +EXTENSION_ENTRY(glCreateShader,GLenum -> IO GLuint) +EXTENSION_ENTRY(glCullFace,GLenum -> IO ()) +EXTENSION_ENTRY(glDeleteBuffers,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glDeleteFramebuffers,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glDeleteProgram,GLuint -> IO ()) +EXTENSION_ENTRY(glDeleteQueries,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glDeleteRenderbuffers,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glDeleteShader,GLuint -> IO ()) +EXTENSION_ENTRY(glDeleteTextures,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glDeleteVertexArrays,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glDepthFunc,GLenum -> IO ()) +EXTENSION_ENTRY(glDepthMask,GLboolean -> IO ()) +EXTENSION_ENTRY(glDepthRange,GLclampd -> GLclampd -> IO ()) +EXTENSION_ENTRY(glDetachShader,GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glDisable,GLenum -> IO ()) +EXTENSION_ENTRY(glDisableVertexAttribArray,GLuint -> IO ()) +EXTENSION_ENTRY(glDisablei,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glDrawArrays,GLenum -> GLint -> GLsizei -> IO ()) +EXTENSION_ENTRY(glDrawArraysInstanced,GLenum -> GLint -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glDrawBuffer,GLenum -> IO ()) +EXTENSION_ENTRY(glDrawBuffers,GLsizei -> Ptr GLenum -> IO ()) +EXTENSION_ENTRY(glDrawElements,GLenum -> GLsizei -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glDrawElementsInstanced,GLenum -> GLsizei -> GLenum -> Ptr a -> GLsizei -> IO ()) +EXTENSION_ENTRY(glDrawRangeElements,GLenum -> GLuint -> GLuint -> GLsizei -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glEnable,GLenum -> IO ()) +EXTENSION_ENTRY(glEnableVertexAttribArray,GLuint -> IO ()) +EXTENSION_ENTRY(glEnablei,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glEndConditionalRender,IO ()) +EXTENSION_ENTRY(glEndQuery,GLenum -> IO ()) +EXTENSION_ENTRY(glEndTransformFeedback,IO ()) +EXTENSION_ENTRY(glFinish,IO ()) +EXTENSION_ENTRY(glFlush,IO ()) +EXTENSION_ENTRY(glFlushMappedBufferRange,GLenum -> GLintptr -> GLsizeiptr -> IO ()) +EXTENSION_ENTRY(glFramebufferRenderbuffer,GLenum -> GLenum -> GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glFramebufferTexture1D,GLenum -> GLenum -> GLenum -> GLuint -> GLint -> IO ()) +EXTENSION_ENTRY(glFramebufferTexture2D,GLenum -> GLenum -> GLenum -> GLuint -> GLint -> IO ()) +EXTENSION_ENTRY(glFramebufferTexture3D,GLenum -> GLenum -> GLenum -> GLuint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glFramebufferTextureLayer,GLenum -> GLenum -> GLuint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glFrontFace,GLenum -> IO ()) +EXTENSION_ENTRY(glGenBuffers,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGenFramebuffers,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGenQueries,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGenRenderbuffers,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGenTextures,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGenVertexArrays,GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGenerateMipmap,GLenum -> IO ()) +EXTENSION_ENTRY(glGetActiveAttrib,GLuint -> GLuint -> GLsizei -> Ptr GLsizei -> Ptr GLint -> Ptr GLenum -> Ptr GLchar -> IO ()) +EXTENSION_ENTRY(glGetActiveUniform,GLuint -> GLuint -> GLsizei -> Ptr GLsizei -> Ptr GLint -> Ptr GLenum -> Ptr GLchar -> IO ()) +EXTENSION_ENTRY(glGetActiveUniformBlockName,GLuint -> GLuint -> GLsizei -> Ptr GLsizei -> Ptr GLchar -> IO ()) +EXTENSION_ENTRY(glGetActiveUniformBlockiv,GLuint -> GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetActiveUniformName,GLuint -> GLuint -> GLsizei -> Ptr GLsizei -> Ptr GLchar -> IO ()) +EXTENSION_ENTRY(glGetActiveUniformsiv,GLuint -> GLsizei -> Ptr GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetAttachedShaders,GLuint -> GLsizei -> Ptr GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGetAttribLocation,GLuint -> Ptr GLchar -> IO GLint) +EXTENSION_ENTRY(glGetBooleani_v,GLenum -> GLuint -> Ptr GLboolean -> IO ()) +EXTENSION_ENTRY(glGetBooleanv,GLenum -> Ptr GLboolean -> IO ()) +EXTENSION_ENTRY(glGetBufferParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetBufferPointerv,GLenum -> GLenum -> Ptr (Ptr a) -> IO ()) +EXTENSION_ENTRY(glGetBufferSubData,GLenum -> GLintptr -> GLsizeiptr -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetCompressedTexImage,GLenum -> GLint -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetDoublev,GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glGetError,IO GLenum) +EXTENSION_ENTRY(glGetFloatv,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetFragDataLocation,GLuint -> Ptr GLchar -> IO GLint) +EXTENSION_ENTRY(glGetFramebufferAttachmentParameteriv,GLenum -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetIntegeri_v,GLenum -> GLuint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetIntegerv,GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetPointerv,GLenum -> Ptr (Ptr a) -> IO ()) +EXTENSION_ENTRY(glGetProgramInfoLog,GLuint -> GLsizei -> Ptr GLsizei -> Ptr GLchar -> IO ()) +EXTENSION_ENTRY(glGetProgramiv,GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetQueryObjectiv,GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetQueryObjectuiv,GLuint -> GLenum -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGetQueryiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetRenderbufferParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetShaderInfoLog,GLuint -> GLsizei -> Ptr GLsizei -> Ptr GLchar -> IO ()) +EXTENSION_ENTRY(glGetShaderSource,GLuint -> GLsizei -> Ptr GLsizei -> Ptr GLchar -> IO ()) +EXTENSION_ENTRY(glGetShaderiv,GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetString,GLenum -> IO (Ptr GLubyte)) +EXTENSION_ENTRY(glGetStringi,GLenum -> GLuint -> IO (Ptr GLubyte)) +EXTENSION_ENTRY(glGetTexImage,GLenum -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetTexLevelParameterfv,GLenum -> GLint -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetTexLevelParameteriv,GLenum -> GLint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetTexParameterIiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetTexParameterIuiv,GLenum -> GLenum -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGetTexParameterfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetTexParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetTransformFeedbackVarying,GLuint -> GLuint -> GLsizei -> Ptr GLsizei -> Ptr GLsizei -> Ptr GLenum -> Ptr GLchar -> IO ()) +EXTENSION_ENTRY(glGetUniformBlockIndex,GLuint -> Ptr GLchar -> IO GLuint) +EXTENSION_ENTRY(glGetUniformIndices,GLuint -> GLsizei -> Ptr (Ptr GLchar) -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGetUniformLocation,GLuint -> Ptr GLchar -> IO GLint) +EXTENSION_ENTRY(glGetUniformfv,GLuint -> GLint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetUniformiv,GLuint -> GLint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetUniformuiv,GLuint -> GLint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGetVertexAttribIiv,GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetVertexAttribIuiv,GLuint -> GLenum -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGetVertexAttribPointerv,GLuint -> GLenum -> Ptr (Ptr a) -> IO ()) +EXTENSION_ENTRY(glGetVertexAttribdv,GLuint -> GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glGetVertexAttribfv,GLuint -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetVertexAttribiv,GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glHint,GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glIsBuffer,GLuint -> IO GLboolean) +EXTENSION_ENTRY(glIsEnabled,GLenum -> IO GLboolean) +EXTENSION_ENTRY(glIsEnabledi,GLenum -> GLuint -> IO GLboolean) +EXTENSION_ENTRY(glIsFramebuffer,GLuint -> IO GLboolean) +EXTENSION_ENTRY(glIsProgram,GLuint -> IO GLboolean) +EXTENSION_ENTRY(glIsQuery,GLuint -> IO GLboolean) +EXTENSION_ENTRY(glIsRenderbuffer,GLuint -> IO GLboolean) +EXTENSION_ENTRY(glIsShader,GLuint -> IO GLboolean) +EXTENSION_ENTRY(glIsTexture,GLuint -> IO GLboolean) +EXTENSION_ENTRY(glIsVertexArray,GLuint -> IO GLboolean) +EXTENSION_ENTRY(glLineWidth,GLfloat -> IO ()) +EXTENSION_ENTRY(glLinkProgram,GLuint -> IO ()) +EXTENSION_ENTRY(glLogicOp,GLenum -> IO ()) +EXTENSION_ENTRY(glMapBuffer,GLenum -> GLenum -> IO (Ptr a)) +EXTENSION_ENTRY(glMapBufferRange,GLenum -> GLintptr -> GLsizeiptr -> GLbitfield -> IO (Ptr a)) +EXTENSION_ENTRY(glMultiDrawArrays,GLenum -> Ptr GLint -> Ptr GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glMultiDrawElements,GLenum -> Ptr GLsizei -> GLenum -> Ptr (Ptr a) -> GLsizei -> IO ()) +EXTENSION_ENTRY(glPixelStoref,GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glPixelStorei,GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glPointParameterf,GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glPointParameterfv,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glPointParameteri,GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glPointParameteriv,GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glPointSize,GLfloat -> IO ()) +EXTENSION_ENTRY(glPolygonMode,GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glPolygonOffset,GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glPrimitiveRestartIndex,GLuint -> IO ()) +EXTENSION_ENTRY(glReadBuffer,GLenum -> IO ()) +EXTENSION_ENTRY(glReadPixels,GLint -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glRenderbufferStorage,GLenum -> GLenum -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glRenderbufferStorageMultisample,GLenum -> GLsizei -> GLenum -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glSampleCoverage,GLclampf -> GLboolean -> IO ()) +EXTENSION_ENTRY(glScissor,GLint -> GLint -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glShaderSource,GLuint -> GLsizei -> Ptr (Ptr GLchar) -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glStencilFunc,GLenum -> GLint -> GLuint -> IO ()) +EXTENSION_ENTRY(glStencilFuncSeparate,GLenum -> GLenum -> GLint -> GLuint -> IO ()) +EXTENSION_ENTRY(glStencilMask,GLuint -> IO ()) +EXTENSION_ENTRY(glStencilMaskSeparate,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glStencilOp,GLenum -> GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glStencilOpSeparate,GLenum -> GLenum -> GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glTexBuffer,GLenum -> GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glTexImage1D,GLenum -> GLint -> GLint -> GLsizei -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glTexImage2D,GLenum -> GLint -> GLint -> GLsizei -> GLsizei -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glTexImage3D,GLenum -> GLint -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glTexParameterIiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTexParameterIuiv,GLenum -> GLenum -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glTexParameterf,GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glTexParameterfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glTexParameteri,GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glTexParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTexSubImage1D,GLenum -> GLint -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glTexSubImage2D,GLenum -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glTexSubImage3D,GLenum -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glTransformFeedbackVaryings,GLuint -> GLsizei -> Ptr (Ptr GLchar) -> GLenum -> IO ()) +EXTENSION_ENTRY(glUniform1f,GLint -> GLfloat -> IO ()) +EXTENSION_ENTRY(glUniform1fv,GLint -> GLsizei -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniform1i,GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glUniform1iv,GLint -> GLsizei -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glUniform1ui,GLint -> GLuint -> IO ()) +EXTENSION_ENTRY(glUniform1uiv,GLint -> GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glUniform2f,GLint -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glUniform2fv,GLint -> GLsizei -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniform2i,GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glUniform2iv,GLint -> GLsizei -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glUniform2ui,GLint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glUniform2uiv,GLint -> GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glUniform3f,GLint -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glUniform3fv,GLint -> GLsizei -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniform3i,GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glUniform3iv,GLint -> GLsizei -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glUniform3ui,GLint -> GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glUniform3uiv,GLint -> GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glUniform4f,GLint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glUniform4fv,GLint -> GLsizei -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniform4i,GLint -> GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glUniform4iv,GLint -> GLsizei -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glUniform4ui,GLint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glUniform4uiv,GLint -> GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glUniformBlockBinding,GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glUniformMatrix2fv,GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniformMatrix2x3fv,GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniformMatrix2x4fv,GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniformMatrix3fv,GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniformMatrix3x2fv,GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniformMatrix3x4fv,GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniformMatrix4fv,GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniformMatrix4x2fv,GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUniformMatrix4x3fv,GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glUnmapBuffer,GLenum -> IO GLboolean) +EXTENSION_ENTRY(glUseProgram,GLuint -> IO ()) +EXTENSION_ENTRY(glValidateProgram,GLuint -> IO ()) +EXTENSION_ENTRY(glVertexAttrib1d,GLuint -> GLdouble -> IO ()) +EXTENSION_ENTRY(glVertexAttrib1dv,GLuint -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glVertexAttrib1f,GLuint -> GLfloat -> IO ()) +EXTENSION_ENTRY(glVertexAttrib1fv,GLuint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glVertexAttrib1s,GLuint -> GLshort -> IO ()) +EXTENSION_ENTRY(glVertexAttrib1sv,GLuint -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glVertexAttrib2d,GLuint -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glVertexAttrib2dv,GLuint -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glVertexAttrib2f,GLuint -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glVertexAttrib2fv,GLuint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glVertexAttrib2s,GLuint -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glVertexAttrib2sv,GLuint -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glVertexAttrib3d,GLuint -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glVertexAttrib3dv,GLuint -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glVertexAttrib3f,GLuint -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glVertexAttrib3fv,GLuint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glVertexAttrib3s,GLuint -> GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glVertexAttrib3sv,GLuint -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4Nbv,GLuint -> Ptr GLbyte -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4Niv,GLuint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4Nsv,GLuint -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4Nub,GLuint -> GLubyte -> GLubyte -> GLubyte -> GLubyte -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4Nubv,GLuint -> Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4Nuiv,GLuint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4Nusv,GLuint -> Ptr GLushort -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4bv,GLuint -> Ptr GLbyte -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4d,GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4dv,GLuint -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4f,GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4fv,GLuint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4iv,GLuint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4s,GLuint -> GLshort -> GLshort -> GLshort -> GLshort -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4sv,GLuint -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4ubv,GLuint -> Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4uiv,GLuint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glVertexAttrib4usv,GLuint -> Ptr GLushort -> IO ()) +EXTENSION_ENTRY(glVertexAttribI1i,GLuint -> GLint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI1iv,GLuint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI1ui,GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI1uiv,GLuint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI2i,GLuint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI2iv,GLuint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI2ui,GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI2uiv,GLuint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI3i,GLuint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI3iv,GLuint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI3ui,GLuint -> GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI3uiv,GLuint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI4bv,GLuint -> Ptr GLbyte -> IO ()) +EXTENSION_ENTRY(glVertexAttribI4i,GLuint -> GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI4iv,GLuint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI4sv,GLuint -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glVertexAttribI4ubv,GLuint -> Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glVertexAttribI4ui,GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI4uiv,GLuint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glVertexAttribI4usv,GLuint -> Ptr GLushort -> IO ()) +EXTENSION_ENTRY(glVertexAttribIPointer,GLuint -> GLint -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glVertexAttribPointer,GLuint -> GLint -> GLenum -> GLboolean -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glViewport,GLint -> GLint -> GLsizei -> GLsizei -> IO ()) diff --git a/src/Graphics/Rendering/OpenGL/Raw/Core31/Tokens.hs b/src/Graphics/Rendering/OpenGL/Raw/Core31/Tokens.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/Core31/Tokens.hs @@ -0,0 +1,2178 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.Core31.Tokens +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All tokens from the OpenGL 3.1 core, see . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.Core31.Tokens where + +import Graphics.Rendering.OpenGL.Raw.Core31.Types + +gl_ACTIVE_ATTRIBUTES :: GLenum +gl_ACTIVE_ATTRIBUTES = 0x8B89 + +gl_ACTIVE_ATTRIBUTE_MAX_LENGTH :: GLenum +gl_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A + +gl_ACTIVE_TEXTURE :: GLenum +gl_ACTIVE_TEXTURE = 0x84E0 + +gl_ACTIVE_UNIFORMS :: GLenum +gl_ACTIVE_UNIFORMS = 0x8B86 + +gl_ACTIVE_UNIFORM_BLOCKS :: GLenum +gl_ACTIVE_UNIFORM_BLOCKS = 0x8A36 + +gl_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH :: GLenum +gl_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 + +gl_ACTIVE_UNIFORM_MAX_LENGTH :: GLenum +gl_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 + +gl_ALIASED_LINE_WIDTH_RANGE :: GLenum +gl_ALIASED_LINE_WIDTH_RANGE = 0x846E + +gl_ALPHA :: GLenum +gl_ALPHA = 0x1906 + +gl_ALWAYS :: GLenum +gl_ALWAYS = 0x0207 + +gl_AND :: GLenum +gl_AND = 0x1501 + +gl_AND_INVERTED :: GLenum +gl_AND_INVERTED = 0x1504 + +gl_AND_REVERSE :: GLenum +gl_AND_REVERSE = 0x1502 + +gl_ARRAY_BUFFER :: GLenum +gl_ARRAY_BUFFER = 0x8892 + +gl_ARRAY_BUFFER_BINDING :: GLenum +gl_ARRAY_BUFFER_BINDING = 0x8894 + +gl_ATTACHED_SHADERS :: GLenum +gl_ATTACHED_SHADERS = 0x8B85 + +gl_BACK :: GLenum +gl_BACK = 0x0405 + +gl_BACK_LEFT :: GLenum +gl_BACK_LEFT = 0x0402 + +gl_BACK_RIGHT :: GLenum +gl_BACK_RIGHT = 0x0403 + +gl_BGR :: GLenum +gl_BGR = 0x80E0 + +gl_BGRA :: GLenum +gl_BGRA = 0x80E1 + +gl_BGRA_INTEGER :: GLenum +gl_BGRA_INTEGER = 0x8D9B + +gl_BGR_INTEGER :: GLenum +gl_BGR_INTEGER = 0x8D9A + +gl_BLEND :: GLenum +gl_BLEND = 0x0BE2 + +gl_BLEND_COLOR :: GLenum +gl_BLEND_COLOR = 0x8005 + +gl_BLEND_DST :: GLenum +gl_BLEND_DST = 0x0BE0 + +gl_BLEND_DST_ALPHA :: GLenum +gl_BLEND_DST_ALPHA = 0x80CA + +gl_BLEND_DST_RGB :: GLenum +gl_BLEND_DST_RGB = 0x80C8 + +gl_BLEND_EQUATION :: GLenum +gl_BLEND_EQUATION = 0x8009 + +gl_BLEND_EQUATION_ALPHA :: GLenum +gl_BLEND_EQUATION_ALPHA = 0x883D + +gl_BLEND_EQUATION_RGB :: GLenum +gl_BLEND_EQUATION_RGB = 0x8009 + +gl_BLEND_SRC :: GLenum +gl_BLEND_SRC = 0x0BE1 + +gl_BLEND_SRC_ALPHA :: GLenum +gl_BLEND_SRC_ALPHA = 0x80CB + +gl_BLEND_SRC_RGB :: GLenum +gl_BLEND_SRC_RGB = 0x80C9 + +gl_BLUE :: GLenum +gl_BLUE = 0x1905 + +gl_BLUE_INTEGER :: GLenum +gl_BLUE_INTEGER = 0x8D96 + +gl_BOOL :: GLenum +gl_BOOL = 0x8B56 + +gl_BOOL_VEC2 :: GLenum +gl_BOOL_VEC2 = 0x8B57 + +gl_BOOL_VEC3 :: GLenum +gl_BOOL_VEC3 = 0x8B58 + +gl_BOOL_VEC4 :: GLenum +gl_BOOL_VEC4 = 0x8B59 + +gl_BUFFER_ACCESS :: GLenum +gl_BUFFER_ACCESS = 0x88BB + +gl_BUFFER_MAPPED :: GLenum +gl_BUFFER_MAPPED = 0x88BC + +gl_BUFFER_MAP_POINTER :: GLenum +gl_BUFFER_MAP_POINTER = 0x88BD + +gl_BUFFER_SIZE :: GLenum +gl_BUFFER_SIZE = 0x8764 + +gl_BUFFER_USAGE :: GLenum +gl_BUFFER_USAGE = 0x8765 + +gl_BYTE :: GLenum +gl_BYTE = 0x1400 + +gl_CCW :: GLenum +gl_CCW = 0x0901 + +gl_CLAMP_READ_COLOR :: GLenum +gl_CLAMP_READ_COLOR = 0x891C + +gl_CLAMP_TO_BORDER :: GLenum +gl_CLAMP_TO_BORDER = 0x812D + +gl_CLAMP_TO_EDGE :: GLenum +gl_CLAMP_TO_EDGE = 0x812F + +gl_CLEAR :: GLenum +gl_CLEAR = 0x1500 + +gl_CLIP_DISTANCE0 :: GLenum +gl_CLIP_DISTANCE0 = 0x3000 + +gl_CLIP_DISTANCE1 :: GLenum +gl_CLIP_DISTANCE1 = 0x3001 + +gl_CLIP_DISTANCE2 :: GLenum +gl_CLIP_DISTANCE2 = 0x3002 + +gl_CLIP_DISTANCE3 :: GLenum +gl_CLIP_DISTANCE3 = 0x3003 + +gl_CLIP_DISTANCE4 :: GLenum +gl_CLIP_DISTANCE4 = 0x3004 + +gl_CLIP_DISTANCE5 :: GLenum +gl_CLIP_DISTANCE5 = 0x3005 + +gl_COLOR :: GLenum +gl_COLOR = 0x1800 + +gl_COLOR_ATTACHMENT0 :: GLenum +gl_COLOR_ATTACHMENT0 = 0x8CE0 + +gl_COLOR_ATTACHMENT1 :: GLenum +gl_COLOR_ATTACHMENT1 = 0x8CE1 + +gl_COLOR_ATTACHMENT10 :: GLenum +gl_COLOR_ATTACHMENT10 = 0x8CEA + +gl_COLOR_ATTACHMENT11 :: GLenum +gl_COLOR_ATTACHMENT11 = 0x8CEB + +gl_COLOR_ATTACHMENT12 :: GLenum +gl_COLOR_ATTACHMENT12 = 0x8CEC + +gl_COLOR_ATTACHMENT13 :: GLenum +gl_COLOR_ATTACHMENT13 = 0x8CED + +gl_COLOR_ATTACHMENT14 :: GLenum +gl_COLOR_ATTACHMENT14 = 0x8CEE + +gl_COLOR_ATTACHMENT15 :: GLenum +gl_COLOR_ATTACHMENT15 = 0x8CEF + +gl_COLOR_ATTACHMENT2 :: GLenum +gl_COLOR_ATTACHMENT2 = 0x8CE2 + +gl_COLOR_ATTACHMENT3 :: GLenum +gl_COLOR_ATTACHMENT3 = 0x8CE3 + +gl_COLOR_ATTACHMENT4 :: GLenum +gl_COLOR_ATTACHMENT4 = 0x8CE4 + +gl_COLOR_ATTACHMENT5 :: GLenum +gl_COLOR_ATTACHMENT5 = 0x8CE5 + +gl_COLOR_ATTACHMENT6 :: GLenum +gl_COLOR_ATTACHMENT6 = 0x8CE6 + +gl_COLOR_ATTACHMENT7 :: GLenum +gl_COLOR_ATTACHMENT7 = 0x8CE7 + +gl_COLOR_ATTACHMENT8 :: GLenum +gl_COLOR_ATTACHMENT8 = 0x8CE8 + +gl_COLOR_ATTACHMENT9 :: GLenum +gl_COLOR_ATTACHMENT9 = 0x8CE9 + +gl_COLOR_BUFFER_BIT :: GLenum +gl_COLOR_BUFFER_BIT = 0x00004000 + +gl_COLOR_CLEAR_VALUE :: GLenum +gl_COLOR_CLEAR_VALUE = 0x0C22 + +gl_COLOR_LOGIC_OP :: GLenum +gl_COLOR_LOGIC_OP = 0x0BF2 + +gl_COLOR_WRITEMASK :: GLenum +gl_COLOR_WRITEMASK = 0x0C23 + +gl_COMPARE_REF_TO_TEXTURE :: GLenum +gl_COMPARE_REF_TO_TEXTURE = 0x884E + +gl_COMPILE_STATUS :: GLenum +gl_COMPILE_STATUS = 0x8B81 + +gl_COMPRESSED_RED :: GLenum +gl_COMPRESSED_RED = 0x8225 + +gl_COMPRESSED_RED_RGTC1 :: GLenum +gl_COMPRESSED_RED_RGTC1 = 0x8DBB + +gl_COMPRESSED_RG :: GLenum +gl_COMPRESSED_RG = 0x8226 + +gl_COMPRESSED_RGB :: GLenum +gl_COMPRESSED_RGB = 0x84ED + +gl_COMPRESSED_RGBA :: GLenum +gl_COMPRESSED_RGBA = 0x84EE + +gl_COMPRESSED_RG_RGTC2 :: GLenum +gl_COMPRESSED_RG_RGTC2 = 0x8DBD + +gl_COMPRESSED_SIGNED_RED_RGTC1 :: GLenum +gl_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC + +gl_COMPRESSED_SIGNED_RG_RGTC2 :: GLenum +gl_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE + +gl_COMPRESSED_SRGB :: GLenum +gl_COMPRESSED_SRGB = 0x8C48 + +gl_COMPRESSED_SRGB_ALPHA :: GLenum +gl_COMPRESSED_SRGB_ALPHA = 0x8C49 + +gl_COMPRESSED_TEXTURE_FORMATS :: GLenum +gl_COMPRESSED_TEXTURE_FORMATS = 0x86A3 + +gl_CONSTANT_ALPHA :: GLenum +gl_CONSTANT_ALPHA = 0x8003 + +gl_CONSTANT_COLOR :: GLenum +gl_CONSTANT_COLOR = 0x8001 + +gl_CONTEXT_FLAGS :: GLenum +gl_CONTEXT_FLAGS = 0x821E + +gl_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT :: GLenum +gl_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x0001 + +gl_COPY :: GLenum +gl_COPY = 0x1503 + +gl_COPY_INVERTED :: GLenum +gl_COPY_INVERTED = 0x150C + +gl_COPY_READ_BUFFER :: GLenum +gl_COPY_READ_BUFFER = 0x8F36 + +gl_COPY_WRITE_BUFFER :: GLenum +gl_COPY_WRITE_BUFFER = 0x8F37 + +gl_CULL_FACE :: GLenum +gl_CULL_FACE = 0x0B44 + +gl_CULL_FACE_MODE :: GLenum +gl_CULL_FACE_MODE = 0x0B45 + +gl_CURRENT_PROGRAM :: GLenum +gl_CURRENT_PROGRAM = 0x8B8D + +gl_CURRENT_QUERY :: GLenum +gl_CURRENT_QUERY = 0x8865 + +gl_CURRENT_VERTEX_ATTRIB :: GLenum +gl_CURRENT_VERTEX_ATTRIB = 0x8626 + +gl_CW :: GLenum +gl_CW = 0x0900 + +gl_DECR :: GLenum +gl_DECR = 0x1E03 + +gl_DECR_WRAP :: GLenum +gl_DECR_WRAP = 0x8508 + +gl_DELETE_STATUS :: GLenum +gl_DELETE_STATUS = 0x8B80 + +gl_DEPTH :: GLenum +gl_DEPTH = 0x1801 + +gl_DEPTH24_STENCIL8 :: GLenum +gl_DEPTH24_STENCIL8 = 0x88F0 + +gl_DEPTH32F_STENCIL8 :: GLenum +gl_DEPTH32F_STENCIL8 = 0x8CAD + +gl_DEPTH_ATTACHMENT :: GLenum +gl_DEPTH_ATTACHMENT = 0x8D00 + +gl_DEPTH_BUFFER :: GLenum +gl_DEPTH_BUFFER = 0x8223 + +gl_DEPTH_BUFFER_BIT :: GLenum +gl_DEPTH_BUFFER_BIT = 0x00000100 + +gl_DEPTH_CLEAR_VALUE :: GLenum +gl_DEPTH_CLEAR_VALUE = 0x0B73 + +gl_DEPTH_COMPONENT :: GLenum +gl_DEPTH_COMPONENT = 0x1902 + +gl_DEPTH_COMPONENT16 :: GLenum +gl_DEPTH_COMPONENT16 = 0x81A5 + +gl_DEPTH_COMPONENT24 :: GLenum +gl_DEPTH_COMPONENT24 = 0x81A6 + +gl_DEPTH_COMPONENT32 :: GLenum +gl_DEPTH_COMPONENT32 = 0x81A7 + +gl_DEPTH_COMPONENT32F :: GLenum +gl_DEPTH_COMPONENT32F = 0x8CAC + +gl_DEPTH_FUNC :: GLenum +gl_DEPTH_FUNC = 0x0B74 + +gl_DEPTH_RANGE :: GLenum +gl_DEPTH_RANGE = 0x0B70 + +gl_DEPTH_STENCIL :: GLenum +gl_DEPTH_STENCIL = 0x84F9 + +gl_DEPTH_STENCIL_ATTACHMENT :: GLenum +gl_DEPTH_STENCIL_ATTACHMENT = 0x821A + +gl_DEPTH_TEST :: GLenum +gl_DEPTH_TEST = 0x0B71 + +gl_DEPTH_WRITEMASK :: GLenum +gl_DEPTH_WRITEMASK = 0x0B72 + +gl_DITHER :: GLenum +gl_DITHER = 0x0BD0 + +gl_DONT_CARE :: GLenum +gl_DONT_CARE = 0x1100 + +gl_DOUBLE :: GLenum +gl_DOUBLE = 0x140A + +gl_DOUBLEBUFFER :: GLenum +gl_DOUBLEBUFFER = 0x0C32 + +gl_DRAW_BUFFER :: GLenum +gl_DRAW_BUFFER = 0x0C01 + +gl_DRAW_BUFFER0 :: GLenum +gl_DRAW_BUFFER0 = 0x8825 + +gl_DRAW_BUFFER1 :: GLenum +gl_DRAW_BUFFER1 = 0x8826 + +gl_DRAW_BUFFER10 :: GLenum +gl_DRAW_BUFFER10 = 0x882F + +gl_DRAW_BUFFER11 :: GLenum +gl_DRAW_BUFFER11 = 0x8830 + +gl_DRAW_BUFFER12 :: GLenum +gl_DRAW_BUFFER12 = 0x8831 + +gl_DRAW_BUFFER13 :: GLenum +gl_DRAW_BUFFER13 = 0x8832 + +gl_DRAW_BUFFER14 :: GLenum +gl_DRAW_BUFFER14 = 0x8833 + +gl_DRAW_BUFFER15 :: GLenum +gl_DRAW_BUFFER15 = 0x8834 + +gl_DRAW_BUFFER2 :: GLenum +gl_DRAW_BUFFER2 = 0x8827 + +gl_DRAW_BUFFER3 :: GLenum +gl_DRAW_BUFFER3 = 0x8828 + +gl_DRAW_BUFFER4 :: GLenum +gl_DRAW_BUFFER4 = 0x8829 + +gl_DRAW_BUFFER5 :: GLenum +gl_DRAW_BUFFER5 = 0x882A + +gl_DRAW_BUFFER6 :: GLenum +gl_DRAW_BUFFER6 = 0x882B + +gl_DRAW_BUFFER7 :: GLenum +gl_DRAW_BUFFER7 = 0x882C + +gl_DRAW_BUFFER8 :: GLenum +gl_DRAW_BUFFER8 = 0x882D + +gl_DRAW_BUFFER9 :: GLenum +gl_DRAW_BUFFER9 = 0x882E + +gl_DRAW_FRAMEBUFFER :: GLenum +gl_DRAW_FRAMEBUFFER = 0x8CA9 + +gl_DRAW_FRAMEBUFFER_BINDING :: GLenum +gl_DRAW_FRAMEBUFFER_BINDING = gl_FRAMEBUFFER_BINDING + +gl_DST_ALPHA :: GLenum +gl_DST_ALPHA = 0x0304 + +gl_DST_COLOR :: GLenum +gl_DST_COLOR = 0x0306 + +gl_DYNAMIC_COPY :: GLenum +gl_DYNAMIC_COPY = 0x88EA + +gl_DYNAMIC_DRAW :: GLenum +gl_DYNAMIC_DRAW = 0x88E8 + +gl_DYNAMIC_READ :: GLenum +gl_DYNAMIC_READ = 0x88E9 + +gl_ELEMENT_ARRAY_BUFFER :: GLenum +gl_ELEMENT_ARRAY_BUFFER = 0x8893 + +gl_ELEMENT_ARRAY_BUFFER_BINDING :: GLenum +gl_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 + +gl_EQUAL :: GLenum +gl_EQUAL = 0x0202 + +gl_EQUIV :: GLenum +gl_EQUIV = 0x1509 + +gl_EXTENSIONS :: GLenum +gl_EXTENSIONS = 0x1F03 + +gl_FALSE :: GLenum +gl_FALSE = 0 + +gl_FASTEST :: GLenum +gl_FASTEST = 0x1101 + +gl_FILL :: GLenum +gl_FILL = 0x1B02 + +gl_FIXED_ONLY :: GLenum +gl_FIXED_ONLY = 0x891D + +gl_FLOAT :: GLenum +gl_FLOAT = 0x1406 + +gl_FLOAT_32_UNSIGNED_INT_24_8_REV :: GLenum +gl_FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD + +gl_FLOAT_MAT2 :: GLenum +gl_FLOAT_MAT2 = 0x8B5A + +gl_FLOAT_MAT2x3 :: GLenum +gl_FLOAT_MAT2x3 = 0x8B65 + +gl_FLOAT_MAT2x4 :: GLenum +gl_FLOAT_MAT2x4 = 0x8B66 + +gl_FLOAT_MAT3 :: GLenum +gl_FLOAT_MAT3 = 0x8B5B + +gl_FLOAT_MAT3x2 :: GLenum +gl_FLOAT_MAT3x2 = 0x8B67 + +gl_FLOAT_MAT3x4 :: GLenum +gl_FLOAT_MAT3x4 = 0x8B68 + +gl_FLOAT_MAT4 :: GLenum +gl_FLOAT_MAT4 = 0x8B5C + +gl_FLOAT_MAT4x2 :: GLenum +gl_FLOAT_MAT4x2 = 0x8B69 + +gl_FLOAT_MAT4x3 :: GLenum +gl_FLOAT_MAT4x3 = 0x8B6A + +gl_FLOAT_VEC2 :: GLenum +gl_FLOAT_VEC2 = 0x8B50 + +gl_FLOAT_VEC3 :: GLenum +gl_FLOAT_VEC3 = 0x8B51 + +gl_FLOAT_VEC4 :: GLenum +gl_FLOAT_VEC4 = 0x8B52 + +gl_FRAGMENT_SHADER :: GLenum +gl_FRAGMENT_SHADER = 0x8B30 + +gl_FRAGMENT_SHADER_DERIVATIVE_HINT :: GLenum +gl_FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B + +gl_FRAMEBUFFER :: GLenum +gl_FRAMEBUFFER = 0x8D40 + +gl_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 + +gl_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 + +gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 + +gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 + +gl_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 + +gl_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 + +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 + +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 + +gl_FRAMEBUFFER_ATTACHMENT_RED_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 + +gl_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 + +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 + +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 + +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 + +gl_FRAMEBUFFER_BINDING :: GLenum +gl_FRAMEBUFFER_BINDING = 0x8CA6 + +gl_FRAMEBUFFER_COMPLETE :: GLenum +gl_FRAMEBUFFER_COMPLETE = 0x8CD5 + +gl_FRAMEBUFFER_DEFAULT :: GLenum +gl_FRAMEBUFFER_DEFAULT = 0x8218 + +gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 + +gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB + +gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 + +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 + +gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC + +gl_FRAMEBUFFER_SRGB :: GLenum +gl_FRAMEBUFFER_SRGB = 0x8DB9 + +gl_FRAMEBUFFER_UNDEFINED :: GLenum +gl_FRAMEBUFFER_UNDEFINED = 0x8219 + +gl_FRAMEBUFFER_UNSUPPORTED :: GLenum +gl_FRAMEBUFFER_UNSUPPORTED = 0x8CDD + +gl_FRONT :: GLenum +gl_FRONT = 0x0404 + +gl_FRONT_AND_BACK :: GLenum +gl_FRONT_AND_BACK = 0x0408 + +gl_FRONT_FACE :: GLenum +gl_FRONT_FACE = 0x0B46 + +gl_FRONT_LEFT :: GLenum +gl_FRONT_LEFT = 0x0400 + +gl_FRONT_RIGHT :: GLenum +gl_FRONT_RIGHT = 0x0401 + +gl_FUNC_ADD :: GLenum +gl_FUNC_ADD = 0x8006 + +gl_FUNC_REVERSE_SUBTRACT :: GLenum +gl_FUNC_REVERSE_SUBTRACT = 0x800B + +gl_FUNC_SUBTRACT :: GLenum +gl_FUNC_SUBTRACT = 0x800A + +gl_GEQUAL :: GLenum +gl_GEQUAL = 0x0206 + +gl_GREATER :: GLenum +gl_GREATER = 0x0204 + +gl_GREEN :: GLenum +gl_GREEN = 0x1904 + +gl_GREEN_INTEGER :: GLenum +gl_GREEN_INTEGER = 0x8D95 + +gl_HALF_FLOAT :: GLenum +gl_HALF_FLOAT = 0x140B + +gl_INCR :: GLenum +gl_INCR = 0x1E02 + +gl_INCR_WRAP :: GLenum +gl_INCR_WRAP = 0x8507 + +gl_INFO_LOG_LENGTH :: GLenum +gl_INFO_LOG_LENGTH = 0x8B84 + +gl_INT :: GLenum +gl_INT = 0x1404 + +gl_INTERLEAVED_ATTRIBS :: GLenum +gl_INTERLEAVED_ATTRIBS = 0x8C8C + +gl_INT_SAMPLER_1D :: GLenum +gl_INT_SAMPLER_1D = 0x8DC9 + +gl_INT_SAMPLER_1D_ARRAY :: GLenum +gl_INT_SAMPLER_1D_ARRAY = 0x8DCE + +gl_INT_SAMPLER_2D :: GLenum +gl_INT_SAMPLER_2D = 0x8DCA + +gl_INT_SAMPLER_2D_ARRAY :: GLenum +gl_INT_SAMPLER_2D_ARRAY = 0x8DCF + +gl_INT_SAMPLER_2D_RECT :: GLenum +gl_INT_SAMPLER_2D_RECT = 0x8DCD + +gl_INT_SAMPLER_3D :: GLenum +gl_INT_SAMPLER_3D = 0x8DCB + +gl_INT_SAMPLER_BUFFER :: GLenum +gl_INT_SAMPLER_BUFFER = 0x8DD0 + +gl_INT_SAMPLER_CUBE :: GLenum +gl_INT_SAMPLER_CUBE = 0x8DCC + +gl_INT_VEC2 :: GLenum +gl_INT_VEC2 = 0x8B53 + +gl_INT_VEC3 :: GLenum +gl_INT_VEC3 = 0x8B54 + +gl_INT_VEC4 :: GLenum +gl_INT_VEC4 = 0x8B55 + +gl_INVALID_ENUM :: GLenum +gl_INVALID_ENUM = 0x0500 + +gl_INVALID_FRAMEBUFFER_OPERATION :: GLenum +gl_INVALID_FRAMEBUFFER_OPERATION = 0x0506 + +gl_INVALID_INDEX :: GLenum +gl_INVALID_INDEX = 0xFFFFFFFF + +gl_INVALID_OPERATION :: GLenum +gl_INVALID_OPERATION = 0x0502 + +gl_INVALID_VALUE :: GLenum +gl_INVALID_VALUE = 0x0501 + +gl_INVERT :: GLenum +gl_INVERT = 0x150A + +gl_KEEP :: GLenum +gl_KEEP = 0x1E00 + +gl_LEFT :: GLenum +gl_LEFT = 0x0406 + +gl_LEQUAL :: GLenum +gl_LEQUAL = 0x0203 + +gl_LESS :: GLenum +gl_LESS = 0x0201 + +gl_LINE :: GLenum +gl_LINE = 0x1B01 + +gl_LINEAR :: GLenum +gl_LINEAR = 0x2601 + +gl_LINEAR_MIPMAP_LINEAR :: GLenum +gl_LINEAR_MIPMAP_LINEAR = 0x2703 + +gl_LINEAR_MIPMAP_NEAREST :: GLenum +gl_LINEAR_MIPMAP_NEAREST = 0x2701 + +gl_LINES :: GLenum +gl_LINES = 0x0001 + +gl_LINE_LOOP :: GLenum +gl_LINE_LOOP = 0x0002 + +gl_LINE_SMOOTH :: GLenum +gl_LINE_SMOOTH = 0x0B20 + +gl_LINE_SMOOTH_HINT :: GLenum +gl_LINE_SMOOTH_HINT = 0x0C52 + +gl_LINE_STRIP :: GLenum +gl_LINE_STRIP = 0x0003 + +gl_LINE_WIDTH :: GLenum +gl_LINE_WIDTH = 0x0B21 + +gl_LINE_WIDTH_GRANULARITY :: GLenum +gl_LINE_WIDTH_GRANULARITY = 0x0B23 + +gl_LINE_WIDTH_RANGE :: GLenum +gl_LINE_WIDTH_RANGE = 0x0B22 + +gl_LINK_STATUS :: GLenum +gl_LINK_STATUS = 0x8B82 + +gl_LOGIC_OP_MODE :: GLenum +gl_LOGIC_OP_MODE = 0x0BF0 + +gl_LOWER_LEFT :: GLenum +gl_LOWER_LEFT = 0x8CA1 + +gl_MAJOR_VERSION :: GLenum +gl_MAJOR_VERSION = 0x821B + +gl_MAP_FLUSH_EXPLICIT_BIT :: GLenum +gl_MAP_FLUSH_EXPLICIT_BIT = 0x0010 + +gl_MAP_INVALIDATE_BUFFER_BIT :: GLenum +gl_MAP_INVALIDATE_BUFFER_BIT = 0x0008 + +gl_MAP_INVALIDATE_RANGE_BIT :: GLenum +gl_MAP_INVALIDATE_RANGE_BIT = 0x0004 + +gl_MAP_READ_BIT :: GLenum +gl_MAP_READ_BIT = 0x0001 + +gl_MAP_UNSYNCHRONIZED_BIT :: GLenum +gl_MAP_UNSYNCHRONIZED_BIT = 0x0020 + +gl_MAP_WRITE_BIT :: GLenum +gl_MAP_WRITE_BIT = 0x0002 + +gl_MAX :: GLenum +gl_MAX = 0x8008 + +gl_MAX_3D_TEXTURE_SIZE :: GLenum +gl_MAX_3D_TEXTURE_SIZE = 0x8073 + +gl_MAX_ARRAY_TEXTURE_LAYERS :: GLenum +gl_MAX_ARRAY_TEXTURE_LAYERS = 0x88FF + +gl_MAX_CLIP_DISTANCES :: GLenum +gl_MAX_CLIP_DISTANCES = 0x0D32 + +gl_MAX_COLOR_ATTACHMENTS :: GLenum +gl_MAX_COLOR_ATTACHMENTS = 0x8CDF + +gl_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS :: GLenum +gl_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 + +gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS :: GLenum +gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D + +gl_MAX_COMBINED_UNIFORM_BLOCKS :: GLenum +gl_MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E + +gl_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS :: GLenum +gl_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 + +gl_MAX_CUBE_MAP_TEXTURE_SIZE :: GLenum +gl_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C + +gl_MAX_DRAW_BUFFERS :: GLenum +gl_MAX_DRAW_BUFFERS = 0x8824 + +gl_MAX_ELEMENTS_INDICES :: GLenum +gl_MAX_ELEMENTS_INDICES = 0x80E9 + +gl_MAX_ELEMENTS_VERTICES :: GLenum +gl_MAX_ELEMENTS_VERTICES = 0x80E8 + +gl_MAX_FRAGMENT_UNIFORM_BLOCKS :: GLenum +gl_MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D + +gl_MAX_FRAGMENT_UNIFORM_COMPONENTS :: GLenum +gl_MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 + +gl_MAX_PROGRAM_TEXEL_OFFSET :: GLenum +gl_MAX_PROGRAM_TEXEL_OFFSET = 0x8905 + +gl_MAX_RECTANGLE_TEXTURE_SIZE :: GLenum +gl_MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 + +gl_MAX_RENDERBUFFER_SIZE :: GLenum +gl_MAX_RENDERBUFFER_SIZE = 0x84E8 + +gl_MAX_SAMPLES :: GLenum +gl_MAX_SAMPLES = 0x8D57 + +gl_MAX_TEXTURE_BUFFER_SIZE :: GLenum +gl_MAX_TEXTURE_BUFFER_SIZE = 0x8C2B + +gl_MAX_TEXTURE_IMAGE_UNITS :: GLenum +gl_MAX_TEXTURE_IMAGE_UNITS = 0x8872 + +gl_MAX_TEXTURE_LOD_BIAS :: GLenum +gl_MAX_TEXTURE_LOD_BIAS = 0x84FD + +gl_MAX_TEXTURE_SIZE :: GLenum +gl_MAX_TEXTURE_SIZE = 0x0D33 + +gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A + +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B + +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 + +gl_MAX_UNIFORM_BLOCK_SIZE :: GLenum +gl_MAX_UNIFORM_BLOCK_SIZE = 0x8A30 + +gl_MAX_UNIFORM_BUFFER_BINDINGS :: GLenum +gl_MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F + +gl_MAX_VARYING_COMPONENTS :: GLenum +gl_MAX_VARYING_COMPONENTS = 0x8B4B + +gl_MAX_VARYING_FLOATS :: GLenum +gl_MAX_VARYING_FLOATS = 0x8B4B + +gl_MAX_VERTEX_ATTRIBS :: GLenum +gl_MAX_VERTEX_ATTRIBS = 0x8869 + +gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS :: GLenum +gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C + +gl_MAX_VERTEX_UNIFORM_BLOCKS :: GLenum +gl_MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B + +gl_MAX_VERTEX_UNIFORM_COMPONENTS :: GLenum +gl_MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A + +gl_MAX_VIEWPORT_DIMS :: GLenum +gl_MAX_VIEWPORT_DIMS = 0x0D3A + +gl_MIN :: GLenum +gl_MIN = 0x8007 + +gl_MINOR_VERSION :: GLenum +gl_MINOR_VERSION = 0x821C + +gl_MIN_PROGRAM_TEXEL_OFFSET :: GLenum +gl_MIN_PROGRAM_TEXEL_OFFSET = 0x8904 + +gl_MIRRORED_REPEAT :: GLenum +gl_MIRRORED_REPEAT = 0x8370 + +gl_MULTISAMPLE :: GLenum +gl_MULTISAMPLE = 0x809D + +gl_NAND :: GLenum +gl_NAND = 0x150E + +gl_NEAREST :: GLenum +gl_NEAREST = 0x2600 + +gl_NEAREST_MIPMAP_LINEAR :: GLenum +gl_NEAREST_MIPMAP_LINEAR = 0x2702 + +gl_NEAREST_MIPMAP_NEAREST :: GLenum +gl_NEAREST_MIPMAP_NEAREST = 0x2700 + +gl_NEVER :: GLenum +gl_NEVER = 0x0200 + +gl_NICEST :: GLenum +gl_NICEST = 0x1102 + +gl_NONE :: GLenum +gl_NONE = 0 + +gl_NOOP :: GLenum +gl_NOOP = 0x1505 + +gl_NOR :: GLenum +gl_NOR = 0x1508 + +gl_NOTEQUAL :: GLenum +gl_NOTEQUAL = 0x0205 + +gl_NO_ERROR :: GLenum +gl_NO_ERROR = 0 + +gl_NUM_COMPRESSED_TEXTURE_FORMATS :: GLenum +gl_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 + +gl_NUM_EXTENSIONS :: GLenum +gl_NUM_EXTENSIONS = 0x821D + +gl_ONE :: GLenum +gl_ONE = 1 + +gl_ONE_MINUS_CONSTANT_ALPHA :: GLenum +gl_ONE_MINUS_CONSTANT_ALPHA = 0x8004 + +gl_ONE_MINUS_CONSTANT_COLOR :: GLenum +gl_ONE_MINUS_CONSTANT_COLOR = 0x8002 + +gl_ONE_MINUS_DST_ALPHA :: GLenum +gl_ONE_MINUS_DST_ALPHA = 0x0305 + +gl_ONE_MINUS_DST_COLOR :: GLenum +gl_ONE_MINUS_DST_COLOR = 0x0307 + +gl_ONE_MINUS_SRC_ALPHA :: GLenum +gl_ONE_MINUS_SRC_ALPHA = 0x0303 + +gl_ONE_MINUS_SRC_COLOR :: GLenum +gl_ONE_MINUS_SRC_COLOR = 0x0301 + +gl_OR :: GLenum +gl_OR = 0x1507 + +gl_OR_INVERTED :: GLenum +gl_OR_INVERTED = 0x150D + +gl_OR_REVERSE :: GLenum +gl_OR_REVERSE = 0x150B + +gl_OUT_OF_MEMORY :: GLenum +gl_OUT_OF_MEMORY = 0x0505 + +gl_PACK_ALIGNMENT :: GLenum +gl_PACK_ALIGNMENT = 0x0D05 + +gl_PACK_IMAGE_HEIGHT :: GLenum +gl_PACK_IMAGE_HEIGHT = 0x806C + +gl_PACK_LSB_FIRST :: GLenum +gl_PACK_LSB_FIRST = 0x0D01 + +gl_PACK_ROW_LENGTH :: GLenum +gl_PACK_ROW_LENGTH = 0x0D02 + +gl_PACK_SKIP_IMAGES :: GLenum +gl_PACK_SKIP_IMAGES = 0x806B + +gl_PACK_SKIP_PIXELS :: GLenum +gl_PACK_SKIP_PIXELS = 0x0D04 + +gl_PACK_SKIP_ROWS :: GLenum +gl_PACK_SKIP_ROWS = 0x0D03 + +gl_PACK_SWAP_BYTES :: GLenum +gl_PACK_SWAP_BYTES = 0x0D00 + +gl_PIXEL_PACK_BUFFER :: GLenum +gl_PIXEL_PACK_BUFFER = 0x88EB + +gl_PIXEL_PACK_BUFFER_BINDING :: GLenum +gl_PIXEL_PACK_BUFFER_BINDING = 0x88ED + +gl_PIXEL_UNPACK_BUFFER :: GLenum +gl_PIXEL_UNPACK_BUFFER = 0x88EC + +gl_PIXEL_UNPACK_BUFFER_BINDING :: GLenum +gl_PIXEL_UNPACK_BUFFER_BINDING = 0x88EF + +gl_POINT :: GLenum +gl_POINT = 0x1B00 + +gl_POINTS :: GLenum +gl_POINTS = 0x0000 + +gl_POINT_FADE_THRESHOLD_SIZE :: GLenum +gl_POINT_FADE_THRESHOLD_SIZE = 0x8128 + +gl_POINT_SIZE :: GLenum +gl_POINT_SIZE = 0x0B11 + +gl_POINT_SIZE_GRANULARITY :: GLenum +gl_POINT_SIZE_GRANULARITY = 0x0B13 + +gl_POINT_SIZE_RANGE :: GLenum +gl_POINT_SIZE_RANGE = 0x0B12 + +gl_POINT_SPRITE_COORD_ORIGIN :: GLenum +gl_POINT_SPRITE_COORD_ORIGIN = 0x8CA0 + +gl_POLYGON_OFFSET_FACTOR :: GLenum +gl_POLYGON_OFFSET_FACTOR = 0x8038 + +gl_POLYGON_OFFSET_FILL :: GLenum +gl_POLYGON_OFFSET_FILL = 0x8037 + +gl_POLYGON_OFFSET_LINE :: GLenum +gl_POLYGON_OFFSET_LINE = 0x2A02 + +gl_POLYGON_OFFSET_POINT :: GLenum +gl_POLYGON_OFFSET_POINT = 0x2A01 + +gl_POLYGON_OFFSET_UNITS :: GLenum +gl_POLYGON_OFFSET_UNITS = 0x2A00 + +gl_POLYGON_SMOOTH :: GLenum +gl_POLYGON_SMOOTH = 0x0B41 + +gl_POLYGON_SMOOTH_HINT :: GLenum +gl_POLYGON_SMOOTH_HINT = 0x0C53 + +gl_PRIMITIVES_GENERATED :: GLenum +gl_PRIMITIVES_GENERATED = 0x8C87 + +gl_PRIMITIVE_RESTART :: GLenum +gl_PRIMITIVE_RESTART = 0x8F9D + +gl_PRIMITIVE_RESTART_INDEX :: GLenum +gl_PRIMITIVE_RESTART_INDEX = 0x8F9E + +gl_PROXY_TEXTURE_1D :: GLenum +gl_PROXY_TEXTURE_1D = 0x8063 + +gl_PROXY_TEXTURE_1D_ARRAY :: GLenum +gl_PROXY_TEXTURE_1D_ARRAY = 0x8C19 + +gl_PROXY_TEXTURE_2D :: GLenum +gl_PROXY_TEXTURE_2D = 0x8064 + +gl_PROXY_TEXTURE_2D_ARRAY :: GLenum +gl_PROXY_TEXTURE_2D_ARRAY = 0x8C1B + +gl_PROXY_TEXTURE_3D :: GLenum +gl_PROXY_TEXTURE_3D = 0x8070 + +gl_PROXY_TEXTURE_CUBE_MAP :: GLenum +gl_PROXY_TEXTURE_CUBE_MAP = 0x851B + +gl_PROXY_TEXTURE_RECTANGLE :: GLenum +gl_PROXY_TEXTURE_RECTANGLE = 0x84F7 + +gl_QUERY_BY_REGION_NO_WAIT :: GLenum +gl_QUERY_BY_REGION_NO_WAIT = 0x8E16 + +gl_QUERY_BY_REGION_WAIT :: GLenum +gl_QUERY_BY_REGION_WAIT = 0x8E15 + +gl_QUERY_COUNTER_BITS :: GLenum +gl_QUERY_COUNTER_BITS = 0x8864 + +gl_QUERY_NO_WAIT :: GLenum +gl_QUERY_NO_WAIT = 0x8E14 + +gl_QUERY_RESULT :: GLenum +gl_QUERY_RESULT = 0x8866 + +gl_QUERY_RESULT_AVAILABLE :: GLenum +gl_QUERY_RESULT_AVAILABLE = 0x8867 + +gl_QUERY_WAIT :: GLenum +gl_QUERY_WAIT = 0x8E13 + +gl_R11F_G11F_B10F :: GLenum +gl_R11F_G11F_B10F = 0x8C3A + +gl_R16 :: GLenum +gl_R16 = 0x822A + +gl_R16F :: GLenum +gl_R16F = 0x822D + +gl_R16I :: GLenum +gl_R16I = 0x8233 + +gl_R16UI :: GLenum +gl_R16UI = 0x8234 + +gl_R16_SNORM :: GLenum +gl_R16_SNORM = 0x8F98 + +gl_R32F :: GLenum +gl_R32F = 0x822E + +gl_R32I :: GLenum +gl_R32I = 0x8235 + +gl_R32UI :: GLenum +gl_R32UI = 0x8236 + +gl_R3_G3_B2 :: GLenum +gl_R3_G3_B2 = 0x2A10 + +gl_R8 :: GLenum +gl_R8 = 0x8229 + +gl_R8I :: GLenum +gl_R8I = 0x8231 + +gl_R8UI :: GLenum +gl_R8UI = 0x8232 + +gl_R8_SNORM :: GLenum +gl_R8_SNORM = 0x8F94 + +gl_RASTERIZER_DISCARD :: GLenum +gl_RASTERIZER_DISCARD = 0x8C89 + +gl_READ_BUFFER :: GLenum +gl_READ_BUFFER = 0x0C02 + +gl_READ_FRAMEBUFFER :: GLenum +gl_READ_FRAMEBUFFER = 0x8CA8 + +gl_READ_FRAMEBUFFER_BINDING :: GLenum +gl_READ_FRAMEBUFFER_BINDING = 0x8CAA + +gl_READ_ONLY :: GLenum +gl_READ_ONLY = 0x88B8 + +gl_READ_WRITE :: GLenum +gl_READ_WRITE = 0x88BA + +gl_RED :: GLenum +gl_RED = 0x1903 + +gl_RED_INTEGER :: GLenum +gl_RED_INTEGER = 0x8D94 + +gl_RED_SNORM :: GLenum +gl_RED_SNORM = 0x8F90 + +gl_RENDERBUFFER :: GLenum +gl_RENDERBUFFER = 0x8D41 + +gl_RENDERBUFFER_ALPHA_SIZE :: GLenum +gl_RENDERBUFFER_ALPHA_SIZE = 0x8D53 + +gl_RENDERBUFFER_BINDING :: GLenum +gl_RENDERBUFFER_BINDING = 0x8CA7 + +gl_RENDERBUFFER_BLUE_SIZE :: GLenum +gl_RENDERBUFFER_BLUE_SIZE = 0x8D52 + +gl_RENDERBUFFER_DEPTH_SIZE :: GLenum +gl_RENDERBUFFER_DEPTH_SIZE = 0x8D54 + +gl_RENDERBUFFER_GREEN_SIZE :: GLenum +gl_RENDERBUFFER_GREEN_SIZE = 0x8D51 + +gl_RENDERBUFFER_HEIGHT :: GLenum +gl_RENDERBUFFER_HEIGHT = 0x8D43 + +gl_RENDERBUFFER_INTERNAL_FORMAT :: GLenum +gl_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 + +gl_RENDERBUFFER_RED_SIZE :: GLenum +gl_RENDERBUFFER_RED_SIZE = 0x8D50 + +gl_RENDERBUFFER_SAMPLES :: GLenum +gl_RENDERBUFFER_SAMPLES = 0x8CAB + +gl_RENDERBUFFER_STENCIL_SIZE :: GLenum +gl_RENDERBUFFER_STENCIL_SIZE = 0x8D55 + +gl_RENDERBUFFER_WIDTH :: GLenum +gl_RENDERBUFFER_WIDTH = 0x8D42 + +gl_RENDERER :: GLenum +gl_RENDERER = 0x1F01 + +gl_REPEAT :: GLenum +gl_REPEAT = 0x2901 + +gl_REPLACE :: GLenum +gl_REPLACE = 0x1E01 + +gl_RG :: GLenum +gl_RG = 0x8227 + +gl_RG16 :: GLenum +gl_RG16 = 0x822C + +gl_RG16F :: GLenum +gl_RG16F = 0x822F + +gl_RG16I :: GLenum +gl_RG16I = 0x8239 + +gl_RG16UI :: GLenum +gl_RG16UI = 0x823A + +gl_RG16_SNORM :: GLenum +gl_RG16_SNORM = 0x8F99 + +gl_RG32F :: GLenum +gl_RG32F = 0x8230 + +gl_RG32I :: GLenum +gl_RG32I = 0x823B + +gl_RG32UI :: GLenum +gl_RG32UI = 0x823C + +gl_RG8 :: GLenum +gl_RG8 = 0x822B + +gl_RG8I :: GLenum +gl_RG8I = 0x8237 + +gl_RG8UI :: GLenum +gl_RG8UI = 0x8238 + +gl_RG8_SNORM :: GLenum +gl_RG8_SNORM = 0x8F95 + +gl_RGB :: GLenum +gl_RGB = 0x1907 + +gl_RGB10 :: GLenum +gl_RGB10 = 0x8052 + +gl_RGB10_A2 :: GLenum +gl_RGB10_A2 = 0x8059 + +gl_RGB12 :: GLenum +gl_RGB12 = 0x8053 + +gl_RGB16 :: GLenum +gl_RGB16 = 0x8054 + +gl_RGB16F :: GLenum +gl_RGB16F = 0x881B + +gl_RGB16I :: GLenum +gl_RGB16I = 0x8D89 + +gl_RGB16UI :: GLenum +gl_RGB16UI = 0x8D77 + +gl_RGB16_SNORM :: GLenum +gl_RGB16_SNORM = 0x8F9A + +gl_RGB32F :: GLenum +gl_RGB32F = 0x8815 + +gl_RGB32I :: GLenum +gl_RGB32I = 0x8D83 + +gl_RGB32UI :: GLenum +gl_RGB32UI = 0x8D71 + +gl_RGB4 :: GLenum +gl_RGB4 = 0x804F + +gl_RGB5 :: GLenum +gl_RGB5 = 0x8050 + +gl_RGB5_A1 :: GLenum +gl_RGB5_A1 = 0x8057 + +gl_RGB8 :: GLenum +gl_RGB8 = 0x8051 + +gl_RGB8I :: GLenum +gl_RGB8I = 0x8D8F + +gl_RGB8UI :: GLenum +gl_RGB8UI = 0x8D7D + +gl_RGB8_SNORM :: GLenum +gl_RGB8_SNORM = 0x8F96 + +gl_RGB9_E5 :: GLenum +gl_RGB9_E5 = 0x8C3D + +gl_RGBA :: GLenum +gl_RGBA = 0x1908 + +gl_RGBA12 :: GLenum +gl_RGBA12 = 0x805A + +gl_RGBA16 :: GLenum +gl_RGBA16 = 0x805B + +gl_RGBA16F :: GLenum +gl_RGBA16F = 0x881A + +gl_RGBA16I :: GLenum +gl_RGBA16I = 0x8D88 + +gl_RGBA16UI :: GLenum +gl_RGBA16UI = 0x8D76 + +gl_RGBA16_SNORM :: GLenum +gl_RGBA16_SNORM = 0x8F9B + +gl_RGBA2 :: GLenum +gl_RGBA2 = 0x8055 + +gl_RGBA32F :: GLenum +gl_RGBA32F = 0x8814 + +gl_RGBA32I :: GLenum +gl_RGBA32I = 0x8D82 + +gl_RGBA32UI :: GLenum +gl_RGBA32UI = 0x8D70 + +gl_RGBA4 :: GLenum +gl_RGBA4 = 0x8056 + +gl_RGBA8 :: GLenum +gl_RGBA8 = 0x8058 + +gl_RGBA8I :: GLenum +gl_RGBA8I = 0x8D8E + +gl_RGBA8UI :: GLenum +gl_RGBA8UI = 0x8D7C + +gl_RGBA8_SNORM :: GLenum +gl_RGBA8_SNORM = 0x8F97 + +gl_RGBA_INTEGER :: GLenum +gl_RGBA_INTEGER = 0x8D99 + +gl_RGBA_SNORM :: GLenum +gl_RGBA_SNORM = 0x8F93 + +gl_RGB_INTEGER :: GLenum +gl_RGB_INTEGER = 0x8D98 + +gl_RGB_SNORM :: GLenum +gl_RGB_SNORM = 0x8F92 + +gl_RG_INTEGER :: GLenum +gl_RG_INTEGER = 0x8228 + +gl_RG_SNORM :: GLenum +gl_RG_SNORM = 0x8F91 + +gl_RIGHT :: GLenum +gl_RIGHT = 0x0407 + +gl_SAMPLER_1D :: GLenum +gl_SAMPLER_1D = 0x8B5D + +gl_SAMPLER_1D_ARRAY :: GLenum +gl_SAMPLER_1D_ARRAY = 0x8DC0 + +gl_SAMPLER_1D_ARRAY_SHADOW :: GLenum +gl_SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 + +gl_SAMPLER_1D_SHADOW :: GLenum +gl_SAMPLER_1D_SHADOW = 0x8B61 + +gl_SAMPLER_2D :: GLenum +gl_SAMPLER_2D = 0x8B5E + +gl_SAMPLER_2D_ARRAY :: GLenum +gl_SAMPLER_2D_ARRAY = 0x8DC1 + +gl_SAMPLER_2D_ARRAY_SHADOW :: GLenum +gl_SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 + +gl_SAMPLER_2D_RECT :: GLenum +gl_SAMPLER_2D_RECT = 0x8B63 + +gl_SAMPLER_2D_RECT_SHADOW :: GLenum +gl_SAMPLER_2D_RECT_SHADOW = 0x8B64 + +gl_SAMPLER_2D_SHADOW :: GLenum +gl_SAMPLER_2D_SHADOW = 0x8B62 + +gl_SAMPLER_3D :: GLenum +gl_SAMPLER_3D = 0x8B5F + +gl_SAMPLER_BUFFER :: GLenum +gl_SAMPLER_BUFFER = 0x8DC2 + +gl_SAMPLER_CUBE :: GLenum +gl_SAMPLER_CUBE = 0x8B60 + +gl_SAMPLER_CUBE_SHADOW :: GLenum +gl_SAMPLER_CUBE_SHADOW = 0x8DC5 + +gl_SAMPLES :: GLenum +gl_SAMPLES = 0x80A9 + +gl_SAMPLES_PASSED :: GLenum +gl_SAMPLES_PASSED = 0x8914 + +gl_SAMPLE_ALPHA_TO_COVERAGE :: GLenum +gl_SAMPLE_ALPHA_TO_COVERAGE = 0x809E + +gl_SAMPLE_ALPHA_TO_ONE :: GLenum +gl_SAMPLE_ALPHA_TO_ONE = 0x809F + +gl_SAMPLE_BUFFERS :: GLenum +gl_SAMPLE_BUFFERS = 0x80A8 + +gl_SAMPLE_COVERAGE :: GLenum +gl_SAMPLE_COVERAGE = 0x80A0 + +gl_SAMPLE_COVERAGE_INVERT :: GLenum +gl_SAMPLE_COVERAGE_INVERT = 0x80AB + +gl_SAMPLE_COVERAGE_VALUE :: GLenum +gl_SAMPLE_COVERAGE_VALUE = 0x80AA + +gl_SCISSOR_BOX :: GLenum +gl_SCISSOR_BOX = 0x0C10 + +gl_SCISSOR_TEST :: GLenum +gl_SCISSOR_TEST = 0x0C11 + +gl_SEPARATE_ATTRIBS :: GLenum +gl_SEPARATE_ATTRIBS = 0x8C8D + +gl_SET :: GLenum +gl_SET = 0x150F + +gl_SHADER_SOURCE_LENGTH :: GLenum +gl_SHADER_SOURCE_LENGTH = 0x8B88 + +gl_SHADER_TYPE :: GLenum +gl_SHADER_TYPE = 0x8B4F + +gl_SHADING_LANGUAGE_VERSION :: GLenum +gl_SHADING_LANGUAGE_VERSION = 0x8B8C + +gl_SHORT :: GLenum +gl_SHORT = 0x1402 + +gl_SIGNED_NORMALIZED :: GLenum +gl_SIGNED_NORMALIZED = 0x8F9C + +gl_SMOOTH_LINE_WIDTH_GRANULARITY :: GLenum +gl_SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 + +gl_SMOOTH_LINE_WIDTH_RANGE :: GLenum +gl_SMOOTH_LINE_WIDTH_RANGE = 0x0B22 + +gl_SMOOTH_POINT_SIZE_GRANULARITY :: GLenum +gl_SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 + +gl_SMOOTH_POINT_SIZE_RANGE :: GLenum +gl_SMOOTH_POINT_SIZE_RANGE = 0x0B12 + +gl_SRC_ALPHA :: GLenum +gl_SRC_ALPHA = 0x0302 + +gl_SRC_ALPHA_SATURATE :: GLenum +gl_SRC_ALPHA_SATURATE = 0x0308 + +gl_SRC_COLOR :: GLenum +gl_SRC_COLOR = 0x0300 + +gl_SRGB :: GLenum +gl_SRGB = 0x8C40 + +gl_SRGB8 :: GLenum +gl_SRGB8 = 0x8C41 + +gl_SRGB8_ALPHA8 :: GLenum +gl_SRGB8_ALPHA8 = 0x8C43 + +gl_SRGB_ALPHA :: GLenum +gl_SRGB_ALPHA = 0x8C42 + +gl_STATIC_COPY :: GLenum +gl_STATIC_COPY = 0x88E6 + +gl_STATIC_DRAW :: GLenum +gl_STATIC_DRAW = 0x88E4 + +gl_STATIC_READ :: GLenum +gl_STATIC_READ = 0x88E5 + +gl_STENCIL :: GLenum +gl_STENCIL = 0x1802 + +gl_STENCIL_ATTACHMENT :: GLenum +gl_STENCIL_ATTACHMENT = 0x8D20 + +gl_STENCIL_BACK_FAIL :: GLenum +gl_STENCIL_BACK_FAIL = 0x8801 + +gl_STENCIL_BACK_FUNC :: GLenum +gl_STENCIL_BACK_FUNC = 0x8800 + +gl_STENCIL_BACK_PASS_DEPTH_FAIL :: GLenum +gl_STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 + +gl_STENCIL_BACK_PASS_DEPTH_PASS :: GLenum +gl_STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 + +gl_STENCIL_BACK_REF :: GLenum +gl_STENCIL_BACK_REF = 0x8CA3 + +gl_STENCIL_BACK_VALUE_MASK :: GLenum +gl_STENCIL_BACK_VALUE_MASK = 0x8CA4 + +gl_STENCIL_BACK_WRITEMASK :: GLenum +gl_STENCIL_BACK_WRITEMASK = 0x8CA5 + +gl_STENCIL_BUFFER :: GLenum +gl_STENCIL_BUFFER = 0x8224 + +gl_STENCIL_BUFFER_BIT :: GLenum +gl_STENCIL_BUFFER_BIT = 0x00000400 + +gl_STENCIL_CLEAR_VALUE :: GLenum +gl_STENCIL_CLEAR_VALUE = 0x0B91 + +gl_STENCIL_FAIL :: GLenum +gl_STENCIL_FAIL = 0x0B94 + +gl_STENCIL_FUNC :: GLenum +gl_STENCIL_FUNC = 0x0B92 + +gl_STENCIL_INDEX :: GLenum +gl_STENCIL_INDEX = 0x1901 + +gl_STENCIL_INDEX1 :: GLenum +gl_STENCIL_INDEX1 = 0x8D46 + +gl_STENCIL_INDEX16 :: GLenum +gl_STENCIL_INDEX16 = 0x8D49 + +gl_STENCIL_INDEX4 :: GLenum +gl_STENCIL_INDEX4 = 0x8D47 + +gl_STENCIL_INDEX8 :: GLenum +gl_STENCIL_INDEX8 = 0x8D48 + +gl_STENCIL_PASS_DEPTH_FAIL :: GLenum +gl_STENCIL_PASS_DEPTH_FAIL = 0x0B95 + +gl_STENCIL_PASS_DEPTH_PASS :: GLenum +gl_STENCIL_PASS_DEPTH_PASS = 0x0B96 + +gl_STENCIL_REF :: GLenum +gl_STENCIL_REF = 0x0B97 + +gl_STENCIL_TEST :: GLenum +gl_STENCIL_TEST = 0x0B90 + +gl_STENCIL_VALUE_MASK :: GLenum +gl_STENCIL_VALUE_MASK = 0x0B93 + +gl_STENCIL_WRITEMASK :: GLenum +gl_STENCIL_WRITEMASK = 0x0B98 + +gl_STEREO :: GLenum +gl_STEREO = 0x0C33 + +gl_STREAM_COPY :: GLenum +gl_STREAM_COPY = 0x88E2 + +gl_STREAM_DRAW :: GLenum +gl_STREAM_DRAW = 0x88E0 + +gl_STREAM_READ :: GLenum +gl_STREAM_READ = 0x88E1 + +gl_SUBPIXEL_BITS :: GLenum +gl_SUBPIXEL_BITS = 0x0D50 + +gl_TEXTURE :: GLenum +gl_TEXTURE = 0x1702 + +gl_TEXTURE0 :: GLenum +gl_TEXTURE0 = 0x84C0 + +gl_TEXTURE1 :: GLenum +gl_TEXTURE1 = 0x84C1 + +gl_TEXTURE10 :: GLenum +gl_TEXTURE10 = 0x84CA + +gl_TEXTURE11 :: GLenum +gl_TEXTURE11 = 0x84CB + +gl_TEXTURE12 :: GLenum +gl_TEXTURE12 = 0x84CC + +gl_TEXTURE13 :: GLenum +gl_TEXTURE13 = 0x84CD + +gl_TEXTURE14 :: GLenum +gl_TEXTURE14 = 0x84CE + +gl_TEXTURE15 :: GLenum +gl_TEXTURE15 = 0x84CF + +gl_TEXTURE16 :: GLenum +gl_TEXTURE16 = 0x84D0 + +gl_TEXTURE17 :: GLenum +gl_TEXTURE17 = 0x84D1 + +gl_TEXTURE18 :: GLenum +gl_TEXTURE18 = 0x84D2 + +gl_TEXTURE19 :: GLenum +gl_TEXTURE19 = 0x84D3 + +gl_TEXTURE2 :: GLenum +gl_TEXTURE2 = 0x84C2 + +gl_TEXTURE20 :: GLenum +gl_TEXTURE20 = 0x84D4 + +gl_TEXTURE21 :: GLenum +gl_TEXTURE21 = 0x84D5 + +gl_TEXTURE22 :: GLenum +gl_TEXTURE22 = 0x84D6 + +gl_TEXTURE23 :: GLenum +gl_TEXTURE23 = 0x84D7 + +gl_TEXTURE24 :: GLenum +gl_TEXTURE24 = 0x84D8 + +gl_TEXTURE25 :: GLenum +gl_TEXTURE25 = 0x84D9 + +gl_TEXTURE26 :: GLenum +gl_TEXTURE26 = 0x84DA + +gl_TEXTURE27 :: GLenum +gl_TEXTURE27 = 0x84DB + +gl_TEXTURE28 :: GLenum +gl_TEXTURE28 = 0x84DC + +gl_TEXTURE29 :: GLenum +gl_TEXTURE29 = 0x84DD + +gl_TEXTURE3 :: GLenum +gl_TEXTURE3 = 0x84C3 + +gl_TEXTURE30 :: GLenum +gl_TEXTURE30 = 0x84DE + +gl_TEXTURE31 :: GLenum +gl_TEXTURE31 = 0x84DF + +gl_TEXTURE4 :: GLenum +gl_TEXTURE4 = 0x84C4 + +gl_TEXTURE5 :: GLenum +gl_TEXTURE5 = 0x84C5 + +gl_TEXTURE6 :: GLenum +gl_TEXTURE6 = 0x84C6 + +gl_TEXTURE7 :: GLenum +gl_TEXTURE7 = 0x84C7 + +gl_TEXTURE8 :: GLenum +gl_TEXTURE8 = 0x84C8 + +gl_TEXTURE9 :: GLenum +gl_TEXTURE9 = 0x84C9 + +gl_TEXTURE_1D :: GLenum +gl_TEXTURE_1D = 0x0DE0 + +gl_TEXTURE_1D_ARRAY :: GLenum +gl_TEXTURE_1D_ARRAY = 0x8C18 + +gl_TEXTURE_2D :: GLenum +gl_TEXTURE_2D = 0x0DE1 + +gl_TEXTURE_2D_ARRAY :: GLenum +gl_TEXTURE_2D_ARRAY = 0x8C1A + +gl_TEXTURE_3D :: GLenum +gl_TEXTURE_3D = 0x806F + +gl_TEXTURE_ALPHA_SIZE :: GLenum +gl_TEXTURE_ALPHA_SIZE = 0x805F + +gl_TEXTURE_ALPHA_TYPE :: GLenum +gl_TEXTURE_ALPHA_TYPE = 0x8C13 + +gl_TEXTURE_BASE_LEVEL :: GLenum +gl_TEXTURE_BASE_LEVEL = 0x813C + +gl_TEXTURE_BINDING_1D :: GLenum +gl_TEXTURE_BINDING_1D = 0x8068 + +gl_TEXTURE_BINDING_1D_ARRAY :: GLenum +gl_TEXTURE_BINDING_1D_ARRAY = 0x8C1C + +gl_TEXTURE_BINDING_2D :: GLenum +gl_TEXTURE_BINDING_2D = 0x8069 + +gl_TEXTURE_BINDING_2D_ARRAY :: GLenum +gl_TEXTURE_BINDING_2D_ARRAY = 0x8C1D + +gl_TEXTURE_BINDING_3D :: GLenum +gl_TEXTURE_BINDING_3D = 0x806A + +gl_TEXTURE_BINDING_BUFFER :: GLenum +gl_TEXTURE_BINDING_BUFFER = 0x8C2C + +gl_TEXTURE_BINDING_CUBE_MAP :: GLenum +gl_TEXTURE_BINDING_CUBE_MAP = 0x8514 + +gl_TEXTURE_BINDING_RECTANGLE :: GLenum +gl_TEXTURE_BINDING_RECTANGLE = 0x84F6 + +gl_TEXTURE_BLUE_SIZE :: GLenum +gl_TEXTURE_BLUE_SIZE = 0x805E + +gl_TEXTURE_BLUE_TYPE :: GLenum +gl_TEXTURE_BLUE_TYPE = 0x8C12 + +gl_TEXTURE_BORDER :: GLenum +gl_TEXTURE_BORDER = 0x1005 + +gl_TEXTURE_BORDER_COLOR :: GLenum +gl_TEXTURE_BORDER_COLOR = 0x1004 + +gl_TEXTURE_BUFFER :: GLenum +gl_TEXTURE_BUFFER = 0x8C2A + +gl_TEXTURE_BUFFER_DATA_STORE_BINDING :: GLenum +gl_TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D + +gl_TEXTURE_BUFFER_FORMAT :: GLenum +gl_TEXTURE_BUFFER_FORMAT = 0x8C2E + +gl_TEXTURE_COMPARE_FUNC :: GLenum +gl_TEXTURE_COMPARE_FUNC = 0x884D + +gl_TEXTURE_COMPARE_MODE :: GLenum +gl_TEXTURE_COMPARE_MODE = 0x884C + +gl_TEXTURE_COMPRESSED :: GLenum +gl_TEXTURE_COMPRESSED = 0x86A1 + +gl_TEXTURE_COMPRESSED_IMAGE_SIZE :: GLenum +gl_TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 + +gl_TEXTURE_COMPRESSION_HINT :: GLenum +gl_TEXTURE_COMPRESSION_HINT = 0x84EF + +gl_TEXTURE_CUBE_MAP :: GLenum +gl_TEXTURE_CUBE_MAP = 0x8513 + +gl_TEXTURE_CUBE_MAP_NEGATIVE_X :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 + +gl_TEXTURE_CUBE_MAP_NEGATIVE_Y :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 + +gl_TEXTURE_CUBE_MAP_NEGATIVE_Z :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A + +gl_TEXTURE_CUBE_MAP_POSITIVE_X :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 + +gl_TEXTURE_CUBE_MAP_POSITIVE_Y :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 + +gl_TEXTURE_CUBE_MAP_POSITIVE_Z :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 + +gl_TEXTURE_DEPTH :: GLenum +gl_TEXTURE_DEPTH = 0x8071 + +gl_TEXTURE_DEPTH_SIZE :: GLenum +gl_TEXTURE_DEPTH_SIZE = 0x884A + +gl_TEXTURE_DEPTH_TYPE :: GLenum +gl_TEXTURE_DEPTH_TYPE = 0x8C16 + +gl_TEXTURE_GREEN_SIZE :: GLenum +gl_TEXTURE_GREEN_SIZE = 0x805D + +gl_TEXTURE_GREEN_TYPE :: GLenum +gl_TEXTURE_GREEN_TYPE = 0x8C11 + +gl_TEXTURE_HEIGHT :: GLenum +gl_TEXTURE_HEIGHT = 0x1001 + +gl_TEXTURE_INTERNAL_FORMAT :: GLenum +gl_TEXTURE_INTERNAL_FORMAT = 0x1003 + +gl_TEXTURE_LOD_BIAS :: GLenum +gl_TEXTURE_LOD_BIAS = 0x8501 + +gl_TEXTURE_MAG_FILTER :: GLenum +gl_TEXTURE_MAG_FILTER = 0x2800 + +gl_TEXTURE_MAX_LEVEL :: GLenum +gl_TEXTURE_MAX_LEVEL = 0x813D + +gl_TEXTURE_MAX_LOD :: GLenum +gl_TEXTURE_MAX_LOD = 0x813B + +gl_TEXTURE_MIN_FILTER :: GLenum +gl_TEXTURE_MIN_FILTER = 0x2801 + +gl_TEXTURE_MIN_LOD :: GLenum +gl_TEXTURE_MIN_LOD = 0x813A + +gl_TEXTURE_RECTANGLE :: GLenum +gl_TEXTURE_RECTANGLE = 0x84F5 + +gl_TEXTURE_RED_SIZE :: GLenum +gl_TEXTURE_RED_SIZE = 0x805C + +gl_TEXTURE_RED_TYPE :: GLenum +gl_TEXTURE_RED_TYPE = 0x8C10 + +gl_TEXTURE_SHARED_SIZE :: GLenum +gl_TEXTURE_SHARED_SIZE = 0x8C3F + +gl_TEXTURE_STENCIL_SIZE :: GLenum +gl_TEXTURE_STENCIL_SIZE = 0x88F1 + +gl_TEXTURE_WIDTH :: GLenum +gl_TEXTURE_WIDTH = 0x1000 + +gl_TEXTURE_WRAP_R :: GLenum +gl_TEXTURE_WRAP_R = 0x8072 + +gl_TEXTURE_WRAP_S :: GLenum +gl_TEXTURE_WRAP_S = 0x2802 + +gl_TEXTURE_WRAP_T :: GLenum +gl_TEXTURE_WRAP_T = 0x2803 + +gl_TRANSFORM_FEEDBACK_BUFFER :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER = 0x8C8E + +gl_TRANSFORM_FEEDBACK_BUFFER_BINDING :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F + +gl_TRANSFORM_FEEDBACK_BUFFER_MODE :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F + +gl_TRANSFORM_FEEDBACK_BUFFER_SIZE :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 + +gl_TRANSFORM_FEEDBACK_BUFFER_START :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 + +gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN :: GLenum +gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 + +gl_TRANSFORM_FEEDBACK_VARYINGS :: GLenum +gl_TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 + +gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH :: GLenum +gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 + +gl_TRIANGLES :: GLenum +gl_TRIANGLES = 0x0004 + +gl_TRIANGLE_FAN :: GLenum +gl_TRIANGLE_FAN = 0x0006 + +gl_TRIANGLE_STRIP :: GLenum +gl_TRIANGLE_STRIP = 0x0005 + +gl_TRUE :: GLenum +gl_TRUE = 1 + +gl_UNIFORM_ARRAY_STRIDE :: GLenum +gl_UNIFORM_ARRAY_STRIDE = 0x8A3C + +gl_UNIFORM_BLOCK_ACTIVE_UNIFORMS :: GLenum +gl_UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 + +gl_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES :: GLenum +gl_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 + +gl_UNIFORM_BLOCK_BINDING :: GLenum +gl_UNIFORM_BLOCK_BINDING = 0x8A3F + +gl_UNIFORM_BLOCK_DATA_SIZE :: GLenum +gl_UNIFORM_BLOCK_DATA_SIZE = 0x8A40 + +gl_UNIFORM_BLOCK_INDEX :: GLenum +gl_UNIFORM_BLOCK_INDEX = 0x8A3A + +gl_UNIFORM_BLOCK_NAME_LENGTH :: GLenum +gl_UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 + +gl_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER :: GLenum +gl_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 + +gl_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER :: GLenum +gl_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 + +gl_UNIFORM_BUFFER :: GLenum +gl_UNIFORM_BUFFER = 0x8A11 + +gl_UNIFORM_BUFFER_BINDING :: GLenum +gl_UNIFORM_BUFFER_BINDING = 0x8A28 + +gl_UNIFORM_BUFFER_OFFSET_ALIGNMENT :: GLenum +gl_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 + +gl_UNIFORM_BUFFER_SIZE :: GLenum +gl_UNIFORM_BUFFER_SIZE = 0x8A2A + +gl_UNIFORM_BUFFER_START :: GLenum +gl_UNIFORM_BUFFER_START = 0x8A29 + +gl_UNIFORM_IS_ROW_MAJOR :: GLenum +gl_UNIFORM_IS_ROW_MAJOR = 0x8A3E + +gl_UNIFORM_MATRIX_STRIDE :: GLenum +gl_UNIFORM_MATRIX_STRIDE = 0x8A3D + +gl_UNIFORM_NAME_LENGTH :: GLenum +gl_UNIFORM_NAME_LENGTH = 0x8A39 + +gl_UNIFORM_OFFSET :: GLenum +gl_UNIFORM_OFFSET = 0x8A3B + +gl_UNIFORM_SIZE :: GLenum +gl_UNIFORM_SIZE = 0x8A38 + +gl_UNIFORM_TYPE :: GLenum +gl_UNIFORM_TYPE = 0x8A37 + +gl_UNPACK_ALIGNMENT :: GLenum +gl_UNPACK_ALIGNMENT = 0x0CF5 + +gl_UNPACK_IMAGE_HEIGHT :: GLenum +gl_UNPACK_IMAGE_HEIGHT = 0x806E + +gl_UNPACK_LSB_FIRST :: GLenum +gl_UNPACK_LSB_FIRST = 0x0CF1 + +gl_UNPACK_ROW_LENGTH :: GLenum +gl_UNPACK_ROW_LENGTH = 0x0CF2 + +gl_UNPACK_SKIP_IMAGES :: GLenum +gl_UNPACK_SKIP_IMAGES = 0x806D + +gl_UNPACK_SKIP_PIXELS :: GLenum +gl_UNPACK_SKIP_PIXELS = 0x0CF4 + +gl_UNPACK_SKIP_ROWS :: GLenum +gl_UNPACK_SKIP_ROWS = 0x0CF3 + +gl_UNPACK_SWAP_BYTES :: GLenum +gl_UNPACK_SWAP_BYTES = 0x0CF0 + +gl_UNSIGNED_BYTE :: GLenum +gl_UNSIGNED_BYTE = 0x1401 + +gl_UNSIGNED_BYTE_2_3_3_REV :: GLenum +gl_UNSIGNED_BYTE_2_3_3_REV = 0x8362 + +gl_UNSIGNED_BYTE_3_3_2 :: GLenum +gl_UNSIGNED_BYTE_3_3_2 = 0x8032 + +gl_UNSIGNED_INT :: GLenum +gl_UNSIGNED_INT = 0x1405 + +gl_UNSIGNED_INT_10F_11F_11F_REV :: GLenum +gl_UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B + +gl_UNSIGNED_INT_10_10_10_2 :: GLenum +gl_UNSIGNED_INT_10_10_10_2 = 0x8036 + +gl_UNSIGNED_INT_24_8 :: GLenum +gl_UNSIGNED_INT_24_8 = 0x84FA + +gl_UNSIGNED_INT_2_10_10_10_REV :: GLenum +gl_UNSIGNED_INT_2_10_10_10_REV = 0x8368 + +gl_UNSIGNED_INT_5_9_9_9_REV :: GLenum +gl_UNSIGNED_INT_5_9_9_9_REV = 0x8C3E + +gl_UNSIGNED_INT_8_8_8_8 :: GLenum +gl_UNSIGNED_INT_8_8_8_8 = 0x8035 + +gl_UNSIGNED_INT_8_8_8_8_REV :: GLenum +gl_UNSIGNED_INT_8_8_8_8_REV = 0x8367 + +gl_UNSIGNED_INT_SAMPLER_1D :: GLenum +gl_UNSIGNED_INT_SAMPLER_1D = 0x8DD1 + +gl_UNSIGNED_INT_SAMPLER_1D_ARRAY :: GLenum +gl_UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 + +gl_UNSIGNED_INT_SAMPLER_2D :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D = 0x8DD2 + +gl_UNSIGNED_INT_SAMPLER_2D_ARRAY :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 + +gl_UNSIGNED_INT_SAMPLER_2D_RECT :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 + +gl_UNSIGNED_INT_SAMPLER_3D :: GLenum +gl_UNSIGNED_INT_SAMPLER_3D = 0x8DD3 + +gl_UNSIGNED_INT_SAMPLER_BUFFER :: GLenum +gl_UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 + +gl_UNSIGNED_INT_SAMPLER_CUBE :: GLenum +gl_UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 + +gl_UNSIGNED_INT_VEC2 :: GLenum +gl_UNSIGNED_INT_VEC2 = 0x8DC6 + +gl_UNSIGNED_INT_VEC3 :: GLenum +gl_UNSIGNED_INT_VEC3 = 0x8DC7 + +gl_UNSIGNED_INT_VEC4 :: GLenum +gl_UNSIGNED_INT_VEC4 = 0x8DC8 + +gl_UNSIGNED_NORMALIZED :: GLenum +gl_UNSIGNED_NORMALIZED = 0x8C17 + +gl_UNSIGNED_SHORT :: GLenum +gl_UNSIGNED_SHORT = 0x1403 + +gl_UNSIGNED_SHORT_1_5_5_5_REV :: GLenum +gl_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 + +gl_UNSIGNED_SHORT_4_4_4_4 :: GLenum +gl_UNSIGNED_SHORT_4_4_4_4 = 0x8033 + +gl_UNSIGNED_SHORT_4_4_4_4_REV :: GLenum +gl_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 + +gl_UNSIGNED_SHORT_5_5_5_1 :: GLenum +gl_UNSIGNED_SHORT_5_5_5_1 = 0x8034 + +gl_UNSIGNED_SHORT_5_6_5 :: GLenum +gl_UNSIGNED_SHORT_5_6_5 = 0x8363 + +gl_UNSIGNED_SHORT_5_6_5_REV :: GLenum +gl_UNSIGNED_SHORT_5_6_5_REV = 0x8364 + +gl_UPPER_LEFT :: GLenum +gl_UPPER_LEFT = 0x8CA2 + +gl_VALIDATE_STATUS :: GLenum +gl_VALIDATE_STATUS = 0x8B83 + +gl_VENDOR :: GLenum +gl_VENDOR = 0x1F00 + +gl_VERSION :: GLenum +gl_VERSION = 0x1F02 + +gl_VERTEX_ARRAY_BINDING :: GLenum +gl_VERTEX_ARRAY_BINDING = 0x85B5 + +gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING :: GLenum +gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F + +gl_VERTEX_ATTRIB_ARRAY_ENABLED :: GLenum +gl_VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 + +gl_VERTEX_ATTRIB_ARRAY_INTEGER :: GLenum +gl_VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD + +gl_VERTEX_ATTRIB_ARRAY_NORMALIZED :: GLenum +gl_VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A + +gl_VERTEX_ATTRIB_ARRAY_POINTER :: GLenum +gl_VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 + +gl_VERTEX_ATTRIB_ARRAY_SIZE :: GLenum +gl_VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 + +gl_VERTEX_ATTRIB_ARRAY_STRIDE :: GLenum +gl_VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 + +gl_VERTEX_ATTRIB_ARRAY_TYPE :: GLenum +gl_VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 + +gl_VERTEX_PROGRAM_POINT_SIZE :: GLenum +gl_VERTEX_PROGRAM_POINT_SIZE = 0x8642 + +gl_VERTEX_SHADER :: GLenum +gl_VERTEX_SHADER = 0x8B31 + +gl_VIEWPORT :: GLenum +gl_VIEWPORT = 0x0BA2 + +gl_WRITE_ONLY :: GLenum +gl_WRITE_ONLY = 0x88B9 + +gl_XOR :: GLenum +gl_XOR = 0x1506 + +gl_ZERO :: GLenum +gl_ZERO = 0 diff --git a/src/Graphics/Rendering/OpenGL/Raw/Core31/Types.hs b/src/Graphics/Rendering/OpenGL/Raw/Core31/Types.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/Core31/Types.hs @@ -0,0 +1,37 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.Core31.Types +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All types from the OpenGL 3.1 core, see . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.Core31.Types where + +import Foreign.C.Types + +type GLbitfield = CUInt +type GLboolean = CUChar +type GLbyte = CSChar +type GLchar = CChar +type GLclampd = CDouble +type GLclampf = CFloat +type GLdouble = CDouble +type GLenum = CUInt +type GLfloat = CFloat +type GLhalf = CUShort +type GLint = CInt +type GLintptr = CPtrdiff +type GLshort = CShort +type GLsizei = CInt +type GLsizeiptr = CPtrdiff +type GLubyte = CUChar +type GLuint = CUInt +type GLushort = CUShort diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT.hs @@ -0,0 +1,123 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- A convenience module, combining all raw modules containing EXT extensions. +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT ( + module Graphics.Rendering.OpenGL.Raw.EXT.Abgr, + module Graphics.Rendering.OpenGL.Raw.EXT.BindableUniform, + module Graphics.Rendering.OpenGL.Raw.EXT.ClipVolumeHint, + module Graphics.Rendering.OpenGL.Raw.EXT.Cmyka, + module Graphics.Rendering.OpenGL.Raw.EXT.ColorSubtable, + module Graphics.Rendering.OpenGL.Raw.EXT.CompiledVertexArray, + module Graphics.Rendering.OpenGL.Raw.EXT.CoordinateFrame, + module Graphics.Rendering.OpenGL.Raw.EXT.CullVertex, + module Graphics.Rendering.OpenGL.Raw.EXT.DepthBoundsTest, + module Graphics.Rendering.OpenGL.Raw.EXT.DirectStateAccess, + module Graphics.Rendering.OpenGL.Raw.EXT.FogCoord, + module Graphics.Rendering.OpenGL.Raw.EXT.FourTwoTwoPixels, + module Graphics.Rendering.OpenGL.Raw.EXT.FragmentLighting, + module Graphics.Rendering.OpenGL.Raw.EXT.FramebufferObject, + module Graphics.Rendering.OpenGL.Raw.EXT.FramebufferSRGB, + module Graphics.Rendering.OpenGL.Raw.EXT.GeometryShader4, + module Graphics.Rendering.OpenGL.Raw.EXT.GpuProgramParameters, + module Graphics.Rendering.OpenGL.Raw.EXT.IndexArrayFormats, + module Graphics.Rendering.OpenGL.Raw.EXT.IndexFunc, + module Graphics.Rendering.OpenGL.Raw.EXT.IndexMaterial, + module Graphics.Rendering.OpenGL.Raw.EXT.LightTexture, + module Graphics.Rendering.OpenGL.Raw.EXT.Multisample, + module Graphics.Rendering.OpenGL.Raw.EXT.PackedFloat, + module Graphics.Rendering.OpenGL.Raw.EXT.PalettedTexture, + module Graphics.Rendering.OpenGL.Raw.EXT.PerturbNormal, + module Graphics.Rendering.OpenGL.Raw.EXT.PixelTransform, + module Graphics.Rendering.OpenGL.Raw.EXT.PointParameters, + module Graphics.Rendering.OpenGL.Raw.EXT.PolygonOffset, + module Graphics.Rendering.OpenGL.Raw.EXT.ProvokingVertex, + module Graphics.Rendering.OpenGL.Raw.EXT.RescaleNormal, + module Graphics.Rendering.OpenGL.Raw.EXT.SecondaryColor, + module Graphics.Rendering.OpenGL.Raw.EXT.SeparateSpecularColor, + module Graphics.Rendering.OpenGL.Raw.EXT.SharedTexturePalette, + module Graphics.Rendering.OpenGL.Raw.EXT.StencilClearTag, + module Graphics.Rendering.OpenGL.Raw.EXT.StencilTwoSide, + module Graphics.Rendering.OpenGL.Raw.EXT.Texture, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionDxt1, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionLatc, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionS3tc, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvAdd, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvCombine, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvDot3, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureFilterAnisotropic, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureInteger, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureLodBias, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureMirrorClamp, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureObject, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureSRGB, + module Graphics.Rendering.OpenGL.Raw.EXT.TextureSwizzle, + module Graphics.Rendering.OpenGL.Raw.EXT.TimerQuery, + module Graphics.Rendering.OpenGL.Raw.EXT.VertexArray, + module Graphics.Rendering.OpenGL.Raw.EXT.VertexShader, + module Graphics.Rendering.OpenGL.Raw.EXT.VertexWeighting +) where + +import Graphics.Rendering.OpenGL.Raw.EXT.Abgr +import Graphics.Rendering.OpenGL.Raw.EXT.BindableUniform +import Graphics.Rendering.OpenGL.Raw.EXT.ClipVolumeHint +import Graphics.Rendering.OpenGL.Raw.EXT.Cmyka +import Graphics.Rendering.OpenGL.Raw.EXT.ColorSubtable +import Graphics.Rendering.OpenGL.Raw.EXT.CompiledVertexArray +import Graphics.Rendering.OpenGL.Raw.EXT.CoordinateFrame +import Graphics.Rendering.OpenGL.Raw.EXT.CullVertex +import Graphics.Rendering.OpenGL.Raw.EXT.DepthBoundsTest +import Graphics.Rendering.OpenGL.Raw.EXT.DirectStateAccess +import Graphics.Rendering.OpenGL.Raw.EXT.FogCoord +import Graphics.Rendering.OpenGL.Raw.EXT.FourTwoTwoPixels +import Graphics.Rendering.OpenGL.Raw.EXT.FragmentLighting +import Graphics.Rendering.OpenGL.Raw.EXT.FramebufferObject +import Graphics.Rendering.OpenGL.Raw.EXT.FramebufferSRGB +import Graphics.Rendering.OpenGL.Raw.EXT.GeometryShader4 +import Graphics.Rendering.OpenGL.Raw.EXT.GpuProgramParameters +import Graphics.Rendering.OpenGL.Raw.EXT.IndexArrayFormats +import Graphics.Rendering.OpenGL.Raw.EXT.IndexFunc +import Graphics.Rendering.OpenGL.Raw.EXT.IndexMaterial +import Graphics.Rendering.OpenGL.Raw.EXT.LightTexture +import Graphics.Rendering.OpenGL.Raw.EXT.Multisample +import Graphics.Rendering.OpenGL.Raw.EXT.PackedFloat +import Graphics.Rendering.OpenGL.Raw.EXT.PalettedTexture +import Graphics.Rendering.OpenGL.Raw.EXT.PerturbNormal +import Graphics.Rendering.OpenGL.Raw.EXT.PixelTransform +import Graphics.Rendering.OpenGL.Raw.EXT.PointParameters +import Graphics.Rendering.OpenGL.Raw.EXT.PolygonOffset +import Graphics.Rendering.OpenGL.Raw.EXT.ProvokingVertex +import Graphics.Rendering.OpenGL.Raw.EXT.RescaleNormal +import Graphics.Rendering.OpenGL.Raw.EXT.SecondaryColor +import Graphics.Rendering.OpenGL.Raw.EXT.SeparateSpecularColor +import Graphics.Rendering.OpenGL.Raw.EXT.SharedTexturePalette +import Graphics.Rendering.OpenGL.Raw.EXT.StencilClearTag +import Graphics.Rendering.OpenGL.Raw.EXT.StencilTwoSide +import Graphics.Rendering.OpenGL.Raw.EXT.Texture +import Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionDxt1 +import Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionLatc +import Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionS3tc +import Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvAdd +import Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvCombine +import Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvDot3 +import Graphics.Rendering.OpenGL.Raw.EXT.TextureFilterAnisotropic +import Graphics.Rendering.OpenGL.Raw.EXT.TextureInteger +import Graphics.Rendering.OpenGL.Raw.EXT.TextureLodBias +import Graphics.Rendering.OpenGL.Raw.EXT.TextureMirrorClamp +import Graphics.Rendering.OpenGL.Raw.EXT.TextureObject +import Graphics.Rendering.OpenGL.Raw.EXT.TextureSRGB +import Graphics.Rendering.OpenGL.Raw.EXT.TextureSwizzle +import Graphics.Rendering.OpenGL.Raw.EXT.TimerQuery +import Graphics.Rendering.OpenGL.Raw.EXT.VertexArray +import Graphics.Rendering.OpenGL.Raw.EXT.VertexShader +import Graphics.Rendering.OpenGL.Raw.EXT.VertexWeighting diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/Abgr.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/Abgr.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/Abgr.hs @@ -0,0 +1,24 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.Abgr +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_abgr extension not already in the +-- OpenGL 3.1 core, see . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.Abgr ( + -- * Tokens + gl_ABGR +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_ABGR :: GLenum +gl_ABGR = 0x8000 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/BindableUniform.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/BindableUniform.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/BindableUniform.hs @@ -0,0 +1,64 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.BindableUniform +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_bindable_uniform extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.BindableUniform ( + -- * Functions + glUniformBuffer, + glGetUniformBufferSize, + glGetUniformOffset, + -- * Tokens + gl_MAX_VERTEX_BINDABLE_UNIFORMS, + gl_MAX_FRAGMENT_BINDABLE_UNIFORMS, + gl_MAX_GEOMETRY_BINDABLE_UNIFORMS, + gl_MAX_BINDABLE_UNIFORM_SIZE, + gl_UNIFORM_BUFFER_BINDING_EXT, + gl_UNIFORM_BUFFER_EXT +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_bindable_uniform" + +EXTENSION_ENTRY(glUniformBuffer,GLuint -> GLint -> GLuint -> IO ()) +EXTENSION_ENTRY(glGetUniformBufferSize,GLuint -> GLint -> IO GLint) +EXTENSION_ENTRY(glGetUniformOffset,GLuint -> GLint -> IO GLintptr) + +gl_MAX_VERTEX_BINDABLE_UNIFORMS :: GLenum +gl_MAX_VERTEX_BINDABLE_UNIFORMS = 0x8DE2 + +gl_MAX_FRAGMENT_BINDABLE_UNIFORMS :: GLenum +gl_MAX_FRAGMENT_BINDABLE_UNIFORMS = 0x8DE3 + +gl_MAX_GEOMETRY_BINDABLE_UNIFORMS :: GLenum +gl_MAX_GEOMETRY_BINDABLE_UNIFORMS = 0x8DE4 + +gl_MAX_BINDABLE_UNIFORM_SIZE :: GLenum +gl_MAX_BINDABLE_UNIFORM_SIZE = 0x8DED + +-- | NOTE: The OpenGL 3.1 core has the same token with a different value, so we +-- use a suffix here. +gl_UNIFORM_BUFFER_BINDING_EXT :: GLenum +gl_UNIFORM_BUFFER_BINDING_EXT = 0x8DEF + +-- | NOTE: The OpenGL 3.1 core has the same token with a different value, so we +-- use a suffix here. +gl_UNIFORM_BUFFER_EXT :: GLenum +gl_UNIFORM_BUFFER_EXT = 0x8DEE diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/ClipVolumeHint.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/ClipVolumeHint.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/ClipVolumeHint.hs @@ -0,0 +1,25 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.ClipVolumeHint +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_clip_volume_hint extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.ClipVolumeHint ( + -- * Tokens + gl_CLIP_VOLUME_CLIPPING_HINT +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_CLIP_VOLUME_CLIPPING_HINT :: GLenum +gl_CLIP_VOLUME_CLIPPING_HINT = 0x80F0 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/Cmyka.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/Cmyka.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/Cmyka.hs @@ -0,0 +1,36 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.Cmyka +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_cmyka extension not already in the +-- OpenGL 3.1 core, see . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.Cmyka ( + -- * Tokens + gl_CMYK, + gl_CMYKA, + gl_PACK_CMYK_HINT, + gl_UNPACK_CMYK_HINT +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_CMYK :: GLenum +gl_CMYK = 0x800C + +gl_CMYKA :: GLenum +gl_CMYKA = 0x800D + +gl_PACK_CMYK_HINT :: GLenum +gl_PACK_CMYK_HINT = 0x800E + +gl_UNPACK_CMYK_HINT :: GLenum +gl_UNPACK_CMYK_HINT = 0x800F diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/ColorSubtable.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/ColorSubtable.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/ColorSubtable.hs @@ -0,0 +1,23 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.ColorSubtable +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_color_subtable extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.ColorSubtable ( + -- * Functions + glColorSubTable, + glCopyColorSubTable +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/CompiledVertexArray.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/CompiledVertexArray.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/CompiledVertexArray.hs @@ -0,0 +1,42 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.CompiledVertexArray +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_compiled_vertex_array extension +-- not already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.CompiledVertexArray ( + -- * Functions + glLockArrays, + glUnlockArrays, + -- * Tokens + gl_ARRAY_ELEMENT_LOCK_FIRST, + gl_ARRAY_ELEMENT_LOCK_COUNT +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_compiled_vertex_array" + +EXTENSION_ENTRY(glLockArrays,GLint -> GLsizei -> IO ()) +EXTENSION_ENTRY(glUnlockArrays,IO ()) + +gl_ARRAY_ELEMENT_LOCK_FIRST :: GLenum +gl_ARRAY_ELEMENT_LOCK_FIRST = 0x81A8 + +gl_ARRAY_ELEMENT_LOCK_COUNT :: GLenum +gl_ARRAY_ELEMENT_LOCK_COUNT = 0x81A9 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/CoordinateFrame.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/CoordinateFrame.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/CoordinateFrame.hs @@ -0,0 +1,131 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.CoordinateFrame +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_coordinate_frame extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.CoordinateFrame ( + -- * Functions + glTangent3b, + glTangent3d, + glTangent3f, + glTangent3i, + glTangent3s, + glTangent3bv, + glTangent3dv, + glTangent3fv, + glTangent3iv, + glTangent3sv, + glBinormal3b, + glBinormal3d, + glBinormal3f, + glBinormal3i, + glBinormal3s, + glBinormal3bv, + glBinormal3dv, + glBinormal3iv, + glBinormal3fv, + glBinormal3sv, + glTangentPointer, + glBinormalPointer, + -- * Tokens + gl_TANGENT_ARRAY, + gl_BINORMAL_ARRAY, + gl_CURRENT_TANGENT, + gl_CURRENT_BINORMAL, + gl_TANGENT_ARRAY_TYPE, + gl_TANGENT_ARRAY_STRIDE, + gl_BINORMAL_ARRAY_TYPE, + gl_BINORMAL_ARRAY_STRIDE, + gl_TANGENT_ARRAY_POINTER, + gl_BINORMAL_ARRAY_POINTER, + gl_MAP1_TANGENT, + gl_MAP2_TANGENT, + gl_MAP1_BINORMAL, + gl_MAP2_BINORMAL +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_coordinate_frame" + +EXTENSION_ENTRY(glTangent3b,GLbyte -> IO ()) +EXTENSION_ENTRY(glTangent3d,GLdouble -> IO ()) +EXTENSION_ENTRY(glTangent3f,GLfloat -> IO ()) +EXTENSION_ENTRY(glTangent3i,GLint -> IO ()) +EXTENSION_ENTRY(glTangent3s,GLshort -> IO ()) +EXTENSION_ENTRY(glTangent3bv,Ptr GLbyte -> IO ()) +EXTENSION_ENTRY(glTangent3dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glTangent3fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glTangent3iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTangent3sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glBinormal3b,GLbyte -> IO ()) +EXTENSION_ENTRY(glBinormal3d,GLdouble -> IO ()) +EXTENSION_ENTRY(glBinormal3f,GLfloat -> IO ()) +EXTENSION_ENTRY(glBinormal3i,GLint -> IO ()) +EXTENSION_ENTRY(glBinormal3s,GLshort -> IO ()) +EXTENSION_ENTRY(glBinormal3bv,Ptr GLbyte -> IO ()) +EXTENSION_ENTRY(glBinormal3dv,Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glBinormal3fv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glBinormal3iv,Ptr GLint -> IO ()) +EXTENSION_ENTRY(glBinormal3sv,Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glTangentPointer,GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glBinormalPointer,GLenum -> GLsizei -> Ptr a -> IO ()) + +gl_TANGENT_ARRAY :: GLenum +gl_TANGENT_ARRAY = 0x8439 + +gl_BINORMAL_ARRAY :: GLenum +gl_BINORMAL_ARRAY = 0x843A + +gl_CURRENT_TANGENT :: GLenum +gl_CURRENT_TANGENT = 0x843B + +gl_CURRENT_BINORMAL :: GLenum +gl_CURRENT_BINORMAL = 0x843C + +gl_TANGENT_ARRAY_TYPE :: GLenum +gl_TANGENT_ARRAY_TYPE = 0x843E + +gl_TANGENT_ARRAY_STRIDE :: GLenum +gl_TANGENT_ARRAY_STRIDE = 0x843F + +gl_BINORMAL_ARRAY_TYPE :: GLenum +gl_BINORMAL_ARRAY_TYPE = 0x8440 + +gl_BINORMAL_ARRAY_STRIDE :: GLenum +gl_BINORMAL_ARRAY_STRIDE = 0x8441 + +gl_TANGENT_ARRAY_POINTER :: GLenum +gl_TANGENT_ARRAY_POINTER = 0x8442 + +gl_BINORMAL_ARRAY_POINTER :: GLenum +gl_BINORMAL_ARRAY_POINTER = 0x8443 + +gl_MAP1_TANGENT :: GLenum +gl_MAP1_TANGENT = 0x8444 + +gl_MAP2_TANGENT :: GLenum +gl_MAP2_TANGENT = 0x8445 + +gl_MAP1_BINORMAL :: GLenum +gl_MAP1_BINORMAL = 0x8446 + +gl_MAP2_BINORMAL :: GLenum +gl_MAP2_BINORMAL = 0x8447 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/CullVertex.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/CullVertex.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/CullVertex.hs @@ -0,0 +1,48 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.CullVertex +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_cull_vertex extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.CullVertex ( + -- * Functions + glCullParameterfv, + glCullParameterdv, + -- * Tokens + gl_CULL_VERTEX, + gl_CULL_VERTEX_EYE_POSITION, + gl_CULL_VERTEX_OBJECT_POSITION +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_cull_vertex" + +EXTENSION_ENTRY(glCullParameterfv,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glCullParameterdv,GLenum -> Ptr GLdouble -> IO ()) + + +gl_CULL_VERTEX :: GLenum +gl_CULL_VERTEX = 0x81AA + +gl_CULL_VERTEX_EYE_POSITION :: GLenum +gl_CULL_VERTEX_EYE_POSITION = 0x81AB + +gl_CULL_VERTEX_OBJECT_POSITION :: GLenum +gl_CULL_VERTEX_OBJECT_POSITION = 0x81AC diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/DepthBoundsTest.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/DepthBoundsTest.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/DepthBoundsTest.hs @@ -0,0 +1,40 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.DepthBoundsTest +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_depth_bounds_test extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.DepthBoundsTest ( + -- * Functions + glDepthBounds, + -- * Tokens + gl_DEPTH_BOUNDS_TEST, + gl_DEPTH_BOUNDS +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_depth_bounds_test" + +EXTENSION_ENTRY(glDepthBounds,GLclampd -> GLclampd -> IO()) + +gl_DEPTH_BOUNDS_TEST :: GLenum +gl_DEPTH_BOUNDS_TEST = 0x8890 + +gl_DEPTH_BOUNDS :: GLenum +gl_DEPTH_BOUNDS = 0x8891 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/DirectStateAccess.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/DirectStateAccess.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/DirectStateAccess.hs @@ -0,0 +1,425 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.DirectStateAccess +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_direct_state_access extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.DirectStateAccess ( + -- * Functions + glClientAttribDefault, + glPushClientAttribDefault, + glMatrixLoadf, + glMatrixLoadd, + glMatrixMultf, + glMatrixMultd, + glMatrixLoadIdentity, + glMatrixRotatef, + glMatrixRotated, + glMatrixScalef, + glMatrixScaled, + glMatrixTranslatef, + glMatrixTranslated, + glMatrixOrtho, + glMatrixFrustum, + glMatrixPush, + glMatrixPop, + glTextureParameteri, + glTextureParameteriv, + glTextureParameterf, + glTextureParameterfv, + glTextureImage1D, + glTextureImage2D, + glTextureSubImage1D, + glTextureSubImage2D, + glCopyTextureImage1D, + glCopyTextureImage2D, + glCopyTextureSubImage1D, + glCopyTextureSubImage2D, + glGetTextureImage, + glGetTextureParameterfv, + glGetTextureParameteriv, + glGetTextureLevelParameterfv, + glGetTextureLevelParameteriv, + glTextureImage3D, + glTextureSubImage3D, + glCopyTextureSubImage3D, + glBindMultiTexture, + glMultiTexCoordPointer, + glMultiTexEnvf, + glMultiTexEnvfv, + glMultiTexEnvi, + glMultiTexEnviv, + glMultiTexGend, + glMultiTexGendv, + glMultiTexGenf, + glMultiTexGenfv, + glMultiTexGeni, + glMultiTexGeniv, + glGetMultiTexEnvfv, + glGetMultiTexEnviv, + glGetMultiTexGendv, + glGetMultiTexGenfv, + glGetMultiTexGeniv, + glMultiTexParameteri, + glMultiTexParameteriv, + glMultiTexParameterf, + glMultiTexParameterfv, + glMultiTexImage1D, + glMultiTexImage2D, + glMultiTexSubImage1D, + glMultiTexSubImage2D, + glCopyMultiTexImage1D, + glCopyMultiTexImage2D, + glCopyMultiTexSubImage1D, + glCopyMultiTexSubImage2D, + glGetMultiTexImage, + glGetMultiTexParameterfv, + glGetMultiTexParameteriv, + glGetMultiTexLevelParameterfv, + glGetMultiTexLevelParameteriv, + glMultiTexImage3D, + glMultiTexSubImage3D, + glCopyMultiTexSubImage3D, + glEnableClientStateIndexed, + glDisableClientStateIndexed, + glGetFloatIndexedv, + glGetDoubleIndexedv, + glGetPointerIndexedv, + glEnableIndexed, + glDisableIndexed, + glIsEnabledIndexed, + glGetIntegerIndexedv, + glGetBooleanIndexedv, + glNamedProgramString, + glNamedProgramLocalParameter4d, + glNamedProgramLocalParameter4dv, + glNamedProgramLocalParameter4f, + glNamedProgramLocalParameter4fv, + glGetNamedProgramLocalParameterdv, + glGetNamedProgramLocalParameterfv, + glGetNamedProgramiv, + glGetNamedProgramString, + glCompressedTextureImage3D, + glCompressedTextureImage2D, + glCompressedTextureImage1D, + glCompressedTextureSubImage3D, + glCompressedTextureSubImage2D, + glCompressedTextureSubImage1D, + glGetCompressedTextureImage, + glCompressedMultiTexImage3D, + glCompressedMultiTexImage2D, + glCompressedMultiTexImage1D, + glCompressedMultiTexSubImage3D, + glCompressedMultiTexSubImage2D, + glCompressedMultiTexSubImage1D, + glGetCompressedMultiTexImage, + glMatrixLoadTransposef, + glMatrixLoadTransposed, + glMatrixMultTransposef, + glMatrixMultTransposed, + glNamedBufferData, + glNamedBufferSubData, + glMapNamedBuffer, + glUnmapNamedBuffer, + glGetNamedBufferParameteriv, + glGetNamedBufferPointerv, + glGetNamedBufferSubData, + glProgramUniform1f, + glProgramUniform2f, + glProgramUniform3f, + glProgramUniform4f, + glProgramUniform1i, + glProgramUniform2i, + glProgramUniform3i, + glProgramUniform4i, + glProgramUniform1fv, + glProgramUniform2fv, + glProgramUniform3fv, + glProgramUniform4fv, + glProgramUniform1iv, + glProgramUniform2iv, + glProgramUniform3iv, + glProgramUniform4iv, + glProgramUniformMatrix2fv, + glProgramUniformMatrix3fv, + glProgramUniformMatrix4fv, + glProgramUniformMatrix2x3fv, + glProgramUniformMatrix3x2fv, + glProgramUniformMatrix2x4fv, + glProgramUniformMatrix4x2fv, + glProgramUniformMatrix3x4fv, + glProgramUniformMatrix4x3fv, + glTextureBuffer, + glMultiTexBuffer, + glTextureParameterIiv, + glTextureParameterIuiv, + glGetTextureParameterIiv, + glGetTextureParameterIuiv, + glMultiTexParameterIiv, + glMultiTexParameterIuiv, + glGetMultiTexParameterIiv, + glGetMultiTexParameterIuiv, + glProgramUniform1ui, + glProgramUniform2ui, + glProgramUniform3ui, + glProgramUniform4ui, + glProgramUniform1uiv, + glProgramUniform2uiv, + glProgramUniform3uiv, + glProgramUniform4uiv, + glNamedProgramLocalParameters4fv, + glNamedProgramLocalParameterI4i, + glNamedProgramLocalParameterI4iv, + glNamedProgramLocalParametersI4iv, + glNamedProgramLocalParameterI4ui, + glNamedProgramLocalParameterI4uiv, + glNamedProgramLocalParametersI4uiv, + glGetNamedProgramLocalParameterIiv, + glGetNamedProgramLocalParameterIuiv, + glNamedRenderbufferStorage, + glGetNamedRenderbufferParameteriv, + glNamedRenderbufferStorageMultisample, + glNamedRenderbufferStorageMultisampleCoverage, + glCheckNamedFramebufferStatus, + glNamedFramebufferTexture1D, + glNamedFramebufferTexture2D, + glNamedFramebufferTexture3D, + glNamedFramebufferRenderbuffer, + glGetNamedFramebufferAttachmentParameteriv, + glGenerateTextureMipmap, + glGenerateMultiTexMipmap, + glFramebufferDrawBuffer, + glFramebufferDrawBuffers, + glFramebufferReadBuffer, + glGetFramebufferParameteriv, + glNamedFramebufferTexture, + glNamedFramebufferTextureLayer, + glNamedFramebufferTextureFace, + glTextureRenderbuffer, + glMultiTexRenderbuffer, + -- * Tokens + gl_PROGRAM_MATRIX, + gl_TRANSPOSE_PROGRAM_MATRIX, + gl_PROGRAM_MATRIX_STACK_DEPTH +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_direct_state_access" + +EXTENSION_ENTRY(glClientAttribDefault,GLbitfield -> IO ()) +EXTENSION_ENTRY(glPushClientAttribDefault,GLbitfield -> IO ()) +EXTENSION_ENTRY(glMatrixLoadf,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMatrixLoadd,GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMatrixMultf,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMatrixMultd,GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMatrixLoadIdentity,GLenum -> IO ()) +EXTENSION_ENTRY(glMatrixRotatef,GLenum -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMatrixRotated,GLenum -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMatrixScalef,GLenum -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMatrixScaled,GLenum -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMatrixTranslatef,GLenum -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMatrixTranslated,GLenum -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMatrixOrtho,GLenum -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMatrixFrustum,GLenum -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMatrixPush,GLenum -> IO ()) +EXTENSION_ENTRY(glMatrixPop,GLenum -> IO ()) +EXTENSION_ENTRY(glTextureParameteri,GLuint -> GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glTextureParameteriv,GLuint -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTextureParameterf,GLuint -> GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glTextureParameterfv,GLuint -> GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glTextureImage1D,GLuint -> GLenum -> GLint -> GLint -> GLsizei -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glTextureImage2D,GLuint -> GLenum -> GLint -> GLint -> GLsizei -> GLsizei -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glTextureSubImage1D,GLuint -> GLenum -> GLint -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glTextureSubImage2D,GLuint -> GLenum -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCopyTextureImage1D,GLuint -> GLenum -> GLint -> GLenum -> GLint -> GLint -> GLsizei -> GLint -> IO ()) +EXTENSION_ENTRY(glCopyTextureImage2D,GLuint -> GLenum -> GLint -> GLenum -> GLint -> GLint -> GLsizei -> GLsizei -> GLint -> IO ()) +EXTENSION_ENTRY(glCopyTextureSubImage1D,GLuint -> GLenum -> GLint -> GLint -> GLint -> GLint -> GLsizei -> IO ()) +EXTENSION_ENTRY(glCopyTextureSubImage2D,GLuint -> GLenum -> GLint -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glGetTextureImage,GLuint -> GLenum -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetTextureParameterfv,GLuint -> GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetTextureParameteriv,GLuint -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetTextureLevelParameterfv,GLuint -> GLenum -> GLint -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetTextureLevelParameteriv,GLuint -> GLenum -> GLint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTextureImage3D,GLuint -> GLenum -> GLint -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glTextureSubImage3D,GLuint -> GLenum -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCopyTextureSubImage3D,GLuint -> GLenum -> GLint -> GLint -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glBindMultiTexture,GLenum -> GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glMultiTexCoordPointer,GLenum -> GLint -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glMultiTexEnvf,GLenum -> GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexEnvfv,GLenum -> GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexEnvi,GLenum -> GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexEnviv,GLenum -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexGend,GLenum -> GLenum -> GLenum -> GLdouble -> IO ()) +EXTENSION_ENTRY(glMultiTexGendv,GLenum -> GLenum -> GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMultiTexGenf,GLenum -> GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexGenfv,GLenum -> GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexGeni,GLenum -> GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexGeniv,GLenum -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetMultiTexEnvfv,GLenum -> GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetMultiTexEnviv,GLenum -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetMultiTexGendv,GLenum -> GLenum -> GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glGetMultiTexGenfv,GLenum -> GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetMultiTexGeniv,GLenum -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexParameteri,GLenum -> GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexParameteriv,GLenum -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexParameterf,GLenum -> GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexParameterfv,GLenum -> GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMultiTexImage1D,GLenum -> GLenum -> GLint -> GLint -> GLsizei -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glMultiTexImage2D,GLenum -> GLenum -> GLint -> GLint -> GLsizei -> GLsizei -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glMultiTexSubImage1D,GLenum -> GLenum -> GLint -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glMultiTexSubImage2D,GLenum -> GLenum -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCopyMultiTexImage1D,GLenum -> GLenum -> GLint -> GLenum -> GLint -> GLint -> GLsizei -> GLint -> IO ()) +EXTENSION_ENTRY(glCopyMultiTexImage2D,GLenum -> GLenum -> GLint -> GLenum -> GLint -> GLint -> GLsizei -> GLsizei -> GLint -> IO ()) +EXTENSION_ENTRY(glCopyMultiTexSubImage1D,GLenum -> GLenum -> GLint -> GLint -> GLint -> GLint -> GLsizei -> IO ()) +EXTENSION_ENTRY(glCopyMultiTexSubImage2D,GLenum -> GLenum -> GLint -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glGetMultiTexImage,GLenum -> GLenum -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetMultiTexParameterfv,GLenum -> GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetMultiTexParameteriv,GLenum -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetMultiTexLevelParameterfv,GLenum -> GLenum -> GLint -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetMultiTexLevelParameteriv,GLenum -> GLenum -> GLint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexImage3D,GLenum -> GLenum -> GLint -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glMultiTexSubImage3D,GLenum -> GLenum -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCopyMultiTexSubImage3D,GLenum -> GLenum -> GLint -> GLint -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glEnableClientStateIndexed,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glDisableClientStateIndexed,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glGetFloatIndexedv,GLenum -> GLuint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetDoubleIndexedv,GLenum -> GLuint -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glGetPointerIndexedv,GLenum -> GLuint -> Ptr (Ptr a) -> IO ()) +EXTENSION_ENTRY(glEnableIndexed,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glDisableIndexed,GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glIsEnabledIndexed,GLenum -> GLuint -> IO GLboolean) +EXTENSION_ENTRY(glGetIntegerIndexedv,GLenum -> GLuint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetBooleanIndexedv,GLenum -> GLuint -> Ptr GLboolean -> IO ()) +EXTENSION_ENTRY(glNamedProgramString,GLuint -> GLenum -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glNamedProgramLocalParameter4d,GLuint -> GLenum -> GLuint -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) +EXTENSION_ENTRY(glNamedProgramLocalParameter4dv,GLuint -> GLenum -> GLuint -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glNamedProgramLocalParameter4f,GLuint -> GLenum -> GLuint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glNamedProgramLocalParameter4fv,GLuint -> GLenum -> GLuint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetNamedProgramLocalParameterdv,GLuint -> GLenum -> GLuint -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glGetNamedProgramLocalParameterfv,GLuint -> GLenum -> GLuint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetNamedProgramiv,GLuint -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetNamedProgramString,GLuint -> GLenum -> GLenum -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedTextureImage3D,GLuint -> GLenum -> GLint -> GLenum -> GLsizei -> GLsizei -> GLsizei -> GLint -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedTextureImage2D,GLuint -> GLenum -> GLint -> GLenum -> GLsizei -> GLsizei -> GLint -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedTextureImage1D,GLuint -> GLenum -> GLint -> GLenum -> GLsizei -> GLint -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedTextureSubImage3D,GLuint -> GLenum -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedTextureSubImage2D,GLuint -> GLenum -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedTextureSubImage1D,GLuint -> GLenum -> GLint -> GLint -> GLsizei -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetCompressedTextureImage,GLuint -> GLenum -> GLint -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedMultiTexImage3D,GLenum -> GLenum -> GLint -> GLenum -> GLsizei -> GLsizei -> GLsizei -> GLint -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedMultiTexImage2D,GLenum -> GLenum -> GLint -> GLenum -> GLsizei -> GLsizei -> GLint -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedMultiTexImage1D,GLenum -> GLenum -> GLint -> GLenum -> GLsizei -> GLint -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedMultiTexSubImage3D,GLenum -> GLenum -> GLint -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedMultiTexSubImage2D,GLenum -> GLenum -> GLint -> GLint -> GLint -> GLsizei -> GLsizei -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glCompressedMultiTexSubImage1D,GLenum -> GLenum -> GLint -> GLint -> GLsizei -> GLenum -> GLsizei -> Ptr a -> IO ()) +EXTENSION_ENTRY(glGetCompressedMultiTexImage,GLenum -> GLenum -> GLint -> Ptr a -> IO ()) +EXTENSION_ENTRY(glMatrixLoadTransposef,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMatrixLoadTransposed,GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glMatrixMultTransposef,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glMatrixMultTransposed,GLenum -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glNamedBufferData,GLuint -> GLsizeiptr -> Ptr a -> GLenum -> IO ()) +EXTENSION_ENTRY(glNamedBufferSubData,GLuint -> GLintptr -> GLsizeiptr -> Ptr a -> IO ()) +EXTENSION_ENTRY(glMapNamedBuffer,GLuint -> GLenum -> IO ()) +EXTENSION_ENTRY(glUnmapNamedBuffer,GLuint -> IO GLboolean) +EXTENSION_ENTRY(glGetNamedBufferParameteriv,GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetNamedBufferPointerv,GLuint -> GLenum -> Ptr (Ptr a) -> IO ()) +EXTENSION_ENTRY(glGetNamedBufferSubData,GLuint -> GLintptr -> GLsizeiptr -> Ptr a -> IO ()) +EXTENSION_ENTRY(glProgramUniform1f,GLuint -> GLint -> GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniform2f,GLuint -> GLint -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniform3f,GLuint -> GLint -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniform4f,GLuint -> GLint -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniform1i,GLuint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glProgramUniform2i,GLuint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glProgramUniform3i,GLuint -> GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glProgramUniform4i,GLuint -> GLint -> GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glProgramUniform1fv,GLuint -> GLint -> GLsizei -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniform2fv,GLuint -> GLint -> GLsizei -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniform3fv,GLuint -> GLint -> GLsizei -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniform4fv,GLuint -> GLint -> GLsizei -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniform1iv,GLuint -> GLint -> GLsizei -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glProgramUniform2iv,GLuint -> GLint -> GLsizei -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glProgramUniform3iv,GLuint -> GLint -> GLsizei -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glProgramUniform4iv,GLuint -> GLint -> GLsizei -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glProgramUniformMatrix2fv,GLuint -> GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniformMatrix3fv,GLuint -> GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniformMatrix4fv,GLuint -> GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniformMatrix2x3fv,GLuint -> GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniformMatrix3x2fv,GLuint -> GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniformMatrix2x4fv,GLuint -> GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniformMatrix4x2fv,GLuint -> GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniformMatrix3x4fv,GLuint -> GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramUniformMatrix4x3fv,GLuint -> GLint -> GLsizei -> GLboolean -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glTextureBuffer,GLuint -> GLenum -> GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glMultiTexBuffer,GLenum -> GLenum -> GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glTextureParameterIiv,GLuint -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glTextureParameterIuiv,GLuint -> GLenum -> GLenum -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGetTextureParameterIiv,GLuint -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetTextureParameterIuiv,GLuint -> GLenum -> GLenum -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glMultiTexParameterIiv,GLenum -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glMultiTexParameterIuiv,GLenum -> GLenum -> GLenum -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGetMultiTexParameterIiv,GLenum -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetMultiTexParameterIuiv,GLenum -> GLenum -> GLenum -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glProgramUniform1ui,GLuint -> GLint -> GLuint -> IO ()) +EXTENSION_ENTRY(glProgramUniform2ui,GLuint -> GLint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glProgramUniform3ui,GLuint -> GLint -> GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glProgramUniform4ui,GLuint -> GLint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glProgramUniform1uiv,GLuint -> GLint -> GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glProgramUniform2uiv,GLuint -> GLint -> GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glProgramUniform3uiv,GLuint -> GLint -> GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glProgramUniform4uiv,GLuint -> GLint -> GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glNamedProgramLocalParameters4fv,GLuint -> GLenum -> GLuint -> GLsizei -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glNamedProgramLocalParameterI4i,GLuint -> GLenum -> GLuint -> GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glNamedProgramLocalParameterI4iv,GLuint -> GLenum -> GLuint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glNamedProgramLocalParametersI4iv,GLuint -> GLenum -> GLuint -> GLsizei -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glNamedProgramLocalParameterI4ui,GLuint -> GLenum -> GLuint -> GLuint -> GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glNamedProgramLocalParameterI4uiv,GLuint -> GLenum -> GLuint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glNamedProgramLocalParametersI4uiv,GLuint -> GLenum -> GLuint -> GLsizei -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glGetNamedProgramLocalParameterIiv,GLuint -> GLenum -> GLuint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetNamedProgramLocalParameterIuiv,GLuint -> GLenum -> GLuint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glNamedRenderbufferStorage,GLuint -> GLenum -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glGetNamedRenderbufferParameteriv,GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glNamedRenderbufferStorageMultisample,GLuint -> GLsizei -> GLenum -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glNamedRenderbufferStorageMultisampleCoverage,GLuint -> GLsizei -> GLsizei -> GLenum -> GLsizei -> GLsizei -> IO ()) +EXTENSION_ENTRY(glCheckNamedFramebufferStatus,GLuint -> GLenum -> IO GLenum) +EXTENSION_ENTRY(glNamedFramebufferTexture1D,GLuint -> GLenum -> GLenum -> GLuint -> GLint -> IO ()) +EXTENSION_ENTRY(glNamedFramebufferTexture2D,GLuint -> GLenum -> GLenum -> GLuint -> GLint -> IO ()) +EXTENSION_ENTRY(glNamedFramebufferTexture3D,GLuint -> GLenum -> GLenum -> GLuint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glNamedFramebufferRenderbuffer,GLuint -> GLenum -> GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glGetNamedFramebufferAttachmentParameteriv,GLuint -> GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGenerateTextureMipmap,GLuint -> GLenum -> IO ()) +EXTENSION_ENTRY(glGenerateMultiTexMipmap,GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glFramebufferDrawBuffer,GLuint -> GLenum -> IO ()) +EXTENSION_ENTRY(glFramebufferDrawBuffers,GLuint -> GLsizei -> Ptr GLenum -> IO ()) +EXTENSION_ENTRY(glFramebufferReadBuffer,GLuint -> GLenum -> IO ()) +EXTENSION_ENTRY(glGetFramebufferParameteriv,GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glNamedFramebufferTexture,GLuint -> GLenum -> GLuint -> GLint -> IO ()) +EXTENSION_ENTRY(glNamedFramebufferTextureLayer,GLuint -> GLenum -> GLuint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glNamedFramebufferTextureFace,GLuint -> GLenum -> GLuint -> GLint -> GLenum -> IO ()) +EXTENSION_ENTRY(glTextureRenderbuffer,GLuint -> GLenum -> GLuint -> IO ()) +EXTENSION_ENTRY(glMultiTexRenderbuffer,GLenum -> GLenum -> GLuint -> IO ()) + +gl_PROGRAM_MATRIX :: GLenum +gl_PROGRAM_MATRIX = 0x8E2D + +gl_TRANSPOSE_PROGRAM_MATRIX :: GLenum +gl_TRANSPOSE_PROGRAM_MATRIX = 0x8E2E + +gl_PROGRAM_MATRIX_STACK_DEPTH :: GLenum +gl_PROGRAM_MATRIX_STACK_DEPTH = 0x8E2F diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/FogCoord.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/FogCoord.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/FogCoord.hs @@ -0,0 +1,35 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.FogCoord +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_fog_coord extension not already +-- in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.FogCoord ( + -- * Functions + glFogCoordf, + glFogCoordd, + glFogCoordfv, + glFogCoorddv, + glFogCoordPointer, + -- * Tokens + gl_FOG_COORDINATE_SOURCE, + gl_FOG_COORDINATE, + gl_FRAGMENT_DEPTH, + gl_CURRENT_FOG_COORDINATE, + gl_FOG_COORDINATE_ARRAY_TYPE, + gl_FOG_COORDINATE_ARRAY_STRIDE, + gl_FOG_COORDINATE_ARRAY_POINTER, + gl_FOG_COORDINATE_ARRAY +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/FourTwoTwoPixels.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/FourTwoTwoPixels.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/FourTwoTwoPixels.hs @@ -0,0 +1,37 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.FourTwoTwoPixels +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_422_pixels extension not already in +-- the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.FourTwoTwoPixels ( + -- * Tokens + gl_422, + gl_422_REV, + gl_422_AVERAGE, + gl_422_REV_AVERAGE +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_422 :: GLenum +gl_422 = 0x80CC + +gl_422_REV :: GLenum +gl_422_REV = 0x80CD + +gl_422_AVERAGE :: GLenum +gl_422_AVERAGE = 0x80CE + +gl_422_REV_AVERAGE :: GLenum +gl_422_REV_AVERAGE = 0x80CF diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/FragmentLighting.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/FragmentLighting.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/FragmentLighting.hs @@ -0,0 +1,148 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.FragmentLighting +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_fragment_lighting extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.FragmentLighting ( + -- * Functions + glFragmentLightModeli, + glFragmentLightModelf, + glFragmentLightModeliv, + glFragmentLightModelfv, + glFragmentLighti, + glFragmentLightf, + glFragmentLightiv, + glFragmentLightfv, + glGetFragmentLightiv, + glGetFragmentLightfv, + glFragmentMaterialf, + glFragmentMateriali, + glFragmentMaterialfv, + glFragmentMaterialiv, + glFragmentColorMaterial, + glGetFragmentMaterialfv, + glGetFragmentMaterialiv, + glLightEnvi, + -- * Tokens + gl_FRAGMENT_LIGHTING, + gl_FRAGMENT_COLOR_MATERIAL, + gl_FRAGMENT_COLOR_MATERIAL_FACE, + gl_FRAGMENT_COLOR_MATERIAL_PARAMETER, + gl_MAX_FRAGMENT_LIGHTS, + gl_MAX_ACTIVE_LIGHTS, + gl_CURRENT_RASTER_NORMAL, + gl_LIGHT_ENV_MODE, + gl_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER, + gl_FRAGMENT_LIGHT_MODEL_TWO_SIDE, + gl_FRAGMENT_LIGHT_MODEL_AMBIENT, + gl_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION, + gl_FRAGMENT_LIGHT0, + gl_FRAGMENT_LIGHT1, + gl_FRAGMENT_LIGHT2, + gl_FRAGMENT_LIGHT3, + gl_FRAGMENT_LIGHT4, + gl_FRAGMENT_LIGHT5, + gl_FRAGMENT_LIGHT6, + gl_FRAGMENT_LIGHT7 +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_fragment_lighting" + +EXTENSION_ENTRY(glFragmentLightModeli,GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glFragmentLightModelf,GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glFragmentLightModeliv,GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glFragmentLightModelfv,GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glFragmentLighti,GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glFragmentLightf,GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glFragmentLightiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glFragmentLightfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetFragmentLightiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetFragmentLightfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glFragmentMaterialf,GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glFragmentMateriali,GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glFragmentMaterialfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glFragmentMaterialiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glFragmentColorMaterial,GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glGetFragmentMaterialfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetFragmentMaterialiv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glLightEnvi,GLenum -> GLint -> IO ()) + +gl_FRAGMENT_LIGHTING :: GLenum +gl_FRAGMENT_LIGHTING = 0x8400 + +gl_FRAGMENT_COLOR_MATERIAL :: GLenum +gl_FRAGMENT_COLOR_MATERIAL = 0x8401 + +gl_FRAGMENT_COLOR_MATERIAL_FACE :: GLenum +gl_FRAGMENT_COLOR_MATERIAL_FACE = 0x8402 + +gl_FRAGMENT_COLOR_MATERIAL_PARAMETER :: GLenum +gl_FRAGMENT_COLOR_MATERIAL_PARAMETER = 0x8403 + +gl_MAX_FRAGMENT_LIGHTS :: GLenum +gl_MAX_FRAGMENT_LIGHTS = 0x8404 + +gl_MAX_ACTIVE_LIGHTS :: GLenum +gl_MAX_ACTIVE_LIGHTS = 0x8405 + +gl_CURRENT_RASTER_NORMAL :: GLenum +gl_CURRENT_RASTER_NORMAL = 0x8406 + +gl_LIGHT_ENV_MODE :: GLenum +gl_LIGHT_ENV_MODE = 0x8407 + +gl_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER :: GLenum +gl_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER = 0x8408 + +gl_FRAGMENT_LIGHT_MODEL_TWO_SIDE :: GLenum +gl_FRAGMENT_LIGHT_MODEL_TWO_SIDE = 0x8409 + +gl_FRAGMENT_LIGHT_MODEL_AMBIENT :: GLenum +gl_FRAGMENT_LIGHT_MODEL_AMBIENT = 0x840A + +gl_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION :: GLenum +gl_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION = 0x840B + +gl_FRAGMENT_LIGHT0 :: GLenum +gl_FRAGMENT_LIGHT0 = 0x840C + +gl_FRAGMENT_LIGHT1 :: GLenum +gl_FRAGMENT_LIGHT1 = 0x840D + +gl_FRAGMENT_LIGHT2 :: GLenum +gl_FRAGMENT_LIGHT2 = 0x840E + +gl_FRAGMENT_LIGHT3 :: GLenum +gl_FRAGMENT_LIGHT3 = 0x840F + +gl_FRAGMENT_LIGHT4 :: GLenum +gl_FRAGMENT_LIGHT4 = 0x8410 + +gl_FRAGMENT_LIGHT5 :: GLenum +gl_FRAGMENT_LIGHT5 = 0x8411 + +gl_FRAGMENT_LIGHT6 :: GLenum +gl_FRAGMENT_LIGHT6 = 0x8412 + +gl_FRAGMENT_LIGHT7 :: GLenum +gl_FRAGMENT_LIGHT7 = 0x8413 + diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/FramebufferObject.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/FramebufferObject.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/FramebufferObject.hs @@ -0,0 +1,29 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.FramebufferObject +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_framebuffer_object extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.FramebufferObject ( + -- * Tokens + gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS, + gl_FRAMEBUFFER_INCOMPLETE_FORMATS +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9 + +gl_FRAMEBUFFER_INCOMPLETE_FORMATS :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_FORMATS = 0x8CDA diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/FramebufferSRGB.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/FramebufferSRGB.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/FramebufferSRGB.hs @@ -0,0 +1,25 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.FramebufferSRGB +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_framebuffer_sRGB extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.FramebufferSRGB ( + -- * Tokens + gl_FRAMEBUFFER_SRGB_CAPABLE +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_FRAMEBUFFER_SRGB_CAPABLE :: GLenum +gl_FRAMEBUFFER_SRGB_CAPABLE = 0x8DBA diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/GeometryShader4.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/GeometryShader4.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/GeometryShader4.hs @@ -0,0 +1,98 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.GeometryShader4 +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_geometry_shader4 extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.GeometryShader4 ( + -- * Functions + glProgramParameteri, + glFramebufferTexture, + glFramebufferTextureFace, + -- * Tokens + gl_GEOMETRY_SHADER, + gl_GEOMETRY_VERTICES_OUT, + gl_GEOMETRY_INPUT_TYPE, + gl_GEOMETRY_OUTPUT_TYPE, + gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, + gl_MAX_GEOMETRY_VARYING_COMPONENTS, + gl_MAX_VERTEX_VARYING_COMPONENTS, + gl_MAX_GEOMETRY_UNIFORM_COMPONENTS, + gl_MAX_GEOMETRY_OUTPUT_VERTICES, + gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, + gl_LINES_ADJACENCY, + gl_LINE_STRIP_ADJACENCY, + gl_TRIANGLES_ADJACENCY, + gl_TRIANGLE_STRIP_ADJACENCY, + gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS, + gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT, + gl_FRAMEBUFFER_ATTACHMENT_LAYERED, + gl_PROGRAM_POINT_SIZE +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.GeometryShader4 +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_GEOMETRY_SHADER :: GLenum +gl_GEOMETRY_SHADER = 0x8DD9 + +gl_GEOMETRY_VERTICES_OUT :: GLenum +gl_GEOMETRY_VERTICES_OUT = 0x8DDA + +gl_GEOMETRY_INPUT_TYPE :: GLenum +gl_GEOMETRY_INPUT_TYPE = 0x8DDB + +gl_GEOMETRY_OUTPUT_TYPE :: GLenum +gl_GEOMETRY_OUTPUT_TYPE = 0x8DDC + +gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS :: GLenum +gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 + +gl_MAX_GEOMETRY_VARYING_COMPONENTS :: GLenum +gl_MAX_GEOMETRY_VARYING_COMPONENTS = 0x8DDD + +gl_MAX_VERTEX_VARYING_COMPONENTS :: GLenum +gl_MAX_VERTEX_VARYING_COMPONENTS = 0x8DDE + +gl_MAX_GEOMETRY_UNIFORM_COMPONENTS :: GLenum +gl_MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF + +gl_MAX_GEOMETRY_OUTPUT_VERTICES :: GLenum +gl_MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 + +gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS :: GLenum +gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 + +gl_LINES_ADJACENCY :: GLenum +gl_LINES_ADJACENCY = 0xA + +gl_LINE_STRIP_ADJACENCY :: GLenum +gl_LINE_STRIP_ADJACENCY = 0xB + +gl_TRIANGLES_ADJACENCY :: GLenum +gl_TRIANGLES_ADJACENCY = 0xC + +gl_TRIANGLE_STRIP_ADJACENCY :: GLenum +gl_TRIANGLE_STRIP_ADJACENCY = 0xD + +gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 + +gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT = 0x8DA9 + +gl_FRAMEBUFFER_ATTACHMENT_LAYERED :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 + +gl_PROGRAM_POINT_SIZE :: GLenum +gl_PROGRAM_POINT_SIZE = 0x8642 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/GpuProgramParameters.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/GpuProgramParameters.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/GpuProgramParameters.hs @@ -0,0 +1,34 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.GpuProgramParameters +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_gpu_program_parameters extension +-- not already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.GpuProgramParameters ( + -- * Functions + glProgramEnvParameters4fv, + glProgramLocalParameters4fv +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_program_parameters" + +EXTENSION_ENTRY(glProgramEnvParameters4fv,GLenum -> GLuint -> GLsizei -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glProgramLocalParameters4fv,GLenum -> GLuint -> GLsizei -> Ptr GLfloat -> IO ()) diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/IndexArrayFormats.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/IndexArrayFormats.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/IndexArrayFormats.hs @@ -0,0 +1,53 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.IndexArrayFormats +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_index_array_formats extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.IndexArrayFormats ( + -- * Tokens + gl_IUI_V2F, + gl_IUI_V3F, + gl_IUI_N3F_V2F, + gl_IUI_N3F_V3F, + gl_T2F_IUI_V2F, + gl_T2F_IUI_V3F, + gl_T2F_IUI_N3F_V2F, + gl_T2F_IUI_N3F_V3F +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_IUI_V2F :: GLenum +gl_IUI_V2F = 0x81AD + +gl_IUI_V3F :: GLenum +gl_IUI_V3F = 0x81AE + +gl_IUI_N3F_V2F :: GLenum +gl_IUI_N3F_V2F = 0x81AF + +gl_IUI_N3F_V3F :: GLenum +gl_IUI_N3F_V3F = 0x81B0 + +gl_T2F_IUI_V2F :: GLenum +gl_T2F_IUI_V2F = 0x81B1 + +gl_T2F_IUI_V3F :: GLenum +gl_T2F_IUI_V3F = 0x81B2 + +gl_T2F_IUI_N3F_V2F :: GLenum +gl_T2F_IUI_N3F_V2F = 0x81B3 + +gl_T2F_IUI_N3F_V3F :: GLenum +gl_T2F_IUI_N3F_V3F = 0x81B4 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/IndexFunc.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/IndexFunc.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/IndexFunc.hs @@ -0,0 +1,44 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.IndexFunc +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_index_func extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.IndexFunc ( + -- * Functions + glIndexFunc, + -- * Tokens + gl_INDEX_TEST, + gl_INDEX_TEST_FUNC, + gl_INDEX_TEST_REF +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_index_func" + +EXTENSION_ENTRY(glIndexFunc,GLenum -> GLfloat -> IO ()) + +gl_INDEX_TEST :: GLenum +gl_INDEX_TEST = 0x81B5 + +gl_INDEX_TEST_FUNC :: GLenum +gl_INDEX_TEST_FUNC = 0x81B6 + +gl_INDEX_TEST_REF :: GLenum +gl_INDEX_TEST_REF = 0x81B7 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/IndexMaterial.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/IndexMaterial.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/IndexMaterial.hs @@ -0,0 +1,44 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.IndexMaterial +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_index_material extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.IndexMaterial ( + -- * Functions + glIndexMaterial, + -- * Tokens + gl_INDEX_MATERIAL, + gl_INDEX_MATERIAL_PARAMETER, + gl_INDEX_MATERIAL_FACE +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_index_material" + +EXTENSION_ENTRY(glIndexMaterial,GLenum -> GLenum -> IO ()) + +gl_INDEX_MATERIAL :: GLenum +gl_INDEX_MATERIAL = 0x81B8 + +gl_INDEX_MATERIAL_PARAMETER :: GLenum +gl_INDEX_MATERIAL_PARAMETER = 0x81B9 + +gl_INDEX_MATERIAL_FACE :: GLenum +gl_INDEX_MATERIAL_FACE = 0x81BA diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/LightTexture.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/LightTexture.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/LightTexture.hs @@ -0,0 +1,74 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.LightTexture +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_light_texture extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.LightTexture ( + -- * Functions + glApplyTexture, + glTextureLight, + glTextureMaterial, + -- * Tokens + gl_FRAGMENT_MATERIAL, + gl_FRAGMENT_NORMAL, + gl_FRAGMENT_DEPTH, + gl_FRAGMENT_COLOR, + gl_ATTENUATION, + gl_SHADOW_ATTENUATION, + gl_TEXTURE_APPLICATION_MODE, + gl_TEXTURE_LIGHT, + gl_TEXTURE_MATERIAL_FACE, + gl_TEXTURE_MATERIAL_PARAMETER +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_light_texture" + +EXTENSION_ENTRY(glApplyTexture,GLenum -> IO ()) +EXTENSION_ENTRY(glTextureLight,GLenum -> IO ()) +EXTENSION_ENTRY(glTextureMaterial,GLenum -> GLenum -> IO ()) + +gl_FRAGMENT_MATERIAL :: GLenum +gl_FRAGMENT_MATERIAL = 0x8349 + +gl_FRAGMENT_NORMAL :: GLenum +gl_FRAGMENT_NORMAL = 0x834A + +gl_FRAGMENT_COLOR :: GLenum +gl_FRAGMENT_COLOR = 0x834C + +gl_ATTENUATION :: GLenum +gl_ATTENUATION = 0x834D + +gl_SHADOW_ATTENUATION :: GLenum +gl_SHADOW_ATTENUATION = 0x834E + +gl_TEXTURE_APPLICATION_MODE :: GLenum +gl_TEXTURE_APPLICATION_MODE = 0x834F + +gl_TEXTURE_LIGHT :: GLenum +gl_TEXTURE_LIGHT = 0x8350 + +gl_TEXTURE_MATERIAL_FACE :: GLenum +gl_TEXTURE_MATERIAL_FACE = 0x8351 + +gl_TEXTURE_MATERIAL_PARAMETER :: GLenum +gl_TEXTURE_MATERIAL_PARAMETER = 0x8352 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/Multisample.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/Multisample.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/Multisample.hs @@ -0,0 +1,84 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.Multisample +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_multisample extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.Multisample ( + -- * Functions + glSampleMask, + glSamplePattern, + -- * Tokens + gl_SAMPLE_ALPHA_TO_MASK, + gl_SAMPLE_MASK, + gl_MULTISAMPLE_BIT, + gl_1PASS, + gl_2PASS_0, + gl_2PASS_1, + gl_4PASS_0, + gl_4PASS_1, + gl_4PASS_2, + gl_4PASS_3, + gl_SAMPLE_MASK_VALUE, + gl_SAMPLE_MASK_INVERT, + gl_SAMPLE_PATTERN +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_multisample" + +EXTENSION_ENTRY(glSampleMask,GLclampf -> GLboolean -> IO ()) +EXTENSION_ENTRY(glSamplePattern,GLenum -> IO ()) + +gl_SAMPLE_ALPHA_TO_MASK :: GLenum +gl_SAMPLE_ALPHA_TO_MASK = 0x809E + +gl_SAMPLE_MASK :: GLenum +gl_SAMPLE_MASK = 0x80A0 + +gl_1PASS :: GLenum +gl_1PASS = 0x80A1 + +gl_2PASS_0 :: GLenum +gl_2PASS_0 = 0x80A2 + +gl_2PASS_1 :: GLenum +gl_2PASS_1 = 0x80A3 + +gl_4PASS_0 :: GLenum +gl_4PASS_0 = 0x80A4 + +gl_4PASS_1 :: GLenum +gl_4PASS_1 = 0x80A5 + +gl_4PASS_2 :: GLenum +gl_4PASS_2 = 0x80A6 + +gl_4PASS_3 :: GLenum +gl_4PASS_3 = 0x80A7 + +gl_SAMPLE_MASK_VALUE :: GLenum +gl_SAMPLE_MASK_VALUE = 0x80AA + +gl_SAMPLE_MASK_INVERT :: GLenum +gl_SAMPLE_MASK_INVERT = 0x80AB + +gl_SAMPLE_PATTERN :: GLenum +gl_SAMPLE_PATTERN = 0x80AC diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/PackedFloat.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/PackedFloat.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/PackedFloat.hs @@ -0,0 +1,25 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.PackedFloat +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_packed_float extension not already +-- in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.PackedFloat ( + -- * Tokens + gl_RGBA_SIGNED_COMPONENTS +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_RGBA_SIGNED_COMPONENTS :: GLenum +gl_RGBA_SIGNED_COMPONENTS = 0x8C3C diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/PalettedTexture.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/PalettedTexture.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/PalettedTexture.hs @@ -0,0 +1,64 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.PalettedTexture +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_paletted_texture extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.PalettedTexture ( + -- * Functions + glColorTable, + glColorSubTable, + glGetColorTable, + glGetColorTableParameteriv, + glGetColorTableParameterfv, + -- * Tokens + gl_COLOR_INDEX1, + gl_COLOR_INDEX2, + gl_COLOR_INDEX4, + gl_COLOR_INDEX8, + gl_COLOR_INDEX12, + gl_COLOR_INDEX16, + gl_COLOR_TABLE_FORMAT, + gl_COLOR_TABLE_WIDTH, + gl_COLOR_TABLE_RED_SIZE, + gl_COLOR_TABLE_GREEN_SIZE, + gl_COLOR_TABLE_BLUE_SIZE, + gl_COLOR_TABLE_ALPHA_SIZE, + gl_COLOR_TABLE_LUMINANCE_SIZE, + gl_COLOR_TABLE_INTENSITY_SIZE, + gl_TEXTURE_INDEX_SIZE +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_COLOR_INDEX1 :: GLenum +gl_COLOR_INDEX1 = 0x80E2 + +gl_COLOR_INDEX2 :: GLenum +gl_COLOR_INDEX2 = 0x80E3 + +gl_COLOR_INDEX4 :: GLenum +gl_COLOR_INDEX4 = 0x80E4 + +gl_COLOR_INDEX8 :: GLenum +gl_COLOR_INDEX8 = 0x80E5 + +gl_COLOR_INDEX12 :: GLenum +gl_COLOR_INDEX12 = 0x80E6 + +gl_COLOR_INDEX16 :: GLenum +gl_COLOR_INDEX16 = 0x80E7 + +gl_TEXTURE_INDEX_SIZE :: GLenum +gl_TEXTURE_INDEX_SIZE = 0x80ED diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/PerturbNormal.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/PerturbNormal.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/PerturbNormal.hs @@ -0,0 +1,40 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.PerturbNormal +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_perturb_normal extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.PerturbNormal ( + -- * Functions + glTextureNormal, + -- * Tokens + gl_PERTURB, + gl_TEXTURE_NORMAL +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_perturb_normal" + +EXTENSION_ENTRY(glTextureNormal,GLenum -> IO ()) + +gl_PERTURB :: GLenum +gl_PERTURB = 0x85AE + +gl_TEXTURE_NORMAL :: GLenum +gl_TEXTURE_NORMAL = 0x85AF diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/PixelTransform.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/PixelTransform.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/PixelTransform.hs @@ -0,0 +1,79 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.PixelTransform +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_pixel_transform extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.PixelTransform ( + -- * Functions + glPixelTransformParameteri, + glPixelTransformParameterf, + glPixelTransformParameteriv, + glPixelTransformParameterfv, + glGetPixelTransformParameteriv, + glGetPixelTransformParameterfv, + -- * Tokens + gl_PIXEL_MAG_FILTER, + gl_PIXEL_MIN_FILTER, + gl_PIXEL_CUBIC_WEIGHT, + gl_CUBIC, + gl_AVERAGE, + gl_PIXEL_TRANSFORM_2D, + gl_PIXEL_TRANSFORM_2D_STACK_DEPTH, + gl_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH, + gl_PIXEL_TRANSFORM_2D_MATRIX +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_pixel_transform" + +EXTENSION_ENTRY(glPixelTransformParameteri,GLenum -> GLenum -> GLint -> IO ()) +EXTENSION_ENTRY(glPixelTransformParameterf,GLenum -> GLenum -> GLfloat -> IO ()) +EXTENSION_ENTRY(glPixelTransformParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glPixelTransformParameterfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetPixelTransformParameteriv,GLenum -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetPixelTransformParameterfv,GLenum -> GLenum -> Ptr GLfloat -> IO ()) + +gl_PIXEL_MAG_FILTER :: GLenum +gl_PIXEL_MAG_FILTER = 0x8331 + +gl_PIXEL_MIN_FILTER :: GLenum +gl_PIXEL_MIN_FILTER = 0x8332 + +gl_PIXEL_CUBIC_WEIGHT :: GLenum +gl_PIXEL_CUBIC_WEIGHT = 0x8333 + +gl_CUBIC :: GLenum +gl_CUBIC = 0x8334 + +gl_AVERAGE :: GLenum +gl_AVERAGE = 0x8335 + +gl_PIXEL_TRANSFORM_2D :: GLenum +gl_PIXEL_TRANSFORM_2D = 0x8330 + +gl_PIXEL_TRANSFORM_2D_STACK_DEPTH :: GLenum +gl_PIXEL_TRANSFORM_2D_STACK_DEPTH = 0x8336 + +gl_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH :: GLenum +gl_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH = 0x8337 + +gl_PIXEL_TRANSFORM_2D_MATRIX :: GLenum +gl_PIXEL_TRANSFORM_2D_MATRIX = 0x8338 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/PointParameters.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/PointParameters.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/PointParameters.hs @@ -0,0 +1,24 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.PointParameters +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_point_parameters extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.PointParameters ( + -- * Tokens + gl_POINT_SIZE_MIN, + gl_POINT_SIZE_MAX, + gl_POINT_DISTANCE_ATTENUATION +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/PolygonOffset.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/PolygonOffset.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/PolygonOffset.hs @@ -0,0 +1,25 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.PolygonOffset +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_polygon_offset extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.PolygonOffset ( + -- * Tokens + gl_POLYGON_OFFSET_BIAS +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_POLYGON_OFFSET_BIAS :: GLenum +gl_POLYGON_OFFSET_BIAS = 0x8039 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/ProvokingVertex.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/ProvokingVertex.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/ProvokingVertex.hs @@ -0,0 +1,48 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.ProvokingVertex +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_provoking_vertex extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.ProvokingVertex ( + -- * Functions + glProvokingVertex, + -- * Tokens + gl_FIRST_VERTEX_CONVENTION, + gl_LAST_VERTEX_CONVENTION, + gl_PROVOKING_VERTEX, + gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_provoking_vertex" + +EXTENSION_ENTRY(glProvokingVertex,GLenum -> IO ()) + +gl_FIRST_VERTEX_CONVENTION :: GLenum +gl_FIRST_VERTEX_CONVENTION = 0x8E4D + +gl_LAST_VERTEX_CONVENTION :: GLenum +gl_LAST_VERTEX_CONVENTION = 0x8E4E + +gl_PROVOKING_VERTEX :: GLenum +gl_PROVOKING_VERTEX = 0x8E4F + +gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION :: GLenum +gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/RescaleNormal.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/RescaleNormal.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/RescaleNormal.hs @@ -0,0 +1,22 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.RescaleNormal +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_rescale_normal extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.RescaleNormal ( + -- * Tokens + gl_RESCALE_NORMAL +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/SecondaryColor.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/SecondaryColor.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/SecondaryColor.hs @@ -0,0 +1,46 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.SecondaryColor +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_secondary_color extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.SecondaryColor ( + -- * Tokens + glSecondaryColor3b, + glSecondaryColor3s, + glSecondaryColor3i, + glSecondaryColor3f, + glSecondaryColor3d, + glSecondaryColor3ub, + glSecondaryColor3us, + glSecondaryColor3ui, + glSecondaryColor3bv, + glSecondaryColor3sv, + glSecondaryColor3iv, + glSecondaryColor3fv, + glSecondaryColor3dv, + glSecondaryColor3ubv, + glSecondaryColor3usv, + glSecondaryColor3uiv, + glSecondaryColorPointer, + -- * Tokens + gl_COLOR_SUM, + gl_CURRENT_SECONDARY_COLOR, + gl_SECONDARY_COLOR_ARRAY_SIZE, + gl_SECONDARY_COLOR_ARRAY_TYPE, + gl_SECONDARY_COLOR_ARRAY_STRIDE, + gl_SECONDARY_COLOR_ARRAY_POINTER, + gl_SECONDARY_COLOR_ARRAY +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/SeparateSpecularColor.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/SeparateSpecularColor.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/SeparateSpecularColor.hs @@ -0,0 +1,24 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.SeparateSpecularColor +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_separate_specular_color extension +-- not already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.SeparateSpecularColor ( + -- * Tokens + gl_LIGHT_MODEL_COLOR_CONTROL, + gl_SINGLE_COLOR, + gl_SEPARATE_SPECULAR_COLOR +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/SharedTexturePalette.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/SharedTexturePalette.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/SharedTexturePalette.hs @@ -0,0 +1,25 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.SharedTexturePalette +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_shared_texture_palette extension +-- not already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.SharedTexturePalette ( + -- * Tokens + gl_SHARED_TEXTURE_PALETTE +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_SHARED_TEXTURE_PALETTE :: GLenum +gl_SHARED_TEXTURE_PALETTE = 0x81FB diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/StencilClearTag.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/StencilClearTag.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/StencilClearTag.hs @@ -0,0 +1,40 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.StencilClearTag +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_stencil_clear_tag extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.StencilClearTag ( + -- * Functions + glStencilClearTag, + -- * Tokens + gl_STENCIL_TAG_BITS, + gl_STENCIL_CLEAR_TAG_VALUE +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_stencil_clear_tag" + +EXTENSION_ENTRY(glStencilClearTag,GLsizei -> GLuint -> IO ()) + +gl_STENCIL_TAG_BITS :: GLenum +gl_STENCIL_TAG_BITS = 0x88F2 + +gl_STENCIL_CLEAR_TAG_VALUE :: GLenum +gl_STENCIL_CLEAR_TAG_VALUE = 0x88F3 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/StencilTwoSide.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/StencilTwoSide.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/StencilTwoSide.hs @@ -0,0 +1,40 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.StencilTwoSide +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_stencil_two_side extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.StencilTwoSide ( + -- * Functions + glActiveStencilFace, + -- * Tokens + gl_STENCIL_TEST_TWO_SIDE, + gl_ACTIVE_STENCIL_FACE +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_stencil_two_side" + +EXTENSION_ENTRY(glActiveStencilFace,GLenum -> IO ()) + +gl_STENCIL_TEST_TWO_SIDE :: GLenum +gl_STENCIL_TEST_TWO_SIDE = 0x8910 + +gl_ACTIVE_STENCIL_FACE :: GLenum +gl_ACTIVE_STENCIL_FACE = 0x8911 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/Texture.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/Texture.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/Texture.hs @@ -0,0 +1,47 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.Texture +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture extension not already in +-- the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.Texture ( + -- * Tokens + gl_ALPHA4, + gl_ALPHA8, + gl_ALPHA12, + gl_ALPHA16, + gl_LUMINANCE4, + gl_LUMINANCE8, + gl_LUMINANCE12, + gl_LUMINANCE16, + gl_LUMINANCE4_ALPHA4, + gl_LUMINANCE6_ALPHA2, + gl_LUMINANCE8_ALPHA8, + gl_LUMINANCE12_ALPHA4, + gl_LUMINANCE12_ALPHA12, + gl_LUMINANCE16_ALPHA16, + gl_INTENSITY, + gl_INTENSITY4, + gl_INTENSITY8, + gl_INTENSITY12, + gl_INTENSITY16, + gl_RGB2, + gl_TEXTURE_LUMINANCE_SIZE, + gl_TEXTURE_INTENSITY_SIZE +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_RGB2 :: GLenum +gl_RGB2 = 0x804E diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureCompressionDxt1.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureCompressionDxt1.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureCompressionDxt1.hs @@ -0,0 +1,23 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionDxt1 +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_compression_dxt1 extension +-- not already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionDxt1 ( + -- * Tokens + gl_COMPRESSED_RGB_S3TC_DXT1, + gl_COMPRESSED_RGBA_S3TC_DXT1 +) where + +import Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionS3tc diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureCompressionLatc.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureCompressionLatc.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureCompressionLatc.hs @@ -0,0 +1,37 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionLatc +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_compression_latc extension +-- not already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionLatc ( + -- * Tokens + gl_COMPRESSED_LUMINANCE_LATC1, + gl_COMPRESSED_SIGNED_LUMINANCE_LATC1, + gl_COMPRESSED_LUMINANCE_ALPHA_LATC2, + gl_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2 +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_COMPRESSED_LUMINANCE_LATC1 :: GLenum +gl_COMPRESSED_LUMINANCE_LATC1 = 0x8C70 + +gl_COMPRESSED_SIGNED_LUMINANCE_LATC1 :: GLenum +gl_COMPRESSED_SIGNED_LUMINANCE_LATC1 = 0x8C71 + +gl_COMPRESSED_LUMINANCE_ALPHA_LATC2 :: GLenum +gl_COMPRESSED_LUMINANCE_ALPHA_LATC2 = 0x8C72 + +gl_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2 :: GLenum +gl_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2 = 0x8C73 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureCompressionS3tc.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureCompressionS3tc.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureCompressionS3tc.hs @@ -0,0 +1,37 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionS3tc +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_compression_s3tc extension +-- not already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureCompressionS3tc ( + -- * Tokens + gl_COMPRESSED_RGB_S3TC_DXT1, + gl_COMPRESSED_RGBA_S3TC_DXT1, + gl_COMPRESSED_RGBA_S3TC_DXT3, + gl_COMPRESSED_RGBA_S3TC_DXT5 +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_COMPRESSED_RGB_S3TC_DXT1 :: GLenum +gl_COMPRESSED_RGB_S3TC_DXT1 = 0x83F0 + +gl_COMPRESSED_RGBA_S3TC_DXT1 :: GLenum +gl_COMPRESSED_RGBA_S3TC_DXT1 = 0x83F1 + +gl_COMPRESSED_RGBA_S3TC_DXT3 :: GLenum +gl_COMPRESSED_RGBA_S3TC_DXT3 = 0x83F2 + +gl_COMPRESSED_RGBA_S3TC_DXT5 :: GLenum +gl_COMPRESSED_RGBA_S3TC_DXT5 = 0x83F3 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureEnvAdd.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureEnvAdd.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureEnvAdd.hs @@ -0,0 +1,22 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvAdd +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_env_add extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvAdd ( + -- * Tokens + gl_ADD +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureEnvCombine.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureEnvCombine.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureEnvCombine.hs @@ -0,0 +1,45 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvCombine +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_env_combine extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvCombine ( + -- * Tokens + gl_COMBINE, + gl_COMBINE_RGB, + gl_COMBINE_ALPHA, + gl_SOURCE0_RGB, + gl_SOURCE1_RGB, + gl_SOURCE2_RGB, + gl_SOURCE0_ALPHA, + gl_SOURCE1_ALPHA, + gl_SOURCE2_ALPHA, + gl_OPERAND0_RGB, + gl_OPERAND1_RGB, + gl_OPERAND2_RGB, + gl_OPERAND0_ALPHA, + gl_OPERAND1_ALPHA, + gl_OPERAND2_ALPHA, + gl_RGB_SCALE, + gl_ALPHA_SCALE, + gl_MODULATE, + gl_ADD, + gl_ADD_SIGNED, + gl_INTERPOLATE, + gl_CONSTANT, + gl_PRIMARY_COLOR, + gl_PREVIOUS +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureEnvDot3.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureEnvDot3.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureEnvDot3.hs @@ -0,0 +1,23 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvDot3 +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_env_dot3 extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureEnvDot3 ( + -- * Tokens + gl_DOT3_RGB, + gl_DOT3_RGBA +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureFilterAnisotropic.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureFilterAnisotropic.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureFilterAnisotropic.hs @@ -0,0 +1,29 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureFilterAnisotropic +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_filter_anisotropic +-- extension not already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureFilterAnisotropic ( + -- * Tokens + gl_TEXTURE_MAX_ANISOTROPY, + gl_MAX_TEXTURE_MAX_ANISOTROPY +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_TEXTURE_MAX_ANISOTROPY :: GLenum +gl_TEXTURE_MAX_ANISOTROPY = 0x84FE + +gl_MAX_TEXTURE_MAX_ANISOTROPY :: GLenum +gl_MAX_TEXTURE_MAX_ANISOTROPY = 0x84FF diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureInteger.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureInteger.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureInteger.hs @@ -0,0 +1,140 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureInteger +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_integer extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureInteger ( + -- * Functions + glClearColorIi, + glClearColorIui, + -- * Tokens + gl_ALPHA32UI, + gl_INTENSITY32UI, + gl_LUMINANCE32UI, + gl_LUMINANCE_ALPHA32UI, + gl_ALPHA16UI, + gl_INTENSITY16UI, + gl_LUMINANCE16UI, + gl_LUMINANCE_ALPHA16UI, + gl_ALPHA8UI, + gl_INTENSITY8UI, + gl_LUMINANCE8UI, + gl_LUMINANCE_ALPHA8UI, + gl_ALPHA32I, + gl_INTENSITY32I, + gl_LUMINANCE32I, + gl_LUMINANCE_ALPHA32I, + gl_ALPHA16I, + gl_INTENSITY16I, + gl_LUMINANCE16I, + gl_LUMINANCE_ALPHA16I, + gl_ALPHA8I, + gl_INTENSITY8I, + gl_LUMINANCE8I, + gl_LUMINANCE_ALPHA8I, + gl_ALPHA_INTEGER, + gl_LUMINANCE_INTEGER, + gl_LUMINANCE_ALPHA_INTEGER +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_texture_integer" + +EXTENSION_ENTRY(glClearColorIi,GLint -> GLint -> GLint -> GLint -> IO ()) +EXTENSION_ENTRY(glClearColorIui,GLuint -> GLuint -> GLuint -> GLuint -> IO ()) + +gl_ALPHA32UI :: GLenum +gl_ALPHA32UI = 0x8D72 + +gl_INTENSITY32UI :: GLenum +gl_INTENSITY32UI = 0x8D73 + +gl_LUMINANCE32UI :: GLenum +gl_LUMINANCE32UI = 0x8D74 + +gl_LUMINANCE_ALPHA32UI :: GLenum +gl_LUMINANCE_ALPHA32UI = 0x8D75 + +gl_ALPHA16UI :: GLenum +gl_ALPHA16UI = 0x8D78 + +gl_INTENSITY16UI :: GLenum +gl_INTENSITY16UI = 0x8D79 + +gl_LUMINANCE16UI :: GLenum +gl_LUMINANCE16UI = 0x8D7A + +gl_LUMINANCE_ALPHA16UI :: GLenum +gl_LUMINANCE_ALPHA16UI = 0x8D7B + +gl_ALPHA8UI :: GLenum +gl_ALPHA8UI = 0x8D7E + +gl_INTENSITY8UI :: GLenum +gl_INTENSITY8UI = 0x8D7F + +gl_LUMINANCE8UI :: GLenum +gl_LUMINANCE8UI = 0x8D80 + +gl_LUMINANCE_ALPHA8UI :: GLenum +gl_LUMINANCE_ALPHA8UI = 0x8D81 + +gl_ALPHA32I :: GLenum +gl_ALPHA32I = 0x8D84 + +gl_INTENSITY32I :: GLenum +gl_INTENSITY32I = 0x8D85 + +gl_LUMINANCE32I :: GLenum +gl_LUMINANCE32I = 0x8D86 + +gl_LUMINANCE_ALPHA32I :: GLenum +gl_LUMINANCE_ALPHA32I = 0x8D87 + +gl_ALPHA16I :: GLenum +gl_ALPHA16I = 0x8D8A + +gl_INTENSITY16I :: GLenum +gl_INTENSITY16I = 0x8D8B + +gl_LUMINANCE16I :: GLenum +gl_LUMINANCE16I = 0x8D8C + +gl_LUMINANCE_ALPHA16I :: GLenum +gl_LUMINANCE_ALPHA16I = 0x8D8D + +gl_ALPHA8I :: GLenum +gl_ALPHA8I = 0x8D90 + +gl_INTENSITY8I :: GLenum +gl_INTENSITY8I = 0x8D91 + +gl_LUMINANCE8I :: GLenum +gl_LUMINANCE8I = 0x8D92 + +gl_LUMINANCE_ALPHA8I :: GLenum +gl_LUMINANCE_ALPHA8I = 0x8D93 + +gl_LUMINANCE_INTEGER :: GLenum +gl_LUMINANCE_INTEGER = 0x8D9C + +gl_LUMINANCE_ALPHA_INTEGER :: GLenum +gl_LUMINANCE_ALPHA_INTEGER = 0x8D9D diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureLodBias.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureLodBias.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureLodBias.hs @@ -0,0 +1,22 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureLodBias +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_lod_bias extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureLodBias ( + -- * Tokens + gl_TEXTURE_FILTER_CONTROL +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureMirrorClamp.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureMirrorClamp.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureMirrorClamp.hs @@ -0,0 +1,33 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureMirrorClamp +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_mirror_clamp extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureMirrorClamp ( + -- * Tokens + gl_MIRROR_CLAMP, + gl_MIRROR_CLAMP_TO_EDGE, + gl_MIRROR_CLAMP_TO_BORDER +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_MIRROR_CLAMP :: GLenum +gl_MIRROR_CLAMP = 0x8742 + +gl_MIRROR_CLAMP_TO_EDGE :: GLenum +gl_MIRROR_CLAMP_TO_EDGE = 0x8743 + +gl_MIRROR_CLAMP_TO_BORDER :: GLenum +gl_MIRROR_CLAMP_TO_BORDER = 0x8912 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureObject.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureObject.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureObject.hs @@ -0,0 +1,26 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureObject +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_object extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureObject ( + -- * Functions + glPrioritizeTextures, + glAreTexturesResident, + -- * Tokens + gl_TEXTURE_PRIORITY, + gl_TEXTURE_RESIDENT +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureSRGB.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureSRGB.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureSRGB.hs @@ -0,0 +1,44 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureSRGB +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_sRGB extension not already +-- in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureSRGB ( + -- * Tokens + gl_SLUMINANCE_ALPHA, + gl_SLUMINANCE8_ALPHA8, + gl_SLUMINANCE, + gl_SLUMINANCE8, + gl_COMPRESSED_SLUMINANCE, + gl_COMPRESSED_SLUMINANCE_ALPHA, + gl_COMPRESSED_SRGB_S3TC_DXT1, + gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1, + gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3, + gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5 +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_COMPRESSED_SRGB_S3TC_DXT1 :: GLenum +gl_COMPRESSED_SRGB_S3TC_DXT1 = 0x8C4C + +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1 :: GLenum +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1 = 0x8C4D + +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3 :: GLenum +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3 = 0x8C4E + +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5 :: GLenum +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5 = 0x8C4F diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureSwizzle.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureSwizzle.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TextureSwizzle.hs @@ -0,0 +1,37 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TextureSwizzle +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_texture_swizzle extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TextureSwizzle ( + -- * Tokens + gl_TEXTURE_SWIZZLE_R, + gl_TEXTURE_SWIZZLE_G, + gl_TEXTURE_SWIZZLE_B, + gl_TEXTURE_SWIZZLE_A +) where + +import Graphics.Rendering.OpenGL.Raw.Core31 + +gl_TEXTURE_SWIZZLE_R :: GLenum +gl_TEXTURE_SWIZZLE_R = 0x8E42 + +gl_TEXTURE_SWIZZLE_G :: GLenum +gl_TEXTURE_SWIZZLE_G = 0x8E43 + +gl_TEXTURE_SWIZZLE_B :: GLenum +gl_TEXTURE_SWIZZLE_B = 0x8E44 + +gl_TEXTURE_SWIZZLE_A :: GLenum +gl_TEXTURE_SWIZZLE_A = 0x8E45 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/TimerQuery.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/TimerQuery.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/TimerQuery.hs @@ -0,0 +1,46 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.TimerQuery +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_timer_query extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.TimerQuery ( + -- * Functions + glGetQueryObjecti64v, + glGetQueryObjectui64v, + -- * Tokens + gl_TIME_ELAPSED, + -- * Types + GLint64, + GLuint64 +) where + +import Foreign.C.Types +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_timer_query" + +EXTENSION_ENTRY(glGetQueryObjecti64v,GLuint -> GLenum -> Ptr GLint64 -> IO ()) +EXTENSION_ENTRY(glGetQueryObjectui64v,GLuint -> GLenum -> Ptr GLuint64 -> IO ()) + +gl_TIME_ELAPSED :: GLenum +gl_TIME_ELAPSED = 0x88BF + +type GLint64 = CLLong +type GLuint64 = CULLong diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/VertexArray.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/VertexArray.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/VertexArray.hs @@ -0,0 +1,61 @@ +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.VertexArray +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_vertex_array extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.VertexArray ( + -- * Functions + glArrayElement, + glVertexPointer, + glNormalPointer, + glColorPointer, + glIndexPointer, + glTexCoordPointer, + glEdgeFlagPointer, + -- * Tokens + gl_VERTEX_ARRAY, + gl_NORMAL_ARRAY, + gl_COLOR_ARRAY, + gl_INDEX_ARRAY, + gl_TEXTURE_COORD_ARRAY, + gl_EDGE_FLAG_ARRAY, + gl_VERTEX_ARRAY_SIZE, + gl_VERTEX_ARRAY_TYPE, + gl_VERTEX_ARRAY_STRIDE, + gl_VERTEX_ARRAY_COUNT, + gl_NORMAL_ARRAY_TYPE, + gl_NORMAL_ARRAY_STRIDE, + gl_NORMAL_ARRAY_COUNT, + gl_COLOR_ARRAY_SIZE, + gl_COLOR_ARRAY_TYPE, + gl_COLOR_ARRAY_STRIDE, + gl_COLOR_ARRAY_COUNT, + gl_INDEX_ARRAY_TYPE, + gl_INDEX_ARRAY_STRIDE, + gl_INDEX_ARRAY_COUNT, + gl_TEXTURE_COORD_ARRAY_SIZE, + gl_TEXTURE_COORD_ARRAY_TYPE, + gl_TEXTURE_COORD_ARRAY_STRIDE, + gl_TEXTURE_COORD_ARRAY_COUNT, + gl_EDGE_FLAG_ARRAY_STRIDE, + gl_EDGE_FLAG_ARRAY_COUNT, + gl_VERTEX_ARRAY_POINTER, + gl_NORMAL_ARRAY_POINTER, + gl_COLOR_ARRAY_POINTER, + gl_INDEX_ARRAY_POINTER, + gl_TEXTURE_COORD_ARRAY_POINTER, + gl_EDGE_FLAG_ARRAY_POINTER +) where + +import Graphics.Rendering.OpenGL.Raw.ARB.Compatibility diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/VertexShader.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/VertexShader.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/VertexShader.hs @@ -0,0 +1,543 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.VertexShader +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_vertex_shader extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.VertexShader ( + -- * Functions + glBeginVertexShader, + glEndVertexShader, + glBindVertexShader, + glGenVertexShaders, + glDeleteVertexShader, + glShaderOp1, + glShaderOp2, + glShaderOp3, + glSwizzle, + glWriteMask, + glInsertComponent, + glExtractComponent, + glGenSymbols, + glSetInvariant, + glSetLocalConstant, + glVariantbv, + glVariantsv, + glVariantiv, + glVariantfv, + glVariantdv, + glVariantubv, + glVariantusv, + glVariantuiv, + glVariantPointer, + glEnableVariantClientState, + glDisableVariantClientState, + glBindLightParameter, + glBindMaterialParameter, + glBindTexGenParameter, + glBindTextureUnitParameter, + glBindParameter, + glIsVariantEnabled, + glGetVariantBooleanv, + glGetVariantIntegerv, + glGetVariantFloatv, + glGetVariantPointerv, + glGetInvariantBooleanv, + glGetInvariantIntegerv, + glGetInvariantFloatv, + glGetLocalConstantBooleanv, + glGetLocalConstantIntegerv, + glGetLocalConstantFloatv, + -- * Tokens + gl_VARIANT_VALUE, + gl_VARIANT_DATATYPE, + gl_VARIANT_ARRAY_STRIDE, + gl_VARIANT_ARRAY_TYPE, + gl_VARIANT_ARRAY, + gl_VARIANT_ARRAY_POINTER, + gl_INVARIANT_VALUE, + gl_INVARIANT_DATATYPE, + gl_LOCAL_CONSTANT_VALUE, + gl_LOCAL_CONSTANT_DATATYPE, + gl_OP_INDEX, + gl_OP_NEGATE, + gl_OP_DOT3, + gl_OP_DOT4, + gl_OP_MUL, + gl_OP_ADD, + gl_OP_MADD, + gl_OP_FRAC, + gl_OP_MAX, + gl_OP_MIN, + gl_OP_SET_GE, + gl_OP_SET_LT, + gl_OP_CLAMP, + gl_OP_FLOOR, + gl_OP_ROUND, + gl_OP_EXP_BASE_2, + gl_OP_LOG_BASE_2, + gl_OP_POWER, + gl_OP_RECIP, + gl_OP_RECIP_SQRT, + gl_OP_SUB, + gl_OP_CROSS_PRODUCT, + gl_OP_MULTIPLY_MATRIX, + gl_OP_MOV, + gl_OUTPUT_VERTEX, + gl_OUTPUT_COLOR0, + gl_OUTPUT_COLOR1, + gl_OUTPUT_TEXTURE_COORD0, + gl_OUTPUT_TEXTURE_COORD1, + gl_OUTPUT_TEXTURE_COORD2, + gl_OUTPUT_TEXTURE_COORD3, + gl_OUTPUT_TEXTURE_COORD4, + gl_OUTPUT_TEXTURE_COORD5, + gl_OUTPUT_TEXTURE_COORD6, + gl_OUTPUT_TEXTURE_COORD7, + gl_OUTPUT_TEXTURE_COORD8, + gl_OUTPUT_TEXTURE_COORD9, + gl_OUTPUT_TEXTURE_COORD10, + gl_OUTPUT_TEXTURE_COORD11, + gl_OUTPUT_TEXTURE_COORD12, + gl_OUTPUT_TEXTURE_COORD13, + gl_OUTPUT_TEXTURE_COORD14, + gl_OUTPUT_TEXTURE_COORD15, + gl_OUTPUT_TEXTURE_COORD16, + gl_OUTPUT_TEXTURE_COORD17, + gl_OUTPUT_TEXTURE_COORD18, + gl_OUTPUT_TEXTURE_COORD19, + gl_OUTPUT_TEXTURE_COORD20, + gl_OUTPUT_TEXTURE_COORD21, + gl_OUTPUT_TEXTURE_COORD22, + gl_OUTPUT_TEXTURE_COORD23, + gl_OUTPUT_TEXTURE_COORD24, + gl_OUTPUT_TEXTURE_COORD25, + gl_OUTPUT_TEXTURE_COORD26, + gl_OUTPUT_TEXTURE_COORD27, + gl_OUTPUT_TEXTURE_COORD28, + gl_OUTPUT_TEXTURE_COORD29, + gl_OUTPUT_TEXTURE_COORD30, + gl_OUTPUT_TEXTURE_COORD31, + gl_OUTPUT_FOG, + gl_SCALAR, + gl_VECTOR, + gl_MATRIX, + gl_VARIANT, + gl_INVARIANT, + gl_LOCAL_CONSTANT, + gl_LOCAL, + gl_MAX_VERTEX_SHADER_INSTRUCTIONS, + gl_MAX_VERTEX_SHADER_VARIANTS, + gl_MAX_VERTEX_SHADER_INVARIANTS, + gl_MAX_VERTEX_SHADER_LOCAL_CONSTANTS, + gl_MAX_VERTEX_SHADER_LOCALS, + gl_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS, + gl_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS, + gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS, + gl_MAX_OPTIMIZED_VERTEX_SHADER_INARIANTS, + gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS, + gl_VERTEX_SHADER_INSTRUCTIONS, + gl_VERTEX_SHADER_VARIANTS, + gl_VERTEX_SHADER_INVARIANTS, + gl_VERTEX_SHADER_LOCAL_CONSTANTS, + gl_VERTEX_SHADER_LOCALS, + gl_VERTEX_SHADER_BINDING, + gl_VERTEX_SHADER_OPTIMIZED, + gl_X, + gl_Y, + gl_Z, + gl_W, + gl_NEGATIVE_X, + gl_NEGATIVE_Y, + gl_NEGATIVE_Z, + gl_NEGATIVE_W, + gl_NEGATIVE_ONE, + gl_NORMALIZED_RANGE, + gl_FULL_RANGE, + gl_CURRENT_VERTEX, + gl_MVP_MATRIX +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_vertex_shader" + +EXTENSION_ENTRY(glBeginVertexShader,IO ()) +EXTENSION_ENTRY(glEndVertexShader,IO ()) +EXTENSION_ENTRY(glBindVertexShader,GLuint -> IO ()) +EXTENSION_ENTRY(glGenVertexShaders,GLuint -> IO GLuint) +EXTENSION_ENTRY(glDeleteVertexShader,GLuint -> IO ()) +EXTENSION_ENTRY(glShaderOp1,GLenum -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glShaderOp2,GLenum -> GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glShaderOp3,GLenum -> GLuint -> GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glSwizzle,GLuint -> GLuint -> GLenum -> GLenum -> GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glWriteMask,GLuint -> GLuint -> GLenum -> GLenum -> GLenum -> GLenum -> IO ()) +EXTENSION_ENTRY(glInsertComponent,GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glExtractComponent,GLuint -> GLuint -> GLuint -> IO ()) +EXTENSION_ENTRY(glGenSymbols,GLenum -> GLenum -> GLenum -> GLuint -> IO GLuint) +EXTENSION_ENTRY(glSetInvariant,GLuint -> GLenum -> Ptr () -> IO ()) +EXTENSION_ENTRY(glSetLocalConstant,GLuint -> GLenum -> Ptr () -> IO ()) +EXTENSION_ENTRY(glVariantbv,GLuint -> Ptr GLbyte -> IO ()) +EXTENSION_ENTRY(glVariantsv,GLuint -> Ptr GLshort -> IO ()) +EXTENSION_ENTRY(glVariantiv,GLuint -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glVariantfv,GLuint -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glVariantdv,GLuint -> Ptr GLdouble -> IO ()) +EXTENSION_ENTRY(glVariantubv,GLuint -> Ptr GLubyte -> IO ()) +EXTENSION_ENTRY(glVariantusv,GLuint -> Ptr GLushort -> IO ()) +EXTENSION_ENTRY(glVariantuiv,GLuint -> Ptr GLuint -> IO ()) +EXTENSION_ENTRY(glVariantPointer,GLuint -> GLenum -> GLuint -> Ptr () -> IO ()) +EXTENSION_ENTRY(glEnableVariantClientState,GLuint-> IO ()) +EXTENSION_ENTRY(glDisableVariantClientState,GLuint-> IO ()) +EXTENSION_ENTRY(glBindLightParameter,GLenum -> GLenum-> IO GLuint) +EXTENSION_ENTRY(glBindMaterialParameter,GLenum -> GLenum-> IO GLuint) +EXTENSION_ENTRY(glBindTexGenParameter,GLenum -> GLenum -> GLenum-> IO GLuint) +EXTENSION_ENTRY(glBindTextureUnitParameter,GLenum -> GLenum-> IO GLuint) +EXTENSION_ENTRY(glBindParameter,GLenum -> IO GLuint) +EXTENSION_ENTRY(glIsVariantEnabled,GLuint -> GLenum -> IO GLboolean) +EXTENSION_ENTRY(glGetVariantBooleanv,GLuint -> GLenum -> Ptr GLboolean -> IO ()) +EXTENSION_ENTRY(glGetVariantIntegerv,GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetVariantFloatv,GLuint -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetVariantPointerv,GLuint -> GLenum -> Ptr (Ptr a) -> IO ()) +EXTENSION_ENTRY(glGetInvariantBooleanv,GLuint -> GLenum -> Ptr GLboolean -> IO ()) +EXTENSION_ENTRY(glGetInvariantIntegerv,GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetInvariantFloatv,GLuint -> GLenum -> Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glGetLocalConstantBooleanv,GLuint -> GLenum -> Ptr GLboolean -> IO ()) +EXTENSION_ENTRY(glGetLocalConstantIntegerv,GLuint -> GLenum -> Ptr GLint -> IO ()) +EXTENSION_ENTRY(glGetLocalConstantFloatv,GLuint -> GLenum -> Ptr GLfloat -> IO ()) + +gl_VARIANT_VALUE :: GLenum +gl_VARIANT_VALUE = 0x87E4 + +gl_VARIANT_DATATYPE :: GLenum +gl_VARIANT_DATATYPE = 0x87E5 + +gl_VARIANT_ARRAY_STRIDE :: GLenum +gl_VARIANT_ARRAY_STRIDE = 0x87E6 + +gl_VARIANT_ARRAY_TYPE :: GLenum +gl_VARIANT_ARRAY_TYPE = 0x87E7 + +gl_VARIANT_ARRAY :: GLenum +gl_VARIANT_ARRAY = 0x87E8 + +gl_VARIANT_ARRAY_POINTER :: GLenum +gl_VARIANT_ARRAY_POINTER = 0x87E9 + +gl_INVARIANT_VALUE :: GLenum +gl_INVARIANT_VALUE = 0x87EA + +gl_INVARIANT_DATATYPE :: GLenum +gl_INVARIANT_DATATYPE = 0x87EB + +gl_LOCAL_CONSTANT_VALUE :: GLenum +gl_LOCAL_CONSTANT_VALUE = 0x87EC + +gl_LOCAL_CONSTANT_DATATYPE :: GLenum +gl_LOCAL_CONSTANT_DATATYPE = 0x87ED + +gl_OP_INDEX :: GLenum +gl_OP_INDEX = 0x8782 + +gl_OP_NEGATE :: GLenum +gl_OP_NEGATE = 0x8783 + +gl_OP_DOT3 :: GLenum +gl_OP_DOT3 = 0x8784 + +gl_OP_DOT4 :: GLenum +gl_OP_DOT4 = 0x8785 + +gl_OP_MUL :: GLenum +gl_OP_MUL = 0x8786 + +gl_OP_ADD :: GLenum +gl_OP_ADD = 0x8787 + +gl_OP_MADD :: GLenum +gl_OP_MADD = 0x8788 + +gl_OP_FRAC :: GLenum +gl_OP_FRAC = 0x8789 + +gl_OP_MAX :: GLenum +gl_OP_MAX = 0x878A + +gl_OP_MIN :: GLenum +gl_OP_MIN = 0x878B + +gl_OP_SET_GE :: GLenum +gl_OP_SET_GE = 0x878C + +gl_OP_SET_LT :: GLenum +gl_OP_SET_LT = 0x878D + +gl_OP_CLAMP :: GLenum +gl_OP_CLAMP = 0x878E + +gl_OP_FLOOR :: GLenum +gl_OP_FLOOR = 0x878F + +gl_OP_ROUND :: GLenum +gl_OP_ROUND = 0x8790 + +gl_OP_EXP_BASE_2 :: GLenum +gl_OP_EXP_BASE_2 = 0x8791 + +gl_OP_LOG_BASE_2 :: GLenum +gl_OP_LOG_BASE_2 = 0x8792 + +gl_OP_POWER :: GLenum +gl_OP_POWER = 0x8793 + +gl_OP_RECIP :: GLenum +gl_OP_RECIP = 0x8794 + +gl_OP_RECIP_SQRT :: GLenum +gl_OP_RECIP_SQRT = 0x8795 + +gl_OP_SUB :: GLenum +gl_OP_SUB = 0x8796 + +gl_OP_CROSS_PRODUCT :: GLenum +gl_OP_CROSS_PRODUCT = 0x8797 + +gl_OP_MULTIPLY_MATRIX :: GLenum +gl_OP_MULTIPLY_MATRIX = 0x8798 + +gl_OP_MOV :: GLenum +gl_OP_MOV = 0x8799 + +gl_OUTPUT_VERTEX :: GLenum +gl_OUTPUT_VERTEX = 0x879A + +gl_OUTPUT_COLOR0 :: GLenum +gl_OUTPUT_COLOR0 = 0x879B + +gl_OUTPUT_COLOR1 :: GLenum +gl_OUTPUT_COLOR1 = 0x879C + +gl_OUTPUT_TEXTURE_COORD0 :: GLenum +gl_OUTPUT_TEXTURE_COORD0 = 0x879D + +gl_OUTPUT_TEXTURE_COORD1 :: GLenum +gl_OUTPUT_TEXTURE_COORD1 = 0x879E + +gl_OUTPUT_TEXTURE_COORD2 :: GLenum +gl_OUTPUT_TEXTURE_COORD2 = 0x879F + +gl_OUTPUT_TEXTURE_COORD3 :: GLenum +gl_OUTPUT_TEXTURE_COORD3 = 0x87A0 + +gl_OUTPUT_TEXTURE_COORD4 :: GLenum +gl_OUTPUT_TEXTURE_COORD4 = 0x87A1 + +gl_OUTPUT_TEXTURE_COORD5 :: GLenum +gl_OUTPUT_TEXTURE_COORD5 = 0x87A2 + +gl_OUTPUT_TEXTURE_COORD6 :: GLenum +gl_OUTPUT_TEXTURE_COORD6 = 0x87A3 + +gl_OUTPUT_TEXTURE_COORD7 :: GLenum +gl_OUTPUT_TEXTURE_COORD7 = 0x87A4 + +gl_OUTPUT_TEXTURE_COORD8 :: GLenum +gl_OUTPUT_TEXTURE_COORD8 = 0x87A5 + +gl_OUTPUT_TEXTURE_COORD9 :: GLenum +gl_OUTPUT_TEXTURE_COORD9 = 0x87A6 + +gl_OUTPUT_TEXTURE_COORD10 :: GLenum +gl_OUTPUT_TEXTURE_COORD10 = 0x87A7 + +gl_OUTPUT_TEXTURE_COORD11 :: GLenum +gl_OUTPUT_TEXTURE_COORD11 = 0x87A8 + +gl_OUTPUT_TEXTURE_COORD12 :: GLenum +gl_OUTPUT_TEXTURE_COORD12 = 0x87A9 + +gl_OUTPUT_TEXTURE_COORD13 :: GLenum +gl_OUTPUT_TEXTURE_COORD13 = 0x87AA + +gl_OUTPUT_TEXTURE_COORD14 :: GLenum +gl_OUTPUT_TEXTURE_COORD14 = 0x87AB + +gl_OUTPUT_TEXTURE_COORD15 :: GLenum +gl_OUTPUT_TEXTURE_COORD15 = 0x87AC + +gl_OUTPUT_TEXTURE_COORD16 :: GLenum +gl_OUTPUT_TEXTURE_COORD16 = 0x87AD + +gl_OUTPUT_TEXTURE_COORD17 :: GLenum +gl_OUTPUT_TEXTURE_COORD17 = 0x87AE + +gl_OUTPUT_TEXTURE_COORD18 :: GLenum +gl_OUTPUT_TEXTURE_COORD18 = 0x87AF + +gl_OUTPUT_TEXTURE_COORD19 :: GLenum +gl_OUTPUT_TEXTURE_COORD19 = 0x87B0 + +gl_OUTPUT_TEXTURE_COORD20 :: GLenum +gl_OUTPUT_TEXTURE_COORD20 = 0x87B1 + +gl_OUTPUT_TEXTURE_COORD21 :: GLenum +gl_OUTPUT_TEXTURE_COORD21 = 0x87B2 + +gl_OUTPUT_TEXTURE_COORD22 :: GLenum +gl_OUTPUT_TEXTURE_COORD22 = 0x87B3 + +gl_OUTPUT_TEXTURE_COORD23 :: GLenum +gl_OUTPUT_TEXTURE_COORD23 = 0x87B4 + +gl_OUTPUT_TEXTURE_COORD24 :: GLenum +gl_OUTPUT_TEXTURE_COORD24 = 0x87B5 + +gl_OUTPUT_TEXTURE_COORD25 :: GLenum +gl_OUTPUT_TEXTURE_COORD25 = 0x87B6 + +gl_OUTPUT_TEXTURE_COORD26 :: GLenum +gl_OUTPUT_TEXTURE_COORD26 = 0x87B7 + +gl_OUTPUT_TEXTURE_COORD27 :: GLenum +gl_OUTPUT_TEXTURE_COORD27 = 0x87B8 + +gl_OUTPUT_TEXTURE_COORD28 :: GLenum +gl_OUTPUT_TEXTURE_COORD28 = 0x87B9 + +gl_OUTPUT_TEXTURE_COORD29 :: GLenum +gl_OUTPUT_TEXTURE_COORD29 = 0x87BA + +gl_OUTPUT_TEXTURE_COORD30 :: GLenum +gl_OUTPUT_TEXTURE_COORD30 = 0x87BB + +gl_OUTPUT_TEXTURE_COORD31 :: GLenum +gl_OUTPUT_TEXTURE_COORD31 = 0x87BC + +gl_OUTPUT_FOG :: GLenum +gl_OUTPUT_FOG = 0x87BD + +gl_SCALAR :: GLenum +gl_SCALAR = 0x87BE + +gl_VECTOR :: GLenum +gl_VECTOR = 0x87BF + +gl_MATRIX :: GLenum +gl_MATRIX = 0x87C0 + +gl_VARIANT :: GLenum +gl_VARIANT = 0x87C1 + +gl_INVARIANT :: GLenum +gl_INVARIANT = 0x87C2 + +gl_LOCAL_CONSTANT :: GLenum +gl_LOCAL_CONSTANT = 0x87C3 + +gl_LOCAL :: GLenum +gl_LOCAL = 0x87C4 + +gl_MAX_VERTEX_SHADER_INSTRUCTIONS :: GLenum +gl_MAX_VERTEX_SHADER_INSTRUCTIONS = 0x87C5 + +gl_MAX_VERTEX_SHADER_VARIANTS :: GLenum +gl_MAX_VERTEX_SHADER_VARIANTS = 0x87C6 + +gl_MAX_VERTEX_SHADER_INVARIANTS :: GLenum +gl_MAX_VERTEX_SHADER_INVARIANTS = 0x87C7 + +gl_MAX_VERTEX_SHADER_LOCAL_CONSTANTS :: GLenum +gl_MAX_VERTEX_SHADER_LOCAL_CONSTANTS = 0x87C8 + +gl_MAX_VERTEX_SHADER_LOCALS :: GLenum +gl_MAX_VERTEX_SHADER_LOCALS = 0x87C9 + +gl_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS :: GLenum +gl_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS = 0x87CA + +gl_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS :: GLenum +gl_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS = 0x87CB + +gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS :: GLenum +gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS = 0x87CC + +gl_MAX_OPTIMIZED_VERTEX_SHADER_INARIANTS :: GLenum +gl_MAX_OPTIMIZED_VERTEX_SHADER_INARIANTS = 0x87CD + +gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS :: GLenum +gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS = 0x87CE + +gl_VERTEX_SHADER_INSTRUCTIONS :: GLenum +gl_VERTEX_SHADER_INSTRUCTIONS = 0x87CF + +gl_VERTEX_SHADER_VARIANTS :: GLenum +gl_VERTEX_SHADER_VARIANTS = 0x87D0 + +gl_VERTEX_SHADER_INVARIANTS :: GLenum +gl_VERTEX_SHADER_INVARIANTS = 0x87D1 + +gl_VERTEX_SHADER_LOCAL_CONSTANTS :: GLenum +gl_VERTEX_SHADER_LOCAL_CONSTANTS = 0x87D2 + +gl_VERTEX_SHADER_LOCALS :: GLenum +gl_VERTEX_SHADER_LOCALS = 0x87D3 + +gl_VERTEX_SHADER_BINDING :: GLenum +gl_VERTEX_SHADER_BINDING = 0x8781 + +gl_VERTEX_SHADER_OPTIMIZED :: GLenum +gl_VERTEX_SHADER_OPTIMIZED = 0x87D4 + +gl_X :: GLenum +gl_X = 0x87D5 + +gl_Y :: GLenum +gl_Y = 0x87D6 + +gl_Z :: GLenum +gl_Z = 0x87D7 + +gl_W :: GLenum +gl_W = 0x87D8 + +gl_NEGATIVE_X :: GLenum +gl_NEGATIVE_X = 0x87D9 + +gl_NEGATIVE_Y :: GLenum +gl_NEGATIVE_Y = 0x87DA + +gl_NEGATIVE_Z :: GLenum +gl_NEGATIVE_Z = 0x87DB + +gl_NEGATIVE_W :: GLenum +gl_NEGATIVE_W = 0x87DC + +gl_NEGATIVE_ONE :: GLenum +gl_NEGATIVE_ONE = 0x87DF + +gl_NORMALIZED_RANGE :: GLenum +gl_NORMALIZED_RANGE = 0x87E0 + +gl_FULL_RANGE :: GLenum +gl_FULL_RANGE = 0x87E1 + +gl_CURRENT_VERTEX :: GLenum +gl_CURRENT_VERTEX = 0x87E2 + +gl_MVP_MATRIX :: GLenum +gl_MVP_MATRIX = 0x87E3 diff --git a/src/Graphics/Rendering/OpenGL/Raw/EXT/VertexWeighting.hs b/src/Graphics/Rendering/OpenGL/Raw/EXT/VertexWeighting.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/EXT/VertexWeighting.hs @@ -0,0 +1,84 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.EXT.VertexWeighting +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- All raw functions and tokens from the EXT_vertex_weighting extension not +-- already in the OpenGL 3.1 core, see +-- . +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.EXT.VertexWeighting ( + -- * Functions + glVertexWeightf, + glVertexWeightfv, + glVertexWeightPointer, + -- * Tokens + gl_VERTEX_WEIGHTING, + gl_MODELVIEW0, + gl_MODELVIEW1, + gl_MODELVIEW0_MATRIX, + gl_MODELVIEW1_MATRIX, + gl_CURRENT_VERTEX_WEIGHT, + gl_VERTEX_WEIGHT_ARRAY, + gl_VERTEX_WEIGHT_ARRAY_SIZE, + gl_VERTEX_WEIGHT_ARRAY_TYPE, + gl_VERTEX_WEIGHT_ARRAY_STRIDE, + gl_MODELVIEW0_STACK_DEPTH, + gl_MODELVIEW1_STACK_DEPTH, + gl_VERTEX_WEIGHT_ARRAY_POINTER +) where + +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.ARB.VertexBlend +import Graphics.Rendering.OpenGL.Raw.Core31 +import Graphics.Rendering.OpenGL.Raw.Extensions + +#include "HsOpenGLRaw.h" + +extensionNameString :: String +extensionNameString = "GL_EXT_vertex_weighting" + +EXTENSION_ENTRY(glVertexWeightf,GLfloat -> IO ()) +EXTENSION_ENTRY(glVertexWeightfv,Ptr GLfloat -> IO ()) +EXTENSION_ENTRY(glVertexWeightPointer,GLint -> GLenum -> GLsizei -> Ptr a -> IO ()) + +gl_VERTEX_WEIGHTING :: GLenum +gl_VERTEX_WEIGHTING = 0x8509 + +gl_MODELVIEW0_MATRIX :: GLenum +gl_MODELVIEW0_MATRIX = 0x0BA6 + +gl_MODELVIEW1_MATRIX :: GLenum +gl_MODELVIEW1_MATRIX = 0x8506 + +gl_CURRENT_VERTEX_WEIGHT :: GLenum +gl_CURRENT_VERTEX_WEIGHT = 0x850B + +gl_VERTEX_WEIGHT_ARRAY :: GLenum +gl_VERTEX_WEIGHT_ARRAY = 0x850C + +gl_VERTEX_WEIGHT_ARRAY_SIZE :: GLenum +gl_VERTEX_WEIGHT_ARRAY_SIZE = 0x850D + +gl_VERTEX_WEIGHT_ARRAY_TYPE :: GLenum +gl_VERTEX_WEIGHT_ARRAY_TYPE = 0x850E + +gl_VERTEX_WEIGHT_ARRAY_STRIDE :: GLenum +gl_VERTEX_WEIGHT_ARRAY_STRIDE = 0x850F + +gl_MODELVIEW0_STACK_DEPTH :: GLenum +gl_MODELVIEW0_STACK_DEPTH = 0x0BA3 + +gl_MODELVIEW1_STACK_DEPTH :: GLenum +gl_MODELVIEW1_STACK_DEPTH = 0x8502 + +gl_VERTEX_WEIGHT_ARRAY_POINTER :: GLenum +gl_VERTEX_WEIGHT_ARRAY_POINTER = 0x8510 diff --git a/src/Graphics/Rendering/OpenGL/Raw/Extensions.hs b/src/Graphics/Rendering/OpenGL/Raw/Extensions.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/Extensions.hs @@ -0,0 +1,45 @@ +-- #hide +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.Extensions +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- This internal module offers convenience functions and re-exports for OpenGL +-- extension loading. +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.Extensions ( + Invoker, getExtensionEntry, + FunPtr, unsafePerformIO +) where + +import Foreign.Marshal.Error +import Foreign.Ptr +import Graphics.Rendering.OpenGL.Raw.GetProcAddress +import System.IO.Unsafe + +-------------------------------------------------------------------------------- + +type Invoker a = FunPtr a -> a + +getExtensionEntry :: String -> String -> IO (FunPtr a) +getExtensionEntry extensionNameString extensionEntry = + throwIfNullFunPtr ("unknown OpenGL extension entry " ++ extensionEntry ++ + ", check for " ++ extensionNameString) $ + getProcAddressWithSuffixes extensionEntry extensionSuffixes + +throwIfNullFunPtr :: String -> IO (FunPtr a) -> IO (FunPtr a) +throwIfNullFunPtr = throwIf (== nullFunPtr) . const + +-- non-ARB extension suffixes are in descending order of number of extensions +extensionSuffixes :: [String] +extensionSuffixes = [ + "", "ARB", "EXT", "NV", "SGIX", "SGIS", "ATI", "APPLE", "SUN", "OES", "IBM", + "MESA", "HP", "SGI", "OML", "AMD", "3DFX", "WIN", "PGI", "INTEL", "INGR", + "GREMEDY", "SUNX", "S3", "REND", "MESAX" ] diff --git a/src/Graphics/Rendering/OpenGL/Raw/GetProcAddress.hs b/src/Graphics/Rendering/OpenGL/Raw/GetProcAddress.hs new file mode 100644 --- /dev/null +++ b/src/Graphics/Rendering/OpenGL/Raw/GetProcAddress.hs @@ -0,0 +1,47 @@ +{-# LANGUAGE ForeignFunctionInterface, CPP #-} +-------------------------------------------------------------------------------- +-- | +-- Module : Graphics.Rendering.OpenGL.Raw.GetProcAddress +-- Copyright : (c) Sven Panne 2009 +-- License : BSD-style (see the file LICENSE) +-- +-- Maintainer : sven.panne@aedion.de +-- Stability : stable +-- Portability : portable +-- +-- This module offers a portable way to retrieve OpenGL extension entries, +-- providing a portability layer upon platform-specific mechanisms like +-- @glXGetProcAddress@, @wglGetProcAddress@ or @NSAddressOfSymbol@. +-- +-------------------------------------------------------------------------------- + +module Graphics.Rendering.OpenGL.Raw.GetProcAddress ( + getProcAddress, getProcAddressWithSuffixes +) where + +import Control.Monad +import Foreign.C.String +import Foreign.Ptr + +#ifdef __HUGS__ +{-# CFILES cbits/HsOpenGLRaw.c #-} +#endif + +-------------------------------------------------------------------------------- + +-- | Retrieve an OpenGL extension entry by name. Returns 'nullFunPtr' when no +-- extension entry with the given name was found. +getProcAddress :: String -> IO (FunPtr a) +getProcAddress extensionEntry = + withCString extensionEntry hs_OpenGLRaw_getProcAddress + +foreign import ccall unsafe "hs_OpenGLRaw_getProcAddress" + hs_OpenGLRaw_getProcAddress :: CString -> IO (FunPtr a) + +-- | Retrieve an OpenGL extension entry by name, trying a list of name suffixes +-- in the given order. Returns 'nullFunPtr' when no extension entry with the +-- given name plus any of the suffixes was found. +getProcAddressWithSuffixes :: String -> [String] -> IO (FunPtr a) +getProcAddressWithSuffixes extensionEntry = foldM gpa nullFunPtr + where gpa p s | p == nullFunPtr = getProcAddress (extensionEntry ++ s) + | otherwise = return p