diff --git a/LICENSE b/LICENSE new file mode 100644 --- /dev/null +++ b/LICENSE @@ -0,0 +1,20 @@ +Copyright (c) 2014 Mikko Juola + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + 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/caramia.cabal b/caramia.cabal new file mode 100644 --- /dev/null +++ b/caramia.cabal @@ -0,0 +1,96 @@ +name: caramia +version: 0.1.0.0 +synopsis: Caramia real-time hardware-accelerated rendering library +homepage: https://github.com/Noeda/caramia/ +license: MIT +license-file: LICENSE +author: Mikko Juola +copyright: Copyright (c) 2014 Mikko Juola +maintainer: mikjuo@gmail.com +category: Graphics +build-type: Simple +stability: experimental +cabal-version: >=1.10 + +description: + (See README.md in the repository for a more comprehensive description). + . + These are low-level, but Haskelly bindings to OpenGL 3.3. + . + See 'giveContext' in "Caramia.Context" as this is the + starting point for using this library. + +source-repository head + type: git + location: https://github.com/Noeda/caramia.git + +library + exposed-modules: Caramia + Caramia.Resource + Caramia.Context + Caramia.Buffer + Caramia.VAO + Caramia.Shader + Caramia.Math + Caramia.ImageFormats + Caramia.Render + Caramia.Texture + Caramia.Memory + Caramia.Framebuffer + Caramia.Color + Caramia.Blend + Caramia.Prelude + Caramia.Sync + Caramia.Internal.ContextLocalData + Caramia.Internal.OpenGLDebug + Caramia.Internal.OpenGLCApi + Caramia.Internal.Lens + Caramia.Internal.FlextGL + Caramia.Render.Internal + Caramia.Framebuffer.Internal + Caramia.Texture.Internal + Caramia.ImageFormats.Internal + Caramia.Shader.Internal + Caramia.Buffer.Internal + Caramia.Blend.Internal + Caramia.VAO.Internal + + ghc-options: -Wall -fno-warn-name-shadowing + + build-depends: base >=4.6 && <5.0.0.0 + ,bytestring >=0.10 && <1.0 + ,containers >=0.5 && <1.0 + ,vector >=0.10 && <1.0 + ,text >=0.9 && <2.0 + ,transformers >=0.4 && <1.0 + ,semigroups >=0.15 && <1.0 + ,OpenGLRaw >=1.5 && <2.0 + hs-source-dirs: src + default-language: Haskell2010 + + if os(darwin) + frameworks: OpenGL + cpp-options: -DMAC_OPENGL + +-- This is just a dumping ground test that does stupid things. It's used to +-- check if things work at all. +test-suite smoke-test + type: exitcode-stdio-1.0 + main-is: Main.hs + ghc-options: -Wall -fno-warn-name-shadowing -threaded + hs-source-dirs: demos/smoke-test + build-depends: base, caramia + ,sdl2 ==1.* + ,text >=0.9 && <2.0 + default-language: Haskell2010 + +-- This one tests Caramia.Memory if it returns anything useful. +test-suite memory-info + type: exitcode-stdio-1.0 + main-is: Main.hs + ghc-options: -Wall -fno-warn-name-shadowing -threaded + hs-source-dirs: demos/memory-info + build-depends: base, caramia + ,sdl2 ==1.* + default-language: Haskell2010 + diff --git a/demos/memory-info/Main.hs b/demos/memory-info/Main.hs new file mode 100644 --- /dev/null +++ b/demos/memory-info/Main.hs @@ -0,0 +1,23 @@ +module Main ( main ) where + +import Caramia +import Graphics.UI.SDL +import Data.Bits +import Foreign.C.String + +main :: IO () +main = + withCString "smoke-test" $ \cstr -> do + _ <- glSetAttribute glAttrContextMajorVersion 3 + _ <- glSetAttribute glAttrContextMinorVersion 3 + _ <- glSetAttribute glAttrContextProfileMask glProfileCore + _ <- glSetAttribute glAttrContextFlags glContextFlagDebug + window <- createWindow cstr windowPosUndefined windowPosUndefined + 500 500 + (windowFlagOpenGL .|. + windowFlagShown) + _ <- glCreateContext window + giveContext $ do + putStrLn "Attempting to retrieve GPU memory information..." + print =<< getMemoryInfo + diff --git a/demos/smoke-test/Main.hs b/demos/smoke-test/Main.hs new file mode 100644 --- /dev/null +++ b/demos/smoke-test/Main.hs @@ -0,0 +1,155 @@ +{-# LANGUAGE NoImplicitPrelude, OverloadedStrings #-} + +module Main ( main ) where + +import Caramia.Prelude +import Caramia +import Caramia.Math + +import Graphics.UI.SDL +import qualified Graphics.UI.SDL as SDL +import Foreign.C.String +import Control.Exception +import Data.Bits +import qualified Data.Text as T +import System.Mem + +main :: IO () +main = do + putStrLn $ "This will run the smoke test. The smoke test merely tests " <> + "that " <> + "things don't crash and burn when trying to heavily draw " <> + "something." + putStrLn $ "However with some drivers it can drive the computer to " <> + "become unresponsive and difficult to recover without a " <> + "reboot." + putStrLn "Press enter to start the smoke test." + _ <- getLine + putStrLn "Running the smoke test..." + bracket_ (SDL.init initFlagVideo) + quit + program + +program :: IO () +program = + withCString "smoke-test" $ \cstr -> do + _ <- glSetAttribute glAttrContextMajorVersion 3 + _ <- glSetAttribute glAttrContextMinorVersion 3 + _ <- glSetAttribute glAttrContextProfileMask glProfileCore + _ <- glSetAttribute glAttrContextFlags glContextFlagDebug + window <- createWindow cstr windowPosUndefined windowPosUndefined + 500 500 + (windowFlagOpenGL .|. + windowFlagShown) + _ <- glCreateContext window + giveContext $ do + -- Make some buffers. + for_ [1..100 :: Integer] $ \idx -> do + buf <- newBuffer defaultBufferCreation { size = 1024 + , accessFlags = + WriteAccess } + withMapping 0 500 WriteAccess buf $ \_ -> return () + runPendingFinalizers + putStrLn $ "Buffer creation: " <> show idx <> "/100" + + -- Make some buffers but with much larger size and ReadAccess + for_ [1..100 :: Integer] $ \idx -> do + buf <- newBuffer defaultBufferCreation { size = 102400 + , accessFlags = + ReadAccess } + withMapping 23 50000 ReadAccess buf $ \_ -> return () + copy buf 100 buf 500 400 + runPendingFinalizers + + -- Compile a gazillion shaders + sh1 <- newShader fragmentShaderSrc Fragment + pipeline <- newPipeline [sh1] + loc <- getUniformLocation "tutturuu" pipeline + setUniform (transpose44 identity44) + loc + pipeline + setUniform identity44 + loc + pipeline + setUniform identity33 + loc + pipeline + setUniform (transpose33 identity33) + loc + pipeline + + tex <- newTexture + textureSpecification + { topology = TexCube { widthCube = 299 } + , mipmapLevels = 5 + , imageFormat = SRGB8_ALPHA8 } + + uploadToTexture + (uploading2D buf 28 28 FWord32 UBGRA) + { + cubeSide = NegativeX + } + tex + + -- Make some stupid VAOs + vao <- newVAO + vao2 <- newVAO + sourceVertexData buf + ((defaultSourcingType (5 :: Word16)) + { offset = 123 + , components = 3 + , stride = 19 + , attributeIndex = 3 + , integerMapping = True }) + vao2 + sourceVertexData buf + ((defaultSourcingType (5 :: Word16)) + { offset = 123 + , components = 3 + , stride = 19 + , instancingDivisor = 19 + , attributeIndex = 3 + , normalize = True + , integerMapping = False }) + vao + draw drawCommand { + primitiveType = LineLoop + , primitivesVAO = vao2 + , numIndices = 8 + , numInstances = 213 + , sourceData = PrimitivesWithIndices { + indexBuffer = buf + , indexOffset = 17 + , indexType = IWord16 } } + defaultDrawParams { + pipeline = pipeline + } + + fbuf <- newFramebuffer [ (ColorAttachment 3 + , frontTextureTarget tex) ] + draw drawCommand { + primitiveType = LineLoop + , primitivesVAO = vao2 + , numIndices = 8 + , numInstances = 999 + , sourceData = Primitives { + firstIndex = 3 } } + defaultDrawParams { + pipeline = pipeline + , targetFramebuffer = fbuf + } + putStrLn $ "Drawing: " <> show idx <> "/100" + + performGC + runPendingFinalizers + return () + +fragmentShaderSrc :: T.Text +fragmentShaderSrc = "" <> + "#version 330\n" <> + "uniform mat3 tutturuu;\n" <> + "layout (location = 0) out vec4 colorOut;\n" <> + "void main() {\n" <> + " colorOut = vec4(tutturuu[0][0]);\n" <> + "}\n" + diff --git a/src/Caramia.hs b/src/Caramia.hs new file mode 100644 --- /dev/null +++ b/src/Caramia.hs @@ -0,0 +1,19 @@ +-- | This module re-exports most Caramia modules. + +module Caramia + ( module Ex ) + where + +import Caramia.Resource as Ex +import Caramia.Context as Ex +import Caramia.Buffer as Ex +import Caramia.VAO as Ex +import Caramia.Shader as Ex +import Caramia.Render as Ex +import Caramia.ImageFormats as Ex +import Caramia.Texture as Ex +import Caramia.Memory as Ex +import Caramia.Framebuffer as Ex +import Caramia.Color as Ex +import Caramia.Blend as Ex + diff --git a/src/Caramia/Blend.hs b/src/Caramia/Blend.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Blend.hs @@ -0,0 +1,42 @@ +-- | Blending stuff. +-- +-- +-- + +module Caramia.Blend + ( + -- * Data types + BlendSpec(..) + , BlendEquation(..) + , BlendFunc(..) + -- * Pre-defined blending specs + , preMultipliedAlpha + , nopBlend ) + where + +--import Caramia.Prelude +import Caramia.Blend.Internal +import Caramia.Color + +preMultipliedAlpha :: BlendSpec +preMultipliedAlpha = BlendSpec + { srcColorFunc = BFOne + , srcAlphaFunc = BFOne + , dstColorFunc = BFOneMinusSrcAlpha + , dstAlphaFunc = BFOneMinusSrcAlpha + , colorEquation = BEAdd + , alphaEquation = BEAdd + , blendColor = rgba 1 1 1 1 } + +-- | Blending that doesn't do anything special; just copies the source pixel to +-- destination. +nopBlend :: BlendSpec +nopBlend = BlendSpec + { srcColorFunc = BFOne + , srcAlphaFunc = BFOne + , dstColorFunc = BFZero + , dstAlphaFunc = BFZero + , colorEquation = BEAdd + , alphaEquation = BEAdd + , blendColor = rgba 1 1 1 1 } + diff --git a/src/Caramia/Blend/Internal.hs b/src/Caramia/Blend/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Blend/Internal.hs @@ -0,0 +1,118 @@ +{-# LANGUAGE RecordWildCards, NoImplicitPrelude, DeriveDataTypeable #-} + +module Caramia.Blend.Internal where + +import Caramia.Prelude + +import Caramia.Internal.OpenGLCApi +import Caramia.Color +import Control.Exception +import Foreign +import Foreign.C.Types + +-- | Describes which equation to use in blending. +-- +-- See `glBlendEquation` in OpenGL documentation. +data BlendEquation = + BEAdd + | BESubtract + | BEReverseSubtract + | BEMin + | BEMax + deriving ( Eq, Ord, Show, Read, Typeable ) + +-- | Describes the arithmetic to use in blending. +-- +-- See `glBlendFunc` in OpenGL documentation. +data BlendFunc = + BFZero + | BFOne + | BFSrcColor + | BFOneMinusSrcColor + | BFDstColor + | BFOneMinusDstColor + | BFSrcAlpha + | BFOneMinusSrcAlpha + | BFDstAlpha + | BFOneMinusDstAlpha + | BFConstantColor + | BFOneMinusConstantColor + | BFConstantAlpha + | BFOneMinusConstantAlpha + | BFSrcAlphaSaturate + deriving ( Eq, Ord, Show, Read, Typeable ) + +toConstantBE :: BlendEquation -> GLenum +toConstantBE BEAdd = gl_FUNC_ADD +toConstantBE BESubtract = gl_FUNC_SUBTRACT +toConstantBE BEReverseSubtract = gl_FUNC_REVERSE_SUBTRACT +toConstantBE BEMin = gl_MIN +toConstantBE BEMax = gl_MAX + +toConstantBF :: BlendFunc -> GLenum +toConstantBF BFZero = gl_ZERO +toConstantBF BFOne = gl_ONE +toConstantBF BFSrcColor = gl_SRC_COLOR +toConstantBF BFOneMinusSrcColor = gl_ONE_MINUS_SRC_COLOR +toConstantBF BFDstColor = gl_DST_COLOR +toConstantBF BFOneMinusDstColor = gl_ONE_MINUS_DST_COLOR +toConstantBF BFSrcAlpha = gl_SRC_ALPHA +toConstantBF BFOneMinusSrcAlpha = gl_ONE_MINUS_SRC_ALPHA +toConstantBF BFDstAlpha = gl_DST_ALPHA +toConstantBF BFOneMinusDstAlpha = gl_ONE_MINUS_DST_ALPHA +toConstantBF BFConstantColor = gl_CONSTANT_COLOR +toConstantBF BFOneMinusConstantColor = gl_ONE_MINUS_CONSTANT_COLOR +toConstantBF BFConstantAlpha = gl_CONSTANT_ALPHA +toConstantBF BFOneMinusConstantAlpha = gl_ONE_MINUS_CONSTANT_ALPHA +toConstantBF BFSrcAlphaSaturate = gl_SRC_ALPHA_SATURATE + +-- | Captures the blending parameters. +data BlendSpec = BlendSpec + { alphaEquation :: !BlendEquation + , colorEquation :: !BlendEquation + , srcColorFunc :: !BlendFunc + , srcAlphaFunc :: !BlendFunc + , dstColorFunc :: !BlendFunc + , dstAlphaFunc :: !BlendFunc + , blendColor :: !Color } + deriving ( Eq, Ord, Show, Read, Typeable ) + +setBlendings :: BlendSpec -> IO () +setBlendings (BlendSpec{..}) = do + glBlendFuncSeparate (toConstantBF srcColorFunc) + (toConstantBF dstColorFunc) + (toConstantBF srcAlphaFunc) + (toConstantBF dstAlphaFunc) + glBlendEquationSeparate (toConstantBE colorEquation) + (toConstantBE alphaEquation) + glBlendColor (CFloat $ viewRed blendColor) + (CFloat $ viewGreen blendColor) + (CFloat $ viewBlue blendColor) + (CFloat $ viewAlpha blendColor) + +withBlendings :: BlendSpec + -> IO a + -> IO a +withBlendings spec@(BlendSpec {..}) action = do + old_be_color <- gi gl_BLEND_EQUATION_RGB + old_be_alpha <- gi gl_BLEND_EQUATION_ALPHA + old_src_color <- gi gl_BLEND_SRC_RGB + old_src_alpha <- gi gl_BLEND_SRC_ALPHA + old_dst_color <- gi gl_BLEND_DST_RGB + old_dst_alpha <- gi gl_BLEND_DST_ALPHA + allocaArray 4 $ \color_ptr -> do + glGetFloatv gl_BLEND_COLOR color_ptr + r <- peekElemOff color_ptr 0 + g <- peekElemOff color_ptr 1 + b <- peekElemOff color_ptr 2 + a <- peekElemOff color_ptr 3 + finally (setBlendings spec >> action) $ do + glBlendColor r g b a + glBlendFuncSeparate old_src_color + old_dst_color + old_src_alpha + old_dst_alpha + glBlendEquationSeparate old_be_color + old_be_alpha + + diff --git a/src/Caramia/Buffer.hs b/src/Caramia/Buffer.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Buffer.hs @@ -0,0 +1,411 @@ +-- | Buffer objects. +-- +-- These are chunks of memory (typically) kept on the GPU. +-- +-- +-- + +-- TODO: Add glBufferStorage based implementation. +-- OpenGLRaw (1.4.0.0) doesn't have this yet. + +{-# LANGUAGE DeriveDataTypeable, NoImplicitPrelude #-} + +module Caramia.Buffer + ( -- * Creation + newBuffer + , Buffer() + , AccessFrequency(..) + , AccessNature(..) + , AccessFlags(..) + , MapFlag(..) + , BufferCreation(..) + , defaultBufferCreation + -- * Invalidation + , invalidateBuffer + -- * Manipulation + , map + , map2 + , unmap + , copy + , withMapping + , withMapping2 + , uploadVector + -- * Views + , viewSize + , viewAllowedMappings + -- * Exceptions + , BufferCorruption(..) + ) + where + +import Caramia.Prelude hiding ( map ) +import Caramia.Buffer.Internal + +import Caramia.Resource +import Caramia.Internal.OpenGLCApi + +import qualified Data.Vector.Storable as V +import qualified Data.Set as S + +import Data.Bits +import Foreign +import Control.Exception + +-- | The frequency of access to a buffer. +-- +-- These correspond to the OpenGL access frequency hints. You can look for them +-- in the OpenGL specification or check this link: +-- +-- +data AccessFrequency = + Stream + | Static + | Dynamic + deriving ( Eq, Ord, Show, Read ) + +-- | The nature of access to a buffer. +-- +-- These correspond to the OpenGL access nature hints. You can look for them +-- in the OpenGL specification or check this link: +-- +-- +data AccessNature = + Draw + | Read + | Copy + deriving ( Eq, Ord, Show, Read ) + +canMapWith :: AccessFlags -> AccessFlags -> Bool +canMapWith ReadWriteAccess _ = True +canMapWith WriteAccess WriteAccess = True +canMapWith WriteAccess _ = False +canMapWith ReadAccess ReadAccess = True +canMapWith ReadAccess _ = False +canMapWith NoAccess NoAccess = True +canMapWith NoAccess _ = False + +toConstant :: AccessFrequency -> AccessNature -> GLuint +toConstant Stream Draw = gl_STREAM_DRAW +toConstant Stream Read = gl_STREAM_READ +toConstant Stream Copy = gl_STREAM_COPY +toConstant Static Draw = gl_STATIC_DRAW +toConstant Static Read = gl_STATIC_READ +toConstant Static Copy = gl_STATIC_COPY +toConstant Dynamic Draw = gl_DYNAMIC_DRAW +toConstant Dynamic Read = gl_DYNAMIC_READ +toConstant Dynamic Copy = gl_DYNAMIC_COPY + +toConstantF :: AccessFlags -> GLbitfield +toConstantF ReadAccess = gl_MAP_READ_BIT +toConstantF WriteAccess = gl_MAP_WRITE_BIT +toConstantF ReadWriteAccess = gl_MAP_READ_BIT .|. gl_MAP_WRITE_BIT +toConstantF NoAccess = 0 + +toConstantMF :: S.Set MapFlag -> GLbitfield +toConstantMF ss + | S.null ss = 0 + | otherwise = + if UnSynchronized `S.member` ss + then gl_MAP_UNSYNCHRONIZED_BIT + else 0 + +-- | This data describes how a buffer should behave and what operations can be +-- done with it. +-- +-- Accurate description can improve performance. +-- +-- For forwards compatibility, it is recommended to use +-- `defaultBufferCreation` and then set the fields you want to change. +data BufferCreation = BufferCreation + { accessHints :: !(AccessFrequency, AccessNature) -- ^ Hints on how the + -- buffer will be used. + + , size :: !Int -- ^ How large the buffer should be, in + -- bytes. + , initialData :: + !(Maybe (Ptr ())) -- ^ The initial data to be copied to + -- the buffer. Can be `Nothing` in + -- which case the initial contents are + -- undefined. + + , accessFlags :: !AccessFlags -- ^ What kind of mapping access is + -- allowed. See `map`. + } + +-- | The default buffer creation flags. +-- +-- The default attempts to give you the most general (and possibly slowest) +-- buffer. Both read and write access are allowed. +-- +-- Default size is 0 which will make `newBuffer` fail if you don't set it. +defaultBufferCreation :: BufferCreation +defaultBufferCreation = BufferCreation { + accessHints = (Dynamic, Draw) + , size = 0 + , initialData = Nothing + , accessFlags = ReadWriteAccess } + +-- | Creates a new buffer according to `BufferCreation` specification. +newBuffer :: BufferCreation + -> IO Buffer +newBuffer creation + | size creation <= 0 = + error "newBuffer: size must be positive." + | otherwise = mask_ $ do + resource <- + newResource createBuffer + (\(Buffer_ bufname) -> mglDeleteBuffer bufname) + (return ()) + initial_status <- newIORef BufferStatus { mapped = False } + oi <- atomicModifyIORef' bufferOrdIndex $ \old -> ( old+1, old ) + return Buffer { resource = resource + , status = initial_status + , viewAllowedMappings = accessFlags creation + , viewSize = size creation + , ordIndex = oi } + where + initial_data = fromMaybe nullPtr (assertNotNull <$> initialData creation) + safe_size = safeFromIntegral $ size creation + (usage, access) = accessHints creation + + createBuffer = do + buf <- mglGenBuffer + mglNamedBufferData buf + safe_size + (castPtr initial_data) + (toConstant usage access) + return (Buffer_ buf) + + assertNotNull ptr + | ptr == nullPtr = error "newBuffer: initial data is a null pointer." + | otherwise = ptr + +-- | Same as `map` but allows more control over mapping. +-- +-- @ map = map2 [] @ +map2 :: S.Set MapFlag + -> Int + -> Int + -> AccessFlags + -> Buffer + -> IO (Ptr ()) +map2 map_flags offset num_bytes access_flags buffer + -- a lot of this implementation is just error checking... + + -- check that offset/num_bytes makes sense + | offset < 0 || offset >= viewSize buffer || + num_bytes <= 0 || + offset + num_bytes > viewSize buffer = + error $ "map: requested mapping has invalid offset " <> + "and/or range. " <> + "Buffer size is " <> show (viewSize buffer) <> ", " <> + "requested mapping was [" <> show offset <> ".." <> + show (offset + num_bytes - 1) <> "]." + | otherwise = + withResource (resource buffer) $ \(Buffer_ buf) -> mask_ $ do + bufstatus <- readIORef (status buffer) + -- make sure buffer has not been alreayd mapped + when (mapped bufstatus) $ + error "map: buffer is already mapped." + -- can we really map with these access flags + unless (canMapWith (viewAllowedMappings buffer) access_flags) $ + error $ "map: attempted to map buffer with " <> show access_flags + <> ", allowed mappings are: " <> + show (viewAllowedMappings buffer) + + ptr <- mglMapNamedBufferRange + buf + (safeFromIntegral offset) + (safeFromIntegral num_bytes) + (toConstantF access_flags .|. toConstantMF map_flags) + + -- what if it just mysteriously fails? I think we caught most, if not + -- all user errors so any other error should be some rare condition + -- depending on external factors. I hope. + when (ptr == nullPtr) $ + -- I am so sorry for any user who sees this error message. + error $ "map: for some reason, mapping a buffer failed. " <> + "You might want to check OpenGL debug log." + + atomicModifyIORef' (status buffer) $ \old -> + ( old { mapped = True }, () ) + + return ptr + +-- | Maps (part) of a buffer to system memory space. +-- +-- The mapping is valid until the buffer is garbage collected (in which case +-- the mapping is automatically unmapped) or when `unmap` is called on the +-- buffer. +-- +-- You can not have two mappings going on at the same time. +map :: Int -- ^ Offset, in bytes, from start of the buffer from where + -- to map. + -> Int -- ^ How many bytes to map. + -> AccessFlags -- ^ What access is allowed in the mapping. + -> Buffer + -> IO (Ptr ()) +map = map2 S.empty + +-- | Exception that is thrown from `unmap` when buffer corruption is detected. +-- +-- Corruption can happen due to external factors and is system-specific. +data BufferCorruption = BufferCorruption Buffer + deriving ( Eq, Typeable ) + +instance Show BufferCorruption where + show _ = "BufferCorruption <#Buffer>" + +instance Exception BufferCorruption + +-- | Unmaps a buffer. +-- +-- Does nothing if the buffer was not mapped. +-- +-- It is possible that the mapping become corrupt during the time it was +-- mapped. If there was corruption, `BufferCorruption` is thrown in this call. +-- +-- Corruption means that the contents of the buffer are now undefined. +unmap :: Buffer -> IO () +unmap buffer = do + bufstatus <- readIORef (status buffer) + when (mapped bufstatus) $ + withResource (resource buffer) $ \(Buffer_ buf) -> mask_ $ do + result <- mglUnmapNamedBuffer buf + when (fromIntegral result == gl_FALSE) $ + throwIO $ BufferCorruption buffer + atomicModifyIORef' (status buffer) $ \old -> + ( old { mapped = False }, () ) + +-- | Same as `withMapping` but with map flags. +-- +-- See `map2`. +withMapping2 :: S.Set MapFlag + -> Int + -> Int + -> AccessFlags + -> Buffer + -> (Ptr () -> IO a) + -> IO a +withMapping2 map_flags offset num_bytes access_flags buffer action = + mask $ \restore -> do + ptr <- map2 map_flags offset num_bytes access_flags buffer + did_it_work <- try $ restore $ action ptr + did_unmapping_work <- try $ unmap buffer + case did_it_work of + Left exc -> throwIO (exc :: SomeException) + Right result -> + case did_unmapping_work of + Left no -> throwIO (no :: BufferCorruption) + Right () -> return result + +-- | A convenience function over map/unmap that automatically unmaps the buffer +-- when done (even in the case of exceptions). +-- +-- The arguments to this function are the same as for `map`, except for extra +-- action argument. +-- +-- This calls `unmap` which means it can throw `BufferCorruption` when the +-- action is done. +-- +-- There is a rare case that can happen if your action throws an exception AND +-- the unmapping throws an exception. Which exception is propagated upwards? +-- If this happens, this call silences `BufferCorruption` exception and +-- re-throws the user exception. This unfortunately means there is no way to +-- know if the buffer was corrupted if you threw an exception inside the +-- action. +withMapping :: Int + -> Int + -> AccessFlags + -> Buffer + -> (Ptr () -> IO a) -- ^ The pointer is valid during this action. + -> IO a +withMapping = withMapping2 S.empty + +-- | A convenience function to upload a storable vector to a buffer. +-- +-- The buffer must be in an unmapped state and must be write-mappable. +uploadVector :: V.Storable a + => V.Vector a -- ^ The vector from which to pull data. + -> Int -- ^ Offset, in bytes, to which point in the + -- buffer to copy the data. + -> Buffer + -> IO () +uploadVector vec offset buffer = + V.unsafeWith vec $ \src_ptr -> + withMapping offset byte_size WriteAccess buffer $ \tgt_ptr -> + copyBytes tgt_ptr (castPtr src_ptr) byte_size + where + byte_size = V.length vec * sizeOf (undefined `asTypeOf` (vec V.! 0)) + +-- | Copies bytes from one buffer to another. +-- +-- The buffers must not be mapped; however this call can bypass the access +-- flags set in `newBuffer`. That is, you can copy data even to a buffer that +-- was set as not writable or copy from a buffer that was set as not readable. +-- +-- This is faster than mapping both buffers and then doing a memcpy() style +-- copying in system memory because this call does not require a round-trip to +-- the driver. +-- +-- You can use the same buffer for both destination and source but the copying +-- area may not overlap. +copy :: Buffer -- ^ Destination buffer. + -> Int -- ^ Offset in destination buffer. + -> Buffer -- ^ Source buffer. + -> Int -- ^ Offset in source buffer. + -> Int -- ^ How many bytes to copy. + -> IO () +copy dst_buffer dst_offset src_buffer src_offset num_bytes + | dst_offset < 0 || + src_offset < 0 || + dst_offset + num_bytes > viewSize dst_buffer || + src_offset + num_bytes > viewSize src_buffer || + num_bytes < 0 = + error "copy: invalid offsets/byte sizes to make a buffer copy." + | overlaps = error "copy: copying area overlaps." + | otherwise = + withResource (resource dst_buffer) $ \(Buffer_ dst) -> + withResource (resource src_buffer) $ \(Buffer_ src) -> do + dst_status <- readIORef (status dst_buffer) + when (mapped dst_status) $ + error "copy: destination buffer is mapped." + src_status <- readIORef (status src_buffer) + when (mapped src_status) $ + error "copy: source buffer is mapped." + + when (num_bytes > 0) $ + mglNamedCopyBufferSubData + src + dst + (safeFromIntegral src_offset) + (safeFromIntegral dst_offset) + (safeFromIntegral num_bytes) + + where + overlaps + | dst_buffer /= src_buffer = False + | dst_offset + num_bytes - 1 < src_offset || + dst_offset > src_offset + num_bytes - 1 = False + | otherwise = True + +-- | Invalidates the contents of a buffer. +-- +-- This is you saying: \"I don't care what's in this buffer anymore. You can do +-- whatever you want with it.\". +-- +-- The data may be gone or it may not be gone. Use this as a hint to the +-- implementation that you will not use the _current_ contents of the buffer +-- anymore. +-- +-- This requires the OpenGL extension \"GL_ARB_invalidate_subdata\" but if this +-- extension is not present, then this simply does nothing. +-- +-- See . +invalidateBuffer :: Buffer -> IO () +invalidateBuffer buf = do + has_it <- has_GL_ARB_invalidate_subdata + when has_it $ + withResource (resource buf) $ \(Buffer_ name) -> + glInvalidateBufferData name + diff --git a/src/Caramia/Buffer/Internal.hs b/src/Caramia/Buffer/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Buffer/Internal.hs @@ -0,0 +1,58 @@ +{-# LANGUAGE NoImplicitPrelude, ViewPatterns, DeriveDataTypeable #-} + +module Caramia.Buffer.Internal + ( Buffer(..) + , Buffer_(..) + , BufferStatus(..) + , AccessFlags(..) + , MapFlag(..) + , bufferOrdIndex ) + where + +import Caramia.Prelude + +import Caramia.Resource +import Caramia.Internal.OpenGLCApi +import System.IO.Unsafe + +-- | Buffer data type. +data Buffer = Buffer + { resource :: !(Resource Buffer_) + , status :: !(IORef BufferStatus) + , viewAllowedMappings :: !AccessFlags -- ^ Returns the allowed mappings. + , viewSize :: !Int -- ^ Returns the size of the buffer, in bytes. + , ordIndex :: !Int + } + +bufferOrdIndex :: IORef Int +bufferOrdIndex = unsafePerformIO $ newIORef 0 +{-# NOINLINE bufferOrdIndex #-} + +instance Ord Buffer where + (ordIndex -> o1) `compare` (ordIndex -> o2) = o1 `compare` o2 + +data BufferStatus = BufferStatus + { mapped :: !Bool } + +instance Eq Buffer where + (resource -> res1) == (resource -> res2) = res1 == res2 + +newtype Buffer_ = Buffer_ GLuint + +-- | Describes a style of mapping. +data AccessFlags = + ReadAccess -- ^ The mapping can be read from. + | WriteAccess -- ^ The mapping can be written to. + | ReadWriteAccess -- ^ Both reading and writing can be done. + | NoAccess -- ^ No access; you cannot map the buffer at all after + -- creation. + deriving ( Eq, Ord, Show, Read ) + +-- | Additional mapping flags. +data MapFlag = + UnSynchronized -- ^ Map the buffer without synchronization. + -- You will have to use synchronization primitives + -- to make sure you and OpenGL won't be using + -- the buffer at the same time. + deriving ( Eq, Ord, Show, Read, Typeable ) + diff --git a/src/Caramia/Color.hs b/src/Caramia/Color.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Color.hs @@ -0,0 +1,100 @@ +-- | Color handling. +-- + +{-# LANGUAGE DeriveDataTypeable, NoImplicitPrelude #-} + +module Caramia.Color + ( + -- * Types + Color() + -- * Constructing colors + , rgba + -- * Lenses + , rgbaL + , redL + , greenL + , blueL + , alphaL + -- * Views + , viewRgba + , viewRed + , viewGreen + , viewBlue + , viewAlpha ) + where + +import Caramia.Prelude +import Foreign.Storable +import Foreign.Ptr +import Caramia.Internal.Lens + +-- | The color data type. +-- +-- This data type says nothing about the color space these values are in. The +-- color space depends on the usage; for example, a framebuffer with sRGB +-- textures attached uses sRGB color space in these color values. +data Color = Color + { viewRed :: !Float + , viewGreen :: !Float + , viewBlue :: !Float + , viewAlpha :: !Float + } + deriving ( Eq, Ord, Show, Read, Typeable ) + +-- | Construct a color from rgba values. +rgba :: Float -> Float -> Float -> Float -> Color +rgba = Color +{-# INLINE rgba #-} + +-- | View rgba in a tuple. +viewRgba :: Color -> (Float, Float, Float, Float) +viewRgba (Color r g b a) = (r, g, b, a) +{-# INLINE viewRgba #-} + +-- | Lens to all components. +rgbaL :: Lens' Color (Float, Float, Float, Float) +rgbaL = lens viewRgba (\old (r, g, b, a) -> + old { viewRed = r + , viewGreen = g + , viewBlue = b + , viewAlpha = a }) + +-- | Lens to red component. +redL :: Lens' Color Float +redL = lens viewRed (\old new -> old { viewRed = new }) + +-- | Lens to green component. +greenL :: Lens' Color Float +greenL = lens viewGreen (\old new -> old { viewGreen = new }) + +-- | Lens to blue component. +blueL :: Lens' Color Float +blueL = lens viewBlue (\old new -> old { viewBlue = new }) + +-- | Lens to alpha component. +alphaL :: Lens' Color Float +alphaL = lens viewAlpha (\old new -> old { viewAlpha = new }) + +instance Storable Color where + sizeOf _ = sizeOf (undefined :: Float) * 4 + alignment _ = alignment (undefined :: Float) * 4 + peek ptr = do + r <- peekElemOff cptr 0 :: IO Float + g <- peekElemOff cptr 1 :: IO Float + b <- peekElemOff cptr 2 :: IO Float + a <- peekElemOff cptr 3 :: IO Float + return $ Color r g b a + where + cptr = castPtr ptr :: Ptr Float + {-# INLINE peek #-} + + poke ptr (Color r g b a) = do + pokeElemOff cptr 0 r + pokeElemOff cptr 1 g + pokeElemOff cptr 2 b + pokeElemOff cptr 3 a + where + cptr = castPtr ptr :: Ptr Float + {-# INLINE poke #-} + + diff --git a/src/Caramia/Context.hs b/src/Caramia/Context.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Context.hs @@ -0,0 +1,205 @@ +-- | This module manages OpenGL contexts in Caramia. +-- +-- Caramia does not actually have any functionality about creating OpenGL +-- contexts. You need to tell it about them with this module. +-- +-- `giveContext` is the most important function in this module. You also want +-- to `runPendingFinalizers` regularly to make sure OpenGL resources are +-- garbage collected. +-- + +{-# LANGUAGE NoImplicitPrelude, ScopedTypeVariables, DeriveDataTypeable #-} +{-# LANGUAGE CPP, LambdaCase #-} + +module Caramia.Context + ( + -- * Running with an OpenGL context + giveContext + -- * Context IDs + , currentContextID + , ContextID + -- * Finalization + , runPendingFinalizers + , scheduleFinalizer + -- * Context local data + , storeContextLocalData + , retrieveContextLocalData + -- * Exceptions + , TooOldOpenGL(..) ) + where + +import Caramia.Prelude +import Caramia.Internal.ContextLocalData +import Caramia.Internal.OpenGLDebug +import Caramia.Internal.FlextGL + +import Control.Concurrent +import Control.Exception +import System.IO.Unsafe +import System.Environment +import Graphics.Rendering.OpenGL.Raw.GetProcAddress +import Foreign.Ptr +import Foreign.Storable +import Foreign.Marshal.Alloc + +import qualified Data.Map.Strict as M +import qualified Data.IntMap.Strict as IM + +-- | An exception that is thrown when the OpenGL version is too old for this +-- library. +data TooOldOpenGL = TooOldOpenGL + { wantedVersion :: (Int, Int) -- ^ The OpenGL version this + -- library needs. + , reportedVersion :: (Int, Int) + -- ^ The OpenGL version reported by current OpenGL + -- context. + } + deriving ( Eq, Show, Read, Typeable ) + +instance Exception TooOldOpenGL + +-- | Tell Caramia the current thread has an OpenGL context active. +-- +-- When the given IO action returns, Caramia will think that the OpenGL context +-- is now gone. It is probably best to actually close the context because this +-- also means OpenGL finalizers will not be run (Caramia thinks they were all +-- released when the OpenGL context went away). +-- +-- The context in the IO action is referred to as \'Caramia context\' in this +-- documentation to distinguish it from OpenGL context. +-- +-- If the environment variable \'CARAMIA_OPENGL_DEBUG\' is set, then, if +-- \'GL_KHR_debug\' extension is supported, OpenGL debug output is written. +-- Note that you might need a debug OpenGL context for there to be any +-- messages. +-- +-- Throws `TooOldOpenGL` if the code detects a context that does not provide +-- OpenGL 3.3. +giveContext :: IO a -> IO a +giveContext action = mask $ \restore -> do + is_bound_thread <- isCurrentThreadBound + unless is_bound_thread $ + error $ "giveContext: current thread is not bound. How can it have " <> + "an OpenGL context?" + + flextInit (\str -> castFunPtrToPtr <$> getProcAddress str) + (\_ -> return True) >>= \case + f@(Failure _) -> throwIO f + _ -> return () + + checkOpenGLVersion33 + + cid <- atomicModifyIORef' nextContextID $ \old -> ( old+1, old ) + tid <- myThreadId + atomicModifyIORef' runningContexts $ \old_map -> + ( M.insert tid cid old_map, () ) + finally (restore insides) (flushDebugMessages >> scrapContext) + where + insides = do + should_activate_debug_mode <- isJust <$> lookupEnv "CARAMIA_OPENGL_DEBUG" + when should_activate_debug_mode activateDebugMode + + -- Enable sRGB framebuffers + -- There seems to be no reason not to enable it; you can turn off sRGB + -- handling in other ways. + glEnable gl_FRAMEBUFFER_SRGB + glEnable gl_BLEND + + action + +checkOpenGLVersion33 :: IO () +checkOpenGLVersion33 = + -- You cannot trust OS X to report versions correctly :-( +#ifdef MAC_OPENGL + return () +#else + alloca $ \major_ptr -> alloca $ \minor_ptr -> do + -- in case glGetIntegerv is completely broken, set initial values for + -- major and minor pointers + poke major_ptr 0 + poke minor_ptr 0 + + glGetIntegerv gl_MAJOR_VERSION major_ptr + glGetIntegerv gl_MAJOR_VERSION minor_ptr + major <- peek major_ptr + minor <- peek minor_ptr + unless (major > 3 || + (major == 3 && minor >= 3)) $ + throwIO + TooOldOpenGL { wantedVersion = (3, 3) + , reportedVersion = ( fromIntegral major + , fromIntegral minor ) + } +#endif + +-- | Scraps the current context. +-- +-- Not public API. +scrapContext :: IO () +scrapContext = mask_ $ do + maybe_cid <- currentContextID + tid <- myThreadId + case maybe_cid of + Nothing -> return () + Just cid -> do + atomicModifyIORef' runningContexts $ \old_map -> + ( M.delete tid old_map, () ) + atomicModifyIORef' pendingFinalizers $ \old_map -> + ( IM.delete cid old_map, () ) + atomicModifyIORef' contextLocalData $ \old_map -> + ( IM.delete cid old_map, () ) + +-- | Run any pending finalizers in the current Caramia context. +-- +-- Does nothing if current thread does not have a Caramia context or there are +-- no pending finalizers. +-- +-- If any finalizer throws an exception (asynchronous or synchronous), the +-- Caramia context dies and that exception is propagated upwards. +-- `runPendingFinalizers` itself runs `mask_` to run the finalizers with +-- exceptions masked but you might still receive asynchronous exceptions with, +-- for example, the `MVar` functions. +-- +-- A good place to call this is right after or before swapping buffers. +runPendingFinalizers :: IO () +runPendingFinalizers = mask_ $ do + maybe_cid <- currentContextID + case maybe_cid of + Nothing -> return () + Just cid -> do + finalizers <- atomicModifyIORef' pendingFinalizers $ + IM.delete cid &&& + IM.findWithDefault (return ()) + cid + + -- We scrap the Caramia context if any of these finalizers throw an + -- exception. The reason is that we cannot expect the OpenGL state + -- to be consistent anymore. + result <- try finalizers + case result of + Left exc -> scrapContext >> throwIO (exc :: SomeException) + Right () -> return () + flushDebugMessages + +-- | Schedules a finalizer to be run in a Caramia context. +-- +-- Does nothing if given context is not alive anymore. +-- +-- This is typically called from Haskell garbage collector finalizers because +-- they cannot do finalization there (Haskell finalizers are running in the +-- wrong operating system thread). +scheduleFinalizer :: ContextID -> IO () -> IO () +scheduleFinalizer cid finalizer = + atomicModifyIORef' pendingFinalizers $ \old -> + ( IM.insertWith + (flip (>>)) + cid + finalizer + old, () ) + +-- these are the pending OpenGL finalizers that wait for a time they can be +-- safely run. +pendingFinalizers :: IORef (IM.IntMap (IO ())) +pendingFinalizers = unsafePerformIO $ newIORef IM.empty +{-# NOINLINE pendingFinalizers #-} + diff --git a/src/Caramia/Framebuffer.hs b/src/Caramia/Framebuffer.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Framebuffer.hs @@ -0,0 +1,302 @@ +-- | Framebuffers. You can render on them. +-- +-- If you come from the OpenGL world, for simplicity, we have combined the +-- concept of draw buffers and color attachments. Nth color attachment is bound +-- exactly to Nth draw buffer. Caramia only talks about draw buffers. +-- +-- +-- + +{-# LANGUAGE NoImplicitPrelude, ViewPatterns, DeriveDataTypeable #-} + +module Caramia.Framebuffer + ( + -- * Creating framebuffers + newFramebuffer + , Framebuffer() + -- * Specifying texture targets + , frontTextureTarget + , mipmapTextureTarget + , layerTextureTarget + , TextureTarget() + , Attachment(..) + -- * Size query + , getDimensions + -- * Clearing framebuffers + , clear + , Clearing(..) + , clearing + -- * Special framebuffers + , screenFramebuffer + -- * Hardware limits + , getMaximumDrawBuffers + -- * Views + , viewTargets ) + where + +import Caramia.Prelude +import Caramia.Context +import Caramia.Color +import Caramia.Resource +import Caramia.Texture +import Caramia.Framebuffer.Internal +import qualified Caramia.Texture.Internal as Tex +import Caramia.ImageFormats +import Caramia.Internal.OpenGLCApi +import Control.Exception +import Data.List ( nub ) +import Data.Bits +import System.IO.Unsafe +import Foreign.Storable +import Foreign.Marshal.Alloc +import Foreign.Marshal.Array +import Foreign.C.Types +import GHC.Float +import qualified Data.IntSet as IS + +-- | Returns the screen framebuffer. +-- +-- Note that all `screenFramebuffer`s are equal to each other with `Eq`, even +-- those in unrelated Caramia contexts. +-- +-- This makes it easy to check if any framebuffer happens to be the screen +-- framebuffer. +screenFramebuffer :: Framebuffer +screenFramebuffer = ScreenFramebuffer + +-- | Make a texture target that is the \"front\" of the given texture. +-- +-- This is the most common use case. \"front\" means the first texture in a +-- texture array and the base layer mipmap level. +frontTextureTarget :: Tex.Texture -> TextureTarget +frontTextureTarget tex = TextureTarget { + attacher = \attachment -> + withResource (Tex.resource tex) $ \(Tex.Texture_ texname) -> + glFramebufferTexture + gl_DRAW_FRAMEBUFFER + attachment + texname + 0 + , texture = tex } + +-- | Map a specific mipmlayer from a texture. +mipmapTextureTarget :: Tex.Texture + -> Int -- ^ Which mipmap layer? + -> TextureTarget +mipmapTextureTarget tex mipmap_layer = TextureTarget { + attacher = \attachment -> + withResource (Tex.resource tex) $ \(Tex.Texture_ texname) -> + glFramebufferTexture + gl_DRAW_FRAMEBUFFER + attachment + texname + (safeFromIntegral mipmap_layer) + , texture = tex } + +-- | Map a specific mipmap layer of a specific layer in a 3D or array texture. +layerTextureTarget :: Tex.Texture + -> Int -- ^ Which mipmap layer? + -> Int -- ^ Which topological layer? + -> TextureTarget +layerTextureTarget tex mipmap_layer topo_layer = TextureTarget { + attacher = \attachment -> + withResource (Tex.resource tex) $ \(Tex.Texture_ texname) -> + glFramebufferTextureLayer + gl_DRAW_FRAMEBUFFER + attachment + texname + (safeFromIntegral mipmap_layer) + (safeFromIntegral topo_layer) + , texture = tex } + +runningIndices :: IORef Int +runningIndices = unsafePerformIO $ newIORef 0 +{-# NOINLINE runningIndices #-} + +toConstantA :: Attachment -> GLenum +toConstantA (ColorAttachment x) = gl_COLOR_ATTACHMENT0 + fromIntegral x +toConstantA DepthAttachment = gl_DEPTH_ATTACHMENT +toConstantA StencilAttachment = gl_STENCIL_ATTACHMENT + +-- | Creates a new framebuffer. +newFramebuffer :: [(Attachment, TextureTarget)] + -> IO Framebuffer +newFramebuffer targets + | null targets = + error "newFramebuffer: no texture targets specified." + | nub (fmap fst targets) /= fmap fst targets = + error "newFramebuffer: there are duplicate attachments." + | otherwise = mask_ $ do + max_bufs <- getMaximumDrawBuffers + targetsSanityCheck max_bufs + + res <- newResource (creator max_bufs) + deleter + (return ()) + index <- atomicModifyIORef' runningIndices $ \old -> + ( old+1, old ) + return Framebuffer { resource = res + , ordIndex = index + , viewTargets = targets + , dimensions = calculatedDimensions + , binder = withThisFramebuffer res + , setter = setThisFramebuffer res } + where + calculatedDimensions@(fw, fh) = + foldl' (\(lowest_w, lowest_h) (w, h) -> + (min lowest_w w, min lowest_h h)) + (maxBound, maxBound) + (fmap (\(snd -> tex) -> + (viewWidth $ texture tex, viewHeight $ texture tex)) + targets) + + creator max_bufs = + bracketOnError mglGenFramebuffer + mglDeleteFramebuffer $ \fbuf_name -> do + withBoundDrawFramebuffer fbuf_name $ do + forM_ targets $ \(index, tex) -> + attacher tex (toConstantA index) + + allocaArray max_bufs $ \buf_ptr -> do + forM_ [0..max_bufs-1] $ \bufnum -> + pokeElemOff buf_ptr bufnum $ + if IS.member bufnum color_attachments + then gl_COLOR_ATTACHMENT0 + + fromIntegral bufnum + else gl_NONE + glDrawBuffers (fromIntegral max_bufs) buf_ptr + + return $ Framebuffer_ fbuf_name + + color_attachments :: IS.IntSet + color_attachments = + foldl' folder IS.empty (fmap fst targets) + where + folder :: IS.IntSet -> Attachment -> IS.IntSet + folder accum (ColorAttachment x) = IS.insert x accum + folder accum _ = accum + + deleter (Framebuffer_ fbuf_name) = + mglDeleteFramebuffer fbuf_name + + targetsSanityCheck max_bufs = forM_ targets $ \(attachment, target) -> do + let format = Tex.imageFormat $ Tex.viewSpecification $ texture target + unless (isRenderTargettable format) $ + error $ "newFramebuffer: cannot render to " <> show format + case attachment of + ColorAttachment x | x < 0 || x >= max_bufs -> + error $ "newFramebuffer: color attachment " <> show x <> + " is out of range. Valid range is [0.." <> + show (max_bufs-1) <> "]." + ColorAttachment _ | not (isColorFormat format) -> + error $ "newFramebuffer: " <> show format <> " is not a " <> + "color format but was attempted to be attached to " <> + "attachment " <> show attachment <> "." + DepthAttachment | not (hasDepthComponent format) -> + error $ "newFramebuffer: " <> show format <> " has no " <> + "depth component but was attempted to be attached " <> + "to depth attachment." + StencilAttachment | not (hasStencilComponent format) -> + error $ "newFramebuffer: " <> show format <> " has no " <> + "stencil component but was attempted to be " <> + "attached to stencil attachment." + _ -> return () + + setThisFramebuffer res = do + withResource res $ \(Framebuffer_ fbuf_name) -> + glBindFramebuffer gl_FRAMEBUFFER fbuf_name + glViewport 0 0 (fromIntegral fw) (fromIntegral fh) + + withThisFramebuffer res action = mask $ \restore -> do + old_draw_framebuffer <- gi gl_DRAW_FRAMEBUFFER_BINDING + old_read_framebuffer <- gi gl_READ_FRAMEBUFFER_BINDING + allocaArray 4 $ \viewport_ptr -> do + glGetIntegerv gl_VIEWPORT viewport_ptr + withResource res $ \(Framebuffer_ fbuf_name) -> do + glBindFramebuffer gl_FRAMEBUFFER fbuf_name + x <- peekElemOff viewport_ptr 0 + y <- peekElemOff viewport_ptr 1 + w <- peekElemOff viewport_ptr 2 + h <- peekElemOff viewport_ptr 3 + glViewport 0 0 (fromIntegral fw) (fromIntegral fh) + finally (restore action) $ do + glViewport x y w h + glBindFramebuffer gl_DRAW_FRAMEBUFFER old_draw_framebuffer + glBindFramebuffer gl_READ_FRAMEBUFFER old_read_framebuffer + +-- | Returns the maximum number of draw buffers in the current context. +-- +-- Almost all GPUs in the last few years have at least 8. +getMaximumDrawBuffers :: IO Int +getMaximumDrawBuffers = do + _ <- currentContextID + -- number of draw buffers + num_drawbuffers <- gi gl_MAX_DRAW_BUFFERS + -- number of attachments + num_attachments <- gi gl_MAX_COLOR_ATTACHMENTS + return (fromIntegral $ min num_drawbuffers num_attachments) + +-- | Specifies what to clear in a `clear` invocation. +-- +-- Use `clearing` smart constructor instead for forward-compatibility. +-- +-- Each member of this data type is a `Maybe` value; if any value is `Just` +-- then that value is cleared, otherwise it is not touched. +data Clearing = Clearing + { clearDepth :: !(Maybe Float) + -- ^ Clear depth buffer to this value. + , clearStencil :: !(Maybe Int32) + -- ^ Clear stencil buffer to this value. + , clearColor :: !(Maybe Color) + -- ^ Clear (all) color buffers to some color. + } + deriving ( Eq, Ord, Show, Read, Typeable ) + +-- TODO: selective clearing for different color buffers. + +-- | Smart constructor for `Clearing`. All members are `Nothing`. +clearing :: Clearing +clearing = Clearing { clearDepth = Nothing + , clearStencil = Nothing + , clearColor = Nothing } + +-- | Clears values in a framebuffer. +clear :: Clearing -> Framebuffer -> IO () +clear clearing fbuf = withBinding fbuf $ mask_ $ + recColor (clearColor clearing) + where + bits = maybe 0 (const gl_COLOR_BUFFER_BIT) (clearColor clearing) .|. + maybe 0 (const gl_DEPTH_BUFFER_BIT) (clearDepth clearing) .|. + maybe 0 (const gl_STENCIL_BUFFER_BIT) (clearStencil clearing) + + recColor Nothing = recDepth (clearDepth clearing) + recColor (Just (viewRgba -> (r, g, b, a))) = + allocaArray 4 $ \ptr -> do + glGetFloatv gl_COLOR_CLEAR_VALUE ptr + glClearColor (CFloat r) + (CFloat g) + (CFloat b) + (CFloat a) + recDepth (clearDepth clearing) + nr <- peekElemOff ptr 0 + ng <- peekElemOff ptr 1 + nb <- peekElemOff ptr 2 + na <- peekElemOff ptr 3 + glClearColor (nr :: CFloat) ng nb na + + recDepth Nothing = recStencil (clearStencil clearing) + recDepth (Just depth) = do + old_depth <- alloca $ \ptr -> + glGetDoublev gl_DEPTH_CLEAR_VALUE ptr *> peek ptr + glClearDepth (CDouble $ float2Double depth) + recStencil (clearStencil clearing) + glClearDepth old_depth + + recStencil Nothing = glClear bits + recStencil (Just stencil) = do + old_stencil <- alloca $ \ptr -> + glGetIntegerv gl_STENCIL_CLEAR_VALUE ptr *> peek ptr + glClearStencil (safeFromIntegral stencil) + glClear bits + glClearStencil old_stencil + diff --git a/src/Caramia/Framebuffer/Internal.hs b/src/Caramia/Framebuffer/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Framebuffer/Internal.hs @@ -0,0 +1,87 @@ +{-# LANGUAGE RankNTypes, NoImplicitPrelude, DeriveDataTypeable #-} + +module Caramia.Framebuffer.Internal where + +import Caramia.Prelude + +import Caramia.Resource +import Caramia.Internal.OpenGLCApi +import qualified Caramia.Texture.Internal as Tex +import Control.Exception +import Foreign + +data Framebuffer = + ScreenFramebuffer + | Framebuffer { + resource :: !(Resource Framebuffer_) + , ordIndex :: !Int + , viewTargets :: [(Attachment, TextureTarget)] + , dimensions :: !(Int, Int) + , binder :: forall a. IO a -> IO a + , setter :: IO () + } + deriving ( Typeable ) + +data Attachment = ColorAttachment !Int + | DepthAttachment + | StencilAttachment + deriving ( Eq, Ord, Show, Read, Typeable ) + +instance Eq Framebuffer where + ScreenFramebuffer == ScreenFramebuffer = True + ScreenFramebuffer == _ = False + _ == ScreenFramebuffer = False + fbuf1 == fbuf2 = resource fbuf1 == resource fbuf2 + +instance Ord Framebuffer where + ScreenFramebuffer `compare` ScreenFramebuffer = EQ + ScreenFramebuffer `compare` _ = LT + _ `compare` ScreenFramebuffer = GT + fbuf1 `compare` fbuf2 = ordIndex fbuf1 `compare` ordIndex fbuf2 + +newtype Framebuffer_ = Framebuffer_ GLuint + +data TextureTarget = TextureTarget + { attacher :: GLuint -> IO () + , texture :: Tex.Texture } + +setBinding :: Framebuffer -> IO () +setBinding ScreenFramebuffer = do + (w, h) <- getDimensions ScreenFramebuffer + glBindFramebuffer gl_FRAMEBUFFER 0 + glViewport 0 0 (fromIntegral w) (fromIntegral h) +setBinding fbuf = setter fbuf + +withBinding :: Framebuffer -> IO a -> IO a +withBinding ScreenFramebuffer action = + allocaArray 4 $ \viewport_ptr -> do + glGetIntegerv gl_VIEWPORT viewport_ptr + ox <- peekElemOff viewport_ptr 0 + oy <- peekElemOff viewport_ptr 1 + ow <- peekElemOff viewport_ptr 2 + oh <- peekElemOff viewport_ptr 3 + (w, h) <- getDimensions ScreenFramebuffer + old_draw <- gi gl_DRAW_FRAMEBUFFER_BINDING + old_read <- gi gl_READ_FRAMEBUFFER_BINDING + finally (glBindFramebuffer gl_FRAMEBUFFER 0 >> + glViewport 0 0 (fromIntegral w) (fromIntegral h) >> + action) $ do + glViewport ox oy ow oh + glBindFramebuffer gl_DRAW_FRAMEBUFFER old_draw + glBindFramebuffer gl_READ_FRAMEBUFFER old_read +withBinding fbuf action = binder fbuf action + +-- | Returns the size of a framebuffer. +-- +-- This is an `IO` action because it can change for the screen framebuffer. +getDimensions :: Framebuffer -> IO (Int, Int) +getDimensions ScreenFramebuffer = + allocaArray 4 $ \vptr -> do + glGetIntegerv gl_VIEWPORT vptr + w <- peekElemOff vptr 2 + h <- peekElemOff vptr 3 + return (fromIntegral w, fromIntegral h) +getDimensions fbuf = return $ dimensions fbuf +{-# INLINE getDimensions #-} + + diff --git a/src/Caramia/ImageFormats.hs b/src/Caramia/ImageFormats.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/ImageFormats.hs @@ -0,0 +1,18 @@ +module Caramia.ImageFormats + ( + -- * Image formats + ImageFormat(..) + , isRenderTargettable + , isCompressed + , isColorFormat + , isSRGBFormat + , hasDepthComponent + , hasStencilComponent + -- * Specification types + , SpecificationType(..) + , sizeOfSpecificationType + , SpecificationTypeable(..) ) + where + +import Caramia.ImageFormats.Internal + diff --git a/src/Caramia/ImageFormats/Internal.hs b/src/Caramia/ImageFormats/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/ImageFormats/Internal.hs @@ -0,0 +1,328 @@ +-- | This module contains data types that describe the data formats of images. +-- +-- +-- + +{-# LANGUAGE DeriveDataTypeable, NoImplicitPrelude #-} + +module Caramia.ImageFormats.Internal where + +import Caramia.Prelude + +import Caramia.Internal.OpenGLCApi +import Foreign.C.Types + +-- | Given a format, returns `True` if that format can be rendered to. That is, +-- if it can be one of the targets in a framebuffer. +-- +-- This is conservative. Sometimes you may be able to render anyway; however +-- this is not guaranteed by the OpenGL specification. +isRenderTargettable :: ImageFormat -> Bool +isRenderTargettable R8 = True +isRenderTargettable R8I = True +isRenderTargettable R8UI = True +isRenderTargettable R16 = True +isRenderTargettable R16I = True +isRenderTargettable R16UI = True +isRenderTargettable R16F = True +isRenderTargettable R32F = True +isRenderTargettable R32I = True +isRenderTargettable R32UI = True +isRenderTargettable RG8 = True +isRenderTargettable RG8I = True +isRenderTargettable RG8UI = True +isRenderTargettable RG16 = True +isRenderTargettable RG16I = True +isRenderTargettable RG16UI = True +isRenderTargettable RG16F = True +isRenderTargettable RG32F = True +isRenderTargettable RG32I = True +isRenderTargettable RG32UI = True +isRenderTargettable R11F_G11F_B10F = True +isRenderTargettable RGB8 = True +isRenderTargettable RGBA32F = True +isRenderTargettable RGBA32I = True +isRenderTargettable RGBA32UI = True +isRenderTargettable RGBA16 = True +isRenderTargettable RGBA16F = True +isRenderTargettable RGBA16I = True +isRenderTargettable RGBA16UI = True +isRenderTargettable RGBA8 = True +isRenderTargettable RGBA8UI = True +isRenderTargettable SRGB8_ALPHA8 = True +isRenderTargettable RGB10_A2 = True +isRenderTargettable DEPTH_COMPONENT32 = True +isRenderTargettable DEPTH_COMPONENT32F = True +isRenderTargettable DEPTH_COMPONENT24 = True +isRenderTargettable DEPTH_COMPONENT16 = True +isRenderTargettable DEPTH32F_STENCIL8 = True +isRenderTargettable DEPTH24_STENCIL8 = True +isRenderTargettable _ = False + +-- | Returns true if the given format is a compressed format. +isCompressed :: ImageFormat -> Bool +isCompressed COMPRESSED_RG_RGTC2 = True +isCompressed COMPRESSED_SIGNED_RG_RGTC2 = True +isCompressed COMPRESSED_RED_RGTC1 = True +isCompressed COMPRESSED_SIGNED_RED_RGTC1 = True +isCompressed COMPRESSED_RGB_S3TC_DXT1 = True +isCompressed COMPRESSED_RGBA_S3TC_DXT1 = True +isCompressed COMPRESSED_RGBA_S3TC_DXT3 = True +isCompressed COMPRESSED_RGBA_S3TC_DXT5 = True +isCompressed COMPRESSED_SRGB_S3TC_DXT1 = True +isCompressed COMPRESSED_SRGB_ALPHA_S3TC_DXT1 = True +isCompressed COMPRESSED_SRGB_ALPHA_S3TC_DXT3 = True +isCompressed COMPRESSED_SRGB_ALPHA_S3TC_DXT5 = True +isCompressed _ = False + +-- | Returns true if the given format is a color format. +isColorFormat :: ImageFormat -> Bool +isColorFormat DEPTH_COMPONENT32 = False +isColorFormat DEPTH_COMPONENT32F = False +isColorFormat DEPTH_COMPONENT24 = False +isColorFormat DEPTH_COMPONENT16 = False +isColorFormat DEPTH32F_STENCIL8 = False +isColorFormat DEPTH24_STENCIL8 = False +isColorFormat _ = True + +-- | Returns true if the given format has a depth component. +hasDepthComponent :: ImageFormat -> Bool +hasDepthComponent DEPTH_COMPONENT32 = True +hasDepthComponent DEPTH_COMPONENT32F = True +hasDepthComponent DEPTH_COMPONENT24 = True +hasDepthComponent DEPTH_COMPONENT16 = True +hasDepthComponent DEPTH32F_STENCIL8 = True +hasDepthComponent DEPTH24_STENCIL8 = True +hasDepthComponent _ = False + +-- | Returns true if the given format has a stencil component. +hasStencilComponent :: ImageFormat -> Bool +hasStencilComponent DEPTH32F_STENCIL8 = True +hasStencilComponent DEPTH24_STENCIL8 = True +hasStencilComponent _ = False + +-- | Returns true if the given format uses the sRGB color space. +-- +-- If the format is not a color format, returns `False`. +isSRGBFormat :: ImageFormat -> Bool +isSRGBFormat SRGB8_ALPHA8 = True +isSRGBFormat SRGB8 = True +isSRGBFormat COMPRESSED_SRGB_S3TC_DXT1 = True +isSRGBFormat COMPRESSED_SRGB_ALPHA_S3TC_DXT1 = True +isSRGBFormat COMPRESSED_SRGB_ALPHA_S3TC_DXT3 = True +isSRGBFormat COMPRESSED_SRGB_ALPHA_S3TC_DXT5 = True +isSRGBFormat _ = False + +-- | All the various internal formats. +-- +-- This list corresponds to the OpenGL specification of 3.3, required texture +-- formats (+ S3TC compressed formats). Check the OpenGL specification for +-- explanations on how these formats work. +data ImageFormat = + R8 + | R8I + | R8UI + | R16 + | R16I + | R16UI + | R16F + | R32F + | R32I + | R32UI + | RG8 + | RG8I + | RG8UI + | RG16 + | RG16I + | RG16UI + | RG16F + | RG32F + | RG32I + | RG32UI + | R11F_G11F_B10F + | RGBA32F + | RGBA32I + | RGBA32UI + | RGBA16 + | RGBA16F + | RGBA16I + | RGBA16UI + | RGBA8 + | RGBA8UI + | SRGB8_ALPHA8 + | RGB10_A2 + | RGB32F + | RGB32I + | RGB32UI + | RGB16F + | RGB16I + | RGB16UI + | RGB16 + | RGB8 + | RGB8I + | RGB8UI + | SRGB8 + | RGB9_E5 + | COMPRESSED_RG_RGTC2 + | COMPRESSED_SIGNED_RG_RGTC2 + | COMPRESSED_RED_RGTC1 + | COMPRESSED_SIGNED_RED_RGTC1 + | COMPRESSED_RGB_S3TC_DXT1 + | COMPRESSED_RGBA_S3TC_DXT1 + | COMPRESSED_RGBA_S3TC_DXT3 + | COMPRESSED_RGBA_S3TC_DXT5 + | COMPRESSED_SRGB_S3TC_DXT1 + | COMPRESSED_SRGB_ALPHA_S3TC_DXT1 + | COMPRESSED_SRGB_ALPHA_S3TC_DXT3 + | COMPRESSED_SRGB_ALPHA_S3TC_DXT5 + | DEPTH_COMPONENT32 + | DEPTH_COMPONENT32F + | DEPTH_COMPONENT24 + | DEPTH_COMPONENT16 + | DEPTH32F_STENCIL8 + | DEPTH24_STENCIL8 + deriving ( Eq, Ord, Show, Read, Typeable ) + +toConstantIF :: ImageFormat -> GLenum +toConstantIF R8 = gl_R8 +toConstantIF R8I = gl_R8I +toConstantIF R8UI = gl_R8UI +toConstantIF R16 = gl_R16 +toConstantIF R16I = gl_R16I +toConstantIF R16UI = gl_R16UI +toConstantIF R16F = gl_R16F +toConstantIF R32F = gl_R32F +toConstantIF R32I = gl_R32I +toConstantIF R32UI = gl_R32UI +toConstantIF RG8 = gl_RG8 +toConstantIF RG8I = gl_RG8I +toConstantIF RG8UI = gl_RG8UI +toConstantIF RG16 = gl_RG16 +toConstantIF RG16I = gl_RG16I +toConstantIF RG16UI = gl_RG16UI +toConstantIF RG16F = gl_RG16F +toConstantIF RG32F = gl_RG32F +toConstantIF RG32I = gl_RG32I +toConstantIF RG32UI = gl_RG32UI +toConstantIF R11F_G11F_B10F = gl_R11F_G11F_B10F +toConstantIF RGBA32F = gl_RGBA32F +toConstantIF RGBA32I = gl_RGBA32I +toConstantIF RGBA32UI = gl_RGBA32UI +toConstantIF RGBA16 = gl_RGBA16 +toConstantIF RGBA16F = gl_RGBA16F +toConstantIF RGBA16I = gl_RGBA16I +toConstantIF RGBA16UI = gl_RGBA16UI +toConstantIF RGBA8 = gl_RGBA8 +toConstantIF RGBA8UI = gl_RGBA8UI +toConstantIF SRGB8_ALPHA8 = gl_SRGB8_ALPHA8 +toConstantIF RGB10_A2 = gl_RGB10_A2 +toConstantIF RGB32F = gl_RGB32F +toConstantIF RGB32I = gl_RGB32I +toConstantIF RGB32UI = gl_RGB32UI +toConstantIF RGB16F = gl_RGB16F +toConstantIF RGB16I = gl_RGB16I +toConstantIF RGB16UI = gl_RGB16UI +toConstantIF RGB16 = gl_RGB16 +toConstantIF RGB8 = gl_RGB8 +toConstantIF RGB8I = gl_RGB8I +toConstantIF RGB8UI = gl_RGB8UI +toConstantIF SRGB8 = gl_SRGB8 +toConstantIF RGB9_E5 = gl_RGB9_E5 +toConstantIF COMPRESSED_RG_RGTC2 = gl_COMPRESSED_RG_RGTC2 +toConstantIF COMPRESSED_SIGNED_RG_RGTC2 = gl_COMPRESSED_SIGNED_RG_RGTC2 +toConstantIF COMPRESSED_RED_RGTC1 = gl_COMPRESSED_RED_RGTC1 +toConstantIF COMPRESSED_SIGNED_RED_RGTC1 = gl_COMPRESSED_SIGNED_RED_RGTC1 +toConstantIF COMPRESSED_RGB_S3TC_DXT1 = gl_COMPRESSED_RGB_S3TC_DXT1_EXT +toConstantIF COMPRESSED_RGBA_S3TC_DXT1 = gl_COMPRESSED_RGBA_S3TC_DXT1_EXT +toConstantIF COMPRESSED_RGBA_S3TC_DXT3 = gl_COMPRESSED_RGBA_S3TC_DXT3_EXT +toConstantIF COMPRESSED_RGBA_S3TC_DXT5 = gl_COMPRESSED_RGBA_S3TC_DXT5_EXT +toConstantIF COMPRESSED_SRGB_S3TC_DXT1 = gl_COMPRESSED_SRGB_S3TC_DXT1_EXT +toConstantIF COMPRESSED_SRGB_ALPHA_S3TC_DXT1 = + gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT +toConstantIF COMPRESSED_SRGB_ALPHA_S3TC_DXT3 = + gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT +toConstantIF COMPRESSED_SRGB_ALPHA_S3TC_DXT5 = + gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT +toConstantIF DEPTH_COMPONENT32 = gl_DEPTH_COMPONENT32 +toConstantIF DEPTH_COMPONENT32F = gl_DEPTH_COMPONENT32F +toConstantIF DEPTH_COMPONENT24 = gl_DEPTH_COMPONENT24 +toConstantIF DEPTH_COMPONENT16 = gl_DEPTH_COMPONENT16 +toConstantIF DEPTH32F_STENCIL8 = gl_DEPTH32F_STENCIL8 +toConstantIF DEPTH24_STENCIL8 = gl_DEPTH24_STENCIL8 + +-- | Specification formats. +-- +-- These formats specify the type of the data passed from Haskell to GPU. +data SpecificationType = + FWord8 + | FWord16 + | FWord32 + | FInt8 + | FInt16 + | FInt32 + | FFloat + | FHalfFloat + deriving ( Eq, Ord, Show, Read, Typeable ) + +toConstantST :: SpecificationType -> GLenum +toConstantST FWord8 = gl_UNSIGNED_BYTE +toConstantST FWord16 = gl_UNSIGNED_SHORT +toConstantST FWord32 = gl_UNSIGNED_INT +toConstantST FInt8 = gl_BYTE +toConstantST FInt16 = gl_SHORT +toConstantST FInt32 = gl_INT +toConstantST FFloat = gl_FLOAT +toConstantST FHalfFloat = gl_HALF_FLOAT + +-- TODO: add special interpretation formats to `SpecificationType`. +-- + +-- | Given a specification format, returns the number of bytes one element +-- uses. +sizeOfSpecificationType :: SpecificationType -> Int +sizeOfSpecificationType FWord8 = 1 +sizeOfSpecificationType FWord16 = 2 +sizeOfSpecificationType FWord32 = 2 +sizeOfSpecificationType FInt8 = 1 +sizeOfSpecificationType FInt16 = 2 +sizeOfSpecificationType FInt32 = 4 +sizeOfSpecificationType FFloat = 4 +sizeOfSpecificationType FHalfFloat = 2 + +-- | Class that turns Haskell types into `SpecificationType`. +class SpecificationTypeable a where + -- | Returns the corresponding `SpecificationType` for a Haskell type. + toSpecificationType :: a -- ^ Used to pass the type; not evaluated. + -> SpecificationType + +instance SpecificationTypeable Word8 where + toSpecificationType _ = FWord8 + +instance SpecificationTypeable Word16 where + toSpecificationType _ = FWord16 + +instance SpecificationTypeable Word32 where + toSpecificationType _ = FWord32 + +instance SpecificationTypeable Int8 where + toSpecificationType _ = FInt8 + +instance SpecificationTypeable Int16 where + toSpecificationType _ = FInt16 + +instance SpecificationTypeable Int32 where + toSpecificationType _ = FInt32 + +instance SpecificationTypeable CInt where + toSpecificationType _ = FInt32 + +instance SpecificationTypeable CUInt where + toSpecificationType _ = FWord32 + +instance SpecificationTypeable Float where + toSpecificationType _ = FFloat + +instance SpecificationTypeable CFloat where + toSpecificationType _ = FFloat + + diff --git a/src/Caramia/Internal/ContextLocalData.hs b/src/Caramia/Internal/ContextLocalData.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Internal/ContextLocalData.hs @@ -0,0 +1,121 @@ +{-# LANGUAGE NoImplicitPrelude, ScopedTypeVariables #-} + +module Caramia.Internal.ContextLocalData + ( storeContextLocalData + , retrieveContextLocalData + , currentContextID + , nextContextID + , runningContexts + , contextLocalData + , ContextID ) + where + +import Caramia.Prelude +import qualified Data.IntMap.Strict as IM +import qualified Data.Map.Strict as M +import System.IO.Unsafe +import Data.Dynamic +import Control.Concurrent + +-- | The type of a Caramia context ID. +type ContextID = Int + +-- currently running contexts, map from thread IDs to context IDs +runningContexts :: IORef (M.Map ThreadId ContextID) +runningContexts = unsafePerformIO $ newIORef M.empty +{-# NOINLINE runningContexts #-} + +-- used to give out new unique context IDs +nextContextID :: IORef ContextID +nextContextID = unsafePerformIO $ newIORef 0 +{-# NOINLINE nextContextID #-} + +-- context local data. This is like poor man's thread local storage but for +-- contexts. +-- +-- The `TypeRep` and `Dynamic` lets this module be agnostic to what other +-- modules hang on to thread local data. +-- +-- Other modules can specify a type that there should be only one per context. +-- And this type's TypeRep is stored/queried from the map below. +contextLocalData :: IORef (IM.IntMap (M.Map TypeRep Dynamic)) +contextLocalData = unsafePerformIO $ newIORef IM.empty +{-# NOINLINE contextLocalData #-} + +-- | Returns the current Caramia context ID. +-- +-- The context ID is unique between different calls to `giveContext`. +-- +-- Returns `Nothing` if there is no context active. +currentContextID :: IO (Maybe ContextID) +currentContextID = + M.lookup <$> myThreadId <*> readIORef runningContexts +{-# INLINE currentContextID #-} + +-- | Stores a context local value. +-- +-- The type of the given value is used as a key. This means that if a value of +-- the same type was stored before, that value is thrown away and replaced with +-- this new value you just gave. +-- +-- The value is evaluated to WHNF. +-- +-- You don't need this function to work with context local data. +-- `retrieveContextLocalData` is sufficient as it also lets you set a default +-- value in case a value was not already set. +-- +-- Context local data is wiped to oblivion once `giveContext` ends. +storeContextLocalData :: Typeable a => a -> IO () +storeContextLocalData value = + maybe (error "storeContextLocalData: not in a context.") + (\cid -> + atomicModifyIORef' contextLocalData $ \old -> + ( IM.alter (Just . maybe (M.singleton + (typeOf value) + (toDyn value)) + (M.insert (typeOf value) + (toDyn value))) + cid + old + , () ) ) + =<< currentContextID +{-# INLINE storeContextLocalData #-} + +-- | Retrieves a context local value. +-- +-- See `storeContextLocalData`. +retrieveContextLocalData :: forall a. Typeable a + => IO a -- ^ Default value generating action; not + -- evaluated if there was already a value + -- stored. + -> IO a +retrieveContextLocalData defvalue = + maybe (error "retrieveContextLocalData: not in a context.") + (\cid -> do + -- No need to care about IORef race conditions because all + -- functions operating on a certain context ID will be + -- run in the same thread, sequentially. + snapshot <- readIORef contextLocalData + case IM.lookup cid snapshot of + Nothing -> do + val <- dyndefvalue + atomicModifyIORef' contextLocalData $ \old -> + ( IM.insert cid (M.singleton typ val) old + , fromDyn val undefined ) + Just old_map -> + case M.lookup typ old_map of + Nothing -> do + val <- dyndefvalue + atomicModifyIORef' contextLocalData $ \old -> + ( IM.adjust (M.insert typ val) + cid + old + , fromDyn val undefined ) + Just value -> return (fromDyn value undefined)) + =<< currentContextID + where + typ = typeOf (undefined :: a) + dyndefvalue = toDyn <$> defvalue +{-# INLINEABLE retrieveContextLocalData #-} + + diff --git a/src/Caramia/Internal/FlextGL.hs b/src/Caramia/Internal/FlextGL.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Internal/FlextGL.hs @@ -0,0 +1,28572 @@ +{-# LANGUAGE CPP, ForeignFunctionInterface, EmptyDataDecls #-} +#ifdef __GLASGOW_HASKELL__ +{-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-} +#endif +-- WARNING: This file was automatically generated +-- Do not edit. + + + +module Caramia.Internal.FlextGL + ( flextInit + , FlextInitResult(..) + , has_GL_ARB_texture_storage + , has_GL_KHR_debug + , has_GL_EXT_direct_state_access + , has_GL_ARB_buffer_storage + , has_GL_ARB_separate_shader_objects + , has_GL_ATI_meminfo + , has_GL_NVX_gpu_memory_info + , has_GL_ARB_invalidate_subdata + , glCullFace + , glFrontFace + , glHint + , glLineWidth + , glPointSize + , glPolygonMode + , glScissor + , glTexParameterf + , glTexParameterfv + , glTexParameteri + , glTexParameteriv + , glTexImage1D + , glTexImage2D + , glDrawBuffer + , glClear + , glClearColor + , glClearStencil + , glClearDepth + , glStencilMask + , glColorMask + , glDepthMask + , glDisable + , glEnable + , glFinish + , glFlush + , glBlendFunc + , glLogicOp + , glStencilFunc + , glStencilOp + , glDepthFunc + , glPixelStoref + , glPixelStorei + , glReadBuffer + , glReadPixels + , glGetBooleanv + , glGetDoublev + , glGetError + , glGetFloatv + , glGetIntegerv + , glGetString + , glGetTexImage + , glGetTexParameterfv + , glGetTexParameteriv + , glGetTexLevelParameterfv + , glGetTexLevelParameteriv + , glIsEnabled + , glDepthRange + , glViewport + , glDrawArrays + , glDrawElements + , glPolygonOffset + , glCopyTexImage1D + , glCopyTexImage2D + , glCopyTexSubImage1D + , glCopyTexSubImage2D + , glTexSubImage1D + , glTexSubImage2D + , glBindTexture + , glDeleteTextures + , glGenTextures + , glIsTexture + , glDrawRangeElements + , glTexImage3D + , glTexSubImage3D + , glCopyTexSubImage3D + , glActiveTexture + , glSampleCoverage + , glCompressedTexImage3D + , glCompressedTexImage2D + , glCompressedTexImage1D + , glCompressedTexSubImage3D + , glCompressedTexSubImage2D + , glCompressedTexSubImage1D + , glGetCompressedTexImage + , glBlendFuncSeparate + , glMultiDrawArrays + , glMultiDrawElements + , glPointParameterf + , glPointParameterfv + , glPointParameteri + , glPointParameteriv + , glBlendColor + , glBlendEquation + , glGenQueries + , glDeleteQueries + , glIsQuery + , glBeginQuery + , glEndQuery + , glGetQueryiv + , glGetQueryObjectiv + , glGetQueryObjectuiv + , glBindBuffer + , glDeleteBuffers + , glGenBuffers + , glIsBuffer + , glBufferData + , glBufferSubData + , glGetBufferSubData + , glMapBuffer + , glUnmapBuffer + , glGetBufferParameteriv + , glGetBufferPointerv + , glBlendEquationSeparate + , glDrawBuffers + , glStencilOpSeparate + , glStencilFuncSeparate + , glStencilMaskSeparate + , glAttachShader + , glBindAttribLocation + , glCompileShader + , glCreateProgram + , glCreateShader + , glDeleteProgram + , glDeleteShader + , glDetachShader + , glDisableVertexAttribArray + , glEnableVertexAttribArray + , glGetActiveAttrib + , glGetActiveUniform + , glGetAttachedShaders + , glGetAttribLocation + , glGetProgramiv + , glGetProgramInfoLog + , glGetShaderiv + , glGetShaderInfoLog + , glGetShaderSource + , glGetUniformLocation + , glGetUniformfv + , glGetUniformiv + , glGetVertexAttribdv + , glGetVertexAttribfv + , glGetVertexAttribiv + , glGetVertexAttribPointerv + , glIsProgram + , glIsShader + , glLinkProgram + , glShaderSource + , glUseProgram + , glUniform1f + , glUniform2f + , glUniform3f + , glUniform4f + , glUniform1i + , glUniform2i + , glUniform3i + , glUniform4i + , glUniform1fv + , glUniform2fv + , glUniform3fv + , glUniform4fv + , glUniform1iv + , glUniform2iv + , glUniform3iv + , glUniform4iv + , glUniformMatrix2fv + , glUniformMatrix3fv + , glUniformMatrix4fv + , 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 + , glVertexAttribPointer + , glUniformMatrix2x3fv + , glUniformMatrix3x2fv + , glUniformMatrix2x4fv + , glUniformMatrix4x2fv + , glUniformMatrix3x4fv + , glUniformMatrix4x3fv + , glColorMaski + , glGetBooleani_v + , glGetIntegeri_v + , glEnablei + , glDisablei + , glIsEnabledi + , glBeginTransformFeedback + , glEndTransformFeedback + , glBindBufferRange + , glBindBufferBase + , glTransformFeedbackVaryings + , glGetTransformFeedbackVarying + , glClampColor + , glBeginConditionalRender + , glEndConditionalRender + , glVertexAttribIPointer + , glGetVertexAttribIiv + , glGetVertexAttribIuiv + , glVertexAttribI1i + , glVertexAttribI2i + , glVertexAttribI3i + , glVertexAttribI4i + , glVertexAttribI1ui + , glVertexAttribI2ui + , glVertexAttribI3ui + , glVertexAttribI4ui + , glVertexAttribI1iv + , glVertexAttribI2iv + , glVertexAttribI3iv + , glVertexAttribI4iv + , glVertexAttribI1uiv + , glVertexAttribI2uiv + , glVertexAttribI3uiv + , glVertexAttribI4uiv + , glVertexAttribI4bv + , glVertexAttribI4sv + , glVertexAttribI4ubv + , glVertexAttribI4usv + , glGetUniformuiv + , glBindFragDataLocation + , glGetFragDataLocation + , glUniform1ui + , glUniform2ui + , glUniform3ui + , glUniform4ui + , glUniform1uiv + , glUniform2uiv + , glUniform3uiv + , glUniform4uiv + , glTexParameterIiv + , glTexParameterIuiv + , glGetTexParameterIiv + , glGetTexParameterIuiv + , glClearBufferiv + , glClearBufferuiv + , glClearBufferfv + , glClearBufferfi + , glGetStringi + , glIsRenderbuffer + , glBindRenderbuffer + , glDeleteRenderbuffers + , glGenRenderbuffers + , glRenderbufferStorage + , glGetRenderbufferParameteriv + , glIsFramebuffer + , glBindFramebuffer + , glDeleteFramebuffers + , glGenFramebuffers + , glCheckFramebufferStatus + , glFramebufferTexture1D + , glFramebufferTexture2D + , glFramebufferTexture3D + , glFramebufferRenderbuffer + , glGetFramebufferAttachmentParameteriv + , glGenerateMipmap + , glBlitFramebuffer + , glRenderbufferStorageMultisample + , glFramebufferTextureLayer + , glMapBufferRange + , glFlushMappedBufferRange + , glBindVertexArray + , glDeleteVertexArrays + , glGenVertexArrays + , glIsVertexArray + , glDrawArraysInstanced + , glDrawElementsInstanced + , glTexBuffer + , glPrimitiveRestartIndex + , glCopyBufferSubData + , glGetUniformIndices + , glGetActiveUniformsiv + , glGetActiveUniformName + , glGetUniformBlockIndex + , glGetActiveUniformBlockiv + , glGetActiveUniformBlockName + , glUniformBlockBinding + , glDrawElementsBaseVertex + , glDrawRangeElementsBaseVertex + , glDrawElementsInstancedBaseVertex + , glMultiDrawElementsBaseVertex + , glProvokingVertex + , glFenceSync + , glIsSync + , glDeleteSync + , glClientWaitSync + , glWaitSync + , glGetInteger64v + , glGetSynciv + , glGetInteger64i_v + , glGetBufferParameteri64v + , glFramebufferTexture + , glTexImage2DMultisample + , glTexImage3DMultisample + , glGetMultisamplefv + , glSampleMaski + , glBindFragDataLocationIndexed + , glGetFragDataIndex + , glGenSamplers + , glDeleteSamplers + , glIsSampler + , glBindSampler + , glSamplerParameteri + , glSamplerParameteriv + , glSamplerParameterf + , glSamplerParameterfv + , glSamplerParameterIiv + , glSamplerParameterIuiv + , glGetSamplerParameteriv + , glGetSamplerParameterIiv + , glGetSamplerParameterfv + , glGetSamplerParameterIuiv + , glQueryCounter + , glGetQueryObjecti64v + , glGetQueryObjectui64v + , glVertexAttribDivisor + , glVertexAttribP1ui + , glVertexAttribP1uiv + , glVertexAttribP2ui + , glVertexAttribP2uiv + , glVertexAttribP3ui + , glVertexAttribP3uiv + , glVertexAttribP4ui + , glVertexAttribP4uiv + , glTexStorage1D + , glTexStorage2D + , glTexStorage3D + , glDebugMessageControl + , glDebugMessageInsert + , glDebugMessageCallback + , glGetDebugMessageLog + , glPushDebugGroup + , glPopDebugGroup + , glObjectLabel + , glGetObjectLabel + , glObjectPtrLabel + , glGetObjectPtrLabel + , glGetPointerv + , glDebugMessageControlKHR + , glDebugMessageInsertKHR + , glDebugMessageCallbackKHR + , glGetDebugMessageLogKHR + , glPushDebugGroupKHR + , glPopDebugGroupKHR + , glObjectLabelKHR + , glGetObjectLabelKHR + , glObjectPtrLabelKHR + , glGetObjectPtrLabelKHR + , glGetPointervKHR + , glMatrixLoadfEXT + , glMatrixLoaddEXT + , glMatrixMultfEXT + , glMatrixMultdEXT + , glMatrixLoadIdentityEXT + , glMatrixRotatefEXT + , glMatrixRotatedEXT + , glMatrixScalefEXT + , glMatrixScaledEXT + , glMatrixTranslatefEXT + , glMatrixTranslatedEXT + , glMatrixFrustumEXT + , glMatrixOrthoEXT + , glMatrixPopEXT + , glMatrixPushEXT + , glClientAttribDefaultEXT + , glPushClientAttribDefaultEXT + , glTextureParameterfEXT + , glTextureParameterfvEXT + , glTextureParameteriEXT + , glTextureParameterivEXT + , glTextureImage1DEXT + , glTextureImage2DEXT + , glTextureSubImage1DEXT + , glTextureSubImage2DEXT + , glCopyTextureImage1DEXT + , glCopyTextureImage2DEXT + , glCopyTextureSubImage1DEXT + , glCopyTextureSubImage2DEXT + , glGetTextureImageEXT + , glGetTextureParameterfvEXT + , glGetTextureParameterivEXT + , glGetTextureLevelParameterfvEXT + , glGetTextureLevelParameterivEXT + , glTextureImage3DEXT + , glTextureSubImage3DEXT + , glCopyTextureSubImage3DEXT + , glBindMultiTextureEXT + , glMultiTexCoordPointerEXT + , glMultiTexEnvfEXT + , glMultiTexEnvfvEXT + , glMultiTexEnviEXT + , glMultiTexEnvivEXT + , glMultiTexGendEXT + , glMultiTexGendvEXT + , glMultiTexGenfEXT + , glMultiTexGenfvEXT + , glMultiTexGeniEXT + , glMultiTexGenivEXT + , glGetMultiTexEnvfvEXT + , glGetMultiTexEnvivEXT + , glGetMultiTexGendvEXT + , glGetMultiTexGenfvEXT + , glGetMultiTexGenivEXT + , glMultiTexParameteriEXT + , glMultiTexParameterivEXT + , glMultiTexParameterfEXT + , glMultiTexParameterfvEXT + , glMultiTexImage1DEXT + , glMultiTexImage2DEXT + , glMultiTexSubImage1DEXT + , glMultiTexSubImage2DEXT + , glCopyMultiTexImage1DEXT + , glCopyMultiTexImage2DEXT + , glCopyMultiTexSubImage1DEXT + , glCopyMultiTexSubImage2DEXT + , glGetMultiTexImageEXT + , glGetMultiTexParameterfvEXT + , glGetMultiTexParameterivEXT + , glGetMultiTexLevelParameterfvEXT + , glGetMultiTexLevelParameterivEXT + , glMultiTexImage3DEXT + , glMultiTexSubImage3DEXT + , glCopyMultiTexSubImage3DEXT + , glEnableClientStateIndexedEXT + , glDisableClientStateIndexedEXT + , glGetFloatIndexedvEXT + , glGetDoubleIndexedvEXT + , glGetPointerIndexedvEXT + , glEnableIndexedEXT + , glDisableIndexedEXT + , glIsEnabledIndexedEXT + , glGetIntegerIndexedvEXT + , glGetBooleanIndexedvEXT + , glCompressedTextureImage3DEXT + , glCompressedTextureImage2DEXT + , glCompressedTextureImage1DEXT + , glCompressedTextureSubImage3DEXT + , glCompressedTextureSubImage2DEXT + , glCompressedTextureSubImage1DEXT + , glGetCompressedTextureImageEXT + , glCompressedMultiTexImage3DEXT + , glCompressedMultiTexImage2DEXT + , glCompressedMultiTexImage1DEXT + , glCompressedMultiTexSubImage3DEXT + , glCompressedMultiTexSubImage2DEXT + , glCompressedMultiTexSubImage1DEXT + , glGetCompressedMultiTexImageEXT + , glMatrixLoadTransposefEXT + , glMatrixLoadTransposedEXT + , glMatrixMultTransposefEXT + , glMatrixMultTransposedEXT + , glNamedBufferDataEXT + , glNamedBufferSubDataEXT + , glMapNamedBufferEXT + , glUnmapNamedBufferEXT + , glGetNamedBufferParameterivEXT + , glGetNamedBufferPointervEXT + , glGetNamedBufferSubDataEXT + , glProgramUniform1fEXT + , glProgramUniform2fEXT + , glProgramUniform3fEXT + , glProgramUniform4fEXT + , glProgramUniform1iEXT + , glProgramUniform2iEXT + , glProgramUniform3iEXT + , glProgramUniform4iEXT + , glProgramUniform1fvEXT + , glProgramUniform2fvEXT + , glProgramUniform3fvEXT + , glProgramUniform4fvEXT + , glProgramUniform1ivEXT + , glProgramUniform2ivEXT + , glProgramUniform3ivEXT + , glProgramUniform4ivEXT + , glProgramUniformMatrix2fvEXT + , glProgramUniformMatrix3fvEXT + , glProgramUniformMatrix4fvEXT + , glProgramUniformMatrix2x3fvEXT + , glProgramUniformMatrix3x2fvEXT + , glProgramUniformMatrix2x4fvEXT + , glProgramUniformMatrix4x2fvEXT + , glProgramUniformMatrix3x4fvEXT + , glProgramUniformMatrix4x3fvEXT + , glTextureBufferEXT + , glMultiTexBufferEXT + , glTextureParameterIivEXT + , glTextureParameterIuivEXT + , glGetTextureParameterIivEXT + , glGetTextureParameterIuivEXT + , glMultiTexParameterIivEXT + , glMultiTexParameterIuivEXT + , glGetMultiTexParameterIivEXT + , glGetMultiTexParameterIuivEXT + , glProgramUniform1uiEXT + , glProgramUniform2uiEXT + , glProgramUniform3uiEXT + , glProgramUniform4uiEXT + , glProgramUniform1uivEXT + , glProgramUniform2uivEXT + , glProgramUniform3uivEXT + , glProgramUniform4uivEXT + , glNamedProgramLocalParameters4fvEXT + , glNamedProgramLocalParameterI4iEXT + , glNamedProgramLocalParameterI4ivEXT + , glNamedProgramLocalParametersI4ivEXT + , glNamedProgramLocalParameterI4uiEXT + , glNamedProgramLocalParameterI4uivEXT + , glNamedProgramLocalParametersI4uivEXT + , glGetNamedProgramLocalParameterIivEXT + , glGetNamedProgramLocalParameterIuivEXT + , glEnableClientStateiEXT + , glDisableClientStateiEXT + , glGetFloati_vEXT + , glGetDoublei_vEXT + , glGetPointeri_vEXT + , glNamedProgramStringEXT + , glNamedProgramLocalParameter4dEXT + , glNamedProgramLocalParameter4dvEXT + , glNamedProgramLocalParameter4fEXT + , glNamedProgramLocalParameter4fvEXT + , glGetNamedProgramLocalParameterdvEXT + , glGetNamedProgramLocalParameterfvEXT + , glGetNamedProgramivEXT + , glGetNamedProgramStringEXT + , glNamedRenderbufferStorageEXT + , glGetNamedRenderbufferParameterivEXT + , glNamedRenderbufferStorageMultisampleEXT + , glNamedRenderbufferStorageMultisampleCoverageEXT + , glCheckNamedFramebufferStatusEXT + , glNamedFramebufferTexture1DEXT + , glNamedFramebufferTexture2DEXT + , glNamedFramebufferTexture3DEXT + , glNamedFramebufferRenderbufferEXT + , glGetNamedFramebufferAttachmentParameterivEXT + , glGenerateTextureMipmapEXT + , glGenerateMultiTexMipmapEXT + , glFramebufferDrawBufferEXT + , glFramebufferDrawBuffersEXT + , glFramebufferReadBufferEXT + , glGetFramebufferParameterivEXT + , glNamedCopyBufferSubDataEXT + , glNamedFramebufferTextureEXT + , glNamedFramebufferTextureLayerEXT + , glNamedFramebufferTextureFaceEXT + , glTextureRenderbufferEXT + , glMultiTexRenderbufferEXT + , glVertexArrayVertexOffsetEXT + , glVertexArrayColorOffsetEXT + , glVertexArrayEdgeFlagOffsetEXT + , glVertexArrayIndexOffsetEXT + , glVertexArrayNormalOffsetEXT + , glVertexArrayTexCoordOffsetEXT + , glVertexArrayMultiTexCoordOffsetEXT + , glVertexArrayFogCoordOffsetEXT + , glVertexArraySecondaryColorOffsetEXT + , glVertexArrayVertexAttribOffsetEXT + , glVertexArrayVertexAttribIOffsetEXT + , glEnableVertexArrayEXT + , glDisableVertexArrayEXT + , glEnableVertexArrayAttribEXT + , glDisableVertexArrayAttribEXT + , glGetVertexArrayIntegervEXT + , glGetVertexArrayPointervEXT + , glGetVertexArrayIntegeri_vEXT + , glGetVertexArrayPointeri_vEXT + , glMapNamedBufferRangeEXT + , glFlushMappedNamedBufferRangeEXT + , glNamedBufferStorageEXT + , glClearNamedBufferDataEXT + , glClearNamedBufferSubDataEXT + , glNamedFramebufferParameteriEXT + , glGetNamedFramebufferParameterivEXT + , glProgramUniform1dEXT + , glProgramUniform2dEXT + , glProgramUniform3dEXT + , glProgramUniform4dEXT + , glProgramUniform1dvEXT + , glProgramUniform2dvEXT + , glProgramUniform3dvEXT + , glProgramUniform4dvEXT + , glProgramUniformMatrix2dvEXT + , glProgramUniformMatrix3dvEXT + , glProgramUniformMatrix4dvEXT + , glProgramUniformMatrix2x3dvEXT + , glProgramUniformMatrix2x4dvEXT + , glProgramUniformMatrix3x2dvEXT + , glProgramUniformMatrix3x4dvEXT + , glProgramUniformMatrix4x2dvEXT + , glProgramUniformMatrix4x3dvEXT + , glTextureBufferRangeEXT + , glTextureStorage1DEXT + , glTextureStorage2DEXT + , glTextureStorage3DEXT + , glTextureStorage2DMultisampleEXT + , glTextureStorage3DMultisampleEXT + , glVertexArrayBindVertexBufferEXT + , glVertexArrayVertexAttribFormatEXT + , glVertexArrayVertexAttribIFormatEXT + , glVertexArrayVertexAttribLFormatEXT + , glVertexArrayVertexAttribBindingEXT + , glVertexArrayVertexBindingDivisorEXT + , glVertexArrayVertexAttribLOffsetEXT + , glTexturePageCommitmentEXT + , glVertexArrayVertexAttribDivisorEXT + , glBufferStorage + , glUseProgramStages + , glActiveShaderProgram + , glCreateShaderProgramv + , glBindProgramPipeline + , glDeleteProgramPipelines + , glGenProgramPipelines + , glIsProgramPipeline + , glGetProgramPipelineiv + , glProgramUniform1i + , glProgramUniform1iv + , glProgramUniform1f + , glProgramUniform1fv + , glProgramUniform1d + , glProgramUniform1dv + , glProgramUniform1ui + , glProgramUniform1uiv + , glProgramUniform2i + , glProgramUniform2iv + , glProgramUniform2f + , glProgramUniform2fv + , glProgramUniform2d + , glProgramUniform2dv + , glProgramUniform2ui + , glProgramUniform2uiv + , glProgramUniform3i + , glProgramUniform3iv + , glProgramUniform3f + , glProgramUniform3fv + , glProgramUniform3d + , glProgramUniform3dv + , glProgramUniform3ui + , glProgramUniform3uiv + , glProgramUniform4i + , glProgramUniform4iv + , glProgramUniform4f + , glProgramUniform4fv + , glProgramUniform4d + , glProgramUniform4dv + , glProgramUniform4ui + , glProgramUniform4uiv + , glProgramUniformMatrix2fv + , glProgramUniformMatrix3fv + , glProgramUniformMatrix4fv + , glProgramUniformMatrix2dv + , glProgramUniformMatrix3dv + , glProgramUniformMatrix4dv + , glProgramUniformMatrix2x3fv + , glProgramUniformMatrix3x2fv + , glProgramUniformMatrix2x4fv + , glProgramUniformMatrix4x2fv + , glProgramUniformMatrix3x4fv + , glProgramUniformMatrix4x3fv + , glProgramUniformMatrix2x3dv + , glProgramUniformMatrix3x2dv + , glProgramUniformMatrix2x4dv + , glProgramUniformMatrix4x2dv + , glProgramUniformMatrix3x4dv + , glProgramUniformMatrix4x3dv + , glValidateProgramPipeline + , glGetProgramPipelineInfoLog + , glInvalidateTexSubImage + , glInvalidateTexImage + , glInvalidateBufferSubData + , glInvalidateBufferData + , glInvalidateFramebuffer + , glInvalidateSubFramebuffer + , gl_UNSIGNED_INT_10_10_10_2_EXT + , gl_ACTIVE_RESOURCES + , gl_MAX_GEOMETRY_SHADER_INVOCATIONS + , gl_RESTART_PATH_NV + , gl_MAX_DEEP_3D_TEXTURE_DEPTH_NV + , gl_PACK_SKIP_IMAGES + , gl_IMAGE_CLASS_2_X_16 + , gl_FRAMEBUFFER_COMPLETE + , gl_HSL_LUMINOSITY_NV + , gl_IMAGE_BINDING_LAYERED_EXT + , gl_ZOOM_Y + , gl_TEXTURE_LUMINANCE_TYPE_ARB + , gl_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB + , gl_TEXTURE_HEIGHT + , gl_OUTPUT_TEXTURE_COORD0_EXT + , gl_FLOAT_CLEAR_COLOR_VALUE_NV + , gl_LIGHT_MODEL_AMBIENT + , gl_INT16_VEC3_NV + , gl_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV + , gl_MATRIX6_NV + , gl_COMPUTE_PROGRAM_NV + , gl_SCALED_RESOLVE_FASTEST_EXT + , gl_REPLACEMENT_CODE_ARRAY_SUN + , gl_TEXTURE_DT_SIZE_NV + , gl_NUM_SPARSE_LEVELS_ARB + , gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR + , gl_NO_ERROR + , gl_INTERNALFORMAT_ALPHA_TYPE + , gl_FONT_HEIGHT_BIT_NV + , gl_TANGENT_ARRAY_POINTER_EXT + , gl_LOCAL_CONSTANT_VALUE_EXT + , gl_READ_WRITE + , gl_TEXTURE_2D + , gl_UNSIGNED_INT_2_10_10_10_REV_EXT + , gl_TEXTURE_WRAP_R + , gl_FLOAT_MAT4x2 + , gl_MAX_COMPUTE_WORK_GROUP_SIZE + , gl_POLYGON_OFFSET_CLAMP_EXT + , gl_SYNC_FLUSH_COMMANDS_BIT + , gl_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB + , gl_INT_IMAGE_BUFFER + , gl_VERTEX_ATTRIB_ARRAY_TYPE + , gl_ONE + , gl_COLOR_CLEAR_UNCLAMPED_VALUE_ATI + , gl_TRANSLATE_X_NV + , gl_HI_SCALE_NV + , gl_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT + , gl_HILO_NV + , gl_TRIANGLES + , gl_LINEARLIGHT_NV + , gl_MAX_3D_TEXTURE_SIZE_OES + , gl_ANY_SAMPLES_PASSED_CONSERVATIVE + , gl_UNIFORM_BLOCK_BINDING + , gl_MAX_TESS_CONTROL_INPUT_COMPONENTS + , gl_TEXTURE_ALPHA_TYPE_ARB + , gl_MAX_CONVOLUTION_HEIGHT + , gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS + , gl_DEPTH_BUFFER_BIT5_QCOM + , gl_PROGRAM_TEX_INDIRECTIONS_ARB + , gl_BLUE + , gl_RGBA_S3TC + , gl_DECR + , gl_MAJOR_VERSION + , gl_ARRAY_STRIDE + , gl_CONSTANT_COLOR1_NV + , gl_SAMPLES_EXT + , gl_MAX_SAMPLES_APPLE + , gl_COLOR_ARRAY_SIZE + , gl_SAMPLE_ALPHA_TO_MASK_SGIS + , gl_DUP_LAST_CUBIC_CURVE_TO_NV + , gl_TEXTURE10 + , gl_R1UI_T2F_C4F_N3F_V3F_SUN + , gl_MAX_VARYING_COMPONENTS + , gl_DRAW_BUFFER7_EXT + , gl_MAX_COMBINED_ATOMIC_COUNTERS + , gl_PROGRAM_ERROR_STRING_ARB + , gl_TRACE_ALL_BITS_MESA + , gl_DEPTH_CLAMP_NV + , gl_REDUCE + , gl_UNSIGNED_SHORT_4_4_4_4 + , gl_SKIP_COMPONENTS1_NV + , gl_PIXEL_TILE_CACHE_INCREMENT_SGIX + , gl_COLOR_ARRAY + , gl_STATIC_VERTEX_ARRAY_IBM + , gl_INDEX_BIT_PGI + , gl_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT + , gl_ETC1_SRGB8_NV + , gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS + , gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT + , gl_LIGHT_MODEL_COLOR_CONTROL_EXT + , gl_PATCH_DEFAULT_OUTER_LEVEL_EXT + , gl_SAMPLER_CUBE_ARB + , gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT + , gl_STORAGE_PRIVATE_APPLE + , gl_MAP1_TEXTURE_COORD_2 + , gl_REPLACEMENT_CODE_ARRAY_STRIDE_SUN + , gl_VERTEX_ATTRIB_ARRAY8_NV + , gl_LUMINANCE16F_ARB + , gl_DEPTH_COMPONENT32F_NV + , gl_MAX_VERTEX_BINDABLE_UNIFORMS_EXT + , gl_MATRIX28_ARB + , gl_SYNC_FLUSH_COMMANDS_BIT_APPLE + , gl_READ_FRAMEBUFFER_BINDING_ANGLE + , gl_FOG_COORDINATE_ARRAY_TYPE + , gl_RGBA32UI_EXT + , gl_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG + , gl_2_BYTES_NV + , gl_TEXTURE_HI_SIZE_NV + , gl_PACK_SWAP_BYTES + , gl_EVAL_FRACTIONAL_TESSELLATION_NV + , gl_RG16 + , gl_SWIZZLE_STR_ATI + , gl_CON_6_ATI + , gl_PATH_FOG_GEN_MODE_NV + , gl_SRGB8_ALPHA8_EXT + , gl_COMPRESSED_SLUMINANCE_ALPHA_EXT + , gl_TEXTURE_COMPARE_FUNC_EXT + , gl_UNIFORM_MATRIX_STRIDE + , gl_INVALID_OPERATION + , gl_DRAW_BUFFER4_ATI + , gl_BYTE + , gl_SECONDARY_COLOR_ARRAY_POINTER + , gl_TEXTURE_CUBE_MAP_POSITIVE_X + , gl_TEXTURE_2D_ARRAY + , gl_OFFSET_TEXTURE_MATRIX_NV + , gl_FLOAT_MAT2x4 + , gl_REG_31_ATI + , gl_DEBUG_TYPE_PORTABILITY + , gl_SAMPLER_2D_ARB + , gl_DRAW_BUFFER11 + , gl_MAX_COMPUTE_WORK_GROUP_INVOCATIONS + , gl_TEXTURE5_ARB + , gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT + , gl_COLOR_TABLE_SCALE + , gl_POINT_FADE_THRESHOLD_SIZE_SGIS + , gl_MAX_SPARSE_3D_TEXTURE_SIZE_ARB + , gl_ACCUM_CLEAR_VALUE + , gl_OPERAND0_ALPHA_EXT + , gl_QUERY_NO_WAIT + , gl_PRIMITIVE_RESTART + , gl_STENCIL_ATTACHMENT_OES + , gl_BUFFER_USAGE + , gl_COLOR_TABLE_BLUE_SIZE + , gl_VERTEX_ARRAY_SIZE_EXT + , gl_ALPHA8 + , gl_PROXY_TEXTURE_2D + , gl_HALF_BIT_ATI + , gl_TRANSPOSE_MODELVIEW_MATRIX + , gl_DRAW_BUFFER3 + , gl_4PASS_2_SGIS + , gl_MAX_GEOMETRY_OUTPUT_COMPONENTS + , gl_SAMPLER_2D_ARRAY_SHADOW_EXT + , gl_TEXTURE_FORMAT_QCOM + , gl_RGB16_SNORM + , gl_DRAW_BUFFER8_NV + , gl_AUX_BUFFERS + , gl_CONVOLUTION_HINT_SGIX + , gl_FOG_COLOR + , gl_COLOR_TABLE_RED_SIZE_SGI + , gl_FUNC_SUBTRACT_OES + , gl_LUMINANCE_ALPHA16F_ARB + , gl_MODELVIEW10_ARB + , gl_LOGIC_OP + , gl_PROGRAM_NATIVE_INSTRUCTIONS_ARB + , gl_SOURCE0_ALPHA_EXT + , gl_INDEX_SHIFT + , gl_PIXEL_FRAGMENT_RGB_SOURCE_SGIS + , gl_RG32F_EXT + , gl_GEOMETRY_LINKED_VERTICES_OUT_EXT + , gl_STACK_UNDERFLOW_KHR + , gl_TESS_GEN_POINT_MODE_EXT + , gl_BUFFER_ACCESS_ARB + , gl_DOT_PRODUCT_NV + , gl_INVERTED_SCREEN_W_REND + , gl_REG_11_ATI + , gl_MAX_FRAMEZOOM_FACTOR_SGIX + , gl_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD + , gl_MATRIX20_ARB + , gl_EVAL_VERTEX_ATTRIB1_NV + , gl_COLOR_ATTACHMENT10_NV + , gl_OUTPUT_TEXTURE_COORD28_EXT + , gl_MAX_TEXTURE_COORDS_ARB + , gl_COLOR_ARRAY_PARALLEL_POINTERS_INTEL + , gl_MAX_COMBINED_SHADER_OUTPUT_RESOURCES + , gl_RENDERBUFFER_BLUE_SIZE + , gl_MULTISAMPLE_BIT + , gl_CURRENT_PROGRAM + , gl_AUX_DEPTH_STENCIL_APPLE + , gl_LUMINANCE8_ALPHA8_EXT + , gl_VIDEO_CAPTURE_SURFACE_ORIGIN_NV + , gl_INTERLACE_OML + , gl_REG_27_ATI + , gl_UNSIGNED_INT_24_8_OES + , gl_COMBINER_AB_OUTPUT_NV + , gl_CURRENT_RASTER_INDEX + , gl_SYNC_FENCE_APPLE + , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT + , gl_MAX_TEXTURE_SIZE + , gl_TEXTURE24 + , gl_STENCIL_BACK_FUNC + , gl_LUMINANCE12 + , gl_PARAMETER_BUFFER_ARB + , gl_AUX2 + , gl_SLICE_ACCUM_SUN + , gl_COLOR_TABLE_ALPHA_SIZE + , gl_TEXTURE_CUBE_MAP_POSITIVE_X_EXT + , gl_DRAW_FRAMEBUFFER_BINDING_ANGLE + , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER + , gl_SUBTRACT + , gl_MAX_PROGRAM_IF_DEPTH_NV + , gl_T2F_C4F_N3F_V3F + , gl_ACTIVE_SUBROUTINE_UNIFORMS + , gl_EMBOSS_LIGHT_NV + , gl_POINT_SIZE_RANGE + , gl_GEOMETRY_LINKED_OUTPUT_TYPE_EXT + , gl_CLAMP_TO_BORDER + , gl_TEXTURE_BUFFER_OFFSET_EXT + , gl_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV + , gl_COMPRESSED_INTENSITY + , gl_MAX_PROGRAM_OUTPUT_VERTICES_NV + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES + , gl_MAX_PROGRAM_ATTRIBS_ARB + , gl_POST_COLOR_MATRIX_GREEN_SCALE_SGI + , gl_TEXTURE_3D_BINDING_EXT + , gl_SHADER_STORAGE_BUFFER_START + , gl_MAP2_INDEX + , gl_CONSTANT_COLOR_EXT + , gl_RG32UI + , gl_BGRA + , gl_FRAGMENT_DEPTH_EXT + , gl_GENERATE_MIPMAP_HINT_SGIS + , gl_DIFFERENCE_NV + , gl_UNSIGNED_SHORT_1_15_REV_MESA + , gl_PROGRAM_BINARY_RETRIEVABLE_HINT + , gl_RGBA32I + , gl_UNSIGNED_INT_8_8_8_8 + , gl_DOMAIN + , gl_COLOR_MATRIX + , gl_PROGRAM_NATIVE_ATTRIBS_ARB + , gl_OP_ROUND_EXT + , gl_VIEW_CLASS_96_BITS + , gl_TEXTURE_WRAP_R_OES + , gl_VERTEX_ARRAY_TYPE + , gl_VIDEO_BUFFER_INTERNAL_FORMAT_NV + , gl_PIXEL_MAP_R_TO_R_SIZE + , gl_UNSIGNED_NORMALIZED_ARB + , gl_UNSIGNED_INT8_VEC3_NV + , gl_COMPRESSED_RGBA8_ETC2_EAC_OES + , gl_HI_BIAS_NV + , gl_SECONDARY_COLOR_ARRAY_EXT + , gl_BUFFER_MAP_OFFSET + , gl_LUMINANCE4_ALPHA4_OES + , gl_FORMAT_SUBSAMPLE_244_244_OML + , gl_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA + , gl_PLUS_CLAMPED_ALPHA_NV + , gl_COLOR_ATTACHMENT0_NV + , gl_COMPRESSED_RGB_S3TC_DXT1_EXT + , gl_GEOMETRY_OUTPUT_TYPE + , gl_INTENSITY8_EXT + , gl_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT + , gl_COMPRESSED_RED_GREEN_RGTC2_EXT + , gl_DEBUG_SOURCE_API_KHR + , gl_BLEND_PREMULTIPLIED_SRC_NV + , gl_CLIENT_STORAGE_BIT + , gl_INTENSITY12_EXT + , gl_MATRIX_INDEX_ARRAY_STRIDE_OES + , gl_CURRENT_RASTER_SECONDARY_COLOR + , gl_REPLACE + , gl_LINEAR + , gl_COMBINER_INPUT_NV + , gl_TRANSFORM_FEEDBACK_VARYINGS + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES + , gl_IMAGE_BINDING_ACCESS + , gl_NUM_LOOPBACK_COMPONENTS_ATI + , gl_ARRAY_ELEMENT_LOCK_COUNT_EXT + , gl_REPLACEMENT_CODE_ARRAY_POINTER_SUN + , gl_TEXTURE_4DSIZE_SGIS + , gl_COUNTER_RANGE_AMD + , gl_RGB8_OES + , gl_ALPHA16F_EXT + , gl_C4F_N3F_V3F + , gl_NEAREST_MIPMAP_LINEAR + , gl_DEBUG_SEVERITY_LOW_KHR + , gl_DISCARD_ATI + , gl_LOCAL_CONSTANT_DATATYPE_EXT + , gl_MAX_GEOMETRY_INPUT_COMPONENTS_EXT + , gl_LOWER_LEFT + , gl_RENDERBUFFER_HEIGHT_OES + , gl_SPRITE_MODE_SGIX + , gl_REPLACEMENT_CODE_ARRAY_TYPE_SUN + , gl_UNSIGNED_INT8_VEC2_NV + , gl_NONE_OES + , gl_POINT_SIZE_MIN_ARB + , gl_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV + , gl_RENDERBUFFER_DEPTH_SIZE_EXT + , gl_BUFFER_MAP_LENGTH + , gl_WRITE_ONLY + , gl_NEAREST_CLIPMAP_NEAREST_SGIX + , gl_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV + , gl_ALREADY_SIGNALED_APPLE + , gl_REPLICATE_BORDER + , gl_SUBPIXEL_BITS + , gl_ALPHA_MIN_SGIX + , gl_BLUE_BIT_ATI + , gl_UNSIGNED_INT_IMAGE_2D_EXT + , gl_TRANSFORM_FEEDBACK_VARYINGS_EXT + , gl_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT + , gl_PIXEL_COUNTER_BITS_NV + , gl_422_REV_AVERAGE_EXT + , gl_TEXTURE_RESIDENT_EXT + , gl_STENCIL_WRITEMASK + , gl_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES + , gl_FLOAT_VEC3_ARB + , gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM + , gl_DYNAMIC_STORAGE_BIT + , gl_DRAW_FRAMEBUFFER_BINDING_APPLE + , gl_CLIP_PLANE4_IMG + , gl_CON_26_ATI + , gl_COMPRESSED_SIGNED_R11_EAC_OES + , gl_LINES_ADJACENCY_EXT + , gl_AUTO_GENERATE_MIPMAP + , gl_OP_EXP_BASE_2_EXT + , gl_ATTRIB_STACK_DEPTH + , gl_ALPHA32F_EXT + , gl_KEEP + , gl_TEXTURE_FILTER4_SIZE_SGIS + , gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT + , gl_INT_VEC3 + , gl_MATRIX_MODE + , gl_UNSIGNED_NORMALIZED + , gl_DEBUG_PRINT_MESA + , gl_DST_OUT_NV + , gl_CLEAR_BUFFER + , gl_COMBINER_SCALE_NV + , gl_WRITE_ONLY_OES + , gl_422_AVERAGE_EXT + , gl_COLOR_INDEX12_EXT + , gl_COLOR_BUFFER_BIT0_QCOM + , gl_CAVEAT_SUPPORT + , gl_BLUE_INTEGER + , gl_IUI_N3F_V2F_EXT + , gl_VERTEX_DATA_HINT_PGI + , gl_REG_13_ATI + , gl_NEGATIVE_ONE_EXT + , gl_CON_16_ATI + , gl_TEXTURE_EXTERNAL_OES + , gl_SHADER_TYPE + , gl_OVERLAY_KHR + , gl_LUMINANCE6_ALPHA2_EXT + , gl_COLOR_TABLE_SGI + , gl_TEXTURE_STENCIL_SIZE_EXT + , gl_NEAREST + , gl_RGB8I + , gl_TEXTURE_SPARSE_ARB + , gl_MATRIX9_ARB + , gl_TEXTURE_TARGET + , gl_SECONDARY_COLOR_ARRAY_TYPE_EXT + , gl_RENDERER + , gl_TEXTURE_BINDING_BUFFER + , gl_INT_VEC3_ARB + , gl_MATRIX12_ARB + , gl_VERTEX_ATTRIB_ARRAY_ENABLED + , gl_RENDERBUFFER_SAMPLES_NV + , gl_COLOR_ATTACHMENT1_EXT + , gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE + , gl_LINEAR_DETAIL_SGIS + , gl_CURRENT_RASTER_POSITION_VALID + , gl_LINEAR_DETAIL_COLOR_SGIS + , gl_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT + , gl_POINT_SIZE_MIN_EXT + , gl_GPU_DISJOINT_EXT + , gl_LIGHT_MODEL_COLOR_CONTROL + , gl_MAX_TESS_PATCH_COMPONENTS + , gl_CURRENT_PALETTE_MATRIX_OES + , gl_SAMPLES_SGIS + , gl_FUNC_REVERSE_SUBTRACT_OES + , gl_TEXTURE13_ARB + , gl_SMOOTH_CUBIC_CURVE_TO_NV + , gl_COMPRESSED_RGBA_ASTC_3x3x3_OES + , gl_MODELVIEW15_ARB + , gl_EYE_PLANE_ABSOLUTE_NV + , gl_READ_FRAMEBUFFER_BINDING_NV + , gl_RENDERBUFFER_RED_SIZE + , gl_PIXEL_PACK_BUFFER_BINDING_EXT + , gl_MAX_RENDERBUFFER_SIZE + , gl_DOUBLE_MAT4_EXT + , gl_COMPRESSED_R11_EAC + , gl_INT_IMAGE_2D_RECT + , gl_MAD_ATI + , gl_IMAGE_CLASS_4_X_32 + , gl_VIDEO_COLOR_CONVERSION_OFFSET_NV + , gl_BOOL_VEC4 + , gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB + , gl_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES + , gl_HISTOGRAM_FORMAT_EXT + , gl_UNSIGNED_INT_8_8_8_8_REV_EXT + , gl_R1UI_C3F_V3F_SUN + , gl_SAMPLER_1D_ARRAY_SHADOW_EXT + , gl_TEXTURE_BINDING_2D_ARRAY + , gl_TEXTURE_RANGE_POINTER_APPLE + , gl_SMALL_CCW_ARC_TO_NV + , gl_SHADER_COMPILER + , gl_DEPTH_COMPONENT24_ARB + , gl_COLOR_ATTACHMENT14_NV + , gl_TIME_ELAPSED + , gl_FRAMEBUFFER_DEFAULT_LAYERS_EXT + , gl_MATRIX11_ARB + , gl_XOR + , gl_HSL_SATURATION_KHR + , gl_R1UI_T2F_V3F_SUN + , gl_COMPUTE_WORK_GROUP_SIZE + , gl_BLEND_EQUATION_EXT + , gl_SAMPLER + , gl_NUM_FRAGMENT_REGISTERS_ATI + , gl_REG_5_ATI + , gl_DSDT8_MAG8_INTENSITY8_NV + , gl_PIXEL_MAP_S_TO_S_SIZE + , gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT + , gl_OR_REVERSE + , gl_QUERY_BUFFER_BARRIER_BIT + , gl_TRANSFORM_FEEDBACK_BUFFER_BINDING + , gl_SAMPLER_1D + , gl_COLOR_TABLE_INTENSITY_SIZE + , gl_TRIANGLE_FAN + , gl_POINT_SIZE_MAX_SGIS + , gl_ELEMENT_ARRAY_POINTER_ATI + , gl_INT_IMAGE_1D_EXT + , gl_CONVOLUTION_FILTER_SCALE_EXT + , gl_EVAL_VERTEX_ATTRIB8_NV + , gl_DYNAMIC_COPY_ARB + , gl_REG_12_ATI + , gl_SIGNED_NORMALIZED + , gl_REG_8_ATI + , gl_SAMPLE_COVERAGE_ARB + , gl_ALLOW_DRAW_MEM_HINT_PGI + , gl_INTENSITY16F_ARB + , gl_PATH_FORMAT_PS_NV + , gl_TEXTURE_FREE_MEMORY_ATI + , gl_SYNC_FENCE + , gl_WRITE_ONLY_ARB + , gl_INVERT + , gl_TRANSLATE_Y_NV + , gl_SAMPLER_3D + , gl_LINE_STRIP_ADJACENCY + , gl_OPERAND2_RGB_EXT + , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG + , gl_COLOR_ARRAY_ADDRESS_NV + , gl_POST_CONVOLUTION_BLUE_SCALE_EXT + , gl_HIGH_FLOAT + , gl_TESS_GEN_MODE_EXT + , gl_DOT_PRODUCT_TEXTURE_RECTANGLE_NV + , gl_MAX_LABEL_LENGTH + , gl_QUERY_BY_REGION_NO_WAIT + , gl_OP_RECIP_EXT + , gl_PROXY_TEXTURE_2D_ARRAY + , gl_COMPRESSED_RGBA_FXT1_3DFX + , gl_PRIMITIVES_GENERATED + , gl_TEXTURE26_ARB + , gl_TESS_EVALUATION_TEXTURE + , gl_TEXTURE1 + , gl_TRANSFORM_FEEDBACK_RECORD_NV + , gl_DRAW_FRAMEBUFFER_NV + , gl_MODELVIEW8_ARB + , gl_UNSIGNED_INT_SAMPLER_BUFFER + , gl_CONVOLUTION_1D + , gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV + , gl_SAMPLER_1D_ARRAY + , gl_TRANSFORM_FEEDBACK_BINDING + , gl_LIGHTING_BIT + , gl_R1UI_C4F_N3F_V3F_SUN + , gl_TEXTURE_RED_SIZE_EXT + , gl_VERTEX_ARRAY_KHR + , gl_ALPHA_BITS + , gl_MAX_VERTEX_SHADER_INVARIANTS_EXT + , gl_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS + , gl_SAMPLE_MASK_INVERT_EXT + , gl_TRANSPOSE_PROGRAM_MATRIX_EXT + , gl_ABGR_EXT + , gl_MULTISAMPLE_BIT_3DFX + , gl_MATRIX0_NV + , gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING + , gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG + , gl_RGB9_E5 + , gl_IMAGE_2D_MULTISAMPLE_ARRAY + , gl_FRAMEBUFFER_ATTACHMENT_RED_SIZE + , gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV + , gl_GEOMETRY_PROGRAM_NV + , gl_RGB10_EXT + , gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT + , gl_ALWAYS_SOFT_HINT_PGI + , gl_WEIGHT_ARRAY_BUFFER_BINDING + , gl_BLEND_DST_ALPHA_OES + , gl_UNIFORM_BUFFER_BINDING_EXT + , gl_CONTINUOUS_AMD + , gl_STENCIL_BUFFER_BIT4_QCOM + , gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV + , gl_TESS_EVALUATION_SHADER_BIT + , gl_TEXTURE_COORD_ARRAY_EXT + , gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET + , gl_PROGRAM_INSTRUCTIONS_ARB + , gl_PROXY_TEXTURE_3D + , gl_CLIP_PLANE0 + , gl_CURRENT_QUERY_EXT + , gl_T4F_C4F_N3F_V4F + , gl_ADD + , gl_STENCIL_EXT + , gl_TEXTURE_BLUE_TYPE + , gl_OUTPUT_TEXTURE_COORD8_EXT + , gl_OBJECT_TYPE_ARB + , gl_RESET_NOTIFICATION_STRATEGY + , gl_UNSIGNED_INT_VEC2_EXT + , gl_DRAW_BUFFER6_NV + , gl_ASYNC_DRAW_PIXELS_SGIX + , gl_INTERNALFORMAT_GREEN_SIZE + , gl_TEXTURE_GREEN_SIZE + , gl_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL + , gl_VIRTUAL_PAGE_SIZE_Y_AMD + , gl_OP_MUL_EXT + , gl_NORMAL_MAP + , gl_ALPHA16_EXT + , gl_POINT_SIZE + , gl_INTERNALFORMAT_SUPPORTED + , gl_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT + , gl_DEBUG_SEVERITY_HIGH_ARB + , gl_TEXTURE_MAX_LEVEL_SGIS + , gl_SHADING_LANGUAGE_VERSION_ARB + , gl_STANDARD_FONT_FORMAT_NV + , gl_VERTEX_WEIGHT_ARRAY_SIZE_EXT + , gl_IR_INSTRUMENT1_SGIX + , gl_SIGNED_HILO8_NV + , gl_RENDERBUFFER_GREEN_SIZE_OES + , gl_REG_1_ATI + , gl_CLAMP_TO_EDGE + , gl_GEOMETRY_SHADER_BIT + , gl_MODELVIEW7_ARB + , gl_BUFFER_MAPPED_ARB + , gl_DRAW_BUFFER12_EXT + , gl_RGB565_OES + , gl_SHORT + , gl_STENCIL_BACK_FAIL_ATI + , gl_UNSIGNED_INT_IMAGE_2D_RECT_EXT + , gl_PATH_MAX_PROJECTION_STACK_DEPTH_NV + , gl_CON_31_ATI + , gl_RGB5 + , gl_SAMPLER_2D_RECT + , gl_COMPRESSED_RGBA_ASTC_5x4x4_OES + , gl_PASS_THROUGH_TOKEN + , gl_RGBA_FLOAT32_ATI + , gl_TEXTURE_COLOR_WRITEMASK_SGIS + , gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS + , gl_OUTPUT_TEXTURE_COORD23_EXT + , gl_YCBYCR8_422_NV + , gl_SRC_NV + , gl_MAX_EXT + , gl_UNPACK_COMPRESSED_BLOCK_DEPTH + , gl_UNSIGNED_SHORT_5_5_5_1_EXT + , gl_IMAGE_3D + , gl_DEPTH_BUFFER_BIT0_QCOM + , gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS + , gl_DECR_WRAP_OES + , gl_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV + , gl_SPARSE_STORAGE_BIT_ARB + , gl_LAST_VIDEO_CAPTURE_STATUS_NV + , gl_LAST_VERTEX_CONVENTION + , gl_IDENTITY_NV + , gl_RETAINED_APPLE + , gl_FLOAT_RGB32_NV + , gl_DRAW_BUFFER15_ARB + , gl_COLOR_EXT + , gl_WEIGHT_ARRAY_TYPE_OES + , gl_DETAIL_TEXTURE_2D_BINDING_SGIS + , gl_BGRA8_EXT + , gl_T2F_IUI_V3F_EXT + , gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS + , gl_VERTEX_ARRAY_LIST_IBM + , gl_INDEX_ARRAY_STRIDE_EXT + , gl_SCALE_BY_ONE_HALF_NV + , gl_PROXY_TEXTURE_4D_SGIS + , gl_HALF_FLOAT + , gl_FIELD_UPPER_NV + , gl_OCCLUSION_QUERY_EVENT_MASK_AMD + , gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV + , gl_VERTEX_ATTRIB_ARRAY4_NV + , gl_CONVOLUTION_BORDER_COLOR_HP + , gl_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT + , gl_MODULATE + , gl_NO_RESET_NOTIFICATION_KHR + , gl_CURRENT_INDEX + , gl_RED_MAX_CLAMP_INGR + , gl_SAMPLE_ALPHA_TO_MASK_EXT + , gl_DEBUG_CATEGORY_DEPRECATION_AMD + , gl_EXP2 + , gl_HISTOGRAM + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR + , gl_VERTEX_WEIGHT_ARRAY_POINTER_EXT + , gl_READ_FRAMEBUFFER_BINDING_APPLE + , gl_COLOR_ATTACHMENT9 + , gl_PROXY_TEXTURE_CUBE_MAP_ARB + , gl_SIGNED_RGB8_NV + , gl_TEXTURE_INTENSITY_SIZE + , gl_TEXTURE_MAX_CLAMP_S_SGIX + , gl_PATH_TRANSPOSE_PROJECTION_MATRIX_NV + , gl_BOUNDING_BOX_OF_BOUNDING_BOXES_NV + , gl_TEXTURE_MAX_LOD_SGIS + , gl_LUMINANCE + , gl_FOG_COORD_ARRAY_BUFFER_BINDING + , gl_OFFSET_TEXTURE_2D_BIAS_NV + , gl_FEEDBACK + , gl_MAGNITUDE_BIAS_NV + , gl_POST_CONVOLUTION_ALPHA_SCALE + , gl_PATH_TERMINAL_END_CAP_NV + , gl_GLYPH_HEIGHT_BIT_NV + , gl_TEXTURE_STORAGE_HINT_APPLE + , gl_MATRIX2_NV + , gl_RGB16I + , gl_NUM_SHADER_BINARY_FORMATS + , gl_MULTISAMPLE_BUFFER_BIT7_QCOM + , gl_SAMPLE_ALPHA_TO_ONE + , gl_CON_11_ATI + , gl_MAP2_TEXTURE_COORD_1 + , gl_DRAW_BUFFER14_ARB + , gl_SHARPEN_TEXTURE_FUNC_POINTS_SGIS + , gl_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB + , gl_FLOAT_RGBA_MODE_NV + , gl_VERTEX_ATTRIB_ARRAY9_NV + , gl_ALPHA4 + , gl_EVAL_VERTEX_ATTRIB9_NV + , gl_VARIANT_ARRAY_POINTER_EXT + , gl_INDEX_TEST_EXT + , gl_MAX_RENDERBUFFER_SIZE_EXT + , gl_MAP1_GRID_SEGMENTS + , gl_DETAIL_TEXTURE_MODE_SGIS + , gl_LINEARBURN_NV + , gl_SOURCE2_ALPHA + , gl_COLOR_ATTACHMENT9_EXT + , gl_RENDERBUFFER_OES + , gl_RGBA8UI + , gl_MIPMAP + , gl_SMOOTH_LINE_WIDTH_RANGE + , gl_COMBINER7_NV + , gl_VIEW_CLASS_64_BITS + , gl_SAMPLE_MASK_VALUE_SGIS + , gl_MAX_SHADER_STORAGE_BUFFER_BINDINGS + , gl_ALPHA32UI_EXT + , gl_NONE + , gl_MATRIX25_ARB + , gl_DUAL_LUMINANCE_ALPHA4_SGIS + , gl_PATCH_VERTICES + , gl_COLOR_MATERIAL_PARAMETER + , gl_NUM_PROGRAM_BINARY_FORMATS + , gl_PACK_ROW_LENGTH + , gl_RENDERBUFFER_BINDING_EXT + , gl_FORMAT_SUBSAMPLE_24_24_OML + , gl_RELATIVE_ROUNDED_RECT4_NV + , gl_TEXTURE3 + , gl_DEPTH_COMPONENT16_SGIX + , gl_SAMPLER_2D_SHADOW_EXT + , gl_MIN_MAP_BUFFER_ALIGNMENT + , gl_PROXY_TEXTURE_2D_ARRAY_EXT + , gl_WEIGHT_ARRAY_TYPE_ARB + , gl_LOW_INT + , gl_DRAW_BUFFER11_ATI + , gl_MAX_ELEMENTS_VERTICES_EXT + , gl_COMPRESSED_RED_RGTC1_EXT + , gl_RGBA + , gl_DRAW_BUFFER0_ARB + , gl_TEXTURE_RED_TYPE + , gl_FENCE_APPLE + , gl_MAX_CONVOLUTION_WIDTH_EXT + , gl_UNSIGNED_INVERT_NV + , gl_LIGHT6 + , gl_STREAM_COPY + , gl_INSTRUMENT_BUFFER_POINTER_SGIX + , gl_MODELVIEW + , gl_RGB32F + , gl_MAP_COLOR + , gl_COLOR_TABLE_INTENSITY_SIZE_SGI + , gl_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV + , gl_LAYER_PROVOKING_VERTEX_EXT + , gl_COMPRESSED_RGBA_ASTC_6x5x5_OES + , gl_FOG_BIT + , gl_NATIVE_GRAPHICS_HANDLE_PGI + , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT + , gl_MAX_COMPUTE_SHARED_MEMORY_SIZE + , gl_STENCIL_INDEX1_EXT + , gl_COLOR_ATTACHMENT2_NV + , gl_DRAW_BUFFER5_ARB + , gl_TEXTURE_OBJECT_VALID_QCOM + , gl_PHONG_HINT_WIN + , gl_MAP1_VERTEX_ATTRIB0_4_NV + , gl_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX + , gl_COLOR_TABLE_WIDTH + , gl_INT_IMAGE_1D_ARRAY + , gl_BUFFER_MAPPED + , gl_TEXTURE_SWIZZLE_R + , gl_COLOR_ATTACHMENT9_NV + , gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER + , gl_LUMINANCE16_ALPHA16 + , gl_PERFQUERY_GLOBAL_CONTEXT_INTEL + , gl_POINT_FADE_THRESHOLD_SIZE_EXT + , gl_BLEND_EQUATION_OES + , gl_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES + , gl_TEXTURE_BINDING_2D_ARRAY_EXT + , gl_CON_7_ATI + , gl_DUAL_LUMINANCE16_SGIS + , gl_RASTER_POSITION_UNCLIPPED_IBM + , gl_ALLOW_DRAW_FRG_HINT_PGI + , gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT + , gl_TEXTURE_COORD_ARRAY + , gl_MAX_DEBUG_LOGGED_MESSAGES_KHR + , gl_ARRAY_BUFFER_BINDING_ARB + , gl_PIXEL_TEXTURE_SGIS + , gl_STENCIL_INDEX8 + , gl_IMAGE_CLASS_10_10_10_2 + , gl_DRAW_INDIRECT_LENGTH_NV + , gl_DEBUG_CALLBACK_FUNCTION_ARB + , gl_INT_SAMPLER_2D_ARRAY + , gl_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB + , gl_GENERIC_ATTRIB_NV + , gl_TEXTURE_RED_TYPE_ARB + , gl_MAX_VERTEX_UNITS_ARB + , gl_DEPTH_BIAS + , gl_SRGB + , gl_TEXTURE_COORD_ARRAY_TYPE + , gl_TRANSFORM_FEEDBACK_BUFFER_START_EXT + , gl_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV + , gl_CURRENT_TIME_NV + , gl_TEXTURE_DEPTH_SIZE + , gl_INDEX_ARRAY_LIST_STRIDE_IBM + , gl_CLIP_PLANE1_IMG + , gl_CULL_VERTEX_EYE_POSITION_EXT + , gl_COPY_READ_BUFFER_NV + , gl_CONTEXT_CORE_PROFILE_BIT + , gl_ARC_TO_NV + , gl_PACK_COMPRESSED_BLOCK_SIZE + , gl_TRACE_NAME_MESA + , gl_TEXTURE_CROP_RECT_OES + , gl_MAP2_VERTEX_ATTRIB15_4_NV + , gl_DRAW_INDIRECT_UNIFIED_NV + , gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS + , gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS + , gl_CULL_FACE_MODE + , gl_LUMINANCE_ALPHA_INTEGER_EXT + , gl_SURFACE_MAPPED_NV + , gl_FOG_COORD_ARRAY_LENGTH_NV + , gl_R + , gl_NUM_VIDEO_CAPTURE_STREAMS_NV + , gl_VERTEX_PROGRAM_POINT_SIZE_NV + , gl_CONSTANT_NV + , gl_RGB10_A2 + , gl_INTENSITY16_EXT + , gl_TEXTURE28 + , gl_COMPRESSED_RGBA_ASTC_4x4_KHR + , gl_SRGB_READ + , gl_LUMINANCE16_ALPHA16_SNORM + , gl_UNSIGNED_INT_IMAGE_1D_ARRAY + , gl_ELEMENT_ARRAY_TYPE_ATI + , gl_PATCH_DEFAULT_OUTER_LEVEL + , gl_LINE_STRIP_ADJACENCY_ARB + , gl_POLYGON_OFFSET_POINT + , gl_UNSIGNED_SHORT_8_8_APPLE + , gl_DYNAMIC_ATI + , gl_UNSIGNED_INT16_NV + , gl_TEXTURE_BINDING_BUFFER_EXT + , gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB + , gl_MAP2_VERTEX_ATTRIB14_4_NV + , gl_COMPRESSED_RGB + , gl_VERTEX_ATTRIB_ARRAY0_NV + , gl_MIN + , gl_COLOR_SUM + , gl_ATC_RGBA_INTERPOLATED_ALPHA_AMD + , gl_RECIP_ADD_SIGNED_ALPHA_IMG + , gl_FONT_MAX_ADVANCE_WIDTH_BIT_NV + , gl_SPRITE_AXIAL_SGIX + , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES + , gl_TEXTURE_ENV_BIAS_SGIX + , gl_PROGRAM_FORMAT_ASCII_ARB + , gl_OUTPUT_COLOR1_EXT + , gl_SELECTION_BUFFER_SIZE + , gl_VERTEX_ATTRIB_MAP2_ORDER_APPLE + , gl_INTENSITY_FLOAT16_ATI + , gl_TEXTURE30_ARB + , gl_TEXTURE_1D_STACK_MESAX + , gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE + , gl_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM + , gl_SIGNED_HILO_NV + , gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT + , gl_ACTIVE_ATTRIBUTE_MAX_LENGTH + , gl_IMAGE_2D_RECT_EXT + , gl_TESS_GEN_MODE + , gl_TEXTURE_MIN_FILTER + , gl_FLOAT_VEC4 + , gl_LIGHT2 + , gl_MODELVIEW24_ARB + , gl_TESS_EVALUATION_SHADER + , gl_PROXY_COLOR_TABLE_SGI + , gl_INDEX_ARRAY_EXT + , gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB + , gl_FRAGMENT_INPUT_NV + , gl_CON_13_ATI + , gl_IMAGE_ROTATE_ORIGIN_Y_HP + , gl_VERTEX_ARRAY_COUNT_EXT + , gl_STENCIL_INDEX1_OES + , gl_BUFFER_DATA_SIZE + , gl_MAX_NAME_STACK_DEPTH + , gl_SAMPLES_PASSED_ARB + , gl_TEXTURE_PRE_SPECULAR_HP + , gl_RESCALE_NORMAL_EXT + , gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY + , gl_TRANSLATE_2D_NV + , gl_QUAD_INTENSITY8_SGIS + , gl_LOCATION_INDEX + , gl_MODELVIEW9_ARB + , gl_CONTEXT_RELEASE_BEHAVIOR_KHR + , gl_EDGE_FLAG_ARRAY_BUFFER_BINDING + , gl_DEBUG_TYPE_PERFORMANCE_KHR + , gl_POINT_DISTANCE_ATTENUATION + , gl_PIXEL_TILE_GRID_HEIGHT_SGIX + , gl_COLOR_ATTACHMENT3 + , gl_COUNT_UP_NV + , gl_STENCIL_BACK_VALUE_MASK + , gl_PERFQUERY_DONOT_FLUSH_INTEL + , gl_VARIABLE_F_NV + , gl_STENCIL_BACK_PASS_DEPTH_FAIL + , gl_IMAGE_CUBIC_WEIGHT_HP + , gl_STENCIL + , gl_DRAW_BUFFER6_ARB + , gl_MAX_COMBINED_IMAGE_UNIFORMS + , gl_PROGRAM_STRING_NV + , gl_STREAM_DRAW + , gl_BGR_INTEGER_EXT + , gl_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES + , gl_LAYER_PROVOKING_VERTEX + , gl_TEXTURE_ALPHA_SIZE_EXT + , gl_QUERY_DEPTH_PASS_EVENT_BIT_AMD + , gl_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX + , gl_VIEW_CLASS_48_BITS + , gl_DRAW_BUFFER15_NV + , gl_MAX_LABEL_LENGTH_KHR + , gl_DEBUG_TYPE_PERFORMANCE + , gl_DEPENDENT_RGB_TEXTURE_3D_NV + , gl_MAX_GEOMETRY_ATOMIC_COUNTERS + , gl_DRAW_BUFFER10_ARB + , gl_FONT_UNDERLINE_THICKNESS_BIT_NV + , gl_DRAW_BUFFER7 + , gl_TEXTURE_GREEN_TYPE_ARB + , gl_TEXTURE_MIN_LOD_SGIS + , gl_UNSIGNED_INT_SAMPLER_BUFFER_EXT + , gl_ELEMENT_ARRAY_BARRIER_BIT_EXT + , gl_SAMPLE_COVERAGE_VALUE + , gl_VERTEX_ATTRIB_RELATIVE_OFFSET + , gl_COLOR_TABLE_RED_SIZE + , gl_TRANSFORM_FEEDBACK_BUFFER_START_NV + , gl_NAME_STACK_DEPTH + , gl_UNSIGNED_INT_5_9_9_9_REV + , gl_FUNC_SUBTRACT_EXT + , gl_STENCIL_INDEX4_EXT + , gl_TEXTURE_COMPRESSION_HINT + , gl_DEPTH_CLAMP + , gl_SAMPLE_COVERAGE_INVERT + , gl_DRAW_BUFFER0_EXT + , gl_DRAW_BUFFER4 + , gl_ALPHA_FLOAT16_ATI + , gl_AFFINE_2D_NV + , gl_MAX_TRACK_MATRICES_NV + , gl_BINORMAL_ARRAY_STRIDE_EXT + , gl_UNSIGNED_SHORT_1_5_5_5_REV + , gl_ROUNDED_RECT4_NV + , gl_COMMAND_BARRIER_BIT_EXT + , gl_TEXTURE_ENV_COLOR + , gl_READ_WRITE_ARB + , gl_RGBA8_EXT + , gl_EVAL_VERTEX_ATTRIB10_NV + , gl_POST_CONVOLUTION_RED_BIAS + , gl_INT16_VEC4_NV + , gl_COLOR_SUM_ARB + , gl_OUTPUT_TEXTURE_COORD5_EXT + , gl_COMPRESSED_RGBA_ASTC_12x10_KHR + , gl_MAX_ELEMENTS_INDICES + , gl_REFERENCED_BY_FRAGMENT_SHADER + , gl_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB + , gl_WEIGHT_ARRAY_ARB + , gl_TIME_ELAPSED_EXT + , gl_BACK_SECONDARY_COLOR_NV + , gl_COMPARE_REF_TO_TEXTURE_EXT + , gl_IS_PER_PATCH_EXT + , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE + , gl_TEXTURE_LUMINANCE_SIZE_EXT + , gl_COVERAGE_BUFFERS_NV + , gl_MATRIX5_ARB + , gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT + , gl_COMPRESSED_RGBA_ASTC_5x5x4_OES + , gl_CONVOLUTION_FILTER_BIAS + , gl_TRACE_PRIMITIVES_BIT_MESA + , gl_POINT_SPRITE + , gl_POLYGON_STIPPLE_BIT + , gl_DEBUG_SEVERITY_HIGH + , gl_RENDERBUFFER_STENCIL_SIZE_EXT + , gl_RED + , gl_DRAW_BUFFER12_NV + , gl_COMPRESSED_RGBA_ASTC_10x10_KHR + , gl_ACTIVE_TEXTURE + , gl_Q + , gl_STRICT_LIGHTING_HINT_PGI + , gl_INT8_VEC2_NV + , gl_MAP2_VERTEX_ATTRIB0_4_NV + , gl_SHADER_SOURCE_LENGTH + , gl_FLOAT_MAT4 + , gl_COLOR_MATRIX_SGI + , gl_SAMPLER_2D_ARRAY_EXT + , gl_MODULATE_SUBTRACT_ATI + , gl_TRIANGLES_ADJACENCY_ARB + , gl_PROGRAM_TARGET_NV + , gl_GEOMETRY_SHADER_ARB + , gl_TEXTURE_BASE_LEVEL_SGIS + , gl_1PASS_SGIS + , gl_TEXTURE_HEIGHT_QCOM + , gl_LUMINANCE12_ALPHA4_EXT + , gl_PIXEL_TILE_HEIGHT_SGIX + , gl_UNSIGNED_INT_S8_S8_8_8_NV + , gl_SOURCE0_RGB + , gl_DRAW_BUFFER6_EXT + , gl_PATH_FILL_BOUNDING_BOX_NV + , gl_RENDER_MODE + , gl_X_EXT + , gl_CON_14_ATI + , gl_TRIANGLE_STRIP_ADJACENCY + , gl_ROUNDED_RECT_NV + , gl_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB + , gl_DSDT_MAG_INTENSITY_NV + , gl_MODELVIEW13_ARB + , gl_MAX_COMBINED_CLIP_AND_CULL_DISTANCES + , gl_CLIP_ORIGIN + , gl_PATH_CLIENT_LENGTH_NV + , gl_SAMPLE_ALPHA_TO_ONE_ARB + , gl_RENDERBUFFER_INTERNAL_FORMAT_OES + , gl_POINT_SPRITE_ARB + , gl_FLOAT_MAT3_ARB + , gl_IMAGE_CLASS_4_X_8 + , gl_PIXEL_SUBSAMPLE_4242_SGIX + , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT + , gl_ROUNDED_RECT8_NV + , gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING + , gl_DST_NV + , gl_MAX_TRANSFORM_FEEDBACK_BUFFERS + , gl_FUNC_ADD_OES + , gl_VERTEX_STREAM7_ATI + , gl_RG_EXT + , gl_STENCIL_BACK_PASS_DEPTH_PASS + , gl_FRAMEBUFFER_RENDERABLE_LAYERED + , gl_MAP2_VERTEX_ATTRIB1_4_NV + , gl_DRAW_BUFFER2_ATI + , gl_RGBA_FLOAT16_ATI + , gl_EVAL_VERTEX_ATTRIB13_NV + , gl_DRAW_BUFFER15_ATI + , gl_MAP_WRITE_BIT + , gl_DOT3_RGBA + , gl_MAT_SHININESS_BIT_PGI + , gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN + , gl_MAX_TRACK_MATRIX_STACK_DEPTH_NV + , gl_MATRIX30_ARB + , gl_STENCIL_TEST + , gl_MAX_INTEGER_SAMPLES + , gl_COPY_READ_BUFFER_BINDING + , gl_TRANSFORM_FEEDBACK_BUFFER + , gl_LUMINANCE_FLOAT16_APPLE + , gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS + , gl_MAX_VERTEX_UNIFORM_VECTORS + , gl_WRITE_PIXEL_DATA_RANGE_LENGTH_NV + , gl_SAMPLER_RENDERBUFFER_NV + , gl_DRAW_BUFFER13_NV + , gl_RGB32F_ARB + , gl_FRAGMENT_LIGHT5_SGIX + , gl_MAX_GENERAL_COMBINERS_NV + , gl_TRANSPOSE_TEXTURE_MATRIX_ARB + , gl_OPERAND1_ALPHA_ARB + , gl_COLOR_ATTACHMENT12 + , gl_GREEN_MAX_CLAMP_INGR + , gl_PATH_PROJECTION_STACK_DEPTH_NV + , gl_MAP2_COLOR_4 + , gl_COLOR_SUM_EXT + , gl_CLAMP_FRAGMENT_COLOR_ARB + , gl_INDEX_BITS + , gl_CON_15_ATI + , gl_BLEND_OVERLAP_NV + , gl_DS_SCALE_NV + , gl_CURRENT_PALETTE_MATRIX_ARB + , gl_IMAGE_BINDING_LAYER_EXT + , gl_WEIGHT_SUM_UNITY_ARB + , gl_ALPHA32I_EXT + , gl_SHADER_STORAGE_BUFFER_SIZE + , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER + , gl_MAX_UNIFORM_LOCATIONS + , gl_DEBUG_SOURCE_OTHER_KHR + , gl_FRACTIONAL_EVEN + , gl_MIN_PROGRAM_TEXEL_OFFSET + , gl_WEIGHT_ARRAY_OES + , gl_RESET_NOTIFICATION_STRATEGY_KHR + , gl_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV + , gl_RGB2_EXT + , gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT + , gl_ELEMENT_ARRAY_BUFFER + , gl_MEDIUM_FLOAT + , gl_SAMPLER_1D_SHADOW_ARB + , gl_DRAW_BUFFER5 + , gl_PARALLEL_ARRAYS_INTEL + , gl_REG_24_ATI + , gl_DEPTH_STENCIL_TO_BGRA_NV + , gl_MAX_FRAMEBUFFER_WIDTH + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES + , gl_POLYGON_OFFSET_FILL + , gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES + , gl_TEXTURE_GEN_T + , gl_TEXTURE_POST_SPECULAR_HP + , gl_TEXTURE_CUBE_MAP_NEGATIVE_X_OES + , gl_MAGNITUDE_SCALE_NV + , gl_VERTEX_SHADER_LOCALS_EXT + , gl_INT_2_10_10_10_REV + , gl_DOUBLE_MAT3x2_EXT + , gl_DISCARD_NV + , gl_MATRIX13_ARB + , gl_GENERATE_MIPMAP_HINT + , gl_MAX_PIXEL_MAP_TABLE + , gl_SHADER_STORAGE_BUFFER + , gl_BUFFER_UPDATE_BARRIER_BIT + , gl_FRAMEBUFFER_BINDING_OES + , gl_CONTEXT_PROFILE_MASK + , gl_MAX_VIEWPORTS + , gl_DRAW_BUFFER4_ARB + , gl_RESAMPLE_DECIMATE_SGIX + , gl_SHADER_OBJECT_ARB + , gl_SYNC_FLAGS_APPLE + , gl_Z4Y12Z4CB12Z4CR12_444_NV + , gl_VERTEX_ARRAY_LENGTH_NV + , gl_FOG_COORDINATE_ARRAY_LIST_IBM + , gl_FRAMEBUFFER_DEFAULT_SAMPLES + , gl_FLAT + , gl_REG_2_ATI + , gl_VIEWPORT_BIT + , gl_TEXTURE_VIEW_MIN_LEVEL_EXT + , gl_FRACTIONAL_ODD_EXT + , gl_VIRTUAL_PAGE_SIZE_X_ARB + , gl_GLOBAL_ALPHA_SUN + , gl_TEXTURE_BORDER + , gl_MAP2_VERTEX_ATTRIB7_4_NV + , gl_BUFFER_ACCESS + , gl_COLOR_ATTACHMENT15_EXT + , gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT + , gl_PRIMITIVE_RESTART_FIXED_INDEX + , gl_MAX_COMBINED_DIMENSIONS + , gl_MINUS_NV + , gl_NORMAL_MAP_ARB + , gl_MAT_AMBIENT_BIT_PGI + , gl_REG_14_ATI + , gl_SECONDARY_INTERPOLATOR_ATI + , gl_FRAGMENT_SHADER_BIT_EXT + , gl_CON_20_ATI + , gl_DYNAMIC_DRAW + , gl_STENCIL_INDEX1 + , gl_DEPTH_COMPONENTS + , gl_SEPARATE_SPECULAR_COLOR_EXT + , gl_CONSTANT_COLOR0_NV + , gl_LUMINANCE16I_EXT + , gl_TEXTURE_COORD_ARRAY_SIZE_EXT + , gl_BLEND_DST_RGB + , gl_VARIABLE_C_NV + , gl_INT_VEC2_ARB + , gl_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX + , gl_PIXEL_MAP_G_TO_G_SIZE + , gl_BLUE_MIN_CLAMP_INGR + , gl_RETURN + , gl_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD + , gl_DOUBLE + , gl_COMBINE4_NV + , gl_IMAGE_ROTATE_ORIGIN_X_HP + , gl_COMBINER5_NV + , gl_SYNC_CONDITION + , gl_DEBUG_LOGGED_MESSAGES_ARB + , gl_REG_15_ATI + , gl_BUFFER_MAP_POINTER_OES + , gl_SM_COUNT_NV + , gl_MAX_FRAMEBUFFER_HEIGHT + , gl_INCR_WRAP_OES + , gl_GCCSO_SHADER_BINARY_FJ + , gl_DRAW_BUFFER4_NV + , gl_RGB565 + , gl_WRITE_PIXEL_DATA_RANGE_NV + , gl_UNIFORM_OFFSET + , gl_UNSIGNED_INT64_ARB + , gl_STENCIL_RENDERABLE + , gl_COMPRESSED_RGBA_BPTC_UNORM + , gl_FLOAT_R32_NV + , gl_TEXTURE_CLIPMAP_OFFSET_SGIX + , gl_TEXTURE_IMAGE_VALID_QCOM + , gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC + , gl_IMAGE_PIXEL_TYPE + , gl_EDGE_FLAG_ARRAY_STRIDE + , gl_RED_SCALE + , gl_RENDERBUFFER_ALPHA_SIZE_OES + , gl_CLIP_DISTANCE7 + , gl_INTENSITY32UI_EXT + , gl_DEBUG_SOURCE_WINDOW_SYSTEM_KHR + , gl_PN_TRIANGLES_ATI + , gl_LIGHT5 + , gl_QUERY_RESULT_ARB + , gl_LUMINANCE16 + , gl_ALPHA_TEST_QCOM + , gl_TEXTURE_BORDER_COLOR_NV + , gl_CULL_FRAGMENT_NV + , gl_PATH_GEN_MODE_NV + , gl_PROGRAM_POINT_SIZE_ARB + , gl_INTERNALFORMAT_DEPTH_TYPE + , gl_UNPACK_SKIP_ROWS + , gl_DEBUG_SEVERITY_NOTIFICATION + , gl_MAX_FRAGMENT_LIGHTS_SGIX + , gl_COUNTER_TYPE_AMD + , gl_TEXTURE_FETCH_BARRIER_BIT_EXT + , gl_CURRENT_NORMAL + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES + , gl_MULTIVIEW_EXT + , gl_TESS_GEN_VERTEX_ORDER_EXT + , gl_IMAGE_SCALE_X_HP + , gl_TEXTURE_COLOR_TABLE_SGI + , gl_DSDT_MAG_NV + , gl_Z400_BINARY_AMD + , gl_COLOR_INDEX8_EXT + , gl_SRGB8_NV + , gl_UNSIGNED_IDENTITY_NV + , gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES + , gl_ALPHA_SNORM + , gl_MAX_TEXTURE_UNITS + , gl_DEBUG_SEVERITY_MEDIUM_KHR + , gl_TEXTURE_RECTANGLE + , gl_CONTRAST_NV + , gl_FILL + , gl_BLEND_COLOR + , gl_POINT_SMOOTH_HINT + , gl_CONTEXT_ROBUST_ACCESS + , gl_FRAGMENT_PROGRAM_NV + , gl_OP_MULTIPLY_MATRIX_EXT + , gl_DEPENDENT_GB_TEXTURE_2D_NV + , gl_DOUBLE_EXT + , gl_VERTEX_PROGRAM_NV + , gl_PATH_END_CAPS_NV + , gl_PATH_STROKE_MASK_NV + , gl_SAMPLER_CUBE_SHADOW_EXT + , gl_COLOR_SAMPLES_NV + , gl_DUAL_INTENSITY16_SGIS + , gl_IMPLEMENTATION_COLOR_READ_TYPE_OES + , gl_MAX_DEBUG_GROUP_STACK_DEPTH_KHR + , gl_SCISSOR_TEST + , gl_ADJACENT_PAIRS_NV + , gl_MAX_VERTEX_ATTRIB_BINDINGS + , gl_TEXTURE_GATHER + , gl_LUMINANCE_ALPHA8UI_EXT + , gl_RELATIVE_ARC_TO_NV + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR + , gl_TEXTURE_BINDING_CUBE_MAP_EXT + , gl_FRAGMENT_ALPHA_MODULATE_IMG + , gl_CURRENT_VERTEX_EXT + , gl_MAP1_VERTEX_ATTRIB11_4_NV + , gl_MATRIX_INDEX_ARRAY_SIZE_ARB + , gl_TRANSFORM_FEEDBACK_BUFFER_MODE + , gl_PIXEL_TILE_CACHE_SIZE_SGIX + , gl_MODELVIEW0_EXT + , gl_FONT_DESCENDER_BIT_NV + , gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS + , gl_RASTERIZER_DISCARD + , gl_TRANSFORM_FEEDBACK_BUFFER_SIZE + , gl_MAX_DEBUG_MESSAGE_LENGTH_ARB + , gl_EXTENSIONS + , gl_RESAMPLE_AVERAGE_OML + , gl_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV + , gl_RELATIVE_SMALL_CCW_ARC_TO_NV + , gl_FRONT + , gl_BLEND_COLOR_EXT + , gl_BUFFER_ACCESS_OES + , gl_MATRIX29_ARB + , gl_GEOMETRY_LINKED_INPUT_TYPE_EXT + , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES + , gl_COLOR_ATTACHMENT12_EXT + , gl_DRAW_BUFFER1 + , gl_FLOAT_32_UNSIGNED_INT_24_8_REV + , gl_UNSIGNED_INT_SAMPLER_2D_RECT_EXT + , gl_UNSIGNED_INT_SAMPLER_CUBE + , gl_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI + , gl_MAX_CULL_DISTANCES + , gl_TEXTURE_LOD_BIAS_S_SGIX + , gl_SPRITE_SGIX + , gl_VERTEX_ATTRIB_ARRAY3_NV + , gl_QUAD_INTENSITY4_SGIS + , gl_DIFFERENCE_KHR + , gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT + , gl_VOLATILE_APPLE + , gl_MAT_EMISSION_BIT_PGI + , gl_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV + , gl_DRAW_FRAMEBUFFER_BINDING + , gl_TEXTURE8 + , gl_MUL_ATI + , gl_PROGRAM_OBJECT_EXT + , gl_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB + , gl_MATRIX_INDEX_ARRAY_TYPE_ARB + , gl_PIXEL_MAG_FILTER_EXT + , gl_LESS + , gl_SOURCE2_RGB_ARB + , gl_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH + , gl_PATH_STENCIL_VALUE_MASK_NV + , gl_IMPLEMENTATION_COLOR_READ_TYPE + , gl_TEXTURE_CLIPMAP_CENTER_SGIX + , gl_BUFFER + , gl_DEBUG_CALLBACK_USER_PARAM_ARB + , gl_FIXED_OES + , gl_INT_VEC2 + , gl_VARIANT_VALUE_EXT + , gl_QUAD_STRIP + , gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT + , gl_ZERO_TO_ONE + , gl_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB + , gl_CND_ATI + , gl_PROGRAM_POINT_SIZE + , gl_VIEWPORT_BOUNDS_RANGE + , gl_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL + , gl_R1UI_T2F_N3F_V3F_SUN + , gl_DEPTH_STENCIL_EXT + , gl_RESCALE_NORMAL + , gl_INDEX_CLEAR_VALUE + , gl_VERTEX_STREAM5_ATI + , gl_CON_4_ATI + , gl_LAYOUT_DEFAULT_INTEL + , gl_RGBA8I_EXT + , gl_IMAGE_CLASS_4_X_16 + , gl_RGB8_EXT + , gl_TEXTURE_DS_SIZE_NV + , gl_CLAMP_VERTEX_COLOR + , gl_DEPTH_CLEAR_VALUE + , gl_VERTEX_ATTRIB_ARRAY_SIZE_ARB + , gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS + , gl_RGB_FLOAT16_APPLE + , gl_DOT_PRODUCT_REFLECT_CUBE_MAP_NV + , gl_COLOR_ATTACHMENT1 + , gl_MAX_TESS_GEN_LEVEL_EXT + , gl_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER + , gl_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM + , gl_MATRIX3_ARB + , gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB + , gl_FRAGMENT_PROGRAM_BINDING_NV + , gl_DOT2_ADD_ATI + , gl_CON_2_ATI + , gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES + , gl_UNIFORM_ARRAY_STRIDE + , gl_RECLAIM_MEMORY_HINT_PGI + , gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS + , gl_DRAW_BUFFER11_ARB + , gl_NORMAL_ARRAY + , gl_PATH_GEN_COMPONENTS_NV + , gl_COLOR_FLOAT_APPLE + , gl_WAIT_FAILED + , gl_SAMPLER_1D_ARRAY_SHADOW + , gl_PIXEL_TEX_GEN_Q_CEILING_SGIX + , gl_ALWAYS_FAST_HINT_PGI + , gl_GEOMETRY_OUTPUT_TYPE_EXT + , gl_MAX_PROGRAM_PATCH_ATTRIBS_NV + , gl_TEXTURE_1D_ARRAY + , gl_LIST_MODE + , gl_COLOR_ARRAY_TYPE + , gl_SAMPLE_MASK_VALUE_EXT + , gl_PIXEL_BUFFER_BARRIER_BIT + , gl_SCISSOR_BOX + , gl_UNSIGNED_INT_SAMPLER_3D_EXT + , gl_MAX_ATOMIC_COUNTER_BUFFER_SIZE + , gl_CLIENT_ALL_ATTRIB_BITS + , gl_TRANSPOSE_MODELVIEW_MATRIX_ARB + , gl_TEXTURE_BINDING_RECTANGLE_NV + , gl_ALPHA_FLOAT32_ATI + , gl_MAP1_TEXTURE_COORD_4 + , gl_CONSTANT_ALPHA + , gl_PREVIOUS_EXT + , gl_PACK_COMPRESSED_SIZE_SGIX + , gl_IMAGE_2D_ARRAY_EXT + , gl_ASYNC_TEX_IMAGE_SGIX + , gl_QUERY_RESULT + , gl_MATRIX0_ARB + , gl_UNPACK_CMYK_HINT_EXT + , gl_MAP1_TEXTURE_COORD_1 + , gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH + , gl_PN_TRIANGLES_POINT_MODE_LINEAR_ATI + , gl_TEXTURE_BLUE_SIZE_EXT + , gl_VARIANT_EXT + , gl_UNPACK_ROW_LENGTH + , gl_VARIANT_DATATYPE_EXT + , gl_LINEAR_MIPMAP_LINEAR + , gl_ALPHA8I_EXT + , gl_OUTPUT_TEXTURE_COORD20_EXT + , gl_EYE_LINEAR + , gl_VIEWPORT + , gl_SHADER_BINARY_DMP + , gl_TEXTURE25_ARB + , gl_UNSIGNED_SHORT_4_4_4_4_EXT + , gl_PROXY_HISTOGRAM_EXT + , gl_SCALEBIAS_HINT_SGIX + , gl_MAP_INVALIDATE_RANGE_BIT_EXT + , gl_FRAGMENT_PROGRAM_CALLBACK_MESA + , gl_TRANSLATE_3D_NV + , gl_PATH_COORD_COUNT_NV + , gl_MAX_ACTIVE_LIGHTS_SGIX + , gl_TRANSFORM_FEEDBACK_OVERFLOW_ARB + , gl_REFERENCE_PLANE_EQUATION_SGIX + , gl_PATH_TERMINAL_DASH_CAP_NV + , gl_INDEX_ARRAY + , gl_INNOCENT_CONTEXT_RESET_ARB + , gl_TEXTURE_BINDING_1D + , gl_TRANSFORM_FEEDBACK_BUFFER_STRIDE + , gl_QUERY_OBJECT_EXT + , gl_UNIFORM_BLOCK + , gl_CONVOLUTION_HEIGHT + , gl_STENCIL_FAIL + , gl_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX + , gl_TEXTURE_SAMPLES_IMG + , gl_REFLECTION_MAP_NV + , gl_GREEN_SCALE + , gl_TRANSFORM_FEEDBACK_BUFFER_EXT + , gl_LIGHTEN_NV + , gl_HISTOGRAM_ALPHA_SIZE_EXT + , gl_UNSIGNED_INT64_NV + , gl_LINE_STIPPLE_REPEAT + , gl_YCBCR_MESA + , gl_LEQUAL + , gl_BUFFER_USAGE_ARB + , gl_MAP1_VERTEX_ATTRIB6_4_NV + , gl_SAMPLER_BUFFER_AMD + , gl_OBJECT_DISTANCE_TO_LINE_SGIS + , gl_PIXEL_COUNT_NV + , gl_VERTEX_PROGRAM_POSITION_MESA + , gl_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI + , gl_POST_COLOR_MATRIX_BLUE_BIAS + , gl_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX + , gl_VERTEX_ATTRIB_MAP2_APPLE + , gl_PLUS_DARKER_NV + , gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT + , gl_FRAGMENT_SHADER_INVOCATIONS_ARB + , gl_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT + , gl_PROXY_TEXTURE_CUBE_MAP_ARRAY + , gl_UNSIGNED_INT_IMAGE_CUBE_EXT + , gl_DYNAMIC_DRAW_ARB + , gl_RGBA_SNORM + , gl_MAX_UNIFORM_BLOCK_SIZE + , gl_FUNC_REVERSE_SUBTRACT_EXT + , gl_STENCIL_BUFFER_BIT1_QCOM + , gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER + , gl_TEXTURE_1D_BINDING_EXT + , gl_RGBA4_EXT + , gl_PREFER_DOUBLEBUFFER_HINT_PGI + , gl_UNKNOWN_CONTEXT_RESET_KHR + , gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES + , gl_REFERENCED_BY_COMPUTE_SHADER + , gl_REG_17_ATI + , gl_BUFFER_FLUSHING_UNMAP_APPLE + , gl_UNIFORM + , gl_TEXCOORD4_BIT_PGI + , gl_BIAS_BY_NEGATIVE_ONE_HALF_NV + , gl_OP_FLOOR_EXT + , gl_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV + , gl_CURRENT_QUERY + , gl_UNIFORM_BUFFER_START + , gl_DEBUG_SEVERITY_HIGH_KHR + , gl_T2F_C4UB_V3F + , gl_FONT_GLYPHS_AVAILABLE_NV + , gl_MAX_CONVOLUTION_HEIGHT_EXT + , gl_STENCIL_BUFFER_BIT3_QCOM + , gl_MAP1_VERTEX_ATTRIB3_4_NV + , gl_BLEND_EQUATION_ALPHA_EXT + , gl_RGB_FLOAT32_APPLE + , gl_CONSTANT_BORDER + , gl_CON_0_ATI + , gl_VERTEX_ARRAY_RANGE_POINTER_NV + , gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV + , gl_INTERLACE_SGIX + , gl_UNPACK_CONSTANT_DATA_SUNX + , gl_VERTEX_BINDING_STRIDE + , gl_IS_PER_PATCH + , gl_AVERAGE_HP + , gl_MAX_VERTEX_ATTRIBS + , gl_MAX_SAMPLES_ANGLE + , gl_RED_EXT + , gl_MAP1_NORMAL + , gl_TEXTURE_COMPRESSED_BLOCK_HEIGHT + , gl_MIN_SAMPLE_SHADING_VALUE_ARB + , gl_COMPRESSED_SLUMINANCE_EXT + , gl_RGBA4 + , gl_TEXTURE_VIEW_MIN_LAYER + , gl_ONE_EXT + , gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES + , gl_MODELVIEW31_ARB + , gl_MAX_TEXTURE_IMAGE_UNITS + , gl_COLOR_ATTACHMENT3_NV + , gl_LUMINANCE6_ALPHA2 + , gl_POINT_SPRITE_R_MODE_NV + , gl_COMPARE_REF_TO_TEXTURE + , gl_MAX_PROJECTION_STACK_DEPTH + , gl_BLEND_DST_ALPHA + , gl_TEXTURE_1D_STACK_BINDING_MESAX + , gl_VERTEX_ATTRIB_ARRAY_LENGTH_NV + , gl_PROGRAM_PARAMETER_NV + , gl_VIDEO_CAPTURE_FRAME_WIDTH_NV + , gl_MATRIX21_ARB + , gl_LIST_BASE + , gl_COLOR_ATTACHMENT5 + , gl_VERTEX_ARRAY_BINDING_APPLE + , gl_RELATIVE_LARGE_CW_ARC_TO_NV + , gl_MAX_DEFORMATION_ORDER_SGIX + , gl_COVERAGE_AUTOMATIC_NV + , gl_FOG_FUNC_SGIS + , gl_SAMPLER_BUFFER_EXT + , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT + , gl_RGB8 + , gl_PRIMARY_COLOR_NV + , gl_DEPTH_TEXTURE_MODE_ARB + , gl_LUMINANCE12_ALPHA4 + , gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS + , gl_TEXTURE_BUFFER_EXT + , gl_LINK_STATUS + , gl_VERTEX_SHADER_EXT + , gl_VERTEX_ARRAY_POINTER + , gl_ONE_MINUS_SRC1_ALPHA + , gl_TEXTURE_BUFFER_SIZE_EXT + , gl_DEBUG_SEVERITY_MEDIUM + , gl_ASYNC_READ_PIXELS_SGIX + , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME + , gl_REPLACE_EXT + , gl_DEBUG_SOURCE_APPLICATION_ARB + , gl_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES + , gl_BROWSER_DEFAULT_WEBGL + , gl_MULTISAMPLE_BUFFER_BIT0_QCOM + , gl_DUAL_ALPHA8_SGIS + , gl_COMPRESSED_RGB_FXT1_3DFX + , gl_BLEND_SRC_RGB_OES + , gl_T2F_IUI_V2F_EXT + , gl_DRAW_BUFFER13_ARB + , gl_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV + , gl_TEXTURE_INTENSITY_TYPE_ARB + , gl_DU8DV8_ATI + , gl_MAP1_VERTEX_ATTRIB14_4_NV + , gl_VARIANT_ARRAY_STRIDE_EXT + , gl_RGB_S3TC + , gl_NORMAL_ARRAY_POINTER + , gl_CONSTANT_ALPHA_EXT + , gl_COLOR_ATTACHMENT8_NV + , gl_MAX_LIST_NESTING + , gl_FRAMEBUFFER_UNDEFINED + , gl_ACTIVE_STENCIL_FACE_EXT + , gl_DEPTH_SCALE + , gl_READ_PIXELS_FORMAT + , gl_QUADS_EXT + , gl_MAX_COMBINED_SHADER_STORAGE_BLOCKS + , gl_OUTPUT_VERTEX_EXT + , gl_PROGRAM_ATTRIBS_ARB + , gl_MAP1_VERTEX_ATTRIB8_4_NV + , gl_INVALID_ENUM + , gl_1PASS_EXT + , gl_FUNC_ADD_EXT + , gl_DISTANCE_ATTENUATION_SGIS + , gl_REG_3_ATI + , gl_INTERPOLATE + , gl_MITER_TRUNCATE_NV + , gl_MAX_PROGRAM_NATIVE_ATTRIBS_ARB + , gl_CONTEXT_COMPATIBILITY_PROFILE_BIT + , gl_MATRIX_STRIDE + , gl_FONT_Y_MIN_BOUNDS_BIT_NV + , gl_COMBINER_BIAS_NV + , gl_TEXTURE_CUBE_MAP_POSITIVE_X_ARB + , gl_CIRCULAR_CW_ARC_TO_NV + , gl_UNSIGNED_INT_IMAGE_1D_EXT + , gl_BLUE_SCALE + , gl_OFFSET_TEXTURE_SCALE_NV + , gl_OFFSET_TEXTURE_2D_NV + , gl_INTERNALFORMAT_DEPTH_SIZE + , gl_TIMEOUT_IGNORED + , gl_BGRA_EXT + , gl_GEQUAL + , gl_EXCLUSION_KHR + , gl_LINES_ADJACENCY_ARB + , gl_MAX_COMPUTE_WORK_GROUP_COUNT + , gl_RENDERBUFFER_EXT + , gl_GENERATE_MIPMAP + , gl_SOURCE1_ALPHA_EXT + , gl_VERTEX_TEXTURE + , gl_LIGHT1 + , gl_STATIC_READ_ARB + , gl_INTERLACE_READ_INGR + , gl_COMPRESSED_R11_EAC_OES + , gl_FRAGMENT_SHADER_ARB + , gl_CURRENT_RASTER_POSITION + , gl_WEIGHT_ARRAY_BUFFER_BINDING_OES + , gl_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT + , gl_RGB_FLOAT32_ATI + , gl_LUMINANCE16_ALPHA16_EXT + , gl_RENDERBUFFER_WIDTH_EXT + , gl_DEPTH_RANGE + , gl_4_BYTES + , gl_VERTEX_WEIGHTING_EXT + , gl_TEXTURE_SWIZZLE_B + , gl_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV + , gl_FEEDBACK_BUFFER_POINTER + , gl_CULL_VERTEX_IBM + , gl_UNPACK_SKIP_VOLUMES_SGIS + , gl_PIXEL_CUBIC_WEIGHT_EXT + , gl_DECR_WRAP_EXT + , gl_TEXTURE31 + , gl_MAX_TESS_GEN_LEVEL + , gl_YCBAYCR8A_4224_NV + , gl_POINT_SPRITE_OES + , gl_SAMPLER_EXTERNAL_OES + , gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT + , gl_PIXEL_PACK_BUFFER_BINDING_ARB + , gl_DEBUG_CATEGORY_API_ERROR_AMD + , gl_TEXCOORD3_BIT_PGI + , gl_UNIFORM_BUFFER_EXT + , gl_COMPRESSED_RGBA8_ETC2_EAC + , gl_COLOR_SUM_CLAMP_NV + , gl_SAMPLER_CUBE + , gl_FRACTIONAL_ODD + , gl_ONE_MINUS_DST_COLOR + , gl_REG_9_ATI + , gl_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV + , gl_PIXEL_MAP_I_TO_G + , gl_FOG_COORD_ARRAY_STRIDE + , gl_TRIANGLES_ADJACENCY_EXT + , gl_DRAW_BUFFER14_EXT + , gl_TEXTURE_COMPARE_MODE_ARB + , gl_REFLECTION_MAP_OES + , gl_WARPS_PER_SM_NV + , gl_QUERY_WAIT + , gl_COMPRESSED_SLUMINANCE_ALPHA + , gl_MAP2_TEXTURE_COORD_3 + , gl_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV + , gl_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV + , gl_INTENSITY_FLOAT32_ATI + , gl_CLAMP_TO_BORDER_SGIS + , gl_FIELDS_NV + , gl_MAX_GEOMETRY_OUTPUT_VERTICES + , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER + , gl_INT_SAMPLER_CUBE_EXT + , gl_SOURCE0_RGB_EXT + , gl_DRAW_BUFFER10_ATI + , gl_VERTEX_ATTRIB_ARRAY_INTEGER_EXT + , gl_COPY_WRITE_BUFFER_NV + , gl_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV + , gl_LUMINANCE8_OES + , gl_POST_CONVOLUTION_RED_BIAS_EXT + , gl_HSL_COLOR_KHR + , gl_SAMPLE_MASK_VALUE_NV + , gl_SLUMINANCE8_NV + , gl_ASYNC_MARKER_SGIX + , gl_TEXTURE17 + , gl_SYNC_CL_EVENT_COMPLETE_ARB + , gl_INVARIANT_VALUE_EXT + , gl_BUMP_ROT_MATRIX_SIZE_ATI + , gl_ACTIVE_VARYING_MAX_LENGTH_NV + , gl_DEPTH_COMPONENT16 + , gl_MODELVIEW25_ARB + , gl_SHADER_BINARY_VIV + , gl_VERTEX_ARRAY_STRIDE_EXT + , gl_VERTEX_ATTRIB_ARRAY_POINTER_ARB + , gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB + , gl_MAX_PALETTE_MATRICES_ARB + , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER + , gl_DEPTH_COMPONENT32_ARB + , gl_PRESERVE_ATI + , gl_PIXEL_TEX_GEN_ALPHA_LS_SGIX + , gl_VERTEX_PROGRAM_TWO_SIDE_NV + , gl_MAX_ELEMENTS_INDICES_EXT + , gl_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS + , gl_CONTEXT_LOST + , gl_VERTEX_SUBROUTINE_UNIFORM + , gl_COMPRESSED_SRGB_EXT + , gl_SAMPLER_2D_MULTISAMPLE_ARRAY + , gl_MAX_PROGRAM_ADDRESS_REGISTERS_ARB + , gl_STENCIL_INDEX_OES + , gl_PATH_INITIAL_END_CAP_NV + , gl_INTENSITY32F_ARB + , gl_SAMPLES_PASSED + , gl_INT_IMAGE_2D_RECT_EXT + , gl_CLIP_PLANE2 + , gl_PALETTE8_RGB8_OES + , gl_ALPHA16I_EXT + , gl_VERTEX_ARRAY + , gl_TEXTURE23_ARB + , gl_AMBIENT_AND_DIFFUSE + , gl_MULTISAMPLE_BUFFER_BIT2_QCOM + , gl_LUMINANCE_FLOAT16_ATI + , gl_INDEX_ARRAY_TYPE + , gl_COMPATIBLE_SUBROUTINES + , gl_VERTEX4_BIT_PGI + , gl_FOG_COORD_SRC + , gl_FULL_SUPPORT + , gl_STEREO + , gl_LUMINANCE_ALPHA16UI_EXT + , gl_ONE_MINUS_SRC_COLOR + , gl_MAX_SHADER_STORAGE_BLOCK_SIZE + , gl_REPLICATE_BORDER_HP + , gl_VERTEX_ATTRIB_MAP1_ORDER_APPLE + , gl_CPU_OPTIMIZED_QCOM + , gl_FLOAT16_VEC2_NV + , gl_SAMPLE_ALPHA_TO_ONE_SGIS + , gl_MAP2_VERTEX_ATTRIB12_4_NV + , gl_COMBINER_MUX_SUM_NV + , gl_UNSIGNED_SHORT_5_6_5_REV_EXT + , gl_TEXTURE20_ARB + , gl_DOT3_RGB + , gl_STENCIL_BUFFER_BIT0_QCOM + , gl_LO_SCALE_NV + , gl_FONT_ASCENDER_BIT_NV + , gl_DRAW_BUFFER9_EXT + , gl_UNSIGNED_INT_2_10_10_10_REV + , gl_BINNING_CONTROL_HINT_QCOM + , gl_PROGRAM_TEMPORARIES_ARB + , gl_MODELVIEW27_ARB + , gl_RGBA16F_EXT + , gl_INDEX_ARRAY_TYPE_EXT + , gl_MAX_VERTEX_SHADER_LOCALS_EXT + , gl_TEXTURE_CUBE_MAP_POSITIVE_Z_OES + , gl_COMP_BIT_ATI + , gl_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT + , gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY + , gl_RGB10_A2_EXT + , gl_MAP1_VERTEX_ATTRIB4_4_NV + , gl_FLOAT_VEC3 + , gl_DELETE_STATUS + , gl_PN_TRIANGLES_TESSELATION_LEVEL_ATI + , gl_UNCORRELATED_NV + , gl_RELATIVE_SMALL_CW_ARC_TO_NV + , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT + , gl_RGB_FLOAT16_ATI + , gl_DRAW_BUFFER7_ATI + , gl_COMBINE_ALPHA_ARB + , gl_RESET_NOTIFICATION_STRATEGY_EXT + , gl_DRAW_BUFFER10_NV + , gl_READ_PIXEL_DATA_RANGE_POINTER_NV + , gl_TRANSFORM_FEEDBACK_ACTIVE + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR + , gl_PROGRAM_PIPELINE_BINDING + , gl_SRGB8_ALPHA8 + , gl_COLOR_INDEX16_EXT + , gl_PHONG_WIN + , gl_MAX_TEXTURE_IMAGE_UNITS_NV + , gl_DSDT8_MAG8_NV + , gl_COPY_READ_BUFFER + , gl_RGBA16F + , gl_UNSIGNED_SHORT_5_6_5 + , gl_CLIP_DISTANCE5 + , gl_TEXTURE_BINDING_3D_OES + , gl_IUI_V2F_EXT + , gl_OFFSET_HILO_TEXTURE_RECTANGLE_NV + , gl_ONE_MINUS_CONSTANT_ALPHA + , gl_SMALL_CW_ARC_TO_NV + , gl_IMAGE_BINDING_NAME_EXT + , gl_CURRENT_FOG_COORDINATE_EXT + , gl_SKIP_COMPONENTS4_NV + , gl_CLIP_PLANE5_IMG + , gl_PATH_MITER_LIMIT_NV + , gl_TEXTURE_3D + , gl_MAX_COMPUTE_SHADER_STORAGE_BLOCKS + , gl_COMPRESSED_LUMINANCE_LATC1_EXT + , gl_MULTISAMPLE_BUFFER_BIT3_QCOM + , gl_SECONDARY_COLOR_ARRAY_SIZE + , gl_RENDERBUFFER_SAMPLES_IMG + , gl_R1UI_C4UB_V3F_SUN + , gl_PIXEL_TEX_GEN_ALPHA_MS_SGIX + , gl_TRANSFORM_FEEDBACK_NV + , gl_FRAMEBUFFER_RENDERABLE + , gl_HARDLIGHT_KHR + , gl_SOURCE0_ALPHA + , gl_COMBINER4_NV + , gl_ELEMENT_ARRAY_BUFFER_BINDING + , gl_TEXTURE10_ARB + , gl_CURRENT_BINORMAL_EXT + , gl_REG_26_ATI + , gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS + , gl_ACTIVE_VARYINGS_NV + , gl_COMBINE_RGB_EXT + , gl_FRAMEBUFFER_COMPLETE_EXT + , gl_MAX_WIDTH + , gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS + , gl_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT + , gl_COLORDODGE_KHR + , gl_PATH_GEN_COEFF_NV + , gl_FLOAT_MAT4x3_NV + , gl_MINMAX_SINK + , gl_FRONT_AND_BACK + , gl_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT + , gl_MATRIX1_ARB + , gl_VIEWPORT_SUBPIXEL_BITS + , gl_MAX_DUAL_SOURCE_DRAW_BUFFERS + , gl_BOOL_VEC3_ARB + , gl_OPERAND2_ALPHA + , gl_MAX_DEBUG_GROUP_STACK_DEPTH + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR + , gl_PROGRAM + , gl_WEIGHT_ARRAY_SIZE_ARB + , gl_BUFFER_GPU_ADDRESS_NV + , gl_ALPHA8_EXT + , gl_RGBA_MODE + , gl_DUDV_ATI + , gl_VERTEX_ATTRIB_ARRAY_INTEGER_NV + , gl_RESAMPLE_DECIMATE_OML + , gl_QUERY_BUFFER + , gl_SINGLE_COLOR + , gl_INT_SAMPLER_RENDERBUFFER_NV + , gl_MAT_COLOR_INDEXES_BIT_PGI + , gl_MODELVIEW3_ARB + , gl_TESS_CONTROL_OUTPUT_VERTICES_EXT + , gl_PIXEL_MAP_B_TO_B + , gl_VERTEX_ATTRIB_MAP1_SIZE_APPLE + , gl_DOUBLE_MAT3 + , gl_MAX_COMBINED_UNIFORM_BLOCKS + , gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT + , gl_MAX_VERTEX_IMAGE_UNIFORMS + , gl_QUERY_RESULT_NO_WAIT_AMD + , gl_MODELVIEW26_ARB + , gl_DEPTH_COMPONENT24_OES + , gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB + , gl_EVAL_VERTEX_ATTRIB6_NV + , gl_OUTPUT_TEXTURE_COORD24_EXT + , gl_COMPUTE_SHADER_BIT + , gl_MATRIX7_ARB + , gl_RENDER + , gl_VERTEX_ATTRIB_BINDING + , gl_VIDEO_CAPTURE_TO_422_SUPPORTED_NV + , gl_TEXTURE_COORD_ARRAY_ADDRESS_NV + , gl_UNSIGNED_INT_SAMPLER_2D_RECT + , gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB + , gl_GENERATE_MIPMAP_SGIS + , gl_SHADER_IMAGE_STORE + , gl_INT_SAMPLER_3D + , gl_PROGRAM_BINARY_LENGTH + , gl_REFERENCED_BY_GEOMETRY_SHADER + , gl_SHADER_IMAGE_ACCESS_BARRIER_BIT + , gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS + , gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT + , gl_LINE + , gl_RENDERBUFFER_ALPHA_SIZE_EXT + , gl_INTENSITY + , gl_AFFINE_3D_NV + , gl_ADD_SIGNED_ARB + , gl_OBJECT_COMPILE_STATUS_ARB + , gl_RGB8I_EXT + , gl_COMMAND_BARRIER_BIT + , gl_COMBINE_RGB + , gl_VERTEX_SHADER_BINDING_EXT + , gl_SECONDARY_COLOR_ARRAY_SIZE_EXT + , gl_DEPTH_EXT + , gl_LINE_RESET_TOKEN + , gl_SMOOTH_POINT_SIZE_GRANULARITY + , gl_SAMPLER_2D_MULTISAMPLE + , gl_PRIMARY_COLOR_ARB + , gl_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY + , gl_GEOMETRY_TEXTURE + , gl_SOURCE1_RGB_ARB + , gl_COLOR_ATTACHMENT6_EXT + , gl_PIXEL_MAP_I_TO_I + , gl_EVAL_VERTEX_ATTRIB7_NV + , gl_OP_MIN_EXT + , gl_RGB16F_EXT + , gl_TEXTURE_CUBE_MAP_POSITIVE_Z + , gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS + , gl_PACK_RESAMPLE_SGIX + , gl_GREEN_BIAS + , gl_DEPTH_STENCIL_NV + , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER + , gl_CON_29_ATI + , gl_COLOR_ARRAY_STRIDE_EXT + , gl_ISOLINES_EXT + , gl_MODELVIEW4_ARB + , gl_LINES_ADJACENCY + , gl_PATH_FILL_MASK_NV + , gl_HISTOGRAM_LUMINANCE_SIZE + , gl_TEXTURE_BINDING_RENDERBUFFER_NV + , gl_PIXEL_UNPACK_BUFFER_EXT + , gl_RENDERBUFFER_GREEN_SIZE + , gl_PASS_THROUGH_NV + , gl_GEOMETRY_VERTICES_OUT_EXT + , gl_EVAL_VERTEX_ATTRIB12_NV + , gl_SMOOTH_QUADRATIC_CURVE_TO_NV + , gl_TEXTURE_BUFFER_SIZE + , gl_READ_PIXEL_DATA_RANGE_NV + , gl_ALIASED_LINE_WIDTH_RANGE + , gl_TRACK_MATRIX_NV + , gl_COLOR_ARRAY_LIST_STRIDE_IBM + , gl_WEIGHT_ARRAY_POINTER_ARB + , gl_SMOOTH_LINE_WIDTH_GRANULARITY + , gl_CLIP_DISTANCE6 + , gl_FRAMEBUFFER_BINDING + , gl_EVAL_VERTEX_ATTRIB4_NV + , gl_CURRENT_SECONDARY_COLOR_EXT + , gl_IMAGE_CLASS_2_X_32 + , gl_PERSPECTIVE_CORRECTION_HINT + , gl_NATIVE_GRAPHICS_BEGIN_HINT_PGI + , gl_SATURATE_BIT_ATI + , gl_FONT_UNITS_PER_EM_BIT_NV + , gl_EVAL_VERTEX_ATTRIB3_NV + , gl_R16UI + , gl_OUTPUT_TEXTURE_COORD17_EXT + , gl_TEXTURE_MULTI_BUFFER_HINT_SGIX + , gl_SKIP_MISSING_GLYPH_NV + , gl_MIRROR_CLAMP_TO_EDGE_EXT + , gl_TEXTURE_TYPE_QCOM + , gl_RGB5_A1 + , gl_UNIFORM_BARRIER_BIT_EXT + , gl_MULTISAMPLE + , gl_SAMPLES_ARB + , gl_RGBA_INTEGER + , gl_STENCIL_COMPONENTS + , gl_DEBUG_SEVERITY_LOW + , gl_TEXTURE_COMPARE_SGIX + , gl_COLOR_ARRAY_LIST_IBM + , gl_COMPRESSED_SIGNED_RED_RGTC1 + , gl_MATRIX3_NV + , gl_MAX_FRAGMENT_UNIFORM_BLOCKS + , gl_INT_SAMPLER_3D_EXT + , gl_MODELVIEW19_ARB + , gl_SWIZZLE_STRQ_DQ_ATI + , gl_COMBINE_ARB + , gl_FRAGMENT_COLOR_EXT + , gl_RENDERBUFFER_WIDTH + , gl_LUMINANCE4_EXT + , gl_UNSIGNED_INT_SAMPLER_2D_EXT + , gl_RGB_SCALE_EXT + , gl_PIXEL_MAP_I_TO_R + , gl_DOT4_ATI + , gl_MAP1_VERTEX_ATTRIB7_4_NV + , gl_VERTEX_ATTRIB_ARRAY_ENABLED_ARB + , gl_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB + , gl_POST_COLOR_MATRIX_BLUE_SCALE_SGI + , gl_NUM_VIRTUAL_PAGE_SIZES_ARB + , gl_RENDERBUFFER_FREE_MEMORY_ATI + , gl_FRAMEBUFFER_DEFAULT_LAYERS + , gl_COMPUTE_SUBROUTINE + , gl_PROGRAM_TEX_INSTRUCTIONS_ARB + , gl_SIGNALED_APPLE + , gl_MULTISAMPLE_3DFX + , gl_TEXTURE_INDEX_SIZE_EXT + , gl_LAYOUT_LINEAR_INTEL + , gl_LERP_ATI + , gl_FACTOR_MAX_AMD + , gl_MATRIX2_ARB + , gl_EQUAL + , gl_COLOR_ATTACHMENT0_OES + , gl_MAX_COLOR_MATRIX_STACK_DEPTH_SGI + , gl_RGB16 + , gl_COLOR_INDEX4_EXT + , gl_PROXY_TEXTURE_CUBE_MAP_EXT + , gl_STENCIL_BACK_FUNC_ATI + , gl_DRAW_BUFFER8_EXT + , gl_DST_ALPHA + , gl_DEBUG_SOURCE_SHADER_COMPILER_KHR + , gl_C4UB_V2F + , gl_INTERNALFORMAT_BLUE_TYPE + , gl_PIXEL_TILE_GRID_DEPTH_SGIX + , gl_DEPTH_BITS + , gl_FLOAT16_VEC3_NV + , gl_ARRAY_OBJECT_OFFSET_ATI + , gl_DOUBLE_MAT2_EXT + , gl_TEXTURE_COLOR_SAMPLES_NV + , gl_NORMAL_ARRAY_EXT + , gl_MIRROR_CLAMP_TO_EDGE_ATI + , gl_EDGE_FLAG_ARRAY_POINTER + , gl_UNSIGNED_INT_24_8_MESA + , gl_IMAGE_COMPATIBILITY_CLASS + , gl_BACK_LEFT + , gl_TESS_EVALUATION_SHADER_INVOCATIONS_ARB + , gl_COLOR_TABLE_BIAS + , gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG + , gl_DARKEN_KHR + , gl_OCCLUSION_TEST_RESULT_HP + , gl_DEBUG_TYPE_POP_GROUP_KHR + , gl_CLAMP_TO_BORDER_ARB + , gl_UNSIGNED_BYTE_2_3_3_REV + , gl_SOURCE2_ALPHA_ARB + , gl_SAMPLE_COVERAGE + , gl_INTERLEAVED_ATTRIBS_EXT + , gl_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL + , gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING + , gl_VERTEX_SHADER + , gl_INDEX_ARRAY_ADDRESS_NV + , gl_QUERY_COUNTER_BITS + , gl_COMPRESSED_RGBA_ASTC_8x6_KHR + , gl_FRAMEBUFFER_BINDING_EXT + , gl_VERTEX_ELEMENT_SWIZZLE_AMD + , gl_DEBUG_CATEGORY_SHADER_COMPILER_AMD + , gl_ARRAY_OBJECT_BUFFER_ATI + , gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES + , gl_RENDERBUFFER_INTERNAL_FORMAT + , gl_VIEW_CLASS_8_BITS + , gl_TEXTURE_CUBE_MAP_POSITIVE_Y_OES + , gl_SHADER_IMAGE_ATOMIC + , gl_MAX_GEOMETRY_OUTPUT_VERTICES_ARB + , gl_COVERAGE_ATTACHMENT_NV + , gl_NUM_PROGRAM_BINARY_FORMATS_OES + , gl_CURRENT_RASTER_TEXTURE_COORDS + , gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS + , gl_PIXEL_MAP_A_TO_A + , gl_TEXTURE_WRAP_T + , gl_LINE_SMOOTH_HINT + , gl_DRAW_BUFFER11_EXT + , gl_OFFSET_TEXTURE_RECTANGLE_SCALE_NV + , gl_LUMINANCE16_SNORM + , gl_PERFQUERY_FLUSH_INTEL + , gl_HISTOGRAM_SINK + , gl_MAP1_VERTEX_ATTRIB15_4_NV + , gl_OUTPUT_TEXTURE_COORD7_EXT + , gl_HISTOGRAM_BLUE_SIZE + , gl_LUMINANCE32F_EXT + , gl_RG16UI + , gl_TEXTURE_ALPHA_MODULATE_IMG + , gl_INT_SAMPLER_2D_RECT + , gl_STENCIL_BACK_WRITEMASK + , gl_PIXEL_TRANSFORM_2D_MATRIX_EXT + , gl_AUX3 + , gl_FRAMEBUFFER_UNSUPPORTED + , gl_MAX_TEXTURE_MAX_ANISOTROPY_EXT + , gl_TEXTURE_DEFORMATION_SGIX + , gl_CON_23_ATI + , gl_CLIP_DISTANCE0 + , gl_COLOR_ATTACHMENT10 + , gl_POINT_SIZE_MAX_EXT + , gl_TEXTURE5 + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR + , gl_PATH_MODELVIEW_MATRIX_NV + , gl_LINE_LOOP + , gl_MODELVIEW17_ARB + , gl_UNSIGNED_INT16_VEC2_NV + , gl_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES + , gl_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS + , gl_DRAW_BUFFER3_EXT + , gl_TEXTURE_SHADOW + , gl_STENCIL_ATTACHMENT + , gl_MAP_STENCIL + , gl_PATH_DASH_ARRAY_COUNT_NV + , gl_BLEND + , gl_UNIFORM_BUFFER_OFFSET_ALIGNMENT + , gl_TEXTURE_TARGET_QCOM + , gl_NORMAL_MAP_OES + , gl_UNSIGNED_SHORT_4_4_4_4_REV_EXT + , gl_TEXTURE20 + , gl_EDGE_FLAG_ARRAY_COUNT_EXT + , gl_SMOOTH + , gl_SHADER_INCLUDE_ARB + , gl_CLAMP_TO_EDGE_SGIS + , gl_COMPRESSED_ALPHA + , gl_TEXTURE_IMAGE_FORMAT + , gl_MAX_FRAMEBUFFER_LAYERS + , gl_WRITEONLY_RENDERING_QCOM + , gl_BACK_RIGHT + , gl_INVARIANT_DATATYPE_EXT + , gl_LINE_TO_NV + , gl_PIXEL_UNPACK_BUFFER_BINDING_ARB + , gl_LIST_BIT + , gl_MAX_ATTRIB_STACK_DEPTH + , gl_FRAGMENT_SHADER + , gl_IMPLEMENTATION_COLOR_READ_FORMAT + , gl_COLOR_TABLE_WIDTH_SGI + , gl_DEBUG_OBJECT_MESA + , gl_EYE_LINE_SGIS + , gl_COMPRESSED_ALPHA_ARB + , gl_DEPTH_BUFFER_BIT7_QCOM + , gl_OPERAND2_RGB_ARB + , gl_PROGRAM_BINARY_ANGLE + , gl_MATRIX_EXT + , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS + , gl_RED_NV + , gl_LIGHT7 + , gl_LOW_FLOAT + , gl_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT + , gl_CON_18_ATI + , gl_UNIFORM_BUFFER_ADDRESS_NV + , gl_VERTEX_ARRAY_BUFFER_BINDING_ARB + , gl_RED_BIT_ATI + , gl_TRACE_TEXTURES_BIT_MESA + , gl_GEOMETRY_SHADER + , gl_VERTEX_ARRAY_ADDRESS_NV + , gl_TIMEOUT_IGNORED_APPLE + , gl_RENDERBUFFER_BINDING + , gl_RGB16F + , gl_TEXTURE_COORD_ARRAY_LENGTH_NV + , gl_MAX_FRAMEBUFFER_LAYERS_EXT + , gl_MODELVIEW23_ARB + , gl_BGR_EXT + , gl_ONE_MINUS_SRC1_COLOR + , gl_VARIANT_ARRAY_EXT + , gl_RGB4 + , gl_RENDERBUFFER_DEPTH_SIZE_OES + , gl_MAX_VARYING_COMPONENTS_EXT + , gl_CURRENT_MATRIX_NV + , gl_T2F_IUI_N3F_V3F_EXT + , gl_SLUMINANCE8 + , gl_MODELVIEW1_MATRIX_EXT + , gl_MODELVIEW29_ARB + , gl_COLOR_ATTACHMENT5_EXT + , gl_DOUBLE_MAT2 + , gl_RGBA12_EXT + , gl_ACCUM_BLUE_BITS + , gl_INVARIANT_EXT + , gl_ACTIVE_UNIFORM_MAX_LENGTH + , gl_FOG_SPECULAR_TEXTURE_WIN + , gl_COLOR_TABLE_SCALE_SGI + , gl_IUI_V3F_EXT + , gl_UNSIGNED_INT_IMAGE_3D_EXT + , gl_MAX_DEBUG_MESSAGE_LENGTH_KHR + , gl_TEXTURE_CUBE_MAP_POSITIVE_Y + , gl_DOUBLE_VEC2 + , gl_MAX_SAMPLE_MASK_WORDS + , gl_DEBUG_OUTPUT + , gl_OBJECT_SHADER_SOURCE_LENGTH_ARB + , gl_R32F_EXT + , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV + , gl_COPY_WRITE_BUFFER_BINDING + , gl_TEXTURE15_ARB + , gl_UNIFORM_BLOCK_NAME_LENGTH + , gl_COLOR_ATTACHMENT4_NV + , gl_DST_OVER_NV + , gl_ATOMIC_COUNTER_BUFFER + , gl_MAP1_VERTEX_ATTRIB12_4_NV + , gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB + , gl_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV + , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE + , gl_RGB_RAW_422_APPLE + , gl_MAX_RECTANGLE_TEXTURE_SIZE + , gl_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT + , gl_FRAGMENT_COLOR_MATERIAL_SGIX + , gl_POST_COLOR_MATRIX_RED_SCALE_SGI + , gl_VIBRANCE_SCALE_NV + , gl_POINT_FADE_THRESHOLD_SIZE + , gl_QUERY_NO_WAIT_NV + , gl_FRAGMENT_SHADER_DERIVATIVE_HINT_OES + , gl_RESAMPLE_REPLICATE_OML + , gl_RENDERBUFFER_BINDING_ANGLE + , gl_R1UI_V3F_SUN + , gl_CONVOLUTION_2D + , gl_OBJECT_TYPE + , gl_MAX_MAP_TESSELLATION_NV + , gl_DOUBLE_MAT4x3_EXT + , gl_MULTISAMPLE_BUFFER_BIT4_QCOM + , gl_UNSIGNED_INT64_AMD + , gl_MAX_PATCH_VERTICES + , gl_TEXTURE_COMPONENTS + , gl_ELEMENT_ARRAY_POINTER_APPLE + , gl_COLOR_ATTACHMENT6_NV + , gl_MODELVIEW_PROJECTION_NV + , gl_STATIC_ATI + , gl_TEXTURE_CUBE_MAP_NEGATIVE_Z + , gl_CONVOLUTION_BORDER_MODE + , gl_2PASS_0_SGIS + , gl_GREEN_INTEGER_EXT + , gl_DEBUG_TYPE_OTHER + , gl_FRAMEBUFFER_SRGB_EXT + , gl_COLOR_WRITEMASK + , gl_TANGENT_ARRAY_EXT + , gl_FONT_TARGET_UNAVAILABLE_NV + , gl_FONT_UNAVAILABLE_NV + , gl_COMBINER2_NV + , gl_TEXTURE22_ARB + , gl_PATH_INITIAL_DASH_CAP_NV + , gl_SWIZZLE_STRQ_ATI + , gl_OBJECT_LINE_SGIS + , gl_MAX_NUM_ACTIVE_VARIABLES + , gl_COLOR_ATTACHMENT3_EXT + , gl_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI + , gl_SCREEN_KHR + , gl_ZOOM_X + , gl_PROGRAM_MATRIX_EXT + , gl_TEXTURE_VIEW + , gl_NEGATIVE_ONE_TO_ONE + , gl_CONVOLUTION_1D_EXT + , gl_CLAMP_READ_COLOR + , gl_REFLECTION_MAP + , gl_PROXY_HISTOGRAM + , gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS + , gl_HALF_FLOAT_ARB + , gl_LINE_QUALITY_HINT_SGIX + , gl_MAP_WRITE_BIT_EXT + , gl_PIXEL_TRANSFORM_2D_EXT + , gl_INCR + , gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES + , gl_LUMINANCE_FLOAT32_ATI + , gl_EVAL_VERTEX_ATTRIB11_NV + , gl_TEXTURE_COORD_ARRAY_SIZE + , gl_IMAGE_BINDING_LEVEL_EXT + , gl_RGBA16I_EXT + , gl_T2F_IUI_N3F_V2F_EXT + , gl_MIN_PROGRAM_TEXEL_OFFSET_NV + , gl_EQUIV + , gl_TEXTURE_BINDING_CUBE_MAP_ARB + , gl_DRAW_BUFFER1_NV + , gl_INTERLACE_READ_OML + , gl_TEXTURE15 + , gl_NAND + , gl_VERTEX_ARRAY_RANGE_APPLE + , gl_CONDITION_SATISFIED_APPLE + , gl_DISPATCH_INDIRECT_BUFFER_BINDING + , gl_RG16I + , gl_EYE_RADIAL_NV + , gl_SLUMINANCE_ALPHA_EXT + , gl_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL + , gl_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT + , gl_RG32F + , gl_SRC1_ALPHA + , gl_RGBA2 + , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES + , gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT + , gl_TEXTURE_COORD_ARRAY_STRIDE_EXT + , gl_OUTPUT_TEXTURE_COORD10_EXT + , gl_DEPTH_ATTACHMENT + , gl_NORMAL_ARRAY_POINTER_EXT + , gl_OPERAND0_ALPHA_ARB + , gl_COMPRESSED_LUMINANCE_ARB + , gl_LIST_PRIORITY_SGIX + , gl_BOUNDING_BOX_NV + , gl_PATCH_VERTICES_EXT + , gl_COPY_INVERTED + , gl_FRAMEBUFFER_BARRIER_BIT_EXT + , gl_OBJECT_ACTIVE_ATTRIBUTES_ARB + , gl_DISCRETE_AMD + , gl_DOT3_RGBA_ARB + , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES + , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES + , gl_SET + , gl_TEXTURE_MAX_ANISOTROPY_EXT + , gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 + , gl_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB + , gl_MAP2_GRID_DOMAIN + , gl_RENDERBUFFER_SAMPLES + , gl_MAX_TEXTURE_LOD_BIAS + , gl_DEPTH_PASS_INSTRUMENT_SGIX + , gl_TEXTURE_COORD_NV + , gl_PROGRAM_ERROR_POSITION_NV + , gl_RENDERBUFFER_RED_SIZE_EXT + , gl_INDEX_OFFSET + , gl_CURRENT_FOG_COORD + , gl_MIRRORED_REPEAT + , gl_MAP_INVALIDATE_BUFFER_BIT + , gl_MATRIX_INDEX_ARRAY_OES + , gl_DRAW_BUFFER6_ATI + , gl_INTENSITY12 + , gl_FLOAT_RGBA_NV + , gl_SMOOTH_POINT_SIZE_RANGE + , gl_COLOR_BUFFER_BIT1_QCOM + , gl_TEXT_FRAGMENT_SHADER_ATI + , gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT + , gl_CLIP_PLANE3 + , gl_NAMED_STRING_TYPE_ARB + , gl_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB + , gl_TEXTURE_VIEW_MIN_LEVEL + , gl_SWIZZLE_STQ_ATI + , gl_RGBA_FLOAT_MODE_ARB + , gl_RG8UI + , gl_FRAGMENT_DEPTH + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR + , gl_MULTISAMPLE_SGIS + , gl_PROXY_TEXTURE_1D + , gl_MODELVIEW0_ARB + , gl_LINE_STRIP_ADJACENCY_EXT + , gl_RGBA16UI + , gl_SRC_ATOP_NV + , gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE + , gl_REG_30_ATI + , gl_4PASS_3_EXT + , gl_INT_IMAGE_3D_EXT + , gl_SYSTEM_FONT_NAME_NV + , gl_DRAW_BUFFER6 + , gl_RG32I + , gl_COLOR_BUFFER_BIT3_QCOM + , gl_CURRENT_OCCLUSION_QUERY_ID_NV + , gl_INTERNALFORMAT_STENCIL_SIZE + , gl_STATIC_DRAW_ARB + , gl_COMPRESSED_SRGB_ALPHA_EXT + , gl_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI + , gl_PALETTE8_RGBA4_OES + , gl_FOG_START + , gl_DEBUG_TYPE_POP_GROUP + , gl_DRAW_BUFFER14_ATI + , gl_IMAGE_1D_ARRAY + , gl_RELATIVE_LARGE_CCW_ARC_TO_NV + , gl_FONT_MAX_ADVANCE_HEIGHT_BIT_NV + , gl_EXCLUSION_NV + , gl_FONT_X_MAX_BOUNDS_BIT_NV + , gl_PIXEL_TEX_GEN_Q_FLOOR_SGIX + , gl_DEPTH_BUFFER_BIT2_QCOM + , gl_UNPACK_FLIP_Y_WEBGL + , gl_COLOR_ATTACHMENT15_NV + , gl_RG16F_EXT + , gl_PRIMARY_COLOR + , gl_UNIFORM_BLOCK_DATA_SIZE + , gl_INTERNALFORMAT_STENCIL_TYPE + , gl_COLOR_MATRIX_STACK_DEPTH_SGI + , gl_AND + , gl_GEOMETRY_INPUT_TYPE_ARB + , gl_SAMPLER_BUFFER + , gl_COLOR_BUFFER_BIT2_QCOM + , gl_MAX_CLIP_DISTANCES + , gl_OUTPUT_TEXTURE_COORD25_EXT + , gl_SLIM8U_SGIX + , gl_OP_DOT4_EXT + , gl_INFO_LOG_LENGTH + , gl_REG_25_ATI + , gl_MAX_PROGRAM_CALL_DEPTH_NV + , gl_VIRTUAL_PAGE_SIZE_INDEX_ARB + , gl_MAX_PROGRAM_RESULT_COMPONENTS_NV + , gl_RELATIVE_CONIC_CURVE_TO_NV + , gl_CLIP_DISTANCE4 + , gl_UTF8_NV + , gl_INVALID_INDEX + , gl_DOT3_RGBA_IMG + , gl_FRAGMENT_MATERIAL_EXT + , gl_PACK_CMYK_HINT_EXT + , gl_LUMINANCE_ALPHA8I_EXT + , gl_PIXEL_BUFFER_BARRIER_BIT_EXT + , gl_BUFFER_KHR + , gl_STENCIL_BACK_OP_VALUE_AMD + , gl_DST_COLOR + , gl_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT + , gl_ZERO + , gl_COORD_REPLACE + , gl_FRAMEBUFFER_SRGB + , gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_OES + , gl_CONSTANT + , gl_TEXTURE_CONSTANT_DATA_SUNX + , gl_MAX_DEBUG_MESSAGE_LENGTH + , gl_MAX_VARYING_FLOATS + , gl_PLUS_NV + , gl_UNIFORM_NAME_LENGTH + , gl_SECONDARY_COLOR_ARRAY_STRIDE + , gl_MAP1_VERTEX_ATTRIB13_4_NV + , gl_TRACK_MATRIX_TRANSFORM_NV + , gl_MAX_COMPUTE_UNIFORM_COMPONENTS + , gl_DOUBLE_MAT4 + , gl_TEXTURE_SRGB_DECODE_EXT + , gl_TEXTURE_BORDER_COLOR + , gl_DISPLAY_LIST + , gl_COLOR_ENCODING + , gl_EXPAND_NEGATE_NV + , gl_UNPACK_ROW_LENGTH_EXT + , gl_RGB_SCALE_ARB + , gl_CURRENT_ATTRIB_NV + , gl_TEXTURE25 + , gl_DEPTH + , gl_DRAW_BUFFER2_ARB + , gl_FENCE_CONDITION_NV + , gl_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB + , gl_OP_POWER_EXT + , gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB + , gl_FRAMEBUFFER_DEFAULT + , gl_COLOR_ATTACHMENT13_EXT + , gl_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE + , gl_CUBIC_HP + , gl_GREATER + , gl_OP_MOV_EXT + , gl_RED_SNORM + , gl_ALPHA_MAX_CLAMP_INGR + , gl_VERTEX_ATTRIB_ARRAY_LONG + , gl_DEBUG_SEVERITY_LOW_ARB + , gl_PURGEABLE_APPLE + , gl_MAX_SHININESS_NV + , gl_VERTEX_SHADER_INVARIANTS_EXT + , gl_CLIP_DISTANCE1 + , gl_PROGRAM_NATIVE_PARAMETERS_ARB + , gl_SRC_ALPHA_SATURATE + , gl_COLOR_RENDERABLE + , gl_LINE_STIPPLE + , gl_COMPILE_AND_EXECUTE + , gl_FOG_COORDINATE + , gl_MULTISAMPLE_COVERAGE_MODES_NV + , gl_OUTPUT_TEXTURE_COORD16_EXT + , gl_SCALE_BY_FOUR_NV + , gl_INDEX_ARRAY_BUFFER_BINDING_ARB + , gl_MAX_TEXTURE_IMAGE_UNITS_ARB + , gl_HALF_BIAS_NEGATE_NV + , gl_INT_IMAGE_2D_MULTISAMPLE_EXT + , gl_CON_30_ATI + , gl_SAMPLE_ALPHA_TO_ONE_EXT + , gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB + , gl_STORAGE_CACHED_APPLE + , gl_SAMPLER_2D_SHADOW + , gl_ALPHA_FLOAT16_APPLE + , gl_PERFQUERY_COUNTER_EVENT_INTEL + , gl_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB + , gl_BACK_PRIMARY_COLOR_NV + , gl_PROGRAM_PARAMETERS_ARB + , gl_MIN_SPARSE_LEVEL_AMD + , gl_INT_SAMPLER_1D_ARRAY_EXT + , gl_DOUBLEBUFFER + , gl_NEGATIVE_W_EXT + , gl_VIEW_CLASS_RGTC1_RED + , gl_PROGRAM_KHR + , gl_LINEARDODGE_NV + , gl_NORMALIZED_RANGE_EXT + , gl_BUFFER_SERIALIZED_MODIFY_APPLE + , gl_TEXTURE3_ARB + , gl_INDEX_TEST_FUNC_EXT + , gl_COMPUTE_TEXTURE + , gl_UNSIGNED_INT_IMAGE_BUFFER_EXT + , gl_CON_9_ATI + , gl_RELATIVE_LINE_TO_NV + , gl_TEXTURE_RECTANGLE_NV + , gl_COMPRESSED_RGBA_S3TC_DXT5_ANGLE + , gl_COMPRESSED_RGBA_ASTC_6x5_KHR + , gl_TEXTURE_LUMINANCE_SIZE + , gl_PROJECTION_MATRIX + , gl_VIBRANCE_BIAS_NV + , gl_MAX_VERTEX_ATOMIC_COUNTERS + , gl_FOG_COORD_ARRAY_POINTER + , gl_POLYGON_OFFSET_BIAS_EXT + , gl_DEBUG_SOURCE_OTHER + , gl_LINEAR_SHARPEN_ALPHA_SGIS + , gl_AVERAGE_EXT + , gl_PACK_SKIP_IMAGES_EXT + , gl_BITMAP_TOKEN + , gl_TESSELLATION_MODE_AMD + , gl_POST_CONVOLUTION_COLOR_TABLE_SGI + , gl_MODELVIEW1_EXT + , gl_OPERAND1_RGB_ARB + , gl_4D_COLOR_TEXTURE + , gl_ACTIVE_ATTRIBUTES + , gl_BUFFER_BINDING + , gl_VERTEX_STATE_PROGRAM_NV + , gl_DST_ATOP_NV + , gl_TEXTURE_DEPTH_EXT + , gl_UNSIGNED_INT_VEC4 + , gl_GREEN_INTEGER + , gl_DOUBLE_MAT4x2_EXT + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR + , gl_INDEX_ARRAY_LIST_IBM + , gl_SAMPLER_2D_ARRAY_SHADOW + , gl_COMPRESSED_SRGB_S3TC_DXT1_NV + , gl_COMPRESSED_RGBA_ASTC_4x3x3_OES + , gl_DRAW_BUFFER3_ATI + , gl_MAX_FRAGMENT_UNIFORM_COMPONENTS + , gl_PROXY_TEXTURE_3D_EXT + , gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT + , gl_PATH_COMPUTED_LENGTH_NV + , gl_DEPTH_STENCIL_MESA + , gl_MAT_DIFFUSE_BIT_PGI + , gl_TEXTURE_STENCIL_SIZE + , gl_PATH_PROJECTION_NV + , gl_DUAL_TEXTURE_SELECT_SGIS + , gl_MATRIX14_ARB + , gl_PATH_OBJECT_BOUNDING_BOX_NV + , gl_READ_PIXELS + , gl_TRIANGLE_LIST_SUN + , gl_COMPARE_R_TO_TEXTURE + , gl_INTENSITY8UI_EXT + , gl_DEBUG_OUTPUT_SYNCHRONOUS_ARB + , gl_COLOR_TABLE_GREEN_SIZE + , gl_CURRENT_VERTEX_ATTRIB + , gl_POST_COLOR_MATRIX_GREEN_BIAS + , gl_GPU_MEMORY_INFO_EVICTION_COUNT_NVX + , gl_SUBSAMPLE_DISTANCE_AMD + , gl_SRGB8_EXT + , gl_DETAIL_TEXTURE_FUNC_POINTS_SGIS + , gl_INCR_WRAP_EXT + , gl_UNPACK_COMPRESSED_BLOCK_SIZE + , gl_OBJECT_VALIDATE_STATUS_ARB + , gl_WEIGHT_ARRAY_STRIDE_ARB + , gl_OUTPUT_TEXTURE_COORD3_EXT + , gl_TEXTURE16_ARB + , gl_VIDEO_COLOR_CONVERSION_MATRIX_NV + , gl_EYE_DISTANCE_TO_POINT_SGIS + , gl_TEXTURE_COMPARE_FUNC + , gl_DEPTH_BUFFER_FLOAT_MODE_NV + , gl_TEXTURE_SWIZZLE_G + , gl_DEBUG_TYPE_OTHER_ARB + , gl_TESS_EVALUATION_SHADER_BIT_EXT + , gl_VERTEX_PROGRAM_CALLBACK_DATA_MESA + , gl_INT_SAMPLER_BUFFER_EXT + , gl_OP_CLAMP_EXT + , gl_POINT_SIZE_MIN + , gl_UNSIGNED_BYTE_3_3_2_EXT + , gl_TEXTURE_CLIPMAP_DEPTH_SGIX + , gl_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT + , gl_DOUBLE_VEC4_EXT + , gl_SYNC_CONDITION_APPLE + , gl_MAX_TEXTURE_COORDS_NV + , gl_RELATIVE_QUADRATIC_CURVE_TO_NV + , gl_DEBUG_GROUP_STACK_DEPTH_KHR + , gl_CONTEXT_LOST_KHR + , gl_QUADRATIC_CURVE_TO_NV + , gl_MIN_EXT + , gl_VERTEX_ATTRIB_ARRAY11_NV + , gl_FACTOR_ALPHA_MODULATE_IMG + , gl_MAP1_GRID_DOMAIN + , gl_COLOR_MATRIX_STACK_DEPTH + , gl_IMAGE_PIXEL_FORMAT + , gl_DRAW_BUFFER1_EXT + , gl_UNSIGNED_INT_VEC2 + , gl_QUAD_LUMINANCE8_SGIS + , gl_ELEMENT_ARRAY_UNIFIED_NV + , gl_COLOR_LOGIC_OP + , gl_GREEN_NV + , gl_DEPTH_COMPONENT + , gl_TEXTURE18 + , gl_COMBINER_SUM_OUTPUT_NV + , gl_DUAL_LUMINANCE8_SGIS + , gl_PATH_DASH_OFFSET_RESET_NV + , gl_INT_SAMPLER_BUFFER + , gl_DEBUG_SEVERITY_MEDIUM_ARB + , gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT + , gl_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX + , gl_UNSIGNED_SHORT_15_1_MESA + , gl_LUMINANCE32F_ARB + , gl_TRANSPOSE_NV + , gl_LUMINANCE8_EXT + , gl_WRITE_DISCARD_NV + , gl_STENCIL_BUFFER_BIT5_QCOM + , gl_FOG_END + , gl_DRAW_BUFFER9_NV + , gl_PROVOKING_VERTEX_EXT + , gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS + , gl_2PASS_0_EXT + , gl_MAP_UNSYNCHRONIZED_BIT + , gl_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI + , gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV + , gl_SAMPLER_CUBE_SHADOW + , gl_V2F + , gl_IMAGE_2D_EXT + , gl_LUMINANCE32UI_EXT + , gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT + , gl_SLUMINANCE8_ALPHA8_NV + , gl_MAX_ASYNC_DRAW_PIXELS_SGIX + , gl_POINT_SIZE_ARRAY_TYPE_OES + , gl_SIGNED_LUMINANCE8_ALPHA8_NV + , gl_UNSIGNED_INT_24_8_EXT + , gl_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV + , gl_CONIC_CURVE_TO_NV + , gl_STREAM_DRAW_ARB + , gl_ACTIVE_PROGRAM_EXT + , gl_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB + , gl_PROGRAM_RESIDENT_NV + , gl_COLOR_TABLE_ALPHA_SIZE_SGI + , gl_INT_IMAGE_2D_ARRAY_EXT + , gl_OUTPUT_TEXTURE_COORD15_EXT + , gl_SRC_OUT_NV + , gl_MAP_FLUSH_EXPLICIT_BIT + , gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB + , gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS + , gl_EVAL_VERTEX_ATTRIB2_NV + , gl_PIXEL_TILE_WIDTH_SGIX + , gl_PROXY_TEXTURE_RECTANGLE + , gl_VERTEX_ARRAY_BINDING + , gl_CLIP_PLANE4 + , gl_EVAL_VERTEX_ATTRIB15_NV + , gl_POINT_FADE_THRESHOLD_SIZE_ARB + , gl_UNSIGNED_INT_5_9_9_9_REV_EXT + , gl_DEBUG_GROUP_STACK_DEPTH + , gl_QUERY_WAIT_INVERTED + , gl_DRAW_PIXEL_TOKEN + , gl_OPERAND2_ALPHA_ARB + , gl_STACK_UNDERFLOW + , gl_FLOAT_VEC4_ARB + , gl_OBJECT_INFO_LOG_LENGTH_ARB + , gl_DRAW_BUFFER15_EXT + , gl_PATH_PROJECTION_MATRIX_NV + , gl_ADD_SIGNED + , gl_FRAGMENT_INTERPOLATION_OFFSET_BITS + , gl_VERTEX_SHADER_INSTRUCTIONS_EXT + , gl_NEXT_BUFFER_NV + , gl_TRIANGLE_STRIP_ADJACENCY_ARB + , gl_UNSIGNED_BYTE_2_3_3_REV_EXT + , gl_QUERY_RESULT_NO_WAIT + , gl_SECONDARY_COLOR_ARRAY_ADDRESS_NV + , gl_ALPHA16_SNORM + , gl_COLOR_ARRAY_LENGTH_NV + , gl_SLUMINANCE_EXT + , gl_DOT_PRODUCT_TEXTURE_2D_NV + , gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES + , gl_INT_IMAGE_2D_ARRAY + , gl_POLYGON_OFFSET_LINE + , gl_ONE_MINUS_DST_ALPHA + , gl_ACCUM_BUFFER_BIT + , gl_SOURCE1_ALPHA_ARB + , gl_HISTOGRAM_WIDTH_EXT + , gl_RENDERBUFFER_SAMPLES_EXT + , gl_FRAGMENT_LIGHTING_SGIX + , gl_TEXTURE_WIDTH_QCOM + , gl_TEXTURE_BUFFER_FORMAT_EXT + , gl_VERTEX_PROGRAM_TWO_SIDE + , gl_DEBUG_TYPE_OTHER_KHR + , gl_PRIMARY_COLOR_EXT + , gl_TEXTURE_COMPRESSED_ARB + , gl_PROXY_TEXTURE_1D_ARRAY_EXT + , gl_NORMAL_ARRAY_TYPE + , gl_POST_COLOR_MATRIX_RED_BIAS_SGI + , gl_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB + , gl_VERTEX_ATTRIB_ARRAY7_NV + , gl_MAX_VERTEX_ATTRIB_STRIDE + , gl_COLOR + , gl_YCBCR_422_APPLE + , gl_TESS_GEN_SPACING + , gl_VERTEX_SHADER_INVOCATIONS_ARB + , gl_STENCIL_INDEX4_OES + , gl_COMBINER_CD_DOT_PRODUCT_NV + , gl_VIRTUAL_PAGE_SIZE_Z_ARB + , gl_RIGHT + , gl_ALPHA16F_ARB + , gl_TANGENT_ARRAY_TYPE_EXT + , gl_READ_FRAMEBUFFER_NV + , gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT + , gl_PALETTE4_RGB8_OES + , gl_UNSIGNED_INT_IMAGE_3D + , gl_NORMAL_ARRAY_ADDRESS_NV + , gl_NO_RESET_NOTIFICATION_EXT + , gl_RGB4_S3TC + , gl_AUX1 + , gl_MODELVIEW1_ARB + , gl_OP_NEGATE_EXT + , gl_PACK_COMPRESSED_BLOCK_HEIGHT + , gl_RENDERBUFFER_BINDING_OES + , gl_INT_IMAGE_1D + , gl_TEXTURE_GEQUAL_R_SGIX + , gl_VERTEX_BINDING_DIVISOR + , gl_BLEND_SRC_ALPHA_OES + , gl_READ_BUFFER_NV + , gl_DEBUG_TYPE_ERROR_KHR + , gl_INT_IMAGE_CUBE_EXT + , gl_COMPRESSED_RGBA_ASTC_6x6x6_OES + , gl_IMAGE_MIN_FILTER_HP + , gl_QUAD_ALPHA8_SGIS + , gl_IMAGE_BINDING_LEVEL + , gl_DOT3_RGB_EXT + , gl_SAMPLER_3D_OES + , gl_INT_VEC4 + , gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT + , gl_NO_RESET_NOTIFICATION_ARB + , gl_IMAGE_MAG_FILTER_HP + , gl_COLOR4_BIT_PGI + , gl_MAX_CLIPMAP_DEPTH_SGIX + , gl_DEBUG_CATEGORY_OTHER_AMD + , gl_INT_IMAGE_2D_MULTISAMPLE + , gl_PERFQUERY_COUNTER_DATA_FLOAT_INTEL + , gl_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB + , gl_BINORMAL_ARRAY_EXT + , gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT + , gl_DRAW_BUFFER9_ARB + , gl_DSDT8_NV + , gl_MAP1_VERTEX_ATTRIB9_4_NV + , gl_PROGRAM_OBJECT_ARB + , gl_FONT_UNDERLINE_POSITION_BIT_NV + , gl_SHADER_OPERATION_NV + , gl_QUERY_RESULT_AVAILABLE_EXT + , gl_VIVIDLIGHT_NV + , gl_HSL_HUE_NV + , gl_EMBOSS_MAP_NV + , gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB + , gl_ALL_BARRIER_BITS + , gl_TEXTURE11_ARB + , gl_BOLD_BIT_NV + , gl_SAMPLE_BUFFERS_3DFX + , gl_INTERNALFORMAT_ALPHA_SIZE + , gl_COMPRESSED_RGBA_ASTC_8x8_KHR + , gl_VIRTUAL_PAGE_SIZE_Z_AMD + , gl_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE + , gl_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB + , gl_DRAW_PIXELS_APPLE + , gl_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB + , gl_FRAGMENT_COLOR_MATERIAL_FACE_SGIX + , gl_DRAW_INDIRECT_ADDRESS_NV + , gl_COVERAGE_BUFFER_BIT_NV + , gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT + , gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT + , gl_BLUE_NV + , gl_TEXTURE0_ARB + , gl_DEBUG_SOURCE_THIRD_PARTY_ARB + , gl_TEXTURE_NORMAL_EXT + , gl_TEXTURE_BUFFER_FORMAT_ARB + , gl_OPERAND0_ALPHA + , gl_FLOAT_MAT2x3 + , gl_TEXTURE_BINDING + , gl_INT_SAMPLER_2D + , gl_OR + , gl_INT16_VEC2_NV + , gl_DUAL_ALPHA4_SGIS + , gl_FRAMEZOOM_FACTOR_SGIX + , gl_IMAGE_2D_MULTISAMPLE_ARRAY_EXT + , gl_RGB_INTEGER + , gl_UNSIGNED_INT64_VEC2_NV + , gl_OUTPUT_TEXTURE_COORD21_EXT + , gl_ENABLE_BIT + , gl_POLYGON_OFFSET_EXT + , gl_PIXEL_TEX_GEN_MODE_SGIX + , gl_LINE_SMOOTH + , gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB + , gl_COLOR_TABLE_LUMINANCE_SIZE_SGI + , gl_COLOR_BUFFER_BIT7_QCOM + , gl_PATH_FILL_MODE_NV + , gl_IMAGE_CUBE + , gl_CON_5_ATI + , gl_COLOR_ATTACHMENT2_EXT + , gl_FAILURE_NV + , gl_VERTEX_ARRAY_LIST_STRIDE_IBM + , gl_MAX_SPARSE_TEXTURE_SIZE_ARB + , gl_VERSION_ES_CL_1_1 + , gl_PERFMON_GLOBAL_MODE_QCOM + , gl_DEPTH_COMPONENT32F + , gl_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT + , gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS + , gl_IMAGE_2D_MULTISAMPLE_EXT + , gl_FRAMEBUFFER_OES + , gl_TRANSPOSE_PROJECTION_MATRIX + , gl_BUFFER_MAP_POINTER + , gl_INT_10_10_10_2_OES + , gl_PROGRAM_PIPELINE_OBJECT_EXT + , gl_GEOMETRY_SHADER_INVOCATIONS_EXT + , gl_SPRITE_AXIS_SGIX + , gl_RED_INTEGER_EXT + , gl_COMPRESSED_RGBA_ASTC_10x6_KHR + , gl_TEXTURE_COORD_ARRAY_COUNT_EXT + , gl_SIGNED_RGB_NV + , gl_CW + , gl_PACK_SUBSAMPLE_RATE_SGIX + , gl_TEXTURE14_ARB + , gl_OUTPUT_TEXTURE_COORD26_EXT + , gl_DRAW_BUFFER + , gl_PACK_ROW_BYTES_APPLE + , gl_BLUE_INTEGER_EXT + , gl_STORAGE_CLIENT_APPLE + , gl_ALL_SHADER_BITS + , gl_FOG_COORDINATE_ARRAY_POINTER + , gl_ACTIVE_PROGRAM + , gl_RGBA32F_ARB + , gl_VERTEX_ATTRIB_ARRAY_INTEGER + , gl_MAP2_VERTEX_ATTRIB13_4_NV + , gl_SAMPLER_2D + , gl_QUERY + , gl_GEOMETRY_INPUT_TYPE_EXT + , gl_RGB5_A1_OES + , gl_MATRIX15_ARB + , gl_INT_IMAGE_CUBE_MAP_ARRAY + , gl_STACK_OVERFLOW + , gl_NORMAL_ARRAY_LENGTH_NV + , gl_RENDERBUFFER_BLUE_SIZE_EXT + , gl_TEXTURE_INTENSITY_SIZE_EXT + , gl_POINT_SIZE_MIN_SGIS + , gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW + , gl_BEVEL_NV + , gl_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX + , gl_SIGNED_RGBA_NV + , gl_COLOR_CLEAR_VALUE + , gl_ARRAY_BUFFER + , gl_CLIP_PLANE2_IMG + , gl_POLYGON_OFFSET_UNITS + , gl_COLOR_ARRAY_POINTER_EXT + , gl_POST_COLOR_MATRIX_COLOR_TABLE + , gl_SHADOW_AMBIENT_SGIX + , gl_SAMPLES + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES + , gl_MIRRORED_REPEAT_IBM + , gl_TEXTURE_2D_MULTISAMPLE_ARRAY_OES + , gl_FRAMEBUFFER_DEFAULT_WIDTH + , gl_TEXTURE_GEN_MODE_OES + , gl_BLEND_SRC_ALPHA_EXT + , gl_OUTPUT_COLOR0_EXT + , gl_SLUMINANCE8_ALPHA8 + , gl_SAMPLER_3D_ARB + , gl_UNSIGNED_INT_SAMPLER_3D + , gl_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT + , gl_PATH_FORMAT_SVG_NV + , gl_MAP1_BINORMAL_EXT + , gl_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX + , gl_COLOR_ARRAY_BUFFER_BINDING + , gl_MATRIX_INDEX_ARRAY_TYPE_OES + , gl_PROJECTION_STACK_DEPTH + , gl_AUTO_NORMAL + , gl_FRAGMENT_SHADER_ATI + , gl_SAMPLE_BUFFERS_EXT + , gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT + , gl_UNSIGNED_INT_10_10_10_2 + , gl_COMPRESSED_RG11_EAC_OES + , gl_LUMINANCE8I_EXT + , gl_VERTEX_ATTRIB_ARRAY13_NV + , gl_UNIFORM_BUFFER_SIZE + , gl_TEXTURE2_ARB + , gl_COMPRESSED_RGBA_BPTC_UNORM_ARB + , gl_POLYGON + , gl_CLIENT_MAPPED_BUFFER_BARRIER_BIT + , gl_ELEMENT_ARRAY_BUFFER_BINDING_ARB + , gl_SAMPLE_BUFFERS_ARB + , gl_RGBA4_DXT5_S3TC + , gl_STREAM_READ + , gl_STATIC_READ + , gl_MAX_FRAGMENT_ATOMIC_COUNTERS + , gl_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT + , gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST + , gl_COUNT_DOWN_NV + , gl_SLUMINANCE + , gl_INNOCENT_CONTEXT_RESET + , gl_DRAW_FRAMEBUFFER_BINDING_NV + , gl_VERTEX_STREAM3_ATI + , gl_TRIANGULAR_NV + , gl_SAMPLER_2D_RECT_ARB + , gl_POST_CONVOLUTION_GREEN_SCALE_EXT + , gl_SKIP_COMPONENTS2_NV + , gl_IMAGE_1D + , gl_ATTRIB_ARRAY_TYPE_NV + , gl_ORDER + , gl_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB + , gl_RGB4_EXT + , gl_COMPRESSED_TEXTURE_FORMATS_ARB + , gl_STENCIL_INDEX16_EXT + , gl_OP_RECIP_SQRT_EXT + , gl_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS + , gl_MAX_PROGRAM_TEXEL_OFFSET + , gl_POST_TEXTURE_FILTER_BIAS_SGIX + , gl_RGB32F_EXT + , gl_SURFACE_REGISTERED_NV + , gl_RGBA_FLOAT16_APPLE + , gl_VIDEO_BUFFER_BINDING_NV + , gl_PRIMITIVE_RESTART_INDEX + , gl_DOT3_RGB_ARB + , gl_INT64_VEC4_NV + , gl_DRAW_BUFFER12_ATI + , gl_RESAMPLE_REPLICATE_SGIX + , gl_ALPHA + , gl_MATRIX22_ARB + , gl_DEPTH_TEST + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR + , gl_BLEND_SRC_ALPHA + , gl_MIRROR_CLAMP_ATI + , gl_COMBINER3_NV + , gl_TEXTURE_BINDING_1D_ARRAY_EXT + , gl_MIRROR_CLAMP_TO_BORDER_EXT + , gl_MAP1_INDEX + , gl_VIEW_CLASS_BPTC_FLOAT + , gl_TRANSPOSE_AFFINE_2D_NV + , gl_IMAGE_CLASS_2_X_8 + , gl_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB + , gl_EYE_POINT_SGIS + , gl_TEXTURE_DEPTH_SIZE_ARB + , gl_GLYPH_HAS_KERNING_BIT_NV + , gl_ACTIVE_SUBROUTINES + , gl_MVP_MATRIX_EXT + , gl_READ_FRAMEBUFFER_BINDING + , gl_GUILTY_CONTEXT_RESET_EXT + , gl_ALPHA16UI_EXT + , gl_TEXTURE_SWIZZLE_B_EXT + , gl_RGB16I_EXT + , gl_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB + , gl_VERTEX_WEIGHT_ARRAY_EXT + , gl_SWIZZLE_STR_DR_ATI + , gl_READ_FRAMEBUFFER + , gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI + , gl_COORD_REPLACE_NV + , gl_MAX_CLIP_PLANES + , gl_DRAW_BUFFER0 + , gl_SPRITE_OBJECT_ALIGNED_SGIX + , gl_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX + , gl_CONSERVE_MEMORY_HINT_PGI + , gl_GET_TEXTURE_IMAGE_FORMAT + , gl_MOVE_TO_RESETS_NV + , gl_SHADER_CONSISTENT_NV + , gl_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT + , gl_PACK_ALIGNMENT + , gl_HISTOGRAM_ALPHA_SIZE + , gl_SHARED_TEXTURE_PALETTE_EXT + , gl_MODELVIEW0_MATRIX_EXT + , gl_MAX_NAME_LENGTH + , gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY + , gl_IMAGE_2D + , gl_QUERY_BUFFER_AMD + , gl_BUMP_ENVMAP_ATI + , gl_POINTS + , gl_ARRAY_SIZE + , gl_MAX_CLIP_PLANES_IMG + , gl_TRIANGLE_STRIP_ADJACENCY_EXT + , gl_VERTEX_STREAM6_ATI + , gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR + , gl_TEXTURE22 + , gl_CURRENT_FOG_COORDINATE + , gl_CON_27_ATI + , gl_MAX_VERTEX_UNITS_OES + , gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT + , gl_SIGNED_INTENSITY8_NV + , gl_MAX_EVAL_ORDER + , gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT + , gl_DYNAMIC_READ_ARB + , gl_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV + , gl_FLOAT16_NV + , gl_COMPUTE_SHADER_INVOCATIONS_ARB + , gl_VERTEX_SHADER_OPTIMIZED_EXT + , gl_TEXTURE_LOD_BIAS_EXT + , gl_INT8_VEC3_NV + , gl_4PASS_0_SGIS + , gl_HISTOGRAM_EXT + , gl_ALLOW_DRAW_WIN_HINT_PGI + , gl_TEXTURE_GREEN_SIZE_EXT + , gl_R32I + , gl_REG_22_ATI + , gl_UNSIGNED_INT_ATOMIC_COUNTER + , gl_COLOR_ATTACHMENT2 + , gl_INTENSITY8 + , gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS + , gl_FOG_DENSITY + , gl_RENDERBUFFER_HEIGHT_EXT + , gl_Z_EXT + , gl_TEXTURE_FETCH_BARRIER_BIT + , gl_PROGRAM_BINARY_FORMATS + , gl_UNSIGNED_INT_IMAGE_BUFFER + , gl_OPERAND0_RGB + , gl_COVERAGE_COMPONENT_NV + , gl_NEGATE_BIT_ATI + , gl_DEBUG_TYPE_PUSH_GROUP + , gl_SELECT + , gl_IMAGE_BINDING_ACCESS_EXT + , gl_TEXTURE_GEN_STR_OES + , gl_OCCLUSION_TEST_HP + , gl_BLEND_DST_RGB_OES + , gl_IMAGE_BINDING_NAME + , gl_DUAL_LUMINANCE_ALPHA8_SGIS + , gl_POLYGON_BIT + , gl_POST_COLOR_MATRIX_GREEN_BIAS_SGI + , gl_COLOR_ATTACHMENT8_EXT + , gl_BLUE_BIAS + , gl_EMISSION + , gl_DEPTH_ATTACHMENT_OES + , gl_POLYGON_OFFSET_FACTOR_EXT + , gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT + , gl_TEXTURE_MATERIAL_FACE_EXT + , gl_PN_TRIANGLES_POINT_MODE_CUBIC_ATI + , gl_DRAW_FRAMEBUFFER_ANGLE + , gl_DEPTH_BUFFER_BIT3_QCOM + , gl_DISTANCE_ATTENUATION_EXT + , gl_TRACE_ARRAYS_BIT_MESA + , gl_MOVE_TO_NV + , gl_2PASS_1_SGIS + , gl_DUAL_LUMINANCE4_SGIS + , gl_PRIMITIVES_SUBMITTED_ARB + , gl_TOP_LEVEL_ARRAY_STRIDE + , gl_NORMAL_ARRAY_STRIDE + , gl_TEXTURE_2D_ARRAY_EXT + , gl_UNPACK_COMPRESSED_BLOCK_WIDTH + , gl_TEXTURE_FIXED_SAMPLE_LOCATIONS + , gl_YCRCBA_SGIX + , gl_LOCATION_COMPONENT + , gl_TEXTURE27 + , gl_CONTEXT_FLAG_DEBUG_BIT_KHR + , gl_FOG_COORDINATE_EXT + , gl_DEBUG_CALLBACK_USER_PARAM_KHR + , gl_MIRRORED_REPEAT_OES + , gl_SYNC_GPU_COMMANDS_COMPLETE + , gl_SLUMINANCE8_ALPHA8_EXT + , gl_TEXTURE_BUFFER_OFFSET + , gl_PROXY_COLOR_TABLE + , gl_FIXED + , gl_SRGB8 + , gl_COMPRESSED_RGBA + , gl_IMAGE_BINDING_FORMAT + , gl_MAX_RENDERBUFFER_SIZE_OES + , gl_DEBUG_SOURCE_API + , gl_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH + , gl_CLIP_PLANE3_IMG + , gl_TEXTURE16 + , gl_FRAGMENTS_INSTRUMENT_SGIX + , gl_MATRIX8_ARB + , gl_DOUBLE_MAT2x4 + , gl_DRAW_BUFFER9_ATI + , gl_CURRENT_TEXTURE_COORDS + , gl_DOT_PRODUCT_TEXTURE_3D_NV + , gl_SECONDARY_COLOR_ARRAY_STRIDE_EXT + , gl_UNSIGNED_INT_IMAGE_2D_ARRAY + , gl_FRAMEBUFFER_BARRIER_BIT + , gl_MAX_SAMPLES_IMG + , gl_TESS_CONTROL_SHADER_BIT_EXT + , gl_PROGRAM_NATIVE_TEMPORARIES_ARB + , gl_COMPRESSED_RGB_PVRTC_4BPPV1_IMG + , gl_VERTEX_PROGRAM_ARB + , gl_MAP2_BINORMAL_EXT + , gl_ETC1_RGB8_OES + , gl_PROGRAM_MATRIX_STACK_DEPTH_EXT + , gl_TEXTURE_USAGE_ANGLE + , gl_TEXTURE_MATRIX + , gl_INT_SAMPLER_CUBE_MAP_ARRAY_EXT + , gl_INDEX_ARRAY_STRIDE + , gl_POST_COLOR_MATRIX_BLUE_SCALE + , gl_TESS_CONTROL_OUTPUT_VERTICES + , gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET + , gl_COMPRESSED_RGBA_ASTC_6x6_KHR + , gl_INTERNALFORMAT_SHARED_SIZE + , gl_SOURCE1_RGB_EXT + , gl_STENCIL_PASS_DEPTH_FAIL + , gl_MATRIX_PALETTE_OES + , gl_MIN_FRAGMENT_INTERPOLATION_OFFSET + , gl_DOT3_RGBA_EXT + , gl_CLIP_VOLUME_CLIPPING_HINT_EXT + , gl_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV + , gl_FONT_X_MIN_BOUNDS_BIT_NV + , gl_WRAP_BORDER_SUN + , gl_MAP_INVALIDATE_RANGE_BIT + , gl_PATH_MODELVIEW_NV + , gl_TESS_CONTROL_SHADER + , gl_VERTEX_STREAM1_ATI + , gl_R3_G3_B2 + , gl_LARGE_CW_ARC_TO_NV + , gl_PRIMITIVE_BOUNDING_BOX_EXT + , gl_ALPHA_BIAS + , gl_DST_IN_NV + , gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT + , gl_NUM_FILL_STREAMS_NV + , gl_ATTRIB_ARRAY_POINTER_NV + , gl_SOURCE0_RGB_ARB + , gl_MAX_PROGRAM_TEXEL_OFFSET_EXT + , gl_MATRIX27_ARB + , gl_R11F_G11F_B10F + , gl_ATOMIC_COUNTER_BUFFER_INDEX + , gl_TEXTURE_SWIZZLE_R_EXT + , gl_MAX_ASYNC_READ_PIXELS_SGIX + , gl_ACTIVE_TEXTURE_ARB + , gl_VERTEX_SHADER_LOCAL_CONSTANTS_EXT + , gl_REFERENCE_PLANE_SGIX + , gl_UNPACK_CLIENT_STORAGE_APPLE + , gl_SKIP_DECODE_EXT + , gl_MAP2_VERTEX_ATTRIB10_4_NV + , gl_ALIASED_POINT_SIZE_RANGE + , gl_MATRIX1_NV + , gl_CCW + , gl_SIGNED_RGB_UNSIGNED_ALPHA_NV + , gl_TEXTURE_BUFFER_BINDING_EXT + , gl_LINEAR_ATTENUATION + , gl_FACTOR_MIN_AMD + , gl_POINT_SPRITE_NV + , gl_IMAGE_FORMAT_COMPATIBILITY_TYPE + , gl_QUERY_DEPTH_FAIL_EVENT_BIT_AMD + , gl_MAP2_VERTEX_ATTRIB4_4_NV + , gl_PATCHES_EXT + , gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS + , gl_OUTPUT_TEXTURE_COORD14_EXT + , gl_V3F + , gl_4PASS_2_EXT + , gl_SAMPLES_3DFX + , gl_MINOR_VERSION + , gl_MAX_DEBUG_LOGGED_MESSAGES_ARB + , gl_FUNC_REVERSE_SUBTRACT + , gl_LAYOUT_LINEAR_CPU_CACHED_INTEL + , gl_MULTISAMPLE_BUFFER_BIT1_QCOM + , gl_SIGNED_RGB8_UNSIGNED_ALPHA8_NV + , gl_PATH_COVER_DEPTH_FUNC_NV + , gl_MAX_FRAGMENT_IMAGE_UNIFORMS + , gl_PROXY_TEXTURE_COLOR_TABLE_SGI + , gl_PIXEL_MAP_I_TO_A_SIZE + , gl_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR + , gl_FRAME_NV + , gl_FLOAT_R_NV + , gl_REFLECTION_MAP_EXT + , gl_RG_SNORM + , gl_REPLACE_MIDDLE_SUN + , gl_COMBINER_MAPPING_NV + , gl_ELEMENT_ARRAY_BUFFER_ARB + , gl_SECONDARY_COLOR_ARRAY_LENGTH_NV + , gl_INTERPOLATE_ARB + , gl_POSITION + , gl_PIXEL_MAP_S_TO_S + , gl_READ_ONLY_ARB + , gl_INVALID_FRAMEBUFFER_OPERATION_OES + , gl_3DC_X_AMD + , gl_FRAGMENT_LIGHT2_SGIX + , gl_IMAGE_SCALE_Y_HP + , gl_READ_FRAMEBUFFER_APPLE + , gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES + , gl_INDEX_MATERIAL_PARAMETER_EXT + , gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH + , gl_CUBIC_CURVE_TO_NV + , gl_QUAD_ALPHA4_SGIS + , gl_FORCE_BLUE_TO_ONE_NV + , gl_DOT_PRODUCT_DEPTH_REPLACE_NV + , gl_MAX_VERTEX_OUTPUT_COMPONENTS + , gl_COMPRESSED_RGBA_ASTC_4x4x3_OES + , gl_COLOR_INDEX1_EXT + , gl_RELATIVE_CUBIC_CURVE_TO_NV + , gl_NOR + , gl_CLIPPING_OUTPUT_PRIMITIVES_ARB + , gl_VERTEX_ATTRIB_ARRAY12_NV + , gl_LINE_BIT + , gl_FOG_COORDINATE_ARRAY_STRIDE + , gl_DUP_FIRST_CUBIC_CURVE_TO_NV + , gl_FRAMEBUFFER_INCOMPLETE_FORMATS_OES + , gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS + , gl_PATH_MAX_MODELVIEW_STACK_DEPTH_NV + , gl_FRAGMENT_LIGHT1_SGIX + , gl_PALETTE8_R5_G6_B5_OES + , gl_DUAL_INTENSITY4_SGIS + , gl_TEXTURE_RANGE_LENGTH_APPLE + , gl_TEXTURE_RECTANGLE_ARB + , gl_LUMINANCE16F_EXT + , gl_DEPTH_COMPONENT16_ARB + , gl_BUMP_TARGET_ATI + , gl_MAX_CUBE_MAP_TEXTURE_SIZE_ARB + , gl_DOUBLE_MAT3_EXT + , gl_QUERY_BY_REGION_NO_WAIT_INVERTED + , gl_MAX_PROGRAM_TEX_INDIRECTIONS_ARB + , gl_QUADS + , gl_ALPHA_INTEGER_EXT + , gl_VERTEX_SHADER_BIT_EXT + , gl_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX + , gl_COLOR_MATERIAL_FACE + , gl_LIGHT_MODEL_TWO_SIDE + , gl_INTERLEAVED_ATTRIBS + , gl_RGBA16I + , gl_VERTEX_ATTRIB_ARRAY_TYPE_ARB + , gl_DEBUG_SEVERITY_LOW_AMD + , gl_POINT_SPRITE_COORD_ORIGIN + , gl_DRAW_BUFFER8 + , gl_SPOT_DIRECTION + , gl_SAMPLE_COVERAGE_INVERT_ARB + , gl_PERFQUERY_COUNTER_RAW_INTEL + , gl_STRICT_SCISSOR_HINT_PGI + , gl_LUMINANCE16_EXT + , gl_UNPACK_ALIGNMENT + , gl_BIAS_BIT_ATI + , gl_LARGE_CCW_ARC_TO_NV + , gl_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB + , gl_FASTEST + , gl_LUMINANCE8_ALPHA8 + , gl_CONVOLUTION_FILTER_BIAS_EXT + , gl_VIEW_CLASS_S3TC_DXT5_RGBA + , gl_DEPTH32F_STENCIL8_NV + , gl_TRACE_OPERATIONS_BIT_MESA + , gl_QUERY_RESULT_EXT + , gl_TRANSFORM_FEEDBACK_BINDING_NV + , gl_REG_10_ATI + , gl_MATRIX16_ARB + , gl_FONT_HAS_KERNING_BIT_NV + , gl_INNOCENT_CONTEXT_RESET_EXT + , gl_VIDEO_CAPTURE_FRAME_HEIGHT_NV + , gl_NATIVE_GRAPHICS_END_HINT_PGI + , gl_HISTOGRAM_LUMINANCE_SIZE_EXT + , gl_COMBINER0_NV + , gl_COORD_REPLACE_OES + , gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT + , gl_TIMESTAMP_EXT + , gl_MAX_IMAGE_UNITS_EXT + , gl_POINT_SIZE_MAX_ARB + , gl_DEPTH_WRITEMASK + , gl_FOG_COORDINATE_ARRAY_STRIDE_EXT + , gl_BUMP_NUM_TEX_UNITS_ATI + , gl_INT_SAMPLER_1D_EXT + , gl_INDEX_MODE + , gl_422_EXT + , gl_ATOMIC_COUNTER_BUFFER_START + , gl_GPU_ADDRESS_NV + , gl_REG_19_ATI + , gl_IMAGE_BUFFER + , gl_HISTOGRAM_GREEN_SIZE + , gl_VERTEX_ATTRIB_ARRAY_ADDRESS_NV + , gl_INTENSITY8_SNORM + , gl_DEBUG_TYPE_MARKER + , gl_VERTEX_PROGRAM_TWO_SIDE_ARB + , gl_INDEX_MATERIAL_FACE_EXT + , gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB + , gl_CMYKA_EXT + , gl_MAP_ATTRIB_V_ORDER_NV + , gl_OFFSET_HILO_TEXTURE_2D_NV + , gl_CALLIGRAPHIC_FRAGMENT_SGIX + , gl_MAX_PROGRAM_PARAMETERS_ARB + , gl_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV + , gl_MAP_READ_BIT + , gl_IMAGE_1D_EXT + , gl_READ_BUFFER + , gl_POST_CONVOLUTION_RED_SCALE + , gl_MATRIX23_ARB + , gl_MAX_SAMPLES_NV + , gl_RGB8_SNORM + , gl_MATRIX5_NV + , gl_UNPACK_SWAP_BYTES + , gl_TABLE_TOO_LARGE + , gl_MIN_SAMPLE_SHADING_VALUE_OES + , gl_SWIZZLE_STQ_DQ_ATI + , gl_BUFFER_IMMUTABLE_STORAGE + , gl_ELEMENT_ARRAY_TYPE_APPLE + , gl_POST_COLOR_MATRIX_BLUE_BIAS_SGI + , gl_PARTIAL_SUCCESS_NV + , gl_LOCAL_CONSTANT_EXT + , gl_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB + , gl_GEOMETRY_DEFORMATION_SGIX + , gl_SAMPLER_CUBE_MAP_ARRAY_EXT + , gl_STENCIL_BACK_PASS_DEPTH_PASS_ATI + , gl_DISJOINT_NV + , gl_FLOAT_MAT4x3 + , gl_TRANSFORM_FEEDBACK_PAUSED + , gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION + , gl_RG8_EXT + , gl_RECT_NV + , gl_GEOMETRY_OUTPUT_TYPE_ARB + , gl_DEBUG_SOURCE_API_ARB + , gl_COLOR_ATTACHMENT15 + , gl_MAX_VARYING_FLOATS_ARB + , gl_MAX_DRAW_BUFFERS_NV + , gl_VERTEX_BLEND_ARB + , gl_DOUBLE_MAT2x3_EXT + , gl_MAX_DEBUG_LOGGED_MESSAGES_AMD + , gl_VERTICES_SUBMITTED_ARB + , gl_UNSIGNED_SHORT_4_4_4_4_REV_IMG + , gl_STATE_RESTORE + , gl_MAX_COLOR_ATTACHMENTS_EXT + , gl_INDEX_LOGIC_OP + , gl_PRIMITIVE_RESTART_NV + , gl_FLOAT_MAT3x2_NV + , gl_VERTEX_CONSISTENT_HINT_PGI + , gl_LUMINANCE_ALPHA16F_EXT + , gl_FLOAT_VEC2_ARB + , gl_TEXTURE_SWIZZLE_RGBA + , gl_PROGRAM_SEPARABLE_EXT + , gl_COMPRESSED_RGBA_ASTC_10x8_KHR + , gl_DEPTH_ATTACHMENT_EXT + , gl_FRAMEBUFFER_UNSUPPORTED_OES + , gl_OPERAND1_ALPHA + , gl_PIXEL_MAP_I_TO_B_SIZE + , gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT + , gl_EVAL_2D_NV + , gl_GREEN_MIN_CLAMP_INGR + , gl_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS + , gl_VERTEX_ARRAY_RANGE_NV + , gl_CONTEXT_LOST_WEBGL + , gl_MAX_VERTEX_UNIFORM_BLOCKS + , gl_VERTEX_ATTRIB_MAP2_COEFF_APPLE + , gl_TEXTURE_MAX_CLAMP_T_SGIX + , gl_LUMINANCE_SNORM + , gl_PIXEL_UNPACK_BUFFER_BINDING + , gl_RGBA8_SNORM + , gl_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX + , gl_PIXEL_SUBSAMPLE_2424_SGIX + , gl_TEXTURE_GATHER_SHADOW + , gl_VIEWPORT_INDEX_PROVOKING_VERTEX + , gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT + , gl_UNSIGNED_INT_IMAGE_CUBE + , gl_WEIGHT_ARRAY_POINTER_OES + , gl_ALL_ATTRIB_BITS + , gl_PERFQUERY_COUNTER_TIMESTAMP_INTEL + , gl_TESS_EVALUATION_SHADER_EXT + , gl_BUFFER_OBJECT_EXT + , gl_TIMESTAMP + , gl_RGBA_INTEGER_EXT + , gl_RGB16UI + , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT + , gl_SAMPLE_SHADING_OES + , gl_CONVOLUTION_BORDER_COLOR + , gl_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV + , gl_VERTEX_ARRAY_BUFFER_BINDING + , gl_DEPTH_CLAMP_NEAR_AMD + , gl_POLYGON_TOKEN + , gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB + , gl_R8_SNORM + , gl_DS_BIAS_NV + , gl_2X_BIT_ATI + , gl_ALREADY_SIGNALED + , gl_2D + , gl_MAX_VERTEX_UNIFORM_COMPONENTS + , gl_DEBUG_CATEGORY_PERFORMANCE_AMD + , gl_OVERLAY_NV + , gl_ATOMIC_COUNTER_BUFFER_SIZE + , gl_COLOR_ATTACHMENT10_EXT + , gl_COLOR_TABLE_BLUE_SIZE_SGI + , gl_ADD_SIGNED_EXT + , gl_INT_SAMPLER_2D_ARRAY_EXT + , gl_TRANSFORM_FEEDBACK_BUFFER_INDEX + , gl_REFERENCED_BY_TESS_CONTROL_SHADER + , gl_FIELD_LOWER_NV + , gl_POST_COLOR_MATRIX_RED_SCALE + , gl_IMAGE_BUFFER_EXT + , gl_3D_COLOR_TEXTURE + , gl_DEBUG_CALLBACK_FUNCTION_KHR + , gl_SCISSOR_BIT + , gl_IMAGE_TRANSLATE_X_HP + , gl_PIXEL_MAP_I_TO_A + , gl_VERTEX_SUBROUTINE + , gl_TEXTURE4_ARB + , gl_PACK_COMPRESSED_BLOCK_DEPTH + , gl_SHADER_STORAGE_BLOCK + , gl_SIGNED_ALPHA_NV + , gl_BLEND_DST_ALPHA_EXT + , gl_MAP2_VERTEX_ATTRIB9_4_NV + , gl_HILO8_NV + , gl_SHADER_BINARY_FORMATS + , gl_DEBUG_OUTPUT_SYNCHRONOUS + , gl_TEXTURE_GEN_R + , gl_PERFORMANCE_MONITOR_AMD + , gl_INTENSITY_FLOAT16_APPLE + , gl_PROGRAM_PIPELINE + , gl_COLOR_BUFFER_BIT5_QCOM + , gl_MAX_GEOMETRY_VARYING_COMPONENTS_EXT + , gl_DEBUG_TYPE_PORTABILITY_KHR + , gl_RGB16F_ARB + , gl_PRIMITIVES_GENERATED_EXT + , gl_PROGRAM_BINARY_FORMATS_OES + , gl_AMBIENT + , gl_QUERY_BY_REGION_NO_WAIT_NV + , gl_VIEW_CLASS_RGTC2_RG + , gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT + , gl_DRAW_BUFFER2_EXT + , gl_TEXTURE_BUFFER_BINDING + , gl_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT + , gl_OPERAND3_ALPHA_NV + , gl_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV + , gl_LINEAR_SHARPEN_SGIS + , gl_MAP_UNSYNCHRONIZED_BIT_EXT + , gl_MODELVIEW28_ARB + , gl_EDGE_FLAG_ARRAY_LIST_IBM + , gl_PALETTE4_RGB5_A1_OES + , gl_MULTIPLY_KHR + , gl_GPU_OPTIMIZED_QCOM + , gl_FOG_FUNC_POINTS_SGIS + , gl_MAX_IMAGE_SAMPLES + , gl_DRAW_BUFFER3_NV + , gl_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS + , gl_RESET_NOTIFICATION_STRATEGY_ARB + , gl_MAX_TEXTURE_STACK_DEPTH + , gl_INT64_NV + , gl_DEBUG_SOURCE_APPLICATION + , gl_STENCIL_CLEAR_VALUE + , gl_SRC1_COLOR + , gl_LIGHT4 + , gl_PIXEL_PACK_BUFFER_BINDING + , gl_MAX_LIGHTS + , gl_OPERAND1_ALPHA_EXT + , gl_PIXEL_MAP_B_TO_B_SIZE + , gl_COLOR_TABLE_FORMAT_SGI + , gl_MODELVIEW22_ARB + , gl_UNSIGNED_INT64_VEC4_NV + , gl_COLOR_ARRAY_TYPE_EXT + , gl_LOSE_CONTEXT_ON_RESET_EXT + , gl_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV + , gl_TEXTURE_PRIORITY_EXT + , gl_UNPACK_COMPRESSED_SIZE_SGIX + , gl_SEPARATE_ATTRIBS_EXT + , gl_IMAGE_BINDING_LAYERED + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR + , gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE + , gl_READ_ONLY + , gl_TEXTURE_3D_BINDING_OES + , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER + , gl_COVERAGE_ALL_FRAGMENTS_NV + , gl_SRC2_ALPHA + , gl_PRIMITIVE_ID_NV + , gl_VIDEO_COLOR_CONVERSION_MAX_NV + , gl_MAP2_TANGENT_EXT + , gl_LIGHTING + , gl_PROGRAM_UNDER_NATIVE_LIMITS_ARB + , gl_VERTEX_ATTRIB_ARRAY2_NV + , gl_PRESENT_TIME_NV + , gl_PATCH_DEFAULT_INNER_LEVEL + , gl_NEVER + , gl_PATH_STROKE_WIDTH_NV + , gl_INVERT_RGB_NV + , gl_BUFFER_MAP_POINTER_ARB + , gl_MAP2_GRID_SEGMENTS + , gl_INVALID_VALUE + , gl_BLEND_EQUATION_ALPHA_OES + , gl_MAX_RATIONAL_EVAL_ORDER_NV + , gl_VERTEX_ATTRIB_ARRAY10_NV + , gl_UNPACK_IMAGE_DEPTH_SGIS + , gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES + , gl_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS + , gl_TRANSPOSE_PROJECTION_MATRIX_ARB + , gl_REDUCE_EXT + , gl_RGB8UI_EXT + , gl_MAX_CLIENT_ATTRIB_STACK_DEPTH + , gl_RGB9_E5_EXT + , gl_OUTPUT_TEXTURE_COORD18_EXT + , gl_COLOR_ATTACHMENT0_EXT + , gl_ALPHA_SCALE + , gl_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV + , gl_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE + , gl_BLEND_SRC + , gl_TEXTURE_MAX_CLAMP_R_SGIX + , gl_MAX_PROGRAM_TEXEL_OFFSET_NV + , gl_TEXTURE_LOD_BIAS_R_SGIX + , gl_UNSIGNED_INT_SAMPLER_2D + , gl_TEXTURE_FILTER_CONTROL_EXT + , gl_VARIABLE_G_NV + , gl_SELECTION_BUFFER_POINTER + , gl_INT_SAMPLER_1D + , gl_COMBINE_ALPHA + , gl_FONT_Y_MAX_BOUNDS_BIT_NV + , gl_UNIFORM_BARRIER_BIT + , gl_TEXTURE_BLUE_TYPE_ARB + , gl_STENCIL_INDEX16 + , gl_SRC_OVER_NV + , gl_INT_SAMPLER_2D_MULTISAMPLE + , gl_COLOR_TABLE_GREEN_SIZE_SGI + , gl_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV + , gl_TEXTURE_COMPRESSED_IMAGE_SIZE + , gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV + , gl_REFERENCED_BY_TESS_EVALUATION_SHADER + , gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT + , gl_MAX_HEIGHT + , gl_ALPHA32F_ARB + , gl_COLOR_ATTACHMENT13 + , gl_OP_SET_GE_EXT + , gl_RGBA16_EXT + , gl_OPERAND3_RGB_NV + , gl_RENDERBUFFER_BLUE_SIZE_OES + , gl_LUMINANCE_ALPHA_FLOAT16_ATI + , gl_VERTEX_ATTRIB_ARRAY_DIVISOR_NV + , gl_PERFQUERY_COUNTER_DURATION_RAW_INTEL + , gl_MAX_DEPTH + , gl_LINEAR_MIPMAP_NEAREST + , gl_UNSIGNED_INT_8_8_S8_S8_REV_NV + , gl_N3F_V3F + , gl_PACK_MAX_COMPRESSED_SIZE_SGIX + , gl_QUERY_BUFFER_BINDING_AMD + , gl_FOG_MODE + , gl_RGBA32F + , gl_FRAGMENT_SHADER_DERIVATIVE_HINT + , gl_UNPACK_SKIP_ROWS_EXT + , gl_LINES + , gl_SPOT_EXPONENT + , gl_MAX_NUM_COMPATIBLE_SUBROUTINES + , gl_RGBA_FLOAT32_APPLE + , gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT + , gl_BLEND_EQUATION_ALPHA + , gl_PATH_MODELVIEW_STACK_DEPTH_NV + , gl_TEXTURE_SHARED_SIZE_EXT + , gl_RGBA16 + , gl_UNDEFINED_VERTEX_EXT + , gl_PALETTE8_RGB5_A1_OES + , gl_MAX_GEOMETRY_OUTPUT_VERTICES_EXT + , gl_IMAGE_CLASS_11_11_10 + , gl_HISTOGRAM_GREEN_SIZE_EXT + , gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT + , gl_MAX_COMPUTE_IMAGE_UNIFORMS + , gl_MAX_PATCH_VERTICES_EXT + , gl_ISOLINES + , gl_LUMINANCE_ALPHA_SNORM + , gl_PROGRAM_PIPELINE_BINDING_EXT + , gl_FIRST_VERTEX_CONVENTION_EXT + , gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT + , gl_UTF16_NV + , gl_PRESENT_DURATION_NV + , gl_TEXTURE_SAMPLES + , gl_BGR + , gl_CULL_VERTEX_OBJECT_POSITION_EXT + , gl_FRAGMENT_PROGRAM_POSITION_MESA + , gl_FLOAT_RG_NV + , gl_PROXY_TEXTURE_2D_MULTISAMPLE + , gl_CON_21_ATI + , gl_MAX_GEOMETRY_IMAGE_UNIFORMS + , gl_FLOAT_MAT3x4_NV + , gl_BUFFER_VARIABLE + , gl_ANY_SAMPLES_PASSED_EXT + , gl_TEXTURE_GEN_Q + , gl_GEOMETRY_VERTICES_OUT_ARB + , gl_POLYGON_SMOOTH_HINT + , gl_TEXTURE_BINDING_CUBE_MAP_ARRAY + , gl_SEPARABLE_2D_EXT + , gl_VERSION_ES_CL_1_0 + , gl_VERTEX_PROGRAM_PARAMETER_BUFFER_NV + , gl_RED_INTEGER + , gl_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD + , gl_OFFSET_TEXTURE_RECTANGLE_NV + , gl_TEXTURE_COORD_ARRAY_TYPE_EXT + , gl_INT8_NV + , gl_VIDEO_COLOR_CONVERSION_MIN_NV + , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV + , gl_FRAMEBUFFER_ATTACHMENT_ANGLE + , gl_SRC1_RGB + , gl_CON_24_ATI + , gl_DEBUG_CALLBACK_USER_PARAM + , gl_MALI_SHADER_BINARY_ARM + , gl_VIEW_CLASS_16_BITS + , gl_DITHER + , gl_PATH_STROKE_COVER_MODE_NV + , gl_BGR_INTEGER + , gl_TEXTURE_MATERIAL_PARAMETER_EXT + , gl_COMPRESSED_RGBA_ASTC_5x4_KHR + , gl_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT + , gl_POST_CONVOLUTION_GREEN_BIAS_EXT + , gl_PATH_ERROR_POSITION_NV + , gl_SAMPLE_ALPHA_TO_COVERAGE + , gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY + , gl_NUM_COMPATIBLE_SUBROUTINES + , gl_RGBA16UI_EXT + , gl_VERTEX_SHADER_ARB + , gl_RGB + , gl_MAP_PERSISTENT_BIT + , gl_QUERY_COUNTER_BITS_ARB + , gl_BLEND_EQUATION_RGB_OES + , gl_FRAGMENT_SHADER_BIT + , gl_MATRIX_INDEX_ARRAY_ARB + , gl_OUTPUT_TEXTURE_COORD29_EXT + , gl_HISTOGRAM_FORMAT + , gl_MAX_ASYNC_HISTOGRAM_SGIX + , gl_MAX_VERTEX_ATTRIBS_ARB + , gl_SAMPLE_MASK_NV + , gl_COLOR_INDEXES + , gl_QUAD_TEXTURE_SELECT_SGIS + , gl_RG16_SNORM + , gl_ACTIVE_SUBROUTINE_MAX_LENGTH + , gl_LOGIC_OP_MODE + , gl_DEPTH_COMPONENT16_NONLINEAR_NV + , gl_PRIMITIVE_RESTART_INDEX_NV + , gl_UNKNOWN_CONTEXT_RESET + , gl_VBO_FREE_MEMORY_ATI + , gl_TEXTURE_CUBE_MAP_POSITIVE_X_OES + , gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR + , gl_TEXTURE_2D_STACK_MESAX + , gl_DRAW_BUFFER10 + , gl_FLOAT16_VEC4_NV + , gl_SIGNED_HILO16_NV + , gl_BUFFER_MAPPED_OES + , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT + , gl_DRAW_BUFFER5_EXT + , gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB + , gl_NUM_EXTENSIONS + , gl_WARP_SIZE_NV + , gl_TEXTURE23 + , gl_INT_SAMPLER_2D_RECT_EXT + , gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES + , gl_REG_4_ATI + , gl_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG + , gl_FOG_INDEX + , gl_QUADRATIC_ATTENUATION + , gl_COLOR_MATERIAL + , gl_SAMPLE_MASK + , gl_DRAW_FRAMEBUFFER_BINDING_EXT + , gl_MULTISAMPLE_BUFFER_BIT5_QCOM + , gl_DEPTH_STENCIL_OES + , gl_STENCIL_BITS + , gl_CURRENT_VERTEX_ATTRIB_ARB + , gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB + , gl_COORD_REPLACE_ARB + , gl_RGBA32I_EXT + , gl_TEXTURE6 + , gl_FLOAT_RGB16_NV + , gl_TEXTURE_IMMUTABLE_FORMAT + , gl_ZERO_EXT + , gl_SOFTLIGHT_NV + , gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT + , gl_TEXTURE_BASE_LEVEL + , gl_COMPRESSED_SRGB_ALPHA + , gl_TEXTURE18_ARB + , gl_AND_INVERTED + , gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT + , gl_ARRAY_BUFFER_ARB + , gl_RGBA32F_EXT + , gl_BLEND_EQUATION_RGB_EXT + , gl_FRONT_FACE + , gl_SINGLE_COLOR_EXT + , gl_QUERY_COUNTER_BITS_EXT + , gl_TESS_CONTROL_SHADER_PATCHES_ARB + , gl_SPOT_CUTOFF + , gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB + , gl_OUTPUT_TEXTURE_COORD6_EXT + , gl_COLOR_ATTACHMENT13_NV + , gl_COMPRESSED_RGBA_S3TC_DXT3_EXT + , gl_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV + , gl_TRANSPOSE_TEXTURE_MATRIX + , gl_MULTISAMPLE_ARB + , gl_DEPTH_COMPONENT24 + , gl_PIXEL_MAP_G_TO_G + , gl_NAMED_STRING_LENGTH_ARB + , gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT + , gl_UNIFORM_SIZE + , gl_MODELVIEW21_ARB + , gl_FRAGMENT_LIGHT7_SGIX + , gl_DRAW_BUFFER3_ARB + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES + , gl_UNSIGNED_SHORT + , gl_MULTISAMPLE_BIT_ARB + , gl_FOG + , gl_TEXTURE_COMPARE_MODE + , gl_SPHERE_MAP + , gl_TIMEOUT_EXPIRED_APPLE + , gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT + , gl_PROXY_TEXTURE_1D_ARRAY + , gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT + , gl_TEXTURE_BINDING_CUBE_MAP + , gl_COLOR_ATTACHMENT14 + , gl_STENCIL_BUFFER_BIT + , gl_SIGNALED + , gl_TEXTURE_WIDTH + , gl_EVAL_BIT + , gl_REG_28_ATI + , gl_TEXTURE_BIT + , gl_CONTEXT_ROBUST_ACCESS_EXT + , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV + , gl_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB + , gl_DEPTH_BUFFER_BIT + , gl_TEXCOORD2_BIT_PGI + , gl_POST_CONVOLUTION_RED_SCALE_EXT + , gl_QUERY_KHR + , gl_PACK_IMAGE_HEIGHT_EXT + , gl_COMPRESSED_RGBA_ASTC_5x5_KHR + , gl_MAX_VERTEX_UNIFORM_COMPONENTS_ARB + , gl_DEPTH_STENCIL_ATTACHMENT + , gl_HSL_HUE_KHR + , gl_ATC_RGB_AMD + , gl_DECR_WRAP + , gl_GEOMETRY_VERTICES_OUT + , gl_OFFSET_TEXTURE_BIAS_NV + , gl_COLOR_ATTACHMENT5_NV + , gl_POINT_SIZE_ARRAY_POINTER_OES + , gl_TEXTURE_COMPARE_FAIL_VALUE_ARB + , gl_RENDERBUFFER_COLOR_SAMPLES_NV + , gl_CON_10_ATI + , gl_IMAGE_ROTATE_ANGLE_HP + , gl_UNIFORM_BUFFER_UNIFIED_NV + , gl_INTENSITY4 + , gl_DEBUG_LOGGED_MESSAGES_KHR + , gl_MINUS_CLAMPED_NV + , gl_BUFFER_SIZE + , gl_SRGB_EXT + , gl_PIXEL_TEX_GEN_Q_ROUND_SGIX + , gl_R16I + , gl_COLOR_COMPONENTS + , gl_TEXTURE_VIEW_NUM_LEVELS + , gl_COLOR_ATTACHMENT11 + , gl_OBJECT_PLANE + , gl_IMAGE_3D_EXT + , gl_MAX_GEOMETRY_INPUT_COMPONENTS + , gl_TEXTURE_COORD_ARRAY_LIST_IBM + , gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS + , gl_CLIENT_ACTIVE_TEXTURE + , gl_MAX_GEOMETRY_VARYING_COMPONENTS_ARB + , gl_OPERAND1_RGB + , gl_POINT_SIZE_ARRAY_OES + , gl_GLYPH_VERTICAL_BEARING_Y_BIT_NV + , gl_MODELVIEW6_ARB + , gl_DEBUG_OUTPUT_SYNCHRONOUS_KHR + , gl_AND_REVERSE + , gl_CLAMP_TO_BORDER_NV + , gl_GUILTY_CONTEXT_RESET_ARB + , gl_INT64_VEC2_NV + , gl_C3F_V3F + , gl_OBJECT_LINEAR_NV + , gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT + , gl_TEXTURE_FLOAT_COMPONENTS_NV + , gl_SOURCE3_ALPHA_NV + , gl_OPERAND2_ALPHA_EXT + , gl_CON_12_ATI + , gl_SYNC_STATUS + , gl_BLEND_SRC_RGB_EXT + , gl_DEBUG_SOURCE_WINDOW_SYSTEM_ARB + , gl_TEXTURE_2D_MULTISAMPLE_ARRAY + , gl_LEFT + , gl_UNSIGNED_INT_SAMPLER_1D + , gl_PIXEL_MAP_I_TO_R_SIZE + , gl_VERTEX_ARRAY_BINDING_OES + , gl_COMBINE_ALPHA_EXT + , gl_TRANSFORM_FEEDBACK_ATTRIBS_NV + , gl_CURRENT_WEIGHT_ARB + , gl_RASTERIZER_DISCARD_NV + , gl_SRC_IN_NV + , gl_OBJECT_DISTANCE_TO_POINT_SGIS + , gl_COMPRESSED_RGB8_ETC2 + , gl_MAX_VERTEX_SHADER_STORAGE_BLOCKS + , gl_RGB_SNORM + , gl_INTENSITY4_EXT + , gl_R8I + , gl_MAX_SUBROUTINE_UNIFORM_LOCATIONS + , gl_EDGEFLAG_BIT_PGI + , gl_MAX_FRAMEBUFFER_SAMPLES + , gl_SECONDARY_COLOR_ARRAY_TYPE + , gl_ALL_BARRIER_BITS_EXT + , gl_TEXTURE14 + , gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER + , gl_SRC0_ALPHA + , gl_MODELVIEW16_ARB + , gl_DARKEN_NV + , gl_INTENSITY_EXT + , gl_CURRENT_BIT + , gl_FLOAT_RGBA32_NV + , gl_SHADOW_ATTENUATION_EXT + , gl_COMPRESSED_SRGB8_ETC2 + , gl_DRAW_BUFFER15 + , gl_COMPARE_R_TO_TEXTURE_ARB + , gl_R11F_G11F_B10F_EXT + , gl_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG + , gl_MULTISAMPLE_BUFFER_BIT6_QCOM + , gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT + , gl_FEEDBACK_BUFFER_TYPE + , gl_IMAGE_BINDING_FORMAT_EXT + , gl_PROXY_TEXTURE_2D_EXT + , gl_DEPTH32F_STENCIL8 + , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS + , gl_TESS_EVALUATION_SUBROUTINE + , gl_TEXTURE_LOD_BIAS_T_SGIX + , gl_COVERAGE_COMPONENT4_NV + , gl_TEXTURE6_ARB + , gl_MAX_3D_TEXTURE_SIZE_EXT + , gl_TEXTURE_RESIDENT + , gl_FOG_COORD_ARRAY_TYPE + , gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR + , gl_QUERY_BY_REGION_WAIT + , gl_SLUMINANCE_ALPHA + , gl_INT_SAMPLER_CUBE + , gl_UNSIGNED_SHORT_4_4_4_4_REV + , gl_MAX_PROGRAM_NATIVE_PARAMETERS_ARB + , gl_LUMINANCE4_ALPHA4_EXT + , gl_OPERAND0_RGB_ARB + , gl_PROXY_TEXTURE_2D_STACK_MESAX + , gl_TEXTURE_3D_EXT + , gl_STREAM_RASTERIZATION_AMD + , gl_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT + , gl_DEPTH_COMPONENT32_SGIX + , gl_LINE_STRIP + , gl_CON_25_ATI + , gl_SLIM10U_SGIX + , gl_COLOR_INDEX2_EXT + , gl_CON_22_ATI + , gl_DEFORMATIONS_MASK_SGIX + , gl_INVERSE_TRANSPOSE_NV + , gl_MULT + , gl_ATTRIB_ARRAY_STRIDE_NV + , gl_RGBA16_SNORM + , gl_MIN_SAMPLE_SHADING_VALUE + , gl_RG8_SNORM + , gl_OBJECT_ATTACHED_OBJECTS_ARB + , gl_UNPACK_SKIP_PIXELS_EXT + , gl_ACTIVE_VERTEX_UNITS_ARB + , gl_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT + , gl_INTERNALFORMAT_RED_TYPE + , gl_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV + , gl_FLOAT_RGB_NV + , gl_MAP_FLUSH_EXPLICIT_BIT_EXT + , gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS + , gl_HALF_FLOAT_NV + , gl_DEPTH_STENCIL + , gl_PROGRAM_ERROR_POSITION_ARB + , gl_TRACE_ERRORS_BIT_MESA + , gl_STENCIL_OP_VALUE_AMD + , gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES + , gl_COMPRESSED_SIGNED_R11_EAC + , gl_FLOAT_MAT3x2 + , gl_PROGRAM_ERROR_STRING_NV + , gl_VERTEX_ID_NV + , gl_VERTEX_BINDING_OFFSET + , gl_RESTART_SUN + , gl_INT_IMAGE_CUBE_MAP_ARRAY_EXT + , gl_COLOR_INDEX + , gl_TEXTURE31_ARB + , gl_MAX_DRAW_BUFFERS_ARB + , gl_MAX_IMAGE_UNITS + , gl_OUTPUT_TEXTURE_COORD4_EXT + , gl_COLOR_ARRAY_POINTER + , gl_MAX_COLOR_TEXTURE_SAMPLES + , gl_SIGNED_NEGATE_NV + , gl_MAX_GEOMETRY_UNIFORM_BLOCKS + , gl_DEBUG_TYPE_ERROR + , gl_HISTOGRAM_RED_SIZE_EXT + , gl_SECONDARY_COLOR_ARRAY_POINTER_EXT + , gl_UNSIGNALED + , gl_CON_8_ATI + , gl_COMPRESSED_RED + , gl_RGBA2_EXT + , gl_T2F_C3F_V3F + , gl_SECONDARY_COLOR_ARRAY + , gl_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT + , gl_COLOR3_BIT_PGI + , gl_CLIP_DISTANCE3 + , gl_TEXTURE_SWIZZLE_G_EXT + , gl_SAMPLER_CUBE_MAP_ARRAY + , gl_4PASS_3_SGIS + , gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT + , gl_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT + , gl_VERTEX_ARRAY_STRIDE + , gl_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS + , gl_TEXTURE_SWIZZLE_A + , gl_DOUBLE_MAT3x2 + , gl_TEXTURE_UPDATE_BARRIER_BIT_EXT + , gl_SHADING_LANGUAGE_VERSION + , gl_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP + , gl_FIXED_ONLY_ARB + , gl_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI + , gl_CON_19_ATI + , gl_CONTEXT_RELEASE_BEHAVIOR + , gl_ARRAY_BUFFER_BINDING + , gl_UNPACK_COLORSPACE_CONVERSION_WEBGL + , gl_CONVEX_HULL_NV + , gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB + , gl_FIRST_TO_REST_NV + , gl_MAX_TEXTURE_COORDS + , gl_TEXTURE_DEPTH + , gl_LIGHT0 + , gl_VERTEX_STREAM4_ATI + , gl_POST_COLOR_MATRIX_ALPHA_BIAS_SGI + , gl_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS + , gl_SAMPLER_2D_RECT_SHADOW_ARB + , gl_DRAW_BUFFER1_ATI + , gl_SAMPLE_BUFFERS_SGIS + , gl_SIGNED_LUMINANCE_ALPHA_NV + , gl_R16_SNORM + , gl_DRAW_BUFFER13_ATI + , gl_TEXTURE_LIGHT_EXT + , gl_BOOL_ARB + , gl_BGRA_IMG + , gl_SRGB_ALPHA_EXT + , gl_RELATIVE_ROUNDED_RECT2_NV + , gl_LUMINANCE16UI_EXT + , gl_MATRIX7_NV + , gl_INTENSITY16 + , gl_DRAW_INDIRECT_BUFFER + , gl_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM + , gl_MAX_IMAGE_SAMPLES_EXT + , gl_DEBUG_SOURCE_OTHER_ARB + , gl_POINT_BIT + , gl_MAX_VARYING_VECTORS + , gl_SUBTRACT_ARB + , gl_INT_SAMPLER_BUFFER_AMD + , gl_SAMPLE_MASK_INVERT_SGIS + , gl_POINT_DISTANCE_ATTENUATION_ARB + , gl_GREEN_BIT_ATI + , gl_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT + , gl_FRAMEBUFFER + , gl_TEXTURE_COMPRESSION_HINT_ARB + , gl_PROGRAM_INPUT + , gl_SCREEN_NV + , gl_TEXTURE_CUBE_MAP_ARRAY_EXT + , gl_FENCE_STATUS_NV + , gl_MAX_BINDABLE_UNIFORM_SIZE_EXT + , gl_PACK_COMPRESSED_BLOCK_WIDTH + , gl_RELATIVE_VERTICAL_LINE_TO_NV + , gl_POST_COLOR_MATRIX_COLOR_TABLE_SGI + , gl_ALPHA_INTEGER + , gl_MAX_SUBROUTINES + , gl_UNSIGNED_INT_VEC3_EXT + , gl_ELEMENT_ARRAY_ATI + , gl_ONE_MINUS_CONSTANT_COLOR + , gl_MODELVIEW18_ARB + , gl_CONSTANT_ARB + , gl_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV + , gl_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL + , gl_DRAW_BUFFER_EXT + , gl_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT + , gl_FLOAT_MAT2x4_NV + , gl_CULL_VERTEX_EXT + , gl_MATRIX_PALETTE_ARB + , gl_VERTEX_PROGRAM_POINT_SIZE_ARB + , gl_FLOAT_RG16_NV + , gl_CON_1_ATI + , gl_BLEND_EQUATION_RGB + , gl_OP_CROSS_PRODUCT_EXT + , gl_VERTEX_WEIGHT_ARRAY_STRIDE_EXT + , gl_TESS_CONTROL_PROGRAM_NV + , gl_FIXED_ONLY + , gl_4PASS_1_EXT + , gl_SAMPLER_2D_MULTISAMPLE_ARRAY_OES + , gl_UNSIGNED_INT_8_8_8_8_REV + , gl_UNIFORM_BLOCK_ACTIVE_UNIFORMS + , gl_SLUMINANCE_ALPHA_NV + , gl_PROXY_TEXTURE_CUBE_MAP + , gl_IMAGE_CLASS_1_X_32 + , gl_STACK_OVERFLOW_KHR + , gl_COMPRESSED_RGBA_ASTC_5x5x5_OES + , gl_CLOSE_PATH_NV + , gl_PIXEL_COUNT_AVAILABLE_NV + , gl_PATH_DASH_OFFSET_NV + , gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV + , gl_GLOBAL_ALPHA_FACTOR_SUN + , gl_INDEX_ARRAY_COUNT_EXT + , gl_PACK_RESAMPLE_OML + , gl_LAYER_NV + , gl_DRAW_FRAMEBUFFER + , gl_LINEAR_DETAIL_ALPHA_SGIS + , gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT + , gl_EDGE_FLAG_ARRAY + , gl_TEXTURE_DEFORMATION_BIT_SGIX + , gl_SOURCE1_RGB + , gl_TEXTURE_3D_OES + , gl_ALLOW_DRAW_OBJ_HINT_PGI + , gl_PATH_STROKE_BOUNDING_BOX_NV + , gl_HINT_BIT + , gl_VERTICAL_LINE_TO_NV + , gl_MAX_TEXTURE_BUFFER_SIZE_EXT + , gl_MAX_DRAW_BUFFERS_ATI + , gl_R8_EXT + , gl_TEXTURE_COVERAGE_SAMPLES_NV + , gl_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV + , gl_REFERENCED_BY_VERTEX_SHADER + , gl_FLOAT_RG32_NV + , gl_TESSELLATION_FACTOR_AMD + , gl_MAX_PROGRAM_TEMPORARIES_ARB + , gl_COMPRESSED_RGBA_ASTC_12x12_KHR + , gl_PROJECTION + , gl_S + , gl_ALPHA_FLOAT32_APPLE + , gl_LUMINANCE8_ALPHA8_OES + , gl_4_BYTES_NV + , gl_CONST_EYE_NV + , gl_MAT_SPECULAR_BIT_PGI + , gl_TEXTURE1_ARB + , gl_LINE_WIDTH_GRANULARITY + , gl_DRAW_INDIRECT_BUFFER_BINDING + , gl_BLEND_EQUATION + , gl_RGBA8UI_EXT + , gl_NORMALIZE + , gl_LUMINANCE_ALPHA_FLOAT16_APPLE + , gl_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX + , gl_INVERSE_NV + , gl_TEXTURE_SWIZZLE_A_EXT + , gl_DEPTH24_STENCIL8_OES + , gl_UNPACK_COMPRESSED_BLOCK_HEIGHT + , gl_RGBA32UI + , gl_MAP1_COLOR_4 + , gl_MAX_ELEMENTS_VERTICES + , gl_CLIENT_VERTEX_ARRAY_BIT + , gl_TEXTURE_GREEN_TYPE + , gl_TEXTURE_BINDING_BUFFER_ARB + , gl_MAX_RECTANGLE_TEXTURE_SIZE_NV + , gl_INTERNALFORMAT_GREEN_TYPE + , gl_OP_ADD_EXT + , gl_UNSIGNED_INT_24_8 + , gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS + , gl_3D_COLOR + , gl_MODULATE_COLOR_IMG + , gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB + , gl_TEXTURE_CLIPMAP_FRAME_SGIX + , gl_NORMAL_ARRAY_STRIDE_EXT + , gl_R16 + , gl_PIXEL_PACK_BUFFER + , gl_SOFTLIGHT_KHR + , gl_POST_CONVOLUTION_BLUE_SCALE + , gl_INTERLEAVED_ATTRIBS_NV + , gl_COLOR_ATTACHMENT8 + , gl_DEBUG_TYPE_PUSH_GROUP_KHR + , gl_PERFQUERY_COUNTER_DATA_UINT64_INTEL + , gl_MOV_ATI + , gl_PROGRAM_SEPARABLE + , gl_REG_20_ATI + , gl_DOUBLE_VEC3 + , gl_8X_BIT_ATI + , gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY + , gl_MATRIX26_ARB + , gl_PROXY_TEXTURE_RECTANGLE_ARB + , gl_TRANSFORM_HINT_APPLE + , gl_UNPACK_ROW_BYTES_APPLE + , gl_POST_COLOR_MATRIX_ALPHA_SCALE_SGI + , gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB + , gl_ONE_MINUS_CONSTANT_COLOR_EXT + , gl_TEXTURE_BINDING_CUBE_MAP_OES + , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT + , gl_VERTEX_ARRAY_STORAGE_HINT_APPLE + , gl_VERTEX_BINDING_BUFFER + , gl_FRAGMENT_LIGHT0_SGIX + , gl_GLYPH_HORIZONTAL_BEARING_X_BIT_NV + , gl_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT + , gl_SRC2_RGB + , gl_NUM_COMPRESSED_TEXTURE_FORMATS + , gl_OUTPUT_TEXTURE_COORD2_EXT + , gl_DEPTH_TEXTURE_MODE + , gl_SAMPLE_PATTERN_EXT + , gl_ELEMENT_ARRAY_APPLE + , gl_MAX_FOG_FUNC_POINTS_SGIS + , gl_TEXTURE_APPLICATION_MODE_EXT + , gl_COLOR_ARRAY_SIZE_EXT + , gl_VERTEX_SOURCE_ATI + , gl_MAP2_VERTEX_ATTRIB3_4_NV + , gl_LIGHTEN_KHR + , gl_INT_SAMPLER_1D_ARRAY + , gl_UNSIGNED_INT_10F_11F_11F_REV_EXT + , gl_LUMINANCE8 + , gl_ACCUM_ALPHA_BITS + , gl_MINMAX_FORMAT + , gl_NOOP + , gl_READ_FRAMEBUFFER_EXT + , gl_SHADER + , gl_UNSIGNED_INT_10_10_10_2_OES + , gl_TEXTURE_COMPRESSED_BLOCK_WIDTH + , gl_DEBUG_OUTPUT_KHR + , gl_SOURCE0_ALPHA_ARB + , gl_SAMPLER_1D_ARRAY_EXT + , gl_T2F_V3F + , gl_SAMPLE_MASK_SGIS + , gl_CIRCULAR_TANGENT_ARC_TO_NV + , gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS + , gl_MAX_DEBUG_LOGGED_MESSAGES + , gl_SOURCE1_ALPHA + , gl_RGB_422_APPLE + , gl_COLOR_TABLE + , gl_MAP1_TEXTURE_COORD_3 + , gl_DEBUG_SEVERITY_HIGH_AMD + , gl_UNSIGNED_INT + , gl_VERTEX_PROGRAM_CALLBACK_MESA + , gl_BLOCK_INDEX + , gl_FLOAT + , gl_TRACE_PIXELS_BIT_MESA + , gl_BACK + , gl_PATH_JOIN_STYLE_NV + , gl_LUMINANCE_ALPHA16I_EXT + , gl_FLOAT_MAT2 + , gl_SIGNED_IDENTITY_NV + , gl_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA + , gl_DEPTH_PASS_INSTRUMENT_MAX_SGIX + , gl_CLIP_DEPTH_MODE + , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT + , gl_CULL_FACE + , gl_DETAIL_TEXTURE_LEVEL_SGIS + , gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB + , gl_PACK_SKIP_ROWS + , gl_COEFF + , gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT + , gl_NUM_INSTRUCTIONS_PER_PASS_ATI + , gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB + , gl_RGBA8 + , gl_TESS_GEN_VERTEX_ORDER + , gl_TEXTURE_CUBE_MAP + , gl_VERTEX_PRECLIP_HINT_SGIX + , gl_NUM_SHADING_LANGUAGE_VERSIONS + , gl_OUTPUT_TEXTURE_COORD9_EXT + , gl_MAX_PROGRAM_GENERIC_RESULTS_NV + , gl_COLOR_ATTACHMENT7_NV + , gl_OUT_OF_MEMORY + , gl_TEXTURE_COORD_ARRAY_POINTER_EXT + , gl_FLOAT_MAT2_ARB + , gl_COMBINER_AB_DOT_PRODUCT_NV + , gl_INDEX_ARRAY_POINTER_EXT + , gl_WRITE_PIXEL_DATA_RANGE_POINTER_NV + , gl_3D + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES + , gl_UPPER_LEFT + , gl_IMAGE_1D_ARRAY_EXT + , gl_GREEN + , gl_RGB12 + , gl_GEOMETRY_DEFORMATION_BIT_SGIX + , gl_LUMINANCE_ALPHA_FLOAT32_ATI + , gl_INT_SAMPLER_CUBE_MAP_ARRAY + , gl_EVAL_TRIANGULAR_2D_NV + , gl_QUERY_BY_REGION_WAIT_INVERTED + , gl_CONTEXT_ROBUST_ACCESS_KHR + , gl_STREAM_READ_ARB + , gl_INT_IMAGE_1D_ARRAY_EXT + , gl_QUERY_NO_WAIT_INVERTED + , gl_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT + , gl_COLOR_ATTACHMENT4_EXT + , gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR + , gl_LOSE_CONTEXT_ON_RESET + , gl_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM + , gl_REPLACEMENT_CODE_SUN + , gl_422_REV_EXT + , gl_COMPILE_STATUS + , gl_VERTEX_ATTRIB_MAP1_COEFF_APPLE + , gl_TRANSPOSE_COLOR_MATRIX + , gl_COLOR_TABLE_FORMAT + , gl_VERSION_ES_CM_1_1 + , gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE + , gl_BUFFER_STORAGE_FLAGS + , gl_UNSIGNED_NORMALIZED_EXT + , gl_LIGHT_MODEL_SPECULAR_VECTOR_APPLE + , gl_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT + , gl_3_BYTES + , gl_CND0_ATI + , gl_TEXTURE_MAX_LEVEL_APPLE + , gl_POINT + , gl_MODELVIEW11_ARB + , gl_RED_BITS + , gl_PIXEL_TILE_GRID_WIDTH_SGIX + , gl_DRAW_BUFFER7_NV + , gl_OP_SET_LT_EXT + , gl_TEXTURE24_ARB + , gl_TESS_GEN_POINT_MODE + , gl_INTERNALFORMAT_PREFERRED + , gl_VERTEX_SHADER_VARIANTS_EXT + , gl_COMBINER_CD_OUTPUT_NV + , gl_TRANSPOSE_CURRENT_MATRIX_ARB + , gl_MAX_ARRAY_TEXTURE_LAYERS_EXT + , gl_UNSIGNED_SHORT_8_8_MESA + , gl_BLEND_ADVANCED_COHERENT_NV + , gl_VERTEX_ARRAY_EXT + , gl_BOOL_VEC4_ARB + , gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV + , gl_UNSIGNED_SHORT_5_5_5_1 + , gl_SHADE_MODEL + , gl_MIRROR_CLAMP_TO_EDGE + , gl_RGB5_EXT + , gl_TEXTURE_GEN_S + , gl_TEXTURE_COMPRESSED + , gl_FRAMEBUFFER_BLEND + , gl_REPLACE_VALUE_AMD + , gl_YCRCB_SGIX + , gl_UNIFORM_BLOCK_INDEX + , gl_TEXTURE_TOO_LARGE_EXT + , gl_MIRRORED_REPEAT_ARB + , gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER + , gl_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB + , gl_MAX_SAMPLES + , gl_ATTENUATION_EXT + , gl_MIRROR_CLAMP_EXT + , gl_DEBUG_LOGGED_MESSAGES + , gl_DOT3_ATI + , gl_EMBOSS_CONSTANT_NV + , gl_OUTPUT_TEXTURE_COORD11_EXT + , gl_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL + , gl_INDEX + , gl_CURRENT_MATRIX_ARB + , gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS + , gl_MAX_DRAW_BUFFERS_EXT + , gl_ADD_BLEND_IMG + , gl_CLIP_FAR_HINT_PGI + , gl_POST_CONVOLUTION_COLOR_TABLE + , gl_RGBA4_OES + , gl_QUERY_RESULT_AVAILABLE_ARB + , gl_RGB8UI + , gl_DYNAMIC_READ + , gl_TEXTURE_BINDING_2D_MULTISAMPLE + , gl_OBJECT_TYPE_APPLE + , gl_PERCENTAGE_AMD + , gl_LIGHT_MODEL_LOCAL_VIEWER + , gl_SPARE0_PLUS_SECONDARY_COLOR_NV + , gl_OP_INDEX_EXT + , gl_VIEW_CLASS_S3TC_DXT3_RGBA + , gl_TEXTURE_DEPTH_TYPE_ARB + , gl_TEXTURE_ALPHA_SIZE + , gl_YCRCB_422_SGIX + , gl_INDEX_ARRAY_LENGTH_NV + , gl_TRANSPOSE_AFFINE_3D_NV + , gl_MATRIX17_ARB + , gl_SRGB_ALPHA + , gl_MAP_TESSELLATION_NV + , gl_PACK_SKIP_VOLUMES_SGIS + , gl_COLOR_BUFFER_BIT + , gl_REG_6_ATI + , gl_ATOMIC_COUNTER_BUFFER_BINDING + , gl_POST_CONVOLUTION_ALPHA_BIAS + , gl_HARDLIGHT_NV + , gl_INTENSITY16_SNORM + , gl_TEXCOORD1_BIT_PGI + , gl_DEBUG_CALLBACK_FUNCTION + , gl_TEXTURE8_ARB + , gl_DOUBLE_VEC2_EXT + , gl_TRIANGLES_ADJACENCY + , gl_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER + , gl_R16F + , gl_OUTPUT_TEXTURE_COORD19_EXT + , gl_QUAD_LUMINANCE4_SGIS + , gl_SAMPLER_OBJECT_AMD + , gl_COMPRESSED_RGBA_S3TC_DXT3_ANGLE + , gl_UNSIGNED_INT_IMAGE_2D + , gl_ALPHA_TEST + , gl_CONVOLUTION_WIDTH + , gl_SLUMINANCE_NV + , gl_FRAMEBUFFER_UNDEFINED_OES + , gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED + , gl_HALF_FLOAT_OES + , gl_CONVOLUTION_FORMAT_EXT + , gl_FALSE + , gl_ADD_ATI + , gl_STENCIL_BACK_FAIL + , gl_DOUBLE_VEC4 + , gl_STANDARD_FONT_NAME_NV + , gl_ALPHA4_EXT + , gl_EXPAND_NORMAL_NV + , gl_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB + , gl_TRACE_MASK_MESA + , gl_VARIABLE_B_NV + , gl_RGB16_EXT + , gl_TEXTURE + , gl_PIXEL_UNPACK_BUFFER_BINDING_EXT + , gl_IMAGE_CLASS_1_X_8 + , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE + , gl_BOOL_VEC2_ARB + , gl_MAP2_VERTEX_3 + , gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH + , gl_TEXTURE_WRAP_S + , gl_TEXTURE_CUBE_MAP_NEGATIVE_X + , gl_TEXTURE_CUBE_MAP_ARRAY + , gl_TEXTURE_ALPHA_TYPE + , gl_MAX_COLOR_ATTACHMENTS_NV + , gl_MAX_CUBE_MAP_TEXTURE_SIZE + , gl_ANY_SAMPLES_PASSED + , gl_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE + , gl_COLOR_ARRAY_STRIDE + , gl_MULTISAMPLE_BIT_EXT + , gl_VERTEX_ATTRIB_ARRAY_DIVISOR + , gl_UNSIGNED_INT64_VEC3_NV + , gl_WAIT_FAILED_APPLE + , gl_DRAW_BUFFER5_ATI + , gl_MAX_CUBE_MAP_TEXTURE_SIZE_EXT + , gl_ONE_MINUS_CONSTANT_ALPHA_EXT + , gl_UNSIGNED_INT_8_24_REV_MESA + , gl_MAX_PROGRAM_ENV_PARAMETERS_ARB + , gl_MAX_VERTEX_VARYING_COMPONENTS_EXT + , gl_CURRENT_TANGENT_EXT + , gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB + , gl_ALPHA16 + , gl_MAP1_VERTEX_4 + , gl_SAMPLER_CUBE_SHADOW_NV + , gl_SAMPLER_2D_SHADOW_ARB + , gl_PROGRAM_LENGTH_NV + , gl_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM + , gl_IGNORE_BORDER_HP + , gl_DEBUG_SOURCE_SHADER_COMPILER + , gl_TEXTURE_BORDER_VALUES_NV + , gl_FRAGMENT_SUBROUTINE + , gl_MAX_DEPTH_TEXTURE_SAMPLES + , gl_VERTEX_ATTRIB_ARRAY_POINTER + , gl_COLOR_ATTACHMENT7 + , gl_LAST_VERTEX_CONVENTION_EXT + , gl_TEXTURE_LO_SIZE_NV + , gl_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER + , gl_COMPRESSED_RGB8_ETC2_OES + , gl_NORMAL_MAP_NV + , gl_COLOR_ARRAY_COUNT_EXT + , gl_TEXTURE_COMPARE_MODE_EXT + , gl_BINORMAL_ARRAY_TYPE_EXT + , gl_OPERAND0_RGB_EXT + , gl_MAX_VERTEX_VARYING_COMPONENTS_ARB + , gl_PIXEL_MIN_FILTER_EXT + , gl_ACCUM_ADJACENT_PAIRS_NV + , gl_BLEND_DST + , gl_W_EXT + , gl_RENDERBUFFER_COVERAGE_SAMPLES_NV + , gl_STENCIL_FUNC + , gl_MAX_VERTEX_STREAMS + , gl_GEOMETRY_INPUT_TYPE + , gl_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV + , gl_MINMAX_SINK_EXT + , gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER + , gl_DOUBLE_MAT2x3 + , gl_FRACTIONAL_EVEN_EXT + , gl_VERTEX_ARRAY_TYPE_EXT + , gl_BINORMAL_ARRAY_POINTER_EXT + , gl_SAMPLE_MASK_EXT + , gl_TESS_CONTROL_SHADER_EXT + , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT + , gl_TANGENT_ARRAY_STRIDE_EXT + , gl_GET_TEXTURE_IMAGE_TYPE + , gl_OFFSET + , gl_ALL_STATIC_DATA_IBM + , gl_READ_PIXEL_DATA_RANGE_LENGTH_NV + , gl_CONSTANT_COLOR + , gl_UNSIGNED_SHORT_1_5_5_5_REV_EXT + , gl_MATERIAL_SIDE_HINT_PGI + , gl_UNPACK_RESAMPLE_OML + , gl_SAMPLE_SHADING + , gl_OUTPUT_TEXTURE_COORD13_EXT + , gl_MAX_COLOR_MATRIX_STACK_DEPTH + , gl_INT64_VEC3_NV + , gl_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV + , gl_TEXTURE_STACK_DEPTH + , gl_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL + , gl_FRAMEBUFFER_UNSUPPORTED_EXT + , gl_QUERY_TARGET + , gl_LUMINANCE4_ALPHA4 + , gl_TRANSFORM_FEEDBACK_BARRIER_BIT + , gl_RGB32UI + , gl_STATIC_DRAW + , gl_MAX_COMPUTE_UNIFORM_BLOCKS + , gl_PALETTE4_RGBA8_OES + , gl_UNPACK_PREMULTIPLY_ALPHA_WEBGL + , gl_TEXTURE21 + , gl_RGB32I + , gl_MAX_TEXTURE_LOD_BIAS_EXT + , gl_PATH_GEN_COLOR_FORMAT_NV + , gl_RGB10_A2UI + , gl_GREEN_BITS + , gl_POLYGON_MODE + , gl_SUCCESS_NV + , gl_RGBA12 + , gl_PATCHES + , gl_ACCUM + , gl_NUM_PASSES_ATI + , gl_DEBUG_TYPE_ERROR_ARB + , gl_TEXTURE_LIGHTING_MODE_HP + , gl_HISTOGRAM_SINK_EXT + , gl_POINT_SIZE_GRANULARITY + , gl_R32F + , gl_STATIC_COPY + , gl_FOG_COORDINATE_ARRAY_TYPE_EXT + , gl_SPARE0_NV + , gl_3DC_XY_AMD + , gl_LUMINANCE_ALPHA32F_ARB + , gl_VERTEX_ARRAY_RANGE_VALID_NV + , gl_DEPTH_BUFFER_BIT6_QCOM + , gl_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX + , gl_LINE_WIDTH + , gl_FOG_OFFSET_SGIX + , gl_GEOMETRY_SHADER_BIT_EXT + , gl_TEXTURE_BLUE_SIZE + , gl_TEXTURE_SHADER_NV + , gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV + , gl_FRAMEZOOM_SGIX + , gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT + , gl_DEPTH_RENDERABLE + , gl_MAX_TEXTURE_BUFFER_SIZE + , gl_COLOR_ALPHA_PAIRING_ATI + , gl_PACK_REVERSE_ROW_ORDER_ANGLE + , gl_VERTEX_ATTRIB_ARRAY_NORMALIZED + , gl_OP_MADD_EXT + , gl_TEXTURE7 + , gl_RGB32I_EXT + , gl_RED_BIAS + , gl_FLOAT_VEC2 + , gl_HALF_APPLE + , gl_SGX_BINARY_IMG + , gl_CON_28_ATI + , gl_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP + , gl_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV + , gl_MAP2_VERTEX_ATTRIB2_4_NV + , gl_TRANSFORM_BIT + , gl_R8 + , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV + , gl_T + , gl_TEXTURE_ENV_MODE + , gl_HIGH_INT + , gl_TEXTURE_UNSIGNED_REMAP_MODE_NV + , gl_MAX_PROGRAM_LOOP_COUNT_NV + , gl_PERFQUERY_WAIT_INTEL + , gl_INVALID_FRAMEBUFFER_OPERATION_EXT + , gl_TEXTURE_2D_BINDING_EXT + , gl_TEXTURE_NUM_LEVELS_QCOM + , gl_TEXTURE_BUFFER_ARB + , gl_TRUE + , gl_MAX_LAYERS + , gl_MAX_TEXTURE_UNITS_ARB + , gl_MAP2_NORMAL + , gl_DUAL_ALPHA16_SGIS + , gl_PROGRAM_OUTPUT + , gl_OUTPUT_TEXTURE_COORD22_EXT + , gl_SAMPLER_1D_ARB + , gl_POST_CONVOLUTION_GREEN_BIAS + , gl_INT_IMAGE_CUBE + , gl_CURRENT_VERTEX_WEIGHT_EXT + , gl_SIGNED_LUMINANCE8_NV + , gl_TEXTURE_VIEW_NUM_LAYERS_EXT + , gl_RG16F + , gl_PROGRAM_POINT_SIZE_EXT + , gl_FILE_NAME_NV + , gl_INT_IMAGE_BUFFER_EXT + , gl_TEXTURE_UPDATE_BARRIER_BIT + , gl_HARDMIX_NV + , gl_FLOAT_MAT3x4 + , gl_TEXTURE_INTERNAL_FORMAT_QCOM + , gl_INTERNALFORMAT_BLUE_SIZE + , gl_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV + , gl_HSL_COLOR_NV + , gl_CONDITION_SATISFIED + , gl_UNIFORM_BUFFER_LENGTH_NV + , gl_ALPHA8UI_EXT + , gl_REG_23_ATI + , gl_UNSIGNED_SHORT_5_6_5_EXT + , gl_EDGE_FLAG_ARRAY_LENGTH_NV + , gl_IMAGE_CLASS_1_X_16 + , gl_LUMINANCE8_ALPHA8_SNORM + , gl_PATH_FILL_COVER_MODE_NV + , gl_LUMINANCE_ALPHA_FLOAT32_APPLE + , gl_INTENSITY16UI_EXT + , gl_RENDERBUFFER_SAMPLES_APPLE + , gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE + , gl_LUMINANCE_ALPHA32I_EXT + , gl_REGISTER_COMBINERS_NV + , gl_R1UI_N3F_V3F_SUN + , gl_FOG_COORDINATE_SOURCE + , gl_DEBUG_SEVERITY_MEDIUM_AMD + , gl_MODELVIEW30_ARB + , gl_COMPRESSED_RGBA_S3TC_DXT5_EXT + , gl_DRAW_BUFFER0_NV + , gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT + , gl_ELEMENT_ARRAY_BARRIER_BIT + , gl_SHADER_PIXEL_LOCAL_STORAGE_EXT + , gl_FRONT_LEFT + , gl_UNIFORM_BUFFER_BINDING + , gl_SIGNED_RGBA8_NV + , gl_EYE_PLANE + , gl_TEXTURE_1D + , gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT + , gl_MALI_PROGRAM_BINARY_ARM + , gl_SKIP_COMPONENTS3_NV + , gl_LUMINANCE_ALPHA + , gl_ACCUM_RED_BITS + , gl_POLYGON_OFFSET_FACTOR + , gl_SAMPLER_2D_ARRAY_SHADOW_NV + , gl_VARIABLE_D_NV + , gl_TEXTURE_LEQUAL_R_SGIX + , gl_INT + , gl_IMAGE_TRANSLATE_Y_HP + , gl_POINT_TOKEN + , gl_RESAMPLE_ZERO_FILL_OML + , gl_DEBUG_SOURCE_THIRD_PARTY_KHR + , gl_TEXTURE_MAG_SIZE_NV + , gl_PER_STAGE_CONSTANTS_NV + , gl_VIRTUAL_PAGE_SIZE_Y_ARB + , gl_SPRITE_EYE_ALIGNED_SGIX + , gl_EVAL_VERTEX_ATTRIB14_NV + , gl_TRANSFORM_FEEDBACK_VARYINGS_NV + , gl_RGB10 + , gl_MAX_VIEWPORT_DIMS + , gl_BLUE_MAX_CLAMP_INGR + , gl_INCR_WRAP + , gl_VIRTUAL_PAGE_SIZE_X_AMD + , gl_BOOL_VEC3 + , gl_CON_17_ATI + , gl_MAX_CUBE_MAP_TEXTURE_SIZE_OES + , gl_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT + , gl_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI + , gl_MINMAX + , gl_CONSTANT_BORDER_HP + , gl_SRGB_WRITE + , gl_MAX_TEXTURE_BUFFER_SIZE_ARB + , gl_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV + , gl_DECAL + , gl_REG_7_ATI + , gl_TESS_GEN_SPACING_EXT + , gl_ELEMENT_ARRAY_LENGTH_NV + , gl_MATRIX31_ARB + , gl_TRANSFORM_FEEDBACK_VARYING + , gl_VERTEX_ATTRIB_ARRAY_SIZE + , gl_NOTEQUAL + , gl_READ_PIXELS_TYPE + , gl_MODELVIEW_STACK_DEPTH + , gl_COMPRESSED_RGBA_ASTC_6x6x5_OES + , gl_COMBINE_EXT + , gl_NICEST + , gl_MODELVIEW2_ARB + , gl_UNPACK_IMAGE_HEIGHT + , gl_TEXTURE_CUBE_MAP_ARRAY_ARB + , gl_DRAW_BUFFER12 + , gl_MAX_FRAGMENT_INTERPOLATION_OFFSET + , gl_FRAMEBUFFER_DEFAULT_HEIGHT + , gl_DT_BIAS_NV + , gl_DSDT_NV + , gl_IMAGE_CUBE_MAP_ARRAY + , gl_STENCIL_INDEX4 + , gl_ROUND_NV + , gl_Y_EXT + , gl_PATH_DASH_CAPS_NV + , gl_TEXTURE_PRIORITY + , gl_TEXTURE_4D_BINDING_SGIS + , gl_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD + , gl_CULL_MODES_NV + , gl_VERTEX_ATTRIB_MAP2_SIZE_APPLE + , gl_REFERENCED_BY_GEOMETRY_SHADER_EXT + , gl_MODELVIEW_MATRIX + , gl_VIDEO_BUFFER_NV + , gl_TEXTURE12 + , gl_COLORBURN_NV + , gl_COLOR_ARRAY_BUFFER_BINDING_ARB + , gl_READ_BUFFER_EXT + , gl_RENDERBUFFER_RED_SIZE_OES + , gl_TEXTURE_SHARED_SIZE + , gl_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS + , gl_ALL_SHADER_BITS_EXT + , gl_PERFQUERY_SINGLE_CONTEXT_INTEL + , gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT + , gl_PERFMON_RESULT_AMD + , gl_GUILTY_CONTEXT_RESET + , gl_PREVIOUS + , gl_UNSIGNED_INT16_VEC3_NV + , gl_VERTEX_ATTRIB_MAP1_APPLE + , gl_LIGHT3 + , gl_TESS_EVALUATION_SUBROUTINE_UNIFORM + , gl_DUAL_INTENSITY8_SGIS + , gl_PARAMETER_BUFFER_BINDING_ARB + , gl_CURRENT_SECONDARY_COLOR + , gl_RENDERBUFFER_ALPHA_SIZE + , gl_DUAL_INTENSITY12_SGIS + , gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING + , gl_OP_MAX_EXT + , gl_EDGE_FLAG_ARRAY_EXT + , gl_COLOR_TABLE_LUMINANCE_SIZE + , gl_FOG_COORD_ARRAY_ADDRESS_NV + , gl_COPY + , gl_DRAW_BUFFER2_NV + , gl_SAMPLER_BINDING + , gl_COPY_WRITE_BUFFER + , gl_PIXEL_UNPACK_BUFFER + , gl_VIEW_CLASS_S3TC_DXT1_RGBA + , gl_DRAW_FRAMEBUFFER_APPLE + , gl_PIXEL_MAP_A_TO_A_SIZE + , gl_EDGE_FLAG + , gl_CLIP_DISTANCE2 + , gl_TEXTURE_GEN_MODE + , gl_HALF_BIAS_NORMAL_NV + , gl_RESAMPLE_ZERO_FILL_SGIX + , gl_OUTPUT_TEXTURE_COORD12_EXT + , gl_UNSIGNED_SHORT_8_8_REV_MESA + , gl_PALETTE8_RGBA8_OES + , gl_TEXTURE_4D_SGIS + , gl_PIXEL_PACK_BUFFER_EXT + , gl_MAP_ATTRIB_U_ORDER_NV + , gl_FUNC_SUBTRACT + , gl_PIXEL_SUBSAMPLE_4444_SGIX + , gl_TEXTURE_CUBE_MAP_NEGATIVE_Y + , gl_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT + , gl_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT + , gl_DYNAMIC_COPY + , gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT + , gl_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT + , gl_PROGRAM_LENGTH_ARB + , gl_MODELVIEW14_ARB + , gl_ITALIC_BIT_NV + , gl_OR_INVERTED + , gl_CLIP_NEAR_HINT_PGI + , gl_COVERAGE_EDGE_FRAGMENTS_NV + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR + , gl_PROGRAM_BINARY_LENGTH_OES + , gl_DRAW_BUFFER8_ARB + , gl_DRAW_FRAMEBUFFER_EXT + , gl_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET + , gl_SYNC_CL_EVENT_ARB + , gl_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE + , gl_MAX_VERTEX_HINT_PGI + , gl_UNPACK_IMAGE_HEIGHT_EXT + , gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV + , gl_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE + , gl_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB + , gl_STENCIL_BACK_REF + , gl_CLAMP_READ_COLOR_ARB + , gl_INTERNALFORMAT_RED_SIZE + , gl_PATCH_DEFAULT_INNER_LEVEL_EXT + , gl_OUTPUT_TEXTURE_COORD27_EXT + , gl_QUERY_STENCIL_FAIL_EVENT_BIT_AMD + , gl_MAX_COMPUTE_TEXTURE_IMAGE_UNITS + , gl_LOCATION + , gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS + , gl_POST_COLOR_MATRIX_GREEN_SCALE + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR + , gl_POST_COLOR_MATRIX_ALPHA_SCALE + , gl_HORIZONTAL_LINE_TO_NV + , gl_MAX_FRAGMENT_INPUT_COMPONENTS + , gl_PROGRAM_STRING_ARB + , gl_EDGE_FLAG_ARRAY_ADDRESS_NV + , gl_VENDOR + , gl_CLIPPING_INPUT_PRIMITIVES_ARB + , gl_TEXTURE_RENDERBUFFER_NV + , gl_ELEMENT_ARRAY_ADDRESS_NV + , gl_LOCAL_EXT + , gl_GEOMETRY_SHADER_INVOCATIONS + , gl_INT_VEC4_ARB + , gl_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE + , gl_SEPARATE_ATTRIBS_NV + , gl_FLOAT_MAT4_ARB + , gl_COLOR_ATTACHMENT_EXT + , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE + , gl_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB + , gl_SHININESS + , gl_INTERPOLATE_EXT + , gl_TRANSFORM_FEEDBACK + , gl_TEXTURE_DEPTH_QCOM + , gl_DOUBLE_MAT4x2 + , gl_NORMAL_ARRAY_BUFFER_BINDING_ARB + , gl_PIXEL_TEX_GEN_SGIX + , gl_TRANSFORM_FEEDBACK_BUFFER_START + , gl_GLYPH_WIDTH_BIT_NV + , gl_STENCIL_ATTACHMENT_EXT + , gl_VERTEX_ARRAY_RANGE_POINTER_APPLE + , gl_VERTEX_WEIGHT_ARRAY_TYPE_EXT + , gl_MATRIX4_NV + , gl_READ_FRAMEBUFFER_ANGLE + , gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS + , gl_VERTEX_ARRAY_POINTER_EXT + , gl_RELATIVE_ROUNDED_RECT_NV + , gl_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV + , gl_MAX_PROGRAM_GENERIC_ATTRIBS_NV + , gl_TEXTURE_MEMORY_LAYOUT_INTEL + , gl_REG_0_ATI + , gl_VERTEX_ATTRIB_ARRAY15_NV + , gl_RGB12_EXT + , gl_FRAGMENT_LIGHT6_SGIX + , gl_MAX_PROGRAM_ATTRIB_COMPONENTS_NV + , gl_QUERY_ALL_EVENT_BITS_AMD + , gl_INTENSITY_FLOAT32_APPLE + , gl_LIST_INDEX + , gl_COMPRESSED_RGB_PVRTC_2BPPV1_IMG + , gl_REG_18_ATI + , gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT + , gl_COMPILE + , gl_VIEW_CLASS_128_BITS + , gl_4X_BIT_ATI + , gl_CLIENT_PIXEL_STORE_BIT + , gl_OPERAND2_RGB + , gl_MINMAX_FORMAT_EXT + , gl_UNSIGNED_INT_IMAGE_1D + , gl_INSTRUMENT_MEASUREMENTS_SGIX + , gl_VALIDATE_STATUS + , gl_NORMAL_ARRAY_COUNT_EXT + , gl_PATH_STENCIL_REF_NV + , gl_DRAW_BUFFER5_NV + , gl_COMPRESSED_RGBA_ARB + , gl_MAX_MULTISAMPLE_COVERAGE_MODES_NV + , gl_MAX_3D_TEXTURE_SIZE + , gl_FRAGMENT_NORMAL_EXT + , gl_SHADER_KHR + , gl_TEXTURE_DEPTH_TYPE + , gl_VERTEX_PROGRAM_CALLBACK_FUNC_MESA + , gl_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE + , gl_TEXTURE_2D_STACK_BINDING_MESAX + , gl_NUM_COMPRESSED_TEXTURE_FORMATS_ARB + , gl_INT_SAMPLER_2D_EXT + , gl_RGBA4_S3TC + , gl_MAX_SPOT_EXPONENT_NV + , gl_NEGATIVE_X_EXT + , gl_SYNC_X11_FENCE_EXT + , gl_OP_DOT3_EXT + , gl_LUMINANCE8_SNORM + , gl_SAMPLE_SHADING_ARB + , gl_CONVOLUTION_2D_EXT + , gl_MAP2_TEXTURE_COORD_2 + , gl_SHADER_IMAGE_LOAD + , gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV + , gl_TEXTURE_VIEW_NUM_LEVELS_EXT + , gl_ACTIVE_UNIFORMS + , gl_ACCUM_GREEN_BITS + , gl_TESS_EVALUATION_PROGRAM_NV + , gl_COMPRESSED_SLUMINANCE + , gl_COLOR_ATTACHMENT14_EXT + , gl_VERTEX23_BIT_PGI + , gl_BUMP_ROT_MATRIX_ATI + , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT + , gl_MAX_PALETTE_MATRICES_OES + , gl_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV + , gl_CONVOLUTION_BORDER_MODE_EXT + , gl_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE + , gl_INTENSITY32I_EXT + , gl_RASTERIZER_DISCARD_EXT + , gl_MAX_SAMPLES_EXT + , gl_DRAW_BUFFER10_EXT + , gl_INT_IMAGE_2D + , gl_PROVOKING_VERTEX + , gl_UNPACK_RESAMPLE_SGIX + , gl_SAMPLE_POSITION_NV + , gl_MAX_PROGRAM_MATRICES_ARB + , gl_SHADER_STORAGE_BUFFER_BINDING + , gl_TEXTURE0 + , gl_DSDT_MAG_VIB_NV + , gl_DOUBLE_MAT4x3 + , gl_TEXTURE27_ARB + , gl_ACTIVE_ATOMIC_COUNTER_BUFFERS + , gl_LUMINANCE32I_EXT + , gl_SAMPLER_KHR + , gl_MITER_REVERT_NV + , gl_RGB32UI_EXT + , gl_DUAL_LUMINANCE12_SGIS + , gl_BOOL_VEC2 + , gl_COLOR_ATTACHMENT1_NV + , gl_MAX_CONVOLUTION_WIDTH + , gl_DRAW_BUFFER14_NV + , gl_BLEND_DST_RGB_EXT + , gl_LUMINANCE12_ALPHA12_EXT + , gl_DEPTH_BOUNDS_EXT + , gl_CIRCULAR_CCW_ARC_TO_NV + , gl_COMPRESSED_LUMINANCE_ALPHA + , gl_SAMPLE_COVERAGE_VALUE_ARB + , gl_DEPTH_STENCIL_TO_RGBA_NV + , gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING + , gl_NAME_LENGTH + , gl_STENCIL_TEST_TWO_SIDE_EXT + , gl_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES + , gl_VERTEX_ATTRIB_ARRAY_STRIDE_ARB + , gl_OUTPUT_TEXTURE_COORD30_EXT + , gl_MAX_PROGRAM_SUBROUTINE_NUM_NV + , gl_MULTIPLY_NV + , gl_TEXTURE19 + , gl_INVERT_OVG_NV + , gl_IMPLEMENTATION_COLOR_READ_FORMAT_OES + , gl_NEAREST_CLIPMAP_LINEAR_SGIX + , gl_VARIABLE_A_NV + , gl_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT + , gl_TEXTURE_2D_MULTISAMPLE + , gl_DEBUG_SOURCE_THIRD_PARTY + , gl_DRAW_BUFFER7_ARB + , gl_MAX_DRAW_BUFFERS + , gl_MAX_SERVER_WAIT_TIMEOUT + , gl_COMPRESSED_SIGNED_RG11_EAC + , gl_VERTEX_PROGRAM_POINT_SIZE + , gl_STENCIL_PASS_DEPTH_PASS + , gl_RENDERBUFFER_STENCIL_SIZE + , gl_TEXTURE_BINDING_2D + , gl_DATA_BUFFER_AMD + , gl_DEBUG_CATEGORY_APPLICATION_AMD + , gl_ASYNC_HISTOGRAM_SGIX + , gl_UNPACK_LSB_FIRST + , gl_UNSIGNED_INT_SAMPLER_CUBE_EXT + , gl_DEPTH_CLAMP_FAR_AMD + , gl_TRANSFORM_FEEDBACK_BUFFER_MODE_NV + , gl_VERTEX_ATTRIB_ARRAY_STRIDE + , gl_UNSIGNED_INT16_VEC4_NV + , gl_OBJECT_BUFFER_SIZE_ATI + , gl_YCRCB_444_SGIX + , gl_LOSE_CONTEXT_ON_RESET_KHR + , gl_TEXTURE_VIEW_NUM_LAYERS + , gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB + , gl_PERFQUERY_COUNTER_DATA_BOOL32_INTEL + , gl_OBJECT_DELETE_STATUS_ARB + , gl_SQUARE_NV + , gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT + , gl_DEBUG_SEVERITY_NOTIFICATION_KHR + , gl_EYE_LINEAR_NV + , gl_REG_16_ATI + , gl_LUMINANCE_ALPHA32UI_EXT + , gl_OUTPUT_TEXTURE_COORD31_EXT + , gl_COMPRESSED_RG_RGTC2 + , gl_FLOAT_MAT3 + , gl_INDEX_ARRAY_POINTER + , gl_FOG_COORD + , gl_DRAW_BUFFER13 + , gl_SCALED_RESOLVE_NICEST_EXT + , gl_QUERY_RESULT_AVAILABLE + , gl_UNPACK_SUBSAMPLE_RATE_SGIX + , gl_3_BYTES_NV + , gl_CLEAR + , gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT + , gl_R8UI + , gl_OFFSET_TEXTURE_2D_MATRIX_NV + , gl_BGRA_INTEGER + , gl_MAX_ARRAY_TEXTURE_LAYERS + , gl_COMPRESSED_RGB_ARB + , gl_FOG_COORDINATE_ARRAY_POINTER_EXT + , gl_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT + , gl_TEXTURE_MAG_FILTER + , gl_DEPTH_COMPONENT32 + , gl_VIEW_CLASS_S3TC_DXT1_RGB + , gl_FRONT_RIGHT + , gl_HISTOGRAM_WIDTH + , gl_SAMPLER_CUBE_MAP_ARRAY_ARB + , gl_WEIGHT_ARRAY_STRIDE_OES + , gl_PIXEL_PACK_BUFFER_ARB + , gl_DOT_PRODUCT_PASS_THROUGH_NV + , gl_COMPRESSED_RG11_EAC + , gl_SRGB_DECODE_ARB + , gl_OP_SUB_EXT + , gl_SLIM12S_SGIX + , gl_SECONDARY_COLOR_NV + , gl_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS + , gl_MAP1_VERTEX_3 + , gl_RELATIVE_ROUNDED_RECT8_NV + , gl_PALETTE4_R5_G6_B5_OES + , gl_UNSIGNED_INT8_NV + , gl_CURRENT_MATRIX_STACK_DEPTH_ARB + , gl_PIXEL_MODE_BIT + , gl_FONT_UNINTELLIGIBLE_NV + , gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT + , gl_LUMINANCE8UI_EXT + , gl_HILO16_NV + , gl_MAP2_VERTEX_ATTRIB8_4_NV + , gl_ATTACHED_SHADERS + , gl_OBJECT_POINT_SGIS + , gl_TEXTURE_CUBE_MAP_SEAMLESS + , gl_COLOR_ATTACHMENT0 + , gl_POST_CONVOLUTION_ALPHA_BIAS_EXT + , gl_SAMPLE_PATTERN_SGIS + , gl_COPY_PIXEL_TOKEN + , gl_BUFFER_SIZE_ARB + , gl_DEPTH_BOUNDS_TEST_EXT + , gl_SAMPLE_POSITION + , gl_FULL_STIPPLE_HINT_PGI + , gl_DEBUG_ASSERT_MESA + , gl_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB + , gl_RENDERBUFFER_WIDTH_OES + , gl_FLOAT_RGBA16_NV + , gl_MODELVIEW5_ARB + , gl_VERSION + , gl_TEXTURE17_ARB + , gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT + , gl_MODELVIEW0_STACK_DEPTH_EXT + , gl_OUTPUT_TEXTURE_COORD1_EXT + , gl_REQUIRED_TEXTURE_IMAGE_UNITS_OES + , gl_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX + , gl_IMAGE_TRANSFORM_2D_HP + , gl_HSL_SATURATION_NV + , gl_UNSIGNED_SHORT_5_6_5_REV + , gl_LINEAR_CLIPMAP_NEAREST_SGIX + , gl_PREVIOUS_ARB + , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT + , gl_PERFQUERY_COUNTER_DURATION_NORM_INTEL + , gl_SLUMINANCE8_EXT + , gl_RGBA16F_ARB + , gl_PIXEL_UNPACK_BUFFER_ARB + , gl_STENCIL_REF + , gl_TEXTURE_VIEW_MIN_LAYER_EXT + , gl_HISTOGRAM_RED_SIZE + , gl_CLIP_PLANE1 + , gl_UNKNOWN_CONTEXT_RESET_ARB + , gl_CMYK_EXT + , gl_TEXTURE_COMPRESSED_BLOCK_SIZE + , gl_RGBA8I + , gl_TEXTURE29_ARB + , gl_STENCIL_BUFFER_BIT2_QCOM + , gl_RED_MIN_CLAMP_INGR + , gl_ATC_RGBA_EXPLICIT_ALPHA_AMD + , gl_ALL_COMPLETED_NV + , gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE + , gl_MATRIX10_ARB + , gl_MAP1_VERTEX_ATTRIB1_4_NV + , gl_MAX_4D_TEXTURE_SIZE_SGIS + , gl_VIEW_CLASS_32_BITS + , gl_TEXTURE7_ARB + , gl_DEBUG_TYPE_PERFORMANCE_ARB + , gl_ACTIVE_VARIABLES + , gl_SOURCE2_RGB_EXT + , gl_PACK_INVERT_MESA + , gl_QUERY_BY_REGION_WAIT_NV + , gl_VERTEX_ID_SWIZZLE_AMD + , gl_SPRITE_TRANSLATION_SGIX + , gl_RENDERBUFFER_HEIGHT + , gl_CUBIC_EXT + , gl_TEXTURE19_ARB + , gl_T2F_N3F_V3F + , gl_ATOMIC_COUNTER_BARRIER_BIT_EXT + , gl_ARRAY_ELEMENT_LOCK_FIRST_EXT + , gl_PROGRAM_RESULT_COMPONENTS_NV + , gl_MAX_RECTANGLE_TEXTURE_SIZE_ARB + , gl_TRIANGLE_MESH_SUN + , gl_TEXTURE_WRAP_Q_SGIS + , gl_ATTRIB_ARRAY_SIZE_NV + , gl_DEBUG_LOGGED_MESSAGES_AMD + , gl_BOOL + , gl_MIN_LOD_WARNING_AMD + , gl_PACK_SKIP_PIXELS + , gl_IMAGE_TEXEL_SIZE + , gl_SRC_ALPHA + , gl_DEPENDENT_HILO_TEXTURE_2D_NV + , gl_FRAMEBUFFER_ATTACHMENT_LAYERED + , gl_PERFQUERY_COUNTER_DATA_UINT32_INTEL + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR + , gl_VERTEX_ARRAY_RANGE_LENGTH_NV + , gl_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS + , gl_POST_CONVOLUTION_GREEN_SCALE + , gl_SEPARATE_ATTRIBS + , gl_UNSIGNED_BYTE_3_3_2 + , gl_SCALAR_EXT + , gl_POINT_SIZE_ARRAY_STRIDE_OES + , gl_DOUBLE_MAT3x4 + , gl_SRC0_RGB + , gl_VIEW_CLASS_BPTC_UNORM + , gl_SYNC_FLAGS + , gl_TEXTURE_SWIZZLE_RGBA_EXT + , gl_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX + , gl_TEXTURE29 + , gl_MEDIUM_INT + , gl_CURRENT_QUERY_ARB + , gl_DT_SCALE_NV + , gl_CLAMP_VERTEX_COLOR_ARB + , gl_DEPTH_BUFFER_BIT4_QCOM + , gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 + , gl_USE_MISSING_GLYPH_NV + , gl_MAX_ASYNC_TEX_IMAGE_SGIX + , gl_TESS_CONTROL_TEXTURE + , gl_DEPTH_FUNC + , gl_RG8I + , gl_MAX_VERTEX_SHADER_VARIANTS_EXT + , gl_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB + , gl_COMPRESSED_SRGB + , gl_PROGRAM_BINDING_ARB + , gl_SAMPLER_2D_ARRAY + , gl_IMAGE_CUBE_MAP_ARRAY_EXT + , gl_BUFFER_ACCESS_FLAGS + , gl_EIGHTH_BIT_ATI + , gl_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV + , gl_INT8_VEC4_NV + , gl_CLEAR_TEXTURE + , gl_TEXTURE_CUBE_MAP_OES + , gl_FONT_NUM_GLYPH_INDICES_BIT_NV + , gl_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV + , gl_RENDERBUFFER_DEPTH_SIZE + , gl_DOT_PRODUCT_TEXTURE_1D_NV + , gl_DOUBLE_VEC3_EXT + , gl_VERTEX_ATTRIB_ARRAY_UNIFIED_NV + , gl_TEXTURE_LUMINANCE_TYPE + , gl_CONTEXT_FLAGS + , gl_NORMAL_ARRAY_BUFFER_BINDING + , gl_PROGRAM_FORMAT_ARB + , gl_MOVE_TO_CONTINUES_NV + , gl_LO_BIAS_NV + , gl_CONVOLUTION_WIDTH_EXT + , gl_FRAGMENT_TEXTURE + , gl_NORMAL_BIT_PGI + , gl_COMPRESSED_SIGNED_RG11_EAC_OES + , gl_FIRST_VERTEX_CONVENTION + , gl_ROUNDED_RECT2_NV + , gl_POST_COLOR_MATRIX_RED_BIAS + , gl_UNIFORM_BUFFER + , gl_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT + , gl_NUM_SAMPLE_COUNTS + , gl_FOG_OFFSET_VALUE_SGIX + , gl_DIFFUSE + , gl_CLIP_PLANE5 + , gl_OUTPUT_FOG_EXT + , gl_PROGRAM_ATTRIB_COMPONENTS_NV + , gl_RGBA_SIGNED_COMPONENTS_EXT + , gl_COLOR_ARRAY_EXT + , gl_PROXY_TEXTURE_1D_STACK_MESAX + , gl_TEXTURE_COORD_ARRAY_POINTER + , gl_MAX_COLOR_ATTACHMENTS + , gl_TEXTURE28_ARB + , gl_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX + , gl_DEPTH24_STENCIL8_EXT + , gl_MAX + , gl_MODELVIEW12_ARB + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES + , gl_PIXEL_MAP_I_TO_I_SIZE + , gl_NORMAL_ARRAY_LIST_STRIDE_IBM + , gl_SOURCE3_RGB_NV + , gl_ALPHA12_EXT + , gl_STREAM_COPY_ARB + , gl_STENCIL_BACK_PASS_DEPTH_FAIL_ATI + , gl_FRAGMENT_SUBROUTINE_UNIFORM + , gl_IS_ROW_MAJOR + , gl_UNPACK_SKIP_IMAGES + , gl_NUM_GENERAL_COMBINERS_NV + , gl_STENCIL_CLEAR_TAG_VALUE_EXT + , gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS + , gl_DRAW_BUFFER12_ARB + , gl_OFFSET_PROJECTIVE_TEXTURE_2D_NV + , gl_VERTEX_ARRAY_OBJECT_EXT + , gl_PN_TRIANGLES_NORMAL_MODE_ATI + , gl_C4UB_V3F + , gl_REPEAT + , gl_MAX_SAMPLE_MASK_WORDS_NV + , gl_STORAGE_SHARED_APPLE + , gl_TEXTURE9_ARB + , gl_QUERY_BUFFER_BINDING + , gl_UNSIGNED_SHORT_8_8_REV_APPLE + , gl_MAX_FRAGMENT_UNIFORM_VECTORS + , gl_UNDEFINED_APPLE + , gl_TABLE_TOO_LARGE_EXT + , gl_MAX_TESS_PATCH_COMPONENTS_EXT + , gl_XOR_NV + , gl_MAX_SHADER_BUFFER_ADDRESS_NV + , gl_DEBUG_SOURCE_WINDOW_SYSTEM + , gl_UNSIGNALED_APPLE + , gl_SIGNED_LUMINANCE_NV + , gl_FOG_DISTANCE_MODE_NV + , gl_PN_TRIANGLES_POINT_MODE_ATI + , gl_GEOMETRY_SUBROUTINE_UNIFORM + , gl_NEGATIVE_Z_EXT + , gl_PIXEL_MAP_R_TO_R + , gl_OBJECT_LINK_STATUS_ARB + , gl_NUM_ACTIVE_VARIABLES + , gl_BUFFER_UPDATE_BARRIER_BIT_EXT + , gl_IMAGE_CUBE_EXT + , gl_RGB_INTEGER_EXT + , gl_DRAW_BUFFER13_EXT + , gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT + , gl_SYNC_GPU_COMMANDS_COMPLETE_APPLE + , gl_RGB_SCALE + , gl_DOUBLE_MAT3x4_EXT + , gl_EXP + , gl_PERFMON_RESULT_AVAILABLE_AMD + , gl_STENCIL_VALUE_MASK + , gl_COLOR_ATTACHMENT12_NV + , gl_VERTEX_STREAM2_ATI + , gl_MAP_COHERENT_BIT + , gl_COMPRESSED_SIGNED_RG_RGTC2 + , gl_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER + , gl_FRAGMENT_PROGRAM_ARB + , gl_COLOR_BUFFER_BIT6_QCOM + , gl_FLOAT_32_UNSIGNED_INT_24_8_REV_NV + , gl_WIDE_LINE_HINT_PGI + , gl_FRAGMENT_LIGHT4_SGIX + , gl_RGBA_FLOAT_MODE_ATI + , gl_UNSIGNED_INT_10F_11F_11F_REV + , gl_MODELVIEW1_STACK_DEPTH_EXT + , gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV + , gl_POINT_SIZE_MAX + , gl_ALPHA_TEST_REF_QCOM + , gl_RELATIVE_HORIZONTAL_LINE_TO_NV + , gl_FILTER4_SGIS + , gl_TEXTURE4 + , gl_INDEX_MATERIAL_EXT + , gl_FETCH_PER_SAMPLE_ARM + , gl_VARIANT_ARRAY_TYPE_EXT + , gl_ALPHA_MAX_SGIX + , gl_NUM_INSTRUCTIONS_TOTAL_ATI + , gl_TEXTURE_IMAGE_TYPE + , gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS + , gl_DRAW_BUFFER11_NV + , gl_SURFACE_STATE_NV + , gl_BLEND_SRC_RGB + , gl_OBJECT_ACTIVE_UNIFORMS_ARB + , gl_COLORDODGE_NV + , gl_PRIMITIVES_GENERATED_NV + , gl_IMAGE_2D_ARRAY + , gl_LOSE_CONTEXT_ON_RESET_ARB + , gl_RG_INTEGER + , gl_UNSIGNED_INT_SAMPLER_1D_EXT + , gl_REFLECTION_MAP_ARB + , gl_NORMAL_ARRAY_TYPE_EXT + , gl_BLUE_BITS + , gl_ATOMIC_COUNTER_BARRIER_BIT + , gl_INTENSITY8I_EXT + , gl_TEXTURE_BINDING_RECTANGLE_ARB + , gl_SCALE_BY_TWO_NV + , gl_PACK_IMAGE_HEIGHT + , gl_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL + , gl_DEPTH_COMPONENT24_SGIX + , gl_NUM_FRAGMENT_CONSTANTS_ATI + , gl_EDGE_FLAG_ARRAY_STRIDE_EXT + , gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT + , gl_SAMPLE_ALPHA_TO_COVERAGE_ARB + , gl_UNPACK_SKIP_IMAGES_EXT + , gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL + , gl_RGBA8_OES + , gl_STENCIL_INDEX8_OES + , gl_MAX_SPARSE_3D_TEXTURE_SIZE_AMD + , gl_COMPUTE_SHADER + , gl_QUERY_WAIT_NV + , gl_TEXTURE_COMPARE_FUNC_ARB + , gl_SCREEN_COORDINATES_REND + , gl_DRAW_BUFFER4_EXT + , gl_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT + , gl_TOP_LEVEL_ARRAY_SIZE + , gl_STATIC_COPY_ARB + , gl_MAP1_TANGENT_EXT + , gl_MAP2_VERTEX_ATTRIB11_4_NV + , gl_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX + , gl_DRAW_BUFFER9 + , gl_COMPRESSED_INTENSITY_ARB + , gl_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB + , gl_MATRIX19_ARB + , gl_MAX_MULTIVIEW_BUFFERS_EXT + , gl_CONJOINT_NV + , gl_INTENSITY_SNORM + , gl_DRAW_BUFFER14 + , gl_MAX_PROGRAM_INSTRUCTIONS_ARB + , gl_TEXTURE_BINDING_RECTANGLE + , gl_DEBUG_SOURCE_SHADER_COMPILER_ARB + , gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR + , gl_MULTISAMPLE_EXT + , gl_NEAREST_MIPMAP_NEAREST + , gl_COLOR_ATTACHMENT7_EXT + , gl_STENCIL_BUFFER_BIT6_QCOM + , gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT + , gl_REG_29_ATI + , gl_COVERAGE_SAMPLES_NV + , gl_RELEASED_APPLE + , gl_ALPHA_TEST_FUNC + , gl_DRAW_BUFFER2 + , gl_VERTEX_PROGRAM_BINDING_NV + , gl_IMAGE_2D_RECT + , gl_COLOR_TABLE_BIAS_SGI + , gl_CLIENT_ACTIVE_TEXTURE_ARB + , gl_CURRENT_MATRIX_INDEX_ARB + , gl_TEXTURE_COORD_ARRAY_STRIDE + , gl_FILTER + , gl_MAX_MODELVIEW_STACK_DEPTH + , gl_VERTEX_ATTRIB_ARRAY5_NV + , gl_UNSIGNED_BYTE + , gl_DETAIL_TEXTURE_2D_SGIS + , gl_POST_CONVOLUTION_BLUE_BIAS + , gl_TYPE + , gl_COMPRESSED_RG + , gl_4PASS_1_SGIS + , gl_SOURCE2_RGB + , gl_TEXTURE_MAX_LOD + , gl_EYE_DISTANCE_TO_LINE_SGIS + , gl_LUMINANCE_ALPHA32F_EXT + , gl_MATRIX_INDEX_ARRAY_STRIDE_ARB + , gl_COLOR_ATTACHMENT4 + , gl_INDEX_ARRAY_BUFFER_BINDING + , gl_UNSIGNED_INT_SAMPLER_2D_ARRAY + , gl_PIXEL_TILE_BEST_ALIGNMENT_SGIX + , gl_SPECULAR + , gl_PACK_IMAGE_DEPTH_SGIS + , gl_PLUS_CLAMPED_NV + , gl_INVALID_FRAMEBUFFER_OPERATION + , gl_RG + , gl_COLOR_ATTACHMENT11_NV + , gl_UNPACK_SKIP_PIXELS + , gl_SAMPLE_BUFFERS + , gl_DRAW_BUFFER1_ARB + , gl_COMBINER6_NV + , gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES + , gl_TEXTURE_ENV + , gl_QUAD_MESH_SUN + , gl_REFERENCED_BY_TESS_CONTROL_SHADER_EXT + , gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV + , gl_TIMEOUT_EXPIRED + , gl_FLOAT_MAT4x2_NV + , gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES + , gl_COMBINER1_NV + , gl_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB + , gl_RENDERBUFFER_SAMPLES_ANGLE + , gl_VERTEX_ARRAY_SIZE + , gl_TEXTURE2 + , gl_RELATIVE_MOVE_TO_NV + , gl_ALPHA_TEST_FUNC_QCOM + , gl_INNOCENT_CONTEXT_RESET_KHR + , gl_MAP1_VERTEX_ATTRIB5_4_NV + , gl_SAMPLER_1D_SHADOW + , gl_TEXTURE_1D_ARRAY_EXT + , gl_STENCIL_INDEX + , gl_SOURCE2_ALPHA_EXT + , gl_NORMAL_MAP_EXT + , gl_FOG_COORDINATE_SOURCE_EXT + , gl_TEXTURE_FILTER_CONTROL + , gl_REPLACE_OLDEST_SUN + , gl_PROGRAM_ADDRESS_REGISTERS_ARB + , gl_2PASS_1_EXT + , gl_LIGHT_ENV_MODE_SGIX + , gl_OP_FRAC_EXT + , gl_PROXY_TEXTURE_RECTANGLE_NV + , gl_RENDERBUFFER + , gl_MAP2_TEXTURE_COORD_4 + , gl_TEXTURE_BORDER_COLOR_EXT + , gl_SEPARABLE_2D + , gl_COMPRESSED_SRGB_S3TC_DXT1_EXT + , gl_DRAW_BUFFER0_ATI + , gl_TEXTURE_IMMUTABLE_LEVELS + , gl_E_TIMES_F_NV + , gl_MATRIX24_ARB + , gl_PIXEL_GROUP_COLOR_SGIS + , gl_CURRENT_RASTER_COLOR + , gl_DOUBLE_MAT2x4_EXT + , gl_BUMP_TEX_UNITS_ATI + , gl_FOG_COORDINATE_ARRAY_EXT + , gl_ALWAYS + , gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES + , gl_MAP2_VERTEX_4 + , gl_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG + , gl_MODULATE_SIGNED_ADD_ATI + , gl_RG8 + , gl_ACTIVE_UNIFORM_BLOCKS + , gl_MAX_SPARSE_TEXTURE_SIZE_AMD + , gl_COLOR_ATTACHMENT11_EXT + , gl_POST_CONVOLUTION_BLUE_BIAS_EXT + , gl_BUFFER_OBJECT_APPLE + , gl_UNIFORM_TYPE + , gl_VARIABLE_E_NV + , gl_MAX_COMPUTE_ATOMIC_COUNTERS + , gl_COMPRESSED_RED_RGTC1 + , gl_LUMINANCE_INTEGER_EXT + , gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY + , gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE + , gl_R16F_EXT + , gl_MATRIX4_ARB + , gl_MATRIX_INDEX_ARRAY_SIZE_OES + , gl_POLYGON_STIPPLE + , gl_DUAL_ALPHA12_SGIS + , gl_PIXEL_MAP_I_TO_B + , gl_VERTEX_ATTRIB_ARRAY6_NV + , gl_REG_21_ATI + , gl_PERFMON_RESULT_SIZE_AMD + , gl_ALPHA8_OES + , gl_OBJECT_BUFFER_USAGE_ATI + , gl_PATH_STENCIL_FUNC_NV + , gl_TEXTURE12_ARB + , gl_DEPTH_COMPONENT16_OES + , gl_MODELVIEW20_ARB + , gl_ALPHA12 + , gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT + , gl_MODULATE_ADD_ATI + , gl_CLAMP_TO_BORDER_EXT + , gl_CONSTANT_EXT + , gl_OP_LOG_BASE_2_EXT + , gl_SET_AMD + , gl_ONE_MINUS_SRC_ALPHA + , gl_COMPRESSED_LUMINANCE_ALPHA_ARB + , gl_MAX_SERVER_WAIT_TIMEOUT_APPLE + , gl_LINE_TOKEN + , gl_PROXY_POST_CONVOLUTION_COLOR_TABLE + , gl_TEXTURE_BINDING_3D + , gl_INTENSITY16I_EXT + , gl_DEPENDENT_AR_TEXTURE_2D_NV + , gl_CURRENT_RASTER_NORMAL_SGIX + , gl_TEXTURE_INTENSITY_TYPE + , gl_TEXTURE_STORAGE_SPARSE_BIT_AMD + , gl_RENDERBUFFER_INTERNAL_FORMAT_EXT + , gl_VERTEX_ATTRIB_ARRAY1_NV + , gl_TEXTURE_RED_SIZE + , gl_CURRENT_COLOR + , gl_COMPRESSED_RGBA_ASTC_8x5_KHR + , gl_STENCIL_BUFFER_BIT7_QCOM + , gl_CLIP_PLANE0_IMG + , gl_ALPHA_TEST_REF + , gl_POINT_SMOOTH + , gl_WEIGHT_ARRAY_SIZE_OES + , gl_DECODE_EXT + , gl_SPARSE_BUFFER_PAGE_SIZE_ARB + , gl_CLIENT_ATTRIB_STACK_DEPTH + , gl_TEXTURE_BINDING_EXTERNAL_OES + , gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT + , gl_RENDERBUFFER_STENCIL_SIZE_OES + , gl_POST_COLOR_MATRIX_ALPHA_BIAS + , gl_COMPARE_REF_DEPTH_TO_TEXTURE_EXT + , gl_HSL_LUMINOSITY_KHR + , gl_MAX_VERTEX_STREAMS_ATI + , gl_PERFQUERY_COUNTER_THROUGHPUT_INTEL + , gl_COMPRESSED_SIGNED_RED_RGTC1_EXT + , gl_DEPTH_COMPONENT32_OES + , gl_CON_3_ATI + , gl_COMPRESSED_RGBA_S3TC_DXT1_EXT + , gl_MATRIX6_ARB + , gl_MAP2_VERTEX_ATTRIB5_4_NV + , gl_LINE_WIDTH_RANGE + , gl_GLYPH_VERTICAL_BEARING_X_BIT_NV + , gl_FOG_COORDINATE_ARRAY + , gl_VERTEX_ARRAY_RANGE_LENGTH_APPLE + , gl_CLAMP_FRAGMENT_COLOR + , gl_COMPRESSED_RGBA_ASTC_10x5_KHR + , gl_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB + , gl_COLOR_BUFFER_BIT4_QCOM + , gl_TEXTURE13 + , gl_MAX_DEBUG_MESSAGE_LENGTH_AMD + , gl_EVAL_VERTEX_ATTRIB0_NV + , gl_ALPHA_MIN_CLAMP_INGR + , gl_SUB_ATI + , gl_SECONDARY_COLOR_ARRAY_LIST_IBM + , gl_RGBA_INTEGER_MODE_EXT + , gl_DEBUG_TYPE_MARKER_KHR + , gl_VERTEX_ATTRIB_ARRAY14_NV + , gl_TEXTURE_MIN_LOD + , gl_INDEX_TEST_REF_EXT + , gl_AUX0 + , gl_UNSIGNED_INT_IMAGE_2D_RECT + , gl_2_BYTES + , gl_UNDEFINED_VERTEX + , gl_LINE_STIPPLE_PATTERN + , gl_FRAMEBUFFER_SRGB_CAPABLE_EXT + , gl_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB + , gl_UNSIGNED_INT_SAMPLER_1D_ARRAY + , gl_LOAD + , gl_SIGNED_ALPHA8_NV + , gl_STENCIL_INDEX8_EXT + , gl_VIEW_CLASS_24_BITS + , gl_SHADER_STORAGE_BARRIER_BIT + , gl_UNSIGNED_INT_SAMPLER_BUFFER_AMD + , gl_IMAGE_BINDING_LAYER + , gl_MULTISAMPLE_FILTER_HINT_NV + , gl_SPARE1_NV + , gl_MAP_READ_BIT_EXT + , gl_COMPRESSED_LUMINANCE + , gl_COMPRESSED_TEXTURE_FORMATS + , gl_UNIFORM_IS_ROW_MAJOR + , gl_OFFSET_TEXTURE_2D_SCALE_NV + , gl_RGBA_DXT5_S3TC + , gl_MAX_PROGRAM_LOCAL_PARAMETERS_ARB + , gl_MAX_UNIFORM_BUFFER_BINDINGS + , gl_RGB16UI_EXT + , gl_TEXTURE_COMPARE_OPERATOR_SGIX + , gl_VIDEO_BUFFER_PITCH_NV + , gl_RELATIVE_RECT_NV + , gl_DRAW_BUFFER8_ATI + , gl_SRC_COLOR + , gl_SHADER_OBJECT_EXT + , gl_GUILTY_CONTEXT_RESET_KHR + , gl_EVAL_VERTEX_ATTRIB5_NV + , gl_PALETTE4_RGBA4_OES + , gl_LUMINANCE12_EXT + , gl_DONT_CARE + , gl_TEXTURE_BUFFER + , gl_COMPRESSED_RGBA_ASTC_4x4x4_OES + , gl_TEXTURE_BINDING_1D_ARRAY + , gl_SEPARATE_SPECULAR_COLOR + , gl_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED + , gl_NORMAL_ARRAY_LIST_IBM + , gl_CURRENT_MATRIX_STACK_DEPTH_NV + , gl_INT_IMAGE_3D + , gl_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV + , gl_CONTEXT_FLAG_DEBUG_BIT + , gl_WEIGHT_ARRAY_BUFFER_BINDING_ARB + , gl_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX + , gl_VECTOR_EXT + , gl_TEXTURE_BUFFER_DATA_STORE_BINDING + , gl_TEXTURE_LOD_BIAS + , gl_GEOMETRY_SHADER_EXT + , gl_TEXTURE30 + , gl_VERTEX_SHADER_BIT + , gl_HISTOGRAM_BLUE_SIZE_EXT + , gl_PATH_COMMAND_COUNT_NV + , gl_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV + , gl_STENCIL_TAG_BITS_EXT + , gl_MAX_PROGRAM_LOOP_DEPTH_NV + , gl_FLOAT_MAT2x3_NV + , gl_CURRENT_RASTER_DISTANCE + , gl_COMPRESSED_SRGB8_ETC2_OES + , gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES + , gl_PIXEL_MAP_I_TO_G_SIZE + , gl_COMBINE + , gl_FOG_HINT + , gl_COMPUTE_SUBROUTINE_UNIFORM + , gl_FRAGMENT_LIGHT3_SGIX + , gl_DEBUG_TYPE_PORTABILITY_ARB + , gl_MIN_PROGRAM_TEXEL_OFFSET_EXT + , gl_TRANSFORM_FEEDBACK_BUFFER_NV + , gl_UNKNOWN_CONTEXT_RESET_EXT + , gl_INT_SAMPLER_CUBE_MAP_ARRAY_ARB + , gl_UNSIGNED_INT_24_8_NV + , gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY + , gl_MANUAL_GENERATE_MIPMAP + , gl_MAP2_VERTEX_ATTRIB6_4_NV + , gl_FRAMEBUFFER_EXT + , gl_INT16_NV + , gl_FULL_RANGE_EXT + , gl_MAP1_VERTEX_ATTRIB2_4_NV + , gl_UNSIGNED_INT_8_8_8_8_EXT + , gl_TESS_CONTROL_SUBROUTINE_UNIFORM + , gl_PREVIOUS_TEXTURE_INPUT_NV + , gl_ATOMIC_COUNTER_BUFFER_DATA_SIZE + , gl_SYNC_STATUS_APPLE + , gl_4PASS_0_EXT + , gl_POLYGON_SMOOTH + , gl_FEEDBACK_BUFFER_SIZE + , gl_COLORBURN_KHR + , gl_DEPTH24_STENCIL8 + , gl_LINEAR_CLIPMAP_LINEAR_SGIX + , gl_TEXTURE_MAX_LEVEL + , gl_TEXTURE_WRAP_R_EXT + , gl_OBJECT_SUBTYPE_ARB + , gl_MATRIX18_ARB + , gl_MATRIX_INDEX_ARRAY_POINTER_OES + , gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB + , gl_ALPHA8_SNORM + , gl_TESS_CONTROL_SUBROUTINE + , gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB + , gl_POST_CONVOLUTION_ALPHA_SCALE_EXT + , gl_RGB5_A1_EXT + , gl_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS + , gl_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM + , gl_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV + , gl_TEXTURE21_ARB + , gl_SAMPLER_2D_RECT_SHADOW + , gl_DEPTH_STENCIL_TEXTURE_MODE + , gl_MAP1_VERTEX_ATTRIB10_4_NV + , gl_PINLIGHT_NV + , gl_TEXTURE_INTERNAL_FORMAT + , gl_VERTEX_ARRAY_OBJECT_AMD + , gl_OBJECT_LINEAR + , gl_TEXTURE_IMMUTABLE_FORMAT_EXT + , gl_COMBINER_COMPONENT_USAGE_NV + , gl_RENDERBUFFER_GREEN_SIZE_EXT + , gl_CONVOLUTION_FILTER_SCALE + , gl_TEXTURE11 + , gl_BITMAP + , gl_VIEW_COMPATIBILITY_CLASS + , gl_TEXTURE26 + , gl_UNSIGNED_INT8_VEC4_NV + , gl_UNSIGNED_INT_VEC3 + , gl_VERTEX_PRECLIP_SGIX + , gl_PACK_LSB_FIRST + , gl_NEGATIVE_Y_EXT + , gl_FRAMEBUFFER_BINDING_ANGLE + , gl_MAP_INVALIDATE_BUFFER_BIT_EXT + , gl_NO_RESET_NOTIFICATION + , gl_MINMAX_EXT + , gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST + , gl_QUARTER_BIT_ATI + , gl_TEXTURE9 + , gl_FLOAT_R16_NV + , gl_BLEND_ADVANCED_COHERENT_KHR + , gl_MATRIX_INDEX_ARRAY_POINTER_ARB + , gl_PROXY_TEXTURE_1D_EXT + , gl_PERTURB_EXT + , gl_IUI_N3F_V3F_EXT + , gl_COMBINE_RGB_ARB + , gl_DEBUG_SOURCE_APPLICATION_KHR + , gl_MAX_GEOMETRY_UNIFORM_COMPONENTS + , gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE + , gl_PROGRAM_ALU_INSTRUCTIONS_ARB + , gl_VERTEX_STREAM0_ATI + , gl_EDGE_FLAG_ARRAY_POINTER_EXT + , gl_INT_IMAGE_2D_EXT + , gl_READ_FRAMEBUFFER_BINDING_EXT + , gl_TEXTURE_CUBE_MAP_ARB + , gl_LUMINANCE12_ALPHA12 + , gl_FUNC_ADD + , gl_TRANSPOSE_COLOR_MATRIX_ARB + , gl_COLOR_ATTACHMENT6 + , gl_GEOMETRY_SUBROUTINE + , gl_MAX_ELEMENT_INDEX + , gl_QUERY_OBJECT_AMD + , gl_TEXTURE_CUBE_MAP_EXT + , gl_CONSTANT_ATTENUATION + , gl_LUMINANCE_FLOAT32_APPLE + , gl_R32UI + , gl_UNSIGNED_INT_VEC4_EXT + , gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT + , gl_SAMPLE_MASK_VALUE + , gl_STRICT_DEPTHFUNC_HINT_PGI + , gl_CONVOLUTION_HEIGHT_EXT + , gl_DEPTH_BUFFER_BIT1_QCOM + , gl_CLIP_DISTANCE_NV + , gl_DISPATCH_INDIRECT_BUFFER + , gl_LUMINANCE4 + , gl_CLAMP + , gl_CONVOLUTION_FORMAT + , gl_IMAGE_2D_MULTISAMPLE + , gl_TRIANGLE_STRIP + , gl_BGRA_INTEGER_EXT + , gl_FRAGMENTS_INSTRUMENT_MAX_SGIX + , gl_TESS_CONTROL_SHADER_BIT + , gl_POINT_SIZE_ARRAY_BUFFER_BINDING_OES + , gl_BACK_NORMALS_HINT_PGI + , gl_FOG_COORD_ARRAY + , gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR + , gl_OPERAND1_RGB_EXT + , gl_LINEAR_SHARPEN_COLOR_SGIS + , gl_POST_TEXTURE_FILTER_SCALE_SGIX + , gl_FRAMEBUFFER_COMPLETE_OES + , gl_SYNC_OBJECT_APPLE + , gl_INDEX_WRITEMASK + , gl_SIGNED_INTENSITY_NV + , gl_SGX_PROGRAM_BINARY_IMG + , gl_T4F_V4F + , GLsync + , GLsyncob() + , GLhalf + , GLhalfARB + , GLintptrARB + , GLsizeiptrARB + , GLDEBUGPROC + , GLDEBUGPROCARB + , GLDEBUGPROCKHR + , GLDEBUGPROCAMD + , GLbyte + , GLubyte + , GLfloat + , GLclampf + , GLfixed + , GLint64 + , GLuint64 + , GLint64EXT + , GLuint64EXT + , GLintptr + , GLsizeiptr + , GLhalfNV + , GLvdpauSurfaceNV + , GLenum + , GLboolean + , GLvoid + , GLbitfield + , GLshort + , GLint + , GLclampx + , GLushort + , GLuint + , GLsizei + , GLdouble + , GLclampd + , GLeglImageOESob() + , GLeglImageOES + , GLchar + , GLcharARB + , GLhandleARB + ) + where + +import Data.Typeable +import Data.IORef +import Data.Int +import Data.Word +import System.IO.Unsafe +import Control.Applicative +import Control.Exception +import Control.Monad +import Control.Monad.IO.Class +import Control.Monad.Trans.Except +import Foreign.C.Types +import Foreign.Ptr + +#ifdef mingw32_HOST_OS +#define APIENTRY stdcall +#else +#define APIENTRY +#endif + +data FlextInitResult = Failure { why :: String } + | Success + deriving ( Eq, Ord, Show, Read ) + +#ifdef __GLASGOW_HASKELL__ +deriving instance Typeable FlextInitResult +instance Exception FlextInitResult +#endif + +proc :: Either a a -> a +proc (Left x) = x +proc (Right x) = x + +-- | Initializes OpenGL entry points in the current OpenGL context. +flextInit :: (String -> IO (Ptr ())) + -> (String -> IO Bool) + -> IO FlextInitResult +flextInit get_proc_address is_supported = fmap proc $ runExceptT $ do + -- GL_VERSION_1_0 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCullFace" + writeIORef glrefCullFace $ gldynCullFace addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFrontFace" + writeIORef glrefFrontFace $ gldynFrontFace addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glHint" + writeIORef glrefHint $ gldynHint addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glLineWidth" + writeIORef glrefLineWidth $ gldynLineWidth addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPointSize" + writeIORef glrefPointSize $ gldynPointSize addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPolygonMode" + writeIORef glrefPolygonMode $ gldynPolygonMode addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glScissor" + writeIORef glrefScissor $ gldynScissor addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameterf" + writeIORef glrefTexParameterf $ gldynTexParameterf addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameterfv" + writeIORef glrefTexParameterfv $ gldynTexParameterfv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameteri" + writeIORef glrefTexParameteri $ gldynTexParameteri addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameteriv" + writeIORef glrefTexParameteriv $ gldynTexParameteriv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexImage1D" + writeIORef glrefTexImage1D $ gldynTexImage1D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexImage2D" + writeIORef glrefTexImage2D $ gldynTexImage2D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawBuffer" + writeIORef glrefDrawBuffer $ gldynDrawBuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClear" + writeIORef glrefClear $ gldynClear addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearColor" + writeIORef glrefClearColor $ gldynClearColor addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearStencil" + writeIORef glrefClearStencil $ gldynClearStencil addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearDepth" + writeIORef glrefClearDepth $ gldynClearDepth addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilMask" + writeIORef glrefStencilMask $ gldynStencilMask addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glColorMask" + writeIORef glrefColorMask $ gldynColorMask addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDepthMask" + writeIORef glrefDepthMask $ gldynDepthMask addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisable" + writeIORef glrefDisable $ gldynDisable addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnable" + writeIORef glrefEnable $ gldynEnable addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFinish" + writeIORef glrefFinish $ gldynFinish addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFlush" + writeIORef glrefFlush $ gldynFlush addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlendFunc" + writeIORef glrefBlendFunc $ gldynBlendFunc addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glLogicOp" + writeIORef glrefLogicOp $ gldynLogicOp addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilFunc" + writeIORef glrefStencilFunc $ gldynStencilFunc addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilOp" + writeIORef glrefStencilOp $ gldynStencilOp addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDepthFunc" + writeIORef glrefDepthFunc $ gldynDepthFunc addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPixelStoref" + writeIORef glrefPixelStoref $ gldynPixelStoref addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPixelStorei" + writeIORef glrefPixelStorei $ gldynPixelStorei addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glReadBuffer" + writeIORef glrefReadBuffer $ gldynReadBuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glReadPixels" + writeIORef glrefReadPixels $ gldynReadPixels addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBooleanv" + writeIORef glrefGetBooleanv $ gldynGetBooleanv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetDoublev" + writeIORef glrefGetDoublev $ gldynGetDoublev addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetError" + writeIORef glrefGetError $ gldynGetError addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFloatv" + writeIORef glrefGetFloatv $ gldynGetFloatv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetIntegerv" + writeIORef glrefGetIntegerv $ gldynGetIntegerv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetString" + writeIORef glrefGetString $ gldynGetString addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexImage" + writeIORef glrefGetTexImage $ gldynGetTexImage addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexParameterfv" + writeIORef glrefGetTexParameterfv $ gldynGetTexParameterfv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexParameteriv" + writeIORef glrefGetTexParameteriv $ gldynGetTexParameteriv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexLevelParameterfv" + writeIORef glrefGetTexLevelParameterfv $ gldynGetTexLevelParameterfv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexLevelParameteriv" + writeIORef glrefGetTexLevelParameteriv $ gldynGetTexLevelParameteriv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsEnabled" + writeIORef glrefIsEnabled $ gldynIsEnabled addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDepthRange" + writeIORef glrefDepthRange $ gldynDepthRange addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glViewport" + writeIORef glrefViewport $ gldynViewport addr + + -- GL_VERSION_1_1 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawArrays" + writeIORef glrefDrawArrays $ gldynDrawArrays addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawElements" + writeIORef glrefDrawElements $ gldynDrawElements addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPolygonOffset" + writeIORef glrefPolygonOffset $ gldynPolygonOffset addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTexImage1D" + writeIORef glrefCopyTexImage1D $ gldynCopyTexImage1D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTexImage2D" + writeIORef glrefCopyTexImage2D $ gldynCopyTexImage2D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTexSubImage1D" + writeIORef glrefCopyTexSubImage1D $ gldynCopyTexSubImage1D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTexSubImage2D" + writeIORef glrefCopyTexSubImage2D $ gldynCopyTexSubImage2D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexSubImage1D" + writeIORef glrefTexSubImage1D $ gldynTexSubImage1D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexSubImage2D" + writeIORef glrefTexSubImage2D $ gldynTexSubImage2D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindTexture" + writeIORef glrefBindTexture $ gldynBindTexture addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteTextures" + writeIORef glrefDeleteTextures $ gldynDeleteTextures addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenTextures" + writeIORef glrefGenTextures $ gldynGenTextures addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsTexture" + writeIORef glrefIsTexture $ gldynIsTexture addr + + -- GL_VERSION_1_2 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawRangeElements" + writeIORef glrefDrawRangeElements $ gldynDrawRangeElements addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexImage3D" + writeIORef glrefTexImage3D $ gldynTexImage3D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexSubImage3D" + writeIORef glrefTexSubImage3D $ gldynTexSubImage3D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTexSubImage3D" + writeIORef glrefCopyTexSubImage3D $ gldynCopyTexSubImage3D addr + + -- GL_VERSION_1_3 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glActiveTexture" + writeIORef glrefActiveTexture $ gldynActiveTexture addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSampleCoverage" + writeIORef glrefSampleCoverage $ gldynSampleCoverage addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexImage3D" + writeIORef glrefCompressedTexImage3D $ gldynCompressedTexImage3D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexImage2D" + writeIORef glrefCompressedTexImage2D $ gldynCompressedTexImage2D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexImage1D" + writeIORef glrefCompressedTexImage1D $ gldynCompressedTexImage1D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexSubImage3D" + writeIORef glrefCompressedTexSubImage3D $ gldynCompressedTexSubImage3D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexSubImage2D" + writeIORef glrefCompressedTexSubImage2D $ gldynCompressedTexSubImage2D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTexSubImage1D" + writeIORef glrefCompressedTexSubImage1D $ gldynCompressedTexSubImage1D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetCompressedTexImage" + writeIORef glrefGetCompressedTexImage $ gldynGetCompressedTexImage addr + + -- GL_VERSION_1_4 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlendFuncSeparate" + writeIORef glrefBlendFuncSeparate $ gldynBlendFuncSeparate addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiDrawArrays" + writeIORef glrefMultiDrawArrays $ gldynMultiDrawArrays addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiDrawElements" + writeIORef glrefMultiDrawElements $ gldynMultiDrawElements addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPointParameterf" + writeIORef glrefPointParameterf $ gldynPointParameterf addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPointParameterfv" + writeIORef glrefPointParameterfv $ gldynPointParameterfv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPointParameteri" + writeIORef glrefPointParameteri $ gldynPointParameteri addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPointParameteriv" + writeIORef glrefPointParameteriv $ gldynPointParameteriv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlendColor" + writeIORef glrefBlendColor $ gldynBlendColor addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlendEquation" + writeIORef glrefBlendEquation $ gldynBlendEquation addr + + -- GL_VERSION_1_5 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenQueries" + writeIORef glrefGenQueries $ gldynGenQueries addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteQueries" + writeIORef glrefDeleteQueries $ gldynDeleteQueries addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsQuery" + writeIORef glrefIsQuery $ gldynIsQuery addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBeginQuery" + writeIORef glrefBeginQuery $ gldynBeginQuery addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEndQuery" + writeIORef glrefEndQuery $ gldynEndQuery addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetQueryiv" + writeIORef glrefGetQueryiv $ gldynGetQueryiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetQueryObjectiv" + writeIORef glrefGetQueryObjectiv $ gldynGetQueryObjectiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetQueryObjectuiv" + writeIORef glrefGetQueryObjectuiv $ gldynGetQueryObjectuiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindBuffer" + writeIORef glrefBindBuffer $ gldynBindBuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteBuffers" + writeIORef glrefDeleteBuffers $ gldynDeleteBuffers addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenBuffers" + writeIORef glrefGenBuffers $ gldynGenBuffers addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsBuffer" + writeIORef glrefIsBuffer $ gldynIsBuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBufferData" + writeIORef glrefBufferData $ gldynBufferData addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBufferSubData" + writeIORef glrefBufferSubData $ gldynBufferSubData addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBufferSubData" + writeIORef glrefGetBufferSubData $ gldynGetBufferSubData addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMapBuffer" + writeIORef glrefMapBuffer $ gldynMapBuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUnmapBuffer" + writeIORef glrefUnmapBuffer $ gldynUnmapBuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBufferParameteriv" + writeIORef glrefGetBufferParameteriv $ gldynGetBufferParameteriv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBufferPointerv" + writeIORef glrefGetBufferPointerv $ gldynGetBufferPointerv addr + + -- GL_VERSION_2_0 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlendEquationSeparate" + writeIORef glrefBlendEquationSeparate $ gldynBlendEquationSeparate addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawBuffers" + writeIORef glrefDrawBuffers $ gldynDrawBuffers addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilOpSeparate" + writeIORef glrefStencilOpSeparate $ gldynStencilOpSeparate addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilFuncSeparate" + writeIORef glrefStencilFuncSeparate $ gldynStencilFuncSeparate addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glStencilMaskSeparate" + writeIORef glrefStencilMaskSeparate $ gldynStencilMaskSeparate addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glAttachShader" + writeIORef glrefAttachShader $ gldynAttachShader addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindAttribLocation" + writeIORef glrefBindAttribLocation $ gldynBindAttribLocation addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompileShader" + writeIORef glrefCompileShader $ gldynCompileShader addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCreateProgram" + writeIORef glrefCreateProgram $ gldynCreateProgram addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCreateShader" + writeIORef glrefCreateShader $ gldynCreateShader addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteProgram" + writeIORef glrefDeleteProgram $ gldynDeleteProgram addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteShader" + writeIORef glrefDeleteShader $ gldynDeleteShader addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDetachShader" + writeIORef glrefDetachShader $ gldynDetachShader addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableVertexAttribArray" + writeIORef glrefDisableVertexAttribArray $ gldynDisableVertexAttribArray addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableVertexAttribArray" + writeIORef glrefEnableVertexAttribArray $ gldynEnableVertexAttribArray addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveAttrib" + writeIORef glrefGetActiveAttrib $ gldynGetActiveAttrib addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveUniform" + writeIORef glrefGetActiveUniform $ gldynGetActiveUniform addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetAttachedShaders" + writeIORef glrefGetAttachedShaders $ gldynGetAttachedShaders addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetAttribLocation" + writeIORef glrefGetAttribLocation $ gldynGetAttribLocation addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetProgramiv" + writeIORef glrefGetProgramiv $ gldynGetProgramiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetProgramInfoLog" + writeIORef glrefGetProgramInfoLog $ gldynGetProgramInfoLog addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetShaderiv" + writeIORef glrefGetShaderiv $ gldynGetShaderiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetShaderInfoLog" + writeIORef glrefGetShaderInfoLog $ gldynGetShaderInfoLog addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetShaderSource" + writeIORef glrefGetShaderSource $ gldynGetShaderSource addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformLocation" + writeIORef glrefGetUniformLocation $ gldynGetUniformLocation addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformfv" + writeIORef glrefGetUniformfv $ gldynGetUniformfv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformiv" + writeIORef glrefGetUniformiv $ gldynGetUniformiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribdv" + writeIORef glrefGetVertexAttribdv $ gldynGetVertexAttribdv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribfv" + writeIORef glrefGetVertexAttribfv $ gldynGetVertexAttribfv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribiv" + writeIORef glrefGetVertexAttribiv $ gldynGetVertexAttribiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribPointerv" + writeIORef glrefGetVertexAttribPointerv $ gldynGetVertexAttribPointerv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsProgram" + writeIORef glrefIsProgram $ gldynIsProgram addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsShader" + writeIORef glrefIsShader $ gldynIsShader addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glLinkProgram" + writeIORef glrefLinkProgram $ gldynLinkProgram addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glShaderSource" + writeIORef glrefShaderSource $ gldynShaderSource addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUseProgram" + writeIORef glrefUseProgram $ gldynUseProgram addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1f" + writeIORef glrefUniform1f $ gldynUniform1f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2f" + writeIORef glrefUniform2f $ gldynUniform2f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3f" + writeIORef glrefUniform3f $ gldynUniform3f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4f" + writeIORef glrefUniform4f $ gldynUniform4f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1i" + writeIORef glrefUniform1i $ gldynUniform1i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2i" + writeIORef glrefUniform2i $ gldynUniform2i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3i" + writeIORef glrefUniform3i $ gldynUniform3i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4i" + writeIORef glrefUniform4i $ gldynUniform4i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1fv" + writeIORef glrefUniform1fv $ gldynUniform1fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2fv" + writeIORef glrefUniform2fv $ gldynUniform2fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3fv" + writeIORef glrefUniform3fv $ gldynUniform3fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4fv" + writeIORef glrefUniform4fv $ gldynUniform4fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1iv" + writeIORef glrefUniform1iv $ gldynUniform1iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2iv" + writeIORef glrefUniform2iv $ gldynUniform2iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3iv" + writeIORef glrefUniform3iv $ gldynUniform3iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4iv" + writeIORef glrefUniform4iv $ gldynUniform4iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix2fv" + writeIORef glrefUniformMatrix2fv $ gldynUniformMatrix2fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix3fv" + writeIORef glrefUniformMatrix3fv $ gldynUniformMatrix3fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix4fv" + writeIORef glrefUniformMatrix4fv $ gldynUniformMatrix4fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glValidateProgram" + writeIORef glrefValidateProgram $ gldynValidateProgram addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1d" + writeIORef glrefVertexAttrib1d $ gldynVertexAttrib1d addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1dv" + writeIORef glrefVertexAttrib1dv $ gldynVertexAttrib1dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1f" + writeIORef glrefVertexAttrib1f $ gldynVertexAttrib1f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1fv" + writeIORef glrefVertexAttrib1fv $ gldynVertexAttrib1fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1s" + writeIORef glrefVertexAttrib1s $ gldynVertexAttrib1s addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib1sv" + writeIORef glrefVertexAttrib1sv $ gldynVertexAttrib1sv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2d" + writeIORef glrefVertexAttrib2d $ gldynVertexAttrib2d addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2dv" + writeIORef glrefVertexAttrib2dv $ gldynVertexAttrib2dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2f" + writeIORef glrefVertexAttrib2f $ gldynVertexAttrib2f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2fv" + writeIORef glrefVertexAttrib2fv $ gldynVertexAttrib2fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2s" + writeIORef glrefVertexAttrib2s $ gldynVertexAttrib2s addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib2sv" + writeIORef glrefVertexAttrib2sv $ gldynVertexAttrib2sv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3d" + writeIORef glrefVertexAttrib3d $ gldynVertexAttrib3d addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3dv" + writeIORef glrefVertexAttrib3dv $ gldynVertexAttrib3dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3f" + writeIORef glrefVertexAttrib3f $ gldynVertexAttrib3f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3fv" + writeIORef glrefVertexAttrib3fv $ gldynVertexAttrib3fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3s" + writeIORef glrefVertexAttrib3s $ gldynVertexAttrib3s addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib3sv" + writeIORef glrefVertexAttrib3sv $ gldynVertexAttrib3sv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nbv" + writeIORef glrefVertexAttrib4Nbv $ gldynVertexAttrib4Nbv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Niv" + writeIORef glrefVertexAttrib4Niv $ gldynVertexAttrib4Niv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nsv" + writeIORef glrefVertexAttrib4Nsv $ gldynVertexAttrib4Nsv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nub" + writeIORef glrefVertexAttrib4Nub $ gldynVertexAttrib4Nub addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nubv" + writeIORef glrefVertexAttrib4Nubv $ gldynVertexAttrib4Nubv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nuiv" + writeIORef glrefVertexAttrib4Nuiv $ gldynVertexAttrib4Nuiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4Nusv" + writeIORef glrefVertexAttrib4Nusv $ gldynVertexAttrib4Nusv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4bv" + writeIORef glrefVertexAttrib4bv $ gldynVertexAttrib4bv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4d" + writeIORef glrefVertexAttrib4d $ gldynVertexAttrib4d addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4dv" + writeIORef glrefVertexAttrib4dv $ gldynVertexAttrib4dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4f" + writeIORef glrefVertexAttrib4f $ gldynVertexAttrib4f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4fv" + writeIORef glrefVertexAttrib4fv $ gldynVertexAttrib4fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4iv" + writeIORef glrefVertexAttrib4iv $ gldynVertexAttrib4iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4s" + writeIORef glrefVertexAttrib4s $ gldynVertexAttrib4s addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4sv" + writeIORef glrefVertexAttrib4sv $ gldynVertexAttrib4sv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4ubv" + writeIORef glrefVertexAttrib4ubv $ gldynVertexAttrib4ubv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4uiv" + writeIORef glrefVertexAttrib4uiv $ gldynVertexAttrib4uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttrib4usv" + writeIORef glrefVertexAttrib4usv $ gldynVertexAttrib4usv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribPointer" + writeIORef glrefVertexAttribPointer $ gldynVertexAttribPointer addr + + -- GL_VERSION_2_1 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix2x3fv" + writeIORef glrefUniformMatrix2x3fv $ gldynUniformMatrix2x3fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix3x2fv" + writeIORef glrefUniformMatrix3x2fv $ gldynUniformMatrix3x2fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix2x4fv" + writeIORef glrefUniformMatrix2x4fv $ gldynUniformMatrix2x4fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix4x2fv" + writeIORef glrefUniformMatrix4x2fv $ gldynUniformMatrix4x2fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix3x4fv" + writeIORef glrefUniformMatrix3x4fv $ gldynUniformMatrix3x4fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformMatrix4x3fv" + writeIORef glrefUniformMatrix4x3fv $ gldynUniformMatrix4x3fv addr + + -- GL_VERSION_3_0 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glColorMaski" + writeIORef glrefColorMaski $ gldynColorMaski addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBooleani_v" + writeIORef glrefGetBooleani_v $ gldynGetBooleani_v addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetIntegeri_v" + writeIORef glrefGetIntegeri_v $ gldynGetIntegeri_v addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnablei" + writeIORef glrefEnablei $ gldynEnablei addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisablei" + writeIORef glrefDisablei $ gldynDisablei addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsEnabledi" + writeIORef glrefIsEnabledi $ gldynIsEnabledi addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBeginTransformFeedback" + writeIORef glrefBeginTransformFeedback $ gldynBeginTransformFeedback addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEndTransformFeedback" + writeIORef glrefEndTransformFeedback $ gldynEndTransformFeedback addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindBufferRange" + writeIORef glrefBindBufferRange $ gldynBindBufferRange addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindBufferBase" + writeIORef glrefBindBufferBase $ gldynBindBufferBase addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTransformFeedbackVaryings" + writeIORef glrefTransformFeedbackVaryings $ gldynTransformFeedbackVaryings addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTransformFeedbackVarying" + writeIORef glrefGetTransformFeedbackVarying $ gldynGetTransformFeedbackVarying addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClampColor" + writeIORef glrefClampColor $ gldynClampColor addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBeginConditionalRender" + writeIORef glrefBeginConditionalRender $ gldynBeginConditionalRender addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEndConditionalRender" + writeIORef glrefEndConditionalRender $ gldynEndConditionalRender addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribIPointer" + writeIORef glrefVertexAttribIPointer $ gldynVertexAttribIPointer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribIiv" + writeIORef glrefGetVertexAttribIiv $ gldynGetVertexAttribIiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexAttribIuiv" + writeIORef glrefGetVertexAttribIuiv $ gldynGetVertexAttribIuiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI1i" + writeIORef glrefVertexAttribI1i $ gldynVertexAttribI1i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI2i" + writeIORef glrefVertexAttribI2i $ gldynVertexAttribI2i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI3i" + writeIORef glrefVertexAttribI3i $ gldynVertexAttribI3i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4i" + writeIORef glrefVertexAttribI4i $ gldynVertexAttribI4i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI1ui" + writeIORef glrefVertexAttribI1ui $ gldynVertexAttribI1ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI2ui" + writeIORef glrefVertexAttribI2ui $ gldynVertexAttribI2ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI3ui" + writeIORef glrefVertexAttribI3ui $ gldynVertexAttribI3ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4ui" + writeIORef glrefVertexAttribI4ui $ gldynVertexAttribI4ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI1iv" + writeIORef glrefVertexAttribI1iv $ gldynVertexAttribI1iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI2iv" + writeIORef glrefVertexAttribI2iv $ gldynVertexAttribI2iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI3iv" + writeIORef glrefVertexAttribI3iv $ gldynVertexAttribI3iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4iv" + writeIORef glrefVertexAttribI4iv $ gldynVertexAttribI4iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI1uiv" + writeIORef glrefVertexAttribI1uiv $ gldynVertexAttribI1uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI2uiv" + writeIORef glrefVertexAttribI2uiv $ gldynVertexAttribI2uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI3uiv" + writeIORef glrefVertexAttribI3uiv $ gldynVertexAttribI3uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4uiv" + writeIORef glrefVertexAttribI4uiv $ gldynVertexAttribI4uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4bv" + writeIORef glrefVertexAttribI4bv $ gldynVertexAttribI4bv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4sv" + writeIORef glrefVertexAttribI4sv $ gldynVertexAttribI4sv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4ubv" + writeIORef glrefVertexAttribI4ubv $ gldynVertexAttribI4ubv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribI4usv" + writeIORef glrefVertexAttribI4usv $ gldynVertexAttribI4usv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformuiv" + writeIORef glrefGetUniformuiv $ gldynGetUniformuiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindFragDataLocation" + writeIORef glrefBindFragDataLocation $ gldynBindFragDataLocation addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFragDataLocation" + writeIORef glrefGetFragDataLocation $ gldynGetFragDataLocation addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1ui" + writeIORef glrefUniform1ui $ gldynUniform1ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2ui" + writeIORef glrefUniform2ui $ gldynUniform2ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3ui" + writeIORef glrefUniform3ui $ gldynUniform3ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4ui" + writeIORef glrefUniform4ui $ gldynUniform4ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform1uiv" + writeIORef glrefUniform1uiv $ gldynUniform1uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform2uiv" + writeIORef glrefUniform2uiv $ gldynUniform2uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform3uiv" + writeIORef glrefUniform3uiv $ gldynUniform3uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniform4uiv" + writeIORef glrefUniform4uiv $ gldynUniform4uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameterIiv" + writeIORef glrefTexParameterIiv $ gldynTexParameterIiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexParameterIuiv" + writeIORef glrefTexParameterIuiv $ gldynTexParameterIuiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexParameterIiv" + writeIORef glrefGetTexParameterIiv $ gldynGetTexParameterIiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTexParameterIuiv" + writeIORef glrefGetTexParameterIuiv $ gldynGetTexParameterIuiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearBufferiv" + writeIORef glrefClearBufferiv $ gldynClearBufferiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearBufferuiv" + writeIORef glrefClearBufferuiv $ gldynClearBufferuiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearBufferfv" + writeIORef glrefClearBufferfv $ gldynClearBufferfv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearBufferfi" + writeIORef glrefClearBufferfi $ gldynClearBufferfi addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetStringi" + writeIORef glrefGetStringi $ gldynGetStringi addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsRenderbuffer" + writeIORef glrefIsRenderbuffer $ gldynIsRenderbuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindRenderbuffer" + writeIORef glrefBindRenderbuffer $ gldynBindRenderbuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteRenderbuffers" + writeIORef glrefDeleteRenderbuffers $ gldynDeleteRenderbuffers addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenRenderbuffers" + writeIORef glrefGenRenderbuffers $ gldynGenRenderbuffers addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glRenderbufferStorage" + writeIORef glrefRenderbufferStorage $ gldynRenderbufferStorage addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetRenderbufferParameteriv" + writeIORef glrefGetRenderbufferParameteriv $ gldynGetRenderbufferParameteriv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsFramebuffer" + writeIORef glrefIsFramebuffer $ gldynIsFramebuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindFramebuffer" + writeIORef glrefBindFramebuffer $ gldynBindFramebuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteFramebuffers" + writeIORef glrefDeleteFramebuffers $ gldynDeleteFramebuffers addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenFramebuffers" + writeIORef glrefGenFramebuffers $ gldynGenFramebuffers addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCheckFramebufferStatus" + writeIORef glrefCheckFramebufferStatus $ gldynCheckFramebufferStatus addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferTexture1D" + writeIORef glrefFramebufferTexture1D $ gldynFramebufferTexture1D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferTexture2D" + writeIORef glrefFramebufferTexture2D $ gldynFramebufferTexture2D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferTexture3D" + writeIORef glrefFramebufferTexture3D $ gldynFramebufferTexture3D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferRenderbuffer" + writeIORef glrefFramebufferRenderbuffer $ gldynFramebufferRenderbuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFramebufferAttachmentParameteriv" + writeIORef glrefGetFramebufferAttachmentParameteriv $ gldynGetFramebufferAttachmentParameteriv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenerateMipmap" + writeIORef glrefGenerateMipmap $ gldynGenerateMipmap addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBlitFramebuffer" + writeIORef glrefBlitFramebuffer $ gldynBlitFramebuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glRenderbufferStorageMultisample" + writeIORef glrefRenderbufferStorageMultisample $ gldynRenderbufferStorageMultisample addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferTextureLayer" + writeIORef glrefFramebufferTextureLayer $ gldynFramebufferTextureLayer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMapBufferRange" + writeIORef glrefMapBufferRange $ gldynMapBufferRange addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFlushMappedBufferRange" + writeIORef glrefFlushMappedBufferRange $ gldynFlushMappedBufferRange addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindVertexArray" + writeIORef glrefBindVertexArray $ gldynBindVertexArray addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteVertexArrays" + writeIORef glrefDeleteVertexArrays $ gldynDeleteVertexArrays addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenVertexArrays" + writeIORef glrefGenVertexArrays $ gldynGenVertexArrays addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsVertexArray" + writeIORef glrefIsVertexArray $ gldynIsVertexArray addr + + -- GL_VERSION_3_1 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawArraysInstanced" + writeIORef glrefDrawArraysInstanced $ gldynDrawArraysInstanced addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawElementsInstanced" + writeIORef glrefDrawElementsInstanced $ gldynDrawElementsInstanced addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexBuffer" + writeIORef glrefTexBuffer $ gldynTexBuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPrimitiveRestartIndex" + writeIORef glrefPrimitiveRestartIndex $ gldynPrimitiveRestartIndex addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyBufferSubData" + writeIORef glrefCopyBufferSubData $ gldynCopyBufferSubData addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformIndices" + writeIORef glrefGetUniformIndices $ gldynGetUniformIndices addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveUniformsiv" + writeIORef glrefGetActiveUniformsiv $ gldynGetActiveUniformsiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveUniformName" + writeIORef glrefGetActiveUniformName $ gldynGetActiveUniformName addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetUniformBlockIndex" + writeIORef glrefGetUniformBlockIndex $ gldynGetUniformBlockIndex addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveUniformBlockiv" + writeIORef glrefGetActiveUniformBlockiv $ gldynGetActiveUniformBlockiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetActiveUniformBlockName" + writeIORef glrefGetActiveUniformBlockName $ gldynGetActiveUniformBlockName addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUniformBlockBinding" + writeIORef glrefUniformBlockBinding $ gldynUniformBlockBinding addr + + -- GL_VERSION_3_2 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawElementsBaseVertex" + writeIORef glrefDrawElementsBaseVertex $ gldynDrawElementsBaseVertex addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawRangeElementsBaseVertex" + writeIORef glrefDrawRangeElementsBaseVertex $ gldynDrawRangeElementsBaseVertex addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDrawElementsInstancedBaseVertex" + writeIORef glrefDrawElementsInstancedBaseVertex $ gldynDrawElementsInstancedBaseVertex addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiDrawElementsBaseVertex" + writeIORef glrefMultiDrawElementsBaseVertex $ gldynMultiDrawElementsBaseVertex addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProvokingVertex" + writeIORef glrefProvokingVertex $ gldynProvokingVertex addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFenceSync" + writeIORef glrefFenceSync $ gldynFenceSync addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsSync" + writeIORef glrefIsSync $ gldynIsSync addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteSync" + writeIORef glrefDeleteSync $ gldynDeleteSync addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClientWaitSync" + writeIORef glrefClientWaitSync $ gldynClientWaitSync addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glWaitSync" + writeIORef glrefWaitSync $ gldynWaitSync addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetInteger64v" + writeIORef glrefGetInteger64v $ gldynGetInteger64v addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetSynciv" + writeIORef glrefGetSynciv $ gldynGetSynciv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetInteger64i_v" + writeIORef glrefGetInteger64i_v $ gldynGetInteger64i_v addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBufferParameteri64v" + writeIORef glrefGetBufferParameteri64v $ gldynGetBufferParameteri64v addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferTexture" + writeIORef glrefFramebufferTexture $ gldynFramebufferTexture addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexImage2DMultisample" + writeIORef glrefTexImage2DMultisample $ gldynTexImage2DMultisample addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexImage3DMultisample" + writeIORef glrefTexImage3DMultisample $ gldynTexImage3DMultisample addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultisamplefv" + writeIORef glrefGetMultisamplefv $ gldynGetMultisamplefv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSampleMaski" + writeIORef glrefSampleMaski $ gldynSampleMaski addr + + -- GL_VERSION_3_3 + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindFragDataLocationIndexed" + writeIORef glrefBindFragDataLocationIndexed $ gldynBindFragDataLocationIndexed addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFragDataIndex" + writeIORef glrefGetFragDataIndex $ gldynGetFragDataIndex addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenSamplers" + writeIORef glrefGenSamplers $ gldynGenSamplers addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteSamplers" + writeIORef glrefDeleteSamplers $ gldynDeleteSamplers addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsSampler" + writeIORef glrefIsSampler $ gldynIsSampler addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindSampler" + writeIORef glrefBindSampler $ gldynBindSampler addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameteri" + writeIORef glrefSamplerParameteri $ gldynSamplerParameteri addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameteriv" + writeIORef glrefSamplerParameteriv $ gldynSamplerParameteriv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameterf" + writeIORef glrefSamplerParameterf $ gldynSamplerParameterf addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameterfv" + writeIORef glrefSamplerParameterfv $ gldynSamplerParameterfv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameterIiv" + writeIORef glrefSamplerParameterIiv $ gldynSamplerParameterIiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glSamplerParameterIuiv" + writeIORef glrefSamplerParameterIuiv $ gldynSamplerParameterIuiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetSamplerParameteriv" + writeIORef glrefGetSamplerParameteriv $ gldynGetSamplerParameteriv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetSamplerParameterIiv" + writeIORef glrefGetSamplerParameterIiv $ gldynGetSamplerParameterIiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetSamplerParameterfv" + writeIORef glrefGetSamplerParameterfv $ gldynGetSamplerParameterfv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetSamplerParameterIuiv" + writeIORef glrefGetSamplerParameterIuiv $ gldynGetSamplerParameterIuiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glQueryCounter" + writeIORef glrefQueryCounter $ gldynQueryCounter addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetQueryObjecti64v" + writeIORef glrefGetQueryObjecti64v $ gldynGetQueryObjecti64v addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetQueryObjectui64v" + writeIORef glrefGetQueryObjectui64v $ gldynGetQueryObjectui64v addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribDivisor" + writeIORef glrefVertexAttribDivisor $ gldynVertexAttribDivisor addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP1ui" + writeIORef glrefVertexAttribP1ui $ gldynVertexAttribP1ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP1uiv" + writeIORef glrefVertexAttribP1uiv $ gldynVertexAttribP1uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP2ui" + writeIORef glrefVertexAttribP2ui $ gldynVertexAttribP2ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP2uiv" + writeIORef glrefVertexAttribP2uiv $ gldynVertexAttribP2uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP3ui" + writeIORef glrefVertexAttribP3ui $ gldynVertexAttribP3ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP3uiv" + writeIORef glrefVertexAttribP3uiv $ gldynVertexAttribP3uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP4ui" + writeIORef glrefVertexAttribP4ui $ gldynVertexAttribP4ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexAttribP4uiv" + writeIORef glrefVertexAttribP4uiv $ gldynVertexAttribP4uiv addr + + -- GL_ARB_texture_storage + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexStorage1D" + writeIORef glrefTexStorage1D $ gldynTexStorage1D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexStorage2D" + writeIORef glrefTexStorage2D $ gldynTexStorage2D addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexStorage3D" + writeIORef glrefTexStorage3D $ gldynTexStorage3D addr + + -- GL_KHR_debug + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageControl" + writeIORef glrefDebugMessageControl $ gldynDebugMessageControl addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageInsert" + writeIORef glrefDebugMessageInsert $ gldynDebugMessageInsert addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageCallback" + writeIORef glrefDebugMessageCallback $ gldynDebugMessageCallback addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetDebugMessageLog" + writeIORef glrefGetDebugMessageLog $ gldynGetDebugMessageLog addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPushDebugGroup" + writeIORef glrefPushDebugGroup $ gldynPushDebugGroup addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPopDebugGroup" + writeIORef glrefPopDebugGroup $ gldynPopDebugGroup addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glObjectLabel" + writeIORef glrefObjectLabel $ gldynObjectLabel addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetObjectLabel" + writeIORef glrefGetObjectLabel $ gldynGetObjectLabel addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glObjectPtrLabel" + writeIORef glrefObjectPtrLabel $ gldynObjectPtrLabel addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetObjectPtrLabel" + writeIORef glrefGetObjectPtrLabel $ gldynGetObjectPtrLabel addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetPointerv" + writeIORef glrefGetPointerv $ gldynGetPointerv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageControlKHR" + writeIORef glrefDebugMessageControlKHR $ gldynDebugMessageControlKHR addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageInsertKHR" + writeIORef glrefDebugMessageInsertKHR $ gldynDebugMessageInsertKHR addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDebugMessageCallbackKHR" + writeIORef glrefDebugMessageCallbackKHR $ gldynDebugMessageCallbackKHR addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetDebugMessageLogKHR" + writeIORef glrefGetDebugMessageLogKHR $ gldynGetDebugMessageLogKHR addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPushDebugGroupKHR" + writeIORef glrefPushDebugGroupKHR $ gldynPushDebugGroupKHR addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPopDebugGroupKHR" + writeIORef glrefPopDebugGroupKHR $ gldynPopDebugGroupKHR addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glObjectLabelKHR" + writeIORef glrefObjectLabelKHR $ gldynObjectLabelKHR addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetObjectLabelKHR" + writeIORef glrefGetObjectLabelKHR $ gldynGetObjectLabelKHR addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glObjectPtrLabelKHR" + writeIORef glrefObjectPtrLabelKHR $ gldynObjectPtrLabelKHR addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetObjectPtrLabelKHR" + writeIORef glrefGetObjectPtrLabelKHR $ gldynGetObjectPtrLabelKHR addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetPointervKHR" + writeIORef glrefGetPointervKHR $ gldynGetPointervKHR addr + + -- GL_EXT_direct_state_access + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixLoadfEXT" + writeIORef glrefMatrixLoadfEXT $ gldynMatrixLoadfEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixLoaddEXT" + writeIORef glrefMatrixLoaddEXT $ gldynMatrixLoaddEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixMultfEXT" + writeIORef glrefMatrixMultfEXT $ gldynMatrixMultfEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixMultdEXT" + writeIORef glrefMatrixMultdEXT $ gldynMatrixMultdEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixLoadIdentityEXT" + writeIORef glrefMatrixLoadIdentityEXT $ gldynMatrixLoadIdentityEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixRotatefEXT" + writeIORef glrefMatrixRotatefEXT $ gldynMatrixRotatefEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixRotatedEXT" + writeIORef glrefMatrixRotatedEXT $ gldynMatrixRotatedEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixScalefEXT" + writeIORef glrefMatrixScalefEXT $ gldynMatrixScalefEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixScaledEXT" + writeIORef glrefMatrixScaledEXT $ gldynMatrixScaledEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixTranslatefEXT" + writeIORef glrefMatrixTranslatefEXT $ gldynMatrixTranslatefEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixTranslatedEXT" + writeIORef glrefMatrixTranslatedEXT $ gldynMatrixTranslatedEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixFrustumEXT" + writeIORef glrefMatrixFrustumEXT $ gldynMatrixFrustumEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixOrthoEXT" + writeIORef glrefMatrixOrthoEXT $ gldynMatrixOrthoEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixPopEXT" + writeIORef glrefMatrixPopEXT $ gldynMatrixPopEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixPushEXT" + writeIORef glrefMatrixPushEXT $ gldynMatrixPushEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClientAttribDefaultEXT" + writeIORef glrefClientAttribDefaultEXT $ gldynClientAttribDefaultEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glPushClientAttribDefaultEXT" + writeIORef glrefPushClientAttribDefaultEXT $ gldynPushClientAttribDefaultEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameterfEXT" + writeIORef glrefTextureParameterfEXT $ gldynTextureParameterfEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameterfvEXT" + writeIORef glrefTextureParameterfvEXT $ gldynTextureParameterfvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameteriEXT" + writeIORef glrefTextureParameteriEXT $ gldynTextureParameteriEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameterivEXT" + writeIORef glrefTextureParameterivEXT $ gldynTextureParameterivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureImage1DEXT" + writeIORef glrefTextureImage1DEXT $ gldynTextureImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureImage2DEXT" + writeIORef glrefTextureImage2DEXT $ gldynTextureImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureSubImage1DEXT" + writeIORef glrefTextureSubImage1DEXT $ gldynTextureSubImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureSubImage2DEXT" + writeIORef glrefTextureSubImage2DEXT $ gldynTextureSubImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTextureImage1DEXT" + writeIORef glrefCopyTextureImage1DEXT $ gldynCopyTextureImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTextureImage2DEXT" + writeIORef glrefCopyTextureImage2DEXT $ gldynCopyTextureImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTextureSubImage1DEXT" + writeIORef glrefCopyTextureSubImage1DEXT $ gldynCopyTextureSubImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTextureSubImage2DEXT" + writeIORef glrefCopyTextureSubImage2DEXT $ gldynCopyTextureSubImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureImageEXT" + writeIORef glrefGetTextureImageEXT $ gldynGetTextureImageEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureParameterfvEXT" + writeIORef glrefGetTextureParameterfvEXT $ gldynGetTextureParameterfvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureParameterivEXT" + writeIORef glrefGetTextureParameterivEXT $ gldynGetTextureParameterivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureLevelParameterfvEXT" + writeIORef glrefGetTextureLevelParameterfvEXT $ gldynGetTextureLevelParameterfvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureLevelParameterivEXT" + writeIORef glrefGetTextureLevelParameterivEXT $ gldynGetTextureLevelParameterivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureImage3DEXT" + writeIORef glrefTextureImage3DEXT $ gldynTextureImage3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureSubImage3DEXT" + writeIORef glrefTextureSubImage3DEXT $ gldynTextureSubImage3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyTextureSubImage3DEXT" + writeIORef glrefCopyTextureSubImage3DEXT $ gldynCopyTextureSubImage3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindMultiTextureEXT" + writeIORef glrefBindMultiTextureEXT $ gldynBindMultiTextureEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexCoordPointerEXT" + writeIORef glrefMultiTexCoordPointerEXT $ gldynMultiTexCoordPointerEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexEnvfEXT" + writeIORef glrefMultiTexEnvfEXT $ gldynMultiTexEnvfEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexEnvfvEXT" + writeIORef glrefMultiTexEnvfvEXT $ gldynMultiTexEnvfvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexEnviEXT" + writeIORef glrefMultiTexEnviEXT $ gldynMultiTexEnviEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexEnvivEXT" + writeIORef glrefMultiTexEnvivEXT $ gldynMultiTexEnvivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGendEXT" + writeIORef glrefMultiTexGendEXT $ gldynMultiTexGendEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGendvEXT" + writeIORef glrefMultiTexGendvEXT $ gldynMultiTexGendvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGenfEXT" + writeIORef glrefMultiTexGenfEXT $ gldynMultiTexGenfEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGenfvEXT" + writeIORef glrefMultiTexGenfvEXT $ gldynMultiTexGenfvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGeniEXT" + writeIORef glrefMultiTexGeniEXT $ gldynMultiTexGeniEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexGenivEXT" + writeIORef glrefMultiTexGenivEXT $ gldynMultiTexGenivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexEnvfvEXT" + writeIORef glrefGetMultiTexEnvfvEXT $ gldynGetMultiTexEnvfvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexEnvivEXT" + writeIORef glrefGetMultiTexEnvivEXT $ gldynGetMultiTexEnvivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexGendvEXT" + writeIORef glrefGetMultiTexGendvEXT $ gldynGetMultiTexGendvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexGenfvEXT" + writeIORef glrefGetMultiTexGenfvEXT $ gldynGetMultiTexGenfvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexGenivEXT" + writeIORef glrefGetMultiTexGenivEXT $ gldynGetMultiTexGenivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameteriEXT" + writeIORef glrefMultiTexParameteriEXT $ gldynMultiTexParameteriEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameterivEXT" + writeIORef glrefMultiTexParameterivEXT $ gldynMultiTexParameterivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameterfEXT" + writeIORef glrefMultiTexParameterfEXT $ gldynMultiTexParameterfEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameterfvEXT" + writeIORef glrefMultiTexParameterfvEXT $ gldynMultiTexParameterfvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexImage1DEXT" + writeIORef glrefMultiTexImage1DEXT $ gldynMultiTexImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexImage2DEXT" + writeIORef glrefMultiTexImage2DEXT $ gldynMultiTexImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexSubImage1DEXT" + writeIORef glrefMultiTexSubImage1DEXT $ gldynMultiTexSubImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexSubImage2DEXT" + writeIORef glrefMultiTexSubImage2DEXT $ gldynMultiTexSubImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyMultiTexImage1DEXT" + writeIORef glrefCopyMultiTexImage1DEXT $ gldynCopyMultiTexImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyMultiTexImage2DEXT" + writeIORef glrefCopyMultiTexImage2DEXT $ gldynCopyMultiTexImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyMultiTexSubImage1DEXT" + writeIORef glrefCopyMultiTexSubImage1DEXT $ gldynCopyMultiTexSubImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyMultiTexSubImage2DEXT" + writeIORef glrefCopyMultiTexSubImage2DEXT $ gldynCopyMultiTexSubImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexImageEXT" + writeIORef glrefGetMultiTexImageEXT $ gldynGetMultiTexImageEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexParameterfvEXT" + writeIORef glrefGetMultiTexParameterfvEXT $ gldynGetMultiTexParameterfvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexParameterivEXT" + writeIORef glrefGetMultiTexParameterivEXT $ gldynGetMultiTexParameterivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexLevelParameterfvEXT" + writeIORef glrefGetMultiTexLevelParameterfvEXT $ gldynGetMultiTexLevelParameterfvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexLevelParameterivEXT" + writeIORef glrefGetMultiTexLevelParameterivEXT $ gldynGetMultiTexLevelParameterivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexImage3DEXT" + writeIORef glrefMultiTexImage3DEXT $ gldynMultiTexImage3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexSubImage3DEXT" + writeIORef glrefMultiTexSubImage3DEXT $ gldynMultiTexSubImage3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCopyMultiTexSubImage3DEXT" + writeIORef glrefCopyMultiTexSubImage3DEXT $ gldynCopyMultiTexSubImage3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableClientStateIndexedEXT" + writeIORef glrefEnableClientStateIndexedEXT $ gldynEnableClientStateIndexedEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableClientStateIndexedEXT" + writeIORef glrefDisableClientStateIndexedEXT $ gldynDisableClientStateIndexedEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFloatIndexedvEXT" + writeIORef glrefGetFloatIndexedvEXT $ gldynGetFloatIndexedvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetDoubleIndexedvEXT" + writeIORef glrefGetDoubleIndexedvEXT $ gldynGetDoubleIndexedvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetPointerIndexedvEXT" + writeIORef glrefGetPointerIndexedvEXT $ gldynGetPointerIndexedvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableIndexedEXT" + writeIORef glrefEnableIndexedEXT $ gldynEnableIndexedEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableIndexedEXT" + writeIORef glrefDisableIndexedEXT $ gldynDisableIndexedEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsEnabledIndexedEXT" + writeIORef glrefIsEnabledIndexedEXT $ gldynIsEnabledIndexedEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetIntegerIndexedvEXT" + writeIORef glrefGetIntegerIndexedvEXT $ gldynGetIntegerIndexedvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetBooleanIndexedvEXT" + writeIORef glrefGetBooleanIndexedvEXT $ gldynGetBooleanIndexedvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureImage3DEXT" + writeIORef glrefCompressedTextureImage3DEXT $ gldynCompressedTextureImage3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureImage2DEXT" + writeIORef glrefCompressedTextureImage2DEXT $ gldynCompressedTextureImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureImage1DEXT" + writeIORef glrefCompressedTextureImage1DEXT $ gldynCompressedTextureImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureSubImage3DEXT" + writeIORef glrefCompressedTextureSubImage3DEXT $ gldynCompressedTextureSubImage3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureSubImage2DEXT" + writeIORef glrefCompressedTextureSubImage2DEXT $ gldynCompressedTextureSubImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedTextureSubImage1DEXT" + writeIORef glrefCompressedTextureSubImage1DEXT $ gldynCompressedTextureSubImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetCompressedTextureImageEXT" + writeIORef glrefGetCompressedTextureImageEXT $ gldynGetCompressedTextureImageEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexImage3DEXT" + writeIORef glrefCompressedMultiTexImage3DEXT $ gldynCompressedMultiTexImage3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexImage2DEXT" + writeIORef glrefCompressedMultiTexImage2DEXT $ gldynCompressedMultiTexImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexImage1DEXT" + writeIORef glrefCompressedMultiTexImage1DEXT $ gldynCompressedMultiTexImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexSubImage3DEXT" + writeIORef glrefCompressedMultiTexSubImage3DEXT $ gldynCompressedMultiTexSubImage3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexSubImage2DEXT" + writeIORef glrefCompressedMultiTexSubImage2DEXT $ gldynCompressedMultiTexSubImage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCompressedMultiTexSubImage1DEXT" + writeIORef glrefCompressedMultiTexSubImage1DEXT $ gldynCompressedMultiTexSubImage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetCompressedMultiTexImageEXT" + writeIORef glrefGetCompressedMultiTexImageEXT $ gldynGetCompressedMultiTexImageEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixLoadTransposefEXT" + writeIORef glrefMatrixLoadTransposefEXT $ gldynMatrixLoadTransposefEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixLoadTransposedEXT" + writeIORef glrefMatrixLoadTransposedEXT $ gldynMatrixLoadTransposedEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixMultTransposefEXT" + writeIORef glrefMatrixMultTransposefEXT $ gldynMatrixMultTransposefEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMatrixMultTransposedEXT" + writeIORef glrefMatrixMultTransposedEXT $ gldynMatrixMultTransposedEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedBufferDataEXT" + writeIORef glrefNamedBufferDataEXT $ gldynNamedBufferDataEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedBufferSubDataEXT" + writeIORef glrefNamedBufferSubDataEXT $ gldynNamedBufferSubDataEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMapNamedBufferEXT" + writeIORef glrefMapNamedBufferEXT $ gldynMapNamedBufferEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUnmapNamedBufferEXT" + writeIORef glrefUnmapNamedBufferEXT $ gldynUnmapNamedBufferEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedBufferParameterivEXT" + writeIORef glrefGetNamedBufferParameterivEXT $ gldynGetNamedBufferParameterivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedBufferPointervEXT" + writeIORef glrefGetNamedBufferPointervEXT $ gldynGetNamedBufferPointervEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedBufferSubDataEXT" + writeIORef glrefGetNamedBufferSubDataEXT $ gldynGetNamedBufferSubDataEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1fEXT" + writeIORef glrefProgramUniform1fEXT $ gldynProgramUniform1fEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2fEXT" + writeIORef glrefProgramUniform2fEXT $ gldynProgramUniform2fEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3fEXT" + writeIORef glrefProgramUniform3fEXT $ gldynProgramUniform3fEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4fEXT" + writeIORef glrefProgramUniform4fEXT $ gldynProgramUniform4fEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1iEXT" + writeIORef glrefProgramUniform1iEXT $ gldynProgramUniform1iEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2iEXT" + writeIORef glrefProgramUniform2iEXT $ gldynProgramUniform2iEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3iEXT" + writeIORef glrefProgramUniform3iEXT $ gldynProgramUniform3iEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4iEXT" + writeIORef glrefProgramUniform4iEXT $ gldynProgramUniform4iEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1fvEXT" + writeIORef glrefProgramUniform1fvEXT $ gldynProgramUniform1fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2fvEXT" + writeIORef glrefProgramUniform2fvEXT $ gldynProgramUniform2fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3fvEXT" + writeIORef glrefProgramUniform3fvEXT $ gldynProgramUniform3fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4fvEXT" + writeIORef glrefProgramUniform4fvEXT $ gldynProgramUniform4fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1ivEXT" + writeIORef glrefProgramUniform1ivEXT $ gldynProgramUniform1ivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2ivEXT" + writeIORef glrefProgramUniform2ivEXT $ gldynProgramUniform2ivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3ivEXT" + writeIORef glrefProgramUniform3ivEXT $ gldynProgramUniform3ivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4ivEXT" + writeIORef glrefProgramUniform4ivEXT $ gldynProgramUniform4ivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2fvEXT" + writeIORef glrefProgramUniformMatrix2fvEXT $ gldynProgramUniformMatrix2fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3fvEXT" + writeIORef glrefProgramUniformMatrix3fvEXT $ gldynProgramUniformMatrix3fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4fvEXT" + writeIORef glrefProgramUniformMatrix4fvEXT $ gldynProgramUniformMatrix4fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x3fvEXT" + writeIORef glrefProgramUniformMatrix2x3fvEXT $ gldynProgramUniformMatrix2x3fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x2fvEXT" + writeIORef glrefProgramUniformMatrix3x2fvEXT $ gldynProgramUniformMatrix3x2fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x4fvEXT" + writeIORef glrefProgramUniformMatrix2x4fvEXT $ gldynProgramUniformMatrix2x4fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x2fvEXT" + writeIORef glrefProgramUniformMatrix4x2fvEXT $ gldynProgramUniformMatrix4x2fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x4fvEXT" + writeIORef glrefProgramUniformMatrix3x4fvEXT $ gldynProgramUniformMatrix3x4fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x3fvEXT" + writeIORef glrefProgramUniformMatrix4x3fvEXT $ gldynProgramUniformMatrix4x3fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureBufferEXT" + writeIORef glrefTextureBufferEXT $ gldynTextureBufferEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexBufferEXT" + writeIORef glrefMultiTexBufferEXT $ gldynMultiTexBufferEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameterIivEXT" + writeIORef glrefTextureParameterIivEXT $ gldynTextureParameterIivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureParameterIuivEXT" + writeIORef glrefTextureParameterIuivEXT $ gldynTextureParameterIuivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureParameterIivEXT" + writeIORef glrefGetTextureParameterIivEXT $ gldynGetTextureParameterIivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetTextureParameterIuivEXT" + writeIORef glrefGetTextureParameterIuivEXT $ gldynGetTextureParameterIuivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameterIivEXT" + writeIORef glrefMultiTexParameterIivEXT $ gldynMultiTexParameterIivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexParameterIuivEXT" + writeIORef glrefMultiTexParameterIuivEXT $ gldynMultiTexParameterIuivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexParameterIivEXT" + writeIORef glrefGetMultiTexParameterIivEXT $ gldynGetMultiTexParameterIivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetMultiTexParameterIuivEXT" + writeIORef glrefGetMultiTexParameterIuivEXT $ gldynGetMultiTexParameterIuivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1uiEXT" + writeIORef glrefProgramUniform1uiEXT $ gldynProgramUniform1uiEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2uiEXT" + writeIORef glrefProgramUniform2uiEXT $ gldynProgramUniform2uiEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3uiEXT" + writeIORef glrefProgramUniform3uiEXT $ gldynProgramUniform3uiEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4uiEXT" + writeIORef glrefProgramUniform4uiEXT $ gldynProgramUniform4uiEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1uivEXT" + writeIORef glrefProgramUniform1uivEXT $ gldynProgramUniform1uivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2uivEXT" + writeIORef glrefProgramUniform2uivEXT $ gldynProgramUniform2uivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3uivEXT" + writeIORef glrefProgramUniform3uivEXT $ gldynProgramUniform3uivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4uivEXT" + writeIORef glrefProgramUniform4uivEXT $ gldynProgramUniform4uivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameters4fvEXT" + writeIORef glrefNamedProgramLocalParameters4fvEXT $ gldynNamedProgramLocalParameters4fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameterI4iEXT" + writeIORef glrefNamedProgramLocalParameterI4iEXT $ gldynNamedProgramLocalParameterI4iEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameterI4ivEXT" + writeIORef glrefNamedProgramLocalParameterI4ivEXT $ gldynNamedProgramLocalParameterI4ivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParametersI4ivEXT" + writeIORef glrefNamedProgramLocalParametersI4ivEXT $ gldynNamedProgramLocalParametersI4ivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameterI4uiEXT" + writeIORef glrefNamedProgramLocalParameterI4uiEXT $ gldynNamedProgramLocalParameterI4uiEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameterI4uivEXT" + writeIORef glrefNamedProgramLocalParameterI4uivEXT $ gldynNamedProgramLocalParameterI4uivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParametersI4uivEXT" + writeIORef glrefNamedProgramLocalParametersI4uivEXT $ gldynNamedProgramLocalParametersI4uivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramLocalParameterIivEXT" + writeIORef glrefGetNamedProgramLocalParameterIivEXT $ gldynGetNamedProgramLocalParameterIivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramLocalParameterIuivEXT" + writeIORef glrefGetNamedProgramLocalParameterIuivEXT $ gldynGetNamedProgramLocalParameterIuivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableClientStateiEXT" + writeIORef glrefEnableClientStateiEXT $ gldynEnableClientStateiEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableClientStateiEXT" + writeIORef glrefDisableClientStateiEXT $ gldynDisableClientStateiEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFloati_vEXT" + writeIORef glrefGetFloati_vEXT $ gldynGetFloati_vEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetDoublei_vEXT" + writeIORef glrefGetDoublei_vEXT $ gldynGetDoublei_vEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetPointeri_vEXT" + writeIORef glrefGetPointeri_vEXT $ gldynGetPointeri_vEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramStringEXT" + writeIORef glrefNamedProgramStringEXT $ gldynNamedProgramStringEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameter4dEXT" + writeIORef glrefNamedProgramLocalParameter4dEXT $ gldynNamedProgramLocalParameter4dEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameter4dvEXT" + writeIORef glrefNamedProgramLocalParameter4dvEXT $ gldynNamedProgramLocalParameter4dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameter4fEXT" + writeIORef glrefNamedProgramLocalParameter4fEXT $ gldynNamedProgramLocalParameter4fEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedProgramLocalParameter4fvEXT" + writeIORef glrefNamedProgramLocalParameter4fvEXT $ gldynNamedProgramLocalParameter4fvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramLocalParameterdvEXT" + writeIORef glrefGetNamedProgramLocalParameterdvEXT $ gldynGetNamedProgramLocalParameterdvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramLocalParameterfvEXT" + writeIORef glrefGetNamedProgramLocalParameterfvEXT $ gldynGetNamedProgramLocalParameterfvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramivEXT" + writeIORef glrefGetNamedProgramivEXT $ gldynGetNamedProgramivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedProgramStringEXT" + writeIORef glrefGetNamedProgramStringEXT $ gldynGetNamedProgramStringEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedRenderbufferStorageEXT" + writeIORef glrefNamedRenderbufferStorageEXT $ gldynNamedRenderbufferStorageEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedRenderbufferParameterivEXT" + writeIORef glrefGetNamedRenderbufferParameterivEXT $ gldynGetNamedRenderbufferParameterivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedRenderbufferStorageMultisampleEXT" + writeIORef glrefNamedRenderbufferStorageMultisampleEXT $ gldynNamedRenderbufferStorageMultisampleEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedRenderbufferStorageMultisampleCoverageEXT" + writeIORef glrefNamedRenderbufferStorageMultisampleCoverageEXT $ gldynNamedRenderbufferStorageMultisampleCoverageEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCheckNamedFramebufferStatusEXT" + writeIORef glrefCheckNamedFramebufferStatusEXT $ gldynCheckNamedFramebufferStatusEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTexture1DEXT" + writeIORef glrefNamedFramebufferTexture1DEXT $ gldynNamedFramebufferTexture1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTexture2DEXT" + writeIORef glrefNamedFramebufferTexture2DEXT $ gldynNamedFramebufferTexture2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTexture3DEXT" + writeIORef glrefNamedFramebufferTexture3DEXT $ gldynNamedFramebufferTexture3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferRenderbufferEXT" + writeIORef glrefNamedFramebufferRenderbufferEXT $ gldynNamedFramebufferRenderbufferEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedFramebufferAttachmentParameterivEXT" + writeIORef glrefGetNamedFramebufferAttachmentParameterivEXT $ gldynGetNamedFramebufferAttachmentParameterivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenerateTextureMipmapEXT" + writeIORef glrefGenerateTextureMipmapEXT $ gldynGenerateTextureMipmapEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenerateMultiTexMipmapEXT" + writeIORef glrefGenerateMultiTexMipmapEXT $ gldynGenerateMultiTexMipmapEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferDrawBufferEXT" + writeIORef glrefFramebufferDrawBufferEXT $ gldynFramebufferDrawBufferEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferDrawBuffersEXT" + writeIORef glrefFramebufferDrawBuffersEXT $ gldynFramebufferDrawBuffersEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFramebufferReadBufferEXT" + writeIORef glrefFramebufferReadBufferEXT $ gldynFramebufferReadBufferEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetFramebufferParameterivEXT" + writeIORef glrefGetFramebufferParameterivEXT $ gldynGetFramebufferParameterivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedCopyBufferSubDataEXT" + writeIORef glrefNamedCopyBufferSubDataEXT $ gldynNamedCopyBufferSubDataEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTextureEXT" + writeIORef glrefNamedFramebufferTextureEXT $ gldynNamedFramebufferTextureEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTextureLayerEXT" + writeIORef glrefNamedFramebufferTextureLayerEXT $ gldynNamedFramebufferTextureLayerEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferTextureFaceEXT" + writeIORef glrefNamedFramebufferTextureFaceEXT $ gldynNamedFramebufferTextureFaceEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureRenderbufferEXT" + writeIORef glrefTextureRenderbufferEXT $ gldynTextureRenderbufferEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMultiTexRenderbufferEXT" + writeIORef glrefMultiTexRenderbufferEXT $ gldynMultiTexRenderbufferEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexOffsetEXT" + writeIORef glrefVertexArrayVertexOffsetEXT $ gldynVertexArrayVertexOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayColorOffsetEXT" + writeIORef glrefVertexArrayColorOffsetEXT $ gldynVertexArrayColorOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayEdgeFlagOffsetEXT" + writeIORef glrefVertexArrayEdgeFlagOffsetEXT $ gldynVertexArrayEdgeFlagOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayIndexOffsetEXT" + writeIORef glrefVertexArrayIndexOffsetEXT $ gldynVertexArrayIndexOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayNormalOffsetEXT" + writeIORef glrefVertexArrayNormalOffsetEXT $ gldynVertexArrayNormalOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayTexCoordOffsetEXT" + writeIORef glrefVertexArrayTexCoordOffsetEXT $ gldynVertexArrayTexCoordOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayMultiTexCoordOffsetEXT" + writeIORef glrefVertexArrayMultiTexCoordOffsetEXT $ gldynVertexArrayMultiTexCoordOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayFogCoordOffsetEXT" + writeIORef glrefVertexArrayFogCoordOffsetEXT $ gldynVertexArrayFogCoordOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArraySecondaryColorOffsetEXT" + writeIORef glrefVertexArraySecondaryColorOffsetEXT $ gldynVertexArraySecondaryColorOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribOffsetEXT" + writeIORef glrefVertexArrayVertexAttribOffsetEXT $ gldynVertexArrayVertexAttribOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribIOffsetEXT" + writeIORef glrefVertexArrayVertexAttribIOffsetEXT $ gldynVertexArrayVertexAttribIOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableVertexArrayEXT" + writeIORef glrefEnableVertexArrayEXT $ gldynEnableVertexArrayEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableVertexArrayEXT" + writeIORef glrefDisableVertexArrayEXT $ gldynDisableVertexArrayEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glEnableVertexArrayAttribEXT" + writeIORef glrefEnableVertexArrayAttribEXT $ gldynEnableVertexArrayAttribEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDisableVertexArrayAttribEXT" + writeIORef glrefDisableVertexArrayAttribEXT $ gldynDisableVertexArrayAttribEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexArrayIntegervEXT" + writeIORef glrefGetVertexArrayIntegervEXT $ gldynGetVertexArrayIntegervEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexArrayPointervEXT" + writeIORef glrefGetVertexArrayPointervEXT $ gldynGetVertexArrayPointervEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexArrayIntegeri_vEXT" + writeIORef glrefGetVertexArrayIntegeri_vEXT $ gldynGetVertexArrayIntegeri_vEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetVertexArrayPointeri_vEXT" + writeIORef glrefGetVertexArrayPointeri_vEXT $ gldynGetVertexArrayPointeri_vEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glMapNamedBufferRangeEXT" + writeIORef glrefMapNamedBufferRangeEXT $ gldynMapNamedBufferRangeEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glFlushMappedNamedBufferRangeEXT" + writeIORef glrefFlushMappedNamedBufferRangeEXT $ gldynFlushMappedNamedBufferRangeEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedBufferStorageEXT" + writeIORef glrefNamedBufferStorageEXT $ gldynNamedBufferStorageEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearNamedBufferDataEXT" + writeIORef glrefClearNamedBufferDataEXT $ gldynClearNamedBufferDataEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glClearNamedBufferSubDataEXT" + writeIORef glrefClearNamedBufferSubDataEXT $ gldynClearNamedBufferSubDataEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glNamedFramebufferParameteriEXT" + writeIORef glrefNamedFramebufferParameteriEXT $ gldynNamedFramebufferParameteriEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetNamedFramebufferParameterivEXT" + writeIORef glrefGetNamedFramebufferParameterivEXT $ gldynGetNamedFramebufferParameterivEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1dEXT" + writeIORef glrefProgramUniform1dEXT $ gldynProgramUniform1dEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2dEXT" + writeIORef glrefProgramUniform2dEXT $ gldynProgramUniform2dEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3dEXT" + writeIORef glrefProgramUniform3dEXT $ gldynProgramUniform3dEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4dEXT" + writeIORef glrefProgramUniform4dEXT $ gldynProgramUniform4dEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1dvEXT" + writeIORef glrefProgramUniform1dvEXT $ gldynProgramUniform1dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2dvEXT" + writeIORef glrefProgramUniform2dvEXT $ gldynProgramUniform2dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3dvEXT" + writeIORef glrefProgramUniform3dvEXT $ gldynProgramUniform3dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4dvEXT" + writeIORef glrefProgramUniform4dvEXT $ gldynProgramUniform4dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2dvEXT" + writeIORef glrefProgramUniformMatrix2dvEXT $ gldynProgramUniformMatrix2dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3dvEXT" + writeIORef glrefProgramUniformMatrix3dvEXT $ gldynProgramUniformMatrix3dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4dvEXT" + writeIORef glrefProgramUniformMatrix4dvEXT $ gldynProgramUniformMatrix4dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x3dvEXT" + writeIORef glrefProgramUniformMatrix2x3dvEXT $ gldynProgramUniformMatrix2x3dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x4dvEXT" + writeIORef glrefProgramUniformMatrix2x4dvEXT $ gldynProgramUniformMatrix2x4dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x2dvEXT" + writeIORef glrefProgramUniformMatrix3x2dvEXT $ gldynProgramUniformMatrix3x2dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x4dvEXT" + writeIORef glrefProgramUniformMatrix3x4dvEXT $ gldynProgramUniformMatrix3x4dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x2dvEXT" + writeIORef glrefProgramUniformMatrix4x2dvEXT $ gldynProgramUniformMatrix4x2dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x3dvEXT" + writeIORef glrefProgramUniformMatrix4x3dvEXT $ gldynProgramUniformMatrix4x3dvEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureBufferRangeEXT" + writeIORef glrefTextureBufferRangeEXT $ gldynTextureBufferRangeEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureStorage1DEXT" + writeIORef glrefTextureStorage1DEXT $ gldynTextureStorage1DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureStorage2DEXT" + writeIORef glrefTextureStorage2DEXT $ gldynTextureStorage2DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureStorage3DEXT" + writeIORef glrefTextureStorage3DEXT $ gldynTextureStorage3DEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureStorage2DMultisampleEXT" + writeIORef glrefTextureStorage2DMultisampleEXT $ gldynTextureStorage2DMultisampleEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTextureStorage3DMultisampleEXT" + writeIORef glrefTextureStorage3DMultisampleEXT $ gldynTextureStorage3DMultisampleEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayBindVertexBufferEXT" + writeIORef glrefVertexArrayBindVertexBufferEXT $ gldynVertexArrayBindVertexBufferEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribFormatEXT" + writeIORef glrefVertexArrayVertexAttribFormatEXT $ gldynVertexArrayVertexAttribFormatEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribIFormatEXT" + writeIORef glrefVertexArrayVertexAttribIFormatEXT $ gldynVertexArrayVertexAttribIFormatEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribLFormatEXT" + writeIORef glrefVertexArrayVertexAttribLFormatEXT $ gldynVertexArrayVertexAttribLFormatEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribBindingEXT" + writeIORef glrefVertexArrayVertexAttribBindingEXT $ gldynVertexArrayVertexAttribBindingEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexBindingDivisorEXT" + writeIORef glrefVertexArrayVertexBindingDivisorEXT $ gldynVertexArrayVertexBindingDivisorEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribLOffsetEXT" + writeIORef glrefVertexArrayVertexAttribLOffsetEXT $ gldynVertexArrayVertexAttribLOffsetEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glTexturePageCommitmentEXT" + writeIORef glrefTexturePageCommitmentEXT $ gldynTexturePageCommitmentEXT addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glVertexArrayVertexAttribDivisorEXT" + writeIORef glrefVertexArrayVertexAttribDivisorEXT $ gldynVertexArrayVertexAttribDivisorEXT addr + + -- GL_ARB_buffer_storage + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBufferStorage" + writeIORef glrefBufferStorage $ gldynBufferStorage addr + + -- GL_ARB_separate_shader_objects + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glUseProgramStages" + writeIORef glrefUseProgramStages $ gldynUseProgramStages addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glActiveShaderProgram" + writeIORef glrefActiveShaderProgram $ gldynActiveShaderProgram addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glCreateShaderProgramv" + writeIORef glrefCreateShaderProgramv $ gldynCreateShaderProgramv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glBindProgramPipeline" + writeIORef glrefBindProgramPipeline $ gldynBindProgramPipeline addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glDeleteProgramPipelines" + writeIORef glrefDeleteProgramPipelines $ gldynDeleteProgramPipelines addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGenProgramPipelines" + writeIORef glrefGenProgramPipelines $ gldynGenProgramPipelines addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glIsProgramPipeline" + writeIORef glrefIsProgramPipeline $ gldynIsProgramPipeline addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetProgramPipelineiv" + writeIORef glrefGetProgramPipelineiv $ gldynGetProgramPipelineiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1i" + writeIORef glrefProgramUniform1i $ gldynProgramUniform1i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1iv" + writeIORef glrefProgramUniform1iv $ gldynProgramUniform1iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1f" + writeIORef glrefProgramUniform1f $ gldynProgramUniform1f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1fv" + writeIORef glrefProgramUniform1fv $ gldynProgramUniform1fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1d" + writeIORef glrefProgramUniform1d $ gldynProgramUniform1d addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1dv" + writeIORef glrefProgramUniform1dv $ gldynProgramUniform1dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1ui" + writeIORef glrefProgramUniform1ui $ gldynProgramUniform1ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform1uiv" + writeIORef glrefProgramUniform1uiv $ gldynProgramUniform1uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2i" + writeIORef glrefProgramUniform2i $ gldynProgramUniform2i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2iv" + writeIORef glrefProgramUniform2iv $ gldynProgramUniform2iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2f" + writeIORef glrefProgramUniform2f $ gldynProgramUniform2f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2fv" + writeIORef glrefProgramUniform2fv $ gldynProgramUniform2fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2d" + writeIORef glrefProgramUniform2d $ gldynProgramUniform2d addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2dv" + writeIORef glrefProgramUniform2dv $ gldynProgramUniform2dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2ui" + writeIORef glrefProgramUniform2ui $ gldynProgramUniform2ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform2uiv" + writeIORef glrefProgramUniform2uiv $ gldynProgramUniform2uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3i" + writeIORef glrefProgramUniform3i $ gldynProgramUniform3i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3iv" + writeIORef glrefProgramUniform3iv $ gldynProgramUniform3iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3f" + writeIORef glrefProgramUniform3f $ gldynProgramUniform3f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3fv" + writeIORef glrefProgramUniform3fv $ gldynProgramUniform3fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3d" + writeIORef glrefProgramUniform3d $ gldynProgramUniform3d addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3dv" + writeIORef glrefProgramUniform3dv $ gldynProgramUniform3dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3ui" + writeIORef glrefProgramUniform3ui $ gldynProgramUniform3ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform3uiv" + writeIORef glrefProgramUniform3uiv $ gldynProgramUniform3uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4i" + writeIORef glrefProgramUniform4i $ gldynProgramUniform4i addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4iv" + writeIORef glrefProgramUniform4iv $ gldynProgramUniform4iv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4f" + writeIORef glrefProgramUniform4f $ gldynProgramUniform4f addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4fv" + writeIORef glrefProgramUniform4fv $ gldynProgramUniform4fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4d" + writeIORef glrefProgramUniform4d $ gldynProgramUniform4d addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4dv" + writeIORef glrefProgramUniform4dv $ gldynProgramUniform4dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4ui" + writeIORef glrefProgramUniform4ui $ gldynProgramUniform4ui addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniform4uiv" + writeIORef glrefProgramUniform4uiv $ gldynProgramUniform4uiv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2fv" + writeIORef glrefProgramUniformMatrix2fv $ gldynProgramUniformMatrix2fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3fv" + writeIORef glrefProgramUniformMatrix3fv $ gldynProgramUniformMatrix3fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4fv" + writeIORef glrefProgramUniformMatrix4fv $ gldynProgramUniformMatrix4fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2dv" + writeIORef glrefProgramUniformMatrix2dv $ gldynProgramUniformMatrix2dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3dv" + writeIORef glrefProgramUniformMatrix3dv $ gldynProgramUniformMatrix3dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4dv" + writeIORef glrefProgramUniformMatrix4dv $ gldynProgramUniformMatrix4dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x3fv" + writeIORef glrefProgramUniformMatrix2x3fv $ gldynProgramUniformMatrix2x3fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x2fv" + writeIORef glrefProgramUniformMatrix3x2fv $ gldynProgramUniformMatrix3x2fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x4fv" + writeIORef glrefProgramUniformMatrix2x4fv $ gldynProgramUniformMatrix2x4fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x2fv" + writeIORef glrefProgramUniformMatrix4x2fv $ gldynProgramUniformMatrix4x2fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x4fv" + writeIORef glrefProgramUniformMatrix3x4fv $ gldynProgramUniformMatrix3x4fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x3fv" + writeIORef glrefProgramUniformMatrix4x3fv $ gldynProgramUniformMatrix4x3fv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x3dv" + writeIORef glrefProgramUniformMatrix2x3dv $ gldynProgramUniformMatrix2x3dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x2dv" + writeIORef glrefProgramUniformMatrix3x2dv $ gldynProgramUniformMatrix3x2dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix2x4dv" + writeIORef glrefProgramUniformMatrix2x4dv $ gldynProgramUniformMatrix2x4dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x2dv" + writeIORef glrefProgramUniformMatrix4x2dv $ gldynProgramUniformMatrix4x2dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix3x4dv" + writeIORef glrefProgramUniformMatrix3x4dv $ gldynProgramUniformMatrix3x4dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glProgramUniformMatrix4x3dv" + writeIORef glrefProgramUniformMatrix4x3dv $ gldynProgramUniformMatrix4x3dv addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glValidateProgramPipeline" + writeIORef glrefValidateProgramPipeline $ gldynValidateProgramPipeline addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glGetProgramPipelineInfoLog" + writeIORef glrefGetProgramPipelineInfoLog $ gldynGetProgramPipelineInfoLog addr + + -- GL_ATI_meminfo + + + -- GL_NVX_gpu_memory_info + + + -- GL_ARB_invalidate_subdata + + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateTexSubImage" + writeIORef glrefInvalidateTexSubImage $ gldynInvalidateTexSubImage addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateTexImage" + writeIORef glrefInvalidateTexImage $ gldynInvalidateTexImage addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateBufferSubData" + writeIORef glrefInvalidateBufferSubData $ gldynInvalidateBufferSubData addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateBufferData" + writeIORef glrefInvalidateBufferData $ gldynInvalidateBufferData addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateFramebuffer" + writeIORef glrefInvalidateFramebuffer $ gldynInvalidateFramebuffer addr + when True $ liftIO $ do + addr <- castPtrToFunPtr . castPtr <$> get_proc_address "glInvalidateSubFramebuffer" + writeIORef glrefInvalidateSubFramebuffer $ gldynInvalidateSubFramebuffer addr + + + + when True $ do + result <- liftIO $ is_supported "GL_ARB_texture_storage" + unless result $ do + throwE $ Failure $ "Missing OpenGL extension: " ++ "GL_ARB_texture_storage" + when True $ do + result <- liftIO $ is_supported "GL_KHR_debug" + liftIO $ writeIORef hasref_GL_KHR_debug result + when True $ do + result <- liftIO $ is_supported "GL_EXT_direct_state_access" + liftIO $ writeIORef hasref_GL_EXT_direct_state_access result + when True $ do + result <- liftIO $ is_supported "GL_ARB_buffer_storage" + liftIO $ writeIORef hasref_GL_ARB_buffer_storage result + when True $ do + result <- liftIO $ is_supported "GL_ARB_separate_shader_objects" + liftIO $ writeIORef hasref_GL_ARB_separate_shader_objects result + when True $ do + result <- liftIO $ is_supported "GL_ATI_meminfo" + liftIO $ writeIORef hasref_GL_ATI_meminfo result + when True $ do + result <- liftIO $ is_supported "GL_NVX_gpu_memory_info" + liftIO $ writeIORef hasref_GL_NVX_gpu_memory_info result + when True $ do + result <- liftIO $ is_supported "GL_ARB_invalidate_subdata" + liftIO $ writeIORef hasref_GL_ARB_invalidate_subdata result + + return Success + +has_GL_ARB_texture_storage :: IO Bool +has_GL_ARB_texture_storage = readIORef hasref_GL_ARB_texture_storage +{-# INLINE has_GL_ARB_texture_storage #-} +hasref_GL_ARB_texture_storage :: IORef Bool +hasref_GL_ARB_texture_storage = unsafePerformIO $ newIORef True +{-# NOINLINE hasref_GL_ARB_texture_storage #-} +has_GL_KHR_debug :: IO Bool +has_GL_KHR_debug = readIORef hasref_GL_KHR_debug +{-# INLINE has_GL_KHR_debug #-} +hasref_GL_KHR_debug :: IORef Bool +hasref_GL_KHR_debug = unsafePerformIO $ newIORef False +{-# NOINLINE hasref_GL_KHR_debug #-} +has_GL_EXT_direct_state_access :: IO Bool +has_GL_EXT_direct_state_access = readIORef hasref_GL_EXT_direct_state_access +{-# INLINE has_GL_EXT_direct_state_access #-} +hasref_GL_EXT_direct_state_access :: IORef Bool +hasref_GL_EXT_direct_state_access = unsafePerformIO $ newIORef False +{-# NOINLINE hasref_GL_EXT_direct_state_access #-} +has_GL_ARB_buffer_storage :: IO Bool +has_GL_ARB_buffer_storage = readIORef hasref_GL_ARB_buffer_storage +{-# INLINE has_GL_ARB_buffer_storage #-} +hasref_GL_ARB_buffer_storage :: IORef Bool +hasref_GL_ARB_buffer_storage = unsafePerformIO $ newIORef False +{-# NOINLINE hasref_GL_ARB_buffer_storage #-} +has_GL_ARB_separate_shader_objects :: IO Bool +has_GL_ARB_separate_shader_objects = readIORef hasref_GL_ARB_separate_shader_objects +{-# INLINE has_GL_ARB_separate_shader_objects #-} +hasref_GL_ARB_separate_shader_objects :: IORef Bool +hasref_GL_ARB_separate_shader_objects = unsafePerformIO $ newIORef False +{-# NOINLINE hasref_GL_ARB_separate_shader_objects #-} +has_GL_ATI_meminfo :: IO Bool +has_GL_ATI_meminfo = readIORef hasref_GL_ATI_meminfo +{-# INLINE has_GL_ATI_meminfo #-} +hasref_GL_ATI_meminfo :: IORef Bool +hasref_GL_ATI_meminfo = unsafePerformIO $ newIORef False +{-# NOINLINE hasref_GL_ATI_meminfo #-} +has_GL_NVX_gpu_memory_info :: IO Bool +has_GL_NVX_gpu_memory_info = readIORef hasref_GL_NVX_gpu_memory_info +{-# INLINE has_GL_NVX_gpu_memory_info #-} +hasref_GL_NVX_gpu_memory_info :: IORef Bool +hasref_GL_NVX_gpu_memory_info = unsafePerformIO $ newIORef False +{-# NOINLINE hasref_GL_NVX_gpu_memory_info #-} +has_GL_ARB_invalidate_subdata :: IO Bool +has_GL_ARB_invalidate_subdata = readIORef hasref_GL_ARB_invalidate_subdata +{-# INLINE has_GL_ARB_invalidate_subdata #-} +hasref_GL_ARB_invalidate_subdata :: IORef Bool +hasref_GL_ARB_invalidate_subdata = unsafePerformIO $ newIORef False +{-# NOINLINE hasref_GL_ARB_invalidate_subdata #-} + + +-- GL_VERSION_1_0 + +type FuntypeCullFace = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCullFace :: FunPtr FuntypeCullFace -> FuntypeCullFace +glrefCullFace :: IORef FuntypeCullFace +glrefCullFace = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCullFace #-} +glCullFace :: FuntypeCullFace +glCullFace = unsafePerformIO $ readIORef glrefCullFace +{-# INLINE glCullFace #-} +type FuntypeFrontFace = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFrontFace :: FunPtr FuntypeFrontFace -> FuntypeFrontFace +glrefFrontFace :: IORef FuntypeFrontFace +glrefFrontFace = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFrontFace #-} +glFrontFace :: FuntypeFrontFace +glFrontFace = unsafePerformIO $ readIORef glrefFrontFace +{-# INLINE glFrontFace #-} +type FuntypeHint = + GLenum -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynHint :: FunPtr FuntypeHint -> FuntypeHint +glrefHint :: IORef FuntypeHint +glrefHint = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefHint #-} +glHint :: FuntypeHint +glHint = unsafePerformIO $ readIORef glrefHint +{-# INLINE glHint #-} +type FuntypeLineWidth = + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynLineWidth :: FunPtr FuntypeLineWidth -> FuntypeLineWidth +glrefLineWidth :: IORef FuntypeLineWidth +glrefLineWidth = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefLineWidth #-} +glLineWidth :: FuntypeLineWidth +glLineWidth = unsafePerformIO $ readIORef glrefLineWidth +{-# INLINE glLineWidth #-} +type FuntypePointSize = + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPointSize :: FunPtr FuntypePointSize -> FuntypePointSize +glrefPointSize :: IORef FuntypePointSize +glrefPointSize = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPointSize #-} +glPointSize :: FuntypePointSize +glPointSize = unsafePerformIO $ readIORef glrefPointSize +{-# INLINE glPointSize #-} +type FuntypePolygonMode = + GLenum -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPolygonMode :: FunPtr FuntypePolygonMode -> FuntypePolygonMode +glrefPolygonMode :: IORef FuntypePolygonMode +glrefPolygonMode = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPolygonMode #-} +glPolygonMode :: FuntypePolygonMode +glPolygonMode = unsafePerformIO $ readIORef glrefPolygonMode +{-# INLINE glPolygonMode #-} +type FuntypeScissor = + GLint -> + GLint -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynScissor :: FunPtr FuntypeScissor -> FuntypeScissor +glrefScissor :: IORef FuntypeScissor +glrefScissor = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefScissor #-} +glScissor :: FuntypeScissor +glScissor = unsafePerformIO $ readIORef glrefScissor +{-# INLINE glScissor #-} +type FuntypeTexParameterf = + GLenum -> + GLenum -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexParameterf :: FunPtr FuntypeTexParameterf -> FuntypeTexParameterf +glrefTexParameterf :: IORef FuntypeTexParameterf +glrefTexParameterf = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexParameterf #-} +glTexParameterf :: FuntypeTexParameterf +glTexParameterf = unsafePerformIO $ readIORef glrefTexParameterf +{-# INLINE glTexParameterf #-} +type FuntypeTexParameterfv = + GLenum -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexParameterfv :: FunPtr FuntypeTexParameterfv -> FuntypeTexParameterfv +glrefTexParameterfv :: IORef FuntypeTexParameterfv +glrefTexParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexParameterfv #-} +glTexParameterfv :: FuntypeTexParameterfv +glTexParameterfv = unsafePerformIO $ readIORef glrefTexParameterfv +{-# INLINE glTexParameterfv #-} +type FuntypeTexParameteri = + GLenum -> + GLenum -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexParameteri :: FunPtr FuntypeTexParameteri -> FuntypeTexParameteri +glrefTexParameteri :: IORef FuntypeTexParameteri +glrefTexParameteri = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexParameteri #-} +glTexParameteri :: FuntypeTexParameteri +glTexParameteri = unsafePerformIO $ readIORef glrefTexParameteri +{-# INLINE glTexParameteri #-} +type FuntypeTexParameteriv = + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexParameteriv :: FunPtr FuntypeTexParameteriv -> FuntypeTexParameteriv +glrefTexParameteriv :: IORef FuntypeTexParameteriv +glrefTexParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexParameteriv #-} +glTexParameteriv :: FuntypeTexParameteriv +glTexParameteriv = unsafePerformIO $ readIORef glrefTexParameteriv +{-# INLINE glTexParameteriv #-} +type FuntypeTexImage1D = + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexImage1D :: FunPtr FuntypeTexImage1D -> FuntypeTexImage1D +glrefTexImage1D :: IORef FuntypeTexImage1D +glrefTexImage1D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexImage1D #-} +glTexImage1D :: FuntypeTexImage1D +glTexImage1D = unsafePerformIO $ readIORef glrefTexImage1D +{-# INLINE glTexImage1D #-} +type FuntypeTexImage2D = + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexImage2D :: FunPtr FuntypeTexImage2D -> FuntypeTexImage2D +glrefTexImage2D :: IORef FuntypeTexImage2D +glrefTexImage2D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexImage2D #-} +glTexImage2D :: FuntypeTexImage2D +glTexImage2D = unsafePerformIO $ readIORef glrefTexImage2D +{-# INLINE glTexImage2D #-} +type FuntypeDrawBuffer = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDrawBuffer :: FunPtr FuntypeDrawBuffer -> FuntypeDrawBuffer +glrefDrawBuffer :: IORef FuntypeDrawBuffer +glrefDrawBuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDrawBuffer #-} +glDrawBuffer :: FuntypeDrawBuffer +glDrawBuffer = unsafePerformIO $ readIORef glrefDrawBuffer +{-# INLINE glDrawBuffer #-} +type FuntypeClear = + GLbitfield -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClear :: FunPtr FuntypeClear -> FuntypeClear +glrefClear :: IORef FuntypeClear +glrefClear = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClear #-} +glClear :: FuntypeClear +glClear = unsafePerformIO $ readIORef glrefClear +{-# INLINE glClear #-} +type FuntypeClearColor = + GLfloat -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClearColor :: FunPtr FuntypeClearColor -> FuntypeClearColor +glrefClearColor :: IORef FuntypeClearColor +glrefClearColor = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClearColor #-} +glClearColor :: FuntypeClearColor +glClearColor = unsafePerformIO $ readIORef glrefClearColor +{-# INLINE glClearColor #-} +type FuntypeClearStencil = + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClearStencil :: FunPtr FuntypeClearStencil -> FuntypeClearStencil +glrefClearStencil :: IORef FuntypeClearStencil +glrefClearStencil = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClearStencil #-} +glClearStencil :: FuntypeClearStencil +glClearStencil = unsafePerformIO $ readIORef glrefClearStencil +{-# INLINE glClearStencil #-} +type FuntypeClearDepth = + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClearDepth :: FunPtr FuntypeClearDepth -> FuntypeClearDepth +glrefClearDepth :: IORef FuntypeClearDepth +glrefClearDepth = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClearDepth #-} +glClearDepth :: FuntypeClearDepth +glClearDepth = unsafePerformIO $ readIORef glrefClearDepth +{-# INLINE glClearDepth #-} +type FuntypeStencilMask = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynStencilMask :: FunPtr FuntypeStencilMask -> FuntypeStencilMask +glrefStencilMask :: IORef FuntypeStencilMask +glrefStencilMask = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefStencilMask #-} +glStencilMask :: FuntypeStencilMask +glStencilMask = unsafePerformIO $ readIORef glrefStencilMask +{-# INLINE glStencilMask #-} +type FuntypeColorMask = + GLboolean -> + GLboolean -> + GLboolean -> + GLboolean -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynColorMask :: FunPtr FuntypeColorMask -> FuntypeColorMask +glrefColorMask :: IORef FuntypeColorMask +glrefColorMask = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefColorMask #-} +glColorMask :: FuntypeColorMask +glColorMask = unsafePerformIO $ readIORef glrefColorMask +{-# INLINE glColorMask #-} +type FuntypeDepthMask = + GLboolean -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDepthMask :: FunPtr FuntypeDepthMask -> FuntypeDepthMask +glrefDepthMask :: IORef FuntypeDepthMask +glrefDepthMask = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDepthMask #-} +glDepthMask :: FuntypeDepthMask +glDepthMask = unsafePerformIO $ readIORef glrefDepthMask +{-# INLINE glDepthMask #-} +type FuntypeDisable = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDisable :: FunPtr FuntypeDisable -> FuntypeDisable +glrefDisable :: IORef FuntypeDisable +glrefDisable = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDisable #-} +glDisable :: FuntypeDisable +glDisable = unsafePerformIO $ readIORef glrefDisable +{-# INLINE glDisable #-} +type FuntypeEnable = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynEnable :: FunPtr FuntypeEnable -> FuntypeEnable +glrefEnable :: IORef FuntypeEnable +glrefEnable = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefEnable #-} +glEnable :: FuntypeEnable +glEnable = unsafePerformIO $ readIORef glrefEnable +{-# INLINE glEnable #-} +type FuntypeFinish = + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFinish :: FunPtr FuntypeFinish -> FuntypeFinish +glrefFinish :: IORef FuntypeFinish +glrefFinish = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFinish #-} +glFinish :: FuntypeFinish +glFinish = unsafePerformIO $ readIORef glrefFinish +{-# INLINE glFinish #-} +type FuntypeFlush = + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFlush :: FunPtr FuntypeFlush -> FuntypeFlush +glrefFlush :: IORef FuntypeFlush +glrefFlush = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFlush #-} +glFlush :: FuntypeFlush +glFlush = unsafePerformIO $ readIORef glrefFlush +{-# INLINE glFlush #-} +type FuntypeBlendFunc = + GLenum -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBlendFunc :: FunPtr FuntypeBlendFunc -> FuntypeBlendFunc +glrefBlendFunc :: IORef FuntypeBlendFunc +glrefBlendFunc = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBlendFunc #-} +glBlendFunc :: FuntypeBlendFunc +glBlendFunc = unsafePerformIO $ readIORef glrefBlendFunc +{-# INLINE glBlendFunc #-} +type FuntypeLogicOp = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynLogicOp :: FunPtr FuntypeLogicOp -> FuntypeLogicOp +glrefLogicOp :: IORef FuntypeLogicOp +glrefLogicOp = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefLogicOp #-} +glLogicOp :: FuntypeLogicOp +glLogicOp = unsafePerformIO $ readIORef glrefLogicOp +{-# INLINE glLogicOp #-} +type FuntypeStencilFunc = + GLenum -> + GLint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynStencilFunc :: FunPtr FuntypeStencilFunc -> FuntypeStencilFunc +glrefStencilFunc :: IORef FuntypeStencilFunc +glrefStencilFunc = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefStencilFunc #-} +glStencilFunc :: FuntypeStencilFunc +glStencilFunc = unsafePerformIO $ readIORef glrefStencilFunc +{-# INLINE glStencilFunc #-} +type FuntypeStencilOp = + GLenum -> + GLenum -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynStencilOp :: FunPtr FuntypeStencilOp -> FuntypeStencilOp +glrefStencilOp :: IORef FuntypeStencilOp +glrefStencilOp = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefStencilOp #-} +glStencilOp :: FuntypeStencilOp +glStencilOp = unsafePerformIO $ readIORef glrefStencilOp +{-# INLINE glStencilOp #-} +type FuntypeDepthFunc = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDepthFunc :: FunPtr FuntypeDepthFunc -> FuntypeDepthFunc +glrefDepthFunc :: IORef FuntypeDepthFunc +glrefDepthFunc = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDepthFunc #-} +glDepthFunc :: FuntypeDepthFunc +glDepthFunc = unsafePerformIO $ readIORef glrefDepthFunc +{-# INLINE glDepthFunc #-} +type FuntypePixelStoref = + GLenum -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPixelStoref :: FunPtr FuntypePixelStoref -> FuntypePixelStoref +glrefPixelStoref :: IORef FuntypePixelStoref +glrefPixelStoref = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPixelStoref #-} +glPixelStoref :: FuntypePixelStoref +glPixelStoref = unsafePerformIO $ readIORef glrefPixelStoref +{-# INLINE glPixelStoref #-} +type FuntypePixelStorei = + GLenum -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPixelStorei :: FunPtr FuntypePixelStorei -> FuntypePixelStorei +glrefPixelStorei :: IORef FuntypePixelStorei +glrefPixelStorei = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPixelStorei #-} +glPixelStorei :: FuntypePixelStorei +glPixelStorei = unsafePerformIO $ readIORef glrefPixelStorei +{-# INLINE glPixelStorei #-} +type FuntypeReadBuffer = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynReadBuffer :: FunPtr FuntypeReadBuffer -> FuntypeReadBuffer +glrefReadBuffer :: IORef FuntypeReadBuffer +glrefReadBuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefReadBuffer #-} +glReadBuffer :: FuntypeReadBuffer +glReadBuffer = unsafePerformIO $ readIORef glrefReadBuffer +{-# INLINE glReadBuffer #-} +type FuntypeReadPixels = + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynReadPixels :: FunPtr FuntypeReadPixels -> FuntypeReadPixels +glrefReadPixels :: IORef FuntypeReadPixels +glrefReadPixels = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefReadPixels #-} +glReadPixels :: FuntypeReadPixels +glReadPixels = unsafePerformIO $ readIORef glrefReadPixels +{-# INLINE glReadPixels #-} +type FuntypeGetBooleanv = + GLenum -> + Ptr (GLboolean) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetBooleanv :: FunPtr FuntypeGetBooleanv -> FuntypeGetBooleanv +glrefGetBooleanv :: IORef FuntypeGetBooleanv +glrefGetBooleanv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetBooleanv #-} +glGetBooleanv :: FuntypeGetBooleanv +glGetBooleanv = unsafePerformIO $ readIORef glrefGetBooleanv +{-# INLINE glGetBooleanv #-} +type FuntypeGetDoublev = + GLenum -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetDoublev :: FunPtr FuntypeGetDoublev -> FuntypeGetDoublev +glrefGetDoublev :: IORef FuntypeGetDoublev +glrefGetDoublev = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetDoublev #-} +glGetDoublev :: FuntypeGetDoublev +glGetDoublev = unsafePerformIO $ readIORef glrefGetDoublev +{-# INLINE glGetDoublev #-} +type FuntypeGetError = + IO ( GLenum ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetError :: FunPtr FuntypeGetError -> FuntypeGetError +glrefGetError :: IORef FuntypeGetError +glrefGetError = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetError #-} +glGetError :: FuntypeGetError +glGetError = unsafePerformIO $ readIORef glrefGetError +{-# INLINE glGetError #-} +type FuntypeGetFloatv = + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetFloatv :: FunPtr FuntypeGetFloatv -> FuntypeGetFloatv +glrefGetFloatv :: IORef FuntypeGetFloatv +glrefGetFloatv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetFloatv #-} +glGetFloatv :: FuntypeGetFloatv +glGetFloatv = unsafePerformIO $ readIORef glrefGetFloatv +{-# INLINE glGetFloatv #-} +type FuntypeGetIntegerv = + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetIntegerv :: FunPtr FuntypeGetIntegerv -> FuntypeGetIntegerv +glrefGetIntegerv :: IORef FuntypeGetIntegerv +glrefGetIntegerv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetIntegerv #-} +glGetIntegerv :: FuntypeGetIntegerv +glGetIntegerv = unsafePerformIO $ readIORef glrefGetIntegerv +{-# INLINE glGetIntegerv #-} +type FuntypeGetString = + GLenum -> + IO ( Ptr (GLubyte) ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetString :: FunPtr FuntypeGetString -> FuntypeGetString +glrefGetString :: IORef FuntypeGetString +glrefGetString = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetString #-} +glGetString :: FuntypeGetString +glGetString = unsafePerformIO $ readIORef glrefGetString +{-# INLINE glGetString #-} +type FuntypeGetTexImage = + GLenum -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTexImage :: FunPtr FuntypeGetTexImage -> FuntypeGetTexImage +glrefGetTexImage :: IORef FuntypeGetTexImage +glrefGetTexImage = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTexImage #-} +glGetTexImage :: FuntypeGetTexImage +glGetTexImage = unsafePerformIO $ readIORef glrefGetTexImage +{-# INLINE glGetTexImage #-} +type FuntypeGetTexParameterfv = + GLenum -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTexParameterfv :: FunPtr FuntypeGetTexParameterfv -> FuntypeGetTexParameterfv +glrefGetTexParameterfv :: IORef FuntypeGetTexParameterfv +glrefGetTexParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTexParameterfv #-} +glGetTexParameterfv :: FuntypeGetTexParameterfv +glGetTexParameterfv = unsafePerformIO $ readIORef glrefGetTexParameterfv +{-# INLINE glGetTexParameterfv #-} +type FuntypeGetTexParameteriv = + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTexParameteriv :: FunPtr FuntypeGetTexParameteriv -> FuntypeGetTexParameteriv +glrefGetTexParameteriv :: IORef FuntypeGetTexParameteriv +glrefGetTexParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTexParameteriv #-} +glGetTexParameteriv :: FuntypeGetTexParameteriv +glGetTexParameteriv = unsafePerformIO $ readIORef glrefGetTexParameteriv +{-# INLINE glGetTexParameteriv #-} +type FuntypeGetTexLevelParameterfv = + GLenum -> + GLint -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTexLevelParameterfv :: FunPtr FuntypeGetTexLevelParameterfv -> FuntypeGetTexLevelParameterfv +glrefGetTexLevelParameterfv :: IORef FuntypeGetTexLevelParameterfv +glrefGetTexLevelParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTexLevelParameterfv #-} +glGetTexLevelParameterfv :: FuntypeGetTexLevelParameterfv +glGetTexLevelParameterfv = unsafePerformIO $ readIORef glrefGetTexLevelParameterfv +{-# INLINE glGetTexLevelParameterfv #-} +type FuntypeGetTexLevelParameteriv = + GLenum -> + GLint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTexLevelParameteriv :: FunPtr FuntypeGetTexLevelParameteriv -> FuntypeGetTexLevelParameteriv +glrefGetTexLevelParameteriv :: IORef FuntypeGetTexLevelParameteriv +glrefGetTexLevelParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTexLevelParameteriv #-} +glGetTexLevelParameteriv :: FuntypeGetTexLevelParameteriv +glGetTexLevelParameteriv = unsafePerformIO $ readIORef glrefGetTexLevelParameteriv +{-# INLINE glGetTexLevelParameteriv #-} +type FuntypeIsEnabled = + GLenum -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsEnabled :: FunPtr FuntypeIsEnabled -> FuntypeIsEnabled +glrefIsEnabled :: IORef FuntypeIsEnabled +glrefIsEnabled = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsEnabled #-} +glIsEnabled :: FuntypeIsEnabled +glIsEnabled = unsafePerformIO $ readIORef glrefIsEnabled +{-# INLINE glIsEnabled #-} +type FuntypeDepthRange = + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDepthRange :: FunPtr FuntypeDepthRange -> FuntypeDepthRange +glrefDepthRange :: IORef FuntypeDepthRange +glrefDepthRange = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDepthRange #-} +glDepthRange :: FuntypeDepthRange +glDepthRange = unsafePerformIO $ readIORef glrefDepthRange +{-# INLINE glDepthRange #-} +type FuntypeViewport = + GLint -> + GLint -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynViewport :: FunPtr FuntypeViewport -> FuntypeViewport +glrefViewport :: IORef FuntypeViewport +glrefViewport = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefViewport #-} +glViewport :: FuntypeViewport +glViewport = unsafePerformIO $ readIORef glrefViewport +{-# INLINE glViewport #-} + +-- GL_VERSION_1_1 + +type FuntypeDrawArrays = + GLenum -> + GLint -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDrawArrays :: FunPtr FuntypeDrawArrays -> FuntypeDrawArrays +glrefDrawArrays :: IORef FuntypeDrawArrays +glrefDrawArrays = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDrawArrays #-} +glDrawArrays :: FuntypeDrawArrays +glDrawArrays = unsafePerformIO $ readIORef glrefDrawArrays +{-# INLINE glDrawArrays #-} +type FuntypeDrawElements = + GLenum -> + GLsizei -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDrawElements :: FunPtr FuntypeDrawElements -> FuntypeDrawElements +glrefDrawElements :: IORef FuntypeDrawElements +glrefDrawElements = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDrawElements #-} +glDrawElements :: FuntypeDrawElements +glDrawElements = unsafePerformIO $ readIORef glrefDrawElements +{-# INLINE glDrawElements #-} +type FuntypePolygonOffset = + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPolygonOffset :: FunPtr FuntypePolygonOffset -> FuntypePolygonOffset +glrefPolygonOffset :: IORef FuntypePolygonOffset +glrefPolygonOffset = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPolygonOffset #-} +glPolygonOffset :: FuntypePolygonOffset +glPolygonOffset = unsafePerformIO $ readIORef glrefPolygonOffset +{-# INLINE glPolygonOffset #-} +type FuntypeCopyTexImage1D = + GLenum -> + GLint -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyTexImage1D :: FunPtr FuntypeCopyTexImage1D -> FuntypeCopyTexImage1D +glrefCopyTexImage1D :: IORef FuntypeCopyTexImage1D +glrefCopyTexImage1D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyTexImage1D #-} +glCopyTexImage1D :: FuntypeCopyTexImage1D +glCopyTexImage1D = unsafePerformIO $ readIORef glrefCopyTexImage1D +{-# INLINE glCopyTexImage1D #-} +type FuntypeCopyTexImage2D = + GLenum -> + GLint -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyTexImage2D :: FunPtr FuntypeCopyTexImage2D -> FuntypeCopyTexImage2D +glrefCopyTexImage2D :: IORef FuntypeCopyTexImage2D +glrefCopyTexImage2D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyTexImage2D #-} +glCopyTexImage2D :: FuntypeCopyTexImage2D +glCopyTexImage2D = unsafePerformIO $ readIORef glrefCopyTexImage2D +{-# INLINE glCopyTexImage2D #-} +type FuntypeCopyTexSubImage1D = + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyTexSubImage1D :: FunPtr FuntypeCopyTexSubImage1D -> FuntypeCopyTexSubImage1D +glrefCopyTexSubImage1D :: IORef FuntypeCopyTexSubImage1D +glrefCopyTexSubImage1D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyTexSubImage1D #-} +glCopyTexSubImage1D :: FuntypeCopyTexSubImage1D +glCopyTexSubImage1D = unsafePerformIO $ readIORef glrefCopyTexSubImage1D +{-# INLINE glCopyTexSubImage1D #-} +type FuntypeCopyTexSubImage2D = + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyTexSubImage2D :: FunPtr FuntypeCopyTexSubImage2D -> FuntypeCopyTexSubImage2D +glrefCopyTexSubImage2D :: IORef FuntypeCopyTexSubImage2D +glrefCopyTexSubImage2D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyTexSubImage2D #-} +glCopyTexSubImage2D :: FuntypeCopyTexSubImage2D +glCopyTexSubImage2D = unsafePerformIO $ readIORef glrefCopyTexSubImage2D +{-# INLINE glCopyTexSubImage2D #-} +type FuntypeTexSubImage1D = + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexSubImage1D :: FunPtr FuntypeTexSubImage1D -> FuntypeTexSubImage1D +glrefTexSubImage1D :: IORef FuntypeTexSubImage1D +glrefTexSubImage1D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexSubImage1D #-} +glTexSubImage1D :: FuntypeTexSubImage1D +glTexSubImage1D = unsafePerformIO $ readIORef glrefTexSubImage1D +{-# INLINE glTexSubImage1D #-} +type FuntypeTexSubImage2D = + GLenum -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexSubImage2D :: FunPtr FuntypeTexSubImage2D -> FuntypeTexSubImage2D +glrefTexSubImage2D :: IORef FuntypeTexSubImage2D +glrefTexSubImage2D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexSubImage2D #-} +glTexSubImage2D :: FuntypeTexSubImage2D +glTexSubImage2D = unsafePerformIO $ readIORef glrefTexSubImage2D +{-# INLINE glTexSubImage2D #-} +type FuntypeBindTexture = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindTexture :: FunPtr FuntypeBindTexture -> FuntypeBindTexture +glrefBindTexture :: IORef FuntypeBindTexture +glrefBindTexture = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindTexture #-} +glBindTexture :: FuntypeBindTexture +glBindTexture = unsafePerformIO $ readIORef glrefBindTexture +{-# INLINE glBindTexture #-} +type FuntypeDeleteTextures = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDeleteTextures :: FunPtr FuntypeDeleteTextures -> FuntypeDeleteTextures +glrefDeleteTextures :: IORef FuntypeDeleteTextures +glrefDeleteTextures = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDeleteTextures #-} +glDeleteTextures :: FuntypeDeleteTextures +glDeleteTextures = unsafePerformIO $ readIORef glrefDeleteTextures +{-# INLINE glDeleteTextures #-} +type FuntypeGenTextures = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGenTextures :: FunPtr FuntypeGenTextures -> FuntypeGenTextures +glrefGenTextures :: IORef FuntypeGenTextures +glrefGenTextures = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGenTextures #-} +glGenTextures :: FuntypeGenTextures +glGenTextures = unsafePerformIO $ readIORef glrefGenTextures +{-# INLINE glGenTextures #-} +type FuntypeIsTexture = + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsTexture :: FunPtr FuntypeIsTexture -> FuntypeIsTexture +glrefIsTexture :: IORef FuntypeIsTexture +glrefIsTexture = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsTexture #-} +glIsTexture :: FuntypeIsTexture +glIsTexture = unsafePerformIO $ readIORef glrefIsTexture +{-# INLINE glIsTexture #-} + +-- GL_VERSION_1_2 + +type FuntypeDrawRangeElements = + GLenum -> + GLuint -> + GLuint -> + GLsizei -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDrawRangeElements :: FunPtr FuntypeDrawRangeElements -> FuntypeDrawRangeElements +glrefDrawRangeElements :: IORef FuntypeDrawRangeElements +glrefDrawRangeElements = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDrawRangeElements #-} +glDrawRangeElements :: FuntypeDrawRangeElements +glDrawRangeElements = unsafePerformIO $ readIORef glrefDrawRangeElements +{-# INLINE glDrawRangeElements #-} +type FuntypeTexImage3D = + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLsizei -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexImage3D :: FunPtr FuntypeTexImage3D -> FuntypeTexImage3D +glrefTexImage3D :: IORef FuntypeTexImage3D +glrefTexImage3D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexImage3D #-} +glTexImage3D :: FuntypeTexImage3D +glTexImage3D = unsafePerformIO $ readIORef glrefTexImage3D +{-# INLINE glTexImage3D #-} +type FuntypeTexSubImage3D = + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLsizei -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexSubImage3D :: FunPtr FuntypeTexSubImage3D -> FuntypeTexSubImage3D +glrefTexSubImage3D :: IORef FuntypeTexSubImage3D +glrefTexSubImage3D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexSubImage3D #-} +glTexSubImage3D :: FuntypeTexSubImage3D +glTexSubImage3D = unsafePerformIO $ readIORef glrefTexSubImage3D +{-# INLINE glTexSubImage3D #-} +type FuntypeCopyTexSubImage3D = + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyTexSubImage3D :: FunPtr FuntypeCopyTexSubImage3D -> FuntypeCopyTexSubImage3D +glrefCopyTexSubImage3D :: IORef FuntypeCopyTexSubImage3D +glrefCopyTexSubImage3D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyTexSubImage3D #-} +glCopyTexSubImage3D :: FuntypeCopyTexSubImage3D +glCopyTexSubImage3D = unsafePerformIO $ readIORef glrefCopyTexSubImage3D +{-# INLINE glCopyTexSubImage3D #-} + +-- GL_VERSION_1_3 + +type FuntypeActiveTexture = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynActiveTexture :: FunPtr FuntypeActiveTexture -> FuntypeActiveTexture +glrefActiveTexture :: IORef FuntypeActiveTexture +glrefActiveTexture = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefActiveTexture #-} +glActiveTexture :: FuntypeActiveTexture +glActiveTexture = unsafePerformIO $ readIORef glrefActiveTexture +{-# INLINE glActiveTexture #-} +type FuntypeSampleCoverage = + GLfloat -> + GLboolean -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynSampleCoverage :: FunPtr FuntypeSampleCoverage -> FuntypeSampleCoverage +glrefSampleCoverage :: IORef FuntypeSampleCoverage +glrefSampleCoverage = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefSampleCoverage #-} +glSampleCoverage :: FuntypeSampleCoverage +glSampleCoverage = unsafePerformIO $ readIORef glrefSampleCoverage +{-# INLINE glSampleCoverage #-} +type FuntypeCompressedTexImage3D = + GLenum -> + GLint -> + GLenum -> + GLsizei -> + GLsizei -> + GLsizei -> + GLint -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTexImage3D :: FunPtr FuntypeCompressedTexImage3D -> FuntypeCompressedTexImage3D +glrefCompressedTexImage3D :: IORef FuntypeCompressedTexImage3D +glrefCompressedTexImage3D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTexImage3D #-} +glCompressedTexImage3D :: FuntypeCompressedTexImage3D +glCompressedTexImage3D = unsafePerformIO $ readIORef glrefCompressedTexImage3D +{-# INLINE glCompressedTexImage3D #-} +type FuntypeCompressedTexImage2D = + GLenum -> + GLint -> + GLenum -> + GLsizei -> + GLsizei -> + GLint -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTexImage2D :: FunPtr FuntypeCompressedTexImage2D -> FuntypeCompressedTexImage2D +glrefCompressedTexImage2D :: IORef FuntypeCompressedTexImage2D +glrefCompressedTexImage2D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTexImage2D #-} +glCompressedTexImage2D :: FuntypeCompressedTexImage2D +glCompressedTexImage2D = unsafePerformIO $ readIORef glrefCompressedTexImage2D +{-# INLINE glCompressedTexImage2D #-} +type FuntypeCompressedTexImage1D = + GLenum -> + GLint -> + GLenum -> + GLsizei -> + GLint -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTexImage1D :: FunPtr FuntypeCompressedTexImage1D -> FuntypeCompressedTexImage1D +glrefCompressedTexImage1D :: IORef FuntypeCompressedTexImage1D +glrefCompressedTexImage1D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTexImage1D #-} +glCompressedTexImage1D :: FuntypeCompressedTexImage1D +glCompressedTexImage1D = unsafePerformIO $ readIORef glrefCompressedTexImage1D +{-# INLINE glCompressedTexImage1D #-} +type FuntypeCompressedTexSubImage3D = + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLsizei -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTexSubImage3D :: FunPtr FuntypeCompressedTexSubImage3D -> FuntypeCompressedTexSubImage3D +glrefCompressedTexSubImage3D :: IORef FuntypeCompressedTexSubImage3D +glrefCompressedTexSubImage3D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTexSubImage3D #-} +glCompressedTexSubImage3D :: FuntypeCompressedTexSubImage3D +glCompressedTexSubImage3D = unsafePerformIO $ readIORef glrefCompressedTexSubImage3D +{-# INLINE glCompressedTexSubImage3D #-} +type FuntypeCompressedTexSubImage2D = + GLenum -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTexSubImage2D :: FunPtr FuntypeCompressedTexSubImage2D -> FuntypeCompressedTexSubImage2D +glrefCompressedTexSubImage2D :: IORef FuntypeCompressedTexSubImage2D +glrefCompressedTexSubImage2D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTexSubImage2D #-} +glCompressedTexSubImage2D :: FuntypeCompressedTexSubImage2D +glCompressedTexSubImage2D = unsafePerformIO $ readIORef glrefCompressedTexSubImage2D +{-# INLINE glCompressedTexSubImage2D #-} +type FuntypeCompressedTexSubImage1D = + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTexSubImage1D :: FunPtr FuntypeCompressedTexSubImage1D -> FuntypeCompressedTexSubImage1D +glrefCompressedTexSubImage1D :: IORef FuntypeCompressedTexSubImage1D +glrefCompressedTexSubImage1D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTexSubImage1D #-} +glCompressedTexSubImage1D :: FuntypeCompressedTexSubImage1D +glCompressedTexSubImage1D = unsafePerformIO $ readIORef glrefCompressedTexSubImage1D +{-# INLINE glCompressedTexSubImage1D #-} +type FuntypeGetCompressedTexImage = + GLenum -> + GLint -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetCompressedTexImage :: FunPtr FuntypeGetCompressedTexImage -> FuntypeGetCompressedTexImage +glrefGetCompressedTexImage :: IORef FuntypeGetCompressedTexImage +glrefGetCompressedTexImage = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetCompressedTexImage #-} +glGetCompressedTexImage :: FuntypeGetCompressedTexImage +glGetCompressedTexImage = unsafePerformIO $ readIORef glrefGetCompressedTexImage +{-# INLINE glGetCompressedTexImage #-} + +-- GL_VERSION_1_4 + +type FuntypeBlendFuncSeparate = + GLenum -> + GLenum -> + GLenum -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBlendFuncSeparate :: FunPtr FuntypeBlendFuncSeparate -> FuntypeBlendFuncSeparate +glrefBlendFuncSeparate :: IORef FuntypeBlendFuncSeparate +glrefBlendFuncSeparate = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBlendFuncSeparate #-} +glBlendFuncSeparate :: FuntypeBlendFuncSeparate +glBlendFuncSeparate = unsafePerformIO $ readIORef glrefBlendFuncSeparate +{-# INLINE glBlendFuncSeparate #-} +type FuntypeMultiDrawArrays = + GLenum -> + Ptr (GLint) -> + Ptr (GLsizei) -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiDrawArrays :: FunPtr FuntypeMultiDrawArrays -> FuntypeMultiDrawArrays +glrefMultiDrawArrays :: IORef FuntypeMultiDrawArrays +glrefMultiDrawArrays = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiDrawArrays #-} +glMultiDrawArrays :: FuntypeMultiDrawArrays +glMultiDrawArrays = unsafePerformIO $ readIORef glrefMultiDrawArrays +{-# INLINE glMultiDrawArrays #-} +type FuntypeMultiDrawElements = + GLenum -> + Ptr (GLsizei) -> + GLenum -> + Ptr (Ptr ()) -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiDrawElements :: FunPtr FuntypeMultiDrawElements -> FuntypeMultiDrawElements +glrefMultiDrawElements :: IORef FuntypeMultiDrawElements +glrefMultiDrawElements = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiDrawElements #-} +glMultiDrawElements :: FuntypeMultiDrawElements +glMultiDrawElements = unsafePerformIO $ readIORef glrefMultiDrawElements +{-# INLINE glMultiDrawElements #-} +type FuntypePointParameterf = + GLenum -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPointParameterf :: FunPtr FuntypePointParameterf -> FuntypePointParameterf +glrefPointParameterf :: IORef FuntypePointParameterf +glrefPointParameterf = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPointParameterf #-} +glPointParameterf :: FuntypePointParameterf +glPointParameterf = unsafePerformIO $ readIORef glrefPointParameterf +{-# INLINE glPointParameterf #-} +type FuntypePointParameterfv = + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPointParameterfv :: FunPtr FuntypePointParameterfv -> FuntypePointParameterfv +glrefPointParameterfv :: IORef FuntypePointParameterfv +glrefPointParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPointParameterfv #-} +glPointParameterfv :: FuntypePointParameterfv +glPointParameterfv = unsafePerformIO $ readIORef glrefPointParameterfv +{-# INLINE glPointParameterfv #-} +type FuntypePointParameteri = + GLenum -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPointParameteri :: FunPtr FuntypePointParameteri -> FuntypePointParameteri +glrefPointParameteri :: IORef FuntypePointParameteri +glrefPointParameteri = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPointParameteri #-} +glPointParameteri :: FuntypePointParameteri +glPointParameteri = unsafePerformIO $ readIORef glrefPointParameteri +{-# INLINE glPointParameteri #-} +type FuntypePointParameteriv = + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPointParameteriv :: FunPtr FuntypePointParameteriv -> FuntypePointParameteriv +glrefPointParameteriv :: IORef FuntypePointParameteriv +glrefPointParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPointParameteriv #-} +glPointParameteriv :: FuntypePointParameteriv +glPointParameteriv = unsafePerformIO $ readIORef glrefPointParameteriv +{-# INLINE glPointParameteriv #-} +type FuntypeBlendColor = + GLfloat -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBlendColor :: FunPtr FuntypeBlendColor -> FuntypeBlendColor +glrefBlendColor :: IORef FuntypeBlendColor +glrefBlendColor = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBlendColor #-} +glBlendColor :: FuntypeBlendColor +glBlendColor = unsafePerformIO $ readIORef glrefBlendColor +{-# INLINE glBlendColor #-} +type FuntypeBlendEquation = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBlendEquation :: FunPtr FuntypeBlendEquation -> FuntypeBlendEquation +glrefBlendEquation :: IORef FuntypeBlendEquation +glrefBlendEquation = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBlendEquation #-} +glBlendEquation :: FuntypeBlendEquation +glBlendEquation = unsafePerformIO $ readIORef glrefBlendEquation +{-# INLINE glBlendEquation #-} + +-- GL_VERSION_1_5 + +type FuntypeGenQueries = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGenQueries :: FunPtr FuntypeGenQueries -> FuntypeGenQueries +glrefGenQueries :: IORef FuntypeGenQueries +glrefGenQueries = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGenQueries #-} +glGenQueries :: FuntypeGenQueries +glGenQueries = unsafePerformIO $ readIORef glrefGenQueries +{-# INLINE glGenQueries #-} +type FuntypeDeleteQueries = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDeleteQueries :: FunPtr FuntypeDeleteQueries -> FuntypeDeleteQueries +glrefDeleteQueries :: IORef FuntypeDeleteQueries +glrefDeleteQueries = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDeleteQueries #-} +glDeleteQueries :: FuntypeDeleteQueries +glDeleteQueries = unsafePerformIO $ readIORef glrefDeleteQueries +{-# INLINE glDeleteQueries #-} +type FuntypeIsQuery = + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsQuery :: FunPtr FuntypeIsQuery -> FuntypeIsQuery +glrefIsQuery :: IORef FuntypeIsQuery +glrefIsQuery = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsQuery #-} +glIsQuery :: FuntypeIsQuery +glIsQuery = unsafePerformIO $ readIORef glrefIsQuery +{-# INLINE glIsQuery #-} +type FuntypeBeginQuery = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBeginQuery :: FunPtr FuntypeBeginQuery -> FuntypeBeginQuery +glrefBeginQuery :: IORef FuntypeBeginQuery +glrefBeginQuery = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBeginQuery #-} +glBeginQuery :: FuntypeBeginQuery +glBeginQuery = unsafePerformIO $ readIORef glrefBeginQuery +{-# INLINE glBeginQuery #-} +type FuntypeEndQuery = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynEndQuery :: FunPtr FuntypeEndQuery -> FuntypeEndQuery +glrefEndQuery :: IORef FuntypeEndQuery +glrefEndQuery = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefEndQuery #-} +glEndQuery :: FuntypeEndQuery +glEndQuery = unsafePerformIO $ readIORef glrefEndQuery +{-# INLINE glEndQuery #-} +type FuntypeGetQueryiv = + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetQueryiv :: FunPtr FuntypeGetQueryiv -> FuntypeGetQueryiv +glrefGetQueryiv :: IORef FuntypeGetQueryiv +glrefGetQueryiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetQueryiv #-} +glGetQueryiv :: FuntypeGetQueryiv +glGetQueryiv = unsafePerformIO $ readIORef glrefGetQueryiv +{-# INLINE glGetQueryiv #-} +type FuntypeGetQueryObjectiv = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetQueryObjectiv :: FunPtr FuntypeGetQueryObjectiv -> FuntypeGetQueryObjectiv +glrefGetQueryObjectiv :: IORef FuntypeGetQueryObjectiv +glrefGetQueryObjectiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetQueryObjectiv #-} +glGetQueryObjectiv :: FuntypeGetQueryObjectiv +glGetQueryObjectiv = unsafePerformIO $ readIORef glrefGetQueryObjectiv +{-# INLINE glGetQueryObjectiv #-} +type FuntypeGetQueryObjectuiv = + GLuint -> + GLenum -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetQueryObjectuiv :: FunPtr FuntypeGetQueryObjectuiv -> FuntypeGetQueryObjectuiv +glrefGetQueryObjectuiv :: IORef FuntypeGetQueryObjectuiv +glrefGetQueryObjectuiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetQueryObjectuiv #-} +glGetQueryObjectuiv :: FuntypeGetQueryObjectuiv +glGetQueryObjectuiv = unsafePerformIO $ readIORef glrefGetQueryObjectuiv +{-# INLINE glGetQueryObjectuiv #-} +type FuntypeBindBuffer = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindBuffer :: FunPtr FuntypeBindBuffer -> FuntypeBindBuffer +glrefBindBuffer :: IORef FuntypeBindBuffer +glrefBindBuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindBuffer #-} +glBindBuffer :: FuntypeBindBuffer +glBindBuffer = unsafePerformIO $ readIORef glrefBindBuffer +{-# INLINE glBindBuffer #-} +type FuntypeDeleteBuffers = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDeleteBuffers :: FunPtr FuntypeDeleteBuffers -> FuntypeDeleteBuffers +glrefDeleteBuffers :: IORef FuntypeDeleteBuffers +glrefDeleteBuffers = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDeleteBuffers #-} +glDeleteBuffers :: FuntypeDeleteBuffers +glDeleteBuffers = unsafePerformIO $ readIORef glrefDeleteBuffers +{-# INLINE glDeleteBuffers #-} +type FuntypeGenBuffers = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGenBuffers :: FunPtr FuntypeGenBuffers -> FuntypeGenBuffers +glrefGenBuffers :: IORef FuntypeGenBuffers +glrefGenBuffers = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGenBuffers #-} +glGenBuffers :: FuntypeGenBuffers +glGenBuffers = unsafePerformIO $ readIORef glrefGenBuffers +{-# INLINE glGenBuffers #-} +type FuntypeIsBuffer = + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsBuffer :: FunPtr FuntypeIsBuffer -> FuntypeIsBuffer +glrefIsBuffer :: IORef FuntypeIsBuffer +glrefIsBuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsBuffer #-} +glIsBuffer :: FuntypeIsBuffer +glIsBuffer = unsafePerformIO $ readIORef glrefIsBuffer +{-# INLINE glIsBuffer #-} +type FuntypeBufferData = + GLenum -> + GLsizeiptr -> + Ptr () -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBufferData :: FunPtr FuntypeBufferData -> FuntypeBufferData +glrefBufferData :: IORef FuntypeBufferData +glrefBufferData = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBufferData #-} +glBufferData :: FuntypeBufferData +glBufferData = unsafePerformIO $ readIORef glrefBufferData +{-# INLINE glBufferData #-} +type FuntypeBufferSubData = + GLenum -> + GLintptr -> + GLsizeiptr -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBufferSubData :: FunPtr FuntypeBufferSubData -> FuntypeBufferSubData +glrefBufferSubData :: IORef FuntypeBufferSubData +glrefBufferSubData = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBufferSubData #-} +glBufferSubData :: FuntypeBufferSubData +glBufferSubData = unsafePerformIO $ readIORef glrefBufferSubData +{-# INLINE glBufferSubData #-} +type FuntypeGetBufferSubData = + GLenum -> + GLintptr -> + GLsizeiptr -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetBufferSubData :: FunPtr FuntypeGetBufferSubData -> FuntypeGetBufferSubData +glrefGetBufferSubData :: IORef FuntypeGetBufferSubData +glrefGetBufferSubData = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetBufferSubData #-} +glGetBufferSubData :: FuntypeGetBufferSubData +glGetBufferSubData = unsafePerformIO $ readIORef glrefGetBufferSubData +{-# INLINE glGetBufferSubData #-} +type FuntypeMapBuffer = + GLenum -> + GLenum -> + IO ( Ptr () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMapBuffer :: FunPtr FuntypeMapBuffer -> FuntypeMapBuffer +glrefMapBuffer :: IORef FuntypeMapBuffer +glrefMapBuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMapBuffer #-} +glMapBuffer :: FuntypeMapBuffer +glMapBuffer = unsafePerformIO $ readIORef glrefMapBuffer +{-# INLINE glMapBuffer #-} +type FuntypeUnmapBuffer = + GLenum -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUnmapBuffer :: FunPtr FuntypeUnmapBuffer -> FuntypeUnmapBuffer +glrefUnmapBuffer :: IORef FuntypeUnmapBuffer +glrefUnmapBuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUnmapBuffer #-} +glUnmapBuffer :: FuntypeUnmapBuffer +glUnmapBuffer = unsafePerformIO $ readIORef glrefUnmapBuffer +{-# INLINE glUnmapBuffer #-} +type FuntypeGetBufferParameteriv = + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetBufferParameteriv :: FunPtr FuntypeGetBufferParameteriv -> FuntypeGetBufferParameteriv +glrefGetBufferParameteriv :: IORef FuntypeGetBufferParameteriv +glrefGetBufferParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetBufferParameteriv #-} +glGetBufferParameteriv :: FuntypeGetBufferParameteriv +glGetBufferParameteriv = unsafePerformIO $ readIORef glrefGetBufferParameteriv +{-# INLINE glGetBufferParameteriv #-} +type FuntypeGetBufferPointerv = + GLenum -> + GLenum -> + Ptr (Ptr ()) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetBufferPointerv :: FunPtr FuntypeGetBufferPointerv -> FuntypeGetBufferPointerv +glrefGetBufferPointerv :: IORef FuntypeGetBufferPointerv +glrefGetBufferPointerv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetBufferPointerv #-} +glGetBufferPointerv :: FuntypeGetBufferPointerv +glGetBufferPointerv = unsafePerformIO $ readIORef glrefGetBufferPointerv +{-# INLINE glGetBufferPointerv #-} + +-- GL_VERSION_2_0 + +type FuntypeBlendEquationSeparate = + GLenum -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBlendEquationSeparate :: FunPtr FuntypeBlendEquationSeparate -> FuntypeBlendEquationSeparate +glrefBlendEquationSeparate :: IORef FuntypeBlendEquationSeparate +glrefBlendEquationSeparate = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBlendEquationSeparate #-} +glBlendEquationSeparate :: FuntypeBlendEquationSeparate +glBlendEquationSeparate = unsafePerformIO $ readIORef glrefBlendEquationSeparate +{-# INLINE glBlendEquationSeparate #-} +type FuntypeDrawBuffers = + GLsizei -> + Ptr (GLenum) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDrawBuffers :: FunPtr FuntypeDrawBuffers -> FuntypeDrawBuffers +glrefDrawBuffers :: IORef FuntypeDrawBuffers +glrefDrawBuffers = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDrawBuffers #-} +glDrawBuffers :: FuntypeDrawBuffers +glDrawBuffers = unsafePerformIO $ readIORef glrefDrawBuffers +{-# INLINE glDrawBuffers #-} +type FuntypeStencilOpSeparate = + GLenum -> + GLenum -> + GLenum -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynStencilOpSeparate :: FunPtr FuntypeStencilOpSeparate -> FuntypeStencilOpSeparate +glrefStencilOpSeparate :: IORef FuntypeStencilOpSeparate +glrefStencilOpSeparate = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefStencilOpSeparate #-} +glStencilOpSeparate :: FuntypeStencilOpSeparate +glStencilOpSeparate = unsafePerformIO $ readIORef glrefStencilOpSeparate +{-# INLINE glStencilOpSeparate #-} +type FuntypeStencilFuncSeparate = + GLenum -> + GLenum -> + GLint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynStencilFuncSeparate :: FunPtr FuntypeStencilFuncSeparate -> FuntypeStencilFuncSeparate +glrefStencilFuncSeparate :: IORef FuntypeStencilFuncSeparate +glrefStencilFuncSeparate = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefStencilFuncSeparate #-} +glStencilFuncSeparate :: FuntypeStencilFuncSeparate +glStencilFuncSeparate = unsafePerformIO $ readIORef glrefStencilFuncSeparate +{-# INLINE glStencilFuncSeparate #-} +type FuntypeStencilMaskSeparate = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynStencilMaskSeparate :: FunPtr FuntypeStencilMaskSeparate -> FuntypeStencilMaskSeparate +glrefStencilMaskSeparate :: IORef FuntypeStencilMaskSeparate +glrefStencilMaskSeparate = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefStencilMaskSeparate #-} +glStencilMaskSeparate :: FuntypeStencilMaskSeparate +glStencilMaskSeparate = unsafePerformIO $ readIORef glrefStencilMaskSeparate +{-# INLINE glStencilMaskSeparate #-} +type FuntypeAttachShader = + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynAttachShader :: FunPtr FuntypeAttachShader -> FuntypeAttachShader +glrefAttachShader :: IORef FuntypeAttachShader +glrefAttachShader = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefAttachShader #-} +glAttachShader :: FuntypeAttachShader +glAttachShader = unsafePerformIO $ readIORef glrefAttachShader +{-# INLINE glAttachShader #-} +type FuntypeBindAttribLocation = + GLuint -> + GLuint -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindAttribLocation :: FunPtr FuntypeBindAttribLocation -> FuntypeBindAttribLocation +glrefBindAttribLocation :: IORef FuntypeBindAttribLocation +glrefBindAttribLocation = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindAttribLocation #-} +glBindAttribLocation :: FuntypeBindAttribLocation +glBindAttribLocation = unsafePerformIO $ readIORef glrefBindAttribLocation +{-# INLINE glBindAttribLocation #-} +type FuntypeCompileShader = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompileShader :: FunPtr FuntypeCompileShader -> FuntypeCompileShader +glrefCompileShader :: IORef FuntypeCompileShader +glrefCompileShader = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompileShader #-} +glCompileShader :: FuntypeCompileShader +glCompileShader = unsafePerformIO $ readIORef glrefCompileShader +{-# INLINE glCompileShader #-} +type FuntypeCreateProgram = + IO ( GLuint ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCreateProgram :: FunPtr FuntypeCreateProgram -> FuntypeCreateProgram +glrefCreateProgram :: IORef FuntypeCreateProgram +glrefCreateProgram = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCreateProgram #-} +glCreateProgram :: FuntypeCreateProgram +glCreateProgram = unsafePerformIO $ readIORef glrefCreateProgram +{-# INLINE glCreateProgram #-} +type FuntypeCreateShader = + GLenum -> + IO ( GLuint ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCreateShader :: FunPtr FuntypeCreateShader -> FuntypeCreateShader +glrefCreateShader :: IORef FuntypeCreateShader +glrefCreateShader = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCreateShader #-} +glCreateShader :: FuntypeCreateShader +glCreateShader = unsafePerformIO $ readIORef glrefCreateShader +{-# INLINE glCreateShader #-} +type FuntypeDeleteProgram = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDeleteProgram :: FunPtr FuntypeDeleteProgram -> FuntypeDeleteProgram +glrefDeleteProgram :: IORef FuntypeDeleteProgram +glrefDeleteProgram = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDeleteProgram #-} +glDeleteProgram :: FuntypeDeleteProgram +glDeleteProgram = unsafePerformIO $ readIORef glrefDeleteProgram +{-# INLINE glDeleteProgram #-} +type FuntypeDeleteShader = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDeleteShader :: FunPtr FuntypeDeleteShader -> FuntypeDeleteShader +glrefDeleteShader :: IORef FuntypeDeleteShader +glrefDeleteShader = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDeleteShader #-} +glDeleteShader :: FuntypeDeleteShader +glDeleteShader = unsafePerformIO $ readIORef glrefDeleteShader +{-# INLINE glDeleteShader #-} +type FuntypeDetachShader = + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDetachShader :: FunPtr FuntypeDetachShader -> FuntypeDetachShader +glrefDetachShader :: IORef FuntypeDetachShader +glrefDetachShader = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDetachShader #-} +glDetachShader :: FuntypeDetachShader +glDetachShader = unsafePerformIO $ readIORef glrefDetachShader +{-# INLINE glDetachShader #-} +type FuntypeDisableVertexAttribArray = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDisableVertexAttribArray :: FunPtr FuntypeDisableVertexAttribArray -> FuntypeDisableVertexAttribArray +glrefDisableVertexAttribArray :: IORef FuntypeDisableVertexAttribArray +glrefDisableVertexAttribArray = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDisableVertexAttribArray #-} +glDisableVertexAttribArray :: FuntypeDisableVertexAttribArray +glDisableVertexAttribArray = unsafePerformIO $ readIORef glrefDisableVertexAttribArray +{-# INLINE glDisableVertexAttribArray #-} +type FuntypeEnableVertexAttribArray = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynEnableVertexAttribArray :: FunPtr FuntypeEnableVertexAttribArray -> FuntypeEnableVertexAttribArray +glrefEnableVertexAttribArray :: IORef FuntypeEnableVertexAttribArray +glrefEnableVertexAttribArray = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefEnableVertexAttribArray #-} +glEnableVertexAttribArray :: FuntypeEnableVertexAttribArray +glEnableVertexAttribArray = unsafePerformIO $ readIORef glrefEnableVertexAttribArray +{-# INLINE glEnableVertexAttribArray #-} +type FuntypeGetActiveAttrib = + GLuint -> + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLint) -> + Ptr (GLenum) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetActiveAttrib :: FunPtr FuntypeGetActiveAttrib -> FuntypeGetActiveAttrib +glrefGetActiveAttrib :: IORef FuntypeGetActiveAttrib +glrefGetActiveAttrib = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetActiveAttrib #-} +glGetActiveAttrib :: FuntypeGetActiveAttrib +glGetActiveAttrib = unsafePerformIO $ readIORef glrefGetActiveAttrib +{-# INLINE glGetActiveAttrib #-} +type FuntypeGetActiveUniform = + GLuint -> + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLint) -> + Ptr (GLenum) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetActiveUniform :: FunPtr FuntypeGetActiveUniform -> FuntypeGetActiveUniform +glrefGetActiveUniform :: IORef FuntypeGetActiveUniform +glrefGetActiveUniform = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetActiveUniform #-} +glGetActiveUniform :: FuntypeGetActiveUniform +glGetActiveUniform = unsafePerformIO $ readIORef glrefGetActiveUniform +{-# INLINE glGetActiveUniform #-} +type FuntypeGetAttachedShaders = + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetAttachedShaders :: FunPtr FuntypeGetAttachedShaders -> FuntypeGetAttachedShaders +glrefGetAttachedShaders :: IORef FuntypeGetAttachedShaders +glrefGetAttachedShaders = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetAttachedShaders #-} +glGetAttachedShaders :: FuntypeGetAttachedShaders +glGetAttachedShaders = unsafePerformIO $ readIORef glrefGetAttachedShaders +{-# INLINE glGetAttachedShaders #-} +type FuntypeGetAttribLocation = + GLuint -> + Ptr (GLchar) -> + IO ( GLint ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetAttribLocation :: FunPtr FuntypeGetAttribLocation -> FuntypeGetAttribLocation +glrefGetAttribLocation :: IORef FuntypeGetAttribLocation +glrefGetAttribLocation = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetAttribLocation #-} +glGetAttribLocation :: FuntypeGetAttribLocation +glGetAttribLocation = unsafePerformIO $ readIORef glrefGetAttribLocation +{-# INLINE glGetAttribLocation #-} +type FuntypeGetProgramiv = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetProgramiv :: FunPtr FuntypeGetProgramiv -> FuntypeGetProgramiv +glrefGetProgramiv :: IORef FuntypeGetProgramiv +glrefGetProgramiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetProgramiv #-} +glGetProgramiv :: FuntypeGetProgramiv +glGetProgramiv = unsafePerformIO $ readIORef glrefGetProgramiv +{-# INLINE glGetProgramiv #-} +type FuntypeGetProgramInfoLog = + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetProgramInfoLog :: FunPtr FuntypeGetProgramInfoLog -> FuntypeGetProgramInfoLog +glrefGetProgramInfoLog :: IORef FuntypeGetProgramInfoLog +glrefGetProgramInfoLog = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetProgramInfoLog #-} +glGetProgramInfoLog :: FuntypeGetProgramInfoLog +glGetProgramInfoLog = unsafePerformIO $ readIORef glrefGetProgramInfoLog +{-# INLINE glGetProgramInfoLog #-} +type FuntypeGetShaderiv = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetShaderiv :: FunPtr FuntypeGetShaderiv -> FuntypeGetShaderiv +glrefGetShaderiv :: IORef FuntypeGetShaderiv +glrefGetShaderiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetShaderiv #-} +glGetShaderiv :: FuntypeGetShaderiv +glGetShaderiv = unsafePerformIO $ readIORef glrefGetShaderiv +{-# INLINE glGetShaderiv #-} +type FuntypeGetShaderInfoLog = + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetShaderInfoLog :: FunPtr FuntypeGetShaderInfoLog -> FuntypeGetShaderInfoLog +glrefGetShaderInfoLog :: IORef FuntypeGetShaderInfoLog +glrefGetShaderInfoLog = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetShaderInfoLog #-} +glGetShaderInfoLog :: FuntypeGetShaderInfoLog +glGetShaderInfoLog = unsafePerformIO $ readIORef glrefGetShaderInfoLog +{-# INLINE glGetShaderInfoLog #-} +type FuntypeGetShaderSource = + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetShaderSource :: FunPtr FuntypeGetShaderSource -> FuntypeGetShaderSource +glrefGetShaderSource :: IORef FuntypeGetShaderSource +glrefGetShaderSource = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetShaderSource #-} +glGetShaderSource :: FuntypeGetShaderSource +glGetShaderSource = unsafePerformIO $ readIORef glrefGetShaderSource +{-# INLINE glGetShaderSource #-} +type FuntypeGetUniformLocation = + GLuint -> + Ptr (GLchar) -> + IO ( GLint ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetUniformLocation :: FunPtr FuntypeGetUniformLocation -> FuntypeGetUniformLocation +glrefGetUniformLocation :: IORef FuntypeGetUniformLocation +glrefGetUniformLocation = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetUniformLocation #-} +glGetUniformLocation :: FuntypeGetUniformLocation +glGetUniformLocation = unsafePerformIO $ readIORef glrefGetUniformLocation +{-# INLINE glGetUniformLocation #-} +type FuntypeGetUniformfv = + GLuint -> + GLint -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetUniformfv :: FunPtr FuntypeGetUniformfv -> FuntypeGetUniformfv +glrefGetUniformfv :: IORef FuntypeGetUniformfv +glrefGetUniformfv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetUniformfv #-} +glGetUniformfv :: FuntypeGetUniformfv +glGetUniformfv = unsafePerformIO $ readIORef glrefGetUniformfv +{-# INLINE glGetUniformfv #-} +type FuntypeGetUniformiv = + GLuint -> + GLint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetUniformiv :: FunPtr FuntypeGetUniformiv -> FuntypeGetUniformiv +glrefGetUniformiv :: IORef FuntypeGetUniformiv +glrefGetUniformiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetUniformiv #-} +glGetUniformiv :: FuntypeGetUniformiv +glGetUniformiv = unsafePerformIO $ readIORef glrefGetUniformiv +{-# INLINE glGetUniformiv #-} +type FuntypeGetVertexAttribdv = + GLuint -> + GLenum -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetVertexAttribdv :: FunPtr FuntypeGetVertexAttribdv -> FuntypeGetVertexAttribdv +glrefGetVertexAttribdv :: IORef FuntypeGetVertexAttribdv +glrefGetVertexAttribdv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetVertexAttribdv #-} +glGetVertexAttribdv :: FuntypeGetVertexAttribdv +glGetVertexAttribdv = unsafePerformIO $ readIORef glrefGetVertexAttribdv +{-# INLINE glGetVertexAttribdv #-} +type FuntypeGetVertexAttribfv = + GLuint -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetVertexAttribfv :: FunPtr FuntypeGetVertexAttribfv -> FuntypeGetVertexAttribfv +glrefGetVertexAttribfv :: IORef FuntypeGetVertexAttribfv +glrefGetVertexAttribfv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetVertexAttribfv #-} +glGetVertexAttribfv :: FuntypeGetVertexAttribfv +glGetVertexAttribfv = unsafePerformIO $ readIORef glrefGetVertexAttribfv +{-# INLINE glGetVertexAttribfv #-} +type FuntypeGetVertexAttribiv = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetVertexAttribiv :: FunPtr FuntypeGetVertexAttribiv -> FuntypeGetVertexAttribiv +glrefGetVertexAttribiv :: IORef FuntypeGetVertexAttribiv +glrefGetVertexAttribiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetVertexAttribiv #-} +glGetVertexAttribiv :: FuntypeGetVertexAttribiv +glGetVertexAttribiv = unsafePerformIO $ readIORef glrefGetVertexAttribiv +{-# INLINE glGetVertexAttribiv #-} +type FuntypeGetVertexAttribPointerv = + GLuint -> + GLenum -> + Ptr (Ptr ()) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetVertexAttribPointerv :: FunPtr FuntypeGetVertexAttribPointerv -> FuntypeGetVertexAttribPointerv +glrefGetVertexAttribPointerv :: IORef FuntypeGetVertexAttribPointerv +glrefGetVertexAttribPointerv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetVertexAttribPointerv #-} +glGetVertexAttribPointerv :: FuntypeGetVertexAttribPointerv +glGetVertexAttribPointerv = unsafePerformIO $ readIORef glrefGetVertexAttribPointerv +{-# INLINE glGetVertexAttribPointerv #-} +type FuntypeIsProgram = + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsProgram :: FunPtr FuntypeIsProgram -> FuntypeIsProgram +glrefIsProgram :: IORef FuntypeIsProgram +glrefIsProgram = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsProgram #-} +glIsProgram :: FuntypeIsProgram +glIsProgram = unsafePerformIO $ readIORef glrefIsProgram +{-# INLINE glIsProgram #-} +type FuntypeIsShader = + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsShader :: FunPtr FuntypeIsShader -> FuntypeIsShader +glrefIsShader :: IORef FuntypeIsShader +glrefIsShader = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsShader #-} +glIsShader :: FuntypeIsShader +glIsShader = unsafePerformIO $ readIORef glrefIsShader +{-# INLINE glIsShader #-} +type FuntypeLinkProgram = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynLinkProgram :: FunPtr FuntypeLinkProgram -> FuntypeLinkProgram +glrefLinkProgram :: IORef FuntypeLinkProgram +glrefLinkProgram = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefLinkProgram #-} +glLinkProgram :: FuntypeLinkProgram +glLinkProgram = unsafePerformIO $ readIORef glrefLinkProgram +{-# INLINE glLinkProgram #-} +type FuntypeShaderSource = + GLuint -> + GLsizei -> + Ptr (Ptr (GLchar)) -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynShaderSource :: FunPtr FuntypeShaderSource -> FuntypeShaderSource +glrefShaderSource :: IORef FuntypeShaderSource +glrefShaderSource = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefShaderSource #-} +glShaderSource :: FuntypeShaderSource +glShaderSource = unsafePerformIO $ readIORef glrefShaderSource +{-# INLINE glShaderSource #-} +type FuntypeUseProgram = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUseProgram :: FunPtr FuntypeUseProgram -> FuntypeUseProgram +glrefUseProgram :: IORef FuntypeUseProgram +glrefUseProgram = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUseProgram #-} +glUseProgram :: FuntypeUseProgram +glUseProgram = unsafePerformIO $ readIORef glrefUseProgram +{-# INLINE glUseProgram #-} +type FuntypeUniform1f = + GLint -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform1f :: FunPtr FuntypeUniform1f -> FuntypeUniform1f +glrefUniform1f :: IORef FuntypeUniform1f +glrefUniform1f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform1f #-} +glUniform1f :: FuntypeUniform1f +glUniform1f = unsafePerformIO $ readIORef glrefUniform1f +{-# INLINE glUniform1f #-} +type FuntypeUniform2f = + GLint -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform2f :: FunPtr FuntypeUniform2f -> FuntypeUniform2f +glrefUniform2f :: IORef FuntypeUniform2f +glrefUniform2f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform2f #-} +glUniform2f :: FuntypeUniform2f +glUniform2f = unsafePerformIO $ readIORef glrefUniform2f +{-# INLINE glUniform2f #-} +type FuntypeUniform3f = + GLint -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform3f :: FunPtr FuntypeUniform3f -> FuntypeUniform3f +glrefUniform3f :: IORef FuntypeUniform3f +glrefUniform3f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform3f #-} +glUniform3f :: FuntypeUniform3f +glUniform3f = unsafePerformIO $ readIORef glrefUniform3f +{-# INLINE glUniform3f #-} +type FuntypeUniform4f = + GLint -> + GLfloat -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform4f :: FunPtr FuntypeUniform4f -> FuntypeUniform4f +glrefUniform4f :: IORef FuntypeUniform4f +glrefUniform4f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform4f #-} +glUniform4f :: FuntypeUniform4f +glUniform4f = unsafePerformIO $ readIORef glrefUniform4f +{-# INLINE glUniform4f #-} +type FuntypeUniform1i = + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform1i :: FunPtr FuntypeUniform1i -> FuntypeUniform1i +glrefUniform1i :: IORef FuntypeUniform1i +glrefUniform1i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform1i #-} +glUniform1i :: FuntypeUniform1i +glUniform1i = unsafePerformIO $ readIORef glrefUniform1i +{-# INLINE glUniform1i #-} +type FuntypeUniform2i = + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform2i :: FunPtr FuntypeUniform2i -> FuntypeUniform2i +glrefUniform2i :: IORef FuntypeUniform2i +glrefUniform2i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform2i #-} +glUniform2i :: FuntypeUniform2i +glUniform2i = unsafePerformIO $ readIORef glrefUniform2i +{-# INLINE glUniform2i #-} +type FuntypeUniform3i = + GLint -> + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform3i :: FunPtr FuntypeUniform3i -> FuntypeUniform3i +glrefUniform3i :: IORef FuntypeUniform3i +glrefUniform3i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform3i #-} +glUniform3i :: FuntypeUniform3i +glUniform3i = unsafePerformIO $ readIORef glrefUniform3i +{-# INLINE glUniform3i #-} +type FuntypeUniform4i = + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform4i :: FunPtr FuntypeUniform4i -> FuntypeUniform4i +glrefUniform4i :: IORef FuntypeUniform4i +glrefUniform4i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform4i #-} +glUniform4i :: FuntypeUniform4i +glUniform4i = unsafePerformIO $ readIORef glrefUniform4i +{-# INLINE glUniform4i #-} +type FuntypeUniform1fv = + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform1fv :: FunPtr FuntypeUniform1fv -> FuntypeUniform1fv +glrefUniform1fv :: IORef FuntypeUniform1fv +glrefUniform1fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform1fv #-} +glUniform1fv :: FuntypeUniform1fv +glUniform1fv = unsafePerformIO $ readIORef glrefUniform1fv +{-# INLINE glUniform1fv #-} +type FuntypeUniform2fv = + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform2fv :: FunPtr FuntypeUniform2fv -> FuntypeUniform2fv +glrefUniform2fv :: IORef FuntypeUniform2fv +glrefUniform2fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform2fv #-} +glUniform2fv :: FuntypeUniform2fv +glUniform2fv = unsafePerformIO $ readIORef glrefUniform2fv +{-# INLINE glUniform2fv #-} +type FuntypeUniform3fv = + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform3fv :: FunPtr FuntypeUniform3fv -> FuntypeUniform3fv +glrefUniform3fv :: IORef FuntypeUniform3fv +glrefUniform3fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform3fv #-} +glUniform3fv :: FuntypeUniform3fv +glUniform3fv = unsafePerformIO $ readIORef glrefUniform3fv +{-# INLINE glUniform3fv #-} +type FuntypeUniform4fv = + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform4fv :: FunPtr FuntypeUniform4fv -> FuntypeUniform4fv +glrefUniform4fv :: IORef FuntypeUniform4fv +glrefUniform4fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform4fv #-} +glUniform4fv :: FuntypeUniform4fv +glUniform4fv = unsafePerformIO $ readIORef glrefUniform4fv +{-# INLINE glUniform4fv #-} +type FuntypeUniform1iv = + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform1iv :: FunPtr FuntypeUniform1iv -> FuntypeUniform1iv +glrefUniform1iv :: IORef FuntypeUniform1iv +glrefUniform1iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform1iv #-} +glUniform1iv :: FuntypeUniform1iv +glUniform1iv = unsafePerformIO $ readIORef glrefUniform1iv +{-# INLINE glUniform1iv #-} +type FuntypeUniform2iv = + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform2iv :: FunPtr FuntypeUniform2iv -> FuntypeUniform2iv +glrefUniform2iv :: IORef FuntypeUniform2iv +glrefUniform2iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform2iv #-} +glUniform2iv :: FuntypeUniform2iv +glUniform2iv = unsafePerformIO $ readIORef glrefUniform2iv +{-# INLINE glUniform2iv #-} +type FuntypeUniform3iv = + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform3iv :: FunPtr FuntypeUniform3iv -> FuntypeUniform3iv +glrefUniform3iv :: IORef FuntypeUniform3iv +glrefUniform3iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform3iv #-} +glUniform3iv :: FuntypeUniform3iv +glUniform3iv = unsafePerformIO $ readIORef glrefUniform3iv +{-# INLINE glUniform3iv #-} +type FuntypeUniform4iv = + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform4iv :: FunPtr FuntypeUniform4iv -> FuntypeUniform4iv +glrefUniform4iv :: IORef FuntypeUniform4iv +glrefUniform4iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform4iv #-} +glUniform4iv :: FuntypeUniform4iv +glUniform4iv = unsafePerformIO $ readIORef glrefUniform4iv +{-# INLINE glUniform4iv #-} +type FuntypeUniformMatrix2fv = + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniformMatrix2fv :: FunPtr FuntypeUniformMatrix2fv -> FuntypeUniformMatrix2fv +glrefUniformMatrix2fv :: IORef FuntypeUniformMatrix2fv +glrefUniformMatrix2fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniformMatrix2fv #-} +glUniformMatrix2fv :: FuntypeUniformMatrix2fv +glUniformMatrix2fv = unsafePerformIO $ readIORef glrefUniformMatrix2fv +{-# INLINE glUniformMatrix2fv #-} +type FuntypeUniformMatrix3fv = + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniformMatrix3fv :: FunPtr FuntypeUniformMatrix3fv -> FuntypeUniformMatrix3fv +glrefUniformMatrix3fv :: IORef FuntypeUniformMatrix3fv +glrefUniformMatrix3fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniformMatrix3fv #-} +glUniformMatrix3fv :: FuntypeUniformMatrix3fv +glUniformMatrix3fv = unsafePerformIO $ readIORef glrefUniformMatrix3fv +{-# INLINE glUniformMatrix3fv #-} +type FuntypeUniformMatrix4fv = + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniformMatrix4fv :: FunPtr FuntypeUniformMatrix4fv -> FuntypeUniformMatrix4fv +glrefUniformMatrix4fv :: IORef FuntypeUniformMatrix4fv +glrefUniformMatrix4fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniformMatrix4fv #-} +glUniformMatrix4fv :: FuntypeUniformMatrix4fv +glUniformMatrix4fv = unsafePerformIO $ readIORef glrefUniformMatrix4fv +{-# INLINE glUniformMatrix4fv #-} +type FuntypeValidateProgram = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynValidateProgram :: FunPtr FuntypeValidateProgram -> FuntypeValidateProgram +glrefValidateProgram :: IORef FuntypeValidateProgram +glrefValidateProgram = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefValidateProgram #-} +glValidateProgram :: FuntypeValidateProgram +glValidateProgram = unsafePerformIO $ readIORef glrefValidateProgram +{-# INLINE glValidateProgram #-} +type FuntypeVertexAttrib1d = + GLuint -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib1d :: FunPtr FuntypeVertexAttrib1d -> FuntypeVertexAttrib1d +glrefVertexAttrib1d :: IORef FuntypeVertexAttrib1d +glrefVertexAttrib1d = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib1d #-} +glVertexAttrib1d :: FuntypeVertexAttrib1d +glVertexAttrib1d = unsafePerformIO $ readIORef glrefVertexAttrib1d +{-# INLINE glVertexAttrib1d #-} +type FuntypeVertexAttrib1dv = + GLuint -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib1dv :: FunPtr FuntypeVertexAttrib1dv -> FuntypeVertexAttrib1dv +glrefVertexAttrib1dv :: IORef FuntypeVertexAttrib1dv +glrefVertexAttrib1dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib1dv #-} +glVertexAttrib1dv :: FuntypeVertexAttrib1dv +glVertexAttrib1dv = unsafePerformIO $ readIORef glrefVertexAttrib1dv +{-# INLINE glVertexAttrib1dv #-} +type FuntypeVertexAttrib1f = + GLuint -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib1f :: FunPtr FuntypeVertexAttrib1f -> FuntypeVertexAttrib1f +glrefVertexAttrib1f :: IORef FuntypeVertexAttrib1f +glrefVertexAttrib1f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib1f #-} +glVertexAttrib1f :: FuntypeVertexAttrib1f +glVertexAttrib1f = unsafePerformIO $ readIORef glrefVertexAttrib1f +{-# INLINE glVertexAttrib1f #-} +type FuntypeVertexAttrib1fv = + GLuint -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib1fv :: FunPtr FuntypeVertexAttrib1fv -> FuntypeVertexAttrib1fv +glrefVertexAttrib1fv :: IORef FuntypeVertexAttrib1fv +glrefVertexAttrib1fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib1fv #-} +glVertexAttrib1fv :: FuntypeVertexAttrib1fv +glVertexAttrib1fv = unsafePerformIO $ readIORef glrefVertexAttrib1fv +{-# INLINE glVertexAttrib1fv #-} +type FuntypeVertexAttrib1s = + GLuint -> + GLshort -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib1s :: FunPtr FuntypeVertexAttrib1s -> FuntypeVertexAttrib1s +glrefVertexAttrib1s :: IORef FuntypeVertexAttrib1s +glrefVertexAttrib1s = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib1s #-} +glVertexAttrib1s :: FuntypeVertexAttrib1s +glVertexAttrib1s = unsafePerformIO $ readIORef glrefVertexAttrib1s +{-# INLINE glVertexAttrib1s #-} +type FuntypeVertexAttrib1sv = + GLuint -> + Ptr (GLshort) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib1sv :: FunPtr FuntypeVertexAttrib1sv -> FuntypeVertexAttrib1sv +glrefVertexAttrib1sv :: IORef FuntypeVertexAttrib1sv +glrefVertexAttrib1sv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib1sv #-} +glVertexAttrib1sv :: FuntypeVertexAttrib1sv +glVertexAttrib1sv = unsafePerformIO $ readIORef glrefVertexAttrib1sv +{-# INLINE glVertexAttrib1sv #-} +type FuntypeVertexAttrib2d = + GLuint -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib2d :: FunPtr FuntypeVertexAttrib2d -> FuntypeVertexAttrib2d +glrefVertexAttrib2d :: IORef FuntypeVertexAttrib2d +glrefVertexAttrib2d = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib2d #-} +glVertexAttrib2d :: FuntypeVertexAttrib2d +glVertexAttrib2d = unsafePerformIO $ readIORef glrefVertexAttrib2d +{-# INLINE glVertexAttrib2d #-} +type FuntypeVertexAttrib2dv = + GLuint -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib2dv :: FunPtr FuntypeVertexAttrib2dv -> FuntypeVertexAttrib2dv +glrefVertexAttrib2dv :: IORef FuntypeVertexAttrib2dv +glrefVertexAttrib2dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib2dv #-} +glVertexAttrib2dv :: FuntypeVertexAttrib2dv +glVertexAttrib2dv = unsafePerformIO $ readIORef glrefVertexAttrib2dv +{-# INLINE glVertexAttrib2dv #-} +type FuntypeVertexAttrib2f = + GLuint -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib2f :: FunPtr FuntypeVertexAttrib2f -> FuntypeVertexAttrib2f +glrefVertexAttrib2f :: IORef FuntypeVertexAttrib2f +glrefVertexAttrib2f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib2f #-} +glVertexAttrib2f :: FuntypeVertexAttrib2f +glVertexAttrib2f = unsafePerformIO $ readIORef glrefVertexAttrib2f +{-# INLINE glVertexAttrib2f #-} +type FuntypeVertexAttrib2fv = + GLuint -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib2fv :: FunPtr FuntypeVertexAttrib2fv -> FuntypeVertexAttrib2fv +glrefVertexAttrib2fv :: IORef FuntypeVertexAttrib2fv +glrefVertexAttrib2fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib2fv #-} +glVertexAttrib2fv :: FuntypeVertexAttrib2fv +glVertexAttrib2fv = unsafePerformIO $ readIORef glrefVertexAttrib2fv +{-# INLINE glVertexAttrib2fv #-} +type FuntypeVertexAttrib2s = + GLuint -> + GLshort -> + GLshort -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib2s :: FunPtr FuntypeVertexAttrib2s -> FuntypeVertexAttrib2s +glrefVertexAttrib2s :: IORef FuntypeVertexAttrib2s +glrefVertexAttrib2s = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib2s #-} +glVertexAttrib2s :: FuntypeVertexAttrib2s +glVertexAttrib2s = unsafePerformIO $ readIORef glrefVertexAttrib2s +{-# INLINE glVertexAttrib2s #-} +type FuntypeVertexAttrib2sv = + GLuint -> + Ptr (GLshort) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib2sv :: FunPtr FuntypeVertexAttrib2sv -> FuntypeVertexAttrib2sv +glrefVertexAttrib2sv :: IORef FuntypeVertexAttrib2sv +glrefVertexAttrib2sv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib2sv #-} +glVertexAttrib2sv :: FuntypeVertexAttrib2sv +glVertexAttrib2sv = unsafePerformIO $ readIORef glrefVertexAttrib2sv +{-# INLINE glVertexAttrib2sv #-} +type FuntypeVertexAttrib3d = + GLuint -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib3d :: FunPtr FuntypeVertexAttrib3d -> FuntypeVertexAttrib3d +glrefVertexAttrib3d :: IORef FuntypeVertexAttrib3d +glrefVertexAttrib3d = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib3d #-} +glVertexAttrib3d :: FuntypeVertexAttrib3d +glVertexAttrib3d = unsafePerformIO $ readIORef glrefVertexAttrib3d +{-# INLINE glVertexAttrib3d #-} +type FuntypeVertexAttrib3dv = + GLuint -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib3dv :: FunPtr FuntypeVertexAttrib3dv -> FuntypeVertexAttrib3dv +glrefVertexAttrib3dv :: IORef FuntypeVertexAttrib3dv +glrefVertexAttrib3dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib3dv #-} +glVertexAttrib3dv :: FuntypeVertexAttrib3dv +glVertexAttrib3dv = unsafePerformIO $ readIORef glrefVertexAttrib3dv +{-# INLINE glVertexAttrib3dv #-} +type FuntypeVertexAttrib3f = + GLuint -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib3f :: FunPtr FuntypeVertexAttrib3f -> FuntypeVertexAttrib3f +glrefVertexAttrib3f :: IORef FuntypeVertexAttrib3f +glrefVertexAttrib3f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib3f #-} +glVertexAttrib3f :: FuntypeVertexAttrib3f +glVertexAttrib3f = unsafePerformIO $ readIORef glrefVertexAttrib3f +{-# INLINE glVertexAttrib3f #-} +type FuntypeVertexAttrib3fv = + GLuint -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib3fv :: FunPtr FuntypeVertexAttrib3fv -> FuntypeVertexAttrib3fv +glrefVertexAttrib3fv :: IORef FuntypeVertexAttrib3fv +glrefVertexAttrib3fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib3fv #-} +glVertexAttrib3fv :: FuntypeVertexAttrib3fv +glVertexAttrib3fv = unsafePerformIO $ readIORef glrefVertexAttrib3fv +{-# INLINE glVertexAttrib3fv #-} +type FuntypeVertexAttrib3s = + GLuint -> + GLshort -> + GLshort -> + GLshort -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib3s :: FunPtr FuntypeVertexAttrib3s -> FuntypeVertexAttrib3s +glrefVertexAttrib3s :: IORef FuntypeVertexAttrib3s +glrefVertexAttrib3s = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib3s #-} +glVertexAttrib3s :: FuntypeVertexAttrib3s +glVertexAttrib3s = unsafePerformIO $ readIORef glrefVertexAttrib3s +{-# INLINE glVertexAttrib3s #-} +type FuntypeVertexAttrib3sv = + GLuint -> + Ptr (GLshort) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib3sv :: FunPtr FuntypeVertexAttrib3sv -> FuntypeVertexAttrib3sv +glrefVertexAttrib3sv :: IORef FuntypeVertexAttrib3sv +glrefVertexAttrib3sv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib3sv #-} +glVertexAttrib3sv :: FuntypeVertexAttrib3sv +glVertexAttrib3sv = unsafePerformIO $ readIORef glrefVertexAttrib3sv +{-# INLINE glVertexAttrib3sv #-} +type FuntypeVertexAttrib4Nbv = + GLuint -> + Ptr (GLbyte) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4Nbv :: FunPtr FuntypeVertexAttrib4Nbv -> FuntypeVertexAttrib4Nbv +glrefVertexAttrib4Nbv :: IORef FuntypeVertexAttrib4Nbv +glrefVertexAttrib4Nbv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4Nbv #-} +glVertexAttrib4Nbv :: FuntypeVertexAttrib4Nbv +glVertexAttrib4Nbv = unsafePerformIO $ readIORef glrefVertexAttrib4Nbv +{-# INLINE glVertexAttrib4Nbv #-} +type FuntypeVertexAttrib4Niv = + GLuint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4Niv :: FunPtr FuntypeVertexAttrib4Niv -> FuntypeVertexAttrib4Niv +glrefVertexAttrib4Niv :: IORef FuntypeVertexAttrib4Niv +glrefVertexAttrib4Niv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4Niv #-} +glVertexAttrib4Niv :: FuntypeVertexAttrib4Niv +glVertexAttrib4Niv = unsafePerformIO $ readIORef glrefVertexAttrib4Niv +{-# INLINE glVertexAttrib4Niv #-} +type FuntypeVertexAttrib4Nsv = + GLuint -> + Ptr (GLshort) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4Nsv :: FunPtr FuntypeVertexAttrib4Nsv -> FuntypeVertexAttrib4Nsv +glrefVertexAttrib4Nsv :: IORef FuntypeVertexAttrib4Nsv +glrefVertexAttrib4Nsv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4Nsv #-} +glVertexAttrib4Nsv :: FuntypeVertexAttrib4Nsv +glVertexAttrib4Nsv = unsafePerformIO $ readIORef glrefVertexAttrib4Nsv +{-# INLINE glVertexAttrib4Nsv #-} +type FuntypeVertexAttrib4Nub = + GLuint -> + GLubyte -> + GLubyte -> + GLubyte -> + GLubyte -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4Nub :: FunPtr FuntypeVertexAttrib4Nub -> FuntypeVertexAttrib4Nub +glrefVertexAttrib4Nub :: IORef FuntypeVertexAttrib4Nub +glrefVertexAttrib4Nub = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4Nub #-} +glVertexAttrib4Nub :: FuntypeVertexAttrib4Nub +glVertexAttrib4Nub = unsafePerformIO $ readIORef glrefVertexAttrib4Nub +{-# INLINE glVertexAttrib4Nub #-} +type FuntypeVertexAttrib4Nubv = + GLuint -> + Ptr (GLubyte) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4Nubv :: FunPtr FuntypeVertexAttrib4Nubv -> FuntypeVertexAttrib4Nubv +glrefVertexAttrib4Nubv :: IORef FuntypeVertexAttrib4Nubv +glrefVertexAttrib4Nubv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4Nubv #-} +glVertexAttrib4Nubv :: FuntypeVertexAttrib4Nubv +glVertexAttrib4Nubv = unsafePerformIO $ readIORef glrefVertexAttrib4Nubv +{-# INLINE glVertexAttrib4Nubv #-} +type FuntypeVertexAttrib4Nuiv = + GLuint -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4Nuiv :: FunPtr FuntypeVertexAttrib4Nuiv -> FuntypeVertexAttrib4Nuiv +glrefVertexAttrib4Nuiv :: IORef FuntypeVertexAttrib4Nuiv +glrefVertexAttrib4Nuiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4Nuiv #-} +glVertexAttrib4Nuiv :: FuntypeVertexAttrib4Nuiv +glVertexAttrib4Nuiv = unsafePerformIO $ readIORef glrefVertexAttrib4Nuiv +{-# INLINE glVertexAttrib4Nuiv #-} +type FuntypeVertexAttrib4Nusv = + GLuint -> + Ptr (GLushort) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4Nusv :: FunPtr FuntypeVertexAttrib4Nusv -> FuntypeVertexAttrib4Nusv +glrefVertexAttrib4Nusv :: IORef FuntypeVertexAttrib4Nusv +glrefVertexAttrib4Nusv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4Nusv #-} +glVertexAttrib4Nusv :: FuntypeVertexAttrib4Nusv +glVertexAttrib4Nusv = unsafePerformIO $ readIORef glrefVertexAttrib4Nusv +{-# INLINE glVertexAttrib4Nusv #-} +type FuntypeVertexAttrib4bv = + GLuint -> + Ptr (GLbyte) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4bv :: FunPtr FuntypeVertexAttrib4bv -> FuntypeVertexAttrib4bv +glrefVertexAttrib4bv :: IORef FuntypeVertexAttrib4bv +glrefVertexAttrib4bv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4bv #-} +glVertexAttrib4bv :: FuntypeVertexAttrib4bv +glVertexAttrib4bv = unsafePerformIO $ readIORef glrefVertexAttrib4bv +{-# INLINE glVertexAttrib4bv #-} +type FuntypeVertexAttrib4d = + GLuint -> + GLdouble -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4d :: FunPtr FuntypeVertexAttrib4d -> FuntypeVertexAttrib4d +glrefVertexAttrib4d :: IORef FuntypeVertexAttrib4d +glrefVertexAttrib4d = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4d #-} +glVertexAttrib4d :: FuntypeVertexAttrib4d +glVertexAttrib4d = unsafePerformIO $ readIORef glrefVertexAttrib4d +{-# INLINE glVertexAttrib4d #-} +type FuntypeVertexAttrib4dv = + GLuint -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4dv :: FunPtr FuntypeVertexAttrib4dv -> FuntypeVertexAttrib4dv +glrefVertexAttrib4dv :: IORef FuntypeVertexAttrib4dv +glrefVertexAttrib4dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4dv #-} +glVertexAttrib4dv :: FuntypeVertexAttrib4dv +glVertexAttrib4dv = unsafePerformIO $ readIORef glrefVertexAttrib4dv +{-# INLINE glVertexAttrib4dv #-} +type FuntypeVertexAttrib4f = + GLuint -> + GLfloat -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4f :: FunPtr FuntypeVertexAttrib4f -> FuntypeVertexAttrib4f +glrefVertexAttrib4f :: IORef FuntypeVertexAttrib4f +glrefVertexAttrib4f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4f #-} +glVertexAttrib4f :: FuntypeVertexAttrib4f +glVertexAttrib4f = unsafePerformIO $ readIORef glrefVertexAttrib4f +{-# INLINE glVertexAttrib4f #-} +type FuntypeVertexAttrib4fv = + GLuint -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4fv :: FunPtr FuntypeVertexAttrib4fv -> FuntypeVertexAttrib4fv +glrefVertexAttrib4fv :: IORef FuntypeVertexAttrib4fv +glrefVertexAttrib4fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4fv #-} +glVertexAttrib4fv :: FuntypeVertexAttrib4fv +glVertexAttrib4fv = unsafePerformIO $ readIORef glrefVertexAttrib4fv +{-# INLINE glVertexAttrib4fv #-} +type FuntypeVertexAttrib4iv = + GLuint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4iv :: FunPtr FuntypeVertexAttrib4iv -> FuntypeVertexAttrib4iv +glrefVertexAttrib4iv :: IORef FuntypeVertexAttrib4iv +glrefVertexAttrib4iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4iv #-} +glVertexAttrib4iv :: FuntypeVertexAttrib4iv +glVertexAttrib4iv = unsafePerformIO $ readIORef glrefVertexAttrib4iv +{-# INLINE glVertexAttrib4iv #-} +type FuntypeVertexAttrib4s = + GLuint -> + GLshort -> + GLshort -> + GLshort -> + GLshort -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4s :: FunPtr FuntypeVertexAttrib4s -> FuntypeVertexAttrib4s +glrefVertexAttrib4s :: IORef FuntypeVertexAttrib4s +glrefVertexAttrib4s = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4s #-} +glVertexAttrib4s :: FuntypeVertexAttrib4s +glVertexAttrib4s = unsafePerformIO $ readIORef glrefVertexAttrib4s +{-# INLINE glVertexAttrib4s #-} +type FuntypeVertexAttrib4sv = + GLuint -> + Ptr (GLshort) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4sv :: FunPtr FuntypeVertexAttrib4sv -> FuntypeVertexAttrib4sv +glrefVertexAttrib4sv :: IORef FuntypeVertexAttrib4sv +glrefVertexAttrib4sv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4sv #-} +glVertexAttrib4sv :: FuntypeVertexAttrib4sv +glVertexAttrib4sv = unsafePerformIO $ readIORef glrefVertexAttrib4sv +{-# INLINE glVertexAttrib4sv #-} +type FuntypeVertexAttrib4ubv = + GLuint -> + Ptr (GLubyte) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4ubv :: FunPtr FuntypeVertexAttrib4ubv -> FuntypeVertexAttrib4ubv +glrefVertexAttrib4ubv :: IORef FuntypeVertexAttrib4ubv +glrefVertexAttrib4ubv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4ubv #-} +glVertexAttrib4ubv :: FuntypeVertexAttrib4ubv +glVertexAttrib4ubv = unsafePerformIO $ readIORef glrefVertexAttrib4ubv +{-# INLINE glVertexAttrib4ubv #-} +type FuntypeVertexAttrib4uiv = + GLuint -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4uiv :: FunPtr FuntypeVertexAttrib4uiv -> FuntypeVertexAttrib4uiv +glrefVertexAttrib4uiv :: IORef FuntypeVertexAttrib4uiv +glrefVertexAttrib4uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4uiv #-} +glVertexAttrib4uiv :: FuntypeVertexAttrib4uiv +glVertexAttrib4uiv = unsafePerformIO $ readIORef glrefVertexAttrib4uiv +{-# INLINE glVertexAttrib4uiv #-} +type FuntypeVertexAttrib4usv = + GLuint -> + Ptr (GLushort) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttrib4usv :: FunPtr FuntypeVertexAttrib4usv -> FuntypeVertexAttrib4usv +glrefVertexAttrib4usv :: IORef FuntypeVertexAttrib4usv +glrefVertexAttrib4usv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttrib4usv #-} +glVertexAttrib4usv :: FuntypeVertexAttrib4usv +glVertexAttrib4usv = unsafePerformIO $ readIORef glrefVertexAttrib4usv +{-# INLINE glVertexAttrib4usv #-} +type FuntypeVertexAttribPointer = + GLuint -> + GLint -> + GLenum -> + GLboolean -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribPointer :: FunPtr FuntypeVertexAttribPointer -> FuntypeVertexAttribPointer +glrefVertexAttribPointer :: IORef FuntypeVertexAttribPointer +glrefVertexAttribPointer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribPointer #-} +glVertexAttribPointer :: FuntypeVertexAttribPointer +glVertexAttribPointer = unsafePerformIO $ readIORef glrefVertexAttribPointer +{-# INLINE glVertexAttribPointer #-} + +-- GL_VERSION_2_1 + +type FuntypeUniformMatrix2x3fv = + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniformMatrix2x3fv :: FunPtr FuntypeUniformMatrix2x3fv -> FuntypeUniformMatrix2x3fv +glrefUniformMatrix2x3fv :: IORef FuntypeUniformMatrix2x3fv +glrefUniformMatrix2x3fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniformMatrix2x3fv #-} +glUniformMatrix2x3fv :: FuntypeUniformMatrix2x3fv +glUniformMatrix2x3fv = unsafePerformIO $ readIORef glrefUniformMatrix2x3fv +{-# INLINE glUniformMatrix2x3fv #-} +type FuntypeUniformMatrix3x2fv = + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniformMatrix3x2fv :: FunPtr FuntypeUniformMatrix3x2fv -> FuntypeUniformMatrix3x2fv +glrefUniformMatrix3x2fv :: IORef FuntypeUniformMatrix3x2fv +glrefUniformMatrix3x2fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniformMatrix3x2fv #-} +glUniformMatrix3x2fv :: FuntypeUniformMatrix3x2fv +glUniformMatrix3x2fv = unsafePerformIO $ readIORef glrefUniformMatrix3x2fv +{-# INLINE glUniformMatrix3x2fv #-} +type FuntypeUniformMatrix2x4fv = + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniformMatrix2x4fv :: FunPtr FuntypeUniformMatrix2x4fv -> FuntypeUniformMatrix2x4fv +glrefUniformMatrix2x4fv :: IORef FuntypeUniformMatrix2x4fv +glrefUniformMatrix2x4fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniformMatrix2x4fv #-} +glUniformMatrix2x4fv :: FuntypeUniformMatrix2x4fv +glUniformMatrix2x4fv = unsafePerformIO $ readIORef glrefUniformMatrix2x4fv +{-# INLINE glUniformMatrix2x4fv #-} +type FuntypeUniformMatrix4x2fv = + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniformMatrix4x2fv :: FunPtr FuntypeUniformMatrix4x2fv -> FuntypeUniformMatrix4x2fv +glrefUniformMatrix4x2fv :: IORef FuntypeUniformMatrix4x2fv +glrefUniformMatrix4x2fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniformMatrix4x2fv #-} +glUniformMatrix4x2fv :: FuntypeUniformMatrix4x2fv +glUniformMatrix4x2fv = unsafePerformIO $ readIORef glrefUniformMatrix4x2fv +{-# INLINE glUniformMatrix4x2fv #-} +type FuntypeUniformMatrix3x4fv = + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniformMatrix3x4fv :: FunPtr FuntypeUniformMatrix3x4fv -> FuntypeUniformMatrix3x4fv +glrefUniformMatrix3x4fv :: IORef FuntypeUniformMatrix3x4fv +glrefUniformMatrix3x4fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniformMatrix3x4fv #-} +glUniformMatrix3x4fv :: FuntypeUniformMatrix3x4fv +glUniformMatrix3x4fv = unsafePerformIO $ readIORef glrefUniformMatrix3x4fv +{-# INLINE glUniformMatrix3x4fv #-} +type FuntypeUniformMatrix4x3fv = + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniformMatrix4x3fv :: FunPtr FuntypeUniformMatrix4x3fv -> FuntypeUniformMatrix4x3fv +glrefUniformMatrix4x3fv :: IORef FuntypeUniformMatrix4x3fv +glrefUniformMatrix4x3fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniformMatrix4x3fv #-} +glUniformMatrix4x3fv :: FuntypeUniformMatrix4x3fv +glUniformMatrix4x3fv = unsafePerformIO $ readIORef glrefUniformMatrix4x3fv +{-# INLINE glUniformMatrix4x3fv #-} + +-- GL_VERSION_3_0 + +type FuntypeColorMaski = + GLuint -> + GLboolean -> + GLboolean -> + GLboolean -> + GLboolean -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynColorMaski :: FunPtr FuntypeColorMaski -> FuntypeColorMaski +glrefColorMaski :: IORef FuntypeColorMaski +glrefColorMaski = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefColorMaski #-} +glColorMaski :: FuntypeColorMaski +glColorMaski = unsafePerformIO $ readIORef glrefColorMaski +{-# INLINE glColorMaski #-} +type FuntypeGetBooleani_v = + GLenum -> + GLuint -> + Ptr (GLboolean) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetBooleani_v :: FunPtr FuntypeGetBooleani_v -> FuntypeGetBooleani_v +glrefGetBooleani_v :: IORef FuntypeGetBooleani_v +glrefGetBooleani_v = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetBooleani_v #-} +glGetBooleani_v :: FuntypeGetBooleani_v +glGetBooleani_v = unsafePerformIO $ readIORef glrefGetBooleani_v +{-# INLINE glGetBooleani_v #-} +type FuntypeGetIntegeri_v = + GLenum -> + GLuint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetIntegeri_v :: FunPtr FuntypeGetIntegeri_v -> FuntypeGetIntegeri_v +glrefGetIntegeri_v :: IORef FuntypeGetIntegeri_v +glrefGetIntegeri_v = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetIntegeri_v #-} +glGetIntegeri_v :: FuntypeGetIntegeri_v +glGetIntegeri_v = unsafePerformIO $ readIORef glrefGetIntegeri_v +{-# INLINE glGetIntegeri_v #-} +type FuntypeEnablei = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynEnablei :: FunPtr FuntypeEnablei -> FuntypeEnablei +glrefEnablei :: IORef FuntypeEnablei +glrefEnablei = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefEnablei #-} +glEnablei :: FuntypeEnablei +glEnablei = unsafePerformIO $ readIORef glrefEnablei +{-# INLINE glEnablei #-} +type FuntypeDisablei = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDisablei :: FunPtr FuntypeDisablei -> FuntypeDisablei +glrefDisablei :: IORef FuntypeDisablei +glrefDisablei = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDisablei #-} +glDisablei :: FuntypeDisablei +glDisablei = unsafePerformIO $ readIORef glrefDisablei +{-# INLINE glDisablei #-} +type FuntypeIsEnabledi = + GLenum -> + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsEnabledi :: FunPtr FuntypeIsEnabledi -> FuntypeIsEnabledi +glrefIsEnabledi :: IORef FuntypeIsEnabledi +glrefIsEnabledi = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsEnabledi #-} +glIsEnabledi :: FuntypeIsEnabledi +glIsEnabledi = unsafePerformIO $ readIORef glrefIsEnabledi +{-# INLINE glIsEnabledi #-} +type FuntypeBeginTransformFeedback = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBeginTransformFeedback :: FunPtr FuntypeBeginTransformFeedback -> FuntypeBeginTransformFeedback +glrefBeginTransformFeedback :: IORef FuntypeBeginTransformFeedback +glrefBeginTransformFeedback = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBeginTransformFeedback #-} +glBeginTransformFeedback :: FuntypeBeginTransformFeedback +glBeginTransformFeedback = unsafePerformIO $ readIORef glrefBeginTransformFeedback +{-# INLINE glBeginTransformFeedback #-} +type FuntypeEndTransformFeedback = + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynEndTransformFeedback :: FunPtr FuntypeEndTransformFeedback -> FuntypeEndTransformFeedback +glrefEndTransformFeedback :: IORef FuntypeEndTransformFeedback +glrefEndTransformFeedback = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefEndTransformFeedback #-} +glEndTransformFeedback :: FuntypeEndTransformFeedback +glEndTransformFeedback = unsafePerformIO $ readIORef glrefEndTransformFeedback +{-# INLINE glEndTransformFeedback #-} +type FuntypeBindBufferRange = + GLenum -> + GLuint -> + GLuint -> + GLintptr -> + GLsizeiptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindBufferRange :: FunPtr FuntypeBindBufferRange -> FuntypeBindBufferRange +glrefBindBufferRange :: IORef FuntypeBindBufferRange +glrefBindBufferRange = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindBufferRange #-} +glBindBufferRange :: FuntypeBindBufferRange +glBindBufferRange = unsafePerformIO $ readIORef glrefBindBufferRange +{-# INLINE glBindBufferRange #-} +type FuntypeBindBufferBase = + GLenum -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindBufferBase :: FunPtr FuntypeBindBufferBase -> FuntypeBindBufferBase +glrefBindBufferBase :: IORef FuntypeBindBufferBase +glrefBindBufferBase = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindBufferBase #-} +glBindBufferBase :: FuntypeBindBufferBase +glBindBufferBase = unsafePerformIO $ readIORef glrefBindBufferBase +{-# INLINE glBindBufferBase #-} +type FuntypeTransformFeedbackVaryings = + GLuint -> + GLsizei -> + Ptr (Ptr (GLchar)) -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTransformFeedbackVaryings :: FunPtr FuntypeTransformFeedbackVaryings -> FuntypeTransformFeedbackVaryings +glrefTransformFeedbackVaryings :: IORef FuntypeTransformFeedbackVaryings +glrefTransformFeedbackVaryings = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTransformFeedbackVaryings #-} +glTransformFeedbackVaryings :: FuntypeTransformFeedbackVaryings +glTransformFeedbackVaryings = unsafePerformIO $ readIORef glrefTransformFeedbackVaryings +{-# INLINE glTransformFeedbackVaryings #-} +type FuntypeGetTransformFeedbackVarying = + GLuint -> + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLsizei) -> + Ptr (GLenum) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTransformFeedbackVarying :: FunPtr FuntypeGetTransformFeedbackVarying -> FuntypeGetTransformFeedbackVarying +glrefGetTransformFeedbackVarying :: IORef FuntypeGetTransformFeedbackVarying +glrefGetTransformFeedbackVarying = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTransformFeedbackVarying #-} +glGetTransformFeedbackVarying :: FuntypeGetTransformFeedbackVarying +glGetTransformFeedbackVarying = unsafePerformIO $ readIORef glrefGetTransformFeedbackVarying +{-# INLINE glGetTransformFeedbackVarying #-} +type FuntypeClampColor = + GLenum -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClampColor :: FunPtr FuntypeClampColor -> FuntypeClampColor +glrefClampColor :: IORef FuntypeClampColor +glrefClampColor = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClampColor #-} +glClampColor :: FuntypeClampColor +glClampColor = unsafePerformIO $ readIORef glrefClampColor +{-# INLINE glClampColor #-} +type FuntypeBeginConditionalRender = + GLuint -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBeginConditionalRender :: FunPtr FuntypeBeginConditionalRender -> FuntypeBeginConditionalRender +glrefBeginConditionalRender :: IORef FuntypeBeginConditionalRender +glrefBeginConditionalRender = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBeginConditionalRender #-} +glBeginConditionalRender :: FuntypeBeginConditionalRender +glBeginConditionalRender = unsafePerformIO $ readIORef glrefBeginConditionalRender +{-# INLINE glBeginConditionalRender #-} +type FuntypeEndConditionalRender = + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynEndConditionalRender :: FunPtr FuntypeEndConditionalRender -> FuntypeEndConditionalRender +glrefEndConditionalRender :: IORef FuntypeEndConditionalRender +glrefEndConditionalRender = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefEndConditionalRender #-} +glEndConditionalRender :: FuntypeEndConditionalRender +glEndConditionalRender = unsafePerformIO $ readIORef glrefEndConditionalRender +{-# INLINE glEndConditionalRender #-} +type FuntypeVertexAttribIPointer = + GLuint -> + GLint -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribIPointer :: FunPtr FuntypeVertexAttribIPointer -> FuntypeVertexAttribIPointer +glrefVertexAttribIPointer :: IORef FuntypeVertexAttribIPointer +glrefVertexAttribIPointer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribIPointer #-} +glVertexAttribIPointer :: FuntypeVertexAttribIPointer +glVertexAttribIPointer = unsafePerformIO $ readIORef glrefVertexAttribIPointer +{-# INLINE glVertexAttribIPointer #-} +type FuntypeGetVertexAttribIiv = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetVertexAttribIiv :: FunPtr FuntypeGetVertexAttribIiv -> FuntypeGetVertexAttribIiv +glrefGetVertexAttribIiv :: IORef FuntypeGetVertexAttribIiv +glrefGetVertexAttribIiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetVertexAttribIiv #-} +glGetVertexAttribIiv :: FuntypeGetVertexAttribIiv +glGetVertexAttribIiv = unsafePerformIO $ readIORef glrefGetVertexAttribIiv +{-# INLINE glGetVertexAttribIiv #-} +type FuntypeGetVertexAttribIuiv = + GLuint -> + GLenum -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetVertexAttribIuiv :: FunPtr FuntypeGetVertexAttribIuiv -> FuntypeGetVertexAttribIuiv +glrefGetVertexAttribIuiv :: IORef FuntypeGetVertexAttribIuiv +glrefGetVertexAttribIuiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetVertexAttribIuiv #-} +glGetVertexAttribIuiv :: FuntypeGetVertexAttribIuiv +glGetVertexAttribIuiv = unsafePerformIO $ readIORef glrefGetVertexAttribIuiv +{-# INLINE glGetVertexAttribIuiv #-} +type FuntypeVertexAttribI1i = + GLuint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI1i :: FunPtr FuntypeVertexAttribI1i -> FuntypeVertexAttribI1i +glrefVertexAttribI1i :: IORef FuntypeVertexAttribI1i +glrefVertexAttribI1i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI1i #-} +glVertexAttribI1i :: FuntypeVertexAttribI1i +glVertexAttribI1i = unsafePerformIO $ readIORef glrefVertexAttribI1i +{-# INLINE glVertexAttribI1i #-} +type FuntypeVertexAttribI2i = + GLuint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI2i :: FunPtr FuntypeVertexAttribI2i -> FuntypeVertexAttribI2i +glrefVertexAttribI2i :: IORef FuntypeVertexAttribI2i +glrefVertexAttribI2i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI2i #-} +glVertexAttribI2i :: FuntypeVertexAttribI2i +glVertexAttribI2i = unsafePerformIO $ readIORef glrefVertexAttribI2i +{-# INLINE glVertexAttribI2i #-} +type FuntypeVertexAttribI3i = + GLuint -> + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI3i :: FunPtr FuntypeVertexAttribI3i -> FuntypeVertexAttribI3i +glrefVertexAttribI3i :: IORef FuntypeVertexAttribI3i +glrefVertexAttribI3i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI3i #-} +glVertexAttribI3i :: FuntypeVertexAttribI3i +glVertexAttribI3i = unsafePerformIO $ readIORef glrefVertexAttribI3i +{-# INLINE glVertexAttribI3i #-} +type FuntypeVertexAttribI4i = + GLuint -> + GLint -> + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI4i :: FunPtr FuntypeVertexAttribI4i -> FuntypeVertexAttribI4i +glrefVertexAttribI4i :: IORef FuntypeVertexAttribI4i +glrefVertexAttribI4i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI4i #-} +glVertexAttribI4i :: FuntypeVertexAttribI4i +glVertexAttribI4i = unsafePerformIO $ readIORef glrefVertexAttribI4i +{-# INLINE glVertexAttribI4i #-} +type FuntypeVertexAttribI1ui = + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI1ui :: FunPtr FuntypeVertexAttribI1ui -> FuntypeVertexAttribI1ui +glrefVertexAttribI1ui :: IORef FuntypeVertexAttribI1ui +glrefVertexAttribI1ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI1ui #-} +glVertexAttribI1ui :: FuntypeVertexAttribI1ui +glVertexAttribI1ui = unsafePerformIO $ readIORef glrefVertexAttribI1ui +{-# INLINE glVertexAttribI1ui #-} +type FuntypeVertexAttribI2ui = + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI2ui :: FunPtr FuntypeVertexAttribI2ui -> FuntypeVertexAttribI2ui +glrefVertexAttribI2ui :: IORef FuntypeVertexAttribI2ui +glrefVertexAttribI2ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI2ui #-} +glVertexAttribI2ui :: FuntypeVertexAttribI2ui +glVertexAttribI2ui = unsafePerformIO $ readIORef glrefVertexAttribI2ui +{-# INLINE glVertexAttribI2ui #-} +type FuntypeVertexAttribI3ui = + GLuint -> + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI3ui :: FunPtr FuntypeVertexAttribI3ui -> FuntypeVertexAttribI3ui +glrefVertexAttribI3ui :: IORef FuntypeVertexAttribI3ui +glrefVertexAttribI3ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI3ui #-} +glVertexAttribI3ui :: FuntypeVertexAttribI3ui +glVertexAttribI3ui = unsafePerformIO $ readIORef glrefVertexAttribI3ui +{-# INLINE glVertexAttribI3ui #-} +type FuntypeVertexAttribI4ui = + GLuint -> + GLuint -> + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI4ui :: FunPtr FuntypeVertexAttribI4ui -> FuntypeVertexAttribI4ui +glrefVertexAttribI4ui :: IORef FuntypeVertexAttribI4ui +glrefVertexAttribI4ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI4ui #-} +glVertexAttribI4ui :: FuntypeVertexAttribI4ui +glVertexAttribI4ui = unsafePerformIO $ readIORef glrefVertexAttribI4ui +{-# INLINE glVertexAttribI4ui #-} +type FuntypeVertexAttribI1iv = + GLuint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI1iv :: FunPtr FuntypeVertexAttribI1iv -> FuntypeVertexAttribI1iv +glrefVertexAttribI1iv :: IORef FuntypeVertexAttribI1iv +glrefVertexAttribI1iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI1iv #-} +glVertexAttribI1iv :: FuntypeVertexAttribI1iv +glVertexAttribI1iv = unsafePerformIO $ readIORef glrefVertexAttribI1iv +{-# INLINE glVertexAttribI1iv #-} +type FuntypeVertexAttribI2iv = + GLuint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI2iv :: FunPtr FuntypeVertexAttribI2iv -> FuntypeVertexAttribI2iv +glrefVertexAttribI2iv :: IORef FuntypeVertexAttribI2iv +glrefVertexAttribI2iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI2iv #-} +glVertexAttribI2iv :: FuntypeVertexAttribI2iv +glVertexAttribI2iv = unsafePerformIO $ readIORef glrefVertexAttribI2iv +{-# INLINE glVertexAttribI2iv #-} +type FuntypeVertexAttribI3iv = + GLuint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI3iv :: FunPtr FuntypeVertexAttribI3iv -> FuntypeVertexAttribI3iv +glrefVertexAttribI3iv :: IORef FuntypeVertexAttribI3iv +glrefVertexAttribI3iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI3iv #-} +glVertexAttribI3iv :: FuntypeVertexAttribI3iv +glVertexAttribI3iv = unsafePerformIO $ readIORef glrefVertexAttribI3iv +{-# INLINE glVertexAttribI3iv #-} +type FuntypeVertexAttribI4iv = + GLuint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI4iv :: FunPtr FuntypeVertexAttribI4iv -> FuntypeVertexAttribI4iv +glrefVertexAttribI4iv :: IORef FuntypeVertexAttribI4iv +glrefVertexAttribI4iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI4iv #-} +glVertexAttribI4iv :: FuntypeVertexAttribI4iv +glVertexAttribI4iv = unsafePerformIO $ readIORef glrefVertexAttribI4iv +{-# INLINE glVertexAttribI4iv #-} +type FuntypeVertexAttribI1uiv = + GLuint -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI1uiv :: FunPtr FuntypeVertexAttribI1uiv -> FuntypeVertexAttribI1uiv +glrefVertexAttribI1uiv :: IORef FuntypeVertexAttribI1uiv +glrefVertexAttribI1uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI1uiv #-} +glVertexAttribI1uiv :: FuntypeVertexAttribI1uiv +glVertexAttribI1uiv = unsafePerformIO $ readIORef glrefVertexAttribI1uiv +{-# INLINE glVertexAttribI1uiv #-} +type FuntypeVertexAttribI2uiv = + GLuint -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI2uiv :: FunPtr FuntypeVertexAttribI2uiv -> FuntypeVertexAttribI2uiv +glrefVertexAttribI2uiv :: IORef FuntypeVertexAttribI2uiv +glrefVertexAttribI2uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI2uiv #-} +glVertexAttribI2uiv :: FuntypeVertexAttribI2uiv +glVertexAttribI2uiv = unsafePerformIO $ readIORef glrefVertexAttribI2uiv +{-# INLINE glVertexAttribI2uiv #-} +type FuntypeVertexAttribI3uiv = + GLuint -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI3uiv :: FunPtr FuntypeVertexAttribI3uiv -> FuntypeVertexAttribI3uiv +glrefVertexAttribI3uiv :: IORef FuntypeVertexAttribI3uiv +glrefVertexAttribI3uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI3uiv #-} +glVertexAttribI3uiv :: FuntypeVertexAttribI3uiv +glVertexAttribI3uiv = unsafePerformIO $ readIORef glrefVertexAttribI3uiv +{-# INLINE glVertexAttribI3uiv #-} +type FuntypeVertexAttribI4uiv = + GLuint -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI4uiv :: FunPtr FuntypeVertexAttribI4uiv -> FuntypeVertexAttribI4uiv +glrefVertexAttribI4uiv :: IORef FuntypeVertexAttribI4uiv +glrefVertexAttribI4uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI4uiv #-} +glVertexAttribI4uiv :: FuntypeVertexAttribI4uiv +glVertexAttribI4uiv = unsafePerformIO $ readIORef glrefVertexAttribI4uiv +{-# INLINE glVertexAttribI4uiv #-} +type FuntypeVertexAttribI4bv = + GLuint -> + Ptr (GLbyte) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI4bv :: FunPtr FuntypeVertexAttribI4bv -> FuntypeVertexAttribI4bv +glrefVertexAttribI4bv :: IORef FuntypeVertexAttribI4bv +glrefVertexAttribI4bv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI4bv #-} +glVertexAttribI4bv :: FuntypeVertexAttribI4bv +glVertexAttribI4bv = unsafePerformIO $ readIORef glrefVertexAttribI4bv +{-# INLINE glVertexAttribI4bv #-} +type FuntypeVertexAttribI4sv = + GLuint -> + Ptr (GLshort) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI4sv :: FunPtr FuntypeVertexAttribI4sv -> FuntypeVertexAttribI4sv +glrefVertexAttribI4sv :: IORef FuntypeVertexAttribI4sv +glrefVertexAttribI4sv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI4sv #-} +glVertexAttribI4sv :: FuntypeVertexAttribI4sv +glVertexAttribI4sv = unsafePerformIO $ readIORef glrefVertexAttribI4sv +{-# INLINE glVertexAttribI4sv #-} +type FuntypeVertexAttribI4ubv = + GLuint -> + Ptr (GLubyte) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI4ubv :: FunPtr FuntypeVertexAttribI4ubv -> FuntypeVertexAttribI4ubv +glrefVertexAttribI4ubv :: IORef FuntypeVertexAttribI4ubv +glrefVertexAttribI4ubv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI4ubv #-} +glVertexAttribI4ubv :: FuntypeVertexAttribI4ubv +glVertexAttribI4ubv = unsafePerformIO $ readIORef glrefVertexAttribI4ubv +{-# INLINE glVertexAttribI4ubv #-} +type FuntypeVertexAttribI4usv = + GLuint -> + Ptr (GLushort) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribI4usv :: FunPtr FuntypeVertexAttribI4usv -> FuntypeVertexAttribI4usv +glrefVertexAttribI4usv :: IORef FuntypeVertexAttribI4usv +glrefVertexAttribI4usv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribI4usv #-} +glVertexAttribI4usv :: FuntypeVertexAttribI4usv +glVertexAttribI4usv = unsafePerformIO $ readIORef glrefVertexAttribI4usv +{-# INLINE glVertexAttribI4usv #-} +type FuntypeGetUniformuiv = + GLuint -> + GLint -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetUniformuiv :: FunPtr FuntypeGetUniformuiv -> FuntypeGetUniformuiv +glrefGetUniformuiv :: IORef FuntypeGetUniformuiv +glrefGetUniformuiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetUniformuiv #-} +glGetUniformuiv :: FuntypeGetUniformuiv +glGetUniformuiv = unsafePerformIO $ readIORef glrefGetUniformuiv +{-# INLINE glGetUniformuiv #-} +type FuntypeBindFragDataLocation = + GLuint -> + GLuint -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindFragDataLocation :: FunPtr FuntypeBindFragDataLocation -> FuntypeBindFragDataLocation +glrefBindFragDataLocation :: IORef FuntypeBindFragDataLocation +glrefBindFragDataLocation = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindFragDataLocation #-} +glBindFragDataLocation :: FuntypeBindFragDataLocation +glBindFragDataLocation = unsafePerformIO $ readIORef glrefBindFragDataLocation +{-# INLINE glBindFragDataLocation #-} +type FuntypeGetFragDataLocation = + GLuint -> + Ptr (GLchar) -> + IO ( GLint ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetFragDataLocation :: FunPtr FuntypeGetFragDataLocation -> FuntypeGetFragDataLocation +glrefGetFragDataLocation :: IORef FuntypeGetFragDataLocation +glrefGetFragDataLocation = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetFragDataLocation #-} +glGetFragDataLocation :: FuntypeGetFragDataLocation +glGetFragDataLocation = unsafePerformIO $ readIORef glrefGetFragDataLocation +{-# INLINE glGetFragDataLocation #-} +type FuntypeUniform1ui = + GLint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform1ui :: FunPtr FuntypeUniform1ui -> FuntypeUniform1ui +glrefUniform1ui :: IORef FuntypeUniform1ui +glrefUniform1ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform1ui #-} +glUniform1ui :: FuntypeUniform1ui +glUniform1ui = unsafePerformIO $ readIORef glrefUniform1ui +{-# INLINE glUniform1ui #-} +type FuntypeUniform2ui = + GLint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform2ui :: FunPtr FuntypeUniform2ui -> FuntypeUniform2ui +glrefUniform2ui :: IORef FuntypeUniform2ui +glrefUniform2ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform2ui #-} +glUniform2ui :: FuntypeUniform2ui +glUniform2ui = unsafePerformIO $ readIORef glrefUniform2ui +{-# INLINE glUniform2ui #-} +type FuntypeUniform3ui = + GLint -> + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform3ui :: FunPtr FuntypeUniform3ui -> FuntypeUniform3ui +glrefUniform3ui :: IORef FuntypeUniform3ui +glrefUniform3ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform3ui #-} +glUniform3ui :: FuntypeUniform3ui +glUniform3ui = unsafePerformIO $ readIORef glrefUniform3ui +{-# INLINE glUniform3ui #-} +type FuntypeUniform4ui = + GLint -> + GLuint -> + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform4ui :: FunPtr FuntypeUniform4ui -> FuntypeUniform4ui +glrefUniform4ui :: IORef FuntypeUniform4ui +glrefUniform4ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform4ui #-} +glUniform4ui :: FuntypeUniform4ui +glUniform4ui = unsafePerformIO $ readIORef glrefUniform4ui +{-# INLINE glUniform4ui #-} +type FuntypeUniform1uiv = + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform1uiv :: FunPtr FuntypeUniform1uiv -> FuntypeUniform1uiv +glrefUniform1uiv :: IORef FuntypeUniform1uiv +glrefUniform1uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform1uiv #-} +glUniform1uiv :: FuntypeUniform1uiv +glUniform1uiv = unsafePerformIO $ readIORef glrefUniform1uiv +{-# INLINE glUniform1uiv #-} +type FuntypeUniform2uiv = + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform2uiv :: FunPtr FuntypeUniform2uiv -> FuntypeUniform2uiv +glrefUniform2uiv :: IORef FuntypeUniform2uiv +glrefUniform2uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform2uiv #-} +glUniform2uiv :: FuntypeUniform2uiv +glUniform2uiv = unsafePerformIO $ readIORef glrefUniform2uiv +{-# INLINE glUniform2uiv #-} +type FuntypeUniform3uiv = + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform3uiv :: FunPtr FuntypeUniform3uiv -> FuntypeUniform3uiv +glrefUniform3uiv :: IORef FuntypeUniform3uiv +glrefUniform3uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform3uiv #-} +glUniform3uiv :: FuntypeUniform3uiv +glUniform3uiv = unsafePerformIO $ readIORef glrefUniform3uiv +{-# INLINE glUniform3uiv #-} +type FuntypeUniform4uiv = + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniform4uiv :: FunPtr FuntypeUniform4uiv -> FuntypeUniform4uiv +glrefUniform4uiv :: IORef FuntypeUniform4uiv +glrefUniform4uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniform4uiv #-} +glUniform4uiv :: FuntypeUniform4uiv +glUniform4uiv = unsafePerformIO $ readIORef glrefUniform4uiv +{-# INLINE glUniform4uiv #-} +type FuntypeTexParameterIiv = + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexParameterIiv :: FunPtr FuntypeTexParameterIiv -> FuntypeTexParameterIiv +glrefTexParameterIiv :: IORef FuntypeTexParameterIiv +glrefTexParameterIiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexParameterIiv #-} +glTexParameterIiv :: FuntypeTexParameterIiv +glTexParameterIiv = unsafePerformIO $ readIORef glrefTexParameterIiv +{-# INLINE glTexParameterIiv #-} +type FuntypeTexParameterIuiv = + GLenum -> + GLenum -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexParameterIuiv :: FunPtr FuntypeTexParameterIuiv -> FuntypeTexParameterIuiv +glrefTexParameterIuiv :: IORef FuntypeTexParameterIuiv +glrefTexParameterIuiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexParameterIuiv #-} +glTexParameterIuiv :: FuntypeTexParameterIuiv +glTexParameterIuiv = unsafePerformIO $ readIORef glrefTexParameterIuiv +{-# INLINE glTexParameterIuiv #-} +type FuntypeGetTexParameterIiv = + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTexParameterIiv :: FunPtr FuntypeGetTexParameterIiv -> FuntypeGetTexParameterIiv +glrefGetTexParameterIiv :: IORef FuntypeGetTexParameterIiv +glrefGetTexParameterIiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTexParameterIiv #-} +glGetTexParameterIiv :: FuntypeGetTexParameterIiv +glGetTexParameterIiv = unsafePerformIO $ readIORef glrefGetTexParameterIiv +{-# INLINE glGetTexParameterIiv #-} +type FuntypeGetTexParameterIuiv = + GLenum -> + GLenum -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTexParameterIuiv :: FunPtr FuntypeGetTexParameterIuiv -> FuntypeGetTexParameterIuiv +glrefGetTexParameterIuiv :: IORef FuntypeGetTexParameterIuiv +glrefGetTexParameterIuiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTexParameterIuiv #-} +glGetTexParameterIuiv :: FuntypeGetTexParameterIuiv +glGetTexParameterIuiv = unsafePerformIO $ readIORef glrefGetTexParameterIuiv +{-# INLINE glGetTexParameterIuiv #-} +type FuntypeClearBufferiv = + GLenum -> + GLint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClearBufferiv :: FunPtr FuntypeClearBufferiv -> FuntypeClearBufferiv +glrefClearBufferiv :: IORef FuntypeClearBufferiv +glrefClearBufferiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClearBufferiv #-} +glClearBufferiv :: FuntypeClearBufferiv +glClearBufferiv = unsafePerformIO $ readIORef glrefClearBufferiv +{-# INLINE glClearBufferiv #-} +type FuntypeClearBufferuiv = + GLenum -> + GLint -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClearBufferuiv :: FunPtr FuntypeClearBufferuiv -> FuntypeClearBufferuiv +glrefClearBufferuiv :: IORef FuntypeClearBufferuiv +glrefClearBufferuiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClearBufferuiv #-} +glClearBufferuiv :: FuntypeClearBufferuiv +glClearBufferuiv = unsafePerformIO $ readIORef glrefClearBufferuiv +{-# INLINE glClearBufferuiv #-} +type FuntypeClearBufferfv = + GLenum -> + GLint -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClearBufferfv :: FunPtr FuntypeClearBufferfv -> FuntypeClearBufferfv +glrefClearBufferfv :: IORef FuntypeClearBufferfv +glrefClearBufferfv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClearBufferfv #-} +glClearBufferfv :: FuntypeClearBufferfv +glClearBufferfv = unsafePerformIO $ readIORef glrefClearBufferfv +{-# INLINE glClearBufferfv #-} +type FuntypeClearBufferfi = + GLenum -> + GLint -> + GLfloat -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClearBufferfi :: FunPtr FuntypeClearBufferfi -> FuntypeClearBufferfi +glrefClearBufferfi :: IORef FuntypeClearBufferfi +glrefClearBufferfi = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClearBufferfi #-} +glClearBufferfi :: FuntypeClearBufferfi +glClearBufferfi = unsafePerformIO $ readIORef glrefClearBufferfi +{-# INLINE glClearBufferfi #-} +type FuntypeGetStringi = + GLenum -> + GLuint -> + IO ( Ptr (GLubyte) ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetStringi :: FunPtr FuntypeGetStringi -> FuntypeGetStringi +glrefGetStringi :: IORef FuntypeGetStringi +glrefGetStringi = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetStringi #-} +glGetStringi :: FuntypeGetStringi +glGetStringi = unsafePerformIO $ readIORef glrefGetStringi +{-# INLINE glGetStringi #-} +type FuntypeIsRenderbuffer = + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsRenderbuffer :: FunPtr FuntypeIsRenderbuffer -> FuntypeIsRenderbuffer +glrefIsRenderbuffer :: IORef FuntypeIsRenderbuffer +glrefIsRenderbuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsRenderbuffer #-} +glIsRenderbuffer :: FuntypeIsRenderbuffer +glIsRenderbuffer = unsafePerformIO $ readIORef glrefIsRenderbuffer +{-# INLINE glIsRenderbuffer #-} +type FuntypeBindRenderbuffer = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindRenderbuffer :: FunPtr FuntypeBindRenderbuffer -> FuntypeBindRenderbuffer +glrefBindRenderbuffer :: IORef FuntypeBindRenderbuffer +glrefBindRenderbuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindRenderbuffer #-} +glBindRenderbuffer :: FuntypeBindRenderbuffer +glBindRenderbuffer = unsafePerformIO $ readIORef glrefBindRenderbuffer +{-# INLINE glBindRenderbuffer #-} +type FuntypeDeleteRenderbuffers = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDeleteRenderbuffers :: FunPtr FuntypeDeleteRenderbuffers -> FuntypeDeleteRenderbuffers +glrefDeleteRenderbuffers :: IORef FuntypeDeleteRenderbuffers +glrefDeleteRenderbuffers = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDeleteRenderbuffers #-} +glDeleteRenderbuffers :: FuntypeDeleteRenderbuffers +glDeleteRenderbuffers = unsafePerformIO $ readIORef glrefDeleteRenderbuffers +{-# INLINE glDeleteRenderbuffers #-} +type FuntypeGenRenderbuffers = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGenRenderbuffers :: FunPtr FuntypeGenRenderbuffers -> FuntypeGenRenderbuffers +glrefGenRenderbuffers :: IORef FuntypeGenRenderbuffers +glrefGenRenderbuffers = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGenRenderbuffers #-} +glGenRenderbuffers :: FuntypeGenRenderbuffers +glGenRenderbuffers = unsafePerformIO $ readIORef glrefGenRenderbuffers +{-# INLINE glGenRenderbuffers #-} +type FuntypeRenderbufferStorage = + GLenum -> + GLenum -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynRenderbufferStorage :: FunPtr FuntypeRenderbufferStorage -> FuntypeRenderbufferStorage +glrefRenderbufferStorage :: IORef FuntypeRenderbufferStorage +glrefRenderbufferStorage = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefRenderbufferStorage #-} +glRenderbufferStorage :: FuntypeRenderbufferStorage +glRenderbufferStorage = unsafePerformIO $ readIORef glrefRenderbufferStorage +{-# INLINE glRenderbufferStorage #-} +type FuntypeGetRenderbufferParameteriv = + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetRenderbufferParameteriv :: FunPtr FuntypeGetRenderbufferParameteriv -> FuntypeGetRenderbufferParameteriv +glrefGetRenderbufferParameteriv :: IORef FuntypeGetRenderbufferParameteriv +glrefGetRenderbufferParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetRenderbufferParameteriv #-} +glGetRenderbufferParameteriv :: FuntypeGetRenderbufferParameteriv +glGetRenderbufferParameteriv = unsafePerformIO $ readIORef glrefGetRenderbufferParameteriv +{-# INLINE glGetRenderbufferParameteriv #-} +type FuntypeIsFramebuffer = + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsFramebuffer :: FunPtr FuntypeIsFramebuffer -> FuntypeIsFramebuffer +glrefIsFramebuffer :: IORef FuntypeIsFramebuffer +glrefIsFramebuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsFramebuffer #-} +glIsFramebuffer :: FuntypeIsFramebuffer +glIsFramebuffer = unsafePerformIO $ readIORef glrefIsFramebuffer +{-# INLINE glIsFramebuffer #-} +type FuntypeBindFramebuffer = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindFramebuffer :: FunPtr FuntypeBindFramebuffer -> FuntypeBindFramebuffer +glrefBindFramebuffer :: IORef FuntypeBindFramebuffer +glrefBindFramebuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindFramebuffer #-} +glBindFramebuffer :: FuntypeBindFramebuffer +glBindFramebuffer = unsafePerformIO $ readIORef glrefBindFramebuffer +{-# INLINE glBindFramebuffer #-} +type FuntypeDeleteFramebuffers = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDeleteFramebuffers :: FunPtr FuntypeDeleteFramebuffers -> FuntypeDeleteFramebuffers +glrefDeleteFramebuffers :: IORef FuntypeDeleteFramebuffers +glrefDeleteFramebuffers = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDeleteFramebuffers #-} +glDeleteFramebuffers :: FuntypeDeleteFramebuffers +glDeleteFramebuffers = unsafePerformIO $ readIORef glrefDeleteFramebuffers +{-# INLINE glDeleteFramebuffers #-} +type FuntypeGenFramebuffers = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGenFramebuffers :: FunPtr FuntypeGenFramebuffers -> FuntypeGenFramebuffers +glrefGenFramebuffers :: IORef FuntypeGenFramebuffers +glrefGenFramebuffers = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGenFramebuffers #-} +glGenFramebuffers :: FuntypeGenFramebuffers +glGenFramebuffers = unsafePerformIO $ readIORef glrefGenFramebuffers +{-# INLINE glGenFramebuffers #-} +type FuntypeCheckFramebufferStatus = + GLenum -> + IO ( GLenum ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCheckFramebufferStatus :: FunPtr FuntypeCheckFramebufferStatus -> FuntypeCheckFramebufferStatus +glrefCheckFramebufferStatus :: IORef FuntypeCheckFramebufferStatus +glrefCheckFramebufferStatus = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCheckFramebufferStatus #-} +glCheckFramebufferStatus :: FuntypeCheckFramebufferStatus +glCheckFramebufferStatus = unsafePerformIO $ readIORef glrefCheckFramebufferStatus +{-# INLINE glCheckFramebufferStatus #-} +type FuntypeFramebufferTexture1D = + GLenum -> + GLenum -> + GLenum -> + GLuint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFramebufferTexture1D :: FunPtr FuntypeFramebufferTexture1D -> FuntypeFramebufferTexture1D +glrefFramebufferTexture1D :: IORef FuntypeFramebufferTexture1D +glrefFramebufferTexture1D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFramebufferTexture1D #-} +glFramebufferTexture1D :: FuntypeFramebufferTexture1D +glFramebufferTexture1D = unsafePerformIO $ readIORef glrefFramebufferTexture1D +{-# INLINE glFramebufferTexture1D #-} +type FuntypeFramebufferTexture2D = + GLenum -> + GLenum -> + GLenum -> + GLuint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFramebufferTexture2D :: FunPtr FuntypeFramebufferTexture2D -> FuntypeFramebufferTexture2D +glrefFramebufferTexture2D :: IORef FuntypeFramebufferTexture2D +glrefFramebufferTexture2D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFramebufferTexture2D #-} +glFramebufferTexture2D :: FuntypeFramebufferTexture2D +glFramebufferTexture2D = unsafePerformIO $ readIORef glrefFramebufferTexture2D +{-# INLINE glFramebufferTexture2D #-} +type FuntypeFramebufferTexture3D = + GLenum -> + GLenum -> + GLenum -> + GLuint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFramebufferTexture3D :: FunPtr FuntypeFramebufferTexture3D -> FuntypeFramebufferTexture3D +glrefFramebufferTexture3D :: IORef FuntypeFramebufferTexture3D +glrefFramebufferTexture3D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFramebufferTexture3D #-} +glFramebufferTexture3D :: FuntypeFramebufferTexture3D +glFramebufferTexture3D = unsafePerformIO $ readIORef glrefFramebufferTexture3D +{-# INLINE glFramebufferTexture3D #-} +type FuntypeFramebufferRenderbuffer = + GLenum -> + GLenum -> + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFramebufferRenderbuffer :: FunPtr FuntypeFramebufferRenderbuffer -> FuntypeFramebufferRenderbuffer +glrefFramebufferRenderbuffer :: IORef FuntypeFramebufferRenderbuffer +glrefFramebufferRenderbuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFramebufferRenderbuffer #-} +glFramebufferRenderbuffer :: FuntypeFramebufferRenderbuffer +glFramebufferRenderbuffer = unsafePerformIO $ readIORef glrefFramebufferRenderbuffer +{-# INLINE glFramebufferRenderbuffer #-} +type FuntypeGetFramebufferAttachmentParameteriv = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetFramebufferAttachmentParameteriv :: FunPtr FuntypeGetFramebufferAttachmentParameteriv -> FuntypeGetFramebufferAttachmentParameteriv +glrefGetFramebufferAttachmentParameteriv :: IORef FuntypeGetFramebufferAttachmentParameteriv +glrefGetFramebufferAttachmentParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetFramebufferAttachmentParameteriv #-} +glGetFramebufferAttachmentParameteriv :: FuntypeGetFramebufferAttachmentParameteriv +glGetFramebufferAttachmentParameteriv = unsafePerformIO $ readIORef glrefGetFramebufferAttachmentParameteriv +{-# INLINE glGetFramebufferAttachmentParameteriv #-} +type FuntypeGenerateMipmap = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGenerateMipmap :: FunPtr FuntypeGenerateMipmap -> FuntypeGenerateMipmap +glrefGenerateMipmap :: IORef FuntypeGenerateMipmap +glrefGenerateMipmap = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGenerateMipmap #-} +glGenerateMipmap :: FuntypeGenerateMipmap +glGenerateMipmap = unsafePerformIO $ readIORef glrefGenerateMipmap +{-# INLINE glGenerateMipmap #-} +type FuntypeBlitFramebuffer = + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLbitfield -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBlitFramebuffer :: FunPtr FuntypeBlitFramebuffer -> FuntypeBlitFramebuffer +glrefBlitFramebuffer :: IORef FuntypeBlitFramebuffer +glrefBlitFramebuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBlitFramebuffer #-} +glBlitFramebuffer :: FuntypeBlitFramebuffer +glBlitFramebuffer = unsafePerformIO $ readIORef glrefBlitFramebuffer +{-# INLINE glBlitFramebuffer #-} +type FuntypeRenderbufferStorageMultisample = + GLenum -> + GLsizei -> + GLenum -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynRenderbufferStorageMultisample :: FunPtr FuntypeRenderbufferStorageMultisample -> FuntypeRenderbufferStorageMultisample +glrefRenderbufferStorageMultisample :: IORef FuntypeRenderbufferStorageMultisample +glrefRenderbufferStorageMultisample = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefRenderbufferStorageMultisample #-} +glRenderbufferStorageMultisample :: FuntypeRenderbufferStorageMultisample +glRenderbufferStorageMultisample = unsafePerformIO $ readIORef glrefRenderbufferStorageMultisample +{-# INLINE glRenderbufferStorageMultisample #-} +type FuntypeFramebufferTextureLayer = + GLenum -> + GLenum -> + GLuint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFramebufferTextureLayer :: FunPtr FuntypeFramebufferTextureLayer -> FuntypeFramebufferTextureLayer +glrefFramebufferTextureLayer :: IORef FuntypeFramebufferTextureLayer +glrefFramebufferTextureLayer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFramebufferTextureLayer #-} +glFramebufferTextureLayer :: FuntypeFramebufferTextureLayer +glFramebufferTextureLayer = unsafePerformIO $ readIORef glrefFramebufferTextureLayer +{-# INLINE glFramebufferTextureLayer #-} +type FuntypeMapBufferRange = + GLenum -> + GLintptr -> + GLsizeiptr -> + GLbitfield -> + IO ( Ptr () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMapBufferRange :: FunPtr FuntypeMapBufferRange -> FuntypeMapBufferRange +glrefMapBufferRange :: IORef FuntypeMapBufferRange +glrefMapBufferRange = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMapBufferRange #-} +glMapBufferRange :: FuntypeMapBufferRange +glMapBufferRange = unsafePerformIO $ readIORef glrefMapBufferRange +{-# INLINE glMapBufferRange #-} +type FuntypeFlushMappedBufferRange = + GLenum -> + GLintptr -> + GLsizeiptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFlushMappedBufferRange :: FunPtr FuntypeFlushMappedBufferRange -> FuntypeFlushMappedBufferRange +glrefFlushMappedBufferRange :: IORef FuntypeFlushMappedBufferRange +glrefFlushMappedBufferRange = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFlushMappedBufferRange #-} +glFlushMappedBufferRange :: FuntypeFlushMappedBufferRange +glFlushMappedBufferRange = unsafePerformIO $ readIORef glrefFlushMappedBufferRange +{-# INLINE glFlushMappedBufferRange #-} +type FuntypeBindVertexArray = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindVertexArray :: FunPtr FuntypeBindVertexArray -> FuntypeBindVertexArray +glrefBindVertexArray :: IORef FuntypeBindVertexArray +glrefBindVertexArray = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindVertexArray #-} +glBindVertexArray :: FuntypeBindVertexArray +glBindVertexArray = unsafePerformIO $ readIORef glrefBindVertexArray +{-# INLINE glBindVertexArray #-} +type FuntypeDeleteVertexArrays = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDeleteVertexArrays :: FunPtr FuntypeDeleteVertexArrays -> FuntypeDeleteVertexArrays +glrefDeleteVertexArrays :: IORef FuntypeDeleteVertexArrays +glrefDeleteVertexArrays = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDeleteVertexArrays #-} +glDeleteVertexArrays :: FuntypeDeleteVertexArrays +glDeleteVertexArrays = unsafePerformIO $ readIORef glrefDeleteVertexArrays +{-# INLINE glDeleteVertexArrays #-} +type FuntypeGenVertexArrays = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGenVertexArrays :: FunPtr FuntypeGenVertexArrays -> FuntypeGenVertexArrays +glrefGenVertexArrays :: IORef FuntypeGenVertexArrays +glrefGenVertexArrays = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGenVertexArrays #-} +glGenVertexArrays :: FuntypeGenVertexArrays +glGenVertexArrays = unsafePerformIO $ readIORef glrefGenVertexArrays +{-# INLINE glGenVertexArrays #-} +type FuntypeIsVertexArray = + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsVertexArray :: FunPtr FuntypeIsVertexArray -> FuntypeIsVertexArray +glrefIsVertexArray :: IORef FuntypeIsVertexArray +glrefIsVertexArray = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsVertexArray #-} +glIsVertexArray :: FuntypeIsVertexArray +glIsVertexArray = unsafePerformIO $ readIORef glrefIsVertexArray +{-# INLINE glIsVertexArray #-} + +-- GL_VERSION_3_1 + +type FuntypeDrawArraysInstanced = + GLenum -> + GLint -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDrawArraysInstanced :: FunPtr FuntypeDrawArraysInstanced -> FuntypeDrawArraysInstanced +glrefDrawArraysInstanced :: IORef FuntypeDrawArraysInstanced +glrefDrawArraysInstanced = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDrawArraysInstanced #-} +glDrawArraysInstanced :: FuntypeDrawArraysInstanced +glDrawArraysInstanced = unsafePerformIO $ readIORef glrefDrawArraysInstanced +{-# INLINE glDrawArraysInstanced #-} +type FuntypeDrawElementsInstanced = + GLenum -> + GLsizei -> + GLenum -> + Ptr () -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDrawElementsInstanced :: FunPtr FuntypeDrawElementsInstanced -> FuntypeDrawElementsInstanced +glrefDrawElementsInstanced :: IORef FuntypeDrawElementsInstanced +glrefDrawElementsInstanced = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDrawElementsInstanced #-} +glDrawElementsInstanced :: FuntypeDrawElementsInstanced +glDrawElementsInstanced = unsafePerformIO $ readIORef glrefDrawElementsInstanced +{-# INLINE glDrawElementsInstanced #-} +type FuntypeTexBuffer = + GLenum -> + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexBuffer :: FunPtr FuntypeTexBuffer -> FuntypeTexBuffer +glrefTexBuffer :: IORef FuntypeTexBuffer +glrefTexBuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexBuffer #-} +glTexBuffer :: FuntypeTexBuffer +glTexBuffer = unsafePerformIO $ readIORef glrefTexBuffer +{-# INLINE glTexBuffer #-} +type FuntypePrimitiveRestartIndex = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPrimitiveRestartIndex :: FunPtr FuntypePrimitiveRestartIndex -> FuntypePrimitiveRestartIndex +glrefPrimitiveRestartIndex :: IORef FuntypePrimitiveRestartIndex +glrefPrimitiveRestartIndex = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPrimitiveRestartIndex #-} +glPrimitiveRestartIndex :: FuntypePrimitiveRestartIndex +glPrimitiveRestartIndex = unsafePerformIO $ readIORef glrefPrimitiveRestartIndex +{-# INLINE glPrimitiveRestartIndex #-} +type FuntypeCopyBufferSubData = + GLenum -> + GLenum -> + GLintptr -> + GLintptr -> + GLsizeiptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyBufferSubData :: FunPtr FuntypeCopyBufferSubData -> FuntypeCopyBufferSubData +glrefCopyBufferSubData :: IORef FuntypeCopyBufferSubData +glrefCopyBufferSubData = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyBufferSubData #-} +glCopyBufferSubData :: FuntypeCopyBufferSubData +glCopyBufferSubData = unsafePerformIO $ readIORef glrefCopyBufferSubData +{-# INLINE glCopyBufferSubData #-} +type FuntypeGetUniformIndices = + GLuint -> + GLsizei -> + Ptr (Ptr (GLchar)) -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetUniformIndices :: FunPtr FuntypeGetUniformIndices -> FuntypeGetUniformIndices +glrefGetUniformIndices :: IORef FuntypeGetUniformIndices +glrefGetUniformIndices = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetUniformIndices #-} +glGetUniformIndices :: FuntypeGetUniformIndices +glGetUniformIndices = unsafePerformIO $ readIORef glrefGetUniformIndices +{-# INLINE glGetUniformIndices #-} +type FuntypeGetActiveUniformsiv = + GLuint -> + GLsizei -> + Ptr (GLuint) -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetActiveUniformsiv :: FunPtr FuntypeGetActiveUniformsiv -> FuntypeGetActiveUniformsiv +glrefGetActiveUniformsiv :: IORef FuntypeGetActiveUniformsiv +glrefGetActiveUniformsiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetActiveUniformsiv #-} +glGetActiveUniformsiv :: FuntypeGetActiveUniformsiv +glGetActiveUniformsiv = unsafePerformIO $ readIORef glrefGetActiveUniformsiv +{-# INLINE glGetActiveUniformsiv #-} +type FuntypeGetActiveUniformName = + GLuint -> + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetActiveUniformName :: FunPtr FuntypeGetActiveUniformName -> FuntypeGetActiveUniformName +glrefGetActiveUniformName :: IORef FuntypeGetActiveUniformName +glrefGetActiveUniformName = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetActiveUniformName #-} +glGetActiveUniformName :: FuntypeGetActiveUniformName +glGetActiveUniformName = unsafePerformIO $ readIORef glrefGetActiveUniformName +{-# INLINE glGetActiveUniformName #-} +type FuntypeGetUniformBlockIndex = + GLuint -> + Ptr (GLchar) -> + IO ( GLuint ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetUniformBlockIndex :: FunPtr FuntypeGetUniformBlockIndex -> FuntypeGetUniformBlockIndex +glrefGetUniformBlockIndex :: IORef FuntypeGetUniformBlockIndex +glrefGetUniformBlockIndex = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetUniformBlockIndex #-} +glGetUniformBlockIndex :: FuntypeGetUniformBlockIndex +glGetUniformBlockIndex = unsafePerformIO $ readIORef glrefGetUniformBlockIndex +{-# INLINE glGetUniformBlockIndex #-} +type FuntypeGetActiveUniformBlockiv = + GLuint -> + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetActiveUniformBlockiv :: FunPtr FuntypeGetActiveUniformBlockiv -> FuntypeGetActiveUniformBlockiv +glrefGetActiveUniformBlockiv :: IORef FuntypeGetActiveUniformBlockiv +glrefGetActiveUniformBlockiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetActiveUniformBlockiv #-} +glGetActiveUniformBlockiv :: FuntypeGetActiveUniformBlockiv +glGetActiveUniformBlockiv = unsafePerformIO $ readIORef glrefGetActiveUniformBlockiv +{-# INLINE glGetActiveUniformBlockiv #-} +type FuntypeGetActiveUniformBlockName = + GLuint -> + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetActiveUniformBlockName :: FunPtr FuntypeGetActiveUniformBlockName -> FuntypeGetActiveUniformBlockName +glrefGetActiveUniformBlockName :: IORef FuntypeGetActiveUniformBlockName +glrefGetActiveUniformBlockName = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetActiveUniformBlockName #-} +glGetActiveUniformBlockName :: FuntypeGetActiveUniformBlockName +glGetActiveUniformBlockName = unsafePerformIO $ readIORef glrefGetActiveUniformBlockName +{-# INLINE glGetActiveUniformBlockName #-} +type FuntypeUniformBlockBinding = + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUniformBlockBinding :: FunPtr FuntypeUniformBlockBinding -> FuntypeUniformBlockBinding +glrefUniformBlockBinding :: IORef FuntypeUniformBlockBinding +glrefUniformBlockBinding = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUniformBlockBinding #-} +glUniformBlockBinding :: FuntypeUniformBlockBinding +glUniformBlockBinding = unsafePerformIO $ readIORef glrefUniformBlockBinding +{-# INLINE glUniformBlockBinding #-} + +-- GL_VERSION_3_2 + +type FuntypeDrawElementsBaseVertex = + GLenum -> + GLsizei -> + GLenum -> + Ptr () -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDrawElementsBaseVertex :: FunPtr FuntypeDrawElementsBaseVertex -> FuntypeDrawElementsBaseVertex +glrefDrawElementsBaseVertex :: IORef FuntypeDrawElementsBaseVertex +glrefDrawElementsBaseVertex = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDrawElementsBaseVertex #-} +glDrawElementsBaseVertex :: FuntypeDrawElementsBaseVertex +glDrawElementsBaseVertex = unsafePerformIO $ readIORef glrefDrawElementsBaseVertex +{-# INLINE glDrawElementsBaseVertex #-} +type FuntypeDrawRangeElementsBaseVertex = + GLenum -> + GLuint -> + GLuint -> + GLsizei -> + GLenum -> + Ptr () -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDrawRangeElementsBaseVertex :: FunPtr FuntypeDrawRangeElementsBaseVertex -> FuntypeDrawRangeElementsBaseVertex +glrefDrawRangeElementsBaseVertex :: IORef FuntypeDrawRangeElementsBaseVertex +glrefDrawRangeElementsBaseVertex = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDrawRangeElementsBaseVertex #-} +glDrawRangeElementsBaseVertex :: FuntypeDrawRangeElementsBaseVertex +glDrawRangeElementsBaseVertex = unsafePerformIO $ readIORef glrefDrawRangeElementsBaseVertex +{-# INLINE glDrawRangeElementsBaseVertex #-} +type FuntypeDrawElementsInstancedBaseVertex = + GLenum -> + GLsizei -> + GLenum -> + Ptr () -> + GLsizei -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDrawElementsInstancedBaseVertex :: FunPtr FuntypeDrawElementsInstancedBaseVertex -> FuntypeDrawElementsInstancedBaseVertex +glrefDrawElementsInstancedBaseVertex :: IORef FuntypeDrawElementsInstancedBaseVertex +glrefDrawElementsInstancedBaseVertex = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDrawElementsInstancedBaseVertex #-} +glDrawElementsInstancedBaseVertex :: FuntypeDrawElementsInstancedBaseVertex +glDrawElementsInstancedBaseVertex = unsafePerformIO $ readIORef glrefDrawElementsInstancedBaseVertex +{-# INLINE glDrawElementsInstancedBaseVertex #-} +type FuntypeMultiDrawElementsBaseVertex = + GLenum -> + Ptr (GLsizei) -> + GLenum -> + Ptr (Ptr ()) -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiDrawElementsBaseVertex :: FunPtr FuntypeMultiDrawElementsBaseVertex -> FuntypeMultiDrawElementsBaseVertex +glrefMultiDrawElementsBaseVertex :: IORef FuntypeMultiDrawElementsBaseVertex +glrefMultiDrawElementsBaseVertex = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiDrawElementsBaseVertex #-} +glMultiDrawElementsBaseVertex :: FuntypeMultiDrawElementsBaseVertex +glMultiDrawElementsBaseVertex = unsafePerformIO $ readIORef glrefMultiDrawElementsBaseVertex +{-# INLINE glMultiDrawElementsBaseVertex #-} +type FuntypeProvokingVertex = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProvokingVertex :: FunPtr FuntypeProvokingVertex -> FuntypeProvokingVertex +glrefProvokingVertex :: IORef FuntypeProvokingVertex +glrefProvokingVertex = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProvokingVertex #-} +glProvokingVertex :: FuntypeProvokingVertex +glProvokingVertex = unsafePerformIO $ readIORef glrefProvokingVertex +{-# INLINE glProvokingVertex #-} +type FuntypeFenceSync = + GLenum -> + GLbitfield -> + IO ( GLsync ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFenceSync :: FunPtr FuntypeFenceSync -> FuntypeFenceSync +glrefFenceSync :: IORef FuntypeFenceSync +glrefFenceSync = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFenceSync #-} +glFenceSync :: FuntypeFenceSync +glFenceSync = unsafePerformIO $ readIORef glrefFenceSync +{-# INLINE glFenceSync #-} +type FuntypeIsSync = + GLsync -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsSync :: FunPtr FuntypeIsSync -> FuntypeIsSync +glrefIsSync :: IORef FuntypeIsSync +glrefIsSync = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsSync #-} +glIsSync :: FuntypeIsSync +glIsSync = unsafePerformIO $ readIORef glrefIsSync +{-# INLINE glIsSync #-} +type FuntypeDeleteSync = + GLsync -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDeleteSync :: FunPtr FuntypeDeleteSync -> FuntypeDeleteSync +glrefDeleteSync :: IORef FuntypeDeleteSync +glrefDeleteSync = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDeleteSync #-} +glDeleteSync :: FuntypeDeleteSync +glDeleteSync = unsafePerformIO $ readIORef glrefDeleteSync +{-# INLINE glDeleteSync #-} +type FuntypeClientWaitSync = + GLsync -> + GLbitfield -> + GLuint64 -> + IO ( GLenum ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClientWaitSync :: FunPtr FuntypeClientWaitSync -> FuntypeClientWaitSync +glrefClientWaitSync :: IORef FuntypeClientWaitSync +glrefClientWaitSync = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClientWaitSync #-} +glClientWaitSync :: FuntypeClientWaitSync +glClientWaitSync = unsafePerformIO $ readIORef glrefClientWaitSync +{-# INLINE glClientWaitSync #-} +type FuntypeWaitSync = + GLsync -> + GLbitfield -> + GLuint64 -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynWaitSync :: FunPtr FuntypeWaitSync -> FuntypeWaitSync +glrefWaitSync :: IORef FuntypeWaitSync +glrefWaitSync = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefWaitSync #-} +glWaitSync :: FuntypeWaitSync +glWaitSync = unsafePerformIO $ readIORef glrefWaitSync +{-# INLINE glWaitSync #-} +type FuntypeGetInteger64v = + GLenum -> + Ptr (GLint64) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetInteger64v :: FunPtr FuntypeGetInteger64v -> FuntypeGetInteger64v +glrefGetInteger64v :: IORef FuntypeGetInteger64v +glrefGetInteger64v = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetInteger64v #-} +glGetInteger64v :: FuntypeGetInteger64v +glGetInteger64v = unsafePerformIO $ readIORef glrefGetInteger64v +{-# INLINE glGetInteger64v #-} +type FuntypeGetSynciv = + GLsync -> + GLenum -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetSynciv :: FunPtr FuntypeGetSynciv -> FuntypeGetSynciv +glrefGetSynciv :: IORef FuntypeGetSynciv +glrefGetSynciv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetSynciv #-} +glGetSynciv :: FuntypeGetSynciv +glGetSynciv = unsafePerformIO $ readIORef glrefGetSynciv +{-# INLINE glGetSynciv #-} +type FuntypeGetInteger64i_v = + GLenum -> + GLuint -> + Ptr (GLint64) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetInteger64i_v :: FunPtr FuntypeGetInteger64i_v -> FuntypeGetInteger64i_v +glrefGetInteger64i_v :: IORef FuntypeGetInteger64i_v +glrefGetInteger64i_v = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetInteger64i_v #-} +glGetInteger64i_v :: FuntypeGetInteger64i_v +glGetInteger64i_v = unsafePerformIO $ readIORef glrefGetInteger64i_v +{-# INLINE glGetInteger64i_v #-} +type FuntypeGetBufferParameteri64v = + GLenum -> + GLenum -> + Ptr (GLint64) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetBufferParameteri64v :: FunPtr FuntypeGetBufferParameteri64v -> FuntypeGetBufferParameteri64v +glrefGetBufferParameteri64v :: IORef FuntypeGetBufferParameteri64v +glrefGetBufferParameteri64v = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetBufferParameteri64v #-} +glGetBufferParameteri64v :: FuntypeGetBufferParameteri64v +glGetBufferParameteri64v = unsafePerformIO $ readIORef glrefGetBufferParameteri64v +{-# INLINE glGetBufferParameteri64v #-} +type FuntypeFramebufferTexture = + GLenum -> + GLenum -> + GLuint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFramebufferTexture :: FunPtr FuntypeFramebufferTexture -> FuntypeFramebufferTexture +glrefFramebufferTexture :: IORef FuntypeFramebufferTexture +glrefFramebufferTexture = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFramebufferTexture #-} +glFramebufferTexture :: FuntypeFramebufferTexture +glFramebufferTexture = unsafePerformIO $ readIORef glrefFramebufferTexture +{-# INLINE glFramebufferTexture #-} +type FuntypeTexImage2DMultisample = + GLenum -> + GLsizei -> + GLenum -> + GLsizei -> + GLsizei -> + GLboolean -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexImage2DMultisample :: FunPtr FuntypeTexImage2DMultisample -> FuntypeTexImage2DMultisample +glrefTexImage2DMultisample :: IORef FuntypeTexImage2DMultisample +glrefTexImage2DMultisample = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexImage2DMultisample #-} +glTexImage2DMultisample :: FuntypeTexImage2DMultisample +glTexImage2DMultisample = unsafePerformIO $ readIORef glrefTexImage2DMultisample +{-# INLINE glTexImage2DMultisample #-} +type FuntypeTexImage3DMultisample = + GLenum -> + GLsizei -> + GLenum -> + GLsizei -> + GLsizei -> + GLsizei -> + GLboolean -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexImage3DMultisample :: FunPtr FuntypeTexImage3DMultisample -> FuntypeTexImage3DMultisample +glrefTexImage3DMultisample :: IORef FuntypeTexImage3DMultisample +glrefTexImage3DMultisample = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexImage3DMultisample #-} +glTexImage3DMultisample :: FuntypeTexImage3DMultisample +glTexImage3DMultisample = unsafePerformIO $ readIORef glrefTexImage3DMultisample +{-# INLINE glTexImage3DMultisample #-} +type FuntypeGetMultisamplefv = + GLenum -> + GLuint -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultisamplefv :: FunPtr FuntypeGetMultisamplefv -> FuntypeGetMultisamplefv +glrefGetMultisamplefv :: IORef FuntypeGetMultisamplefv +glrefGetMultisamplefv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultisamplefv #-} +glGetMultisamplefv :: FuntypeGetMultisamplefv +glGetMultisamplefv = unsafePerformIO $ readIORef glrefGetMultisamplefv +{-# INLINE glGetMultisamplefv #-} +type FuntypeSampleMaski = + GLuint -> + GLbitfield -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynSampleMaski :: FunPtr FuntypeSampleMaski -> FuntypeSampleMaski +glrefSampleMaski :: IORef FuntypeSampleMaski +glrefSampleMaski = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefSampleMaski #-} +glSampleMaski :: FuntypeSampleMaski +glSampleMaski = unsafePerformIO $ readIORef glrefSampleMaski +{-# INLINE glSampleMaski #-} + +-- GL_VERSION_3_3 + +type FuntypeBindFragDataLocationIndexed = + GLuint -> + GLuint -> + GLuint -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindFragDataLocationIndexed :: FunPtr FuntypeBindFragDataLocationIndexed -> FuntypeBindFragDataLocationIndexed +glrefBindFragDataLocationIndexed :: IORef FuntypeBindFragDataLocationIndexed +glrefBindFragDataLocationIndexed = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindFragDataLocationIndexed #-} +glBindFragDataLocationIndexed :: FuntypeBindFragDataLocationIndexed +glBindFragDataLocationIndexed = unsafePerformIO $ readIORef glrefBindFragDataLocationIndexed +{-# INLINE glBindFragDataLocationIndexed #-} +type FuntypeGetFragDataIndex = + GLuint -> + Ptr (GLchar) -> + IO ( GLint ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetFragDataIndex :: FunPtr FuntypeGetFragDataIndex -> FuntypeGetFragDataIndex +glrefGetFragDataIndex :: IORef FuntypeGetFragDataIndex +glrefGetFragDataIndex = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetFragDataIndex #-} +glGetFragDataIndex :: FuntypeGetFragDataIndex +glGetFragDataIndex = unsafePerformIO $ readIORef glrefGetFragDataIndex +{-# INLINE glGetFragDataIndex #-} +type FuntypeGenSamplers = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGenSamplers :: FunPtr FuntypeGenSamplers -> FuntypeGenSamplers +glrefGenSamplers :: IORef FuntypeGenSamplers +glrefGenSamplers = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGenSamplers #-} +glGenSamplers :: FuntypeGenSamplers +glGenSamplers = unsafePerformIO $ readIORef glrefGenSamplers +{-# INLINE glGenSamplers #-} +type FuntypeDeleteSamplers = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDeleteSamplers :: FunPtr FuntypeDeleteSamplers -> FuntypeDeleteSamplers +glrefDeleteSamplers :: IORef FuntypeDeleteSamplers +glrefDeleteSamplers = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDeleteSamplers #-} +glDeleteSamplers :: FuntypeDeleteSamplers +glDeleteSamplers = unsafePerformIO $ readIORef glrefDeleteSamplers +{-# INLINE glDeleteSamplers #-} +type FuntypeIsSampler = + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsSampler :: FunPtr FuntypeIsSampler -> FuntypeIsSampler +glrefIsSampler :: IORef FuntypeIsSampler +glrefIsSampler = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsSampler #-} +glIsSampler :: FuntypeIsSampler +glIsSampler = unsafePerformIO $ readIORef glrefIsSampler +{-# INLINE glIsSampler #-} +type FuntypeBindSampler = + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindSampler :: FunPtr FuntypeBindSampler -> FuntypeBindSampler +glrefBindSampler :: IORef FuntypeBindSampler +glrefBindSampler = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindSampler #-} +glBindSampler :: FuntypeBindSampler +glBindSampler = unsafePerformIO $ readIORef glrefBindSampler +{-# INLINE glBindSampler #-} +type FuntypeSamplerParameteri = + GLuint -> + GLenum -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynSamplerParameteri :: FunPtr FuntypeSamplerParameteri -> FuntypeSamplerParameteri +glrefSamplerParameteri :: IORef FuntypeSamplerParameteri +glrefSamplerParameteri = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefSamplerParameteri #-} +glSamplerParameteri :: FuntypeSamplerParameteri +glSamplerParameteri = unsafePerformIO $ readIORef glrefSamplerParameteri +{-# INLINE glSamplerParameteri #-} +type FuntypeSamplerParameteriv = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynSamplerParameteriv :: FunPtr FuntypeSamplerParameteriv -> FuntypeSamplerParameteriv +glrefSamplerParameteriv :: IORef FuntypeSamplerParameteriv +glrefSamplerParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefSamplerParameteriv #-} +glSamplerParameteriv :: FuntypeSamplerParameteriv +glSamplerParameteriv = unsafePerformIO $ readIORef glrefSamplerParameteriv +{-# INLINE glSamplerParameteriv #-} +type FuntypeSamplerParameterf = + GLuint -> + GLenum -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynSamplerParameterf :: FunPtr FuntypeSamplerParameterf -> FuntypeSamplerParameterf +glrefSamplerParameterf :: IORef FuntypeSamplerParameterf +glrefSamplerParameterf = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefSamplerParameterf #-} +glSamplerParameterf :: FuntypeSamplerParameterf +glSamplerParameterf = unsafePerformIO $ readIORef glrefSamplerParameterf +{-# INLINE glSamplerParameterf #-} +type FuntypeSamplerParameterfv = + GLuint -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynSamplerParameterfv :: FunPtr FuntypeSamplerParameterfv -> FuntypeSamplerParameterfv +glrefSamplerParameterfv :: IORef FuntypeSamplerParameterfv +glrefSamplerParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefSamplerParameterfv #-} +glSamplerParameterfv :: FuntypeSamplerParameterfv +glSamplerParameterfv = unsafePerformIO $ readIORef glrefSamplerParameterfv +{-# INLINE glSamplerParameterfv #-} +type FuntypeSamplerParameterIiv = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynSamplerParameterIiv :: FunPtr FuntypeSamplerParameterIiv -> FuntypeSamplerParameterIiv +glrefSamplerParameterIiv :: IORef FuntypeSamplerParameterIiv +glrefSamplerParameterIiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefSamplerParameterIiv #-} +glSamplerParameterIiv :: FuntypeSamplerParameterIiv +glSamplerParameterIiv = unsafePerformIO $ readIORef glrefSamplerParameterIiv +{-# INLINE glSamplerParameterIiv #-} +type FuntypeSamplerParameterIuiv = + GLuint -> + GLenum -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynSamplerParameterIuiv :: FunPtr FuntypeSamplerParameterIuiv -> FuntypeSamplerParameterIuiv +glrefSamplerParameterIuiv :: IORef FuntypeSamplerParameterIuiv +glrefSamplerParameterIuiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefSamplerParameterIuiv #-} +glSamplerParameterIuiv :: FuntypeSamplerParameterIuiv +glSamplerParameterIuiv = unsafePerformIO $ readIORef glrefSamplerParameterIuiv +{-# INLINE glSamplerParameterIuiv #-} +type FuntypeGetSamplerParameteriv = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetSamplerParameteriv :: FunPtr FuntypeGetSamplerParameteriv -> FuntypeGetSamplerParameteriv +glrefGetSamplerParameteriv :: IORef FuntypeGetSamplerParameteriv +glrefGetSamplerParameteriv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetSamplerParameteriv #-} +glGetSamplerParameteriv :: FuntypeGetSamplerParameteriv +glGetSamplerParameteriv = unsafePerformIO $ readIORef glrefGetSamplerParameteriv +{-# INLINE glGetSamplerParameteriv #-} +type FuntypeGetSamplerParameterIiv = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetSamplerParameterIiv :: FunPtr FuntypeGetSamplerParameterIiv -> FuntypeGetSamplerParameterIiv +glrefGetSamplerParameterIiv :: IORef FuntypeGetSamplerParameterIiv +glrefGetSamplerParameterIiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetSamplerParameterIiv #-} +glGetSamplerParameterIiv :: FuntypeGetSamplerParameterIiv +glGetSamplerParameterIiv = unsafePerformIO $ readIORef glrefGetSamplerParameterIiv +{-# INLINE glGetSamplerParameterIiv #-} +type FuntypeGetSamplerParameterfv = + GLuint -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetSamplerParameterfv :: FunPtr FuntypeGetSamplerParameterfv -> FuntypeGetSamplerParameterfv +glrefGetSamplerParameterfv :: IORef FuntypeGetSamplerParameterfv +glrefGetSamplerParameterfv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetSamplerParameterfv #-} +glGetSamplerParameterfv :: FuntypeGetSamplerParameterfv +glGetSamplerParameterfv = unsafePerformIO $ readIORef glrefGetSamplerParameterfv +{-# INLINE glGetSamplerParameterfv #-} +type FuntypeGetSamplerParameterIuiv = + GLuint -> + GLenum -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetSamplerParameterIuiv :: FunPtr FuntypeGetSamplerParameterIuiv -> FuntypeGetSamplerParameterIuiv +glrefGetSamplerParameterIuiv :: IORef FuntypeGetSamplerParameterIuiv +glrefGetSamplerParameterIuiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetSamplerParameterIuiv #-} +glGetSamplerParameterIuiv :: FuntypeGetSamplerParameterIuiv +glGetSamplerParameterIuiv = unsafePerformIO $ readIORef glrefGetSamplerParameterIuiv +{-# INLINE glGetSamplerParameterIuiv #-} +type FuntypeQueryCounter = + GLuint -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynQueryCounter :: FunPtr FuntypeQueryCounter -> FuntypeQueryCounter +glrefQueryCounter :: IORef FuntypeQueryCounter +glrefQueryCounter = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefQueryCounter #-} +glQueryCounter :: FuntypeQueryCounter +glQueryCounter = unsafePerformIO $ readIORef glrefQueryCounter +{-# INLINE glQueryCounter #-} +type FuntypeGetQueryObjecti64v = + GLuint -> + GLenum -> + Ptr (GLint64) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetQueryObjecti64v :: FunPtr FuntypeGetQueryObjecti64v -> FuntypeGetQueryObjecti64v +glrefGetQueryObjecti64v :: IORef FuntypeGetQueryObjecti64v +glrefGetQueryObjecti64v = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetQueryObjecti64v #-} +glGetQueryObjecti64v :: FuntypeGetQueryObjecti64v +glGetQueryObjecti64v = unsafePerformIO $ readIORef glrefGetQueryObjecti64v +{-# INLINE glGetQueryObjecti64v #-} +type FuntypeGetQueryObjectui64v = + GLuint -> + GLenum -> + Ptr (GLuint64) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetQueryObjectui64v :: FunPtr FuntypeGetQueryObjectui64v -> FuntypeGetQueryObjectui64v +glrefGetQueryObjectui64v :: IORef FuntypeGetQueryObjectui64v +glrefGetQueryObjectui64v = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetQueryObjectui64v #-} +glGetQueryObjectui64v :: FuntypeGetQueryObjectui64v +glGetQueryObjectui64v = unsafePerformIO $ readIORef glrefGetQueryObjectui64v +{-# INLINE glGetQueryObjectui64v #-} +type FuntypeVertexAttribDivisor = + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribDivisor :: FunPtr FuntypeVertexAttribDivisor -> FuntypeVertexAttribDivisor +glrefVertexAttribDivisor :: IORef FuntypeVertexAttribDivisor +glrefVertexAttribDivisor = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribDivisor #-} +glVertexAttribDivisor :: FuntypeVertexAttribDivisor +glVertexAttribDivisor = unsafePerformIO $ readIORef glrefVertexAttribDivisor +{-# INLINE glVertexAttribDivisor #-} +type FuntypeVertexAttribP1ui = + GLuint -> + GLenum -> + GLboolean -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribP1ui :: FunPtr FuntypeVertexAttribP1ui -> FuntypeVertexAttribP1ui +glrefVertexAttribP1ui :: IORef FuntypeVertexAttribP1ui +glrefVertexAttribP1ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribP1ui #-} +glVertexAttribP1ui :: FuntypeVertexAttribP1ui +glVertexAttribP1ui = unsafePerformIO $ readIORef glrefVertexAttribP1ui +{-# INLINE glVertexAttribP1ui #-} +type FuntypeVertexAttribP1uiv = + GLuint -> + GLenum -> + GLboolean -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribP1uiv :: FunPtr FuntypeVertexAttribP1uiv -> FuntypeVertexAttribP1uiv +glrefVertexAttribP1uiv :: IORef FuntypeVertexAttribP1uiv +glrefVertexAttribP1uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribP1uiv #-} +glVertexAttribP1uiv :: FuntypeVertexAttribP1uiv +glVertexAttribP1uiv = unsafePerformIO $ readIORef glrefVertexAttribP1uiv +{-# INLINE glVertexAttribP1uiv #-} +type FuntypeVertexAttribP2ui = + GLuint -> + GLenum -> + GLboolean -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribP2ui :: FunPtr FuntypeVertexAttribP2ui -> FuntypeVertexAttribP2ui +glrefVertexAttribP2ui :: IORef FuntypeVertexAttribP2ui +glrefVertexAttribP2ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribP2ui #-} +glVertexAttribP2ui :: FuntypeVertexAttribP2ui +glVertexAttribP2ui = unsafePerformIO $ readIORef glrefVertexAttribP2ui +{-# INLINE glVertexAttribP2ui #-} +type FuntypeVertexAttribP2uiv = + GLuint -> + GLenum -> + GLboolean -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribP2uiv :: FunPtr FuntypeVertexAttribP2uiv -> FuntypeVertexAttribP2uiv +glrefVertexAttribP2uiv :: IORef FuntypeVertexAttribP2uiv +glrefVertexAttribP2uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribP2uiv #-} +glVertexAttribP2uiv :: FuntypeVertexAttribP2uiv +glVertexAttribP2uiv = unsafePerformIO $ readIORef glrefVertexAttribP2uiv +{-# INLINE glVertexAttribP2uiv #-} +type FuntypeVertexAttribP3ui = + GLuint -> + GLenum -> + GLboolean -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribP3ui :: FunPtr FuntypeVertexAttribP3ui -> FuntypeVertexAttribP3ui +glrefVertexAttribP3ui :: IORef FuntypeVertexAttribP3ui +glrefVertexAttribP3ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribP3ui #-} +glVertexAttribP3ui :: FuntypeVertexAttribP3ui +glVertexAttribP3ui = unsafePerformIO $ readIORef glrefVertexAttribP3ui +{-# INLINE glVertexAttribP3ui #-} +type FuntypeVertexAttribP3uiv = + GLuint -> + GLenum -> + GLboolean -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribP3uiv :: FunPtr FuntypeVertexAttribP3uiv -> FuntypeVertexAttribP3uiv +glrefVertexAttribP3uiv :: IORef FuntypeVertexAttribP3uiv +glrefVertexAttribP3uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribP3uiv #-} +glVertexAttribP3uiv :: FuntypeVertexAttribP3uiv +glVertexAttribP3uiv = unsafePerformIO $ readIORef glrefVertexAttribP3uiv +{-# INLINE glVertexAttribP3uiv #-} +type FuntypeVertexAttribP4ui = + GLuint -> + GLenum -> + GLboolean -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribP4ui :: FunPtr FuntypeVertexAttribP4ui -> FuntypeVertexAttribP4ui +glrefVertexAttribP4ui :: IORef FuntypeVertexAttribP4ui +glrefVertexAttribP4ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribP4ui #-} +glVertexAttribP4ui :: FuntypeVertexAttribP4ui +glVertexAttribP4ui = unsafePerformIO $ readIORef glrefVertexAttribP4ui +{-# INLINE glVertexAttribP4ui #-} +type FuntypeVertexAttribP4uiv = + GLuint -> + GLenum -> + GLboolean -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexAttribP4uiv :: FunPtr FuntypeVertexAttribP4uiv -> FuntypeVertexAttribP4uiv +glrefVertexAttribP4uiv :: IORef FuntypeVertexAttribP4uiv +glrefVertexAttribP4uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexAttribP4uiv #-} +glVertexAttribP4uiv :: FuntypeVertexAttribP4uiv +glVertexAttribP4uiv = unsafePerformIO $ readIORef glrefVertexAttribP4uiv +{-# INLINE glVertexAttribP4uiv #-} + +-- GL_ARB_texture_storage + +type FuntypeTexStorage1D = + GLenum -> + GLsizei -> + GLenum -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexStorage1D :: FunPtr FuntypeTexStorage1D -> FuntypeTexStorage1D +glrefTexStorage1D :: IORef FuntypeTexStorage1D +glrefTexStorage1D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexStorage1D #-} +glTexStorage1D :: FuntypeTexStorage1D +glTexStorage1D = unsafePerformIO $ readIORef glrefTexStorage1D +{-# INLINE glTexStorage1D #-} +type FuntypeTexStorage2D = + GLenum -> + GLsizei -> + GLenum -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexStorage2D :: FunPtr FuntypeTexStorage2D -> FuntypeTexStorage2D +glrefTexStorage2D :: IORef FuntypeTexStorage2D +glrefTexStorage2D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexStorage2D #-} +glTexStorage2D :: FuntypeTexStorage2D +glTexStorage2D = unsafePerformIO $ readIORef glrefTexStorage2D +{-# INLINE glTexStorage2D #-} +type FuntypeTexStorage3D = + GLenum -> + GLsizei -> + GLenum -> + GLsizei -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexStorage3D :: FunPtr FuntypeTexStorage3D -> FuntypeTexStorage3D +glrefTexStorage3D :: IORef FuntypeTexStorage3D +glrefTexStorage3D = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexStorage3D #-} +glTexStorage3D :: FuntypeTexStorage3D +glTexStorage3D = unsafePerformIO $ readIORef glrefTexStorage3D +{-# INLINE glTexStorage3D #-} + +-- GL_KHR_debug + +type FuntypeDebugMessageControl = + GLenum -> + GLenum -> + GLenum -> + GLsizei -> + Ptr (GLuint) -> + GLboolean -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDebugMessageControl :: FunPtr FuntypeDebugMessageControl -> FuntypeDebugMessageControl +glrefDebugMessageControl :: IORef FuntypeDebugMessageControl +glrefDebugMessageControl = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDebugMessageControl #-} +glDebugMessageControl :: FuntypeDebugMessageControl +glDebugMessageControl = unsafePerformIO $ readIORef glrefDebugMessageControl +{-# INLINE glDebugMessageControl #-} +type FuntypeDebugMessageInsert = + GLenum -> + GLenum -> + GLuint -> + GLenum -> + GLsizei -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDebugMessageInsert :: FunPtr FuntypeDebugMessageInsert -> FuntypeDebugMessageInsert +glrefDebugMessageInsert :: IORef FuntypeDebugMessageInsert +glrefDebugMessageInsert = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDebugMessageInsert #-} +glDebugMessageInsert :: FuntypeDebugMessageInsert +glDebugMessageInsert = unsafePerformIO $ readIORef glrefDebugMessageInsert +{-# INLINE glDebugMessageInsert #-} +type FuntypeDebugMessageCallback = + GLDEBUGPROC -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDebugMessageCallback :: FunPtr FuntypeDebugMessageCallback -> FuntypeDebugMessageCallback +glrefDebugMessageCallback :: IORef FuntypeDebugMessageCallback +glrefDebugMessageCallback = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDebugMessageCallback #-} +glDebugMessageCallback :: FuntypeDebugMessageCallback +glDebugMessageCallback = unsafePerformIO $ readIORef glrefDebugMessageCallback +{-# INLINE glDebugMessageCallback #-} +type FuntypeGetDebugMessageLog = + GLuint -> + GLsizei -> + Ptr (GLenum) -> + Ptr (GLenum) -> + Ptr (GLuint) -> + Ptr (GLenum) -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( GLuint ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetDebugMessageLog :: FunPtr FuntypeGetDebugMessageLog -> FuntypeGetDebugMessageLog +glrefGetDebugMessageLog :: IORef FuntypeGetDebugMessageLog +glrefGetDebugMessageLog = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetDebugMessageLog #-} +glGetDebugMessageLog :: FuntypeGetDebugMessageLog +glGetDebugMessageLog = unsafePerformIO $ readIORef glrefGetDebugMessageLog +{-# INLINE glGetDebugMessageLog #-} +type FuntypePushDebugGroup = + GLenum -> + GLuint -> + GLsizei -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPushDebugGroup :: FunPtr FuntypePushDebugGroup -> FuntypePushDebugGroup +glrefPushDebugGroup :: IORef FuntypePushDebugGroup +glrefPushDebugGroup = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPushDebugGroup #-} +glPushDebugGroup :: FuntypePushDebugGroup +glPushDebugGroup = unsafePerformIO $ readIORef glrefPushDebugGroup +{-# INLINE glPushDebugGroup #-} +type FuntypePopDebugGroup = + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPopDebugGroup :: FunPtr FuntypePopDebugGroup -> FuntypePopDebugGroup +glrefPopDebugGroup :: IORef FuntypePopDebugGroup +glrefPopDebugGroup = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPopDebugGroup #-} +glPopDebugGroup :: FuntypePopDebugGroup +glPopDebugGroup = unsafePerformIO $ readIORef glrefPopDebugGroup +{-# INLINE glPopDebugGroup #-} +type FuntypeObjectLabel = + GLenum -> + GLuint -> + GLsizei -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynObjectLabel :: FunPtr FuntypeObjectLabel -> FuntypeObjectLabel +glrefObjectLabel :: IORef FuntypeObjectLabel +glrefObjectLabel = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefObjectLabel #-} +glObjectLabel :: FuntypeObjectLabel +glObjectLabel = unsafePerformIO $ readIORef glrefObjectLabel +{-# INLINE glObjectLabel #-} +type FuntypeGetObjectLabel = + GLenum -> + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetObjectLabel :: FunPtr FuntypeGetObjectLabel -> FuntypeGetObjectLabel +glrefGetObjectLabel :: IORef FuntypeGetObjectLabel +glrefGetObjectLabel = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetObjectLabel #-} +glGetObjectLabel :: FuntypeGetObjectLabel +glGetObjectLabel = unsafePerformIO $ readIORef glrefGetObjectLabel +{-# INLINE glGetObjectLabel #-} +type FuntypeObjectPtrLabel = + Ptr () -> + GLsizei -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynObjectPtrLabel :: FunPtr FuntypeObjectPtrLabel -> FuntypeObjectPtrLabel +glrefObjectPtrLabel :: IORef FuntypeObjectPtrLabel +glrefObjectPtrLabel = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefObjectPtrLabel #-} +glObjectPtrLabel :: FuntypeObjectPtrLabel +glObjectPtrLabel = unsafePerformIO $ readIORef glrefObjectPtrLabel +{-# INLINE glObjectPtrLabel #-} +type FuntypeGetObjectPtrLabel = + Ptr () -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetObjectPtrLabel :: FunPtr FuntypeGetObjectPtrLabel -> FuntypeGetObjectPtrLabel +glrefGetObjectPtrLabel :: IORef FuntypeGetObjectPtrLabel +glrefGetObjectPtrLabel = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetObjectPtrLabel #-} +glGetObjectPtrLabel :: FuntypeGetObjectPtrLabel +glGetObjectPtrLabel = unsafePerformIO $ readIORef glrefGetObjectPtrLabel +{-# INLINE glGetObjectPtrLabel #-} +type FuntypeGetPointerv = + GLenum -> + Ptr (Ptr ()) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetPointerv :: FunPtr FuntypeGetPointerv -> FuntypeGetPointerv +glrefGetPointerv :: IORef FuntypeGetPointerv +glrefGetPointerv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetPointerv #-} +glGetPointerv :: FuntypeGetPointerv +glGetPointerv = unsafePerformIO $ readIORef glrefGetPointerv +{-# INLINE glGetPointerv #-} +type FuntypeDebugMessageControlKHR = + GLenum -> + GLenum -> + GLenum -> + GLsizei -> + Ptr (GLuint) -> + GLboolean -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDebugMessageControlKHR :: FunPtr FuntypeDebugMessageControlKHR -> FuntypeDebugMessageControlKHR +glrefDebugMessageControlKHR :: IORef FuntypeDebugMessageControlKHR +glrefDebugMessageControlKHR = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDebugMessageControlKHR #-} +glDebugMessageControlKHR :: FuntypeDebugMessageControlKHR +glDebugMessageControlKHR = unsafePerformIO $ readIORef glrefDebugMessageControlKHR +{-# INLINE glDebugMessageControlKHR #-} +type FuntypeDebugMessageInsertKHR = + GLenum -> + GLenum -> + GLuint -> + GLenum -> + GLsizei -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDebugMessageInsertKHR :: FunPtr FuntypeDebugMessageInsertKHR -> FuntypeDebugMessageInsertKHR +glrefDebugMessageInsertKHR :: IORef FuntypeDebugMessageInsertKHR +glrefDebugMessageInsertKHR = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDebugMessageInsertKHR #-} +glDebugMessageInsertKHR :: FuntypeDebugMessageInsertKHR +glDebugMessageInsertKHR = unsafePerformIO $ readIORef glrefDebugMessageInsertKHR +{-# INLINE glDebugMessageInsertKHR #-} +type FuntypeDebugMessageCallbackKHR = + GLDEBUGPROCKHR -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDebugMessageCallbackKHR :: FunPtr FuntypeDebugMessageCallbackKHR -> FuntypeDebugMessageCallbackKHR +glrefDebugMessageCallbackKHR :: IORef FuntypeDebugMessageCallbackKHR +glrefDebugMessageCallbackKHR = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDebugMessageCallbackKHR #-} +glDebugMessageCallbackKHR :: FuntypeDebugMessageCallbackKHR +glDebugMessageCallbackKHR = unsafePerformIO $ readIORef glrefDebugMessageCallbackKHR +{-# INLINE glDebugMessageCallbackKHR #-} +type FuntypeGetDebugMessageLogKHR = + GLuint -> + GLsizei -> + Ptr (GLenum) -> + Ptr (GLenum) -> + Ptr (GLuint) -> + Ptr (GLenum) -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( GLuint ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetDebugMessageLogKHR :: FunPtr FuntypeGetDebugMessageLogKHR -> FuntypeGetDebugMessageLogKHR +glrefGetDebugMessageLogKHR :: IORef FuntypeGetDebugMessageLogKHR +glrefGetDebugMessageLogKHR = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetDebugMessageLogKHR #-} +glGetDebugMessageLogKHR :: FuntypeGetDebugMessageLogKHR +glGetDebugMessageLogKHR = unsafePerformIO $ readIORef glrefGetDebugMessageLogKHR +{-# INLINE glGetDebugMessageLogKHR #-} +type FuntypePushDebugGroupKHR = + GLenum -> + GLuint -> + GLsizei -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPushDebugGroupKHR :: FunPtr FuntypePushDebugGroupKHR -> FuntypePushDebugGroupKHR +glrefPushDebugGroupKHR :: IORef FuntypePushDebugGroupKHR +glrefPushDebugGroupKHR = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPushDebugGroupKHR #-} +glPushDebugGroupKHR :: FuntypePushDebugGroupKHR +glPushDebugGroupKHR = unsafePerformIO $ readIORef glrefPushDebugGroupKHR +{-# INLINE glPushDebugGroupKHR #-} +type FuntypePopDebugGroupKHR = + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPopDebugGroupKHR :: FunPtr FuntypePopDebugGroupKHR -> FuntypePopDebugGroupKHR +glrefPopDebugGroupKHR :: IORef FuntypePopDebugGroupKHR +glrefPopDebugGroupKHR = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPopDebugGroupKHR #-} +glPopDebugGroupKHR :: FuntypePopDebugGroupKHR +glPopDebugGroupKHR = unsafePerformIO $ readIORef glrefPopDebugGroupKHR +{-# INLINE glPopDebugGroupKHR #-} +type FuntypeObjectLabelKHR = + GLenum -> + GLuint -> + GLsizei -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynObjectLabelKHR :: FunPtr FuntypeObjectLabelKHR -> FuntypeObjectLabelKHR +glrefObjectLabelKHR :: IORef FuntypeObjectLabelKHR +glrefObjectLabelKHR = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefObjectLabelKHR #-} +glObjectLabelKHR :: FuntypeObjectLabelKHR +glObjectLabelKHR = unsafePerformIO $ readIORef glrefObjectLabelKHR +{-# INLINE glObjectLabelKHR #-} +type FuntypeGetObjectLabelKHR = + GLenum -> + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetObjectLabelKHR :: FunPtr FuntypeGetObjectLabelKHR -> FuntypeGetObjectLabelKHR +glrefGetObjectLabelKHR :: IORef FuntypeGetObjectLabelKHR +glrefGetObjectLabelKHR = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetObjectLabelKHR #-} +glGetObjectLabelKHR :: FuntypeGetObjectLabelKHR +glGetObjectLabelKHR = unsafePerformIO $ readIORef glrefGetObjectLabelKHR +{-# INLINE glGetObjectLabelKHR #-} +type FuntypeObjectPtrLabelKHR = + Ptr () -> + GLsizei -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynObjectPtrLabelKHR :: FunPtr FuntypeObjectPtrLabelKHR -> FuntypeObjectPtrLabelKHR +glrefObjectPtrLabelKHR :: IORef FuntypeObjectPtrLabelKHR +glrefObjectPtrLabelKHR = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefObjectPtrLabelKHR #-} +glObjectPtrLabelKHR :: FuntypeObjectPtrLabelKHR +glObjectPtrLabelKHR = unsafePerformIO $ readIORef glrefObjectPtrLabelKHR +{-# INLINE glObjectPtrLabelKHR #-} +type FuntypeGetObjectPtrLabelKHR = + Ptr () -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetObjectPtrLabelKHR :: FunPtr FuntypeGetObjectPtrLabelKHR -> FuntypeGetObjectPtrLabelKHR +glrefGetObjectPtrLabelKHR :: IORef FuntypeGetObjectPtrLabelKHR +glrefGetObjectPtrLabelKHR = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetObjectPtrLabelKHR #-} +glGetObjectPtrLabelKHR :: FuntypeGetObjectPtrLabelKHR +glGetObjectPtrLabelKHR = unsafePerformIO $ readIORef glrefGetObjectPtrLabelKHR +{-# INLINE glGetObjectPtrLabelKHR #-} +type FuntypeGetPointervKHR = + GLenum -> + Ptr (Ptr ()) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetPointervKHR :: FunPtr FuntypeGetPointervKHR -> FuntypeGetPointervKHR +glrefGetPointervKHR :: IORef FuntypeGetPointervKHR +glrefGetPointervKHR = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetPointervKHR #-} +glGetPointervKHR :: FuntypeGetPointervKHR +glGetPointervKHR = unsafePerformIO $ readIORef glrefGetPointervKHR +{-# INLINE glGetPointervKHR #-} + +-- GL_EXT_direct_state_access + +type FuntypeMatrixLoadfEXT = + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixLoadfEXT :: FunPtr FuntypeMatrixLoadfEXT -> FuntypeMatrixLoadfEXT +glrefMatrixLoadfEXT :: IORef FuntypeMatrixLoadfEXT +glrefMatrixLoadfEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixLoadfEXT #-} +glMatrixLoadfEXT :: FuntypeMatrixLoadfEXT +glMatrixLoadfEXT = unsafePerformIO $ readIORef glrefMatrixLoadfEXT +{-# INLINE glMatrixLoadfEXT #-} +type FuntypeMatrixLoaddEXT = + GLenum -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixLoaddEXT :: FunPtr FuntypeMatrixLoaddEXT -> FuntypeMatrixLoaddEXT +glrefMatrixLoaddEXT :: IORef FuntypeMatrixLoaddEXT +glrefMatrixLoaddEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixLoaddEXT #-} +glMatrixLoaddEXT :: FuntypeMatrixLoaddEXT +glMatrixLoaddEXT = unsafePerformIO $ readIORef glrefMatrixLoaddEXT +{-# INLINE glMatrixLoaddEXT #-} +type FuntypeMatrixMultfEXT = + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixMultfEXT :: FunPtr FuntypeMatrixMultfEXT -> FuntypeMatrixMultfEXT +glrefMatrixMultfEXT :: IORef FuntypeMatrixMultfEXT +glrefMatrixMultfEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixMultfEXT #-} +glMatrixMultfEXT :: FuntypeMatrixMultfEXT +glMatrixMultfEXT = unsafePerformIO $ readIORef glrefMatrixMultfEXT +{-# INLINE glMatrixMultfEXT #-} +type FuntypeMatrixMultdEXT = + GLenum -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixMultdEXT :: FunPtr FuntypeMatrixMultdEXT -> FuntypeMatrixMultdEXT +glrefMatrixMultdEXT :: IORef FuntypeMatrixMultdEXT +glrefMatrixMultdEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixMultdEXT #-} +glMatrixMultdEXT :: FuntypeMatrixMultdEXT +glMatrixMultdEXT = unsafePerformIO $ readIORef glrefMatrixMultdEXT +{-# INLINE glMatrixMultdEXT #-} +type FuntypeMatrixLoadIdentityEXT = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixLoadIdentityEXT :: FunPtr FuntypeMatrixLoadIdentityEXT -> FuntypeMatrixLoadIdentityEXT +glrefMatrixLoadIdentityEXT :: IORef FuntypeMatrixLoadIdentityEXT +glrefMatrixLoadIdentityEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixLoadIdentityEXT #-} +glMatrixLoadIdentityEXT :: FuntypeMatrixLoadIdentityEXT +glMatrixLoadIdentityEXT = unsafePerformIO $ readIORef glrefMatrixLoadIdentityEXT +{-# INLINE glMatrixLoadIdentityEXT #-} +type FuntypeMatrixRotatefEXT = + GLenum -> + GLfloat -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixRotatefEXT :: FunPtr FuntypeMatrixRotatefEXT -> FuntypeMatrixRotatefEXT +glrefMatrixRotatefEXT :: IORef FuntypeMatrixRotatefEXT +glrefMatrixRotatefEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixRotatefEXT #-} +glMatrixRotatefEXT :: FuntypeMatrixRotatefEXT +glMatrixRotatefEXT = unsafePerformIO $ readIORef glrefMatrixRotatefEXT +{-# INLINE glMatrixRotatefEXT #-} +type FuntypeMatrixRotatedEXT = + GLenum -> + GLdouble -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixRotatedEXT :: FunPtr FuntypeMatrixRotatedEXT -> FuntypeMatrixRotatedEXT +glrefMatrixRotatedEXT :: IORef FuntypeMatrixRotatedEXT +glrefMatrixRotatedEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixRotatedEXT #-} +glMatrixRotatedEXT :: FuntypeMatrixRotatedEXT +glMatrixRotatedEXT = unsafePerformIO $ readIORef glrefMatrixRotatedEXT +{-# INLINE glMatrixRotatedEXT #-} +type FuntypeMatrixScalefEXT = + GLenum -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixScalefEXT :: FunPtr FuntypeMatrixScalefEXT -> FuntypeMatrixScalefEXT +glrefMatrixScalefEXT :: IORef FuntypeMatrixScalefEXT +glrefMatrixScalefEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixScalefEXT #-} +glMatrixScalefEXT :: FuntypeMatrixScalefEXT +glMatrixScalefEXT = unsafePerformIO $ readIORef glrefMatrixScalefEXT +{-# INLINE glMatrixScalefEXT #-} +type FuntypeMatrixScaledEXT = + GLenum -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixScaledEXT :: FunPtr FuntypeMatrixScaledEXT -> FuntypeMatrixScaledEXT +glrefMatrixScaledEXT :: IORef FuntypeMatrixScaledEXT +glrefMatrixScaledEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixScaledEXT #-} +glMatrixScaledEXT :: FuntypeMatrixScaledEXT +glMatrixScaledEXT = unsafePerformIO $ readIORef glrefMatrixScaledEXT +{-# INLINE glMatrixScaledEXT #-} +type FuntypeMatrixTranslatefEXT = + GLenum -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixTranslatefEXT :: FunPtr FuntypeMatrixTranslatefEXT -> FuntypeMatrixTranslatefEXT +glrefMatrixTranslatefEXT :: IORef FuntypeMatrixTranslatefEXT +glrefMatrixTranslatefEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixTranslatefEXT #-} +glMatrixTranslatefEXT :: FuntypeMatrixTranslatefEXT +glMatrixTranslatefEXT = unsafePerformIO $ readIORef glrefMatrixTranslatefEXT +{-# INLINE glMatrixTranslatefEXT #-} +type FuntypeMatrixTranslatedEXT = + GLenum -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixTranslatedEXT :: FunPtr FuntypeMatrixTranslatedEXT -> FuntypeMatrixTranslatedEXT +glrefMatrixTranslatedEXT :: IORef FuntypeMatrixTranslatedEXT +glrefMatrixTranslatedEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixTranslatedEXT #-} +glMatrixTranslatedEXT :: FuntypeMatrixTranslatedEXT +glMatrixTranslatedEXT = unsafePerformIO $ readIORef glrefMatrixTranslatedEXT +{-# INLINE glMatrixTranslatedEXT #-} +type FuntypeMatrixFrustumEXT = + GLenum -> + GLdouble -> + GLdouble -> + GLdouble -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixFrustumEXT :: FunPtr FuntypeMatrixFrustumEXT -> FuntypeMatrixFrustumEXT +glrefMatrixFrustumEXT :: IORef FuntypeMatrixFrustumEXT +glrefMatrixFrustumEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixFrustumEXT #-} +glMatrixFrustumEXT :: FuntypeMatrixFrustumEXT +glMatrixFrustumEXT = unsafePerformIO $ readIORef glrefMatrixFrustumEXT +{-# INLINE glMatrixFrustumEXT #-} +type FuntypeMatrixOrthoEXT = + GLenum -> + GLdouble -> + GLdouble -> + GLdouble -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixOrthoEXT :: FunPtr FuntypeMatrixOrthoEXT -> FuntypeMatrixOrthoEXT +glrefMatrixOrthoEXT :: IORef FuntypeMatrixOrthoEXT +glrefMatrixOrthoEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixOrthoEXT #-} +glMatrixOrthoEXT :: FuntypeMatrixOrthoEXT +glMatrixOrthoEXT = unsafePerformIO $ readIORef glrefMatrixOrthoEXT +{-# INLINE glMatrixOrthoEXT #-} +type FuntypeMatrixPopEXT = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixPopEXT :: FunPtr FuntypeMatrixPopEXT -> FuntypeMatrixPopEXT +glrefMatrixPopEXT :: IORef FuntypeMatrixPopEXT +glrefMatrixPopEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixPopEXT #-} +glMatrixPopEXT :: FuntypeMatrixPopEXT +glMatrixPopEXT = unsafePerformIO $ readIORef glrefMatrixPopEXT +{-# INLINE glMatrixPopEXT #-} +type FuntypeMatrixPushEXT = + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixPushEXT :: FunPtr FuntypeMatrixPushEXT -> FuntypeMatrixPushEXT +glrefMatrixPushEXT :: IORef FuntypeMatrixPushEXT +glrefMatrixPushEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixPushEXT #-} +glMatrixPushEXT :: FuntypeMatrixPushEXT +glMatrixPushEXT = unsafePerformIO $ readIORef glrefMatrixPushEXT +{-# INLINE glMatrixPushEXT #-} +type FuntypeClientAttribDefaultEXT = + GLbitfield -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClientAttribDefaultEXT :: FunPtr FuntypeClientAttribDefaultEXT -> FuntypeClientAttribDefaultEXT +glrefClientAttribDefaultEXT :: IORef FuntypeClientAttribDefaultEXT +glrefClientAttribDefaultEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClientAttribDefaultEXT #-} +glClientAttribDefaultEXT :: FuntypeClientAttribDefaultEXT +glClientAttribDefaultEXT = unsafePerformIO $ readIORef glrefClientAttribDefaultEXT +{-# INLINE glClientAttribDefaultEXT #-} +type FuntypePushClientAttribDefaultEXT = + GLbitfield -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynPushClientAttribDefaultEXT :: FunPtr FuntypePushClientAttribDefaultEXT -> FuntypePushClientAttribDefaultEXT +glrefPushClientAttribDefaultEXT :: IORef FuntypePushClientAttribDefaultEXT +glrefPushClientAttribDefaultEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefPushClientAttribDefaultEXT #-} +glPushClientAttribDefaultEXT :: FuntypePushClientAttribDefaultEXT +glPushClientAttribDefaultEXT = unsafePerformIO $ readIORef glrefPushClientAttribDefaultEXT +{-# INLINE glPushClientAttribDefaultEXT #-} +type FuntypeTextureParameterfEXT = + GLuint -> + GLenum -> + GLenum -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureParameterfEXT :: FunPtr FuntypeTextureParameterfEXT -> FuntypeTextureParameterfEXT +glrefTextureParameterfEXT :: IORef FuntypeTextureParameterfEXT +glrefTextureParameterfEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureParameterfEXT #-} +glTextureParameterfEXT :: FuntypeTextureParameterfEXT +glTextureParameterfEXT = unsafePerformIO $ readIORef glrefTextureParameterfEXT +{-# INLINE glTextureParameterfEXT #-} +type FuntypeTextureParameterfvEXT = + GLuint -> + GLenum -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureParameterfvEXT :: FunPtr FuntypeTextureParameterfvEXT -> FuntypeTextureParameterfvEXT +glrefTextureParameterfvEXT :: IORef FuntypeTextureParameterfvEXT +glrefTextureParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureParameterfvEXT #-} +glTextureParameterfvEXT :: FuntypeTextureParameterfvEXT +glTextureParameterfvEXT = unsafePerformIO $ readIORef glrefTextureParameterfvEXT +{-# INLINE glTextureParameterfvEXT #-} +type FuntypeTextureParameteriEXT = + GLuint -> + GLenum -> + GLenum -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureParameteriEXT :: FunPtr FuntypeTextureParameteriEXT -> FuntypeTextureParameteriEXT +glrefTextureParameteriEXT :: IORef FuntypeTextureParameteriEXT +glrefTextureParameteriEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureParameteriEXT #-} +glTextureParameteriEXT :: FuntypeTextureParameteriEXT +glTextureParameteriEXT = unsafePerformIO $ readIORef glrefTextureParameteriEXT +{-# INLINE glTextureParameteriEXT #-} +type FuntypeTextureParameterivEXT = + GLuint -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureParameterivEXT :: FunPtr FuntypeTextureParameterivEXT -> FuntypeTextureParameterivEXT +glrefTextureParameterivEXT :: IORef FuntypeTextureParameterivEXT +glrefTextureParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureParameterivEXT #-} +glTextureParameterivEXT :: FuntypeTextureParameterivEXT +glTextureParameterivEXT = unsafePerformIO $ readIORef glrefTextureParameterivEXT +{-# INLINE glTextureParameterivEXT #-} +type FuntypeTextureImage1DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureImage1DEXT :: FunPtr FuntypeTextureImage1DEXT -> FuntypeTextureImage1DEXT +glrefTextureImage1DEXT :: IORef FuntypeTextureImage1DEXT +glrefTextureImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureImage1DEXT #-} +glTextureImage1DEXT :: FuntypeTextureImage1DEXT +glTextureImage1DEXT = unsafePerformIO $ readIORef glrefTextureImage1DEXT +{-# INLINE glTextureImage1DEXT #-} +type FuntypeTextureImage2DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureImage2DEXT :: FunPtr FuntypeTextureImage2DEXT -> FuntypeTextureImage2DEXT +glrefTextureImage2DEXT :: IORef FuntypeTextureImage2DEXT +glrefTextureImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureImage2DEXT #-} +glTextureImage2DEXT :: FuntypeTextureImage2DEXT +glTextureImage2DEXT = unsafePerformIO $ readIORef glrefTextureImage2DEXT +{-# INLINE glTextureImage2DEXT #-} +type FuntypeTextureSubImage1DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureSubImage1DEXT :: FunPtr FuntypeTextureSubImage1DEXT -> FuntypeTextureSubImage1DEXT +glrefTextureSubImage1DEXT :: IORef FuntypeTextureSubImage1DEXT +glrefTextureSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureSubImage1DEXT #-} +glTextureSubImage1DEXT :: FuntypeTextureSubImage1DEXT +glTextureSubImage1DEXT = unsafePerformIO $ readIORef glrefTextureSubImage1DEXT +{-# INLINE glTextureSubImage1DEXT #-} +type FuntypeTextureSubImage2DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureSubImage2DEXT :: FunPtr FuntypeTextureSubImage2DEXT -> FuntypeTextureSubImage2DEXT +glrefTextureSubImage2DEXT :: IORef FuntypeTextureSubImage2DEXT +glrefTextureSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureSubImage2DEXT #-} +glTextureSubImage2DEXT :: FuntypeTextureSubImage2DEXT +glTextureSubImage2DEXT = unsafePerformIO $ readIORef glrefTextureSubImage2DEXT +{-# INLINE glTextureSubImage2DEXT #-} +type FuntypeCopyTextureImage1DEXT = + GLuint -> + GLenum -> + GLint -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyTextureImage1DEXT :: FunPtr FuntypeCopyTextureImage1DEXT -> FuntypeCopyTextureImage1DEXT +glrefCopyTextureImage1DEXT :: IORef FuntypeCopyTextureImage1DEXT +glrefCopyTextureImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyTextureImage1DEXT #-} +glCopyTextureImage1DEXT :: FuntypeCopyTextureImage1DEXT +glCopyTextureImage1DEXT = unsafePerformIO $ readIORef glrefCopyTextureImage1DEXT +{-# INLINE glCopyTextureImage1DEXT #-} +type FuntypeCopyTextureImage2DEXT = + GLuint -> + GLenum -> + GLint -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyTextureImage2DEXT :: FunPtr FuntypeCopyTextureImage2DEXT -> FuntypeCopyTextureImage2DEXT +glrefCopyTextureImage2DEXT :: IORef FuntypeCopyTextureImage2DEXT +glrefCopyTextureImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyTextureImage2DEXT #-} +glCopyTextureImage2DEXT :: FuntypeCopyTextureImage2DEXT +glCopyTextureImage2DEXT = unsafePerformIO $ readIORef glrefCopyTextureImage2DEXT +{-# INLINE glCopyTextureImage2DEXT #-} +type FuntypeCopyTextureSubImage1DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyTextureSubImage1DEXT :: FunPtr FuntypeCopyTextureSubImage1DEXT -> FuntypeCopyTextureSubImage1DEXT +glrefCopyTextureSubImage1DEXT :: IORef FuntypeCopyTextureSubImage1DEXT +glrefCopyTextureSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyTextureSubImage1DEXT #-} +glCopyTextureSubImage1DEXT :: FuntypeCopyTextureSubImage1DEXT +glCopyTextureSubImage1DEXT = unsafePerformIO $ readIORef glrefCopyTextureSubImage1DEXT +{-# INLINE glCopyTextureSubImage1DEXT #-} +type FuntypeCopyTextureSubImage2DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyTextureSubImage2DEXT :: FunPtr FuntypeCopyTextureSubImage2DEXT -> FuntypeCopyTextureSubImage2DEXT +glrefCopyTextureSubImage2DEXT :: IORef FuntypeCopyTextureSubImage2DEXT +glrefCopyTextureSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyTextureSubImage2DEXT #-} +glCopyTextureSubImage2DEXT :: FuntypeCopyTextureSubImage2DEXT +glCopyTextureSubImage2DEXT = unsafePerformIO $ readIORef glrefCopyTextureSubImage2DEXT +{-# INLINE glCopyTextureSubImage2DEXT #-} +type FuntypeGetTextureImageEXT = + GLuint -> + GLenum -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTextureImageEXT :: FunPtr FuntypeGetTextureImageEXT -> FuntypeGetTextureImageEXT +glrefGetTextureImageEXT :: IORef FuntypeGetTextureImageEXT +glrefGetTextureImageEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTextureImageEXT #-} +glGetTextureImageEXT :: FuntypeGetTextureImageEXT +glGetTextureImageEXT = unsafePerformIO $ readIORef glrefGetTextureImageEXT +{-# INLINE glGetTextureImageEXT #-} +type FuntypeGetTextureParameterfvEXT = + GLuint -> + GLenum -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTextureParameterfvEXT :: FunPtr FuntypeGetTextureParameterfvEXT -> FuntypeGetTextureParameterfvEXT +glrefGetTextureParameterfvEXT :: IORef FuntypeGetTextureParameterfvEXT +glrefGetTextureParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTextureParameterfvEXT #-} +glGetTextureParameterfvEXT :: FuntypeGetTextureParameterfvEXT +glGetTextureParameterfvEXT = unsafePerformIO $ readIORef glrefGetTextureParameterfvEXT +{-# INLINE glGetTextureParameterfvEXT #-} +type FuntypeGetTextureParameterivEXT = + GLuint -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTextureParameterivEXT :: FunPtr FuntypeGetTextureParameterivEXT -> FuntypeGetTextureParameterivEXT +glrefGetTextureParameterivEXT :: IORef FuntypeGetTextureParameterivEXT +glrefGetTextureParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTextureParameterivEXT #-} +glGetTextureParameterivEXT :: FuntypeGetTextureParameterivEXT +glGetTextureParameterivEXT = unsafePerformIO $ readIORef glrefGetTextureParameterivEXT +{-# INLINE glGetTextureParameterivEXT #-} +type FuntypeGetTextureLevelParameterfvEXT = + GLuint -> + GLenum -> + GLint -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTextureLevelParameterfvEXT :: FunPtr FuntypeGetTextureLevelParameterfvEXT -> FuntypeGetTextureLevelParameterfvEXT +glrefGetTextureLevelParameterfvEXT :: IORef FuntypeGetTextureLevelParameterfvEXT +glrefGetTextureLevelParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTextureLevelParameterfvEXT #-} +glGetTextureLevelParameterfvEXT :: FuntypeGetTextureLevelParameterfvEXT +glGetTextureLevelParameterfvEXT = unsafePerformIO $ readIORef glrefGetTextureLevelParameterfvEXT +{-# INLINE glGetTextureLevelParameterfvEXT #-} +type FuntypeGetTextureLevelParameterivEXT = + GLuint -> + GLenum -> + GLint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTextureLevelParameterivEXT :: FunPtr FuntypeGetTextureLevelParameterivEXT -> FuntypeGetTextureLevelParameterivEXT +glrefGetTextureLevelParameterivEXT :: IORef FuntypeGetTextureLevelParameterivEXT +glrefGetTextureLevelParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTextureLevelParameterivEXT #-} +glGetTextureLevelParameterivEXT :: FuntypeGetTextureLevelParameterivEXT +glGetTextureLevelParameterivEXT = unsafePerformIO $ readIORef glrefGetTextureLevelParameterivEXT +{-# INLINE glGetTextureLevelParameterivEXT #-} +type FuntypeTextureImage3DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLsizei -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureImage3DEXT :: FunPtr FuntypeTextureImage3DEXT -> FuntypeTextureImage3DEXT +glrefTextureImage3DEXT :: IORef FuntypeTextureImage3DEXT +glrefTextureImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureImage3DEXT #-} +glTextureImage3DEXT :: FuntypeTextureImage3DEXT +glTextureImage3DEXT = unsafePerformIO $ readIORef glrefTextureImage3DEXT +{-# INLINE glTextureImage3DEXT #-} +type FuntypeTextureSubImage3DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLsizei -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureSubImage3DEXT :: FunPtr FuntypeTextureSubImage3DEXT -> FuntypeTextureSubImage3DEXT +glrefTextureSubImage3DEXT :: IORef FuntypeTextureSubImage3DEXT +glrefTextureSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureSubImage3DEXT #-} +glTextureSubImage3DEXT :: FuntypeTextureSubImage3DEXT +glTextureSubImage3DEXT = unsafePerformIO $ readIORef glrefTextureSubImage3DEXT +{-# INLINE glTextureSubImage3DEXT #-} +type FuntypeCopyTextureSubImage3DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyTextureSubImage3DEXT :: FunPtr FuntypeCopyTextureSubImage3DEXT -> FuntypeCopyTextureSubImage3DEXT +glrefCopyTextureSubImage3DEXT :: IORef FuntypeCopyTextureSubImage3DEXT +glrefCopyTextureSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyTextureSubImage3DEXT #-} +glCopyTextureSubImage3DEXT :: FuntypeCopyTextureSubImage3DEXT +glCopyTextureSubImage3DEXT = unsafePerformIO $ readIORef glrefCopyTextureSubImage3DEXT +{-# INLINE glCopyTextureSubImage3DEXT #-} +type FuntypeBindMultiTextureEXT = + GLenum -> + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindMultiTextureEXT :: FunPtr FuntypeBindMultiTextureEXT -> FuntypeBindMultiTextureEXT +glrefBindMultiTextureEXT :: IORef FuntypeBindMultiTextureEXT +glrefBindMultiTextureEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindMultiTextureEXT #-} +glBindMultiTextureEXT :: FuntypeBindMultiTextureEXT +glBindMultiTextureEXT = unsafePerformIO $ readIORef glrefBindMultiTextureEXT +{-# INLINE glBindMultiTextureEXT #-} +type FuntypeMultiTexCoordPointerEXT = + GLenum -> + GLint -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexCoordPointerEXT :: FunPtr FuntypeMultiTexCoordPointerEXT -> FuntypeMultiTexCoordPointerEXT +glrefMultiTexCoordPointerEXT :: IORef FuntypeMultiTexCoordPointerEXT +glrefMultiTexCoordPointerEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexCoordPointerEXT #-} +glMultiTexCoordPointerEXT :: FuntypeMultiTexCoordPointerEXT +glMultiTexCoordPointerEXT = unsafePerformIO $ readIORef glrefMultiTexCoordPointerEXT +{-# INLINE glMultiTexCoordPointerEXT #-} +type FuntypeMultiTexEnvfEXT = + GLenum -> + GLenum -> + GLenum -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexEnvfEXT :: FunPtr FuntypeMultiTexEnvfEXT -> FuntypeMultiTexEnvfEXT +glrefMultiTexEnvfEXT :: IORef FuntypeMultiTexEnvfEXT +glrefMultiTexEnvfEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexEnvfEXT #-} +glMultiTexEnvfEXT :: FuntypeMultiTexEnvfEXT +glMultiTexEnvfEXT = unsafePerformIO $ readIORef glrefMultiTexEnvfEXT +{-# INLINE glMultiTexEnvfEXT #-} +type FuntypeMultiTexEnvfvEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexEnvfvEXT :: FunPtr FuntypeMultiTexEnvfvEXT -> FuntypeMultiTexEnvfvEXT +glrefMultiTexEnvfvEXT :: IORef FuntypeMultiTexEnvfvEXT +glrefMultiTexEnvfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexEnvfvEXT #-} +glMultiTexEnvfvEXT :: FuntypeMultiTexEnvfvEXT +glMultiTexEnvfvEXT = unsafePerformIO $ readIORef glrefMultiTexEnvfvEXT +{-# INLINE glMultiTexEnvfvEXT #-} +type FuntypeMultiTexEnviEXT = + GLenum -> + GLenum -> + GLenum -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexEnviEXT :: FunPtr FuntypeMultiTexEnviEXT -> FuntypeMultiTexEnviEXT +glrefMultiTexEnviEXT :: IORef FuntypeMultiTexEnviEXT +glrefMultiTexEnviEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexEnviEXT #-} +glMultiTexEnviEXT :: FuntypeMultiTexEnviEXT +glMultiTexEnviEXT = unsafePerformIO $ readIORef glrefMultiTexEnviEXT +{-# INLINE glMultiTexEnviEXT #-} +type FuntypeMultiTexEnvivEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexEnvivEXT :: FunPtr FuntypeMultiTexEnvivEXT -> FuntypeMultiTexEnvivEXT +glrefMultiTexEnvivEXT :: IORef FuntypeMultiTexEnvivEXT +glrefMultiTexEnvivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexEnvivEXT #-} +glMultiTexEnvivEXT :: FuntypeMultiTexEnvivEXT +glMultiTexEnvivEXT = unsafePerformIO $ readIORef glrefMultiTexEnvivEXT +{-# INLINE glMultiTexEnvivEXT #-} +type FuntypeMultiTexGendEXT = + GLenum -> + GLenum -> + GLenum -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexGendEXT :: FunPtr FuntypeMultiTexGendEXT -> FuntypeMultiTexGendEXT +glrefMultiTexGendEXT :: IORef FuntypeMultiTexGendEXT +glrefMultiTexGendEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexGendEXT #-} +glMultiTexGendEXT :: FuntypeMultiTexGendEXT +glMultiTexGendEXT = unsafePerformIO $ readIORef glrefMultiTexGendEXT +{-# INLINE glMultiTexGendEXT #-} +type FuntypeMultiTexGendvEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexGendvEXT :: FunPtr FuntypeMultiTexGendvEXT -> FuntypeMultiTexGendvEXT +glrefMultiTexGendvEXT :: IORef FuntypeMultiTexGendvEXT +glrefMultiTexGendvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexGendvEXT #-} +glMultiTexGendvEXT :: FuntypeMultiTexGendvEXT +glMultiTexGendvEXT = unsafePerformIO $ readIORef glrefMultiTexGendvEXT +{-# INLINE glMultiTexGendvEXT #-} +type FuntypeMultiTexGenfEXT = + GLenum -> + GLenum -> + GLenum -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexGenfEXT :: FunPtr FuntypeMultiTexGenfEXT -> FuntypeMultiTexGenfEXT +glrefMultiTexGenfEXT :: IORef FuntypeMultiTexGenfEXT +glrefMultiTexGenfEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexGenfEXT #-} +glMultiTexGenfEXT :: FuntypeMultiTexGenfEXT +glMultiTexGenfEXT = unsafePerformIO $ readIORef glrefMultiTexGenfEXT +{-# INLINE glMultiTexGenfEXT #-} +type FuntypeMultiTexGenfvEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexGenfvEXT :: FunPtr FuntypeMultiTexGenfvEXT -> FuntypeMultiTexGenfvEXT +glrefMultiTexGenfvEXT :: IORef FuntypeMultiTexGenfvEXT +glrefMultiTexGenfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexGenfvEXT #-} +glMultiTexGenfvEXT :: FuntypeMultiTexGenfvEXT +glMultiTexGenfvEXT = unsafePerformIO $ readIORef glrefMultiTexGenfvEXT +{-# INLINE glMultiTexGenfvEXT #-} +type FuntypeMultiTexGeniEXT = + GLenum -> + GLenum -> + GLenum -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexGeniEXT :: FunPtr FuntypeMultiTexGeniEXT -> FuntypeMultiTexGeniEXT +glrefMultiTexGeniEXT :: IORef FuntypeMultiTexGeniEXT +glrefMultiTexGeniEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexGeniEXT #-} +glMultiTexGeniEXT :: FuntypeMultiTexGeniEXT +glMultiTexGeniEXT = unsafePerformIO $ readIORef glrefMultiTexGeniEXT +{-# INLINE glMultiTexGeniEXT #-} +type FuntypeMultiTexGenivEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexGenivEXT :: FunPtr FuntypeMultiTexGenivEXT -> FuntypeMultiTexGenivEXT +glrefMultiTexGenivEXT :: IORef FuntypeMultiTexGenivEXT +glrefMultiTexGenivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexGenivEXT #-} +glMultiTexGenivEXT :: FuntypeMultiTexGenivEXT +glMultiTexGenivEXT = unsafePerformIO $ readIORef glrefMultiTexGenivEXT +{-# INLINE glMultiTexGenivEXT #-} +type FuntypeGetMultiTexEnvfvEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexEnvfvEXT :: FunPtr FuntypeGetMultiTexEnvfvEXT -> FuntypeGetMultiTexEnvfvEXT +glrefGetMultiTexEnvfvEXT :: IORef FuntypeGetMultiTexEnvfvEXT +glrefGetMultiTexEnvfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexEnvfvEXT #-} +glGetMultiTexEnvfvEXT :: FuntypeGetMultiTexEnvfvEXT +glGetMultiTexEnvfvEXT = unsafePerformIO $ readIORef glrefGetMultiTexEnvfvEXT +{-# INLINE glGetMultiTexEnvfvEXT #-} +type FuntypeGetMultiTexEnvivEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexEnvivEXT :: FunPtr FuntypeGetMultiTexEnvivEXT -> FuntypeGetMultiTexEnvivEXT +glrefGetMultiTexEnvivEXT :: IORef FuntypeGetMultiTexEnvivEXT +glrefGetMultiTexEnvivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexEnvivEXT #-} +glGetMultiTexEnvivEXT :: FuntypeGetMultiTexEnvivEXT +glGetMultiTexEnvivEXT = unsafePerformIO $ readIORef glrefGetMultiTexEnvivEXT +{-# INLINE glGetMultiTexEnvivEXT #-} +type FuntypeGetMultiTexGendvEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexGendvEXT :: FunPtr FuntypeGetMultiTexGendvEXT -> FuntypeGetMultiTexGendvEXT +glrefGetMultiTexGendvEXT :: IORef FuntypeGetMultiTexGendvEXT +glrefGetMultiTexGendvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexGendvEXT #-} +glGetMultiTexGendvEXT :: FuntypeGetMultiTexGendvEXT +glGetMultiTexGendvEXT = unsafePerformIO $ readIORef glrefGetMultiTexGendvEXT +{-# INLINE glGetMultiTexGendvEXT #-} +type FuntypeGetMultiTexGenfvEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexGenfvEXT :: FunPtr FuntypeGetMultiTexGenfvEXT -> FuntypeGetMultiTexGenfvEXT +glrefGetMultiTexGenfvEXT :: IORef FuntypeGetMultiTexGenfvEXT +glrefGetMultiTexGenfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexGenfvEXT #-} +glGetMultiTexGenfvEXT :: FuntypeGetMultiTexGenfvEXT +glGetMultiTexGenfvEXT = unsafePerformIO $ readIORef glrefGetMultiTexGenfvEXT +{-# INLINE glGetMultiTexGenfvEXT #-} +type FuntypeGetMultiTexGenivEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexGenivEXT :: FunPtr FuntypeGetMultiTexGenivEXT -> FuntypeGetMultiTexGenivEXT +glrefGetMultiTexGenivEXT :: IORef FuntypeGetMultiTexGenivEXT +glrefGetMultiTexGenivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexGenivEXT #-} +glGetMultiTexGenivEXT :: FuntypeGetMultiTexGenivEXT +glGetMultiTexGenivEXT = unsafePerformIO $ readIORef glrefGetMultiTexGenivEXT +{-# INLINE glGetMultiTexGenivEXT #-} +type FuntypeMultiTexParameteriEXT = + GLenum -> + GLenum -> + GLenum -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexParameteriEXT :: FunPtr FuntypeMultiTexParameteriEXT -> FuntypeMultiTexParameteriEXT +glrefMultiTexParameteriEXT :: IORef FuntypeMultiTexParameteriEXT +glrefMultiTexParameteriEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexParameteriEXT #-} +glMultiTexParameteriEXT :: FuntypeMultiTexParameteriEXT +glMultiTexParameteriEXT = unsafePerformIO $ readIORef glrefMultiTexParameteriEXT +{-# INLINE glMultiTexParameteriEXT #-} +type FuntypeMultiTexParameterivEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexParameterivEXT :: FunPtr FuntypeMultiTexParameterivEXT -> FuntypeMultiTexParameterivEXT +glrefMultiTexParameterivEXT :: IORef FuntypeMultiTexParameterivEXT +glrefMultiTexParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexParameterivEXT #-} +glMultiTexParameterivEXT :: FuntypeMultiTexParameterivEXT +glMultiTexParameterivEXT = unsafePerformIO $ readIORef glrefMultiTexParameterivEXT +{-# INLINE glMultiTexParameterivEXT #-} +type FuntypeMultiTexParameterfEXT = + GLenum -> + GLenum -> + GLenum -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexParameterfEXT :: FunPtr FuntypeMultiTexParameterfEXT -> FuntypeMultiTexParameterfEXT +glrefMultiTexParameterfEXT :: IORef FuntypeMultiTexParameterfEXT +glrefMultiTexParameterfEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexParameterfEXT #-} +glMultiTexParameterfEXT :: FuntypeMultiTexParameterfEXT +glMultiTexParameterfEXT = unsafePerformIO $ readIORef glrefMultiTexParameterfEXT +{-# INLINE glMultiTexParameterfEXT #-} +type FuntypeMultiTexParameterfvEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexParameterfvEXT :: FunPtr FuntypeMultiTexParameterfvEXT -> FuntypeMultiTexParameterfvEXT +glrefMultiTexParameterfvEXT :: IORef FuntypeMultiTexParameterfvEXT +glrefMultiTexParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexParameterfvEXT #-} +glMultiTexParameterfvEXT :: FuntypeMultiTexParameterfvEXT +glMultiTexParameterfvEXT = unsafePerformIO $ readIORef glrefMultiTexParameterfvEXT +{-# INLINE glMultiTexParameterfvEXT #-} +type FuntypeMultiTexImage1DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexImage1DEXT :: FunPtr FuntypeMultiTexImage1DEXT -> FuntypeMultiTexImage1DEXT +glrefMultiTexImage1DEXT :: IORef FuntypeMultiTexImage1DEXT +glrefMultiTexImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexImage1DEXT #-} +glMultiTexImage1DEXT :: FuntypeMultiTexImage1DEXT +glMultiTexImage1DEXT = unsafePerformIO $ readIORef glrefMultiTexImage1DEXT +{-# INLINE glMultiTexImage1DEXT #-} +type FuntypeMultiTexImage2DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexImage2DEXT :: FunPtr FuntypeMultiTexImage2DEXT -> FuntypeMultiTexImage2DEXT +glrefMultiTexImage2DEXT :: IORef FuntypeMultiTexImage2DEXT +glrefMultiTexImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexImage2DEXT #-} +glMultiTexImage2DEXT :: FuntypeMultiTexImage2DEXT +glMultiTexImage2DEXT = unsafePerformIO $ readIORef glrefMultiTexImage2DEXT +{-# INLINE glMultiTexImage2DEXT #-} +type FuntypeMultiTexSubImage1DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexSubImage1DEXT :: FunPtr FuntypeMultiTexSubImage1DEXT -> FuntypeMultiTexSubImage1DEXT +glrefMultiTexSubImage1DEXT :: IORef FuntypeMultiTexSubImage1DEXT +glrefMultiTexSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexSubImage1DEXT #-} +glMultiTexSubImage1DEXT :: FuntypeMultiTexSubImage1DEXT +glMultiTexSubImage1DEXT = unsafePerformIO $ readIORef glrefMultiTexSubImage1DEXT +{-# INLINE glMultiTexSubImage1DEXT #-} +type FuntypeMultiTexSubImage2DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexSubImage2DEXT :: FunPtr FuntypeMultiTexSubImage2DEXT -> FuntypeMultiTexSubImage2DEXT +glrefMultiTexSubImage2DEXT :: IORef FuntypeMultiTexSubImage2DEXT +glrefMultiTexSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexSubImage2DEXT #-} +glMultiTexSubImage2DEXT :: FuntypeMultiTexSubImage2DEXT +glMultiTexSubImage2DEXT = unsafePerformIO $ readIORef glrefMultiTexSubImage2DEXT +{-# INLINE glMultiTexSubImage2DEXT #-} +type FuntypeCopyMultiTexImage1DEXT = + GLenum -> + GLenum -> + GLint -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyMultiTexImage1DEXT :: FunPtr FuntypeCopyMultiTexImage1DEXT -> FuntypeCopyMultiTexImage1DEXT +glrefCopyMultiTexImage1DEXT :: IORef FuntypeCopyMultiTexImage1DEXT +glrefCopyMultiTexImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyMultiTexImage1DEXT #-} +glCopyMultiTexImage1DEXT :: FuntypeCopyMultiTexImage1DEXT +glCopyMultiTexImage1DEXT = unsafePerformIO $ readIORef glrefCopyMultiTexImage1DEXT +{-# INLINE glCopyMultiTexImage1DEXT #-} +type FuntypeCopyMultiTexImage2DEXT = + GLenum -> + GLenum -> + GLint -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyMultiTexImage2DEXT :: FunPtr FuntypeCopyMultiTexImage2DEXT -> FuntypeCopyMultiTexImage2DEXT +glrefCopyMultiTexImage2DEXT :: IORef FuntypeCopyMultiTexImage2DEXT +glrefCopyMultiTexImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyMultiTexImage2DEXT #-} +glCopyMultiTexImage2DEXT :: FuntypeCopyMultiTexImage2DEXT +glCopyMultiTexImage2DEXT = unsafePerformIO $ readIORef glrefCopyMultiTexImage2DEXT +{-# INLINE glCopyMultiTexImage2DEXT #-} +type FuntypeCopyMultiTexSubImage1DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyMultiTexSubImage1DEXT :: FunPtr FuntypeCopyMultiTexSubImage1DEXT -> FuntypeCopyMultiTexSubImage1DEXT +glrefCopyMultiTexSubImage1DEXT :: IORef FuntypeCopyMultiTexSubImage1DEXT +glrefCopyMultiTexSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyMultiTexSubImage1DEXT #-} +glCopyMultiTexSubImage1DEXT :: FuntypeCopyMultiTexSubImage1DEXT +glCopyMultiTexSubImage1DEXT = unsafePerformIO $ readIORef glrefCopyMultiTexSubImage1DEXT +{-# INLINE glCopyMultiTexSubImage1DEXT #-} +type FuntypeCopyMultiTexSubImage2DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyMultiTexSubImage2DEXT :: FunPtr FuntypeCopyMultiTexSubImage2DEXT -> FuntypeCopyMultiTexSubImage2DEXT +glrefCopyMultiTexSubImage2DEXT :: IORef FuntypeCopyMultiTexSubImage2DEXT +glrefCopyMultiTexSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyMultiTexSubImage2DEXT #-} +glCopyMultiTexSubImage2DEXT :: FuntypeCopyMultiTexSubImage2DEXT +glCopyMultiTexSubImage2DEXT = unsafePerformIO $ readIORef glrefCopyMultiTexSubImage2DEXT +{-# INLINE glCopyMultiTexSubImage2DEXT #-} +type FuntypeGetMultiTexImageEXT = + GLenum -> + GLenum -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexImageEXT :: FunPtr FuntypeGetMultiTexImageEXT -> FuntypeGetMultiTexImageEXT +glrefGetMultiTexImageEXT :: IORef FuntypeGetMultiTexImageEXT +glrefGetMultiTexImageEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexImageEXT #-} +glGetMultiTexImageEXT :: FuntypeGetMultiTexImageEXT +glGetMultiTexImageEXT = unsafePerformIO $ readIORef glrefGetMultiTexImageEXT +{-# INLINE glGetMultiTexImageEXT #-} +type FuntypeGetMultiTexParameterfvEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexParameterfvEXT :: FunPtr FuntypeGetMultiTexParameterfvEXT -> FuntypeGetMultiTexParameterfvEXT +glrefGetMultiTexParameterfvEXT :: IORef FuntypeGetMultiTexParameterfvEXT +glrefGetMultiTexParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexParameterfvEXT #-} +glGetMultiTexParameterfvEXT :: FuntypeGetMultiTexParameterfvEXT +glGetMultiTexParameterfvEXT = unsafePerformIO $ readIORef glrefGetMultiTexParameterfvEXT +{-# INLINE glGetMultiTexParameterfvEXT #-} +type FuntypeGetMultiTexParameterivEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexParameterivEXT :: FunPtr FuntypeGetMultiTexParameterivEXT -> FuntypeGetMultiTexParameterivEXT +glrefGetMultiTexParameterivEXT :: IORef FuntypeGetMultiTexParameterivEXT +glrefGetMultiTexParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexParameterivEXT #-} +glGetMultiTexParameterivEXT :: FuntypeGetMultiTexParameterivEXT +glGetMultiTexParameterivEXT = unsafePerformIO $ readIORef glrefGetMultiTexParameterivEXT +{-# INLINE glGetMultiTexParameterivEXT #-} +type FuntypeGetMultiTexLevelParameterfvEXT = + GLenum -> + GLenum -> + GLint -> + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexLevelParameterfvEXT :: FunPtr FuntypeGetMultiTexLevelParameterfvEXT -> FuntypeGetMultiTexLevelParameterfvEXT +glrefGetMultiTexLevelParameterfvEXT :: IORef FuntypeGetMultiTexLevelParameterfvEXT +glrefGetMultiTexLevelParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexLevelParameterfvEXT #-} +glGetMultiTexLevelParameterfvEXT :: FuntypeGetMultiTexLevelParameterfvEXT +glGetMultiTexLevelParameterfvEXT = unsafePerformIO $ readIORef glrefGetMultiTexLevelParameterfvEXT +{-# INLINE glGetMultiTexLevelParameterfvEXT #-} +type FuntypeGetMultiTexLevelParameterivEXT = + GLenum -> + GLenum -> + GLint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexLevelParameterivEXT :: FunPtr FuntypeGetMultiTexLevelParameterivEXT -> FuntypeGetMultiTexLevelParameterivEXT +glrefGetMultiTexLevelParameterivEXT :: IORef FuntypeGetMultiTexLevelParameterivEXT +glrefGetMultiTexLevelParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexLevelParameterivEXT #-} +glGetMultiTexLevelParameterivEXT :: FuntypeGetMultiTexLevelParameterivEXT +glGetMultiTexLevelParameterivEXT = unsafePerformIO $ readIORef glrefGetMultiTexLevelParameterivEXT +{-# INLINE glGetMultiTexLevelParameterivEXT #-} +type FuntypeMultiTexImage3DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLsizei -> + GLint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexImage3DEXT :: FunPtr FuntypeMultiTexImage3DEXT -> FuntypeMultiTexImage3DEXT +glrefMultiTexImage3DEXT :: IORef FuntypeMultiTexImage3DEXT +glrefMultiTexImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexImage3DEXT #-} +glMultiTexImage3DEXT :: FuntypeMultiTexImage3DEXT +glMultiTexImage3DEXT = unsafePerformIO $ readIORef glrefMultiTexImage3DEXT +{-# INLINE glMultiTexImage3DEXT #-} +type FuntypeMultiTexSubImage3DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLsizei -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexSubImage3DEXT :: FunPtr FuntypeMultiTexSubImage3DEXT -> FuntypeMultiTexSubImage3DEXT +glrefMultiTexSubImage3DEXT :: IORef FuntypeMultiTexSubImage3DEXT +glrefMultiTexSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexSubImage3DEXT #-} +glMultiTexSubImage3DEXT :: FuntypeMultiTexSubImage3DEXT +glMultiTexSubImage3DEXT = unsafePerformIO $ readIORef glrefMultiTexSubImage3DEXT +{-# INLINE glMultiTexSubImage3DEXT #-} +type FuntypeCopyMultiTexSubImage3DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCopyMultiTexSubImage3DEXT :: FunPtr FuntypeCopyMultiTexSubImage3DEXT -> FuntypeCopyMultiTexSubImage3DEXT +glrefCopyMultiTexSubImage3DEXT :: IORef FuntypeCopyMultiTexSubImage3DEXT +glrefCopyMultiTexSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCopyMultiTexSubImage3DEXT #-} +glCopyMultiTexSubImage3DEXT :: FuntypeCopyMultiTexSubImage3DEXT +glCopyMultiTexSubImage3DEXT = unsafePerformIO $ readIORef glrefCopyMultiTexSubImage3DEXT +{-# INLINE glCopyMultiTexSubImage3DEXT #-} +type FuntypeEnableClientStateIndexedEXT = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynEnableClientStateIndexedEXT :: FunPtr FuntypeEnableClientStateIndexedEXT -> FuntypeEnableClientStateIndexedEXT +glrefEnableClientStateIndexedEXT :: IORef FuntypeEnableClientStateIndexedEXT +glrefEnableClientStateIndexedEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefEnableClientStateIndexedEXT #-} +glEnableClientStateIndexedEXT :: FuntypeEnableClientStateIndexedEXT +glEnableClientStateIndexedEXT = unsafePerformIO $ readIORef glrefEnableClientStateIndexedEXT +{-# INLINE glEnableClientStateIndexedEXT #-} +type FuntypeDisableClientStateIndexedEXT = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDisableClientStateIndexedEXT :: FunPtr FuntypeDisableClientStateIndexedEXT -> FuntypeDisableClientStateIndexedEXT +glrefDisableClientStateIndexedEXT :: IORef FuntypeDisableClientStateIndexedEXT +glrefDisableClientStateIndexedEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDisableClientStateIndexedEXT #-} +glDisableClientStateIndexedEXT :: FuntypeDisableClientStateIndexedEXT +glDisableClientStateIndexedEXT = unsafePerformIO $ readIORef glrefDisableClientStateIndexedEXT +{-# INLINE glDisableClientStateIndexedEXT #-} +type FuntypeGetFloatIndexedvEXT = + GLenum -> + GLuint -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetFloatIndexedvEXT :: FunPtr FuntypeGetFloatIndexedvEXT -> FuntypeGetFloatIndexedvEXT +glrefGetFloatIndexedvEXT :: IORef FuntypeGetFloatIndexedvEXT +glrefGetFloatIndexedvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetFloatIndexedvEXT #-} +glGetFloatIndexedvEXT :: FuntypeGetFloatIndexedvEXT +glGetFloatIndexedvEXT = unsafePerformIO $ readIORef glrefGetFloatIndexedvEXT +{-# INLINE glGetFloatIndexedvEXT #-} +type FuntypeGetDoubleIndexedvEXT = + GLenum -> + GLuint -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetDoubleIndexedvEXT :: FunPtr FuntypeGetDoubleIndexedvEXT -> FuntypeGetDoubleIndexedvEXT +glrefGetDoubleIndexedvEXT :: IORef FuntypeGetDoubleIndexedvEXT +glrefGetDoubleIndexedvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetDoubleIndexedvEXT #-} +glGetDoubleIndexedvEXT :: FuntypeGetDoubleIndexedvEXT +glGetDoubleIndexedvEXT = unsafePerformIO $ readIORef glrefGetDoubleIndexedvEXT +{-# INLINE glGetDoubleIndexedvEXT #-} +type FuntypeGetPointerIndexedvEXT = + GLenum -> + GLuint -> + Ptr (Ptr ()) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetPointerIndexedvEXT :: FunPtr FuntypeGetPointerIndexedvEXT -> FuntypeGetPointerIndexedvEXT +glrefGetPointerIndexedvEXT :: IORef FuntypeGetPointerIndexedvEXT +glrefGetPointerIndexedvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetPointerIndexedvEXT #-} +glGetPointerIndexedvEXT :: FuntypeGetPointerIndexedvEXT +glGetPointerIndexedvEXT = unsafePerformIO $ readIORef glrefGetPointerIndexedvEXT +{-# INLINE glGetPointerIndexedvEXT #-} +type FuntypeEnableIndexedEXT = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynEnableIndexedEXT :: FunPtr FuntypeEnableIndexedEXT -> FuntypeEnableIndexedEXT +glrefEnableIndexedEXT :: IORef FuntypeEnableIndexedEXT +glrefEnableIndexedEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefEnableIndexedEXT #-} +glEnableIndexedEXT :: FuntypeEnableIndexedEXT +glEnableIndexedEXT = unsafePerformIO $ readIORef glrefEnableIndexedEXT +{-# INLINE glEnableIndexedEXT #-} +type FuntypeDisableIndexedEXT = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDisableIndexedEXT :: FunPtr FuntypeDisableIndexedEXT -> FuntypeDisableIndexedEXT +glrefDisableIndexedEXT :: IORef FuntypeDisableIndexedEXT +glrefDisableIndexedEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDisableIndexedEXT #-} +glDisableIndexedEXT :: FuntypeDisableIndexedEXT +glDisableIndexedEXT = unsafePerformIO $ readIORef glrefDisableIndexedEXT +{-# INLINE glDisableIndexedEXT #-} +type FuntypeIsEnabledIndexedEXT = + GLenum -> + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsEnabledIndexedEXT :: FunPtr FuntypeIsEnabledIndexedEXT -> FuntypeIsEnabledIndexedEXT +glrefIsEnabledIndexedEXT :: IORef FuntypeIsEnabledIndexedEXT +glrefIsEnabledIndexedEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsEnabledIndexedEXT #-} +glIsEnabledIndexedEXT :: FuntypeIsEnabledIndexedEXT +glIsEnabledIndexedEXT = unsafePerformIO $ readIORef glrefIsEnabledIndexedEXT +{-# INLINE glIsEnabledIndexedEXT #-} +type FuntypeGetIntegerIndexedvEXT = + GLenum -> + GLuint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetIntegerIndexedvEXT :: FunPtr FuntypeGetIntegerIndexedvEXT -> FuntypeGetIntegerIndexedvEXT +glrefGetIntegerIndexedvEXT :: IORef FuntypeGetIntegerIndexedvEXT +glrefGetIntegerIndexedvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetIntegerIndexedvEXT #-} +glGetIntegerIndexedvEXT :: FuntypeGetIntegerIndexedvEXT +glGetIntegerIndexedvEXT = unsafePerformIO $ readIORef glrefGetIntegerIndexedvEXT +{-# INLINE glGetIntegerIndexedvEXT #-} +type FuntypeGetBooleanIndexedvEXT = + GLenum -> + GLuint -> + Ptr (GLboolean) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetBooleanIndexedvEXT :: FunPtr FuntypeGetBooleanIndexedvEXT -> FuntypeGetBooleanIndexedvEXT +glrefGetBooleanIndexedvEXT :: IORef FuntypeGetBooleanIndexedvEXT +glrefGetBooleanIndexedvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetBooleanIndexedvEXT #-} +glGetBooleanIndexedvEXT :: FuntypeGetBooleanIndexedvEXT +glGetBooleanIndexedvEXT = unsafePerformIO $ readIORef glrefGetBooleanIndexedvEXT +{-# INLINE glGetBooleanIndexedvEXT #-} +type FuntypeCompressedTextureImage3DEXT = + GLuint -> + GLenum -> + GLint -> + GLenum -> + GLsizei -> + GLsizei -> + GLsizei -> + GLint -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTextureImage3DEXT :: FunPtr FuntypeCompressedTextureImage3DEXT -> FuntypeCompressedTextureImage3DEXT +glrefCompressedTextureImage3DEXT :: IORef FuntypeCompressedTextureImage3DEXT +glrefCompressedTextureImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTextureImage3DEXT #-} +glCompressedTextureImage3DEXT :: FuntypeCompressedTextureImage3DEXT +glCompressedTextureImage3DEXT = unsafePerformIO $ readIORef glrefCompressedTextureImage3DEXT +{-# INLINE glCompressedTextureImage3DEXT #-} +type FuntypeCompressedTextureImage2DEXT = + GLuint -> + GLenum -> + GLint -> + GLenum -> + GLsizei -> + GLsizei -> + GLint -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTextureImage2DEXT :: FunPtr FuntypeCompressedTextureImage2DEXT -> FuntypeCompressedTextureImage2DEXT +glrefCompressedTextureImage2DEXT :: IORef FuntypeCompressedTextureImage2DEXT +glrefCompressedTextureImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTextureImage2DEXT #-} +glCompressedTextureImage2DEXT :: FuntypeCompressedTextureImage2DEXT +glCompressedTextureImage2DEXT = unsafePerformIO $ readIORef glrefCompressedTextureImage2DEXT +{-# INLINE glCompressedTextureImage2DEXT #-} +type FuntypeCompressedTextureImage1DEXT = + GLuint -> + GLenum -> + GLint -> + GLenum -> + GLsizei -> + GLint -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTextureImage1DEXT :: FunPtr FuntypeCompressedTextureImage1DEXT -> FuntypeCompressedTextureImage1DEXT +glrefCompressedTextureImage1DEXT :: IORef FuntypeCompressedTextureImage1DEXT +glrefCompressedTextureImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTextureImage1DEXT #-} +glCompressedTextureImage1DEXT :: FuntypeCompressedTextureImage1DEXT +glCompressedTextureImage1DEXT = unsafePerformIO $ readIORef glrefCompressedTextureImage1DEXT +{-# INLINE glCompressedTextureImage1DEXT #-} +type FuntypeCompressedTextureSubImage3DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLsizei -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTextureSubImage3DEXT :: FunPtr FuntypeCompressedTextureSubImage3DEXT -> FuntypeCompressedTextureSubImage3DEXT +glrefCompressedTextureSubImage3DEXT :: IORef FuntypeCompressedTextureSubImage3DEXT +glrefCompressedTextureSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTextureSubImage3DEXT #-} +glCompressedTextureSubImage3DEXT :: FuntypeCompressedTextureSubImage3DEXT +glCompressedTextureSubImage3DEXT = unsafePerformIO $ readIORef glrefCompressedTextureSubImage3DEXT +{-# INLINE glCompressedTextureSubImage3DEXT #-} +type FuntypeCompressedTextureSubImage2DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTextureSubImage2DEXT :: FunPtr FuntypeCompressedTextureSubImage2DEXT -> FuntypeCompressedTextureSubImage2DEXT +glrefCompressedTextureSubImage2DEXT :: IORef FuntypeCompressedTextureSubImage2DEXT +glrefCompressedTextureSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTextureSubImage2DEXT #-} +glCompressedTextureSubImage2DEXT :: FuntypeCompressedTextureSubImage2DEXT +glCompressedTextureSubImage2DEXT = unsafePerformIO $ readIORef glrefCompressedTextureSubImage2DEXT +{-# INLINE glCompressedTextureSubImage2DEXT #-} +type FuntypeCompressedTextureSubImage1DEXT = + GLuint -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedTextureSubImage1DEXT :: FunPtr FuntypeCompressedTextureSubImage1DEXT -> FuntypeCompressedTextureSubImage1DEXT +glrefCompressedTextureSubImage1DEXT :: IORef FuntypeCompressedTextureSubImage1DEXT +glrefCompressedTextureSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedTextureSubImage1DEXT #-} +glCompressedTextureSubImage1DEXT :: FuntypeCompressedTextureSubImage1DEXT +glCompressedTextureSubImage1DEXT = unsafePerformIO $ readIORef glrefCompressedTextureSubImage1DEXT +{-# INLINE glCompressedTextureSubImage1DEXT #-} +type FuntypeGetCompressedTextureImageEXT = + GLuint -> + GLenum -> + GLint -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetCompressedTextureImageEXT :: FunPtr FuntypeGetCompressedTextureImageEXT -> FuntypeGetCompressedTextureImageEXT +glrefGetCompressedTextureImageEXT :: IORef FuntypeGetCompressedTextureImageEXT +glrefGetCompressedTextureImageEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetCompressedTextureImageEXT #-} +glGetCompressedTextureImageEXT :: FuntypeGetCompressedTextureImageEXT +glGetCompressedTextureImageEXT = unsafePerformIO $ readIORef glrefGetCompressedTextureImageEXT +{-# INLINE glGetCompressedTextureImageEXT #-} +type FuntypeCompressedMultiTexImage3DEXT = + GLenum -> + GLenum -> + GLint -> + GLenum -> + GLsizei -> + GLsizei -> + GLsizei -> + GLint -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedMultiTexImage3DEXT :: FunPtr FuntypeCompressedMultiTexImage3DEXT -> FuntypeCompressedMultiTexImage3DEXT +glrefCompressedMultiTexImage3DEXT :: IORef FuntypeCompressedMultiTexImage3DEXT +glrefCompressedMultiTexImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedMultiTexImage3DEXT #-} +glCompressedMultiTexImage3DEXT :: FuntypeCompressedMultiTexImage3DEXT +glCompressedMultiTexImage3DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexImage3DEXT +{-# INLINE glCompressedMultiTexImage3DEXT #-} +type FuntypeCompressedMultiTexImage2DEXT = + GLenum -> + GLenum -> + GLint -> + GLenum -> + GLsizei -> + GLsizei -> + GLint -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedMultiTexImage2DEXT :: FunPtr FuntypeCompressedMultiTexImage2DEXT -> FuntypeCompressedMultiTexImage2DEXT +glrefCompressedMultiTexImage2DEXT :: IORef FuntypeCompressedMultiTexImage2DEXT +glrefCompressedMultiTexImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedMultiTexImage2DEXT #-} +glCompressedMultiTexImage2DEXT :: FuntypeCompressedMultiTexImage2DEXT +glCompressedMultiTexImage2DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexImage2DEXT +{-# INLINE glCompressedMultiTexImage2DEXT #-} +type FuntypeCompressedMultiTexImage1DEXT = + GLenum -> + GLenum -> + GLint -> + GLenum -> + GLsizei -> + GLint -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedMultiTexImage1DEXT :: FunPtr FuntypeCompressedMultiTexImage1DEXT -> FuntypeCompressedMultiTexImage1DEXT +glrefCompressedMultiTexImage1DEXT :: IORef FuntypeCompressedMultiTexImage1DEXT +glrefCompressedMultiTexImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedMultiTexImage1DEXT #-} +glCompressedMultiTexImage1DEXT :: FuntypeCompressedMultiTexImage1DEXT +glCompressedMultiTexImage1DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexImage1DEXT +{-# INLINE glCompressedMultiTexImage1DEXT #-} +type FuntypeCompressedMultiTexSubImage3DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLsizei -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedMultiTexSubImage3DEXT :: FunPtr FuntypeCompressedMultiTexSubImage3DEXT -> FuntypeCompressedMultiTexSubImage3DEXT +glrefCompressedMultiTexSubImage3DEXT :: IORef FuntypeCompressedMultiTexSubImage3DEXT +glrefCompressedMultiTexSubImage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedMultiTexSubImage3DEXT #-} +glCompressedMultiTexSubImage3DEXT :: FuntypeCompressedMultiTexSubImage3DEXT +glCompressedMultiTexSubImage3DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexSubImage3DEXT +{-# INLINE glCompressedMultiTexSubImage3DEXT #-} +type FuntypeCompressedMultiTexSubImage2DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedMultiTexSubImage2DEXT :: FunPtr FuntypeCompressedMultiTexSubImage2DEXT -> FuntypeCompressedMultiTexSubImage2DEXT +glrefCompressedMultiTexSubImage2DEXT :: IORef FuntypeCompressedMultiTexSubImage2DEXT +glrefCompressedMultiTexSubImage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedMultiTexSubImage2DEXT #-} +glCompressedMultiTexSubImage2DEXT :: FuntypeCompressedMultiTexSubImage2DEXT +glCompressedMultiTexSubImage2DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexSubImage2DEXT +{-# INLINE glCompressedMultiTexSubImage2DEXT #-} +type FuntypeCompressedMultiTexSubImage1DEXT = + GLenum -> + GLenum -> + GLint -> + GLint -> + GLsizei -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCompressedMultiTexSubImage1DEXT :: FunPtr FuntypeCompressedMultiTexSubImage1DEXT -> FuntypeCompressedMultiTexSubImage1DEXT +glrefCompressedMultiTexSubImage1DEXT :: IORef FuntypeCompressedMultiTexSubImage1DEXT +glrefCompressedMultiTexSubImage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCompressedMultiTexSubImage1DEXT #-} +glCompressedMultiTexSubImage1DEXT :: FuntypeCompressedMultiTexSubImage1DEXT +glCompressedMultiTexSubImage1DEXT = unsafePerformIO $ readIORef glrefCompressedMultiTexSubImage1DEXT +{-# INLINE glCompressedMultiTexSubImage1DEXT #-} +type FuntypeGetCompressedMultiTexImageEXT = + GLenum -> + GLenum -> + GLint -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetCompressedMultiTexImageEXT :: FunPtr FuntypeGetCompressedMultiTexImageEXT -> FuntypeGetCompressedMultiTexImageEXT +glrefGetCompressedMultiTexImageEXT :: IORef FuntypeGetCompressedMultiTexImageEXT +glrefGetCompressedMultiTexImageEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetCompressedMultiTexImageEXT #-} +glGetCompressedMultiTexImageEXT :: FuntypeGetCompressedMultiTexImageEXT +glGetCompressedMultiTexImageEXT = unsafePerformIO $ readIORef glrefGetCompressedMultiTexImageEXT +{-# INLINE glGetCompressedMultiTexImageEXT #-} +type FuntypeMatrixLoadTransposefEXT = + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixLoadTransposefEXT :: FunPtr FuntypeMatrixLoadTransposefEXT -> FuntypeMatrixLoadTransposefEXT +glrefMatrixLoadTransposefEXT :: IORef FuntypeMatrixLoadTransposefEXT +glrefMatrixLoadTransposefEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixLoadTransposefEXT #-} +glMatrixLoadTransposefEXT :: FuntypeMatrixLoadTransposefEXT +glMatrixLoadTransposefEXT = unsafePerformIO $ readIORef glrefMatrixLoadTransposefEXT +{-# INLINE glMatrixLoadTransposefEXT #-} +type FuntypeMatrixLoadTransposedEXT = + GLenum -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixLoadTransposedEXT :: FunPtr FuntypeMatrixLoadTransposedEXT -> FuntypeMatrixLoadTransposedEXT +glrefMatrixLoadTransposedEXT :: IORef FuntypeMatrixLoadTransposedEXT +glrefMatrixLoadTransposedEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixLoadTransposedEXT #-} +glMatrixLoadTransposedEXT :: FuntypeMatrixLoadTransposedEXT +glMatrixLoadTransposedEXT = unsafePerformIO $ readIORef glrefMatrixLoadTransposedEXT +{-# INLINE glMatrixLoadTransposedEXT #-} +type FuntypeMatrixMultTransposefEXT = + GLenum -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixMultTransposefEXT :: FunPtr FuntypeMatrixMultTransposefEXT -> FuntypeMatrixMultTransposefEXT +glrefMatrixMultTransposefEXT :: IORef FuntypeMatrixMultTransposefEXT +glrefMatrixMultTransposefEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixMultTransposefEXT #-} +glMatrixMultTransposefEXT :: FuntypeMatrixMultTransposefEXT +glMatrixMultTransposefEXT = unsafePerformIO $ readIORef glrefMatrixMultTransposefEXT +{-# INLINE glMatrixMultTransposefEXT #-} +type FuntypeMatrixMultTransposedEXT = + GLenum -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMatrixMultTransposedEXT :: FunPtr FuntypeMatrixMultTransposedEXT -> FuntypeMatrixMultTransposedEXT +glrefMatrixMultTransposedEXT :: IORef FuntypeMatrixMultTransposedEXT +glrefMatrixMultTransposedEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMatrixMultTransposedEXT #-} +glMatrixMultTransposedEXT :: FuntypeMatrixMultTransposedEXT +glMatrixMultTransposedEXT = unsafePerformIO $ readIORef glrefMatrixMultTransposedEXT +{-# INLINE glMatrixMultTransposedEXT #-} +type FuntypeNamedBufferDataEXT = + GLuint -> + GLsizeiptr -> + Ptr () -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedBufferDataEXT :: FunPtr FuntypeNamedBufferDataEXT -> FuntypeNamedBufferDataEXT +glrefNamedBufferDataEXT :: IORef FuntypeNamedBufferDataEXT +glrefNamedBufferDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedBufferDataEXT #-} +glNamedBufferDataEXT :: FuntypeNamedBufferDataEXT +glNamedBufferDataEXT = unsafePerformIO $ readIORef glrefNamedBufferDataEXT +{-# INLINE glNamedBufferDataEXT #-} +type FuntypeNamedBufferSubDataEXT = + GLuint -> + GLintptr -> + GLsizeiptr -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedBufferSubDataEXT :: FunPtr FuntypeNamedBufferSubDataEXT -> FuntypeNamedBufferSubDataEXT +glrefNamedBufferSubDataEXT :: IORef FuntypeNamedBufferSubDataEXT +glrefNamedBufferSubDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedBufferSubDataEXT #-} +glNamedBufferSubDataEXT :: FuntypeNamedBufferSubDataEXT +glNamedBufferSubDataEXT = unsafePerformIO $ readIORef glrefNamedBufferSubDataEXT +{-# INLINE glNamedBufferSubDataEXT #-} +type FuntypeMapNamedBufferEXT = + GLuint -> + GLenum -> + IO ( Ptr () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMapNamedBufferEXT :: FunPtr FuntypeMapNamedBufferEXT -> FuntypeMapNamedBufferEXT +glrefMapNamedBufferEXT :: IORef FuntypeMapNamedBufferEXT +glrefMapNamedBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMapNamedBufferEXT #-} +glMapNamedBufferEXT :: FuntypeMapNamedBufferEXT +glMapNamedBufferEXT = unsafePerformIO $ readIORef glrefMapNamedBufferEXT +{-# INLINE glMapNamedBufferEXT #-} +type FuntypeUnmapNamedBufferEXT = + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUnmapNamedBufferEXT :: FunPtr FuntypeUnmapNamedBufferEXT -> FuntypeUnmapNamedBufferEXT +glrefUnmapNamedBufferEXT :: IORef FuntypeUnmapNamedBufferEXT +glrefUnmapNamedBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUnmapNamedBufferEXT #-} +glUnmapNamedBufferEXT :: FuntypeUnmapNamedBufferEXT +glUnmapNamedBufferEXT = unsafePerformIO $ readIORef glrefUnmapNamedBufferEXT +{-# INLINE glUnmapNamedBufferEXT #-} +type FuntypeGetNamedBufferParameterivEXT = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedBufferParameterivEXT :: FunPtr FuntypeGetNamedBufferParameterivEXT -> FuntypeGetNamedBufferParameterivEXT +glrefGetNamedBufferParameterivEXT :: IORef FuntypeGetNamedBufferParameterivEXT +glrefGetNamedBufferParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedBufferParameterivEXT #-} +glGetNamedBufferParameterivEXT :: FuntypeGetNamedBufferParameterivEXT +glGetNamedBufferParameterivEXT = unsafePerformIO $ readIORef glrefGetNamedBufferParameterivEXT +{-# INLINE glGetNamedBufferParameterivEXT #-} +type FuntypeGetNamedBufferPointervEXT = + GLuint -> + GLenum -> + Ptr (Ptr ()) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedBufferPointervEXT :: FunPtr FuntypeGetNamedBufferPointervEXT -> FuntypeGetNamedBufferPointervEXT +glrefGetNamedBufferPointervEXT :: IORef FuntypeGetNamedBufferPointervEXT +glrefGetNamedBufferPointervEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedBufferPointervEXT #-} +glGetNamedBufferPointervEXT :: FuntypeGetNamedBufferPointervEXT +glGetNamedBufferPointervEXT = unsafePerformIO $ readIORef glrefGetNamedBufferPointervEXT +{-# INLINE glGetNamedBufferPointervEXT #-} +type FuntypeGetNamedBufferSubDataEXT = + GLuint -> + GLintptr -> + GLsizeiptr -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedBufferSubDataEXT :: FunPtr FuntypeGetNamedBufferSubDataEXT -> FuntypeGetNamedBufferSubDataEXT +glrefGetNamedBufferSubDataEXT :: IORef FuntypeGetNamedBufferSubDataEXT +glrefGetNamedBufferSubDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedBufferSubDataEXT #-} +glGetNamedBufferSubDataEXT :: FuntypeGetNamedBufferSubDataEXT +glGetNamedBufferSubDataEXT = unsafePerformIO $ readIORef glrefGetNamedBufferSubDataEXT +{-# INLINE glGetNamedBufferSubDataEXT #-} +type FuntypeProgramUniform1fEXT = + GLuint -> + GLint -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1fEXT :: FunPtr FuntypeProgramUniform1fEXT -> FuntypeProgramUniform1fEXT +glrefProgramUniform1fEXT :: IORef FuntypeProgramUniform1fEXT +glrefProgramUniform1fEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1fEXT #-} +glProgramUniform1fEXT :: FuntypeProgramUniform1fEXT +glProgramUniform1fEXT = unsafePerformIO $ readIORef glrefProgramUniform1fEXT +{-# INLINE glProgramUniform1fEXT #-} +type FuntypeProgramUniform2fEXT = + GLuint -> + GLint -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2fEXT :: FunPtr FuntypeProgramUniform2fEXT -> FuntypeProgramUniform2fEXT +glrefProgramUniform2fEXT :: IORef FuntypeProgramUniform2fEXT +glrefProgramUniform2fEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2fEXT #-} +glProgramUniform2fEXT :: FuntypeProgramUniform2fEXT +glProgramUniform2fEXT = unsafePerformIO $ readIORef glrefProgramUniform2fEXT +{-# INLINE glProgramUniform2fEXT #-} +type FuntypeProgramUniform3fEXT = + GLuint -> + GLint -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3fEXT :: FunPtr FuntypeProgramUniform3fEXT -> FuntypeProgramUniform3fEXT +glrefProgramUniform3fEXT :: IORef FuntypeProgramUniform3fEXT +glrefProgramUniform3fEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3fEXT #-} +glProgramUniform3fEXT :: FuntypeProgramUniform3fEXT +glProgramUniform3fEXT = unsafePerformIO $ readIORef glrefProgramUniform3fEXT +{-# INLINE glProgramUniform3fEXT #-} +type FuntypeProgramUniform4fEXT = + GLuint -> + GLint -> + GLfloat -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4fEXT :: FunPtr FuntypeProgramUniform4fEXT -> FuntypeProgramUniform4fEXT +glrefProgramUniform4fEXT :: IORef FuntypeProgramUniform4fEXT +glrefProgramUniform4fEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4fEXT #-} +glProgramUniform4fEXT :: FuntypeProgramUniform4fEXT +glProgramUniform4fEXT = unsafePerformIO $ readIORef glrefProgramUniform4fEXT +{-# INLINE glProgramUniform4fEXT #-} +type FuntypeProgramUniform1iEXT = + GLuint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1iEXT :: FunPtr FuntypeProgramUniform1iEXT -> FuntypeProgramUniform1iEXT +glrefProgramUniform1iEXT :: IORef FuntypeProgramUniform1iEXT +glrefProgramUniform1iEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1iEXT #-} +glProgramUniform1iEXT :: FuntypeProgramUniform1iEXT +glProgramUniform1iEXT = unsafePerformIO $ readIORef glrefProgramUniform1iEXT +{-# INLINE glProgramUniform1iEXT #-} +type FuntypeProgramUniform2iEXT = + GLuint -> + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2iEXT :: FunPtr FuntypeProgramUniform2iEXT -> FuntypeProgramUniform2iEXT +glrefProgramUniform2iEXT :: IORef FuntypeProgramUniform2iEXT +glrefProgramUniform2iEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2iEXT #-} +glProgramUniform2iEXT :: FuntypeProgramUniform2iEXT +glProgramUniform2iEXT = unsafePerformIO $ readIORef glrefProgramUniform2iEXT +{-# INLINE glProgramUniform2iEXT #-} +type FuntypeProgramUniform3iEXT = + GLuint -> + GLint -> + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3iEXT :: FunPtr FuntypeProgramUniform3iEXT -> FuntypeProgramUniform3iEXT +glrefProgramUniform3iEXT :: IORef FuntypeProgramUniform3iEXT +glrefProgramUniform3iEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3iEXT #-} +glProgramUniform3iEXT :: FuntypeProgramUniform3iEXT +glProgramUniform3iEXT = unsafePerformIO $ readIORef glrefProgramUniform3iEXT +{-# INLINE glProgramUniform3iEXT #-} +type FuntypeProgramUniform4iEXT = + GLuint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4iEXT :: FunPtr FuntypeProgramUniform4iEXT -> FuntypeProgramUniform4iEXT +glrefProgramUniform4iEXT :: IORef FuntypeProgramUniform4iEXT +glrefProgramUniform4iEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4iEXT #-} +glProgramUniform4iEXT :: FuntypeProgramUniform4iEXT +glProgramUniform4iEXT = unsafePerformIO $ readIORef glrefProgramUniform4iEXT +{-# INLINE glProgramUniform4iEXT #-} +type FuntypeProgramUniform1fvEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1fvEXT :: FunPtr FuntypeProgramUniform1fvEXT -> FuntypeProgramUniform1fvEXT +glrefProgramUniform1fvEXT :: IORef FuntypeProgramUniform1fvEXT +glrefProgramUniform1fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1fvEXT #-} +glProgramUniform1fvEXT :: FuntypeProgramUniform1fvEXT +glProgramUniform1fvEXT = unsafePerformIO $ readIORef glrefProgramUniform1fvEXT +{-# INLINE glProgramUniform1fvEXT #-} +type FuntypeProgramUniform2fvEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2fvEXT :: FunPtr FuntypeProgramUniform2fvEXT -> FuntypeProgramUniform2fvEXT +glrefProgramUniform2fvEXT :: IORef FuntypeProgramUniform2fvEXT +glrefProgramUniform2fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2fvEXT #-} +glProgramUniform2fvEXT :: FuntypeProgramUniform2fvEXT +glProgramUniform2fvEXT = unsafePerformIO $ readIORef glrefProgramUniform2fvEXT +{-# INLINE glProgramUniform2fvEXT #-} +type FuntypeProgramUniform3fvEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3fvEXT :: FunPtr FuntypeProgramUniform3fvEXT -> FuntypeProgramUniform3fvEXT +glrefProgramUniform3fvEXT :: IORef FuntypeProgramUniform3fvEXT +glrefProgramUniform3fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3fvEXT #-} +glProgramUniform3fvEXT :: FuntypeProgramUniform3fvEXT +glProgramUniform3fvEXT = unsafePerformIO $ readIORef glrefProgramUniform3fvEXT +{-# INLINE glProgramUniform3fvEXT #-} +type FuntypeProgramUniform4fvEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4fvEXT :: FunPtr FuntypeProgramUniform4fvEXT -> FuntypeProgramUniform4fvEXT +glrefProgramUniform4fvEXT :: IORef FuntypeProgramUniform4fvEXT +glrefProgramUniform4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4fvEXT #-} +glProgramUniform4fvEXT :: FuntypeProgramUniform4fvEXT +glProgramUniform4fvEXT = unsafePerformIO $ readIORef glrefProgramUniform4fvEXT +{-# INLINE glProgramUniform4fvEXT #-} +type FuntypeProgramUniform1ivEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1ivEXT :: FunPtr FuntypeProgramUniform1ivEXT -> FuntypeProgramUniform1ivEXT +glrefProgramUniform1ivEXT :: IORef FuntypeProgramUniform1ivEXT +glrefProgramUniform1ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1ivEXT #-} +glProgramUniform1ivEXT :: FuntypeProgramUniform1ivEXT +glProgramUniform1ivEXT = unsafePerformIO $ readIORef glrefProgramUniform1ivEXT +{-# INLINE glProgramUniform1ivEXT #-} +type FuntypeProgramUniform2ivEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2ivEXT :: FunPtr FuntypeProgramUniform2ivEXT -> FuntypeProgramUniform2ivEXT +glrefProgramUniform2ivEXT :: IORef FuntypeProgramUniform2ivEXT +glrefProgramUniform2ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2ivEXT #-} +glProgramUniform2ivEXT :: FuntypeProgramUniform2ivEXT +glProgramUniform2ivEXT = unsafePerformIO $ readIORef glrefProgramUniform2ivEXT +{-# INLINE glProgramUniform2ivEXT #-} +type FuntypeProgramUniform3ivEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3ivEXT :: FunPtr FuntypeProgramUniform3ivEXT -> FuntypeProgramUniform3ivEXT +glrefProgramUniform3ivEXT :: IORef FuntypeProgramUniform3ivEXT +glrefProgramUniform3ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3ivEXT #-} +glProgramUniform3ivEXT :: FuntypeProgramUniform3ivEXT +glProgramUniform3ivEXT = unsafePerformIO $ readIORef glrefProgramUniform3ivEXT +{-# INLINE glProgramUniform3ivEXT #-} +type FuntypeProgramUniform4ivEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4ivEXT :: FunPtr FuntypeProgramUniform4ivEXT -> FuntypeProgramUniform4ivEXT +glrefProgramUniform4ivEXT :: IORef FuntypeProgramUniform4ivEXT +glrefProgramUniform4ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4ivEXT #-} +glProgramUniform4ivEXT :: FuntypeProgramUniform4ivEXT +glProgramUniform4ivEXT = unsafePerformIO $ readIORef glrefProgramUniform4ivEXT +{-# INLINE glProgramUniform4ivEXT #-} +type FuntypeProgramUniformMatrix2fvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2fvEXT :: FunPtr FuntypeProgramUniformMatrix2fvEXT -> FuntypeProgramUniformMatrix2fvEXT +glrefProgramUniformMatrix2fvEXT :: IORef FuntypeProgramUniformMatrix2fvEXT +glrefProgramUniformMatrix2fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2fvEXT #-} +glProgramUniformMatrix2fvEXT :: FuntypeProgramUniformMatrix2fvEXT +glProgramUniformMatrix2fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2fvEXT +{-# INLINE glProgramUniformMatrix2fvEXT #-} +type FuntypeProgramUniformMatrix3fvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3fvEXT :: FunPtr FuntypeProgramUniformMatrix3fvEXT -> FuntypeProgramUniformMatrix3fvEXT +glrefProgramUniformMatrix3fvEXT :: IORef FuntypeProgramUniformMatrix3fvEXT +glrefProgramUniformMatrix3fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3fvEXT #-} +glProgramUniformMatrix3fvEXT :: FuntypeProgramUniformMatrix3fvEXT +glProgramUniformMatrix3fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3fvEXT +{-# INLINE glProgramUniformMatrix3fvEXT #-} +type FuntypeProgramUniformMatrix4fvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4fvEXT :: FunPtr FuntypeProgramUniformMatrix4fvEXT -> FuntypeProgramUniformMatrix4fvEXT +glrefProgramUniformMatrix4fvEXT :: IORef FuntypeProgramUniformMatrix4fvEXT +glrefProgramUniformMatrix4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4fvEXT #-} +glProgramUniformMatrix4fvEXT :: FuntypeProgramUniformMatrix4fvEXT +glProgramUniformMatrix4fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4fvEXT +{-# INLINE glProgramUniformMatrix4fvEXT #-} +type FuntypeProgramUniformMatrix2x3fvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2x3fvEXT :: FunPtr FuntypeProgramUniformMatrix2x3fvEXT -> FuntypeProgramUniformMatrix2x3fvEXT +glrefProgramUniformMatrix2x3fvEXT :: IORef FuntypeProgramUniformMatrix2x3fvEXT +glrefProgramUniformMatrix2x3fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2x3fvEXT #-} +glProgramUniformMatrix2x3fvEXT :: FuntypeProgramUniformMatrix2x3fvEXT +glProgramUniformMatrix2x3fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x3fvEXT +{-# INLINE glProgramUniformMatrix2x3fvEXT #-} +type FuntypeProgramUniformMatrix3x2fvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3x2fvEXT :: FunPtr FuntypeProgramUniformMatrix3x2fvEXT -> FuntypeProgramUniformMatrix3x2fvEXT +glrefProgramUniformMatrix3x2fvEXT :: IORef FuntypeProgramUniformMatrix3x2fvEXT +glrefProgramUniformMatrix3x2fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3x2fvEXT #-} +glProgramUniformMatrix3x2fvEXT :: FuntypeProgramUniformMatrix3x2fvEXT +glProgramUniformMatrix3x2fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x2fvEXT +{-# INLINE glProgramUniformMatrix3x2fvEXT #-} +type FuntypeProgramUniformMatrix2x4fvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2x4fvEXT :: FunPtr FuntypeProgramUniformMatrix2x4fvEXT -> FuntypeProgramUniformMatrix2x4fvEXT +glrefProgramUniformMatrix2x4fvEXT :: IORef FuntypeProgramUniformMatrix2x4fvEXT +glrefProgramUniformMatrix2x4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2x4fvEXT #-} +glProgramUniformMatrix2x4fvEXT :: FuntypeProgramUniformMatrix2x4fvEXT +glProgramUniformMatrix2x4fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x4fvEXT +{-# INLINE glProgramUniformMatrix2x4fvEXT #-} +type FuntypeProgramUniformMatrix4x2fvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4x2fvEXT :: FunPtr FuntypeProgramUniformMatrix4x2fvEXT -> FuntypeProgramUniformMatrix4x2fvEXT +glrefProgramUniformMatrix4x2fvEXT :: IORef FuntypeProgramUniformMatrix4x2fvEXT +glrefProgramUniformMatrix4x2fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4x2fvEXT #-} +glProgramUniformMatrix4x2fvEXT :: FuntypeProgramUniformMatrix4x2fvEXT +glProgramUniformMatrix4x2fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x2fvEXT +{-# INLINE glProgramUniformMatrix4x2fvEXT #-} +type FuntypeProgramUniformMatrix3x4fvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3x4fvEXT :: FunPtr FuntypeProgramUniformMatrix3x4fvEXT -> FuntypeProgramUniformMatrix3x4fvEXT +glrefProgramUniformMatrix3x4fvEXT :: IORef FuntypeProgramUniformMatrix3x4fvEXT +glrefProgramUniformMatrix3x4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3x4fvEXT #-} +glProgramUniformMatrix3x4fvEXT :: FuntypeProgramUniformMatrix3x4fvEXT +glProgramUniformMatrix3x4fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x4fvEXT +{-# INLINE glProgramUniformMatrix3x4fvEXT #-} +type FuntypeProgramUniformMatrix4x3fvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4x3fvEXT :: FunPtr FuntypeProgramUniformMatrix4x3fvEXT -> FuntypeProgramUniformMatrix4x3fvEXT +glrefProgramUniformMatrix4x3fvEXT :: IORef FuntypeProgramUniformMatrix4x3fvEXT +glrefProgramUniformMatrix4x3fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4x3fvEXT #-} +glProgramUniformMatrix4x3fvEXT :: FuntypeProgramUniformMatrix4x3fvEXT +glProgramUniformMatrix4x3fvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x3fvEXT +{-# INLINE glProgramUniformMatrix4x3fvEXT #-} +type FuntypeTextureBufferEXT = + GLuint -> + GLenum -> + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureBufferEXT :: FunPtr FuntypeTextureBufferEXT -> FuntypeTextureBufferEXT +glrefTextureBufferEXT :: IORef FuntypeTextureBufferEXT +glrefTextureBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureBufferEXT #-} +glTextureBufferEXT :: FuntypeTextureBufferEXT +glTextureBufferEXT = unsafePerformIO $ readIORef glrefTextureBufferEXT +{-# INLINE glTextureBufferEXT #-} +type FuntypeMultiTexBufferEXT = + GLenum -> + GLenum -> + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexBufferEXT :: FunPtr FuntypeMultiTexBufferEXT -> FuntypeMultiTexBufferEXT +glrefMultiTexBufferEXT :: IORef FuntypeMultiTexBufferEXT +glrefMultiTexBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexBufferEXT #-} +glMultiTexBufferEXT :: FuntypeMultiTexBufferEXT +glMultiTexBufferEXT = unsafePerformIO $ readIORef glrefMultiTexBufferEXT +{-# INLINE glMultiTexBufferEXT #-} +type FuntypeTextureParameterIivEXT = + GLuint -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureParameterIivEXT :: FunPtr FuntypeTextureParameterIivEXT -> FuntypeTextureParameterIivEXT +glrefTextureParameterIivEXT :: IORef FuntypeTextureParameterIivEXT +glrefTextureParameterIivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureParameterIivEXT #-} +glTextureParameterIivEXT :: FuntypeTextureParameterIivEXT +glTextureParameterIivEXT = unsafePerformIO $ readIORef glrefTextureParameterIivEXT +{-# INLINE glTextureParameterIivEXT #-} +type FuntypeTextureParameterIuivEXT = + GLuint -> + GLenum -> + GLenum -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureParameterIuivEXT :: FunPtr FuntypeTextureParameterIuivEXT -> FuntypeTextureParameterIuivEXT +glrefTextureParameterIuivEXT :: IORef FuntypeTextureParameterIuivEXT +glrefTextureParameterIuivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureParameterIuivEXT #-} +glTextureParameterIuivEXT :: FuntypeTextureParameterIuivEXT +glTextureParameterIuivEXT = unsafePerformIO $ readIORef glrefTextureParameterIuivEXT +{-# INLINE glTextureParameterIuivEXT #-} +type FuntypeGetTextureParameterIivEXT = + GLuint -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTextureParameterIivEXT :: FunPtr FuntypeGetTextureParameterIivEXT -> FuntypeGetTextureParameterIivEXT +glrefGetTextureParameterIivEXT :: IORef FuntypeGetTextureParameterIivEXT +glrefGetTextureParameterIivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTextureParameterIivEXT #-} +glGetTextureParameterIivEXT :: FuntypeGetTextureParameterIivEXT +glGetTextureParameterIivEXT = unsafePerformIO $ readIORef glrefGetTextureParameterIivEXT +{-# INLINE glGetTextureParameterIivEXT #-} +type FuntypeGetTextureParameterIuivEXT = + GLuint -> + GLenum -> + GLenum -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetTextureParameterIuivEXT :: FunPtr FuntypeGetTextureParameterIuivEXT -> FuntypeGetTextureParameterIuivEXT +glrefGetTextureParameterIuivEXT :: IORef FuntypeGetTextureParameterIuivEXT +glrefGetTextureParameterIuivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetTextureParameterIuivEXT #-} +glGetTextureParameterIuivEXT :: FuntypeGetTextureParameterIuivEXT +glGetTextureParameterIuivEXT = unsafePerformIO $ readIORef glrefGetTextureParameterIuivEXT +{-# INLINE glGetTextureParameterIuivEXT #-} +type FuntypeMultiTexParameterIivEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexParameterIivEXT :: FunPtr FuntypeMultiTexParameterIivEXT -> FuntypeMultiTexParameterIivEXT +glrefMultiTexParameterIivEXT :: IORef FuntypeMultiTexParameterIivEXT +glrefMultiTexParameterIivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexParameterIivEXT #-} +glMultiTexParameterIivEXT :: FuntypeMultiTexParameterIivEXT +glMultiTexParameterIivEXT = unsafePerformIO $ readIORef glrefMultiTexParameterIivEXT +{-# INLINE glMultiTexParameterIivEXT #-} +type FuntypeMultiTexParameterIuivEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexParameterIuivEXT :: FunPtr FuntypeMultiTexParameterIuivEXT -> FuntypeMultiTexParameterIuivEXT +glrefMultiTexParameterIuivEXT :: IORef FuntypeMultiTexParameterIuivEXT +glrefMultiTexParameterIuivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexParameterIuivEXT #-} +glMultiTexParameterIuivEXT :: FuntypeMultiTexParameterIuivEXT +glMultiTexParameterIuivEXT = unsafePerformIO $ readIORef glrefMultiTexParameterIuivEXT +{-# INLINE glMultiTexParameterIuivEXT #-} +type FuntypeGetMultiTexParameterIivEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexParameterIivEXT :: FunPtr FuntypeGetMultiTexParameterIivEXT -> FuntypeGetMultiTexParameterIivEXT +glrefGetMultiTexParameterIivEXT :: IORef FuntypeGetMultiTexParameterIivEXT +glrefGetMultiTexParameterIivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexParameterIivEXT #-} +glGetMultiTexParameterIivEXT :: FuntypeGetMultiTexParameterIivEXT +glGetMultiTexParameterIivEXT = unsafePerformIO $ readIORef glrefGetMultiTexParameterIivEXT +{-# INLINE glGetMultiTexParameterIivEXT #-} +type FuntypeGetMultiTexParameterIuivEXT = + GLenum -> + GLenum -> + GLenum -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetMultiTexParameterIuivEXT :: FunPtr FuntypeGetMultiTexParameterIuivEXT -> FuntypeGetMultiTexParameterIuivEXT +glrefGetMultiTexParameterIuivEXT :: IORef FuntypeGetMultiTexParameterIuivEXT +glrefGetMultiTexParameterIuivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetMultiTexParameterIuivEXT #-} +glGetMultiTexParameterIuivEXT :: FuntypeGetMultiTexParameterIuivEXT +glGetMultiTexParameterIuivEXT = unsafePerformIO $ readIORef glrefGetMultiTexParameterIuivEXT +{-# INLINE glGetMultiTexParameterIuivEXT #-} +type FuntypeProgramUniform1uiEXT = + GLuint -> + GLint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1uiEXT :: FunPtr FuntypeProgramUniform1uiEXT -> FuntypeProgramUniform1uiEXT +glrefProgramUniform1uiEXT :: IORef FuntypeProgramUniform1uiEXT +glrefProgramUniform1uiEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1uiEXT #-} +glProgramUniform1uiEXT :: FuntypeProgramUniform1uiEXT +glProgramUniform1uiEXT = unsafePerformIO $ readIORef glrefProgramUniform1uiEXT +{-# INLINE glProgramUniform1uiEXT #-} +type FuntypeProgramUniform2uiEXT = + GLuint -> + GLint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2uiEXT :: FunPtr FuntypeProgramUniform2uiEXT -> FuntypeProgramUniform2uiEXT +glrefProgramUniform2uiEXT :: IORef FuntypeProgramUniform2uiEXT +glrefProgramUniform2uiEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2uiEXT #-} +glProgramUniform2uiEXT :: FuntypeProgramUniform2uiEXT +glProgramUniform2uiEXT = unsafePerformIO $ readIORef glrefProgramUniform2uiEXT +{-# INLINE glProgramUniform2uiEXT #-} +type FuntypeProgramUniform3uiEXT = + GLuint -> + GLint -> + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3uiEXT :: FunPtr FuntypeProgramUniform3uiEXT -> FuntypeProgramUniform3uiEXT +glrefProgramUniform3uiEXT :: IORef FuntypeProgramUniform3uiEXT +glrefProgramUniform3uiEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3uiEXT #-} +glProgramUniform3uiEXT :: FuntypeProgramUniform3uiEXT +glProgramUniform3uiEXT = unsafePerformIO $ readIORef glrefProgramUniform3uiEXT +{-# INLINE glProgramUniform3uiEXT #-} +type FuntypeProgramUniform4uiEXT = + GLuint -> + GLint -> + GLuint -> + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4uiEXT :: FunPtr FuntypeProgramUniform4uiEXT -> FuntypeProgramUniform4uiEXT +glrefProgramUniform4uiEXT :: IORef FuntypeProgramUniform4uiEXT +glrefProgramUniform4uiEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4uiEXT #-} +glProgramUniform4uiEXT :: FuntypeProgramUniform4uiEXT +glProgramUniform4uiEXT = unsafePerformIO $ readIORef glrefProgramUniform4uiEXT +{-# INLINE glProgramUniform4uiEXT #-} +type FuntypeProgramUniform1uivEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1uivEXT :: FunPtr FuntypeProgramUniform1uivEXT -> FuntypeProgramUniform1uivEXT +glrefProgramUniform1uivEXT :: IORef FuntypeProgramUniform1uivEXT +glrefProgramUniform1uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1uivEXT #-} +glProgramUniform1uivEXT :: FuntypeProgramUniform1uivEXT +glProgramUniform1uivEXT = unsafePerformIO $ readIORef glrefProgramUniform1uivEXT +{-# INLINE glProgramUniform1uivEXT #-} +type FuntypeProgramUniform2uivEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2uivEXT :: FunPtr FuntypeProgramUniform2uivEXT -> FuntypeProgramUniform2uivEXT +glrefProgramUniform2uivEXT :: IORef FuntypeProgramUniform2uivEXT +glrefProgramUniform2uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2uivEXT #-} +glProgramUniform2uivEXT :: FuntypeProgramUniform2uivEXT +glProgramUniform2uivEXT = unsafePerformIO $ readIORef glrefProgramUniform2uivEXT +{-# INLINE glProgramUniform2uivEXT #-} +type FuntypeProgramUniform3uivEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3uivEXT :: FunPtr FuntypeProgramUniform3uivEXT -> FuntypeProgramUniform3uivEXT +glrefProgramUniform3uivEXT :: IORef FuntypeProgramUniform3uivEXT +glrefProgramUniform3uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3uivEXT #-} +glProgramUniform3uivEXT :: FuntypeProgramUniform3uivEXT +glProgramUniform3uivEXT = unsafePerformIO $ readIORef glrefProgramUniform3uivEXT +{-# INLINE glProgramUniform3uivEXT #-} +type FuntypeProgramUniform4uivEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4uivEXT :: FunPtr FuntypeProgramUniform4uivEXT -> FuntypeProgramUniform4uivEXT +glrefProgramUniform4uivEXT :: IORef FuntypeProgramUniform4uivEXT +glrefProgramUniform4uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4uivEXT #-} +glProgramUniform4uivEXT :: FuntypeProgramUniform4uivEXT +glProgramUniform4uivEXT = unsafePerformIO $ readIORef glrefProgramUniform4uivEXT +{-# INLINE glProgramUniform4uivEXT #-} +type FuntypeNamedProgramLocalParameters4fvEXT = + GLuint -> + GLenum -> + GLuint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramLocalParameters4fvEXT :: FunPtr FuntypeNamedProgramLocalParameters4fvEXT -> FuntypeNamedProgramLocalParameters4fvEXT +glrefNamedProgramLocalParameters4fvEXT :: IORef FuntypeNamedProgramLocalParameters4fvEXT +glrefNamedProgramLocalParameters4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramLocalParameters4fvEXT #-} +glNamedProgramLocalParameters4fvEXT :: FuntypeNamedProgramLocalParameters4fvEXT +glNamedProgramLocalParameters4fvEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameters4fvEXT +{-# INLINE glNamedProgramLocalParameters4fvEXT #-} +type FuntypeNamedProgramLocalParameterI4iEXT = + GLuint -> + GLenum -> + GLuint -> + GLint -> + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramLocalParameterI4iEXT :: FunPtr FuntypeNamedProgramLocalParameterI4iEXT -> FuntypeNamedProgramLocalParameterI4iEXT +glrefNamedProgramLocalParameterI4iEXT :: IORef FuntypeNamedProgramLocalParameterI4iEXT +glrefNamedProgramLocalParameterI4iEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramLocalParameterI4iEXT #-} +glNamedProgramLocalParameterI4iEXT :: FuntypeNamedProgramLocalParameterI4iEXT +glNamedProgramLocalParameterI4iEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameterI4iEXT +{-# INLINE glNamedProgramLocalParameterI4iEXT #-} +type FuntypeNamedProgramLocalParameterI4ivEXT = + GLuint -> + GLenum -> + GLuint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramLocalParameterI4ivEXT :: FunPtr FuntypeNamedProgramLocalParameterI4ivEXT -> FuntypeNamedProgramLocalParameterI4ivEXT +glrefNamedProgramLocalParameterI4ivEXT :: IORef FuntypeNamedProgramLocalParameterI4ivEXT +glrefNamedProgramLocalParameterI4ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramLocalParameterI4ivEXT #-} +glNamedProgramLocalParameterI4ivEXT :: FuntypeNamedProgramLocalParameterI4ivEXT +glNamedProgramLocalParameterI4ivEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameterI4ivEXT +{-# INLINE glNamedProgramLocalParameterI4ivEXT #-} +type FuntypeNamedProgramLocalParametersI4ivEXT = + GLuint -> + GLenum -> + GLuint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramLocalParametersI4ivEXT :: FunPtr FuntypeNamedProgramLocalParametersI4ivEXT -> FuntypeNamedProgramLocalParametersI4ivEXT +glrefNamedProgramLocalParametersI4ivEXT :: IORef FuntypeNamedProgramLocalParametersI4ivEXT +glrefNamedProgramLocalParametersI4ivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramLocalParametersI4ivEXT #-} +glNamedProgramLocalParametersI4ivEXT :: FuntypeNamedProgramLocalParametersI4ivEXT +glNamedProgramLocalParametersI4ivEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParametersI4ivEXT +{-# INLINE glNamedProgramLocalParametersI4ivEXT #-} +type FuntypeNamedProgramLocalParameterI4uiEXT = + GLuint -> + GLenum -> + GLuint -> + GLuint -> + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramLocalParameterI4uiEXT :: FunPtr FuntypeNamedProgramLocalParameterI4uiEXT -> FuntypeNamedProgramLocalParameterI4uiEXT +glrefNamedProgramLocalParameterI4uiEXT :: IORef FuntypeNamedProgramLocalParameterI4uiEXT +glrefNamedProgramLocalParameterI4uiEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramLocalParameterI4uiEXT #-} +glNamedProgramLocalParameterI4uiEXT :: FuntypeNamedProgramLocalParameterI4uiEXT +glNamedProgramLocalParameterI4uiEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameterI4uiEXT +{-# INLINE glNamedProgramLocalParameterI4uiEXT #-} +type FuntypeNamedProgramLocalParameterI4uivEXT = + GLuint -> + GLenum -> + GLuint -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramLocalParameterI4uivEXT :: FunPtr FuntypeNamedProgramLocalParameterI4uivEXT -> FuntypeNamedProgramLocalParameterI4uivEXT +glrefNamedProgramLocalParameterI4uivEXT :: IORef FuntypeNamedProgramLocalParameterI4uivEXT +glrefNamedProgramLocalParameterI4uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramLocalParameterI4uivEXT #-} +glNamedProgramLocalParameterI4uivEXT :: FuntypeNamedProgramLocalParameterI4uivEXT +glNamedProgramLocalParameterI4uivEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameterI4uivEXT +{-# INLINE glNamedProgramLocalParameterI4uivEXT #-} +type FuntypeNamedProgramLocalParametersI4uivEXT = + GLuint -> + GLenum -> + GLuint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramLocalParametersI4uivEXT :: FunPtr FuntypeNamedProgramLocalParametersI4uivEXT -> FuntypeNamedProgramLocalParametersI4uivEXT +glrefNamedProgramLocalParametersI4uivEXT :: IORef FuntypeNamedProgramLocalParametersI4uivEXT +glrefNamedProgramLocalParametersI4uivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramLocalParametersI4uivEXT #-} +glNamedProgramLocalParametersI4uivEXT :: FuntypeNamedProgramLocalParametersI4uivEXT +glNamedProgramLocalParametersI4uivEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParametersI4uivEXT +{-# INLINE glNamedProgramLocalParametersI4uivEXT #-} +type FuntypeGetNamedProgramLocalParameterIivEXT = + GLuint -> + GLenum -> + GLuint -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedProgramLocalParameterIivEXT :: FunPtr FuntypeGetNamedProgramLocalParameterIivEXT -> FuntypeGetNamedProgramLocalParameterIivEXT +glrefGetNamedProgramLocalParameterIivEXT :: IORef FuntypeGetNamedProgramLocalParameterIivEXT +glrefGetNamedProgramLocalParameterIivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedProgramLocalParameterIivEXT #-} +glGetNamedProgramLocalParameterIivEXT :: FuntypeGetNamedProgramLocalParameterIivEXT +glGetNamedProgramLocalParameterIivEXT = unsafePerformIO $ readIORef glrefGetNamedProgramLocalParameterIivEXT +{-# INLINE glGetNamedProgramLocalParameterIivEXT #-} +type FuntypeGetNamedProgramLocalParameterIuivEXT = + GLuint -> + GLenum -> + GLuint -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedProgramLocalParameterIuivEXT :: FunPtr FuntypeGetNamedProgramLocalParameterIuivEXT -> FuntypeGetNamedProgramLocalParameterIuivEXT +glrefGetNamedProgramLocalParameterIuivEXT :: IORef FuntypeGetNamedProgramLocalParameterIuivEXT +glrefGetNamedProgramLocalParameterIuivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedProgramLocalParameterIuivEXT #-} +glGetNamedProgramLocalParameterIuivEXT :: FuntypeGetNamedProgramLocalParameterIuivEXT +glGetNamedProgramLocalParameterIuivEXT = unsafePerformIO $ readIORef glrefGetNamedProgramLocalParameterIuivEXT +{-# INLINE glGetNamedProgramLocalParameterIuivEXT #-} +type FuntypeEnableClientStateiEXT = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynEnableClientStateiEXT :: FunPtr FuntypeEnableClientStateiEXT -> FuntypeEnableClientStateiEXT +glrefEnableClientStateiEXT :: IORef FuntypeEnableClientStateiEXT +glrefEnableClientStateiEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefEnableClientStateiEXT #-} +glEnableClientStateiEXT :: FuntypeEnableClientStateiEXT +glEnableClientStateiEXT = unsafePerformIO $ readIORef glrefEnableClientStateiEXT +{-# INLINE glEnableClientStateiEXT #-} +type FuntypeDisableClientStateiEXT = + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDisableClientStateiEXT :: FunPtr FuntypeDisableClientStateiEXT -> FuntypeDisableClientStateiEXT +glrefDisableClientStateiEXT :: IORef FuntypeDisableClientStateiEXT +glrefDisableClientStateiEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDisableClientStateiEXT #-} +glDisableClientStateiEXT :: FuntypeDisableClientStateiEXT +glDisableClientStateiEXT = unsafePerformIO $ readIORef glrefDisableClientStateiEXT +{-# INLINE glDisableClientStateiEXT #-} +type FuntypeGetFloati_vEXT = + GLenum -> + GLuint -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetFloati_vEXT :: FunPtr FuntypeGetFloati_vEXT -> FuntypeGetFloati_vEXT +glrefGetFloati_vEXT :: IORef FuntypeGetFloati_vEXT +glrefGetFloati_vEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetFloati_vEXT #-} +glGetFloati_vEXT :: FuntypeGetFloati_vEXT +glGetFloati_vEXT = unsafePerformIO $ readIORef glrefGetFloati_vEXT +{-# INLINE glGetFloati_vEXT #-} +type FuntypeGetDoublei_vEXT = + GLenum -> + GLuint -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetDoublei_vEXT :: FunPtr FuntypeGetDoublei_vEXT -> FuntypeGetDoublei_vEXT +glrefGetDoublei_vEXT :: IORef FuntypeGetDoublei_vEXT +glrefGetDoublei_vEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetDoublei_vEXT #-} +glGetDoublei_vEXT :: FuntypeGetDoublei_vEXT +glGetDoublei_vEXT = unsafePerformIO $ readIORef glrefGetDoublei_vEXT +{-# INLINE glGetDoublei_vEXT #-} +type FuntypeGetPointeri_vEXT = + GLenum -> + GLuint -> + Ptr (Ptr ()) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetPointeri_vEXT :: FunPtr FuntypeGetPointeri_vEXT -> FuntypeGetPointeri_vEXT +glrefGetPointeri_vEXT :: IORef FuntypeGetPointeri_vEXT +glrefGetPointeri_vEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetPointeri_vEXT #-} +glGetPointeri_vEXT :: FuntypeGetPointeri_vEXT +glGetPointeri_vEXT = unsafePerformIO $ readIORef glrefGetPointeri_vEXT +{-# INLINE glGetPointeri_vEXT #-} +type FuntypeNamedProgramStringEXT = + GLuint -> + GLenum -> + GLenum -> + GLsizei -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramStringEXT :: FunPtr FuntypeNamedProgramStringEXT -> FuntypeNamedProgramStringEXT +glrefNamedProgramStringEXT :: IORef FuntypeNamedProgramStringEXT +glrefNamedProgramStringEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramStringEXT #-} +glNamedProgramStringEXT :: FuntypeNamedProgramStringEXT +glNamedProgramStringEXT = unsafePerformIO $ readIORef glrefNamedProgramStringEXT +{-# INLINE glNamedProgramStringEXT #-} +type FuntypeNamedProgramLocalParameter4dEXT = + GLuint -> + GLenum -> + GLuint -> + GLdouble -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramLocalParameter4dEXT :: FunPtr FuntypeNamedProgramLocalParameter4dEXT -> FuntypeNamedProgramLocalParameter4dEXT +glrefNamedProgramLocalParameter4dEXT :: IORef FuntypeNamedProgramLocalParameter4dEXT +glrefNamedProgramLocalParameter4dEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramLocalParameter4dEXT #-} +glNamedProgramLocalParameter4dEXT :: FuntypeNamedProgramLocalParameter4dEXT +glNamedProgramLocalParameter4dEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameter4dEXT +{-# INLINE glNamedProgramLocalParameter4dEXT #-} +type FuntypeNamedProgramLocalParameter4dvEXT = + GLuint -> + GLenum -> + GLuint -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramLocalParameter4dvEXT :: FunPtr FuntypeNamedProgramLocalParameter4dvEXT -> FuntypeNamedProgramLocalParameter4dvEXT +glrefNamedProgramLocalParameter4dvEXT :: IORef FuntypeNamedProgramLocalParameter4dvEXT +glrefNamedProgramLocalParameter4dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramLocalParameter4dvEXT #-} +glNamedProgramLocalParameter4dvEXT :: FuntypeNamedProgramLocalParameter4dvEXT +glNamedProgramLocalParameter4dvEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameter4dvEXT +{-# INLINE glNamedProgramLocalParameter4dvEXT #-} +type FuntypeNamedProgramLocalParameter4fEXT = + GLuint -> + GLenum -> + GLuint -> + GLfloat -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramLocalParameter4fEXT :: FunPtr FuntypeNamedProgramLocalParameter4fEXT -> FuntypeNamedProgramLocalParameter4fEXT +glrefNamedProgramLocalParameter4fEXT :: IORef FuntypeNamedProgramLocalParameter4fEXT +glrefNamedProgramLocalParameter4fEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramLocalParameter4fEXT #-} +glNamedProgramLocalParameter4fEXT :: FuntypeNamedProgramLocalParameter4fEXT +glNamedProgramLocalParameter4fEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameter4fEXT +{-# INLINE glNamedProgramLocalParameter4fEXT #-} +type FuntypeNamedProgramLocalParameter4fvEXT = + GLuint -> + GLenum -> + GLuint -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedProgramLocalParameter4fvEXT :: FunPtr FuntypeNamedProgramLocalParameter4fvEXT -> FuntypeNamedProgramLocalParameter4fvEXT +glrefNamedProgramLocalParameter4fvEXT :: IORef FuntypeNamedProgramLocalParameter4fvEXT +glrefNamedProgramLocalParameter4fvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedProgramLocalParameter4fvEXT #-} +glNamedProgramLocalParameter4fvEXT :: FuntypeNamedProgramLocalParameter4fvEXT +glNamedProgramLocalParameter4fvEXT = unsafePerformIO $ readIORef glrefNamedProgramLocalParameter4fvEXT +{-# INLINE glNamedProgramLocalParameter4fvEXT #-} +type FuntypeGetNamedProgramLocalParameterdvEXT = + GLuint -> + GLenum -> + GLuint -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedProgramLocalParameterdvEXT :: FunPtr FuntypeGetNamedProgramLocalParameterdvEXT -> FuntypeGetNamedProgramLocalParameterdvEXT +glrefGetNamedProgramLocalParameterdvEXT :: IORef FuntypeGetNamedProgramLocalParameterdvEXT +glrefGetNamedProgramLocalParameterdvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedProgramLocalParameterdvEXT #-} +glGetNamedProgramLocalParameterdvEXT :: FuntypeGetNamedProgramLocalParameterdvEXT +glGetNamedProgramLocalParameterdvEXT = unsafePerformIO $ readIORef glrefGetNamedProgramLocalParameterdvEXT +{-# INLINE glGetNamedProgramLocalParameterdvEXT #-} +type FuntypeGetNamedProgramLocalParameterfvEXT = + GLuint -> + GLenum -> + GLuint -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedProgramLocalParameterfvEXT :: FunPtr FuntypeGetNamedProgramLocalParameterfvEXT -> FuntypeGetNamedProgramLocalParameterfvEXT +glrefGetNamedProgramLocalParameterfvEXT :: IORef FuntypeGetNamedProgramLocalParameterfvEXT +glrefGetNamedProgramLocalParameterfvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedProgramLocalParameterfvEXT #-} +glGetNamedProgramLocalParameterfvEXT :: FuntypeGetNamedProgramLocalParameterfvEXT +glGetNamedProgramLocalParameterfvEXT = unsafePerformIO $ readIORef glrefGetNamedProgramLocalParameterfvEXT +{-# INLINE glGetNamedProgramLocalParameterfvEXT #-} +type FuntypeGetNamedProgramivEXT = + GLuint -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedProgramivEXT :: FunPtr FuntypeGetNamedProgramivEXT -> FuntypeGetNamedProgramivEXT +glrefGetNamedProgramivEXT :: IORef FuntypeGetNamedProgramivEXT +glrefGetNamedProgramivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedProgramivEXT #-} +glGetNamedProgramivEXT :: FuntypeGetNamedProgramivEXT +glGetNamedProgramivEXT = unsafePerformIO $ readIORef glrefGetNamedProgramivEXT +{-# INLINE glGetNamedProgramivEXT #-} +type FuntypeGetNamedProgramStringEXT = + GLuint -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedProgramStringEXT :: FunPtr FuntypeGetNamedProgramStringEXT -> FuntypeGetNamedProgramStringEXT +glrefGetNamedProgramStringEXT :: IORef FuntypeGetNamedProgramStringEXT +glrefGetNamedProgramStringEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedProgramStringEXT #-} +glGetNamedProgramStringEXT :: FuntypeGetNamedProgramStringEXT +glGetNamedProgramStringEXT = unsafePerformIO $ readIORef glrefGetNamedProgramStringEXT +{-# INLINE glGetNamedProgramStringEXT #-} +type FuntypeNamedRenderbufferStorageEXT = + GLuint -> + GLenum -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedRenderbufferStorageEXT :: FunPtr FuntypeNamedRenderbufferStorageEXT -> FuntypeNamedRenderbufferStorageEXT +glrefNamedRenderbufferStorageEXT :: IORef FuntypeNamedRenderbufferStorageEXT +glrefNamedRenderbufferStorageEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedRenderbufferStorageEXT #-} +glNamedRenderbufferStorageEXT :: FuntypeNamedRenderbufferStorageEXT +glNamedRenderbufferStorageEXT = unsafePerformIO $ readIORef glrefNamedRenderbufferStorageEXT +{-# INLINE glNamedRenderbufferStorageEXT #-} +type FuntypeGetNamedRenderbufferParameterivEXT = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedRenderbufferParameterivEXT :: FunPtr FuntypeGetNamedRenderbufferParameterivEXT -> FuntypeGetNamedRenderbufferParameterivEXT +glrefGetNamedRenderbufferParameterivEXT :: IORef FuntypeGetNamedRenderbufferParameterivEXT +glrefGetNamedRenderbufferParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedRenderbufferParameterivEXT #-} +glGetNamedRenderbufferParameterivEXT :: FuntypeGetNamedRenderbufferParameterivEXT +glGetNamedRenderbufferParameterivEXT = unsafePerformIO $ readIORef glrefGetNamedRenderbufferParameterivEXT +{-# INLINE glGetNamedRenderbufferParameterivEXT #-} +type FuntypeNamedRenderbufferStorageMultisampleEXT = + GLuint -> + GLsizei -> + GLenum -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedRenderbufferStorageMultisampleEXT :: FunPtr FuntypeNamedRenderbufferStorageMultisampleEXT -> FuntypeNamedRenderbufferStorageMultisampleEXT +glrefNamedRenderbufferStorageMultisampleEXT :: IORef FuntypeNamedRenderbufferStorageMultisampleEXT +glrefNamedRenderbufferStorageMultisampleEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedRenderbufferStorageMultisampleEXT #-} +glNamedRenderbufferStorageMultisampleEXT :: FuntypeNamedRenderbufferStorageMultisampleEXT +glNamedRenderbufferStorageMultisampleEXT = unsafePerformIO $ readIORef glrefNamedRenderbufferStorageMultisampleEXT +{-# INLINE glNamedRenderbufferStorageMultisampleEXT #-} +type FuntypeNamedRenderbufferStorageMultisampleCoverageEXT = + GLuint -> + GLsizei -> + GLsizei -> + GLenum -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedRenderbufferStorageMultisampleCoverageEXT :: FunPtr FuntypeNamedRenderbufferStorageMultisampleCoverageEXT -> FuntypeNamedRenderbufferStorageMultisampleCoverageEXT +glrefNamedRenderbufferStorageMultisampleCoverageEXT :: IORef FuntypeNamedRenderbufferStorageMultisampleCoverageEXT +glrefNamedRenderbufferStorageMultisampleCoverageEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedRenderbufferStorageMultisampleCoverageEXT #-} +glNamedRenderbufferStorageMultisampleCoverageEXT :: FuntypeNamedRenderbufferStorageMultisampleCoverageEXT +glNamedRenderbufferStorageMultisampleCoverageEXT = unsafePerformIO $ readIORef glrefNamedRenderbufferStorageMultisampleCoverageEXT +{-# INLINE glNamedRenderbufferStorageMultisampleCoverageEXT #-} +type FuntypeCheckNamedFramebufferStatusEXT = + GLuint -> + GLenum -> + IO ( GLenum ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCheckNamedFramebufferStatusEXT :: FunPtr FuntypeCheckNamedFramebufferStatusEXT -> FuntypeCheckNamedFramebufferStatusEXT +glrefCheckNamedFramebufferStatusEXT :: IORef FuntypeCheckNamedFramebufferStatusEXT +glrefCheckNamedFramebufferStatusEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCheckNamedFramebufferStatusEXT #-} +glCheckNamedFramebufferStatusEXT :: FuntypeCheckNamedFramebufferStatusEXT +glCheckNamedFramebufferStatusEXT = unsafePerformIO $ readIORef glrefCheckNamedFramebufferStatusEXT +{-# INLINE glCheckNamedFramebufferStatusEXT #-} +type FuntypeNamedFramebufferTexture1DEXT = + GLuint -> + GLenum -> + GLenum -> + GLuint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedFramebufferTexture1DEXT :: FunPtr FuntypeNamedFramebufferTexture1DEXT -> FuntypeNamedFramebufferTexture1DEXT +glrefNamedFramebufferTexture1DEXT :: IORef FuntypeNamedFramebufferTexture1DEXT +glrefNamedFramebufferTexture1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedFramebufferTexture1DEXT #-} +glNamedFramebufferTexture1DEXT :: FuntypeNamedFramebufferTexture1DEXT +glNamedFramebufferTexture1DEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTexture1DEXT +{-# INLINE glNamedFramebufferTexture1DEXT #-} +type FuntypeNamedFramebufferTexture2DEXT = + GLuint -> + GLenum -> + GLenum -> + GLuint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedFramebufferTexture2DEXT :: FunPtr FuntypeNamedFramebufferTexture2DEXT -> FuntypeNamedFramebufferTexture2DEXT +glrefNamedFramebufferTexture2DEXT :: IORef FuntypeNamedFramebufferTexture2DEXT +glrefNamedFramebufferTexture2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedFramebufferTexture2DEXT #-} +glNamedFramebufferTexture2DEXT :: FuntypeNamedFramebufferTexture2DEXT +glNamedFramebufferTexture2DEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTexture2DEXT +{-# INLINE glNamedFramebufferTexture2DEXT #-} +type FuntypeNamedFramebufferTexture3DEXT = + GLuint -> + GLenum -> + GLenum -> + GLuint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedFramebufferTexture3DEXT :: FunPtr FuntypeNamedFramebufferTexture3DEXT -> FuntypeNamedFramebufferTexture3DEXT +glrefNamedFramebufferTexture3DEXT :: IORef FuntypeNamedFramebufferTexture3DEXT +glrefNamedFramebufferTexture3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedFramebufferTexture3DEXT #-} +glNamedFramebufferTexture3DEXT :: FuntypeNamedFramebufferTexture3DEXT +glNamedFramebufferTexture3DEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTexture3DEXT +{-# INLINE glNamedFramebufferTexture3DEXT #-} +type FuntypeNamedFramebufferRenderbufferEXT = + GLuint -> + GLenum -> + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedFramebufferRenderbufferEXT :: FunPtr FuntypeNamedFramebufferRenderbufferEXT -> FuntypeNamedFramebufferRenderbufferEXT +glrefNamedFramebufferRenderbufferEXT :: IORef FuntypeNamedFramebufferRenderbufferEXT +glrefNamedFramebufferRenderbufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedFramebufferRenderbufferEXT #-} +glNamedFramebufferRenderbufferEXT :: FuntypeNamedFramebufferRenderbufferEXT +glNamedFramebufferRenderbufferEXT = unsafePerformIO $ readIORef glrefNamedFramebufferRenderbufferEXT +{-# INLINE glNamedFramebufferRenderbufferEXT #-} +type FuntypeGetNamedFramebufferAttachmentParameterivEXT = + GLuint -> + GLenum -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedFramebufferAttachmentParameterivEXT :: FunPtr FuntypeGetNamedFramebufferAttachmentParameterivEXT -> FuntypeGetNamedFramebufferAttachmentParameterivEXT +glrefGetNamedFramebufferAttachmentParameterivEXT :: IORef FuntypeGetNamedFramebufferAttachmentParameterivEXT +glrefGetNamedFramebufferAttachmentParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedFramebufferAttachmentParameterivEXT #-} +glGetNamedFramebufferAttachmentParameterivEXT :: FuntypeGetNamedFramebufferAttachmentParameterivEXT +glGetNamedFramebufferAttachmentParameterivEXT = unsafePerformIO $ readIORef glrefGetNamedFramebufferAttachmentParameterivEXT +{-# INLINE glGetNamedFramebufferAttachmentParameterivEXT #-} +type FuntypeGenerateTextureMipmapEXT = + GLuint -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGenerateTextureMipmapEXT :: FunPtr FuntypeGenerateTextureMipmapEXT -> FuntypeGenerateTextureMipmapEXT +glrefGenerateTextureMipmapEXT :: IORef FuntypeGenerateTextureMipmapEXT +glrefGenerateTextureMipmapEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGenerateTextureMipmapEXT #-} +glGenerateTextureMipmapEXT :: FuntypeGenerateTextureMipmapEXT +glGenerateTextureMipmapEXT = unsafePerformIO $ readIORef glrefGenerateTextureMipmapEXT +{-# INLINE glGenerateTextureMipmapEXT #-} +type FuntypeGenerateMultiTexMipmapEXT = + GLenum -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGenerateMultiTexMipmapEXT :: FunPtr FuntypeGenerateMultiTexMipmapEXT -> FuntypeGenerateMultiTexMipmapEXT +glrefGenerateMultiTexMipmapEXT :: IORef FuntypeGenerateMultiTexMipmapEXT +glrefGenerateMultiTexMipmapEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGenerateMultiTexMipmapEXT #-} +glGenerateMultiTexMipmapEXT :: FuntypeGenerateMultiTexMipmapEXT +glGenerateMultiTexMipmapEXT = unsafePerformIO $ readIORef glrefGenerateMultiTexMipmapEXT +{-# INLINE glGenerateMultiTexMipmapEXT #-} +type FuntypeFramebufferDrawBufferEXT = + GLuint -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFramebufferDrawBufferEXT :: FunPtr FuntypeFramebufferDrawBufferEXT -> FuntypeFramebufferDrawBufferEXT +glrefFramebufferDrawBufferEXT :: IORef FuntypeFramebufferDrawBufferEXT +glrefFramebufferDrawBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFramebufferDrawBufferEXT #-} +glFramebufferDrawBufferEXT :: FuntypeFramebufferDrawBufferEXT +glFramebufferDrawBufferEXT = unsafePerformIO $ readIORef glrefFramebufferDrawBufferEXT +{-# INLINE glFramebufferDrawBufferEXT #-} +type FuntypeFramebufferDrawBuffersEXT = + GLuint -> + GLsizei -> + Ptr (GLenum) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFramebufferDrawBuffersEXT :: FunPtr FuntypeFramebufferDrawBuffersEXT -> FuntypeFramebufferDrawBuffersEXT +glrefFramebufferDrawBuffersEXT :: IORef FuntypeFramebufferDrawBuffersEXT +glrefFramebufferDrawBuffersEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFramebufferDrawBuffersEXT #-} +glFramebufferDrawBuffersEXT :: FuntypeFramebufferDrawBuffersEXT +glFramebufferDrawBuffersEXT = unsafePerformIO $ readIORef glrefFramebufferDrawBuffersEXT +{-# INLINE glFramebufferDrawBuffersEXT #-} +type FuntypeFramebufferReadBufferEXT = + GLuint -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFramebufferReadBufferEXT :: FunPtr FuntypeFramebufferReadBufferEXT -> FuntypeFramebufferReadBufferEXT +glrefFramebufferReadBufferEXT :: IORef FuntypeFramebufferReadBufferEXT +glrefFramebufferReadBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFramebufferReadBufferEXT #-} +glFramebufferReadBufferEXT :: FuntypeFramebufferReadBufferEXT +glFramebufferReadBufferEXT = unsafePerformIO $ readIORef glrefFramebufferReadBufferEXT +{-# INLINE glFramebufferReadBufferEXT #-} +type FuntypeGetFramebufferParameterivEXT = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetFramebufferParameterivEXT :: FunPtr FuntypeGetFramebufferParameterivEXT -> FuntypeGetFramebufferParameterivEXT +glrefGetFramebufferParameterivEXT :: IORef FuntypeGetFramebufferParameterivEXT +glrefGetFramebufferParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetFramebufferParameterivEXT #-} +glGetFramebufferParameterivEXT :: FuntypeGetFramebufferParameterivEXT +glGetFramebufferParameterivEXT = unsafePerformIO $ readIORef glrefGetFramebufferParameterivEXT +{-# INLINE glGetFramebufferParameterivEXT #-} +type FuntypeNamedCopyBufferSubDataEXT = + GLuint -> + GLuint -> + GLintptr -> + GLintptr -> + GLsizeiptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedCopyBufferSubDataEXT :: FunPtr FuntypeNamedCopyBufferSubDataEXT -> FuntypeNamedCopyBufferSubDataEXT +glrefNamedCopyBufferSubDataEXT :: IORef FuntypeNamedCopyBufferSubDataEXT +glrefNamedCopyBufferSubDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedCopyBufferSubDataEXT #-} +glNamedCopyBufferSubDataEXT :: FuntypeNamedCopyBufferSubDataEXT +glNamedCopyBufferSubDataEXT = unsafePerformIO $ readIORef glrefNamedCopyBufferSubDataEXT +{-# INLINE glNamedCopyBufferSubDataEXT #-} +type FuntypeNamedFramebufferTextureEXT = + GLuint -> + GLenum -> + GLuint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedFramebufferTextureEXT :: FunPtr FuntypeNamedFramebufferTextureEXT -> FuntypeNamedFramebufferTextureEXT +glrefNamedFramebufferTextureEXT :: IORef FuntypeNamedFramebufferTextureEXT +glrefNamedFramebufferTextureEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedFramebufferTextureEXT #-} +glNamedFramebufferTextureEXT :: FuntypeNamedFramebufferTextureEXT +glNamedFramebufferTextureEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTextureEXT +{-# INLINE glNamedFramebufferTextureEXT #-} +type FuntypeNamedFramebufferTextureLayerEXT = + GLuint -> + GLenum -> + GLuint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedFramebufferTextureLayerEXT :: FunPtr FuntypeNamedFramebufferTextureLayerEXT -> FuntypeNamedFramebufferTextureLayerEXT +glrefNamedFramebufferTextureLayerEXT :: IORef FuntypeNamedFramebufferTextureLayerEXT +glrefNamedFramebufferTextureLayerEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedFramebufferTextureLayerEXT #-} +glNamedFramebufferTextureLayerEXT :: FuntypeNamedFramebufferTextureLayerEXT +glNamedFramebufferTextureLayerEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTextureLayerEXT +{-# INLINE glNamedFramebufferTextureLayerEXT #-} +type FuntypeNamedFramebufferTextureFaceEXT = + GLuint -> + GLenum -> + GLuint -> + GLint -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedFramebufferTextureFaceEXT :: FunPtr FuntypeNamedFramebufferTextureFaceEXT -> FuntypeNamedFramebufferTextureFaceEXT +glrefNamedFramebufferTextureFaceEXT :: IORef FuntypeNamedFramebufferTextureFaceEXT +glrefNamedFramebufferTextureFaceEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedFramebufferTextureFaceEXT #-} +glNamedFramebufferTextureFaceEXT :: FuntypeNamedFramebufferTextureFaceEXT +glNamedFramebufferTextureFaceEXT = unsafePerformIO $ readIORef glrefNamedFramebufferTextureFaceEXT +{-# INLINE glNamedFramebufferTextureFaceEXT #-} +type FuntypeTextureRenderbufferEXT = + GLuint -> + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureRenderbufferEXT :: FunPtr FuntypeTextureRenderbufferEXT -> FuntypeTextureRenderbufferEXT +glrefTextureRenderbufferEXT :: IORef FuntypeTextureRenderbufferEXT +glrefTextureRenderbufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureRenderbufferEXT #-} +glTextureRenderbufferEXT :: FuntypeTextureRenderbufferEXT +glTextureRenderbufferEXT = unsafePerformIO $ readIORef glrefTextureRenderbufferEXT +{-# INLINE glTextureRenderbufferEXT #-} +type FuntypeMultiTexRenderbufferEXT = + GLenum -> + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMultiTexRenderbufferEXT :: FunPtr FuntypeMultiTexRenderbufferEXT -> FuntypeMultiTexRenderbufferEXT +glrefMultiTexRenderbufferEXT :: IORef FuntypeMultiTexRenderbufferEXT +glrefMultiTexRenderbufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMultiTexRenderbufferEXT #-} +glMultiTexRenderbufferEXT :: FuntypeMultiTexRenderbufferEXT +glMultiTexRenderbufferEXT = unsafePerformIO $ readIORef glrefMultiTexRenderbufferEXT +{-# INLINE glMultiTexRenderbufferEXT #-} +type FuntypeVertexArrayVertexOffsetEXT = + GLuint -> + GLuint -> + GLint -> + GLenum -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayVertexOffsetEXT :: FunPtr FuntypeVertexArrayVertexOffsetEXT -> FuntypeVertexArrayVertexOffsetEXT +glrefVertexArrayVertexOffsetEXT :: IORef FuntypeVertexArrayVertexOffsetEXT +glrefVertexArrayVertexOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayVertexOffsetEXT #-} +glVertexArrayVertexOffsetEXT :: FuntypeVertexArrayVertexOffsetEXT +glVertexArrayVertexOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexOffsetEXT +{-# INLINE glVertexArrayVertexOffsetEXT #-} +type FuntypeVertexArrayColorOffsetEXT = + GLuint -> + GLuint -> + GLint -> + GLenum -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayColorOffsetEXT :: FunPtr FuntypeVertexArrayColorOffsetEXT -> FuntypeVertexArrayColorOffsetEXT +glrefVertexArrayColorOffsetEXT :: IORef FuntypeVertexArrayColorOffsetEXT +glrefVertexArrayColorOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayColorOffsetEXT #-} +glVertexArrayColorOffsetEXT :: FuntypeVertexArrayColorOffsetEXT +glVertexArrayColorOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayColorOffsetEXT +{-# INLINE glVertexArrayColorOffsetEXT #-} +type FuntypeVertexArrayEdgeFlagOffsetEXT = + GLuint -> + GLuint -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayEdgeFlagOffsetEXT :: FunPtr FuntypeVertexArrayEdgeFlagOffsetEXT -> FuntypeVertexArrayEdgeFlagOffsetEXT +glrefVertexArrayEdgeFlagOffsetEXT :: IORef FuntypeVertexArrayEdgeFlagOffsetEXT +glrefVertexArrayEdgeFlagOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayEdgeFlagOffsetEXT #-} +glVertexArrayEdgeFlagOffsetEXT :: FuntypeVertexArrayEdgeFlagOffsetEXT +glVertexArrayEdgeFlagOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayEdgeFlagOffsetEXT +{-# INLINE glVertexArrayEdgeFlagOffsetEXT #-} +type FuntypeVertexArrayIndexOffsetEXT = + GLuint -> + GLuint -> + GLenum -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayIndexOffsetEXT :: FunPtr FuntypeVertexArrayIndexOffsetEXT -> FuntypeVertexArrayIndexOffsetEXT +glrefVertexArrayIndexOffsetEXT :: IORef FuntypeVertexArrayIndexOffsetEXT +glrefVertexArrayIndexOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayIndexOffsetEXT #-} +glVertexArrayIndexOffsetEXT :: FuntypeVertexArrayIndexOffsetEXT +glVertexArrayIndexOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayIndexOffsetEXT +{-# INLINE glVertexArrayIndexOffsetEXT #-} +type FuntypeVertexArrayNormalOffsetEXT = + GLuint -> + GLuint -> + GLenum -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayNormalOffsetEXT :: FunPtr FuntypeVertexArrayNormalOffsetEXT -> FuntypeVertexArrayNormalOffsetEXT +glrefVertexArrayNormalOffsetEXT :: IORef FuntypeVertexArrayNormalOffsetEXT +glrefVertexArrayNormalOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayNormalOffsetEXT #-} +glVertexArrayNormalOffsetEXT :: FuntypeVertexArrayNormalOffsetEXT +glVertexArrayNormalOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayNormalOffsetEXT +{-# INLINE glVertexArrayNormalOffsetEXT #-} +type FuntypeVertexArrayTexCoordOffsetEXT = + GLuint -> + GLuint -> + GLint -> + GLenum -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayTexCoordOffsetEXT :: FunPtr FuntypeVertexArrayTexCoordOffsetEXT -> FuntypeVertexArrayTexCoordOffsetEXT +glrefVertexArrayTexCoordOffsetEXT :: IORef FuntypeVertexArrayTexCoordOffsetEXT +glrefVertexArrayTexCoordOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayTexCoordOffsetEXT #-} +glVertexArrayTexCoordOffsetEXT :: FuntypeVertexArrayTexCoordOffsetEXT +glVertexArrayTexCoordOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayTexCoordOffsetEXT +{-# INLINE glVertexArrayTexCoordOffsetEXT #-} +type FuntypeVertexArrayMultiTexCoordOffsetEXT = + GLuint -> + GLuint -> + GLenum -> + GLint -> + GLenum -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayMultiTexCoordOffsetEXT :: FunPtr FuntypeVertexArrayMultiTexCoordOffsetEXT -> FuntypeVertexArrayMultiTexCoordOffsetEXT +glrefVertexArrayMultiTexCoordOffsetEXT :: IORef FuntypeVertexArrayMultiTexCoordOffsetEXT +glrefVertexArrayMultiTexCoordOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayMultiTexCoordOffsetEXT #-} +glVertexArrayMultiTexCoordOffsetEXT :: FuntypeVertexArrayMultiTexCoordOffsetEXT +glVertexArrayMultiTexCoordOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayMultiTexCoordOffsetEXT +{-# INLINE glVertexArrayMultiTexCoordOffsetEXT #-} +type FuntypeVertexArrayFogCoordOffsetEXT = + GLuint -> + GLuint -> + GLenum -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayFogCoordOffsetEXT :: FunPtr FuntypeVertexArrayFogCoordOffsetEXT -> FuntypeVertexArrayFogCoordOffsetEXT +glrefVertexArrayFogCoordOffsetEXT :: IORef FuntypeVertexArrayFogCoordOffsetEXT +glrefVertexArrayFogCoordOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayFogCoordOffsetEXT #-} +glVertexArrayFogCoordOffsetEXT :: FuntypeVertexArrayFogCoordOffsetEXT +glVertexArrayFogCoordOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayFogCoordOffsetEXT +{-# INLINE glVertexArrayFogCoordOffsetEXT #-} +type FuntypeVertexArraySecondaryColorOffsetEXT = + GLuint -> + GLuint -> + GLint -> + GLenum -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArraySecondaryColorOffsetEXT :: FunPtr FuntypeVertexArraySecondaryColorOffsetEXT -> FuntypeVertexArraySecondaryColorOffsetEXT +glrefVertexArraySecondaryColorOffsetEXT :: IORef FuntypeVertexArraySecondaryColorOffsetEXT +glrefVertexArraySecondaryColorOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArraySecondaryColorOffsetEXT #-} +glVertexArraySecondaryColorOffsetEXT :: FuntypeVertexArraySecondaryColorOffsetEXT +glVertexArraySecondaryColorOffsetEXT = unsafePerformIO $ readIORef glrefVertexArraySecondaryColorOffsetEXT +{-# INLINE glVertexArraySecondaryColorOffsetEXT #-} +type FuntypeVertexArrayVertexAttribOffsetEXT = + GLuint -> + GLuint -> + GLuint -> + GLint -> + GLenum -> + GLboolean -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayVertexAttribOffsetEXT :: FunPtr FuntypeVertexArrayVertexAttribOffsetEXT -> FuntypeVertexArrayVertexAttribOffsetEXT +glrefVertexArrayVertexAttribOffsetEXT :: IORef FuntypeVertexArrayVertexAttribOffsetEXT +glrefVertexArrayVertexAttribOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayVertexAttribOffsetEXT #-} +glVertexArrayVertexAttribOffsetEXT :: FuntypeVertexArrayVertexAttribOffsetEXT +glVertexArrayVertexAttribOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribOffsetEXT +{-# INLINE glVertexArrayVertexAttribOffsetEXT #-} +type FuntypeVertexArrayVertexAttribIOffsetEXT = + GLuint -> + GLuint -> + GLuint -> + GLint -> + GLenum -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayVertexAttribIOffsetEXT :: FunPtr FuntypeVertexArrayVertexAttribIOffsetEXT -> FuntypeVertexArrayVertexAttribIOffsetEXT +glrefVertexArrayVertexAttribIOffsetEXT :: IORef FuntypeVertexArrayVertexAttribIOffsetEXT +glrefVertexArrayVertexAttribIOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayVertexAttribIOffsetEXT #-} +glVertexArrayVertexAttribIOffsetEXT :: FuntypeVertexArrayVertexAttribIOffsetEXT +glVertexArrayVertexAttribIOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribIOffsetEXT +{-# INLINE glVertexArrayVertexAttribIOffsetEXT #-} +type FuntypeEnableVertexArrayEXT = + GLuint -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynEnableVertexArrayEXT :: FunPtr FuntypeEnableVertexArrayEXT -> FuntypeEnableVertexArrayEXT +glrefEnableVertexArrayEXT :: IORef FuntypeEnableVertexArrayEXT +glrefEnableVertexArrayEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefEnableVertexArrayEXT #-} +glEnableVertexArrayEXT :: FuntypeEnableVertexArrayEXT +glEnableVertexArrayEXT = unsafePerformIO $ readIORef glrefEnableVertexArrayEXT +{-# INLINE glEnableVertexArrayEXT #-} +type FuntypeDisableVertexArrayEXT = + GLuint -> + GLenum -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDisableVertexArrayEXT :: FunPtr FuntypeDisableVertexArrayEXT -> FuntypeDisableVertexArrayEXT +glrefDisableVertexArrayEXT :: IORef FuntypeDisableVertexArrayEXT +glrefDisableVertexArrayEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDisableVertexArrayEXT #-} +glDisableVertexArrayEXT :: FuntypeDisableVertexArrayEXT +glDisableVertexArrayEXT = unsafePerformIO $ readIORef glrefDisableVertexArrayEXT +{-# INLINE glDisableVertexArrayEXT #-} +type FuntypeEnableVertexArrayAttribEXT = + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynEnableVertexArrayAttribEXT :: FunPtr FuntypeEnableVertexArrayAttribEXT -> FuntypeEnableVertexArrayAttribEXT +glrefEnableVertexArrayAttribEXT :: IORef FuntypeEnableVertexArrayAttribEXT +glrefEnableVertexArrayAttribEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefEnableVertexArrayAttribEXT #-} +glEnableVertexArrayAttribEXT :: FuntypeEnableVertexArrayAttribEXT +glEnableVertexArrayAttribEXT = unsafePerformIO $ readIORef glrefEnableVertexArrayAttribEXT +{-# INLINE glEnableVertexArrayAttribEXT #-} +type FuntypeDisableVertexArrayAttribEXT = + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDisableVertexArrayAttribEXT :: FunPtr FuntypeDisableVertexArrayAttribEXT -> FuntypeDisableVertexArrayAttribEXT +glrefDisableVertexArrayAttribEXT :: IORef FuntypeDisableVertexArrayAttribEXT +glrefDisableVertexArrayAttribEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDisableVertexArrayAttribEXT #-} +glDisableVertexArrayAttribEXT :: FuntypeDisableVertexArrayAttribEXT +glDisableVertexArrayAttribEXT = unsafePerformIO $ readIORef glrefDisableVertexArrayAttribEXT +{-# INLINE glDisableVertexArrayAttribEXT #-} +type FuntypeGetVertexArrayIntegervEXT = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetVertexArrayIntegervEXT :: FunPtr FuntypeGetVertexArrayIntegervEXT -> FuntypeGetVertexArrayIntegervEXT +glrefGetVertexArrayIntegervEXT :: IORef FuntypeGetVertexArrayIntegervEXT +glrefGetVertexArrayIntegervEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetVertexArrayIntegervEXT #-} +glGetVertexArrayIntegervEXT :: FuntypeGetVertexArrayIntegervEXT +glGetVertexArrayIntegervEXT = unsafePerformIO $ readIORef glrefGetVertexArrayIntegervEXT +{-# INLINE glGetVertexArrayIntegervEXT #-} +type FuntypeGetVertexArrayPointervEXT = + GLuint -> + GLenum -> + Ptr (Ptr ()) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetVertexArrayPointervEXT :: FunPtr FuntypeGetVertexArrayPointervEXT -> FuntypeGetVertexArrayPointervEXT +glrefGetVertexArrayPointervEXT :: IORef FuntypeGetVertexArrayPointervEXT +glrefGetVertexArrayPointervEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetVertexArrayPointervEXT #-} +glGetVertexArrayPointervEXT :: FuntypeGetVertexArrayPointervEXT +glGetVertexArrayPointervEXT = unsafePerformIO $ readIORef glrefGetVertexArrayPointervEXT +{-# INLINE glGetVertexArrayPointervEXT #-} +type FuntypeGetVertexArrayIntegeri_vEXT = + GLuint -> + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetVertexArrayIntegeri_vEXT :: FunPtr FuntypeGetVertexArrayIntegeri_vEXT -> FuntypeGetVertexArrayIntegeri_vEXT +glrefGetVertexArrayIntegeri_vEXT :: IORef FuntypeGetVertexArrayIntegeri_vEXT +glrefGetVertexArrayIntegeri_vEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetVertexArrayIntegeri_vEXT #-} +glGetVertexArrayIntegeri_vEXT :: FuntypeGetVertexArrayIntegeri_vEXT +glGetVertexArrayIntegeri_vEXT = unsafePerformIO $ readIORef glrefGetVertexArrayIntegeri_vEXT +{-# INLINE glGetVertexArrayIntegeri_vEXT #-} +type FuntypeGetVertexArrayPointeri_vEXT = + GLuint -> + GLuint -> + GLenum -> + Ptr (Ptr ()) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetVertexArrayPointeri_vEXT :: FunPtr FuntypeGetVertexArrayPointeri_vEXT -> FuntypeGetVertexArrayPointeri_vEXT +glrefGetVertexArrayPointeri_vEXT :: IORef FuntypeGetVertexArrayPointeri_vEXT +glrefGetVertexArrayPointeri_vEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetVertexArrayPointeri_vEXT #-} +glGetVertexArrayPointeri_vEXT :: FuntypeGetVertexArrayPointeri_vEXT +glGetVertexArrayPointeri_vEXT = unsafePerformIO $ readIORef glrefGetVertexArrayPointeri_vEXT +{-# INLINE glGetVertexArrayPointeri_vEXT #-} +type FuntypeMapNamedBufferRangeEXT = + GLuint -> + GLintptr -> + GLsizeiptr -> + GLbitfield -> + IO ( Ptr () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynMapNamedBufferRangeEXT :: FunPtr FuntypeMapNamedBufferRangeEXT -> FuntypeMapNamedBufferRangeEXT +glrefMapNamedBufferRangeEXT :: IORef FuntypeMapNamedBufferRangeEXT +glrefMapNamedBufferRangeEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefMapNamedBufferRangeEXT #-} +glMapNamedBufferRangeEXT :: FuntypeMapNamedBufferRangeEXT +glMapNamedBufferRangeEXT = unsafePerformIO $ readIORef glrefMapNamedBufferRangeEXT +{-# INLINE glMapNamedBufferRangeEXT #-} +type FuntypeFlushMappedNamedBufferRangeEXT = + GLuint -> + GLintptr -> + GLsizeiptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynFlushMappedNamedBufferRangeEXT :: FunPtr FuntypeFlushMappedNamedBufferRangeEXT -> FuntypeFlushMappedNamedBufferRangeEXT +glrefFlushMappedNamedBufferRangeEXT :: IORef FuntypeFlushMappedNamedBufferRangeEXT +glrefFlushMappedNamedBufferRangeEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefFlushMappedNamedBufferRangeEXT #-} +glFlushMappedNamedBufferRangeEXT :: FuntypeFlushMappedNamedBufferRangeEXT +glFlushMappedNamedBufferRangeEXT = unsafePerformIO $ readIORef glrefFlushMappedNamedBufferRangeEXT +{-# INLINE glFlushMappedNamedBufferRangeEXT #-} +type FuntypeNamedBufferStorageEXT = + GLuint -> + GLsizeiptr -> + Ptr () -> + GLbitfield -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedBufferStorageEXT :: FunPtr FuntypeNamedBufferStorageEXT -> FuntypeNamedBufferStorageEXT +glrefNamedBufferStorageEXT :: IORef FuntypeNamedBufferStorageEXT +glrefNamedBufferStorageEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedBufferStorageEXT #-} +glNamedBufferStorageEXT :: FuntypeNamedBufferStorageEXT +glNamedBufferStorageEXT = unsafePerformIO $ readIORef glrefNamedBufferStorageEXT +{-# INLINE glNamedBufferStorageEXT #-} +type FuntypeClearNamedBufferDataEXT = + GLuint -> + GLenum -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClearNamedBufferDataEXT :: FunPtr FuntypeClearNamedBufferDataEXT -> FuntypeClearNamedBufferDataEXT +glrefClearNamedBufferDataEXT :: IORef FuntypeClearNamedBufferDataEXT +glrefClearNamedBufferDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClearNamedBufferDataEXT #-} +glClearNamedBufferDataEXT :: FuntypeClearNamedBufferDataEXT +glClearNamedBufferDataEXT = unsafePerformIO $ readIORef glrefClearNamedBufferDataEXT +{-# INLINE glClearNamedBufferDataEXT #-} +type FuntypeClearNamedBufferSubDataEXT = + GLuint -> + GLenum -> + GLsizeiptr -> + GLsizeiptr -> + GLenum -> + GLenum -> + Ptr () -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynClearNamedBufferSubDataEXT :: FunPtr FuntypeClearNamedBufferSubDataEXT -> FuntypeClearNamedBufferSubDataEXT +glrefClearNamedBufferSubDataEXT :: IORef FuntypeClearNamedBufferSubDataEXT +glrefClearNamedBufferSubDataEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefClearNamedBufferSubDataEXT #-} +glClearNamedBufferSubDataEXT :: FuntypeClearNamedBufferSubDataEXT +glClearNamedBufferSubDataEXT = unsafePerformIO $ readIORef glrefClearNamedBufferSubDataEXT +{-# INLINE glClearNamedBufferSubDataEXT #-} +type FuntypeNamedFramebufferParameteriEXT = + GLuint -> + GLenum -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynNamedFramebufferParameteriEXT :: FunPtr FuntypeNamedFramebufferParameteriEXT -> FuntypeNamedFramebufferParameteriEXT +glrefNamedFramebufferParameteriEXT :: IORef FuntypeNamedFramebufferParameteriEXT +glrefNamedFramebufferParameteriEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefNamedFramebufferParameteriEXT #-} +glNamedFramebufferParameteriEXT :: FuntypeNamedFramebufferParameteriEXT +glNamedFramebufferParameteriEXT = unsafePerformIO $ readIORef glrefNamedFramebufferParameteriEXT +{-# INLINE glNamedFramebufferParameteriEXT #-} +type FuntypeGetNamedFramebufferParameterivEXT = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetNamedFramebufferParameterivEXT :: FunPtr FuntypeGetNamedFramebufferParameterivEXT -> FuntypeGetNamedFramebufferParameterivEXT +glrefGetNamedFramebufferParameterivEXT :: IORef FuntypeGetNamedFramebufferParameterivEXT +glrefGetNamedFramebufferParameterivEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetNamedFramebufferParameterivEXT #-} +glGetNamedFramebufferParameterivEXT :: FuntypeGetNamedFramebufferParameterivEXT +glGetNamedFramebufferParameterivEXT = unsafePerformIO $ readIORef glrefGetNamedFramebufferParameterivEXT +{-# INLINE glGetNamedFramebufferParameterivEXT #-} +type FuntypeProgramUniform1dEXT = + GLuint -> + GLint -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1dEXT :: FunPtr FuntypeProgramUniform1dEXT -> FuntypeProgramUniform1dEXT +glrefProgramUniform1dEXT :: IORef FuntypeProgramUniform1dEXT +glrefProgramUniform1dEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1dEXT #-} +glProgramUniform1dEXT :: FuntypeProgramUniform1dEXT +glProgramUniform1dEXT = unsafePerformIO $ readIORef glrefProgramUniform1dEXT +{-# INLINE glProgramUniform1dEXT #-} +type FuntypeProgramUniform2dEXT = + GLuint -> + GLint -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2dEXT :: FunPtr FuntypeProgramUniform2dEXT -> FuntypeProgramUniform2dEXT +glrefProgramUniform2dEXT :: IORef FuntypeProgramUniform2dEXT +glrefProgramUniform2dEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2dEXT #-} +glProgramUniform2dEXT :: FuntypeProgramUniform2dEXT +glProgramUniform2dEXT = unsafePerformIO $ readIORef glrefProgramUniform2dEXT +{-# INLINE glProgramUniform2dEXT #-} +type FuntypeProgramUniform3dEXT = + GLuint -> + GLint -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3dEXT :: FunPtr FuntypeProgramUniform3dEXT -> FuntypeProgramUniform3dEXT +glrefProgramUniform3dEXT :: IORef FuntypeProgramUniform3dEXT +glrefProgramUniform3dEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3dEXT #-} +glProgramUniform3dEXT :: FuntypeProgramUniform3dEXT +glProgramUniform3dEXT = unsafePerformIO $ readIORef glrefProgramUniform3dEXT +{-# INLINE glProgramUniform3dEXT #-} +type FuntypeProgramUniform4dEXT = + GLuint -> + GLint -> + GLdouble -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4dEXT :: FunPtr FuntypeProgramUniform4dEXT -> FuntypeProgramUniform4dEXT +glrefProgramUniform4dEXT :: IORef FuntypeProgramUniform4dEXT +glrefProgramUniform4dEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4dEXT #-} +glProgramUniform4dEXT :: FuntypeProgramUniform4dEXT +glProgramUniform4dEXT = unsafePerformIO $ readIORef glrefProgramUniform4dEXT +{-# INLINE glProgramUniform4dEXT #-} +type FuntypeProgramUniform1dvEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1dvEXT :: FunPtr FuntypeProgramUniform1dvEXT -> FuntypeProgramUniform1dvEXT +glrefProgramUniform1dvEXT :: IORef FuntypeProgramUniform1dvEXT +glrefProgramUniform1dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1dvEXT #-} +glProgramUniform1dvEXT :: FuntypeProgramUniform1dvEXT +glProgramUniform1dvEXT = unsafePerformIO $ readIORef glrefProgramUniform1dvEXT +{-# INLINE glProgramUniform1dvEXT #-} +type FuntypeProgramUniform2dvEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2dvEXT :: FunPtr FuntypeProgramUniform2dvEXT -> FuntypeProgramUniform2dvEXT +glrefProgramUniform2dvEXT :: IORef FuntypeProgramUniform2dvEXT +glrefProgramUniform2dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2dvEXT #-} +glProgramUniform2dvEXT :: FuntypeProgramUniform2dvEXT +glProgramUniform2dvEXT = unsafePerformIO $ readIORef glrefProgramUniform2dvEXT +{-# INLINE glProgramUniform2dvEXT #-} +type FuntypeProgramUniform3dvEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3dvEXT :: FunPtr FuntypeProgramUniform3dvEXT -> FuntypeProgramUniform3dvEXT +glrefProgramUniform3dvEXT :: IORef FuntypeProgramUniform3dvEXT +glrefProgramUniform3dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3dvEXT #-} +glProgramUniform3dvEXT :: FuntypeProgramUniform3dvEXT +glProgramUniform3dvEXT = unsafePerformIO $ readIORef glrefProgramUniform3dvEXT +{-# INLINE glProgramUniform3dvEXT #-} +type FuntypeProgramUniform4dvEXT = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4dvEXT :: FunPtr FuntypeProgramUniform4dvEXT -> FuntypeProgramUniform4dvEXT +glrefProgramUniform4dvEXT :: IORef FuntypeProgramUniform4dvEXT +glrefProgramUniform4dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4dvEXT #-} +glProgramUniform4dvEXT :: FuntypeProgramUniform4dvEXT +glProgramUniform4dvEXT = unsafePerformIO $ readIORef glrefProgramUniform4dvEXT +{-# INLINE glProgramUniform4dvEXT #-} +type FuntypeProgramUniformMatrix2dvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2dvEXT :: FunPtr FuntypeProgramUniformMatrix2dvEXT -> FuntypeProgramUniformMatrix2dvEXT +glrefProgramUniformMatrix2dvEXT :: IORef FuntypeProgramUniformMatrix2dvEXT +glrefProgramUniformMatrix2dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2dvEXT #-} +glProgramUniformMatrix2dvEXT :: FuntypeProgramUniformMatrix2dvEXT +glProgramUniformMatrix2dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2dvEXT +{-# INLINE glProgramUniformMatrix2dvEXT #-} +type FuntypeProgramUniformMatrix3dvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3dvEXT :: FunPtr FuntypeProgramUniformMatrix3dvEXT -> FuntypeProgramUniformMatrix3dvEXT +glrefProgramUniformMatrix3dvEXT :: IORef FuntypeProgramUniformMatrix3dvEXT +glrefProgramUniformMatrix3dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3dvEXT #-} +glProgramUniformMatrix3dvEXT :: FuntypeProgramUniformMatrix3dvEXT +glProgramUniformMatrix3dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3dvEXT +{-# INLINE glProgramUniformMatrix3dvEXT #-} +type FuntypeProgramUniformMatrix4dvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4dvEXT :: FunPtr FuntypeProgramUniformMatrix4dvEXT -> FuntypeProgramUniformMatrix4dvEXT +glrefProgramUniformMatrix4dvEXT :: IORef FuntypeProgramUniformMatrix4dvEXT +glrefProgramUniformMatrix4dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4dvEXT #-} +glProgramUniformMatrix4dvEXT :: FuntypeProgramUniformMatrix4dvEXT +glProgramUniformMatrix4dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4dvEXT +{-# INLINE glProgramUniformMatrix4dvEXT #-} +type FuntypeProgramUniformMatrix2x3dvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2x3dvEXT :: FunPtr FuntypeProgramUniformMatrix2x3dvEXT -> FuntypeProgramUniformMatrix2x3dvEXT +glrefProgramUniformMatrix2x3dvEXT :: IORef FuntypeProgramUniformMatrix2x3dvEXT +glrefProgramUniformMatrix2x3dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2x3dvEXT #-} +glProgramUniformMatrix2x3dvEXT :: FuntypeProgramUniformMatrix2x3dvEXT +glProgramUniformMatrix2x3dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x3dvEXT +{-# INLINE glProgramUniformMatrix2x3dvEXT #-} +type FuntypeProgramUniformMatrix2x4dvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2x4dvEXT :: FunPtr FuntypeProgramUniformMatrix2x4dvEXT -> FuntypeProgramUniformMatrix2x4dvEXT +glrefProgramUniformMatrix2x4dvEXT :: IORef FuntypeProgramUniformMatrix2x4dvEXT +glrefProgramUniformMatrix2x4dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2x4dvEXT #-} +glProgramUniformMatrix2x4dvEXT :: FuntypeProgramUniformMatrix2x4dvEXT +glProgramUniformMatrix2x4dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x4dvEXT +{-# INLINE glProgramUniformMatrix2x4dvEXT #-} +type FuntypeProgramUniformMatrix3x2dvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3x2dvEXT :: FunPtr FuntypeProgramUniformMatrix3x2dvEXT -> FuntypeProgramUniformMatrix3x2dvEXT +glrefProgramUniformMatrix3x2dvEXT :: IORef FuntypeProgramUniformMatrix3x2dvEXT +glrefProgramUniformMatrix3x2dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3x2dvEXT #-} +glProgramUniformMatrix3x2dvEXT :: FuntypeProgramUniformMatrix3x2dvEXT +glProgramUniformMatrix3x2dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x2dvEXT +{-# INLINE glProgramUniformMatrix3x2dvEXT #-} +type FuntypeProgramUniformMatrix3x4dvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3x4dvEXT :: FunPtr FuntypeProgramUniformMatrix3x4dvEXT -> FuntypeProgramUniformMatrix3x4dvEXT +glrefProgramUniformMatrix3x4dvEXT :: IORef FuntypeProgramUniformMatrix3x4dvEXT +glrefProgramUniformMatrix3x4dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3x4dvEXT #-} +glProgramUniformMatrix3x4dvEXT :: FuntypeProgramUniformMatrix3x4dvEXT +glProgramUniformMatrix3x4dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x4dvEXT +{-# INLINE glProgramUniformMatrix3x4dvEXT #-} +type FuntypeProgramUniformMatrix4x2dvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4x2dvEXT :: FunPtr FuntypeProgramUniformMatrix4x2dvEXT -> FuntypeProgramUniformMatrix4x2dvEXT +glrefProgramUniformMatrix4x2dvEXT :: IORef FuntypeProgramUniformMatrix4x2dvEXT +glrefProgramUniformMatrix4x2dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4x2dvEXT #-} +glProgramUniformMatrix4x2dvEXT :: FuntypeProgramUniformMatrix4x2dvEXT +glProgramUniformMatrix4x2dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x2dvEXT +{-# INLINE glProgramUniformMatrix4x2dvEXT #-} +type FuntypeProgramUniformMatrix4x3dvEXT = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4x3dvEXT :: FunPtr FuntypeProgramUniformMatrix4x3dvEXT -> FuntypeProgramUniformMatrix4x3dvEXT +glrefProgramUniformMatrix4x3dvEXT :: IORef FuntypeProgramUniformMatrix4x3dvEXT +glrefProgramUniformMatrix4x3dvEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4x3dvEXT #-} +glProgramUniformMatrix4x3dvEXT :: FuntypeProgramUniformMatrix4x3dvEXT +glProgramUniformMatrix4x3dvEXT = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x3dvEXT +{-# INLINE glProgramUniformMatrix4x3dvEXT #-} +type FuntypeTextureBufferRangeEXT = + GLuint -> + GLenum -> + GLenum -> + GLuint -> + GLintptr -> + GLsizeiptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureBufferRangeEXT :: FunPtr FuntypeTextureBufferRangeEXT -> FuntypeTextureBufferRangeEXT +glrefTextureBufferRangeEXT :: IORef FuntypeTextureBufferRangeEXT +glrefTextureBufferRangeEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureBufferRangeEXT #-} +glTextureBufferRangeEXT :: FuntypeTextureBufferRangeEXT +glTextureBufferRangeEXT = unsafePerformIO $ readIORef glrefTextureBufferRangeEXT +{-# INLINE glTextureBufferRangeEXT #-} +type FuntypeTextureStorage1DEXT = + GLuint -> + GLenum -> + GLsizei -> + GLenum -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureStorage1DEXT :: FunPtr FuntypeTextureStorage1DEXT -> FuntypeTextureStorage1DEXT +glrefTextureStorage1DEXT :: IORef FuntypeTextureStorage1DEXT +glrefTextureStorage1DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureStorage1DEXT #-} +glTextureStorage1DEXT :: FuntypeTextureStorage1DEXT +glTextureStorage1DEXT = unsafePerformIO $ readIORef glrefTextureStorage1DEXT +{-# INLINE glTextureStorage1DEXT #-} +type FuntypeTextureStorage2DEXT = + GLuint -> + GLenum -> + GLsizei -> + GLenum -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureStorage2DEXT :: FunPtr FuntypeTextureStorage2DEXT -> FuntypeTextureStorage2DEXT +glrefTextureStorage2DEXT :: IORef FuntypeTextureStorage2DEXT +glrefTextureStorage2DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureStorage2DEXT #-} +glTextureStorage2DEXT :: FuntypeTextureStorage2DEXT +glTextureStorage2DEXT = unsafePerformIO $ readIORef glrefTextureStorage2DEXT +{-# INLINE glTextureStorage2DEXT #-} +type FuntypeTextureStorage3DEXT = + GLuint -> + GLenum -> + GLsizei -> + GLenum -> + GLsizei -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureStorage3DEXT :: FunPtr FuntypeTextureStorage3DEXT -> FuntypeTextureStorage3DEXT +glrefTextureStorage3DEXT :: IORef FuntypeTextureStorage3DEXT +glrefTextureStorage3DEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureStorage3DEXT #-} +glTextureStorage3DEXT :: FuntypeTextureStorage3DEXT +glTextureStorage3DEXT = unsafePerformIO $ readIORef glrefTextureStorage3DEXT +{-# INLINE glTextureStorage3DEXT #-} +type FuntypeTextureStorage2DMultisampleEXT = + GLuint -> + GLenum -> + GLsizei -> + GLenum -> + GLsizei -> + GLsizei -> + GLboolean -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureStorage2DMultisampleEXT :: FunPtr FuntypeTextureStorage2DMultisampleEXT -> FuntypeTextureStorage2DMultisampleEXT +glrefTextureStorage2DMultisampleEXT :: IORef FuntypeTextureStorage2DMultisampleEXT +glrefTextureStorage2DMultisampleEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureStorage2DMultisampleEXT #-} +glTextureStorage2DMultisampleEXT :: FuntypeTextureStorage2DMultisampleEXT +glTextureStorage2DMultisampleEXT = unsafePerformIO $ readIORef glrefTextureStorage2DMultisampleEXT +{-# INLINE glTextureStorage2DMultisampleEXT #-} +type FuntypeTextureStorage3DMultisampleEXT = + GLuint -> + GLenum -> + GLsizei -> + GLenum -> + GLsizei -> + GLsizei -> + GLsizei -> + GLboolean -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTextureStorage3DMultisampleEXT :: FunPtr FuntypeTextureStorage3DMultisampleEXT -> FuntypeTextureStorage3DMultisampleEXT +glrefTextureStorage3DMultisampleEXT :: IORef FuntypeTextureStorage3DMultisampleEXT +glrefTextureStorage3DMultisampleEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTextureStorage3DMultisampleEXT #-} +glTextureStorage3DMultisampleEXT :: FuntypeTextureStorage3DMultisampleEXT +glTextureStorage3DMultisampleEXT = unsafePerformIO $ readIORef glrefTextureStorage3DMultisampleEXT +{-# INLINE glTextureStorage3DMultisampleEXT #-} +type FuntypeVertexArrayBindVertexBufferEXT = + GLuint -> + GLuint -> + GLuint -> + GLintptr -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayBindVertexBufferEXT :: FunPtr FuntypeVertexArrayBindVertexBufferEXT -> FuntypeVertexArrayBindVertexBufferEXT +glrefVertexArrayBindVertexBufferEXT :: IORef FuntypeVertexArrayBindVertexBufferEXT +glrefVertexArrayBindVertexBufferEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayBindVertexBufferEXT #-} +glVertexArrayBindVertexBufferEXT :: FuntypeVertexArrayBindVertexBufferEXT +glVertexArrayBindVertexBufferEXT = unsafePerformIO $ readIORef glrefVertexArrayBindVertexBufferEXT +{-# INLINE glVertexArrayBindVertexBufferEXT #-} +type FuntypeVertexArrayVertexAttribFormatEXT = + GLuint -> + GLuint -> + GLint -> + GLenum -> + GLboolean -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayVertexAttribFormatEXT :: FunPtr FuntypeVertexArrayVertexAttribFormatEXT -> FuntypeVertexArrayVertexAttribFormatEXT +glrefVertexArrayVertexAttribFormatEXT :: IORef FuntypeVertexArrayVertexAttribFormatEXT +glrefVertexArrayVertexAttribFormatEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayVertexAttribFormatEXT #-} +glVertexArrayVertexAttribFormatEXT :: FuntypeVertexArrayVertexAttribFormatEXT +glVertexArrayVertexAttribFormatEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribFormatEXT +{-# INLINE glVertexArrayVertexAttribFormatEXT #-} +type FuntypeVertexArrayVertexAttribIFormatEXT = + GLuint -> + GLuint -> + GLint -> + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayVertexAttribIFormatEXT :: FunPtr FuntypeVertexArrayVertexAttribIFormatEXT -> FuntypeVertexArrayVertexAttribIFormatEXT +glrefVertexArrayVertexAttribIFormatEXT :: IORef FuntypeVertexArrayVertexAttribIFormatEXT +glrefVertexArrayVertexAttribIFormatEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayVertexAttribIFormatEXT #-} +glVertexArrayVertexAttribIFormatEXT :: FuntypeVertexArrayVertexAttribIFormatEXT +glVertexArrayVertexAttribIFormatEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribIFormatEXT +{-# INLINE glVertexArrayVertexAttribIFormatEXT #-} +type FuntypeVertexArrayVertexAttribLFormatEXT = + GLuint -> + GLuint -> + GLint -> + GLenum -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayVertexAttribLFormatEXT :: FunPtr FuntypeVertexArrayVertexAttribLFormatEXT -> FuntypeVertexArrayVertexAttribLFormatEXT +glrefVertexArrayVertexAttribLFormatEXT :: IORef FuntypeVertexArrayVertexAttribLFormatEXT +glrefVertexArrayVertexAttribLFormatEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayVertexAttribLFormatEXT #-} +glVertexArrayVertexAttribLFormatEXT :: FuntypeVertexArrayVertexAttribLFormatEXT +glVertexArrayVertexAttribLFormatEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribLFormatEXT +{-# INLINE glVertexArrayVertexAttribLFormatEXT #-} +type FuntypeVertexArrayVertexAttribBindingEXT = + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayVertexAttribBindingEXT :: FunPtr FuntypeVertexArrayVertexAttribBindingEXT -> FuntypeVertexArrayVertexAttribBindingEXT +glrefVertexArrayVertexAttribBindingEXT :: IORef FuntypeVertexArrayVertexAttribBindingEXT +glrefVertexArrayVertexAttribBindingEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayVertexAttribBindingEXT #-} +glVertexArrayVertexAttribBindingEXT :: FuntypeVertexArrayVertexAttribBindingEXT +glVertexArrayVertexAttribBindingEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribBindingEXT +{-# INLINE glVertexArrayVertexAttribBindingEXT #-} +type FuntypeVertexArrayVertexBindingDivisorEXT = + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayVertexBindingDivisorEXT :: FunPtr FuntypeVertexArrayVertexBindingDivisorEXT -> FuntypeVertexArrayVertexBindingDivisorEXT +glrefVertexArrayVertexBindingDivisorEXT :: IORef FuntypeVertexArrayVertexBindingDivisorEXT +glrefVertexArrayVertexBindingDivisorEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayVertexBindingDivisorEXT #-} +glVertexArrayVertexBindingDivisorEXT :: FuntypeVertexArrayVertexBindingDivisorEXT +glVertexArrayVertexBindingDivisorEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexBindingDivisorEXT +{-# INLINE glVertexArrayVertexBindingDivisorEXT #-} +type FuntypeVertexArrayVertexAttribLOffsetEXT = + GLuint -> + GLuint -> + GLuint -> + GLint -> + GLenum -> + GLsizei -> + GLintptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayVertexAttribLOffsetEXT :: FunPtr FuntypeVertexArrayVertexAttribLOffsetEXT -> FuntypeVertexArrayVertexAttribLOffsetEXT +glrefVertexArrayVertexAttribLOffsetEXT :: IORef FuntypeVertexArrayVertexAttribLOffsetEXT +glrefVertexArrayVertexAttribLOffsetEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayVertexAttribLOffsetEXT #-} +glVertexArrayVertexAttribLOffsetEXT :: FuntypeVertexArrayVertexAttribLOffsetEXT +glVertexArrayVertexAttribLOffsetEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribLOffsetEXT +{-# INLINE glVertexArrayVertexAttribLOffsetEXT #-} +type FuntypeTexturePageCommitmentEXT = + GLuint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLsizei -> + GLboolean -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynTexturePageCommitmentEXT :: FunPtr FuntypeTexturePageCommitmentEXT -> FuntypeTexturePageCommitmentEXT +glrefTexturePageCommitmentEXT :: IORef FuntypeTexturePageCommitmentEXT +glrefTexturePageCommitmentEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefTexturePageCommitmentEXT #-} +glTexturePageCommitmentEXT :: FuntypeTexturePageCommitmentEXT +glTexturePageCommitmentEXT = unsafePerformIO $ readIORef glrefTexturePageCommitmentEXT +{-# INLINE glTexturePageCommitmentEXT #-} +type FuntypeVertexArrayVertexAttribDivisorEXT = + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynVertexArrayVertexAttribDivisorEXT :: FunPtr FuntypeVertexArrayVertexAttribDivisorEXT -> FuntypeVertexArrayVertexAttribDivisorEXT +glrefVertexArrayVertexAttribDivisorEXT :: IORef FuntypeVertexArrayVertexAttribDivisorEXT +glrefVertexArrayVertexAttribDivisorEXT = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefVertexArrayVertexAttribDivisorEXT #-} +glVertexArrayVertexAttribDivisorEXT :: FuntypeVertexArrayVertexAttribDivisorEXT +glVertexArrayVertexAttribDivisorEXT = unsafePerformIO $ readIORef glrefVertexArrayVertexAttribDivisorEXT +{-# INLINE glVertexArrayVertexAttribDivisorEXT #-} + +-- GL_ARB_buffer_storage + +type FuntypeBufferStorage = + GLenum -> + GLsizeiptr -> + Ptr () -> + GLbitfield -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBufferStorage :: FunPtr FuntypeBufferStorage -> FuntypeBufferStorage +glrefBufferStorage :: IORef FuntypeBufferStorage +glrefBufferStorage = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBufferStorage #-} +glBufferStorage :: FuntypeBufferStorage +glBufferStorage = unsafePerformIO $ readIORef glrefBufferStorage +{-# INLINE glBufferStorage #-} + +-- GL_ARB_separate_shader_objects + +type FuntypeUseProgramStages = + GLuint -> + GLbitfield -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynUseProgramStages :: FunPtr FuntypeUseProgramStages -> FuntypeUseProgramStages +glrefUseProgramStages :: IORef FuntypeUseProgramStages +glrefUseProgramStages = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefUseProgramStages #-} +glUseProgramStages :: FuntypeUseProgramStages +glUseProgramStages = unsafePerformIO $ readIORef glrefUseProgramStages +{-# INLINE glUseProgramStages #-} +type FuntypeActiveShaderProgram = + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynActiveShaderProgram :: FunPtr FuntypeActiveShaderProgram -> FuntypeActiveShaderProgram +glrefActiveShaderProgram :: IORef FuntypeActiveShaderProgram +glrefActiveShaderProgram = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefActiveShaderProgram #-} +glActiveShaderProgram :: FuntypeActiveShaderProgram +glActiveShaderProgram = unsafePerformIO $ readIORef glrefActiveShaderProgram +{-# INLINE glActiveShaderProgram #-} +type FuntypeCreateShaderProgramv = + GLenum -> + GLsizei -> + Ptr (Ptr (GLchar)) -> + IO ( GLuint ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynCreateShaderProgramv :: FunPtr FuntypeCreateShaderProgramv -> FuntypeCreateShaderProgramv +glrefCreateShaderProgramv :: IORef FuntypeCreateShaderProgramv +glrefCreateShaderProgramv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefCreateShaderProgramv #-} +glCreateShaderProgramv :: FuntypeCreateShaderProgramv +glCreateShaderProgramv = unsafePerformIO $ readIORef glrefCreateShaderProgramv +{-# INLINE glCreateShaderProgramv #-} +type FuntypeBindProgramPipeline = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynBindProgramPipeline :: FunPtr FuntypeBindProgramPipeline -> FuntypeBindProgramPipeline +glrefBindProgramPipeline :: IORef FuntypeBindProgramPipeline +glrefBindProgramPipeline = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefBindProgramPipeline #-} +glBindProgramPipeline :: FuntypeBindProgramPipeline +glBindProgramPipeline = unsafePerformIO $ readIORef glrefBindProgramPipeline +{-# INLINE glBindProgramPipeline #-} +type FuntypeDeleteProgramPipelines = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynDeleteProgramPipelines :: FunPtr FuntypeDeleteProgramPipelines -> FuntypeDeleteProgramPipelines +glrefDeleteProgramPipelines :: IORef FuntypeDeleteProgramPipelines +glrefDeleteProgramPipelines = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefDeleteProgramPipelines #-} +glDeleteProgramPipelines :: FuntypeDeleteProgramPipelines +glDeleteProgramPipelines = unsafePerformIO $ readIORef glrefDeleteProgramPipelines +{-# INLINE glDeleteProgramPipelines #-} +type FuntypeGenProgramPipelines = + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGenProgramPipelines :: FunPtr FuntypeGenProgramPipelines -> FuntypeGenProgramPipelines +glrefGenProgramPipelines :: IORef FuntypeGenProgramPipelines +glrefGenProgramPipelines = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGenProgramPipelines #-} +glGenProgramPipelines :: FuntypeGenProgramPipelines +glGenProgramPipelines = unsafePerformIO $ readIORef glrefGenProgramPipelines +{-# INLINE glGenProgramPipelines #-} +type FuntypeIsProgramPipeline = + GLuint -> + IO ( GLboolean ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynIsProgramPipeline :: FunPtr FuntypeIsProgramPipeline -> FuntypeIsProgramPipeline +glrefIsProgramPipeline :: IORef FuntypeIsProgramPipeline +glrefIsProgramPipeline = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefIsProgramPipeline #-} +glIsProgramPipeline :: FuntypeIsProgramPipeline +glIsProgramPipeline = unsafePerformIO $ readIORef glrefIsProgramPipeline +{-# INLINE glIsProgramPipeline #-} +type FuntypeGetProgramPipelineiv = + GLuint -> + GLenum -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetProgramPipelineiv :: FunPtr FuntypeGetProgramPipelineiv -> FuntypeGetProgramPipelineiv +glrefGetProgramPipelineiv :: IORef FuntypeGetProgramPipelineiv +glrefGetProgramPipelineiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetProgramPipelineiv #-} +glGetProgramPipelineiv :: FuntypeGetProgramPipelineiv +glGetProgramPipelineiv = unsafePerformIO $ readIORef glrefGetProgramPipelineiv +{-# INLINE glGetProgramPipelineiv #-} +type FuntypeProgramUniform1i = + GLuint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1i :: FunPtr FuntypeProgramUniform1i -> FuntypeProgramUniform1i +glrefProgramUniform1i :: IORef FuntypeProgramUniform1i +glrefProgramUniform1i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1i #-} +glProgramUniform1i :: FuntypeProgramUniform1i +glProgramUniform1i = unsafePerformIO $ readIORef glrefProgramUniform1i +{-# INLINE glProgramUniform1i #-} +type FuntypeProgramUniform1iv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1iv :: FunPtr FuntypeProgramUniform1iv -> FuntypeProgramUniform1iv +glrefProgramUniform1iv :: IORef FuntypeProgramUniform1iv +glrefProgramUniform1iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1iv #-} +glProgramUniform1iv :: FuntypeProgramUniform1iv +glProgramUniform1iv = unsafePerformIO $ readIORef glrefProgramUniform1iv +{-# INLINE glProgramUniform1iv #-} +type FuntypeProgramUniform1f = + GLuint -> + GLint -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1f :: FunPtr FuntypeProgramUniform1f -> FuntypeProgramUniform1f +glrefProgramUniform1f :: IORef FuntypeProgramUniform1f +glrefProgramUniform1f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1f #-} +glProgramUniform1f :: FuntypeProgramUniform1f +glProgramUniform1f = unsafePerformIO $ readIORef glrefProgramUniform1f +{-# INLINE glProgramUniform1f #-} +type FuntypeProgramUniform1fv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1fv :: FunPtr FuntypeProgramUniform1fv -> FuntypeProgramUniform1fv +glrefProgramUniform1fv :: IORef FuntypeProgramUniform1fv +glrefProgramUniform1fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1fv #-} +glProgramUniform1fv :: FuntypeProgramUniform1fv +glProgramUniform1fv = unsafePerformIO $ readIORef glrefProgramUniform1fv +{-# INLINE glProgramUniform1fv #-} +type FuntypeProgramUniform1d = + GLuint -> + GLint -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1d :: FunPtr FuntypeProgramUniform1d -> FuntypeProgramUniform1d +glrefProgramUniform1d :: IORef FuntypeProgramUniform1d +glrefProgramUniform1d = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1d #-} +glProgramUniform1d :: FuntypeProgramUniform1d +glProgramUniform1d = unsafePerformIO $ readIORef glrefProgramUniform1d +{-# INLINE glProgramUniform1d #-} +type FuntypeProgramUniform1dv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1dv :: FunPtr FuntypeProgramUniform1dv -> FuntypeProgramUniform1dv +glrefProgramUniform1dv :: IORef FuntypeProgramUniform1dv +glrefProgramUniform1dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1dv #-} +glProgramUniform1dv :: FuntypeProgramUniform1dv +glProgramUniform1dv = unsafePerformIO $ readIORef glrefProgramUniform1dv +{-# INLINE glProgramUniform1dv #-} +type FuntypeProgramUniform1ui = + GLuint -> + GLint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1ui :: FunPtr FuntypeProgramUniform1ui -> FuntypeProgramUniform1ui +glrefProgramUniform1ui :: IORef FuntypeProgramUniform1ui +glrefProgramUniform1ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1ui #-} +glProgramUniform1ui :: FuntypeProgramUniform1ui +glProgramUniform1ui = unsafePerformIO $ readIORef glrefProgramUniform1ui +{-# INLINE glProgramUniform1ui #-} +type FuntypeProgramUniform1uiv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform1uiv :: FunPtr FuntypeProgramUniform1uiv -> FuntypeProgramUniform1uiv +glrefProgramUniform1uiv :: IORef FuntypeProgramUniform1uiv +glrefProgramUniform1uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform1uiv #-} +glProgramUniform1uiv :: FuntypeProgramUniform1uiv +glProgramUniform1uiv = unsafePerformIO $ readIORef glrefProgramUniform1uiv +{-# INLINE glProgramUniform1uiv #-} +type FuntypeProgramUniform2i = + GLuint -> + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2i :: FunPtr FuntypeProgramUniform2i -> FuntypeProgramUniform2i +glrefProgramUniform2i :: IORef FuntypeProgramUniform2i +glrefProgramUniform2i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2i #-} +glProgramUniform2i :: FuntypeProgramUniform2i +glProgramUniform2i = unsafePerformIO $ readIORef glrefProgramUniform2i +{-# INLINE glProgramUniform2i #-} +type FuntypeProgramUniform2iv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2iv :: FunPtr FuntypeProgramUniform2iv -> FuntypeProgramUniform2iv +glrefProgramUniform2iv :: IORef FuntypeProgramUniform2iv +glrefProgramUniform2iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2iv #-} +glProgramUniform2iv :: FuntypeProgramUniform2iv +glProgramUniform2iv = unsafePerformIO $ readIORef glrefProgramUniform2iv +{-# INLINE glProgramUniform2iv #-} +type FuntypeProgramUniform2f = + GLuint -> + GLint -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2f :: FunPtr FuntypeProgramUniform2f -> FuntypeProgramUniform2f +glrefProgramUniform2f :: IORef FuntypeProgramUniform2f +glrefProgramUniform2f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2f #-} +glProgramUniform2f :: FuntypeProgramUniform2f +glProgramUniform2f = unsafePerformIO $ readIORef glrefProgramUniform2f +{-# INLINE glProgramUniform2f #-} +type FuntypeProgramUniform2fv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2fv :: FunPtr FuntypeProgramUniform2fv -> FuntypeProgramUniform2fv +glrefProgramUniform2fv :: IORef FuntypeProgramUniform2fv +glrefProgramUniform2fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2fv #-} +glProgramUniform2fv :: FuntypeProgramUniform2fv +glProgramUniform2fv = unsafePerformIO $ readIORef glrefProgramUniform2fv +{-# INLINE glProgramUniform2fv #-} +type FuntypeProgramUniform2d = + GLuint -> + GLint -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2d :: FunPtr FuntypeProgramUniform2d -> FuntypeProgramUniform2d +glrefProgramUniform2d :: IORef FuntypeProgramUniform2d +glrefProgramUniform2d = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2d #-} +glProgramUniform2d :: FuntypeProgramUniform2d +glProgramUniform2d = unsafePerformIO $ readIORef glrefProgramUniform2d +{-# INLINE glProgramUniform2d #-} +type FuntypeProgramUniform2dv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2dv :: FunPtr FuntypeProgramUniform2dv -> FuntypeProgramUniform2dv +glrefProgramUniform2dv :: IORef FuntypeProgramUniform2dv +glrefProgramUniform2dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2dv #-} +glProgramUniform2dv :: FuntypeProgramUniform2dv +glProgramUniform2dv = unsafePerformIO $ readIORef glrefProgramUniform2dv +{-# INLINE glProgramUniform2dv #-} +type FuntypeProgramUniform2ui = + GLuint -> + GLint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2ui :: FunPtr FuntypeProgramUniform2ui -> FuntypeProgramUniform2ui +glrefProgramUniform2ui :: IORef FuntypeProgramUniform2ui +glrefProgramUniform2ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2ui #-} +glProgramUniform2ui :: FuntypeProgramUniform2ui +glProgramUniform2ui = unsafePerformIO $ readIORef glrefProgramUniform2ui +{-# INLINE glProgramUniform2ui #-} +type FuntypeProgramUniform2uiv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform2uiv :: FunPtr FuntypeProgramUniform2uiv -> FuntypeProgramUniform2uiv +glrefProgramUniform2uiv :: IORef FuntypeProgramUniform2uiv +glrefProgramUniform2uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform2uiv #-} +glProgramUniform2uiv :: FuntypeProgramUniform2uiv +glProgramUniform2uiv = unsafePerformIO $ readIORef glrefProgramUniform2uiv +{-# INLINE glProgramUniform2uiv #-} +type FuntypeProgramUniform3i = + GLuint -> + GLint -> + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3i :: FunPtr FuntypeProgramUniform3i -> FuntypeProgramUniform3i +glrefProgramUniform3i :: IORef FuntypeProgramUniform3i +glrefProgramUniform3i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3i #-} +glProgramUniform3i :: FuntypeProgramUniform3i +glProgramUniform3i = unsafePerformIO $ readIORef glrefProgramUniform3i +{-# INLINE glProgramUniform3i #-} +type FuntypeProgramUniform3iv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3iv :: FunPtr FuntypeProgramUniform3iv -> FuntypeProgramUniform3iv +glrefProgramUniform3iv :: IORef FuntypeProgramUniform3iv +glrefProgramUniform3iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3iv #-} +glProgramUniform3iv :: FuntypeProgramUniform3iv +glProgramUniform3iv = unsafePerformIO $ readIORef glrefProgramUniform3iv +{-# INLINE glProgramUniform3iv #-} +type FuntypeProgramUniform3f = + GLuint -> + GLint -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3f :: FunPtr FuntypeProgramUniform3f -> FuntypeProgramUniform3f +glrefProgramUniform3f :: IORef FuntypeProgramUniform3f +glrefProgramUniform3f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3f #-} +glProgramUniform3f :: FuntypeProgramUniform3f +glProgramUniform3f = unsafePerformIO $ readIORef glrefProgramUniform3f +{-# INLINE glProgramUniform3f #-} +type FuntypeProgramUniform3fv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3fv :: FunPtr FuntypeProgramUniform3fv -> FuntypeProgramUniform3fv +glrefProgramUniform3fv :: IORef FuntypeProgramUniform3fv +glrefProgramUniform3fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3fv #-} +glProgramUniform3fv :: FuntypeProgramUniform3fv +glProgramUniform3fv = unsafePerformIO $ readIORef glrefProgramUniform3fv +{-# INLINE glProgramUniform3fv #-} +type FuntypeProgramUniform3d = + GLuint -> + GLint -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3d :: FunPtr FuntypeProgramUniform3d -> FuntypeProgramUniform3d +glrefProgramUniform3d :: IORef FuntypeProgramUniform3d +glrefProgramUniform3d = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3d #-} +glProgramUniform3d :: FuntypeProgramUniform3d +glProgramUniform3d = unsafePerformIO $ readIORef glrefProgramUniform3d +{-# INLINE glProgramUniform3d #-} +type FuntypeProgramUniform3dv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3dv :: FunPtr FuntypeProgramUniform3dv -> FuntypeProgramUniform3dv +glrefProgramUniform3dv :: IORef FuntypeProgramUniform3dv +glrefProgramUniform3dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3dv #-} +glProgramUniform3dv :: FuntypeProgramUniform3dv +glProgramUniform3dv = unsafePerformIO $ readIORef glrefProgramUniform3dv +{-# INLINE glProgramUniform3dv #-} +type FuntypeProgramUniform3ui = + GLuint -> + GLint -> + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3ui :: FunPtr FuntypeProgramUniform3ui -> FuntypeProgramUniform3ui +glrefProgramUniform3ui :: IORef FuntypeProgramUniform3ui +glrefProgramUniform3ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3ui #-} +glProgramUniform3ui :: FuntypeProgramUniform3ui +glProgramUniform3ui = unsafePerformIO $ readIORef glrefProgramUniform3ui +{-# INLINE glProgramUniform3ui #-} +type FuntypeProgramUniform3uiv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform3uiv :: FunPtr FuntypeProgramUniform3uiv -> FuntypeProgramUniform3uiv +glrefProgramUniform3uiv :: IORef FuntypeProgramUniform3uiv +glrefProgramUniform3uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform3uiv #-} +glProgramUniform3uiv :: FuntypeProgramUniform3uiv +glProgramUniform3uiv = unsafePerformIO $ readIORef glrefProgramUniform3uiv +{-# INLINE glProgramUniform3uiv #-} +type FuntypeProgramUniform4i = + GLuint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4i :: FunPtr FuntypeProgramUniform4i -> FuntypeProgramUniform4i +glrefProgramUniform4i :: IORef FuntypeProgramUniform4i +glrefProgramUniform4i = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4i #-} +glProgramUniform4i :: FuntypeProgramUniform4i +glProgramUniform4i = unsafePerformIO $ readIORef glrefProgramUniform4i +{-# INLINE glProgramUniform4i #-} +type FuntypeProgramUniform4iv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4iv :: FunPtr FuntypeProgramUniform4iv -> FuntypeProgramUniform4iv +glrefProgramUniform4iv :: IORef FuntypeProgramUniform4iv +glrefProgramUniform4iv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4iv #-} +glProgramUniform4iv :: FuntypeProgramUniform4iv +glProgramUniform4iv = unsafePerformIO $ readIORef glrefProgramUniform4iv +{-# INLINE glProgramUniform4iv #-} +type FuntypeProgramUniform4f = + GLuint -> + GLint -> + GLfloat -> + GLfloat -> + GLfloat -> + GLfloat -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4f :: FunPtr FuntypeProgramUniform4f -> FuntypeProgramUniform4f +glrefProgramUniform4f :: IORef FuntypeProgramUniform4f +glrefProgramUniform4f = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4f #-} +glProgramUniform4f :: FuntypeProgramUniform4f +glProgramUniform4f = unsafePerformIO $ readIORef glrefProgramUniform4f +{-# INLINE glProgramUniform4f #-} +type FuntypeProgramUniform4fv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4fv :: FunPtr FuntypeProgramUniform4fv -> FuntypeProgramUniform4fv +glrefProgramUniform4fv :: IORef FuntypeProgramUniform4fv +glrefProgramUniform4fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4fv #-} +glProgramUniform4fv :: FuntypeProgramUniform4fv +glProgramUniform4fv = unsafePerformIO $ readIORef glrefProgramUniform4fv +{-# INLINE glProgramUniform4fv #-} +type FuntypeProgramUniform4d = + GLuint -> + GLint -> + GLdouble -> + GLdouble -> + GLdouble -> + GLdouble -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4d :: FunPtr FuntypeProgramUniform4d -> FuntypeProgramUniform4d +glrefProgramUniform4d :: IORef FuntypeProgramUniform4d +glrefProgramUniform4d = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4d #-} +glProgramUniform4d :: FuntypeProgramUniform4d +glProgramUniform4d = unsafePerformIO $ readIORef glrefProgramUniform4d +{-# INLINE glProgramUniform4d #-} +type FuntypeProgramUniform4dv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4dv :: FunPtr FuntypeProgramUniform4dv -> FuntypeProgramUniform4dv +glrefProgramUniform4dv :: IORef FuntypeProgramUniform4dv +glrefProgramUniform4dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4dv #-} +glProgramUniform4dv :: FuntypeProgramUniform4dv +glProgramUniform4dv = unsafePerformIO $ readIORef glrefProgramUniform4dv +{-# INLINE glProgramUniform4dv #-} +type FuntypeProgramUniform4ui = + GLuint -> + GLint -> + GLuint -> + GLuint -> + GLuint -> + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4ui :: FunPtr FuntypeProgramUniform4ui -> FuntypeProgramUniform4ui +glrefProgramUniform4ui :: IORef FuntypeProgramUniform4ui +glrefProgramUniform4ui = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4ui #-} +glProgramUniform4ui :: FuntypeProgramUniform4ui +glProgramUniform4ui = unsafePerformIO $ readIORef glrefProgramUniform4ui +{-# INLINE glProgramUniform4ui #-} +type FuntypeProgramUniform4uiv = + GLuint -> + GLint -> + GLsizei -> + Ptr (GLuint) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniform4uiv :: FunPtr FuntypeProgramUniform4uiv -> FuntypeProgramUniform4uiv +glrefProgramUniform4uiv :: IORef FuntypeProgramUniform4uiv +glrefProgramUniform4uiv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniform4uiv #-} +glProgramUniform4uiv :: FuntypeProgramUniform4uiv +glProgramUniform4uiv = unsafePerformIO $ readIORef glrefProgramUniform4uiv +{-# INLINE glProgramUniform4uiv #-} +type FuntypeProgramUniformMatrix2fv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2fv :: FunPtr FuntypeProgramUniformMatrix2fv -> FuntypeProgramUniformMatrix2fv +glrefProgramUniformMatrix2fv :: IORef FuntypeProgramUniformMatrix2fv +glrefProgramUniformMatrix2fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2fv #-} +glProgramUniformMatrix2fv :: FuntypeProgramUniformMatrix2fv +glProgramUniformMatrix2fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2fv +{-# INLINE glProgramUniformMatrix2fv #-} +type FuntypeProgramUniformMatrix3fv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3fv :: FunPtr FuntypeProgramUniformMatrix3fv -> FuntypeProgramUniformMatrix3fv +glrefProgramUniformMatrix3fv :: IORef FuntypeProgramUniformMatrix3fv +glrefProgramUniformMatrix3fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3fv #-} +glProgramUniformMatrix3fv :: FuntypeProgramUniformMatrix3fv +glProgramUniformMatrix3fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3fv +{-# INLINE glProgramUniformMatrix3fv #-} +type FuntypeProgramUniformMatrix4fv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4fv :: FunPtr FuntypeProgramUniformMatrix4fv -> FuntypeProgramUniformMatrix4fv +glrefProgramUniformMatrix4fv :: IORef FuntypeProgramUniformMatrix4fv +glrefProgramUniformMatrix4fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4fv #-} +glProgramUniformMatrix4fv :: FuntypeProgramUniformMatrix4fv +glProgramUniformMatrix4fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4fv +{-# INLINE glProgramUniformMatrix4fv #-} +type FuntypeProgramUniformMatrix2dv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2dv :: FunPtr FuntypeProgramUniformMatrix2dv -> FuntypeProgramUniformMatrix2dv +glrefProgramUniformMatrix2dv :: IORef FuntypeProgramUniformMatrix2dv +glrefProgramUniformMatrix2dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2dv #-} +glProgramUniformMatrix2dv :: FuntypeProgramUniformMatrix2dv +glProgramUniformMatrix2dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2dv +{-# INLINE glProgramUniformMatrix2dv #-} +type FuntypeProgramUniformMatrix3dv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3dv :: FunPtr FuntypeProgramUniformMatrix3dv -> FuntypeProgramUniformMatrix3dv +glrefProgramUniformMatrix3dv :: IORef FuntypeProgramUniformMatrix3dv +glrefProgramUniformMatrix3dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3dv #-} +glProgramUniformMatrix3dv :: FuntypeProgramUniformMatrix3dv +glProgramUniformMatrix3dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3dv +{-# INLINE glProgramUniformMatrix3dv #-} +type FuntypeProgramUniformMatrix4dv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4dv :: FunPtr FuntypeProgramUniformMatrix4dv -> FuntypeProgramUniformMatrix4dv +glrefProgramUniformMatrix4dv :: IORef FuntypeProgramUniformMatrix4dv +glrefProgramUniformMatrix4dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4dv #-} +glProgramUniformMatrix4dv :: FuntypeProgramUniformMatrix4dv +glProgramUniformMatrix4dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4dv +{-# INLINE glProgramUniformMatrix4dv #-} +type FuntypeProgramUniformMatrix2x3fv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2x3fv :: FunPtr FuntypeProgramUniformMatrix2x3fv -> FuntypeProgramUniformMatrix2x3fv +glrefProgramUniformMatrix2x3fv :: IORef FuntypeProgramUniformMatrix2x3fv +glrefProgramUniformMatrix2x3fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2x3fv #-} +glProgramUniformMatrix2x3fv :: FuntypeProgramUniformMatrix2x3fv +glProgramUniformMatrix2x3fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x3fv +{-# INLINE glProgramUniformMatrix2x3fv #-} +type FuntypeProgramUniformMatrix3x2fv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3x2fv :: FunPtr FuntypeProgramUniformMatrix3x2fv -> FuntypeProgramUniformMatrix3x2fv +glrefProgramUniformMatrix3x2fv :: IORef FuntypeProgramUniformMatrix3x2fv +glrefProgramUniformMatrix3x2fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3x2fv #-} +glProgramUniformMatrix3x2fv :: FuntypeProgramUniformMatrix3x2fv +glProgramUniformMatrix3x2fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x2fv +{-# INLINE glProgramUniformMatrix3x2fv #-} +type FuntypeProgramUniformMatrix2x4fv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2x4fv :: FunPtr FuntypeProgramUniformMatrix2x4fv -> FuntypeProgramUniformMatrix2x4fv +glrefProgramUniformMatrix2x4fv :: IORef FuntypeProgramUniformMatrix2x4fv +glrefProgramUniformMatrix2x4fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2x4fv #-} +glProgramUniformMatrix2x4fv :: FuntypeProgramUniformMatrix2x4fv +glProgramUniformMatrix2x4fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x4fv +{-# INLINE glProgramUniformMatrix2x4fv #-} +type FuntypeProgramUniformMatrix4x2fv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4x2fv :: FunPtr FuntypeProgramUniformMatrix4x2fv -> FuntypeProgramUniformMatrix4x2fv +glrefProgramUniformMatrix4x2fv :: IORef FuntypeProgramUniformMatrix4x2fv +glrefProgramUniformMatrix4x2fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4x2fv #-} +glProgramUniformMatrix4x2fv :: FuntypeProgramUniformMatrix4x2fv +glProgramUniformMatrix4x2fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x2fv +{-# INLINE glProgramUniformMatrix4x2fv #-} +type FuntypeProgramUniformMatrix3x4fv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3x4fv :: FunPtr FuntypeProgramUniformMatrix3x4fv -> FuntypeProgramUniformMatrix3x4fv +glrefProgramUniformMatrix3x4fv :: IORef FuntypeProgramUniformMatrix3x4fv +glrefProgramUniformMatrix3x4fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3x4fv #-} +glProgramUniformMatrix3x4fv :: FuntypeProgramUniformMatrix3x4fv +glProgramUniformMatrix3x4fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x4fv +{-# INLINE glProgramUniformMatrix3x4fv #-} +type FuntypeProgramUniformMatrix4x3fv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLfloat) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4x3fv :: FunPtr FuntypeProgramUniformMatrix4x3fv -> FuntypeProgramUniformMatrix4x3fv +glrefProgramUniformMatrix4x3fv :: IORef FuntypeProgramUniformMatrix4x3fv +glrefProgramUniformMatrix4x3fv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4x3fv #-} +glProgramUniformMatrix4x3fv :: FuntypeProgramUniformMatrix4x3fv +glProgramUniformMatrix4x3fv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x3fv +{-# INLINE glProgramUniformMatrix4x3fv #-} +type FuntypeProgramUniformMatrix2x3dv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2x3dv :: FunPtr FuntypeProgramUniformMatrix2x3dv -> FuntypeProgramUniformMatrix2x3dv +glrefProgramUniformMatrix2x3dv :: IORef FuntypeProgramUniformMatrix2x3dv +glrefProgramUniformMatrix2x3dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2x3dv #-} +glProgramUniformMatrix2x3dv :: FuntypeProgramUniformMatrix2x3dv +glProgramUniformMatrix2x3dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x3dv +{-# INLINE glProgramUniformMatrix2x3dv #-} +type FuntypeProgramUniformMatrix3x2dv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3x2dv :: FunPtr FuntypeProgramUniformMatrix3x2dv -> FuntypeProgramUniformMatrix3x2dv +glrefProgramUniformMatrix3x2dv :: IORef FuntypeProgramUniformMatrix3x2dv +glrefProgramUniformMatrix3x2dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3x2dv #-} +glProgramUniformMatrix3x2dv :: FuntypeProgramUniformMatrix3x2dv +glProgramUniformMatrix3x2dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x2dv +{-# INLINE glProgramUniformMatrix3x2dv #-} +type FuntypeProgramUniformMatrix2x4dv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix2x4dv :: FunPtr FuntypeProgramUniformMatrix2x4dv -> FuntypeProgramUniformMatrix2x4dv +glrefProgramUniformMatrix2x4dv :: IORef FuntypeProgramUniformMatrix2x4dv +glrefProgramUniformMatrix2x4dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix2x4dv #-} +glProgramUniformMatrix2x4dv :: FuntypeProgramUniformMatrix2x4dv +glProgramUniformMatrix2x4dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix2x4dv +{-# INLINE glProgramUniformMatrix2x4dv #-} +type FuntypeProgramUniformMatrix4x2dv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4x2dv :: FunPtr FuntypeProgramUniformMatrix4x2dv -> FuntypeProgramUniformMatrix4x2dv +glrefProgramUniformMatrix4x2dv :: IORef FuntypeProgramUniformMatrix4x2dv +glrefProgramUniformMatrix4x2dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4x2dv #-} +glProgramUniformMatrix4x2dv :: FuntypeProgramUniformMatrix4x2dv +glProgramUniformMatrix4x2dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x2dv +{-# INLINE glProgramUniformMatrix4x2dv #-} +type FuntypeProgramUniformMatrix3x4dv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix3x4dv :: FunPtr FuntypeProgramUniformMatrix3x4dv -> FuntypeProgramUniformMatrix3x4dv +glrefProgramUniformMatrix3x4dv :: IORef FuntypeProgramUniformMatrix3x4dv +glrefProgramUniformMatrix3x4dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix3x4dv #-} +glProgramUniformMatrix3x4dv :: FuntypeProgramUniformMatrix3x4dv +glProgramUniformMatrix3x4dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix3x4dv +{-# INLINE glProgramUniformMatrix3x4dv #-} +type FuntypeProgramUniformMatrix4x3dv = + GLuint -> + GLint -> + GLsizei -> + GLboolean -> + Ptr (GLdouble) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynProgramUniformMatrix4x3dv :: FunPtr FuntypeProgramUniformMatrix4x3dv -> FuntypeProgramUniformMatrix4x3dv +glrefProgramUniformMatrix4x3dv :: IORef FuntypeProgramUniformMatrix4x3dv +glrefProgramUniformMatrix4x3dv = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefProgramUniformMatrix4x3dv #-} +glProgramUniformMatrix4x3dv :: FuntypeProgramUniformMatrix4x3dv +glProgramUniformMatrix4x3dv = unsafePerformIO $ readIORef glrefProgramUniformMatrix4x3dv +{-# INLINE glProgramUniformMatrix4x3dv #-} +type FuntypeValidateProgramPipeline = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynValidateProgramPipeline :: FunPtr FuntypeValidateProgramPipeline -> FuntypeValidateProgramPipeline +glrefValidateProgramPipeline :: IORef FuntypeValidateProgramPipeline +glrefValidateProgramPipeline = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefValidateProgramPipeline #-} +glValidateProgramPipeline :: FuntypeValidateProgramPipeline +glValidateProgramPipeline = unsafePerformIO $ readIORef glrefValidateProgramPipeline +{-# INLINE glValidateProgramPipeline #-} +type FuntypeGetProgramPipelineInfoLog = + GLuint -> + GLsizei -> + Ptr (GLsizei) -> + Ptr (GLchar) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynGetProgramPipelineInfoLog :: FunPtr FuntypeGetProgramPipelineInfoLog -> FuntypeGetProgramPipelineInfoLog +glrefGetProgramPipelineInfoLog :: IORef FuntypeGetProgramPipelineInfoLog +glrefGetProgramPipelineInfoLog = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefGetProgramPipelineInfoLog #-} +glGetProgramPipelineInfoLog :: FuntypeGetProgramPipelineInfoLog +glGetProgramPipelineInfoLog = unsafePerformIO $ readIORef glrefGetProgramPipelineInfoLog +{-# INLINE glGetProgramPipelineInfoLog #-} + +-- GL_ATI_meminfo + + +-- GL_NVX_gpu_memory_info + + +-- GL_ARB_invalidate_subdata + +type FuntypeInvalidateTexSubImage = + GLuint -> + GLint -> + GLint -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynInvalidateTexSubImage :: FunPtr FuntypeInvalidateTexSubImage -> FuntypeInvalidateTexSubImage +glrefInvalidateTexSubImage :: IORef FuntypeInvalidateTexSubImage +glrefInvalidateTexSubImage = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefInvalidateTexSubImage #-} +glInvalidateTexSubImage :: FuntypeInvalidateTexSubImage +glInvalidateTexSubImage = unsafePerformIO $ readIORef glrefInvalidateTexSubImage +{-# INLINE glInvalidateTexSubImage #-} +type FuntypeInvalidateTexImage = + GLuint -> + GLint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynInvalidateTexImage :: FunPtr FuntypeInvalidateTexImage -> FuntypeInvalidateTexImage +glrefInvalidateTexImage :: IORef FuntypeInvalidateTexImage +glrefInvalidateTexImage = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefInvalidateTexImage #-} +glInvalidateTexImage :: FuntypeInvalidateTexImage +glInvalidateTexImage = unsafePerformIO $ readIORef glrefInvalidateTexImage +{-# INLINE glInvalidateTexImage #-} +type FuntypeInvalidateBufferSubData = + GLuint -> + GLintptr -> + GLsizeiptr -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynInvalidateBufferSubData :: FunPtr FuntypeInvalidateBufferSubData -> FuntypeInvalidateBufferSubData +glrefInvalidateBufferSubData :: IORef FuntypeInvalidateBufferSubData +glrefInvalidateBufferSubData = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefInvalidateBufferSubData #-} +glInvalidateBufferSubData :: FuntypeInvalidateBufferSubData +glInvalidateBufferSubData = unsafePerformIO $ readIORef glrefInvalidateBufferSubData +{-# INLINE glInvalidateBufferSubData #-} +type FuntypeInvalidateBufferData = + GLuint -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynInvalidateBufferData :: FunPtr FuntypeInvalidateBufferData -> FuntypeInvalidateBufferData +glrefInvalidateBufferData :: IORef FuntypeInvalidateBufferData +glrefInvalidateBufferData = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefInvalidateBufferData #-} +glInvalidateBufferData :: FuntypeInvalidateBufferData +glInvalidateBufferData = unsafePerformIO $ readIORef glrefInvalidateBufferData +{-# INLINE glInvalidateBufferData #-} +type FuntypeInvalidateFramebuffer = + GLenum -> + GLsizei -> + Ptr (GLenum) -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynInvalidateFramebuffer :: FunPtr FuntypeInvalidateFramebuffer -> FuntypeInvalidateFramebuffer +glrefInvalidateFramebuffer :: IORef FuntypeInvalidateFramebuffer +glrefInvalidateFramebuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefInvalidateFramebuffer #-} +glInvalidateFramebuffer :: FuntypeInvalidateFramebuffer +glInvalidateFramebuffer = unsafePerformIO $ readIORef glrefInvalidateFramebuffer +{-# INLINE glInvalidateFramebuffer #-} +type FuntypeInvalidateSubFramebuffer = + GLenum -> + GLsizei -> + Ptr (GLenum) -> + GLint -> + GLint -> + GLsizei -> + GLsizei -> + IO ( () ) +foreign import ccall APIENTRY unsafe "dynamic" + gldynInvalidateSubFramebuffer :: FunPtr FuntypeInvalidateSubFramebuffer -> FuntypeInvalidateSubFramebuffer +glrefInvalidateSubFramebuffer :: IORef FuntypeInvalidateSubFramebuffer +glrefInvalidateSubFramebuffer = unsafePerformIO $ newIORef $ error "No function retrieved." +{-# NOINLINE glrefInvalidateSubFramebuffer #-} +glInvalidateSubFramebuffer :: FuntypeInvalidateSubFramebuffer +glInvalidateSubFramebuffer = unsafePerformIO $ readIORef glrefInvalidateSubFramebuffer +{-# INLINE glInvalidateSubFramebuffer #-} + +gl_UNSIGNED_INT_10_10_10_2_EXT :: GLenum +gl_UNSIGNED_INT_10_10_10_2_EXT = 0x8036 +gl_ACTIVE_RESOURCES :: GLenum +gl_ACTIVE_RESOURCES = 0x92F5 +gl_MAX_GEOMETRY_SHADER_INVOCATIONS :: GLenum +gl_MAX_GEOMETRY_SHADER_INVOCATIONS = 0x8E5A +gl_RESTART_PATH_NV :: GLenum +gl_RESTART_PATH_NV = 0xF0 +gl_MAX_DEEP_3D_TEXTURE_DEPTH_NV :: GLenum +gl_MAX_DEEP_3D_TEXTURE_DEPTH_NV = 0x90D1 +gl_PACK_SKIP_IMAGES :: GLenum +gl_PACK_SKIP_IMAGES = 0x806B +gl_IMAGE_CLASS_2_X_16 :: GLenum +gl_IMAGE_CLASS_2_X_16 = 0x82BD +gl_FRAMEBUFFER_COMPLETE :: GLenum +gl_FRAMEBUFFER_COMPLETE = 0x8CD5 +gl_HSL_LUMINOSITY_NV :: GLenum +gl_HSL_LUMINOSITY_NV = 0x92B0 +gl_IMAGE_BINDING_LAYERED_EXT :: GLenum +gl_IMAGE_BINDING_LAYERED_EXT = 0x8F3C +gl_ZOOM_Y :: GLenum +gl_ZOOM_Y = 0x0D17 +gl_TEXTURE_LUMINANCE_TYPE_ARB :: GLenum +gl_TEXTURE_LUMINANCE_TYPE_ARB = 0x8C14 +gl_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB :: GLenum +gl_MAX_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x880B +gl_TEXTURE_HEIGHT :: GLenum +gl_TEXTURE_HEIGHT = 0x1001 +gl_OUTPUT_TEXTURE_COORD0_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD0_EXT = 0x879D +gl_FLOAT_CLEAR_COLOR_VALUE_NV :: GLenum +gl_FLOAT_CLEAR_COLOR_VALUE_NV = 0x888D +gl_LIGHT_MODEL_AMBIENT :: GLenum +gl_LIGHT_MODEL_AMBIENT = 0x0B53 +gl_INT16_VEC3_NV :: GLenum +gl_INT16_VEC3_NV = 0x8FE6 +gl_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV :: GLenum +gl_TESS_CONTROL_PROGRAM_PARAMETER_BUFFER_NV = 0x8C74 +gl_MATRIX6_NV :: GLenum +gl_MATRIX6_NV = 0x8636 +gl_COMPUTE_PROGRAM_NV :: GLenum +gl_COMPUTE_PROGRAM_NV = 0x90FB +gl_SCALED_RESOLVE_FASTEST_EXT :: GLenum +gl_SCALED_RESOLVE_FASTEST_EXT = 0x90BA +gl_REPLACEMENT_CODE_ARRAY_SUN :: GLenum +gl_REPLACEMENT_CODE_ARRAY_SUN = 0x85C0 +gl_TEXTURE_DT_SIZE_NV :: GLenum +gl_TEXTURE_DT_SIZE_NV = 0x871E +gl_NUM_SPARSE_LEVELS_ARB :: GLenum +gl_NUM_SPARSE_LEVELS_ARB = 0x91AA +gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR :: GLenum +gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_KHR = 0x8243 +gl_NO_ERROR :: GLenum +gl_NO_ERROR = 0 +gl_INTERNALFORMAT_ALPHA_TYPE :: GLenum +gl_INTERNALFORMAT_ALPHA_TYPE = 0x827B +gl_FONT_HEIGHT_BIT_NV :: GLenum +gl_FONT_HEIGHT_BIT_NV = 0x00800000 +gl_TANGENT_ARRAY_POINTER_EXT :: GLenum +gl_TANGENT_ARRAY_POINTER_EXT = 0x8442 +gl_LOCAL_CONSTANT_VALUE_EXT :: GLenum +gl_LOCAL_CONSTANT_VALUE_EXT = 0x87EC +gl_READ_WRITE :: GLenum +gl_READ_WRITE = 0x88BA +gl_TEXTURE_2D :: GLenum +gl_TEXTURE_2D = 0x0DE1 +gl_UNSIGNED_INT_2_10_10_10_REV_EXT :: GLenum +gl_UNSIGNED_INT_2_10_10_10_REV_EXT = 0x8368 +gl_TEXTURE_WRAP_R :: GLenum +gl_TEXTURE_WRAP_R = 0x8072 +gl_FLOAT_MAT4x2 :: GLenum +gl_FLOAT_MAT4x2 = 0x8B69 +gl_MAX_COMPUTE_WORK_GROUP_SIZE :: GLenum +gl_MAX_COMPUTE_WORK_GROUP_SIZE = 0x91BF +gl_POLYGON_OFFSET_CLAMP_EXT :: GLenum +gl_POLYGON_OFFSET_CLAMP_EXT = 0x8E1B +gl_SYNC_FLUSH_COMMANDS_BIT :: GLenum +gl_SYNC_FLUSH_COMMANDS_BIT = 0x00000001 +gl_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB :: GLenum +gl_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x8809 +gl_INT_IMAGE_BUFFER :: GLenum +gl_INT_IMAGE_BUFFER = 0x905C +gl_VERTEX_ATTRIB_ARRAY_TYPE :: GLenum +gl_VERTEX_ATTRIB_ARRAY_TYPE = 0x8625 +gl_ONE :: GLenum +gl_ONE = 1 +gl_COLOR_CLEAR_UNCLAMPED_VALUE_ATI :: GLenum +gl_COLOR_CLEAR_UNCLAMPED_VALUE_ATI = 0x8835 +gl_TRANSLATE_X_NV :: GLenum +gl_TRANSLATE_X_NV = 0x908E +gl_HI_SCALE_NV :: GLenum +gl_HI_SCALE_NV = 0x870E +gl_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT :: GLenum +gl_REFERENCED_BY_TESS_EVALUATION_SHADER_EXT = 0x9308 +gl_HILO_NV :: GLenum +gl_HILO_NV = 0x86F4 +gl_TRIANGLES :: GLenum +gl_TRIANGLES = 0x0004 +gl_LINEARLIGHT_NV :: GLenum +gl_LINEARLIGHT_NV = 0x92A7 +gl_MAX_3D_TEXTURE_SIZE_OES :: GLenum +gl_MAX_3D_TEXTURE_SIZE_OES = 0x8073 +gl_ANY_SAMPLES_PASSED_CONSERVATIVE :: GLenum +gl_ANY_SAMPLES_PASSED_CONSERVATIVE = 0x8D6A +gl_UNIFORM_BLOCK_BINDING :: GLenum +gl_UNIFORM_BLOCK_BINDING = 0x8A3F +gl_MAX_TESS_CONTROL_INPUT_COMPONENTS :: GLenum +gl_MAX_TESS_CONTROL_INPUT_COMPONENTS = 0x886C +gl_TEXTURE_ALPHA_TYPE_ARB :: GLenum +gl_TEXTURE_ALPHA_TYPE_ARB = 0x8C13 +gl_MAX_CONVOLUTION_HEIGHT :: GLenum +gl_MAX_CONVOLUTION_HEIGHT = 0x801B +gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS = 0x8CD9 +gl_DEPTH_BUFFER_BIT5_QCOM :: GLenum +gl_DEPTH_BUFFER_BIT5_QCOM = 0x00002000 +gl_PROGRAM_TEX_INDIRECTIONS_ARB :: GLenum +gl_PROGRAM_TEX_INDIRECTIONS_ARB = 0x8807 +gl_BLUE :: GLenum +gl_BLUE = 0x1905 +gl_RGBA_S3TC :: GLenum +gl_RGBA_S3TC = 0x83A2 +gl_DECR :: GLenum +gl_DECR = 0x1E03 +gl_MAJOR_VERSION :: GLenum +gl_MAJOR_VERSION = 0x821B +gl_ARRAY_STRIDE :: GLenum +gl_ARRAY_STRIDE = 0x92FE +gl_CONSTANT_COLOR1_NV :: GLenum +gl_CONSTANT_COLOR1_NV = 0x852B +gl_SAMPLES_EXT :: GLenum +gl_SAMPLES_EXT = 0x80A9 +gl_MAX_SAMPLES_APPLE :: GLenum +gl_MAX_SAMPLES_APPLE = 0x8D57 +gl_COLOR_ARRAY_SIZE :: GLenum +gl_COLOR_ARRAY_SIZE = 0x8081 +gl_SAMPLE_ALPHA_TO_MASK_SGIS :: GLenum +gl_SAMPLE_ALPHA_TO_MASK_SGIS = 0x809E +gl_DUP_LAST_CUBIC_CURVE_TO_NV :: GLenum +gl_DUP_LAST_CUBIC_CURVE_TO_NV = 0xF4 +gl_TEXTURE10 :: GLenum +gl_TEXTURE10 = 0x84CA +gl_R1UI_T2F_C4F_N3F_V3F_SUN :: GLenum +gl_R1UI_T2F_C4F_N3F_V3F_SUN = 0x85CB +gl_MAX_VARYING_COMPONENTS :: GLenum +gl_MAX_VARYING_COMPONENTS = 0x8B4B +gl_DRAW_BUFFER7_EXT :: GLenum +gl_DRAW_BUFFER7_EXT = 0x882C +gl_MAX_COMBINED_ATOMIC_COUNTERS :: GLenum +gl_MAX_COMBINED_ATOMIC_COUNTERS = 0x92D7 +gl_PROGRAM_ERROR_STRING_ARB :: GLenum +gl_PROGRAM_ERROR_STRING_ARB = 0x8874 +gl_TRACE_ALL_BITS_MESA :: GLenum +gl_TRACE_ALL_BITS_MESA = 0xFFFF +gl_DEPTH_CLAMP_NV :: GLenum +gl_DEPTH_CLAMP_NV = 0x864F +gl_REDUCE :: GLenum +gl_REDUCE = 0x8016 +gl_UNSIGNED_SHORT_4_4_4_4 :: GLenum +gl_UNSIGNED_SHORT_4_4_4_4 = 0x8033 +gl_SKIP_COMPONENTS1_NV :: GLenum +gl_SKIP_COMPONENTS1_NV = -6 +gl_PIXEL_TILE_CACHE_INCREMENT_SGIX :: GLenum +gl_PIXEL_TILE_CACHE_INCREMENT_SGIX = 0x813F +gl_COLOR_ARRAY :: GLenum +gl_COLOR_ARRAY = 0x8076 +gl_STATIC_VERTEX_ARRAY_IBM :: GLenum +gl_STATIC_VERTEX_ARRAY_IBM = 103061 +gl_INDEX_BIT_PGI :: GLenum +gl_INDEX_BIT_PGI = 0x00080000 +gl_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_Z_EXT = 0x8519 +gl_ETC1_SRGB8_NV :: GLenum +gl_ETC1_SRGB8_NV = 0x88EE +gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS :: GLenum +gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS = 0x8E81 +gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT :: GLenum +gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT_EXT = 0x00000001 +gl_LIGHT_MODEL_COLOR_CONTROL_EXT :: GLenum +gl_LIGHT_MODEL_COLOR_CONTROL_EXT = 0x81F8 +gl_PATCH_DEFAULT_OUTER_LEVEL_EXT :: GLenum +gl_PATCH_DEFAULT_OUTER_LEVEL_EXT = 0x8E74 +gl_SAMPLER_CUBE_ARB :: GLenum +gl_SAMPLER_CUBE_ARB = 0x8B60 +gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT :: GLenum +gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8DE1 +gl_STORAGE_PRIVATE_APPLE :: GLenum +gl_STORAGE_PRIVATE_APPLE = 0x85BD +gl_MAP1_TEXTURE_COORD_2 :: GLenum +gl_MAP1_TEXTURE_COORD_2 = 0x0D94 +gl_REPLACEMENT_CODE_ARRAY_STRIDE_SUN :: GLenum +gl_REPLACEMENT_CODE_ARRAY_STRIDE_SUN = 0x85C2 +gl_VERTEX_ATTRIB_ARRAY8_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY8_NV = 0x8658 +gl_LUMINANCE16F_ARB :: GLenum +gl_LUMINANCE16F_ARB = 0x881E +gl_DEPTH_COMPONENT32F_NV :: GLenum +gl_DEPTH_COMPONENT32F_NV = 0x8DAB +gl_MAX_VERTEX_BINDABLE_UNIFORMS_EXT :: GLenum +gl_MAX_VERTEX_BINDABLE_UNIFORMS_EXT = 0x8DE2 +gl_MATRIX28_ARB :: GLenum +gl_MATRIX28_ARB = 0x88DC +gl_SYNC_FLUSH_COMMANDS_BIT_APPLE :: GLenum +gl_SYNC_FLUSH_COMMANDS_BIT_APPLE = 0x00000001 +gl_READ_FRAMEBUFFER_BINDING_ANGLE :: GLenum +gl_READ_FRAMEBUFFER_BINDING_ANGLE = 0x8CAA +gl_FOG_COORDINATE_ARRAY_TYPE :: GLenum +gl_FOG_COORDINATE_ARRAY_TYPE = 0x8454 +gl_RGBA32UI_EXT :: GLenum +gl_RGBA32UI_EXT = 0x8D70 +gl_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG :: GLenum +gl_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG = 0x8C02 +gl_2_BYTES_NV :: GLenum +gl_2_BYTES_NV = 0x1407 +gl_TEXTURE_HI_SIZE_NV :: GLenum +gl_TEXTURE_HI_SIZE_NV = 0x871B +gl_PACK_SWAP_BYTES :: GLenum +gl_PACK_SWAP_BYTES = 0x0D00 +gl_EVAL_FRACTIONAL_TESSELLATION_NV :: GLenum +gl_EVAL_FRACTIONAL_TESSELLATION_NV = 0x86C5 +gl_RG16 :: GLenum +gl_RG16 = 0x822C +gl_SWIZZLE_STR_ATI :: GLenum +gl_SWIZZLE_STR_ATI = 0x8976 +gl_CON_6_ATI :: GLenum +gl_CON_6_ATI = 0x8947 +gl_PATH_FOG_GEN_MODE_NV :: GLenum +gl_PATH_FOG_GEN_MODE_NV = 0x90AC +gl_SRGB8_ALPHA8_EXT :: GLenum +gl_SRGB8_ALPHA8_EXT = 0x8C43 +gl_COMPRESSED_SLUMINANCE_ALPHA_EXT :: GLenum +gl_COMPRESSED_SLUMINANCE_ALPHA_EXT = 0x8C4B +gl_TEXTURE_COMPARE_FUNC_EXT :: GLenum +gl_TEXTURE_COMPARE_FUNC_EXT = 0x884D +gl_UNIFORM_MATRIX_STRIDE :: GLenum +gl_UNIFORM_MATRIX_STRIDE = 0x8A3D +gl_INVALID_OPERATION :: GLenum +gl_INVALID_OPERATION = 0x0502 +gl_DRAW_BUFFER4_ATI :: GLenum +gl_DRAW_BUFFER4_ATI = 0x8829 +gl_BYTE :: GLenum +gl_BYTE = 0x1400 +gl_SECONDARY_COLOR_ARRAY_POINTER :: GLenum +gl_SECONDARY_COLOR_ARRAY_POINTER = 0x845D +gl_TEXTURE_CUBE_MAP_POSITIVE_X :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_X = 0x8515 +gl_TEXTURE_2D_ARRAY :: GLenum +gl_TEXTURE_2D_ARRAY = 0x8C1A +gl_OFFSET_TEXTURE_MATRIX_NV :: GLenum +gl_OFFSET_TEXTURE_MATRIX_NV = 0x86E1 +gl_FLOAT_MAT2x4 :: GLenum +gl_FLOAT_MAT2x4 = 0x8B66 +gl_REG_31_ATI :: GLenum +gl_REG_31_ATI = 0x8940 +gl_DEBUG_TYPE_PORTABILITY :: GLenum +gl_DEBUG_TYPE_PORTABILITY = 0x824F +gl_SAMPLER_2D_ARB :: GLenum +gl_SAMPLER_2D_ARB = 0x8B5E +gl_DRAW_BUFFER11 :: GLenum +gl_DRAW_BUFFER11 = 0x8830 +gl_MAX_COMPUTE_WORK_GROUP_INVOCATIONS :: GLenum +gl_MAX_COMPUTE_WORK_GROUP_INVOCATIONS = 0x90EB +gl_TEXTURE5_ARB :: GLenum +gl_TEXTURE5_ARB = 0x84C5 +gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT :: GLenum +gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS_EXT = 0x90D7 +gl_COLOR_TABLE_SCALE :: GLenum +gl_COLOR_TABLE_SCALE = 0x80D6 +gl_POINT_FADE_THRESHOLD_SIZE_SGIS :: GLenum +gl_POINT_FADE_THRESHOLD_SIZE_SGIS = 0x8128 +gl_MAX_SPARSE_3D_TEXTURE_SIZE_ARB :: GLenum +gl_MAX_SPARSE_3D_TEXTURE_SIZE_ARB = 0x9199 +gl_ACCUM_CLEAR_VALUE :: GLenum +gl_ACCUM_CLEAR_VALUE = 0x0B80 +gl_OPERAND0_ALPHA_EXT :: GLenum +gl_OPERAND0_ALPHA_EXT = 0x8598 +gl_QUERY_NO_WAIT :: GLenum +gl_QUERY_NO_WAIT = 0x8E14 +gl_PRIMITIVE_RESTART :: GLenum +gl_PRIMITIVE_RESTART = 0x8F9D +gl_STENCIL_ATTACHMENT_OES :: GLenum +gl_STENCIL_ATTACHMENT_OES = 0x8D20 +gl_BUFFER_USAGE :: GLenum +gl_BUFFER_USAGE = 0x8765 +gl_COLOR_TABLE_BLUE_SIZE :: GLenum +gl_COLOR_TABLE_BLUE_SIZE = 0x80DC +gl_VERTEX_ARRAY_SIZE_EXT :: GLenum +gl_VERTEX_ARRAY_SIZE_EXT = 0x807A +gl_ALPHA8 :: GLenum +gl_ALPHA8 = 0x803C +gl_PROXY_TEXTURE_2D :: GLenum +gl_PROXY_TEXTURE_2D = 0x8064 +gl_HALF_BIT_ATI :: GLenum +gl_HALF_BIT_ATI = 0x00000008 +gl_TRANSPOSE_MODELVIEW_MATRIX :: GLenum +gl_TRANSPOSE_MODELVIEW_MATRIX = 0x84E3 +gl_DRAW_BUFFER3 :: GLenum +gl_DRAW_BUFFER3 = 0x8828 +gl_4PASS_2_SGIS :: GLenum +gl_4PASS_2_SGIS = 0x80A6 +gl_MAX_GEOMETRY_OUTPUT_COMPONENTS :: GLenum +gl_MAX_GEOMETRY_OUTPUT_COMPONENTS = 0x9124 +gl_SAMPLER_2D_ARRAY_SHADOW_EXT :: GLenum +gl_SAMPLER_2D_ARRAY_SHADOW_EXT = 0x8DC4 +gl_TEXTURE_FORMAT_QCOM :: GLenum +gl_TEXTURE_FORMAT_QCOM = 0x8BD6 +gl_RGB16_SNORM :: GLenum +gl_RGB16_SNORM = 0x8F9A +gl_DRAW_BUFFER8_NV :: GLenum +gl_DRAW_BUFFER8_NV = 0x882D +gl_AUX_BUFFERS :: GLenum +gl_AUX_BUFFERS = 0x0C00 +gl_CONVOLUTION_HINT_SGIX :: GLenum +gl_CONVOLUTION_HINT_SGIX = 0x8316 +gl_FOG_COLOR :: GLenum +gl_FOG_COLOR = 0x0B66 +gl_COLOR_TABLE_RED_SIZE_SGI :: GLenum +gl_COLOR_TABLE_RED_SIZE_SGI = 0x80DA +gl_FUNC_SUBTRACT_OES :: GLenum +gl_FUNC_SUBTRACT_OES = 0x800A +gl_LUMINANCE_ALPHA16F_ARB :: GLenum +gl_LUMINANCE_ALPHA16F_ARB = 0x881F +gl_MODELVIEW10_ARB :: GLenum +gl_MODELVIEW10_ARB = 0x872A +gl_LOGIC_OP :: GLenum +gl_LOGIC_OP = 0x0BF1 +gl_PROGRAM_NATIVE_INSTRUCTIONS_ARB :: GLenum +gl_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A2 +gl_SOURCE0_ALPHA_EXT :: GLenum +gl_SOURCE0_ALPHA_EXT = 0x8588 +gl_INDEX_SHIFT :: GLenum +gl_INDEX_SHIFT = 0x0D12 +gl_PIXEL_FRAGMENT_RGB_SOURCE_SGIS :: GLenum +gl_PIXEL_FRAGMENT_RGB_SOURCE_SGIS = 0x8354 +gl_RG32F_EXT :: GLenum +gl_RG32F_EXT = 0x8230 +gl_GEOMETRY_LINKED_VERTICES_OUT_EXT :: GLenum +gl_GEOMETRY_LINKED_VERTICES_OUT_EXT = 0x8916 +gl_STACK_UNDERFLOW_KHR :: GLenum +gl_STACK_UNDERFLOW_KHR = 0x0504 +gl_TESS_GEN_POINT_MODE_EXT :: GLenum +gl_TESS_GEN_POINT_MODE_EXT = 0x8E79 +gl_BUFFER_ACCESS_ARB :: GLenum +gl_BUFFER_ACCESS_ARB = 0x88BB +gl_DOT_PRODUCT_NV :: GLenum +gl_DOT_PRODUCT_NV = 0x86EC +gl_INVERTED_SCREEN_W_REND :: GLenum +gl_INVERTED_SCREEN_W_REND = 0x8491 +gl_REG_11_ATI :: GLenum +gl_REG_11_ATI = 0x892C +gl_MAX_FRAMEZOOM_FACTOR_SGIX :: GLenum +gl_MAX_FRAMEZOOM_FACTOR_SGIX = 0x818D +gl_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD :: GLenum +gl_QUERY_DEPTH_BOUNDS_FAIL_EVENT_BIT_AMD = 0x00000008 +gl_MATRIX20_ARB :: GLenum +gl_MATRIX20_ARB = 0x88D4 +gl_EVAL_VERTEX_ATTRIB1_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB1_NV = 0x86C7 +gl_COLOR_ATTACHMENT10_NV :: GLenum +gl_COLOR_ATTACHMENT10_NV = 0x8CEA +gl_OUTPUT_TEXTURE_COORD28_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD28_EXT = 0x87B9 +gl_MAX_TEXTURE_COORDS_ARB :: GLenum +gl_MAX_TEXTURE_COORDS_ARB = 0x8871 +gl_COLOR_ARRAY_PARALLEL_POINTERS_INTEL :: GLenum +gl_COLOR_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F7 +gl_MAX_COMBINED_SHADER_OUTPUT_RESOURCES :: GLenum +gl_MAX_COMBINED_SHADER_OUTPUT_RESOURCES = 0x8F39 +gl_RENDERBUFFER_BLUE_SIZE :: GLenum +gl_RENDERBUFFER_BLUE_SIZE = 0x8D52 +gl_MULTISAMPLE_BIT :: GLenum +gl_MULTISAMPLE_BIT = 0x20000000 +gl_CURRENT_PROGRAM :: GLenum +gl_CURRENT_PROGRAM = 0x8B8D +gl_AUX_DEPTH_STENCIL_APPLE :: GLenum +gl_AUX_DEPTH_STENCIL_APPLE = 0x8A14 +gl_LUMINANCE8_ALPHA8_EXT :: GLenum +gl_LUMINANCE8_ALPHA8_EXT = 0x8045 +gl_VIDEO_CAPTURE_SURFACE_ORIGIN_NV :: GLenum +gl_VIDEO_CAPTURE_SURFACE_ORIGIN_NV = 0x903C +gl_INTERLACE_OML :: GLenum +gl_INTERLACE_OML = 0x8980 +gl_REG_27_ATI :: GLenum +gl_REG_27_ATI = 0x893C +gl_UNSIGNED_INT_24_8_OES :: GLenum +gl_UNSIGNED_INT_24_8_OES = 0x84FA +gl_COMBINER_AB_OUTPUT_NV :: GLenum +gl_COMBINER_AB_OUTPUT_NV = 0x854A +gl_CURRENT_RASTER_INDEX :: GLenum +gl_CURRENT_RASTER_INDEX = 0x0B05 +gl_SYNC_FENCE_APPLE :: GLenum +gl_SYNC_FENCE_APPLE = 0x9116 +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_EXT = 0x8CD3 +gl_MAX_TEXTURE_SIZE :: GLenum +gl_MAX_TEXTURE_SIZE = 0x0D33 +gl_TEXTURE24 :: GLenum +gl_TEXTURE24 = 0x84D8 +gl_STENCIL_BACK_FUNC :: GLenum +gl_STENCIL_BACK_FUNC = 0x8800 +gl_LUMINANCE12 :: GLenum +gl_LUMINANCE12 = 0x8041 +gl_PARAMETER_BUFFER_ARB :: GLenum +gl_PARAMETER_BUFFER_ARB = 0x80EE +gl_AUX2 :: GLenum +gl_AUX2 = 0x040B +gl_SLICE_ACCUM_SUN :: GLenum +gl_SLICE_ACCUM_SUN = 0x85CC +gl_COLOR_TABLE_ALPHA_SIZE :: GLenum +gl_COLOR_TABLE_ALPHA_SIZE = 0x80DD +gl_TEXTURE_CUBE_MAP_POSITIVE_X_EXT :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_X_EXT = 0x8515 +gl_DRAW_FRAMEBUFFER_BINDING_ANGLE :: GLenum +gl_DRAW_FRAMEBUFFER_BINDING_ANGLE = 0x8CA6 +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER :: GLenum +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x92C9 +gl_SUBTRACT :: GLenum +gl_SUBTRACT = 0x84E7 +gl_MAX_PROGRAM_IF_DEPTH_NV :: GLenum +gl_MAX_PROGRAM_IF_DEPTH_NV = 0x88F6 +gl_T2F_C4F_N3F_V3F :: GLenum +gl_T2F_C4F_N3F_V3F = 0x2A2C +gl_ACTIVE_SUBROUTINE_UNIFORMS :: GLenum +gl_ACTIVE_SUBROUTINE_UNIFORMS = 0x8DE6 +gl_EMBOSS_LIGHT_NV :: GLenum +gl_EMBOSS_LIGHT_NV = 0x855D +gl_POINT_SIZE_RANGE :: GLenum +gl_POINT_SIZE_RANGE = 0x0B12 +gl_GEOMETRY_LINKED_OUTPUT_TYPE_EXT :: GLenum +gl_GEOMETRY_LINKED_OUTPUT_TYPE_EXT = 0x8918 +gl_CLAMP_TO_BORDER :: GLenum +gl_CLAMP_TO_BORDER = 0x812D +gl_TEXTURE_BUFFER_OFFSET_EXT :: GLenum +gl_TEXTURE_BUFFER_OFFSET_EXT = 0x919D +gl_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV :: GLenum +gl_COMPUTE_PROGRAM_PARAMETER_BUFFER_NV = 0x90FC +gl_COMPRESSED_INTENSITY :: GLenum +gl_COMPRESSED_INTENSITY = 0x84EC +gl_MAX_PROGRAM_OUTPUT_VERTICES_NV :: GLenum +gl_MAX_PROGRAM_OUTPUT_VERTICES_NV = 0x8C27 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x5_OES = 0x93E6 +gl_MAX_PROGRAM_ATTRIBS_ARB :: GLenum +gl_MAX_PROGRAM_ATTRIBS_ARB = 0x88AD +gl_POST_COLOR_MATRIX_GREEN_SCALE_SGI :: GLenum +gl_POST_COLOR_MATRIX_GREEN_SCALE_SGI = 0x80B5 +gl_TEXTURE_3D_BINDING_EXT :: GLenum +gl_TEXTURE_3D_BINDING_EXT = 0x806A +gl_SHADER_STORAGE_BUFFER_START :: GLenum +gl_SHADER_STORAGE_BUFFER_START = 0x90D4 +gl_MAP2_INDEX :: GLenum +gl_MAP2_INDEX = 0x0DB1 +gl_CONSTANT_COLOR_EXT :: GLenum +gl_CONSTANT_COLOR_EXT = 0x8001 +gl_RG32UI :: GLenum +gl_RG32UI = 0x823C +gl_BGRA :: GLenum +gl_BGRA = 0x80E1 +gl_FRAGMENT_DEPTH_EXT :: GLenum +gl_FRAGMENT_DEPTH_EXT = 0x8452 +gl_GENERATE_MIPMAP_HINT_SGIS :: GLenum +gl_GENERATE_MIPMAP_HINT_SGIS = 0x8192 +gl_DIFFERENCE_NV :: GLenum +gl_DIFFERENCE_NV = 0x929E +gl_UNSIGNED_SHORT_1_15_REV_MESA :: GLenum +gl_UNSIGNED_SHORT_1_15_REV_MESA = 0x8754 +gl_PROGRAM_BINARY_RETRIEVABLE_HINT :: GLenum +gl_PROGRAM_BINARY_RETRIEVABLE_HINT = 0x8257 +gl_RGBA32I :: GLenum +gl_RGBA32I = 0x8D82 +gl_UNSIGNED_INT_8_8_8_8 :: GLenum +gl_UNSIGNED_INT_8_8_8_8 = 0x8035 +gl_DOMAIN :: GLenum +gl_DOMAIN = 0x0A02 +gl_COLOR_MATRIX :: GLenum +gl_COLOR_MATRIX = 0x80B1 +gl_PROGRAM_NATIVE_ATTRIBS_ARB :: GLenum +gl_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AE +gl_OP_ROUND_EXT :: GLenum +gl_OP_ROUND_EXT = 0x8790 +gl_VIEW_CLASS_96_BITS :: GLenum +gl_VIEW_CLASS_96_BITS = 0x82C5 +gl_TEXTURE_WRAP_R_OES :: GLenum +gl_TEXTURE_WRAP_R_OES = 0x8072 +gl_VERTEX_ARRAY_TYPE :: GLenum +gl_VERTEX_ARRAY_TYPE = 0x807B +gl_VIDEO_BUFFER_INTERNAL_FORMAT_NV :: GLenum +gl_VIDEO_BUFFER_INTERNAL_FORMAT_NV = 0x902D +gl_PIXEL_MAP_R_TO_R_SIZE :: GLenum +gl_PIXEL_MAP_R_TO_R_SIZE = 0x0CB6 +gl_UNSIGNED_NORMALIZED_ARB :: GLenum +gl_UNSIGNED_NORMALIZED_ARB = 0x8C17 +gl_UNSIGNED_INT8_VEC3_NV :: GLenum +gl_UNSIGNED_INT8_VEC3_NV = 0x8FEE +gl_COMPRESSED_RGBA8_ETC2_EAC_OES :: GLenum +gl_COMPRESSED_RGBA8_ETC2_EAC_OES = 0x9278 +gl_HI_BIAS_NV :: GLenum +gl_HI_BIAS_NV = 0x8714 +gl_SECONDARY_COLOR_ARRAY_EXT :: GLenum +gl_SECONDARY_COLOR_ARRAY_EXT = 0x845E +gl_BUFFER_MAP_OFFSET :: GLenum +gl_BUFFER_MAP_OFFSET = 0x9121 +gl_LUMINANCE4_ALPHA4_OES :: GLenum +gl_LUMINANCE4_ALPHA4_OES = 0x8043 +gl_FORMAT_SUBSAMPLE_244_244_OML :: GLenum +gl_FORMAT_SUBSAMPLE_244_244_OML = 0x8983 +gl_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA :: GLenum +gl_FRAGMENT_PROGRAM_CALLBACK_FUNC_MESA = 0x8BB2 +gl_PLUS_CLAMPED_ALPHA_NV :: GLenum +gl_PLUS_CLAMPED_ALPHA_NV = 0x92B2 +gl_COLOR_ATTACHMENT0_NV :: GLenum +gl_COLOR_ATTACHMENT0_NV = 0x8CE0 +gl_COMPRESSED_RGB_S3TC_DXT1_EXT :: GLenum +gl_COMPRESSED_RGB_S3TC_DXT1_EXT = 0x83F0 +gl_GEOMETRY_OUTPUT_TYPE :: GLenum +gl_GEOMETRY_OUTPUT_TYPE = 0x8918 +gl_INTENSITY8_EXT :: GLenum +gl_INTENSITY8_EXT = 0x804B +gl_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_Y_EXT = 0x8517 +gl_COMPRESSED_RED_GREEN_RGTC2_EXT :: GLenum +gl_COMPRESSED_RED_GREEN_RGTC2_EXT = 0x8DBD +gl_DEBUG_SOURCE_API_KHR :: GLenum +gl_DEBUG_SOURCE_API_KHR = 0x8246 +gl_BLEND_PREMULTIPLIED_SRC_NV :: GLenum +gl_BLEND_PREMULTIPLIED_SRC_NV = 0x9280 +gl_CLIENT_STORAGE_BIT :: GLenum +gl_CLIENT_STORAGE_BIT = 0x0200 +gl_INTENSITY12_EXT :: GLenum +gl_INTENSITY12_EXT = 0x804C +gl_MATRIX_INDEX_ARRAY_STRIDE_OES :: GLenum +gl_MATRIX_INDEX_ARRAY_STRIDE_OES = 0x8848 +gl_CURRENT_RASTER_SECONDARY_COLOR :: GLenum +gl_CURRENT_RASTER_SECONDARY_COLOR = 0x845F +gl_REPLACE :: GLenum +gl_REPLACE = 0x1E01 +gl_LINEAR :: GLenum +gl_LINEAR = 0x2601 +gl_COMBINER_INPUT_NV :: GLenum +gl_COMBINER_INPUT_NV = 0x8542 +gl_TRANSFORM_FEEDBACK_VARYINGS :: GLenum +gl_TRANSFORM_FEEDBACK_VARYINGS = 0x8C83 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x3_OES = 0x93E2 +gl_IMAGE_BINDING_ACCESS :: GLenum +gl_IMAGE_BINDING_ACCESS = 0x8F3E +gl_NUM_LOOPBACK_COMPONENTS_ATI :: GLenum +gl_NUM_LOOPBACK_COMPONENTS_ATI = 0x8974 +gl_ARRAY_ELEMENT_LOCK_COUNT_EXT :: GLenum +gl_ARRAY_ELEMENT_LOCK_COUNT_EXT = 0x81A9 +gl_REPLACEMENT_CODE_ARRAY_POINTER_SUN :: GLenum +gl_REPLACEMENT_CODE_ARRAY_POINTER_SUN = 0x85C3 +gl_TEXTURE_4DSIZE_SGIS :: GLenum +gl_TEXTURE_4DSIZE_SGIS = 0x8136 +gl_COUNTER_RANGE_AMD :: GLenum +gl_COUNTER_RANGE_AMD = 0x8BC1 +gl_RGB8_OES :: GLenum +gl_RGB8_OES = 0x8051 +gl_ALPHA16F_EXT :: GLenum +gl_ALPHA16F_EXT = 0x881C +gl_C4F_N3F_V3F :: GLenum +gl_C4F_N3F_V3F = 0x2A26 +gl_NEAREST_MIPMAP_LINEAR :: GLenum +gl_NEAREST_MIPMAP_LINEAR = 0x2702 +gl_DEBUG_SEVERITY_LOW_KHR :: GLenum +gl_DEBUG_SEVERITY_LOW_KHR = 0x9148 +gl_DISCARD_ATI :: GLenum +gl_DISCARD_ATI = 0x8763 +gl_LOCAL_CONSTANT_DATATYPE_EXT :: GLenum +gl_LOCAL_CONSTANT_DATATYPE_EXT = 0x87ED +gl_MAX_GEOMETRY_INPUT_COMPONENTS_EXT :: GLenum +gl_MAX_GEOMETRY_INPUT_COMPONENTS_EXT = 0x9123 +gl_LOWER_LEFT :: GLenum +gl_LOWER_LEFT = 0x8CA1 +gl_RENDERBUFFER_HEIGHT_OES :: GLenum +gl_RENDERBUFFER_HEIGHT_OES = 0x8D43 +gl_SPRITE_MODE_SGIX :: GLenum +gl_SPRITE_MODE_SGIX = 0x8149 +gl_REPLACEMENT_CODE_ARRAY_TYPE_SUN :: GLenum +gl_REPLACEMENT_CODE_ARRAY_TYPE_SUN = 0x85C1 +gl_UNSIGNED_INT8_VEC2_NV :: GLenum +gl_UNSIGNED_INT8_VEC2_NV = 0x8FED +gl_NONE_OES :: GLenum +gl_NONE_OES = 0 +gl_POINT_SIZE_MIN_ARB :: GLenum +gl_POINT_SIZE_MIN_ARB = 0x8126 +gl_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV :: GLenum +gl_FRAGMENT_PROGRAM_INTERPOLATION_OFFSET_BITS_NV = 0x8E5D +gl_RENDERBUFFER_DEPTH_SIZE_EXT :: GLenum +gl_RENDERBUFFER_DEPTH_SIZE_EXT = 0x8D54 +gl_BUFFER_MAP_LENGTH :: GLenum +gl_BUFFER_MAP_LENGTH = 0x9120 +gl_WRITE_ONLY :: GLenum +gl_WRITE_ONLY = 0x88B9 +gl_NEAREST_CLIPMAP_NEAREST_SGIX :: GLenum +gl_NEAREST_CLIPMAP_NEAREST_SGIX = 0x844D +gl_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV :: GLenum +gl_GLYPH_HORIZONTAL_BEARING_ADVANCE_BIT_NV = 0x10 +gl_ALREADY_SIGNALED_APPLE :: GLenum +gl_ALREADY_SIGNALED_APPLE = 0x911A +gl_REPLICATE_BORDER :: GLenum +gl_REPLICATE_BORDER = 0x8153 +gl_SUBPIXEL_BITS :: GLenum +gl_SUBPIXEL_BITS = 0x0D50 +gl_ALPHA_MIN_SGIX :: GLenum +gl_ALPHA_MIN_SGIX = 0x8320 +gl_BLUE_BIT_ATI :: GLenum +gl_BLUE_BIT_ATI = 0x00000004 +gl_UNSIGNED_INT_IMAGE_2D_EXT :: GLenum +gl_UNSIGNED_INT_IMAGE_2D_EXT = 0x9063 +gl_TRANSFORM_FEEDBACK_VARYINGS_EXT :: GLenum +gl_TRANSFORM_FEEDBACK_VARYINGS_EXT = 0x8C83 +gl_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT :: GLenum +gl_COMPRESSED_SIGNED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C73 +gl_PIXEL_COUNTER_BITS_NV :: GLenum +gl_PIXEL_COUNTER_BITS_NV = 0x8864 +gl_422_REV_AVERAGE_EXT :: GLenum +gl_422_REV_AVERAGE_EXT = 0x80CF +gl_TEXTURE_RESIDENT_EXT :: GLenum +gl_TEXTURE_RESIDENT_EXT = 0x8067 +gl_STENCIL_WRITEMASK :: GLenum +gl_STENCIL_WRITEMASK = 0x0B98 +gl_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES :: GLenum +gl_UNIFORM_BLOCK_ACTIVE_UNIFORM_INDICES = 0x8A43 +gl_FLOAT_VEC3_ARB :: GLenum +gl_FLOAT_VEC3_ARB = 0x8B51 +gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM :: GLenum +gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM = 0x8E8D +gl_DYNAMIC_STORAGE_BIT :: GLenum +gl_DYNAMIC_STORAGE_BIT = 0x0100 +gl_DRAW_FRAMEBUFFER_BINDING_APPLE :: GLenum +gl_DRAW_FRAMEBUFFER_BINDING_APPLE = 0x8CA6 +gl_CLIP_PLANE4_IMG :: GLenum +gl_CLIP_PLANE4_IMG = 0x3004 +gl_CON_26_ATI :: GLenum +gl_CON_26_ATI = 0x895B +gl_COMPRESSED_SIGNED_R11_EAC_OES :: GLenum +gl_COMPRESSED_SIGNED_R11_EAC_OES = 0x9271 +gl_LINES_ADJACENCY_EXT :: GLenum +gl_LINES_ADJACENCY_EXT = 0x000A +gl_AUTO_GENERATE_MIPMAP :: GLenum +gl_AUTO_GENERATE_MIPMAP = 0x8295 +gl_OP_EXP_BASE_2_EXT :: GLenum +gl_OP_EXP_BASE_2_EXT = 0x8791 +gl_ATTRIB_STACK_DEPTH :: GLenum +gl_ATTRIB_STACK_DEPTH = 0x0BB0 +gl_ALPHA32F_EXT :: GLenum +gl_ALPHA32F_EXT = 0x8816 +gl_KEEP :: GLenum +gl_KEEP = 0x1E00 +gl_TEXTURE_FILTER4_SIZE_SGIS :: GLenum +gl_TEXTURE_FILTER4_SIZE_SGIS = 0x8147 +gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT :: GLenum +gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x906A +gl_INT_VEC3 :: GLenum +gl_INT_VEC3 = 0x8B54 +gl_MATRIX_MODE :: GLenum +gl_MATRIX_MODE = 0x0BA0 +gl_UNSIGNED_NORMALIZED :: GLenum +gl_UNSIGNED_NORMALIZED = 0x8C17 +gl_DEBUG_PRINT_MESA :: GLenum +gl_DEBUG_PRINT_MESA = 0x875A +gl_DST_OUT_NV :: GLenum +gl_DST_OUT_NV = 0x928D +gl_CLEAR_BUFFER :: GLenum +gl_CLEAR_BUFFER = 0x82B4 +gl_COMBINER_SCALE_NV :: GLenum +gl_COMBINER_SCALE_NV = 0x8548 +gl_WRITE_ONLY_OES :: GLenum +gl_WRITE_ONLY_OES = 0x88B9 +gl_422_AVERAGE_EXT :: GLenum +gl_422_AVERAGE_EXT = 0x80CE +gl_COLOR_INDEX12_EXT :: GLenum +gl_COLOR_INDEX12_EXT = 0x80E6 +gl_COLOR_BUFFER_BIT0_QCOM :: GLenum +gl_COLOR_BUFFER_BIT0_QCOM = 0x00000001 +gl_CAVEAT_SUPPORT :: GLenum +gl_CAVEAT_SUPPORT = 0x82B8 +gl_BLUE_INTEGER :: GLenum +gl_BLUE_INTEGER = 0x8D96 +gl_IUI_N3F_V2F_EXT :: GLenum +gl_IUI_N3F_V2F_EXT = 0x81AF +gl_VERTEX_DATA_HINT_PGI :: GLenum +gl_VERTEX_DATA_HINT_PGI = 0x1A22A +gl_REG_13_ATI :: GLenum +gl_REG_13_ATI = 0x892E +gl_NEGATIVE_ONE_EXT :: GLenum +gl_NEGATIVE_ONE_EXT = 0x87DF +gl_CON_16_ATI :: GLenum +gl_CON_16_ATI = 0x8951 +gl_TEXTURE_EXTERNAL_OES :: GLenum +gl_TEXTURE_EXTERNAL_OES = 0x8D65 +gl_SHADER_TYPE :: GLenum +gl_SHADER_TYPE = 0x8B4F +gl_OVERLAY_KHR :: GLenum +gl_OVERLAY_KHR = 0x9296 +gl_LUMINANCE6_ALPHA2_EXT :: GLenum +gl_LUMINANCE6_ALPHA2_EXT = 0x8044 +gl_COLOR_TABLE_SGI :: GLenum +gl_COLOR_TABLE_SGI = 0x80D0 +gl_TEXTURE_STENCIL_SIZE_EXT :: GLenum +gl_TEXTURE_STENCIL_SIZE_EXT = 0x88F1 +gl_NEAREST :: GLenum +gl_NEAREST = 0x2600 +gl_RGB8I :: GLenum +gl_RGB8I = 0x8D8F +gl_TEXTURE_SPARSE_ARB :: GLenum +gl_TEXTURE_SPARSE_ARB = 0x91A6 +gl_MATRIX9_ARB :: GLenum +gl_MATRIX9_ARB = 0x88C9 +gl_TEXTURE_TARGET :: GLenum +gl_TEXTURE_TARGET = 0x1006 +gl_SECONDARY_COLOR_ARRAY_TYPE_EXT :: GLenum +gl_SECONDARY_COLOR_ARRAY_TYPE_EXT = 0x845B +gl_RENDERER :: GLenum +gl_RENDERER = 0x1F01 +gl_TEXTURE_BINDING_BUFFER :: GLenum +gl_TEXTURE_BINDING_BUFFER = 0x8C2C +gl_INT_VEC3_ARB :: GLenum +gl_INT_VEC3_ARB = 0x8B54 +gl_MATRIX12_ARB :: GLenum +gl_MATRIX12_ARB = 0x88CC +gl_VERTEX_ATTRIB_ARRAY_ENABLED :: GLenum +gl_VERTEX_ATTRIB_ARRAY_ENABLED = 0x8622 +gl_RENDERBUFFER_SAMPLES_NV :: GLenum +gl_RENDERBUFFER_SAMPLES_NV = 0x8CAB +gl_COLOR_ATTACHMENT1_EXT :: GLenum +gl_COLOR_ATTACHMENT1_EXT = 0x8CE1 +gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE = 0x8211 +gl_LINEAR_DETAIL_SGIS :: GLenum +gl_LINEAR_DETAIL_SGIS = 0x8097 +gl_CURRENT_RASTER_POSITION_VALID :: GLenum +gl_CURRENT_RASTER_POSITION_VALID = 0x0B08 +gl_LINEAR_DETAIL_COLOR_SGIS :: GLenum +gl_LINEAR_DETAIL_COLOR_SGIS = 0x8099 +gl_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT :: GLenum +gl_COMPRESSED_SRGB_PVRTC_2BPPV1_EXT = 0x8A54 +gl_POINT_SIZE_MIN_EXT :: GLenum +gl_POINT_SIZE_MIN_EXT = 0x8126 +gl_GPU_DISJOINT_EXT :: GLenum +gl_GPU_DISJOINT_EXT = 0x8FBB +gl_LIGHT_MODEL_COLOR_CONTROL :: GLenum +gl_LIGHT_MODEL_COLOR_CONTROL = 0x81F8 +gl_MAX_TESS_PATCH_COMPONENTS :: GLenum +gl_MAX_TESS_PATCH_COMPONENTS = 0x8E84 +gl_CURRENT_PALETTE_MATRIX_OES :: GLenum +gl_CURRENT_PALETTE_MATRIX_OES = 0x8843 +gl_SAMPLES_SGIS :: GLenum +gl_SAMPLES_SGIS = 0x80A9 +gl_FUNC_REVERSE_SUBTRACT_OES :: GLenum +gl_FUNC_REVERSE_SUBTRACT_OES = 0x800B +gl_TEXTURE13_ARB :: GLenum +gl_TEXTURE13_ARB = 0x84CD +gl_SMOOTH_CUBIC_CURVE_TO_NV :: GLenum +gl_SMOOTH_CUBIC_CURVE_TO_NV = 0x10 +gl_COMPRESSED_RGBA_ASTC_3x3x3_OES :: GLenum +gl_COMPRESSED_RGBA_ASTC_3x3x3_OES = 0x93C0 +gl_MODELVIEW15_ARB :: GLenum +gl_MODELVIEW15_ARB = 0x872F +gl_EYE_PLANE_ABSOLUTE_NV :: GLenum +gl_EYE_PLANE_ABSOLUTE_NV = 0x855C +gl_READ_FRAMEBUFFER_BINDING_NV :: GLenum +gl_READ_FRAMEBUFFER_BINDING_NV = 0x8CAA +gl_RENDERBUFFER_RED_SIZE :: GLenum +gl_RENDERBUFFER_RED_SIZE = 0x8D50 +gl_PIXEL_PACK_BUFFER_BINDING_EXT :: GLenum +gl_PIXEL_PACK_BUFFER_BINDING_EXT = 0x88ED +gl_MAX_RENDERBUFFER_SIZE :: GLenum +gl_MAX_RENDERBUFFER_SIZE = 0x84E8 +gl_DOUBLE_MAT4_EXT :: GLenum +gl_DOUBLE_MAT4_EXT = 0x8F48 +gl_COMPRESSED_R11_EAC :: GLenum +gl_COMPRESSED_R11_EAC = 0x9270 +gl_INT_IMAGE_2D_RECT :: GLenum +gl_INT_IMAGE_2D_RECT = 0x905A +gl_MAD_ATI :: GLenum +gl_MAD_ATI = 0x8968 +gl_IMAGE_CLASS_4_X_32 :: GLenum +gl_IMAGE_CLASS_4_X_32 = 0x82B9 +gl_VIDEO_COLOR_CONVERSION_OFFSET_NV :: GLenum +gl_VIDEO_COLOR_CONVERSION_OFFSET_NV = 0x902C +gl_BOOL_VEC4 :: GLenum +gl_BOOL_VEC4 = 0x8B59 +gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING_ARB = 0x889D +gl_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES :: GLenum +gl_FRAGMENT_INTERPOLATION_OFFSET_BITS_OES = 0x8E5D +gl_HISTOGRAM_FORMAT_EXT :: GLenum +gl_HISTOGRAM_FORMAT_EXT = 0x8027 +gl_UNSIGNED_INT_8_8_8_8_REV_EXT :: GLenum +gl_UNSIGNED_INT_8_8_8_8_REV_EXT = 0x8367 +gl_R1UI_C3F_V3F_SUN :: GLenum +gl_R1UI_C3F_V3F_SUN = 0x85C6 +gl_SAMPLER_1D_ARRAY_SHADOW_EXT :: GLenum +gl_SAMPLER_1D_ARRAY_SHADOW_EXT = 0x8DC3 +gl_TEXTURE_BINDING_2D_ARRAY :: GLenum +gl_TEXTURE_BINDING_2D_ARRAY = 0x8C1D +gl_TEXTURE_RANGE_POINTER_APPLE :: GLenum +gl_TEXTURE_RANGE_POINTER_APPLE = 0x85B8 +gl_SMALL_CCW_ARC_TO_NV :: GLenum +gl_SMALL_CCW_ARC_TO_NV = 0x12 +gl_SHADER_COMPILER :: GLenum +gl_SHADER_COMPILER = 0x8DFA +gl_DEPTH_COMPONENT24_ARB :: GLenum +gl_DEPTH_COMPONENT24_ARB = 0x81A6 +gl_COLOR_ATTACHMENT14_NV :: GLenum +gl_COLOR_ATTACHMENT14_NV = 0x8CEE +gl_TIME_ELAPSED :: GLenum +gl_TIME_ELAPSED = 0x88BF +gl_FRAMEBUFFER_DEFAULT_LAYERS_EXT :: GLenum +gl_FRAMEBUFFER_DEFAULT_LAYERS_EXT = 0x9312 +gl_MATRIX11_ARB :: GLenum +gl_MATRIX11_ARB = 0x88CB +gl_XOR :: GLenum +gl_XOR = 0x1506 +gl_HSL_SATURATION_KHR :: GLenum +gl_HSL_SATURATION_KHR = 0x92AE +gl_R1UI_T2F_V3F_SUN :: GLenum +gl_R1UI_T2F_V3F_SUN = 0x85C9 +gl_COMPUTE_WORK_GROUP_SIZE :: GLenum +gl_COMPUTE_WORK_GROUP_SIZE = 0x8267 +gl_BLEND_EQUATION_EXT :: GLenum +gl_BLEND_EQUATION_EXT = 0x8009 +gl_SAMPLER :: GLenum +gl_SAMPLER = 0x82E6 +gl_NUM_FRAGMENT_REGISTERS_ATI :: GLenum +gl_NUM_FRAGMENT_REGISTERS_ATI = 0x896E +gl_REG_5_ATI :: GLenum +gl_REG_5_ATI = 0x8926 +gl_DSDT8_MAG8_INTENSITY8_NV :: GLenum +gl_DSDT8_MAG8_INTENSITY8_NV = 0x870B +gl_PIXEL_MAP_S_TO_S_SIZE :: GLenum +gl_PIXEL_MAP_S_TO_S_SIZE = 0x0CB1 +gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT = 0x8CD7 +gl_OR_REVERSE :: GLenum +gl_OR_REVERSE = 0x150B +gl_QUERY_BUFFER_BARRIER_BIT :: GLenum +gl_QUERY_BUFFER_BARRIER_BIT = 0x00008000 +gl_TRANSFORM_FEEDBACK_BUFFER_BINDING :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_BINDING = 0x8C8F +gl_SAMPLER_1D :: GLenum +gl_SAMPLER_1D = 0x8B5D +gl_COLOR_TABLE_INTENSITY_SIZE :: GLenum +gl_COLOR_TABLE_INTENSITY_SIZE = 0x80DF +gl_TRIANGLE_FAN :: GLenum +gl_TRIANGLE_FAN = 0x0006 +gl_POINT_SIZE_MAX_SGIS :: GLenum +gl_POINT_SIZE_MAX_SGIS = 0x8127 +gl_ELEMENT_ARRAY_POINTER_ATI :: GLenum +gl_ELEMENT_ARRAY_POINTER_ATI = 0x876A +gl_INT_IMAGE_1D_EXT :: GLenum +gl_INT_IMAGE_1D_EXT = 0x9057 +gl_CONVOLUTION_FILTER_SCALE_EXT :: GLenum +gl_CONVOLUTION_FILTER_SCALE_EXT = 0x8014 +gl_EVAL_VERTEX_ATTRIB8_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB8_NV = 0x86CE +gl_DYNAMIC_COPY_ARB :: GLenum +gl_DYNAMIC_COPY_ARB = 0x88EA +gl_REG_12_ATI :: GLenum +gl_REG_12_ATI = 0x892D +gl_SIGNED_NORMALIZED :: GLenum +gl_SIGNED_NORMALIZED = 0x8F9C +gl_REG_8_ATI :: GLenum +gl_REG_8_ATI = 0x8929 +gl_SAMPLE_COVERAGE_ARB :: GLenum +gl_SAMPLE_COVERAGE_ARB = 0x80A0 +gl_ALLOW_DRAW_MEM_HINT_PGI :: GLenum +gl_ALLOW_DRAW_MEM_HINT_PGI = 0x1A211 +gl_INTENSITY16F_ARB :: GLenum +gl_INTENSITY16F_ARB = 0x881D +gl_PATH_FORMAT_PS_NV :: GLenum +gl_PATH_FORMAT_PS_NV = 0x9071 +gl_TEXTURE_FREE_MEMORY_ATI :: GLenum +gl_TEXTURE_FREE_MEMORY_ATI = 0x87FC +gl_SYNC_FENCE :: GLenum +gl_SYNC_FENCE = 0x9116 +gl_WRITE_ONLY_ARB :: GLenum +gl_WRITE_ONLY_ARB = 0x88B9 +gl_INVERT :: GLenum +gl_INVERT = 0x150A +gl_TRANSLATE_Y_NV :: GLenum +gl_TRANSLATE_Y_NV = 0x908F +gl_SAMPLER_3D :: GLenum +gl_SAMPLER_3D = 0x8B5F +gl_LINE_STRIP_ADJACENCY :: GLenum +gl_LINE_STRIP_ADJACENCY = 0x000B +gl_OPERAND2_RGB_EXT :: GLenum +gl_OPERAND2_RGB_EXT = 0x8592 +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_IMG = 0x9134 +gl_COLOR_ARRAY_ADDRESS_NV :: GLenum +gl_COLOR_ARRAY_ADDRESS_NV = 0x8F23 +gl_POST_CONVOLUTION_BLUE_SCALE_EXT :: GLenum +gl_POST_CONVOLUTION_BLUE_SCALE_EXT = 0x801E +gl_HIGH_FLOAT :: GLenum +gl_HIGH_FLOAT = 0x8DF2 +gl_TESS_GEN_MODE_EXT :: GLenum +gl_TESS_GEN_MODE_EXT = 0x8E76 +gl_DOT_PRODUCT_TEXTURE_RECTANGLE_NV :: GLenum +gl_DOT_PRODUCT_TEXTURE_RECTANGLE_NV = 0x864E +gl_MAX_LABEL_LENGTH :: GLenum +gl_MAX_LABEL_LENGTH = 0x82E8 +gl_QUERY_BY_REGION_NO_WAIT :: GLenum +gl_QUERY_BY_REGION_NO_WAIT = 0x8E16 +gl_OP_RECIP_EXT :: GLenum +gl_OP_RECIP_EXT = 0x8794 +gl_PROXY_TEXTURE_2D_ARRAY :: GLenum +gl_PROXY_TEXTURE_2D_ARRAY = 0x8C1B +gl_COMPRESSED_RGBA_FXT1_3DFX :: GLenum +gl_COMPRESSED_RGBA_FXT1_3DFX = 0x86B1 +gl_PRIMITIVES_GENERATED :: GLenum +gl_PRIMITIVES_GENERATED = 0x8C87 +gl_TEXTURE26_ARB :: GLenum +gl_TEXTURE26_ARB = 0x84DA +gl_TESS_EVALUATION_TEXTURE :: GLenum +gl_TESS_EVALUATION_TEXTURE = 0x829D +gl_TEXTURE1 :: GLenum +gl_TEXTURE1 = 0x84C1 +gl_TRANSFORM_FEEDBACK_RECORD_NV :: GLenum +gl_TRANSFORM_FEEDBACK_RECORD_NV = 0x8C86 +gl_DRAW_FRAMEBUFFER_NV :: GLenum +gl_DRAW_FRAMEBUFFER_NV = 0x8CA9 +gl_MODELVIEW8_ARB :: GLenum +gl_MODELVIEW8_ARB = 0x8728 +gl_UNSIGNED_INT_SAMPLER_BUFFER :: GLenum +gl_UNSIGNED_INT_SAMPLER_BUFFER = 0x8DD8 +gl_CONVOLUTION_1D :: GLenum +gl_CONVOLUTION_1D = 0x8010 +gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED_NV = 0x8E23 +gl_SAMPLER_1D_ARRAY :: GLenum +gl_SAMPLER_1D_ARRAY = 0x8DC0 +gl_TRANSFORM_FEEDBACK_BINDING :: GLenum +gl_TRANSFORM_FEEDBACK_BINDING = 0x8E25 +gl_LIGHTING_BIT :: GLenum +gl_LIGHTING_BIT = 0x00000040 +gl_R1UI_C4F_N3F_V3F_SUN :: GLenum +gl_R1UI_C4F_N3F_V3F_SUN = 0x85C8 +gl_TEXTURE_RED_SIZE_EXT :: GLenum +gl_TEXTURE_RED_SIZE_EXT = 0x805C +gl_VERTEX_ARRAY_KHR :: GLenum +gl_VERTEX_ARRAY_KHR = 0x8074 +gl_ALPHA_BITS :: GLenum +gl_ALPHA_BITS = 0x0D55 +gl_MAX_VERTEX_SHADER_INVARIANTS_EXT :: GLenum +gl_MAX_VERTEX_SHADER_INVARIANTS_EXT = 0x87C7 +gl_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS :: GLenum +gl_MAX_COMBINED_VERTEX_UNIFORM_COMPONENTS = 0x8A31 +gl_SAMPLE_MASK_INVERT_EXT :: GLenum +gl_SAMPLE_MASK_INVERT_EXT = 0x80AB +gl_TRANSPOSE_PROGRAM_MATRIX_EXT :: GLenum +gl_TRANSPOSE_PROGRAM_MATRIX_EXT = 0x8E2E +gl_ABGR_EXT :: GLenum +gl_ABGR_EXT = 0x8000 +gl_MULTISAMPLE_BIT_3DFX :: GLenum +gl_MULTISAMPLE_BIT_3DFX = 0x20000000 +gl_MATRIX0_NV :: GLenum +gl_MATRIX0_NV = 0x8630 +gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING = 0x8210 +gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG :: GLenum +gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV2_IMG = 0x93F0 +gl_RGB9_E5 :: GLenum +gl_RGB9_E5 = 0x8C3D +gl_IMAGE_2D_MULTISAMPLE_ARRAY :: GLenum +gl_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9056 +gl_FRAMEBUFFER_ATTACHMENT_RED_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_RED_SIZE = 0x8212 +gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_NV = 0x8C8F +gl_GEOMETRY_PROGRAM_NV :: GLenum +gl_GEOMETRY_PROGRAM_NV = 0x8C26 +gl_RGB10_EXT :: GLenum +gl_RGB10_EXT = 0x8052 +gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT :: GLenum +gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT = 0x8E8F +gl_ALWAYS_SOFT_HINT_PGI :: GLenum +gl_ALWAYS_SOFT_HINT_PGI = 0x1A20D +gl_WEIGHT_ARRAY_BUFFER_BINDING :: GLenum +gl_WEIGHT_ARRAY_BUFFER_BINDING = 0x889E +gl_BLEND_DST_ALPHA_OES :: GLenum +gl_BLEND_DST_ALPHA_OES = 0x80CA +gl_UNIFORM_BUFFER_BINDING_EXT :: GLenum +gl_UNIFORM_BUFFER_BINDING_EXT = 0x8DEF +gl_CONTINUOUS_AMD :: GLenum +gl_CONTINUOUS_AMD = 0x9007 +gl_STENCIL_BUFFER_BIT4_QCOM :: GLenum +gl_STENCIL_BUFFER_BIT4_QCOM = 0x00100000 +gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV :: GLenum +gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_NV = 0x8C88 +gl_TESS_EVALUATION_SHADER_BIT :: GLenum +gl_TESS_EVALUATION_SHADER_BIT = 0x00000010 +gl_TEXTURE_COORD_ARRAY_EXT :: GLenum +gl_TEXTURE_COORD_ARRAY_EXT = 0x8078 +gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET :: GLenum +gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5F +gl_PROGRAM_INSTRUCTIONS_ARB :: GLenum +gl_PROGRAM_INSTRUCTIONS_ARB = 0x88A0 +gl_PROXY_TEXTURE_3D :: GLenum +gl_PROXY_TEXTURE_3D = 0x8070 +gl_CLIP_PLANE0 :: GLenum +gl_CLIP_PLANE0 = 0x3000 +gl_CURRENT_QUERY_EXT :: GLenum +gl_CURRENT_QUERY_EXT = 0x8865 +gl_T4F_C4F_N3F_V4F :: GLenum +gl_T4F_C4F_N3F_V4F = 0x2A2D +gl_ADD :: GLenum +gl_ADD = 0x0104 +gl_STENCIL_EXT :: GLenum +gl_STENCIL_EXT = 0x1802 +gl_TEXTURE_BLUE_TYPE :: GLenum +gl_TEXTURE_BLUE_TYPE = 0x8C12 +gl_OUTPUT_TEXTURE_COORD8_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD8_EXT = 0x87A5 +gl_OBJECT_TYPE_ARB :: GLenum +gl_OBJECT_TYPE_ARB = 0x8B4E +gl_RESET_NOTIFICATION_STRATEGY :: GLenum +gl_RESET_NOTIFICATION_STRATEGY = 0x8256 +gl_UNSIGNED_INT_VEC2_EXT :: GLenum +gl_UNSIGNED_INT_VEC2_EXT = 0x8DC6 +gl_DRAW_BUFFER6_NV :: GLenum +gl_DRAW_BUFFER6_NV = 0x882B +gl_ASYNC_DRAW_PIXELS_SGIX :: GLenum +gl_ASYNC_DRAW_PIXELS_SGIX = 0x835D +gl_INTERNALFORMAT_GREEN_SIZE :: GLenum +gl_INTERNALFORMAT_GREEN_SIZE = 0x8272 +gl_TEXTURE_GREEN_SIZE :: GLenum +gl_TEXTURE_GREEN_SIZE = 0x805D +gl_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL :: GLenum +gl_PERFQUERY_COUNTER_NAME_LENGTH_MAX_INTEL = 0x94FE +gl_VIRTUAL_PAGE_SIZE_Y_AMD :: GLenum +gl_VIRTUAL_PAGE_SIZE_Y_AMD = 0x9196 +gl_OP_MUL_EXT :: GLenum +gl_OP_MUL_EXT = 0x8786 +gl_NORMAL_MAP :: GLenum +gl_NORMAL_MAP = 0x8511 +gl_ALPHA16_EXT :: GLenum +gl_ALPHA16_EXT = 0x803E +gl_POINT_SIZE :: GLenum +gl_POINT_SIZE = 0x0B11 +gl_INTERNALFORMAT_SUPPORTED :: GLenum +gl_INTERNALFORMAT_SUPPORTED = 0x826F +gl_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT = 0x8DD7 +gl_DEBUG_SEVERITY_HIGH_ARB :: GLenum +gl_DEBUG_SEVERITY_HIGH_ARB = 0x9146 +gl_TEXTURE_MAX_LEVEL_SGIS :: GLenum +gl_TEXTURE_MAX_LEVEL_SGIS = 0x813D +gl_SHADING_LANGUAGE_VERSION_ARB :: GLenum +gl_SHADING_LANGUAGE_VERSION_ARB = 0x8B8C +gl_STANDARD_FONT_FORMAT_NV :: GLenum +gl_STANDARD_FONT_FORMAT_NV = 0x936C +gl_VERTEX_WEIGHT_ARRAY_SIZE_EXT :: GLenum +gl_VERTEX_WEIGHT_ARRAY_SIZE_EXT = 0x850D +gl_IR_INSTRUMENT1_SGIX :: GLenum +gl_IR_INSTRUMENT1_SGIX = 0x817F +gl_SIGNED_HILO8_NV :: GLenum +gl_SIGNED_HILO8_NV = 0x885F +gl_RENDERBUFFER_GREEN_SIZE_OES :: GLenum +gl_RENDERBUFFER_GREEN_SIZE_OES = 0x8D51 +gl_REG_1_ATI :: GLenum +gl_REG_1_ATI = 0x8922 +gl_CLAMP_TO_EDGE :: GLenum +gl_CLAMP_TO_EDGE = 0x812F +gl_GEOMETRY_SHADER_BIT :: GLenum +gl_GEOMETRY_SHADER_BIT = 0x00000004 +gl_MODELVIEW7_ARB :: GLenum +gl_MODELVIEW7_ARB = 0x8727 +gl_BUFFER_MAPPED_ARB :: GLenum +gl_BUFFER_MAPPED_ARB = 0x88BC +gl_DRAW_BUFFER12_EXT :: GLenum +gl_DRAW_BUFFER12_EXT = 0x8831 +gl_RGB565_OES :: GLenum +gl_RGB565_OES = 0x8D62 +gl_SHORT :: GLenum +gl_SHORT = 0x1402 +gl_STENCIL_BACK_FAIL_ATI :: GLenum +gl_STENCIL_BACK_FAIL_ATI = 0x8801 +gl_UNSIGNED_INT_IMAGE_2D_RECT_EXT :: GLenum +gl_UNSIGNED_INT_IMAGE_2D_RECT_EXT = 0x9065 +gl_PATH_MAX_PROJECTION_STACK_DEPTH_NV :: GLenum +gl_PATH_MAX_PROJECTION_STACK_DEPTH_NV = 0x0D38 +gl_CON_31_ATI :: GLenum +gl_CON_31_ATI = 0x8960 +gl_RGB5 :: GLenum +gl_RGB5 = 0x8050 +gl_SAMPLER_2D_RECT :: GLenum +gl_SAMPLER_2D_RECT = 0x8B63 +gl_COMPRESSED_RGBA_ASTC_5x4x4_OES :: GLenum +gl_COMPRESSED_RGBA_ASTC_5x4x4_OES = 0x93C4 +gl_PASS_THROUGH_TOKEN :: GLenum +gl_PASS_THROUGH_TOKEN = 0x0700 +gl_RGBA_FLOAT32_ATI :: GLenum +gl_RGBA_FLOAT32_ATI = 0x8814 +gl_TEXTURE_COLOR_WRITEMASK_SGIS :: GLenum +gl_TEXTURE_COLOR_WRITEMASK_SGIS = 0x81EF +gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS :: GLenum +gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E1F +gl_OUTPUT_TEXTURE_COORD23_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD23_EXT = 0x87B4 +gl_YCBYCR8_422_NV :: GLenum +gl_YCBYCR8_422_NV = 0x9031 +gl_SRC_NV :: GLenum +gl_SRC_NV = 0x9286 +gl_MAX_EXT :: GLenum +gl_MAX_EXT = 0x8008 +gl_UNPACK_COMPRESSED_BLOCK_DEPTH :: GLenum +gl_UNPACK_COMPRESSED_BLOCK_DEPTH = 0x9129 +gl_UNSIGNED_SHORT_5_5_5_1_EXT :: GLenum +gl_UNSIGNED_SHORT_5_5_5_1_EXT = 0x8034 +gl_IMAGE_3D :: GLenum +gl_IMAGE_3D = 0x904E +gl_DEPTH_BUFFER_BIT0_QCOM :: GLenum +gl_DEPTH_BUFFER_BIT0_QCOM = 0x00000100 +gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS = 0x8C8A +gl_DECR_WRAP_OES :: GLenum +gl_DECR_WRAP_OES = 0x8508 +gl_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV :: GLenum +gl_VIDEO_CAPTURE_FIELD_UPPER_HEIGHT_NV = 0x903A +gl_SPARSE_STORAGE_BIT_ARB :: GLenum +gl_SPARSE_STORAGE_BIT_ARB = 0x0400 +gl_LAST_VIDEO_CAPTURE_STATUS_NV :: GLenum +gl_LAST_VIDEO_CAPTURE_STATUS_NV = 0x9027 +gl_LAST_VERTEX_CONVENTION :: GLenum +gl_LAST_VERTEX_CONVENTION = 0x8E4E +gl_IDENTITY_NV :: GLenum +gl_IDENTITY_NV = 0x862A +gl_RETAINED_APPLE :: GLenum +gl_RETAINED_APPLE = 0x8A1B +gl_FLOAT_RGB32_NV :: GLenum +gl_FLOAT_RGB32_NV = 0x8889 +gl_DRAW_BUFFER15_ARB :: GLenum +gl_DRAW_BUFFER15_ARB = 0x8834 +gl_COLOR_EXT :: GLenum +gl_COLOR_EXT = 0x1800 +gl_WEIGHT_ARRAY_TYPE_OES :: GLenum +gl_WEIGHT_ARRAY_TYPE_OES = 0x86A9 +gl_DETAIL_TEXTURE_2D_BINDING_SGIS :: GLenum +gl_DETAIL_TEXTURE_2D_BINDING_SGIS = 0x8096 +gl_BGRA8_EXT :: GLenum +gl_BGRA8_EXT = 0x93A1 +gl_T2F_IUI_V3F_EXT :: GLenum +gl_T2F_IUI_V3F_EXT = 0x81B2 +gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS :: GLenum +gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS = 0x92CD +gl_VERTEX_ARRAY_LIST_IBM :: GLenum +gl_VERTEX_ARRAY_LIST_IBM = 103070 +gl_INDEX_ARRAY_STRIDE_EXT :: GLenum +gl_INDEX_ARRAY_STRIDE_EXT = 0x8086 +gl_SCALE_BY_ONE_HALF_NV :: GLenum +gl_SCALE_BY_ONE_HALF_NV = 0x8540 +gl_PROXY_TEXTURE_4D_SGIS :: GLenum +gl_PROXY_TEXTURE_4D_SGIS = 0x8135 +gl_HALF_FLOAT :: GLenum +gl_HALF_FLOAT = 0x140B +gl_FIELD_UPPER_NV :: GLenum +gl_FIELD_UPPER_NV = 0x9022 +gl_OCCLUSION_QUERY_EVENT_MASK_AMD :: GLenum +gl_OCCLUSION_QUERY_EVENT_MASK_AMD = 0x874F +gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV :: GLenum +gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_NV = 0x8E5B +gl_VERTEX_ATTRIB_ARRAY4_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY4_NV = 0x8654 +gl_CONVOLUTION_BORDER_COLOR_HP :: GLenum +gl_CONVOLUTION_BORDER_COLOR_HP = 0x8154 +gl_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT :: GLenum +gl_FRAGMENT_SHADER_DISCARDS_SAMPLES_EXT = 0x8A52 +gl_MODULATE :: GLenum +gl_MODULATE = 0x2100 +gl_NO_RESET_NOTIFICATION_KHR :: GLenum +gl_NO_RESET_NOTIFICATION_KHR = 0x8261 +gl_CURRENT_INDEX :: GLenum +gl_CURRENT_INDEX = 0x0B01 +gl_RED_MAX_CLAMP_INGR :: GLenum +gl_RED_MAX_CLAMP_INGR = 0x8564 +gl_SAMPLE_ALPHA_TO_MASK_EXT :: GLenum +gl_SAMPLE_ALPHA_TO_MASK_EXT = 0x809E +gl_DEBUG_CATEGORY_DEPRECATION_AMD :: GLenum +gl_DEBUG_CATEGORY_DEPRECATION_AMD = 0x914B +gl_EXP2 :: GLenum +gl_EXP2 = 0x0801 +gl_HISTOGRAM :: GLenum +gl_HISTOGRAM = 0x8024 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR = 0x93DB +gl_VERTEX_WEIGHT_ARRAY_POINTER_EXT :: GLenum +gl_VERTEX_WEIGHT_ARRAY_POINTER_EXT = 0x8510 +gl_READ_FRAMEBUFFER_BINDING_APPLE :: GLenum +gl_READ_FRAMEBUFFER_BINDING_APPLE = 0x8CAA +gl_COLOR_ATTACHMENT9 :: GLenum +gl_COLOR_ATTACHMENT9 = 0x8CE9 +gl_PROXY_TEXTURE_CUBE_MAP_ARB :: GLenum +gl_PROXY_TEXTURE_CUBE_MAP_ARB = 0x851B +gl_SIGNED_RGB8_NV :: GLenum +gl_SIGNED_RGB8_NV = 0x86FF +gl_TEXTURE_INTENSITY_SIZE :: GLenum +gl_TEXTURE_INTENSITY_SIZE = 0x8061 +gl_TEXTURE_MAX_CLAMP_S_SGIX :: GLenum +gl_TEXTURE_MAX_CLAMP_S_SGIX = 0x8369 +gl_PATH_TRANSPOSE_PROJECTION_MATRIX_NV :: GLenum +gl_PATH_TRANSPOSE_PROJECTION_MATRIX_NV = 0x84E4 +gl_BOUNDING_BOX_OF_BOUNDING_BOXES_NV :: GLenum +gl_BOUNDING_BOX_OF_BOUNDING_BOXES_NV = 0x909C +gl_TEXTURE_MAX_LOD_SGIS :: GLenum +gl_TEXTURE_MAX_LOD_SGIS = 0x813B +gl_LUMINANCE :: GLenum +gl_LUMINANCE = 0x1909 +gl_FOG_COORD_ARRAY_BUFFER_BINDING :: GLenum +gl_FOG_COORD_ARRAY_BUFFER_BINDING = 0x889D +gl_OFFSET_TEXTURE_2D_BIAS_NV :: GLenum +gl_OFFSET_TEXTURE_2D_BIAS_NV = 0x86E3 +gl_FEEDBACK :: GLenum +gl_FEEDBACK = 0x1C01 +gl_MAGNITUDE_BIAS_NV :: GLenum +gl_MAGNITUDE_BIAS_NV = 0x8718 +gl_POST_CONVOLUTION_ALPHA_SCALE :: GLenum +gl_POST_CONVOLUTION_ALPHA_SCALE = 0x801F +gl_PATH_TERMINAL_END_CAP_NV :: GLenum +gl_PATH_TERMINAL_END_CAP_NV = 0x9078 +gl_GLYPH_HEIGHT_BIT_NV :: GLenum +gl_GLYPH_HEIGHT_BIT_NV = 0x02 +gl_TEXTURE_STORAGE_HINT_APPLE :: GLenum +gl_TEXTURE_STORAGE_HINT_APPLE = 0x85BC +gl_MATRIX2_NV :: GLenum +gl_MATRIX2_NV = 0x8632 +gl_RGB16I :: GLenum +gl_RGB16I = 0x8D89 +gl_NUM_SHADER_BINARY_FORMATS :: GLenum +gl_NUM_SHADER_BINARY_FORMATS = 0x8DF9 +gl_MULTISAMPLE_BUFFER_BIT7_QCOM :: GLenum +gl_MULTISAMPLE_BUFFER_BIT7_QCOM = 0x80000000 +gl_SAMPLE_ALPHA_TO_ONE :: GLenum +gl_SAMPLE_ALPHA_TO_ONE = 0x809F +gl_CON_11_ATI :: GLenum +gl_CON_11_ATI = 0x894C +gl_MAP2_TEXTURE_COORD_1 :: GLenum +gl_MAP2_TEXTURE_COORD_1 = 0x0DB3 +gl_DRAW_BUFFER14_ARB :: GLenum +gl_DRAW_BUFFER14_ARB = 0x8833 +gl_SHARPEN_TEXTURE_FUNC_POINTS_SGIS :: GLenum +gl_SHARPEN_TEXTURE_FUNC_POINTS_SGIS = 0x80B0 +gl_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_LAYERED_ARB = 0x8DA7 +gl_FLOAT_RGBA_MODE_NV :: GLenum +gl_FLOAT_RGBA_MODE_NV = 0x888E +gl_VERTEX_ATTRIB_ARRAY9_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY9_NV = 0x8659 +gl_ALPHA4 :: GLenum +gl_ALPHA4 = 0x803B +gl_EVAL_VERTEX_ATTRIB9_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB9_NV = 0x86CF +gl_VARIANT_ARRAY_POINTER_EXT :: GLenum +gl_VARIANT_ARRAY_POINTER_EXT = 0x87E9 +gl_INDEX_TEST_EXT :: GLenum +gl_INDEX_TEST_EXT = 0x81B5 +gl_MAX_RENDERBUFFER_SIZE_EXT :: GLenum +gl_MAX_RENDERBUFFER_SIZE_EXT = 0x84E8 +gl_MAP1_GRID_SEGMENTS :: GLenum +gl_MAP1_GRID_SEGMENTS = 0x0DD1 +gl_DETAIL_TEXTURE_MODE_SGIS :: GLenum +gl_DETAIL_TEXTURE_MODE_SGIS = 0x809B +gl_LINEARBURN_NV :: GLenum +gl_LINEARBURN_NV = 0x92A5 +gl_SOURCE2_ALPHA :: GLenum +gl_SOURCE2_ALPHA = 0x858A +gl_COLOR_ATTACHMENT9_EXT :: GLenum +gl_COLOR_ATTACHMENT9_EXT = 0x8CE9 +gl_RENDERBUFFER_OES :: GLenum +gl_RENDERBUFFER_OES = 0x8D41 +gl_RGBA8UI :: GLenum +gl_RGBA8UI = 0x8D7C +gl_MIPMAP :: GLenum +gl_MIPMAP = 0x8293 +gl_SMOOTH_LINE_WIDTH_RANGE :: GLenum +gl_SMOOTH_LINE_WIDTH_RANGE = 0x0B22 +gl_COMBINER7_NV :: GLenum +gl_COMBINER7_NV = 0x8557 +gl_VIEW_CLASS_64_BITS :: GLenum +gl_VIEW_CLASS_64_BITS = 0x82C6 +gl_SAMPLE_MASK_VALUE_SGIS :: GLenum +gl_SAMPLE_MASK_VALUE_SGIS = 0x80AA +gl_MAX_SHADER_STORAGE_BUFFER_BINDINGS :: GLenum +gl_MAX_SHADER_STORAGE_BUFFER_BINDINGS = 0x90DD +gl_ALPHA32UI_EXT :: GLenum +gl_ALPHA32UI_EXT = 0x8D72 +gl_NONE :: GLenum +gl_NONE = 0 +gl_MATRIX25_ARB :: GLenum +gl_MATRIX25_ARB = 0x88D9 +gl_DUAL_LUMINANCE_ALPHA4_SGIS :: GLenum +gl_DUAL_LUMINANCE_ALPHA4_SGIS = 0x811C +gl_PATCH_VERTICES :: GLenum +gl_PATCH_VERTICES = 0x8E72 +gl_COLOR_MATERIAL_PARAMETER :: GLenum +gl_COLOR_MATERIAL_PARAMETER = 0x0B56 +gl_NUM_PROGRAM_BINARY_FORMATS :: GLenum +gl_NUM_PROGRAM_BINARY_FORMATS = 0x87FE +gl_PACK_ROW_LENGTH :: GLenum +gl_PACK_ROW_LENGTH = 0x0D02 +gl_RENDERBUFFER_BINDING_EXT :: GLenum +gl_RENDERBUFFER_BINDING_EXT = 0x8CA7 +gl_FORMAT_SUBSAMPLE_24_24_OML :: GLenum +gl_FORMAT_SUBSAMPLE_24_24_OML = 0x8982 +gl_RELATIVE_ROUNDED_RECT4_NV :: GLenum +gl_RELATIVE_ROUNDED_RECT4_NV = 0xED +gl_TEXTURE3 :: GLenum +gl_TEXTURE3 = 0x84C3 +gl_DEPTH_COMPONENT16_SGIX :: GLenum +gl_DEPTH_COMPONENT16_SGIX = 0x81A5 +gl_SAMPLER_2D_SHADOW_EXT :: GLenum +gl_SAMPLER_2D_SHADOW_EXT = 0x8B62 +gl_MIN_MAP_BUFFER_ALIGNMENT :: GLenum +gl_MIN_MAP_BUFFER_ALIGNMENT = 0x90BC +gl_PROXY_TEXTURE_2D_ARRAY_EXT :: GLenum +gl_PROXY_TEXTURE_2D_ARRAY_EXT = 0x8C1B +gl_WEIGHT_ARRAY_TYPE_ARB :: GLenum +gl_WEIGHT_ARRAY_TYPE_ARB = 0x86A9 +gl_LOW_INT :: GLenum +gl_LOW_INT = 0x8DF3 +gl_DRAW_BUFFER11_ATI :: GLenum +gl_DRAW_BUFFER11_ATI = 0x8830 +gl_MAX_ELEMENTS_VERTICES_EXT :: GLenum +gl_MAX_ELEMENTS_VERTICES_EXT = 0x80E8 +gl_COMPRESSED_RED_RGTC1_EXT :: GLenum +gl_COMPRESSED_RED_RGTC1_EXT = 0x8DBB +gl_RGBA :: GLenum +gl_RGBA = 0x1908 +gl_DRAW_BUFFER0_ARB :: GLenum +gl_DRAW_BUFFER0_ARB = 0x8825 +gl_TEXTURE_RED_TYPE :: GLenum +gl_TEXTURE_RED_TYPE = 0x8C10 +gl_FENCE_APPLE :: GLenum +gl_FENCE_APPLE = 0x8A0B +gl_MAX_CONVOLUTION_WIDTH_EXT :: GLenum +gl_MAX_CONVOLUTION_WIDTH_EXT = 0x801A +gl_UNSIGNED_INVERT_NV :: GLenum +gl_UNSIGNED_INVERT_NV = 0x8537 +gl_LIGHT6 :: GLenum +gl_LIGHT6 = 0x4006 +gl_STREAM_COPY :: GLenum +gl_STREAM_COPY = 0x88E2 +gl_INSTRUMENT_BUFFER_POINTER_SGIX :: GLenum +gl_INSTRUMENT_BUFFER_POINTER_SGIX = 0x8180 +gl_MODELVIEW :: GLenum +gl_MODELVIEW = 0x1700 +gl_RGB32F :: GLenum +gl_RGB32F = 0x8815 +gl_MAP_COLOR :: GLenum +gl_MAP_COLOR = 0x0D10 +gl_COLOR_TABLE_INTENSITY_SIZE_SGI :: GLenum +gl_COLOR_TABLE_INTENSITY_SIZE_SGI = 0x80DF +gl_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV :: GLenum +gl_MAX_DEEP_3D_TEXTURE_WIDTH_HEIGHT_NV = 0x90D0 +gl_LAYER_PROVOKING_VERTEX_EXT :: GLenum +gl_LAYER_PROVOKING_VERTEX_EXT = 0x825E +gl_COMPRESSED_RGBA_ASTC_6x5x5_OES :: GLenum +gl_COMPRESSED_RGBA_ASTC_6x5x5_OES = 0x93C7 +gl_FOG_BIT :: GLenum +gl_FOG_BIT = 0x00000080 +gl_NATIVE_GRAPHICS_HANDLE_PGI :: GLenum +gl_NATIVE_GRAPHICS_HANDLE_PGI = 0x1A202 +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_EXT = 0x8C8B +gl_MAX_COMPUTE_SHARED_MEMORY_SIZE :: GLenum +gl_MAX_COMPUTE_SHARED_MEMORY_SIZE = 0x8262 +gl_STENCIL_INDEX1_EXT :: GLenum +gl_STENCIL_INDEX1_EXT = 0x8D46 +gl_COLOR_ATTACHMENT2_NV :: GLenum +gl_COLOR_ATTACHMENT2_NV = 0x8CE2 +gl_DRAW_BUFFER5_ARB :: GLenum +gl_DRAW_BUFFER5_ARB = 0x882A +gl_TEXTURE_OBJECT_VALID_QCOM :: GLenum +gl_TEXTURE_OBJECT_VALID_QCOM = 0x8BDB +gl_PHONG_HINT_WIN :: GLenum +gl_PHONG_HINT_WIN = 0x80EB +gl_MAP1_VERTEX_ATTRIB0_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB0_4_NV = 0x8660 +gl_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX :: GLenum +gl_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX = 0x9047 +gl_COLOR_TABLE_WIDTH :: GLenum +gl_COLOR_TABLE_WIDTH = 0x80D9 +gl_INT_IMAGE_1D_ARRAY :: GLenum +gl_INT_IMAGE_1D_ARRAY = 0x905D +gl_BUFFER_MAPPED :: GLenum +gl_BUFFER_MAPPED = 0x88BC +gl_TEXTURE_SWIZZLE_R :: GLenum +gl_TEXTURE_SWIZZLE_R = 0x8E42 +gl_COLOR_ATTACHMENT9_NV :: GLenum +gl_COLOR_ATTACHMENT9_NV = 0x8CE9 +gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER :: GLenum +gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_CONTROL_SHADER = 0x84F0 +gl_LUMINANCE16_ALPHA16 :: GLenum +gl_LUMINANCE16_ALPHA16 = 0x8048 +gl_PERFQUERY_GLOBAL_CONTEXT_INTEL :: GLenum +gl_PERFQUERY_GLOBAL_CONTEXT_INTEL = 0x00000001 +gl_POINT_FADE_THRESHOLD_SIZE_EXT :: GLenum +gl_POINT_FADE_THRESHOLD_SIZE_EXT = 0x8128 +gl_BLEND_EQUATION_OES :: GLenum +gl_BLEND_EQUATION_OES = 0x8009 +gl_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES :: GLenum +gl_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898E +gl_TEXTURE_BINDING_2D_ARRAY_EXT :: GLenum +gl_TEXTURE_BINDING_2D_ARRAY_EXT = 0x8C1D +gl_CON_7_ATI :: GLenum +gl_CON_7_ATI = 0x8948 +gl_DUAL_LUMINANCE16_SGIS :: GLenum +gl_DUAL_LUMINANCE16_SGIS = 0x8117 +gl_RASTER_POSITION_UNCLIPPED_IBM :: GLenum +gl_RASTER_POSITION_UNCLIPPED_IBM = 0x19262 +gl_ALLOW_DRAW_FRG_HINT_PGI :: GLenum +gl_ALLOW_DRAW_FRG_HINT_PGI = 0x1A210 +gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT :: GLenum +gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS_EXT = 0x8F39 +gl_TEXTURE_COORD_ARRAY :: GLenum +gl_TEXTURE_COORD_ARRAY = 0x8078 +gl_MAX_DEBUG_LOGGED_MESSAGES_KHR :: GLenum +gl_MAX_DEBUG_LOGGED_MESSAGES_KHR = 0x9144 +gl_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_ARRAY_BUFFER_BINDING_ARB = 0x8894 +gl_PIXEL_TEXTURE_SGIS :: GLenum +gl_PIXEL_TEXTURE_SGIS = 0x8353 +gl_STENCIL_INDEX8 :: GLenum +gl_STENCIL_INDEX8 = 0x8D48 +gl_IMAGE_CLASS_10_10_10_2 :: GLenum +gl_IMAGE_CLASS_10_10_10_2 = 0x82C3 +gl_DRAW_INDIRECT_LENGTH_NV :: GLenum +gl_DRAW_INDIRECT_LENGTH_NV = 0x8F42 +gl_DEBUG_CALLBACK_FUNCTION_ARB :: GLenum +gl_DEBUG_CALLBACK_FUNCTION_ARB = 0x8244 +gl_INT_SAMPLER_2D_ARRAY :: GLenum +gl_INT_SAMPLER_2D_ARRAY = 0x8DCF +gl_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB :: GLenum +gl_MAX_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B3 +gl_GENERIC_ATTRIB_NV :: GLenum +gl_GENERIC_ATTRIB_NV = 0x8C7D +gl_TEXTURE_RED_TYPE_ARB :: GLenum +gl_TEXTURE_RED_TYPE_ARB = 0x8C10 +gl_MAX_VERTEX_UNITS_ARB :: GLenum +gl_MAX_VERTEX_UNITS_ARB = 0x86A4 +gl_DEPTH_BIAS :: GLenum +gl_DEPTH_BIAS = 0x0D1F +gl_SRGB :: GLenum +gl_SRGB = 0x8C40 +gl_TEXTURE_COORD_ARRAY_TYPE :: GLenum +gl_TEXTURE_COORD_ARRAY_TYPE = 0x8089 +gl_TRANSFORM_FEEDBACK_BUFFER_START_EXT :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_START_EXT = 0x8C84 +gl_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV :: GLenum +gl_MAX_PROGRAM_SUBROUTINE_PARAMETERS_NV = 0x8F44 +gl_CURRENT_TIME_NV :: GLenum +gl_CURRENT_TIME_NV = 0x8E28 +gl_TEXTURE_DEPTH_SIZE :: GLenum +gl_TEXTURE_DEPTH_SIZE = 0x884A +gl_INDEX_ARRAY_LIST_STRIDE_IBM :: GLenum +gl_INDEX_ARRAY_LIST_STRIDE_IBM = 103083 +gl_CLIP_PLANE1_IMG :: GLenum +gl_CLIP_PLANE1_IMG = 0x3001 +gl_CULL_VERTEX_EYE_POSITION_EXT :: GLenum +gl_CULL_VERTEX_EYE_POSITION_EXT = 0x81AB +gl_COPY_READ_BUFFER_NV :: GLenum +gl_COPY_READ_BUFFER_NV = 0x8F36 +gl_CONTEXT_CORE_PROFILE_BIT :: GLenum +gl_CONTEXT_CORE_PROFILE_BIT = 0x00000001 +gl_ARC_TO_NV :: GLenum +gl_ARC_TO_NV = 0xFE +gl_PACK_COMPRESSED_BLOCK_SIZE :: GLenum +gl_PACK_COMPRESSED_BLOCK_SIZE = 0x912E +gl_TRACE_NAME_MESA :: GLenum +gl_TRACE_NAME_MESA = 0x8756 +gl_TEXTURE_CROP_RECT_OES :: GLenum +gl_TEXTURE_CROP_RECT_OES = 0x8B9D +gl_MAP2_VERTEX_ATTRIB15_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB15_4_NV = 0x867F +gl_DRAW_INDIRECT_UNIFIED_NV :: GLenum +gl_DRAW_INDIRECT_UNIFIED_NV = 0x8F40 +gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS :: GLenum +gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS = 0x90CC +gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS :: GLenum +gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS = 0x8B4D +gl_CULL_FACE_MODE :: GLenum +gl_CULL_FACE_MODE = 0x0B45 +gl_LUMINANCE_ALPHA_INTEGER_EXT :: GLenum +gl_LUMINANCE_ALPHA_INTEGER_EXT = 0x8D9D +gl_SURFACE_MAPPED_NV :: GLenum +gl_SURFACE_MAPPED_NV = 0x8700 +gl_FOG_COORD_ARRAY_LENGTH_NV :: GLenum +gl_FOG_COORD_ARRAY_LENGTH_NV = 0x8F32 +gl_R :: GLenum +gl_R = 0x2002 +gl_NUM_VIDEO_CAPTURE_STREAMS_NV :: GLenum +gl_NUM_VIDEO_CAPTURE_STREAMS_NV = 0x9024 +gl_VERTEX_PROGRAM_POINT_SIZE_NV :: GLenum +gl_VERTEX_PROGRAM_POINT_SIZE_NV = 0x8642 +gl_CONSTANT_NV :: GLenum +gl_CONSTANT_NV = 0x8576 +gl_RGB10_A2 :: GLenum +gl_RGB10_A2 = 0x8059 +gl_INTENSITY16_EXT :: GLenum +gl_INTENSITY16_EXT = 0x804D +gl_TEXTURE28 :: GLenum +gl_TEXTURE28 = 0x84DC +gl_COMPRESSED_RGBA_ASTC_4x4_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_4x4_KHR = 0x93B0 +gl_SRGB_READ :: GLenum +gl_SRGB_READ = 0x8297 +gl_LUMINANCE16_ALPHA16_SNORM :: GLenum +gl_LUMINANCE16_ALPHA16_SNORM = 0x901A +gl_UNSIGNED_INT_IMAGE_1D_ARRAY :: GLenum +gl_UNSIGNED_INT_IMAGE_1D_ARRAY = 0x9068 +gl_ELEMENT_ARRAY_TYPE_ATI :: GLenum +gl_ELEMENT_ARRAY_TYPE_ATI = 0x8769 +gl_PATCH_DEFAULT_OUTER_LEVEL :: GLenum +gl_PATCH_DEFAULT_OUTER_LEVEL = 0x8E74 +gl_LINE_STRIP_ADJACENCY_ARB :: GLenum +gl_LINE_STRIP_ADJACENCY_ARB = 0x000B +gl_POLYGON_OFFSET_POINT :: GLenum +gl_POLYGON_OFFSET_POINT = 0x2A01 +gl_UNSIGNED_SHORT_8_8_APPLE :: GLenum +gl_UNSIGNED_SHORT_8_8_APPLE = 0x85BA +gl_DYNAMIC_ATI :: GLenum +gl_DYNAMIC_ATI = 0x8761 +gl_UNSIGNED_INT16_NV :: GLenum +gl_UNSIGNED_INT16_NV = 0x8FF0 +gl_TEXTURE_BINDING_BUFFER_EXT :: GLenum +gl_TEXTURE_BINDING_BUFFER_EXT = 0x8C2C +gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB :: GLenum +gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_ARB = 0x900A +gl_MAP2_VERTEX_ATTRIB14_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB14_4_NV = 0x867E +gl_COMPRESSED_RGB :: GLenum +gl_COMPRESSED_RGB = 0x84ED +gl_VERTEX_ATTRIB_ARRAY0_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY0_NV = 0x8650 +gl_MIN :: GLenum +gl_MIN = 0x8007 +gl_COLOR_SUM :: GLenum +gl_COLOR_SUM = 0x8458 +gl_ATC_RGBA_INTERPOLATED_ALPHA_AMD :: GLenum +gl_ATC_RGBA_INTERPOLATED_ALPHA_AMD = 0x87EE +gl_RECIP_ADD_SIGNED_ALPHA_IMG :: GLenum +gl_RECIP_ADD_SIGNED_ALPHA_IMG = 0x8C05 +gl_FONT_MAX_ADVANCE_WIDTH_BIT_NV :: GLenum +gl_FONT_MAX_ADVANCE_WIDTH_BIT_NV = 0x01000000 +gl_SPRITE_AXIAL_SGIX :: GLenum +gl_SPRITE_AXIAL_SGIX = 0x814C +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE_OES = 0x8CD3 +gl_TEXTURE_ENV_BIAS_SGIX :: GLenum +gl_TEXTURE_ENV_BIAS_SGIX = 0x80BE +gl_PROGRAM_FORMAT_ASCII_ARB :: GLenum +gl_PROGRAM_FORMAT_ASCII_ARB = 0x8875 +gl_OUTPUT_COLOR1_EXT :: GLenum +gl_OUTPUT_COLOR1_EXT = 0x879C +gl_SELECTION_BUFFER_SIZE :: GLenum +gl_SELECTION_BUFFER_SIZE = 0x0DF4 +gl_VERTEX_ATTRIB_MAP2_ORDER_APPLE :: GLenum +gl_VERTEX_ATTRIB_MAP2_ORDER_APPLE = 0x8A08 +gl_INTENSITY_FLOAT16_ATI :: GLenum +gl_INTENSITY_FLOAT16_ATI = 0x881D +gl_TEXTURE30_ARB :: GLenum +gl_TEXTURE30_ARB = 0x84DE +gl_TEXTURE_1D_STACK_MESAX :: GLenum +gl_TEXTURE_1D_STACK_MESAX = 0x8759 +gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = 0x910A +gl_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM :: GLenum +gl_SECONDARY_COLOR_ARRAY_LIST_STRIDE_IBM = 103087 +gl_SIGNED_HILO_NV :: GLenum +gl_SIGNED_HILO_NV = 0x86F9 +gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT :: GLenum +gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT = 0x00000004 +gl_ACTIVE_ATTRIBUTE_MAX_LENGTH :: GLenum +gl_ACTIVE_ATTRIBUTE_MAX_LENGTH = 0x8B8A +gl_IMAGE_2D_RECT_EXT :: GLenum +gl_IMAGE_2D_RECT_EXT = 0x904F +gl_TESS_GEN_MODE :: GLenum +gl_TESS_GEN_MODE = 0x8E76 +gl_TEXTURE_MIN_FILTER :: GLenum +gl_TEXTURE_MIN_FILTER = 0x2801 +gl_FLOAT_VEC4 :: GLenum +gl_FLOAT_VEC4 = 0x8B52 +gl_LIGHT2 :: GLenum +gl_LIGHT2 = 0x4002 +gl_MODELVIEW24_ARB :: GLenum +gl_MODELVIEW24_ARB = 0x8738 +gl_TESS_EVALUATION_SHADER :: GLenum +gl_TESS_EVALUATION_SHADER = 0x8E87 +gl_PROXY_COLOR_TABLE_SGI :: GLenum +gl_PROXY_COLOR_TABLE_SGI = 0x80D3 +gl_INDEX_ARRAY_EXT :: GLenum +gl_INDEX_ARRAY_EXT = 0x8077 +gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING_ARB = 0x889F +gl_FRAGMENT_INPUT_NV :: GLenum +gl_FRAGMENT_INPUT_NV = 0x936D +gl_CON_13_ATI :: GLenum +gl_CON_13_ATI = 0x894E +gl_IMAGE_ROTATE_ORIGIN_Y_HP :: GLenum +gl_IMAGE_ROTATE_ORIGIN_Y_HP = 0x815B +gl_VERTEX_ARRAY_COUNT_EXT :: GLenum +gl_VERTEX_ARRAY_COUNT_EXT = 0x807D +gl_STENCIL_INDEX1_OES :: GLenum +gl_STENCIL_INDEX1_OES = 0x8D46 +gl_BUFFER_DATA_SIZE :: GLenum +gl_BUFFER_DATA_SIZE = 0x9303 +gl_MAX_NAME_STACK_DEPTH :: GLenum +gl_MAX_NAME_STACK_DEPTH = 0x0D37 +gl_SAMPLES_PASSED_ARB :: GLenum +gl_SAMPLES_PASSED_ARB = 0x8914 +gl_TEXTURE_PRE_SPECULAR_HP :: GLenum +gl_TEXTURE_PRE_SPECULAR_HP = 0x8169 +gl_RESCALE_NORMAL_EXT :: GLenum +gl_RESCALE_NORMAL_EXT = 0x803A +gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY :: GLenum +gl_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = 0x906A +gl_TRANSLATE_2D_NV :: GLenum +gl_TRANSLATE_2D_NV = 0x9090 +gl_QUAD_INTENSITY8_SGIS :: GLenum +gl_QUAD_INTENSITY8_SGIS = 0x8123 +gl_LOCATION_INDEX :: GLenum +gl_LOCATION_INDEX = 0x930F +gl_MODELVIEW9_ARB :: GLenum +gl_MODELVIEW9_ARB = 0x8729 +gl_CONTEXT_RELEASE_BEHAVIOR_KHR :: GLenum +gl_CONTEXT_RELEASE_BEHAVIOR_KHR = 0x82FB +gl_EDGE_FLAG_ARRAY_BUFFER_BINDING :: GLenum +gl_EDGE_FLAG_ARRAY_BUFFER_BINDING = 0x889B +gl_DEBUG_TYPE_PERFORMANCE_KHR :: GLenum +gl_DEBUG_TYPE_PERFORMANCE_KHR = 0x8250 +gl_POINT_DISTANCE_ATTENUATION :: GLenum +gl_POINT_DISTANCE_ATTENUATION = 0x8129 +gl_PIXEL_TILE_GRID_HEIGHT_SGIX :: GLenum +gl_PIXEL_TILE_GRID_HEIGHT_SGIX = 0x8143 +gl_COLOR_ATTACHMENT3 :: GLenum +gl_COLOR_ATTACHMENT3 = 0x8CE3 +gl_COUNT_UP_NV :: GLenum +gl_COUNT_UP_NV = 0x9088 +gl_STENCIL_BACK_VALUE_MASK :: GLenum +gl_STENCIL_BACK_VALUE_MASK = 0x8CA4 +gl_PERFQUERY_DONOT_FLUSH_INTEL :: GLenum +gl_PERFQUERY_DONOT_FLUSH_INTEL = 0x83F9 +gl_VARIABLE_F_NV :: GLenum +gl_VARIABLE_F_NV = 0x8528 +gl_STENCIL_BACK_PASS_DEPTH_FAIL :: GLenum +gl_STENCIL_BACK_PASS_DEPTH_FAIL = 0x8802 +gl_IMAGE_CUBIC_WEIGHT_HP :: GLenum +gl_IMAGE_CUBIC_WEIGHT_HP = 0x815E +gl_STENCIL :: GLenum +gl_STENCIL = 0x1802 +gl_DRAW_BUFFER6_ARB :: GLenum +gl_DRAW_BUFFER6_ARB = 0x882B +gl_MAX_COMBINED_IMAGE_UNIFORMS :: GLenum +gl_MAX_COMBINED_IMAGE_UNIFORMS = 0x90CF +gl_PROGRAM_STRING_NV :: GLenum +gl_PROGRAM_STRING_NV = 0x8628 +gl_STREAM_DRAW :: GLenum +gl_STREAM_DRAW = 0x88E0 +gl_BGR_INTEGER_EXT :: GLenum +gl_BGR_INTEGER_EXT = 0x8D9A +gl_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES :: GLenum +gl_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES = 0x8B9E +gl_LAYER_PROVOKING_VERTEX :: GLenum +gl_LAYER_PROVOKING_VERTEX = 0x825E +gl_TEXTURE_ALPHA_SIZE_EXT :: GLenum +gl_TEXTURE_ALPHA_SIZE_EXT = 0x805F +gl_QUERY_DEPTH_PASS_EVENT_BIT_AMD :: GLenum +gl_QUERY_DEPTH_PASS_EVENT_BIT_AMD = 0x00000001 +gl_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX :: GLenum +gl_TEXTURE_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8174 +gl_VIEW_CLASS_48_BITS :: GLenum +gl_VIEW_CLASS_48_BITS = 0x82C7 +gl_DRAW_BUFFER15_NV :: GLenum +gl_DRAW_BUFFER15_NV = 0x8834 +gl_MAX_LABEL_LENGTH_KHR :: GLenum +gl_MAX_LABEL_LENGTH_KHR = 0x82E8 +gl_DEBUG_TYPE_PERFORMANCE :: GLenum +gl_DEBUG_TYPE_PERFORMANCE = 0x8250 +gl_DEPENDENT_RGB_TEXTURE_3D_NV :: GLenum +gl_DEPENDENT_RGB_TEXTURE_3D_NV = 0x8859 +gl_MAX_GEOMETRY_ATOMIC_COUNTERS :: GLenum +gl_MAX_GEOMETRY_ATOMIC_COUNTERS = 0x92D5 +gl_DRAW_BUFFER10_ARB :: GLenum +gl_DRAW_BUFFER10_ARB = 0x882F +gl_FONT_UNDERLINE_THICKNESS_BIT_NV :: GLenum +gl_FONT_UNDERLINE_THICKNESS_BIT_NV = 0x08000000 +gl_DRAW_BUFFER7 :: GLenum +gl_DRAW_BUFFER7 = 0x882C +gl_TEXTURE_GREEN_TYPE_ARB :: GLenum +gl_TEXTURE_GREEN_TYPE_ARB = 0x8C11 +gl_TEXTURE_MIN_LOD_SGIS :: GLenum +gl_TEXTURE_MIN_LOD_SGIS = 0x813A +gl_UNSIGNED_INT_SAMPLER_BUFFER_EXT :: GLenum +gl_UNSIGNED_INT_SAMPLER_BUFFER_EXT = 0x8DD8 +gl_ELEMENT_ARRAY_BARRIER_BIT_EXT :: GLenum +gl_ELEMENT_ARRAY_BARRIER_BIT_EXT = 0x00000002 +gl_SAMPLE_COVERAGE_VALUE :: GLenum +gl_SAMPLE_COVERAGE_VALUE = 0x80AA +gl_VERTEX_ATTRIB_RELATIVE_OFFSET :: GLenum +gl_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D5 +gl_COLOR_TABLE_RED_SIZE :: GLenum +gl_COLOR_TABLE_RED_SIZE = 0x80DA +gl_TRANSFORM_FEEDBACK_BUFFER_START_NV :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_START_NV = 0x8C84 +gl_NAME_STACK_DEPTH :: GLenum +gl_NAME_STACK_DEPTH = 0x0D70 +gl_UNSIGNED_INT_5_9_9_9_REV :: GLenum +gl_UNSIGNED_INT_5_9_9_9_REV = 0x8C3E +gl_FUNC_SUBTRACT_EXT :: GLenum +gl_FUNC_SUBTRACT_EXT = 0x800A +gl_STENCIL_INDEX4_EXT :: GLenum +gl_STENCIL_INDEX4_EXT = 0x8D47 +gl_TEXTURE_COMPRESSION_HINT :: GLenum +gl_TEXTURE_COMPRESSION_HINT = 0x84EF +gl_DEPTH_CLAMP :: GLenum +gl_DEPTH_CLAMP = 0x864F +gl_SAMPLE_COVERAGE_INVERT :: GLenum +gl_SAMPLE_COVERAGE_INVERT = 0x80AB +gl_DRAW_BUFFER0_EXT :: GLenum +gl_DRAW_BUFFER0_EXT = 0x8825 +gl_DRAW_BUFFER4 :: GLenum +gl_DRAW_BUFFER4 = 0x8829 +gl_ALPHA_FLOAT16_ATI :: GLenum +gl_ALPHA_FLOAT16_ATI = 0x881C +gl_AFFINE_2D_NV :: GLenum +gl_AFFINE_2D_NV = 0x9092 +gl_MAX_TRACK_MATRICES_NV :: GLenum +gl_MAX_TRACK_MATRICES_NV = 0x862F +gl_BINORMAL_ARRAY_STRIDE_EXT :: GLenum +gl_BINORMAL_ARRAY_STRIDE_EXT = 0x8441 +gl_UNSIGNED_SHORT_1_5_5_5_REV :: GLenum +gl_UNSIGNED_SHORT_1_5_5_5_REV = 0x8366 +gl_ROUNDED_RECT4_NV :: GLenum +gl_ROUNDED_RECT4_NV = 0xEC +gl_COMMAND_BARRIER_BIT_EXT :: GLenum +gl_COMMAND_BARRIER_BIT_EXT = 0x00000040 +gl_TEXTURE_ENV_COLOR :: GLenum +gl_TEXTURE_ENV_COLOR = 0x2201 +gl_READ_WRITE_ARB :: GLenum +gl_READ_WRITE_ARB = 0x88BA +gl_RGBA8_EXT :: GLenum +gl_RGBA8_EXT = 0x8058 +gl_EVAL_VERTEX_ATTRIB10_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB10_NV = 0x86D0 +gl_POST_CONVOLUTION_RED_BIAS :: GLenum +gl_POST_CONVOLUTION_RED_BIAS = 0x8020 +gl_INT16_VEC4_NV :: GLenum +gl_INT16_VEC4_NV = 0x8FE7 +gl_COLOR_SUM_ARB :: GLenum +gl_COLOR_SUM_ARB = 0x8458 +gl_OUTPUT_TEXTURE_COORD5_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD5_EXT = 0x87A2 +gl_COMPRESSED_RGBA_ASTC_12x10_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_12x10_KHR = 0x93BC +gl_MAX_ELEMENTS_INDICES :: GLenum +gl_MAX_ELEMENTS_INDICES = 0x80E9 +gl_REFERENCED_BY_FRAGMENT_SHADER :: GLenum +gl_REFERENCED_BY_FRAGMENT_SHADER = 0x930A +gl_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB :: GLenum +gl_MAX_COMPUTE_VARIABLE_GROUP_INVOCATIONS_ARB = 0x9344 +gl_WEIGHT_ARRAY_ARB :: GLenum +gl_WEIGHT_ARRAY_ARB = 0x86AD +gl_TIME_ELAPSED_EXT :: GLenum +gl_TIME_ELAPSED_EXT = 0x88BF +gl_BACK_SECONDARY_COLOR_NV :: GLenum +gl_BACK_SECONDARY_COLOR_NV = 0x8C78 +gl_COMPARE_REF_TO_TEXTURE_EXT :: GLenum +gl_COMPARE_REF_TO_TEXTURE_EXT = 0x884E +gl_IS_PER_PATCH_EXT :: GLenum +gl_IS_PER_PATCH_EXT = 0x92E7 +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_APPLE = 0x8D56 +gl_TEXTURE_LUMINANCE_SIZE_EXT :: GLenum +gl_TEXTURE_LUMINANCE_SIZE_EXT = 0x8060 +gl_COVERAGE_BUFFERS_NV :: GLenum +gl_COVERAGE_BUFFERS_NV = 0x8ED3 +gl_MATRIX5_ARB :: GLenum +gl_MATRIX5_ARB = 0x88C5 +gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT :: GLenum +gl_COMPRESSED_SRGB_ALPHA_PVRTC_2BPPV1_EXT = 0x8A56 +gl_COMPRESSED_RGBA_ASTC_5x5x4_OES :: GLenum +gl_COMPRESSED_RGBA_ASTC_5x5x4_OES = 0x93C5 +gl_CONVOLUTION_FILTER_BIAS :: GLenum +gl_CONVOLUTION_FILTER_BIAS = 0x8015 +gl_TRACE_PRIMITIVES_BIT_MESA :: GLenum +gl_TRACE_PRIMITIVES_BIT_MESA = 0x0002 +gl_POINT_SPRITE :: GLenum +gl_POINT_SPRITE = 0x8861 +gl_POLYGON_STIPPLE_BIT :: GLenum +gl_POLYGON_STIPPLE_BIT = 0x00000010 +gl_DEBUG_SEVERITY_HIGH :: GLenum +gl_DEBUG_SEVERITY_HIGH = 0x9146 +gl_RENDERBUFFER_STENCIL_SIZE_EXT :: GLenum +gl_RENDERBUFFER_STENCIL_SIZE_EXT = 0x8D55 +gl_RED :: GLenum +gl_RED = 0x1903 +gl_DRAW_BUFFER12_NV :: GLenum +gl_DRAW_BUFFER12_NV = 0x8831 +gl_COMPRESSED_RGBA_ASTC_10x10_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_10x10_KHR = 0x93BB +gl_ACTIVE_TEXTURE :: GLenum +gl_ACTIVE_TEXTURE = 0x84E0 +gl_Q :: GLenum +gl_Q = 0x2003 +gl_STRICT_LIGHTING_HINT_PGI :: GLenum +gl_STRICT_LIGHTING_HINT_PGI = 0x1A217 +gl_INT8_VEC2_NV :: GLenum +gl_INT8_VEC2_NV = 0x8FE1 +gl_MAP2_VERTEX_ATTRIB0_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB0_4_NV = 0x8670 +gl_SHADER_SOURCE_LENGTH :: GLenum +gl_SHADER_SOURCE_LENGTH = 0x8B88 +gl_FLOAT_MAT4 :: GLenum +gl_FLOAT_MAT4 = 0x8B5C +gl_COLOR_MATRIX_SGI :: GLenum +gl_COLOR_MATRIX_SGI = 0x80B1 +gl_SAMPLER_2D_ARRAY_EXT :: GLenum +gl_SAMPLER_2D_ARRAY_EXT = 0x8DC1 +gl_MODULATE_SUBTRACT_ATI :: GLenum +gl_MODULATE_SUBTRACT_ATI = 0x8746 +gl_TRIANGLES_ADJACENCY_ARB :: GLenum +gl_TRIANGLES_ADJACENCY_ARB = 0x000C +gl_PROGRAM_TARGET_NV :: GLenum +gl_PROGRAM_TARGET_NV = 0x8646 +gl_GEOMETRY_SHADER_ARB :: GLenum +gl_GEOMETRY_SHADER_ARB = 0x8DD9 +gl_TEXTURE_BASE_LEVEL_SGIS :: GLenum +gl_TEXTURE_BASE_LEVEL_SGIS = 0x813C +gl_1PASS_SGIS :: GLenum +gl_1PASS_SGIS = 0x80A1 +gl_TEXTURE_HEIGHT_QCOM :: GLenum +gl_TEXTURE_HEIGHT_QCOM = 0x8BD3 +gl_LUMINANCE12_ALPHA4_EXT :: GLenum +gl_LUMINANCE12_ALPHA4_EXT = 0x8046 +gl_PIXEL_TILE_HEIGHT_SGIX :: GLenum +gl_PIXEL_TILE_HEIGHT_SGIX = 0x8141 +gl_UNSIGNED_INT_S8_S8_8_8_NV :: GLenum +gl_UNSIGNED_INT_S8_S8_8_8_NV = 0x86DA +gl_SOURCE0_RGB :: GLenum +gl_SOURCE0_RGB = 0x8580 +gl_DRAW_BUFFER6_EXT :: GLenum +gl_DRAW_BUFFER6_EXT = 0x882B +gl_PATH_FILL_BOUNDING_BOX_NV :: GLenum +gl_PATH_FILL_BOUNDING_BOX_NV = 0x90A1 +gl_RENDER_MODE :: GLenum +gl_RENDER_MODE = 0x0C40 +gl_X_EXT :: GLenum +gl_X_EXT = 0x87D5 +gl_CON_14_ATI :: GLenum +gl_CON_14_ATI = 0x894F +gl_TRIANGLE_STRIP_ADJACENCY :: GLenum +gl_TRIANGLE_STRIP_ADJACENCY = 0x000D +gl_ROUNDED_RECT_NV :: GLenum +gl_ROUNDED_RECT_NV = 0xE8 +gl_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB :: GLenum +gl_OBJECT_ACTIVE_UNIFORM_MAX_LENGTH_ARB = 0x8B87 +gl_DSDT_MAG_INTENSITY_NV :: GLenum +gl_DSDT_MAG_INTENSITY_NV = 0x86DC +gl_MODELVIEW13_ARB :: GLenum +gl_MODELVIEW13_ARB = 0x872D +gl_MAX_COMBINED_CLIP_AND_CULL_DISTANCES :: GLenum +gl_MAX_COMBINED_CLIP_AND_CULL_DISTANCES = 0x82FA +gl_CLIP_ORIGIN :: GLenum +gl_CLIP_ORIGIN = 0x935C +gl_PATH_CLIENT_LENGTH_NV :: GLenum +gl_PATH_CLIENT_LENGTH_NV = 0x907F +gl_SAMPLE_ALPHA_TO_ONE_ARB :: GLenum +gl_SAMPLE_ALPHA_TO_ONE_ARB = 0x809F +gl_RENDERBUFFER_INTERNAL_FORMAT_OES :: GLenum +gl_RENDERBUFFER_INTERNAL_FORMAT_OES = 0x8D44 +gl_POINT_SPRITE_ARB :: GLenum +gl_POINT_SPRITE_ARB = 0x8861 +gl_FLOAT_MAT3_ARB :: GLenum +gl_FLOAT_MAT3_ARB = 0x8B5B +gl_IMAGE_CLASS_4_X_8 :: GLenum +gl_IMAGE_CLASS_4_X_8 = 0x82BF +gl_PIXEL_SUBSAMPLE_4242_SGIX :: GLenum +gl_PIXEL_SUBSAMPLE_4242_SGIX = 0x85A4 +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT :: GLenum +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT = 0x8C4D +gl_ROUNDED_RECT8_NV :: GLenum +gl_ROUNDED_RECT8_NV = 0xEE +gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING :: GLenum +gl_FOG_COORDINATE_ARRAY_BUFFER_BINDING = 0x889D +gl_DST_NV :: GLenum +gl_DST_NV = 0x9287 +gl_MAX_TRANSFORM_FEEDBACK_BUFFERS :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_BUFFERS = 0x8E70 +gl_FUNC_ADD_OES :: GLenum +gl_FUNC_ADD_OES = 0x8006 +gl_VERTEX_STREAM7_ATI :: GLenum +gl_VERTEX_STREAM7_ATI = 0x8773 +gl_RG_EXT :: GLenum +gl_RG_EXT = 0x8227 +gl_STENCIL_BACK_PASS_DEPTH_PASS :: GLenum +gl_STENCIL_BACK_PASS_DEPTH_PASS = 0x8803 +gl_FRAMEBUFFER_RENDERABLE_LAYERED :: GLenum +gl_FRAMEBUFFER_RENDERABLE_LAYERED = 0x828A +gl_MAP2_VERTEX_ATTRIB1_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB1_4_NV = 0x8671 +gl_DRAW_BUFFER2_ATI :: GLenum +gl_DRAW_BUFFER2_ATI = 0x8827 +gl_RGBA_FLOAT16_ATI :: GLenum +gl_RGBA_FLOAT16_ATI = 0x881A +gl_EVAL_VERTEX_ATTRIB13_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB13_NV = 0x86D3 +gl_DRAW_BUFFER15_ATI :: GLenum +gl_DRAW_BUFFER15_ATI = 0x8834 +gl_MAP_WRITE_BIT :: GLenum +gl_MAP_WRITE_BIT = 0x0002 +gl_DOT3_RGBA :: GLenum +gl_DOT3_RGBA = 0x86AF +gl_MAT_SHININESS_BIT_PGI :: GLenum +gl_MAT_SHININESS_BIT_PGI = 0x02000000 +gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN :: GLenum +gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN = 0x8C88 +gl_MAX_TRACK_MATRIX_STACK_DEPTH_NV :: GLenum +gl_MAX_TRACK_MATRIX_STACK_DEPTH_NV = 0x862E +gl_MATRIX30_ARB :: GLenum +gl_MATRIX30_ARB = 0x88DE +gl_STENCIL_TEST :: GLenum +gl_STENCIL_TEST = 0x0B90 +gl_MAX_INTEGER_SAMPLES :: GLenum +gl_MAX_INTEGER_SAMPLES = 0x9110 +gl_COPY_READ_BUFFER_BINDING :: GLenum +gl_COPY_READ_BUFFER_BINDING = 0x8F36 +gl_TRANSFORM_FEEDBACK_BUFFER :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER = 0x8C8E +gl_LUMINANCE_FLOAT16_APPLE :: GLenum +gl_LUMINANCE_FLOAT16_APPLE = 0x881E +gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS :: GLenum +gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS = 0x8E89 +gl_MAX_VERTEX_UNIFORM_VECTORS :: GLenum +gl_MAX_VERTEX_UNIFORM_VECTORS = 0x8DFB +gl_WRITE_PIXEL_DATA_RANGE_LENGTH_NV :: GLenum +gl_WRITE_PIXEL_DATA_RANGE_LENGTH_NV = 0x887A +gl_SAMPLER_RENDERBUFFER_NV :: GLenum +gl_SAMPLER_RENDERBUFFER_NV = 0x8E56 +gl_DRAW_BUFFER13_NV :: GLenum +gl_DRAW_BUFFER13_NV = 0x8832 +gl_RGB32F_ARB :: GLenum +gl_RGB32F_ARB = 0x8815 +gl_FRAGMENT_LIGHT5_SGIX :: GLenum +gl_FRAGMENT_LIGHT5_SGIX = 0x8411 +gl_MAX_GENERAL_COMBINERS_NV :: GLenum +gl_MAX_GENERAL_COMBINERS_NV = 0x854D +gl_TRANSPOSE_TEXTURE_MATRIX_ARB :: GLenum +gl_TRANSPOSE_TEXTURE_MATRIX_ARB = 0x84E5 +gl_OPERAND1_ALPHA_ARB :: GLenum +gl_OPERAND1_ALPHA_ARB = 0x8599 +gl_COLOR_ATTACHMENT12 :: GLenum +gl_COLOR_ATTACHMENT12 = 0x8CEC +gl_GREEN_MAX_CLAMP_INGR :: GLenum +gl_GREEN_MAX_CLAMP_INGR = 0x8565 +gl_PATH_PROJECTION_STACK_DEPTH_NV :: GLenum +gl_PATH_PROJECTION_STACK_DEPTH_NV = 0x0BA4 +gl_MAP2_COLOR_4 :: GLenum +gl_MAP2_COLOR_4 = 0x0DB0 +gl_COLOR_SUM_EXT :: GLenum +gl_COLOR_SUM_EXT = 0x8458 +gl_CLAMP_FRAGMENT_COLOR_ARB :: GLenum +gl_CLAMP_FRAGMENT_COLOR_ARB = 0x891B +gl_INDEX_BITS :: GLenum +gl_INDEX_BITS = 0x0D51 +gl_CON_15_ATI :: GLenum +gl_CON_15_ATI = 0x8950 +gl_BLEND_OVERLAP_NV :: GLenum +gl_BLEND_OVERLAP_NV = 0x9281 +gl_DS_SCALE_NV :: GLenum +gl_DS_SCALE_NV = 0x8710 +gl_CURRENT_PALETTE_MATRIX_ARB :: GLenum +gl_CURRENT_PALETTE_MATRIX_ARB = 0x8843 +gl_IMAGE_BINDING_LAYER_EXT :: GLenum +gl_IMAGE_BINDING_LAYER_EXT = 0x8F3D +gl_WEIGHT_SUM_UNITY_ARB :: GLenum +gl_WEIGHT_SUM_UNITY_ARB = 0x86A6 +gl_ALPHA32I_EXT :: GLenum +gl_ALPHA32I_EXT = 0x8D84 +gl_SHADER_STORAGE_BUFFER_SIZE :: GLenum +gl_SHADER_STORAGE_BUFFER_SIZE = 0x90D5 +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER :: GLenum +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_COMPUTE_SHADER = 0x90ED +gl_MAX_UNIFORM_LOCATIONS :: GLenum +gl_MAX_UNIFORM_LOCATIONS = 0x826E +gl_DEBUG_SOURCE_OTHER_KHR :: GLenum +gl_DEBUG_SOURCE_OTHER_KHR = 0x824B +gl_FRACTIONAL_EVEN :: GLenum +gl_FRACTIONAL_EVEN = 0x8E7C +gl_MIN_PROGRAM_TEXEL_OFFSET :: GLenum +gl_MIN_PROGRAM_TEXEL_OFFSET = 0x8904 +gl_WEIGHT_ARRAY_OES :: GLenum +gl_WEIGHT_ARRAY_OES = 0x86AD +gl_RESET_NOTIFICATION_STRATEGY_KHR :: GLenum +gl_RESET_NOTIFICATION_STRATEGY_KHR = 0x8256 +gl_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV :: GLenum +gl_FRAGMENT_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA4 +gl_RGB2_EXT :: GLenum +gl_RGB2_EXT = 0x804E +gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT :: GLenum +gl_VERTEX_ATTRIB_ARRAY_BARRIER_BIT = 0x00000001 +gl_ELEMENT_ARRAY_BUFFER :: GLenum +gl_ELEMENT_ARRAY_BUFFER = 0x8893 +gl_MEDIUM_FLOAT :: GLenum +gl_MEDIUM_FLOAT = 0x8DF1 +gl_SAMPLER_1D_SHADOW_ARB :: GLenum +gl_SAMPLER_1D_SHADOW_ARB = 0x8B61 +gl_DRAW_BUFFER5 :: GLenum +gl_DRAW_BUFFER5 = 0x882A +gl_PARALLEL_ARRAYS_INTEL :: GLenum +gl_PARALLEL_ARRAYS_INTEL = 0x83F4 +gl_REG_24_ATI :: GLenum +gl_REG_24_ATI = 0x8939 +gl_DEPTH_STENCIL_TO_BGRA_NV :: GLenum +gl_DEPTH_STENCIL_TO_BGRA_NV = 0x886F +gl_MAX_FRAMEBUFFER_WIDTH :: GLenum +gl_MAX_FRAMEBUFFER_WIDTH = 0x9315 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4x4_OES = 0x93E3 +gl_POLYGON_OFFSET_FILL :: GLenum +gl_POLYGON_OFFSET_FILL = 0x8037 +gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_OES = 0x8518 +gl_TEXTURE_GEN_T :: GLenum +gl_TEXTURE_GEN_T = 0x0C61 +gl_TEXTURE_POST_SPECULAR_HP :: GLenum +gl_TEXTURE_POST_SPECULAR_HP = 0x8168 +gl_TEXTURE_CUBE_MAP_NEGATIVE_X_OES :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_X_OES = 0x8516 +gl_MAGNITUDE_SCALE_NV :: GLenum +gl_MAGNITUDE_SCALE_NV = 0x8712 +gl_VERTEX_SHADER_LOCALS_EXT :: GLenum +gl_VERTEX_SHADER_LOCALS_EXT = 0x87D3 +gl_INT_2_10_10_10_REV :: GLenum +gl_INT_2_10_10_10_REV = 0x8D9F +gl_DOUBLE_MAT3x2_EXT :: GLenum +gl_DOUBLE_MAT3x2_EXT = 0x8F4B +gl_DISCARD_NV :: GLenum +gl_DISCARD_NV = 0x8530 +gl_MATRIX13_ARB :: GLenum +gl_MATRIX13_ARB = 0x88CD +gl_GENERATE_MIPMAP_HINT :: GLenum +gl_GENERATE_MIPMAP_HINT = 0x8192 +gl_MAX_PIXEL_MAP_TABLE :: GLenum +gl_MAX_PIXEL_MAP_TABLE = 0x0D34 +gl_SHADER_STORAGE_BUFFER :: GLenum +gl_SHADER_STORAGE_BUFFER = 0x90D2 +gl_BUFFER_UPDATE_BARRIER_BIT :: GLenum +gl_BUFFER_UPDATE_BARRIER_BIT = 0x00000200 +gl_FRAMEBUFFER_BINDING_OES :: GLenum +gl_FRAMEBUFFER_BINDING_OES = 0x8CA6 +gl_CONTEXT_PROFILE_MASK :: GLenum +gl_CONTEXT_PROFILE_MASK = 0x9126 +gl_MAX_VIEWPORTS :: GLenum +gl_MAX_VIEWPORTS = 0x825B +gl_DRAW_BUFFER4_ARB :: GLenum +gl_DRAW_BUFFER4_ARB = 0x8829 +gl_RESAMPLE_DECIMATE_SGIX :: GLenum +gl_RESAMPLE_DECIMATE_SGIX = 0x8430 +gl_SHADER_OBJECT_ARB :: GLenum +gl_SHADER_OBJECT_ARB = 0x8B48 +gl_SYNC_FLAGS_APPLE :: GLenum +gl_SYNC_FLAGS_APPLE = 0x9115 +gl_Z4Y12Z4CB12Z4CR12_444_NV :: GLenum +gl_Z4Y12Z4CB12Z4CR12_444_NV = 0x9037 +gl_VERTEX_ARRAY_LENGTH_NV :: GLenum +gl_VERTEX_ARRAY_LENGTH_NV = 0x8F2B +gl_FOG_COORDINATE_ARRAY_LIST_IBM :: GLenum +gl_FOG_COORDINATE_ARRAY_LIST_IBM = 103076 +gl_FRAMEBUFFER_DEFAULT_SAMPLES :: GLenum +gl_FRAMEBUFFER_DEFAULT_SAMPLES = 0x9313 +gl_FLAT :: GLenum +gl_FLAT = 0x1D00 +gl_REG_2_ATI :: GLenum +gl_REG_2_ATI = 0x8923 +gl_VIEWPORT_BIT :: GLenum +gl_VIEWPORT_BIT = 0x00000800 +gl_TEXTURE_VIEW_MIN_LEVEL_EXT :: GLenum +gl_TEXTURE_VIEW_MIN_LEVEL_EXT = 0x82DB +gl_FRACTIONAL_ODD_EXT :: GLenum +gl_FRACTIONAL_ODD_EXT = 0x8E7B +gl_VIRTUAL_PAGE_SIZE_X_ARB :: GLenum +gl_VIRTUAL_PAGE_SIZE_X_ARB = 0x9195 +gl_GLOBAL_ALPHA_SUN :: GLenum +gl_GLOBAL_ALPHA_SUN = 0x81D9 +gl_TEXTURE_BORDER :: GLenum +gl_TEXTURE_BORDER = 0x1005 +gl_MAP2_VERTEX_ATTRIB7_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB7_4_NV = 0x8677 +gl_BUFFER_ACCESS :: GLenum +gl_BUFFER_ACCESS = 0x88BB +gl_COLOR_ATTACHMENT15_EXT :: GLenum +gl_COLOR_ATTACHMENT15_EXT = 0x8CEF +gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT :: GLenum +gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CF +gl_PRIMITIVE_RESTART_FIXED_INDEX :: GLenum +gl_PRIMITIVE_RESTART_FIXED_INDEX = 0x8D69 +gl_MAX_COMBINED_DIMENSIONS :: GLenum +gl_MAX_COMBINED_DIMENSIONS = 0x8282 +gl_MINUS_NV :: GLenum +gl_MINUS_NV = 0x929F +gl_NORMAL_MAP_ARB :: GLenum +gl_NORMAL_MAP_ARB = 0x8511 +gl_MAT_AMBIENT_BIT_PGI :: GLenum +gl_MAT_AMBIENT_BIT_PGI = 0x00100000 +gl_REG_14_ATI :: GLenum +gl_REG_14_ATI = 0x892F +gl_SECONDARY_INTERPOLATOR_ATI :: GLenum +gl_SECONDARY_INTERPOLATOR_ATI = 0x896D +gl_FRAGMENT_SHADER_BIT_EXT :: GLenum +gl_FRAGMENT_SHADER_BIT_EXT = 0x00000002 +gl_CON_20_ATI :: GLenum +gl_CON_20_ATI = 0x8955 +gl_DYNAMIC_DRAW :: GLenum +gl_DYNAMIC_DRAW = 0x88E8 +gl_STENCIL_INDEX1 :: GLenum +gl_STENCIL_INDEX1 = 0x8D46 +gl_DEPTH_COMPONENTS :: GLenum +gl_DEPTH_COMPONENTS = 0x8284 +gl_SEPARATE_SPECULAR_COLOR_EXT :: GLenum +gl_SEPARATE_SPECULAR_COLOR_EXT = 0x81FA +gl_CONSTANT_COLOR0_NV :: GLenum +gl_CONSTANT_COLOR0_NV = 0x852A +gl_LUMINANCE16I_EXT :: GLenum +gl_LUMINANCE16I_EXT = 0x8D8C +gl_TEXTURE_COORD_ARRAY_SIZE_EXT :: GLenum +gl_TEXTURE_COORD_ARRAY_SIZE_EXT = 0x8088 +gl_BLEND_DST_RGB :: GLenum +gl_BLEND_DST_RGB = 0x80C8 +gl_VARIABLE_C_NV :: GLenum +gl_VARIABLE_C_NV = 0x8525 +gl_INT_VEC2_ARB :: GLenum +gl_INT_VEC2_ARB = 0x8B53 +gl_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX :: GLenum +gl_MAX_CLIPMAP_VIRTUAL_DEPTH_SGIX = 0x8178 +gl_PIXEL_MAP_G_TO_G_SIZE :: GLenum +gl_PIXEL_MAP_G_TO_G_SIZE = 0x0CB7 +gl_BLUE_MIN_CLAMP_INGR :: GLenum +gl_BLUE_MIN_CLAMP_INGR = 0x8562 +gl_RETURN :: GLenum +gl_RETURN = 0x0102 +gl_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD :: GLenum +gl_EXTERNAL_VIRTUAL_MEMORY_BUFFER_AMD = 0x9160 +gl_DOUBLE :: GLenum +gl_DOUBLE = 0x140A +gl_COMBINE4_NV :: GLenum +gl_COMBINE4_NV = 0x8503 +gl_IMAGE_ROTATE_ORIGIN_X_HP :: GLenum +gl_IMAGE_ROTATE_ORIGIN_X_HP = 0x815A +gl_COMBINER5_NV :: GLenum +gl_COMBINER5_NV = 0x8555 +gl_SYNC_CONDITION :: GLenum +gl_SYNC_CONDITION = 0x9113 +gl_DEBUG_LOGGED_MESSAGES_ARB :: GLenum +gl_DEBUG_LOGGED_MESSAGES_ARB = 0x9145 +gl_REG_15_ATI :: GLenum +gl_REG_15_ATI = 0x8930 +gl_BUFFER_MAP_POINTER_OES :: GLenum +gl_BUFFER_MAP_POINTER_OES = 0x88BD +gl_SM_COUNT_NV :: GLenum +gl_SM_COUNT_NV = 0x933B +gl_MAX_FRAMEBUFFER_HEIGHT :: GLenum +gl_MAX_FRAMEBUFFER_HEIGHT = 0x9316 +gl_INCR_WRAP_OES :: GLenum +gl_INCR_WRAP_OES = 0x8507 +gl_GCCSO_SHADER_BINARY_FJ :: GLenum +gl_GCCSO_SHADER_BINARY_FJ = 0x9260 +gl_DRAW_BUFFER4_NV :: GLenum +gl_DRAW_BUFFER4_NV = 0x8829 +gl_RGB565 :: GLenum +gl_RGB565 = 0x8D62 +gl_WRITE_PIXEL_DATA_RANGE_NV :: GLenum +gl_WRITE_PIXEL_DATA_RANGE_NV = 0x8878 +gl_UNIFORM_OFFSET :: GLenum +gl_UNIFORM_OFFSET = 0x8A3B +gl_UNSIGNED_INT64_ARB :: GLenum +gl_UNSIGNED_INT64_ARB = 0x140F +gl_STENCIL_RENDERABLE :: GLenum +gl_STENCIL_RENDERABLE = 0x8288 +gl_COMPRESSED_RGBA_BPTC_UNORM :: GLenum +gl_COMPRESSED_RGBA_BPTC_UNORM = 0x8E8C +gl_FLOAT_R32_NV :: GLenum +gl_FLOAT_R32_NV = 0x8885 +gl_TEXTURE_CLIPMAP_OFFSET_SGIX :: GLenum +gl_TEXTURE_CLIPMAP_OFFSET_SGIX = 0x8173 +gl_TEXTURE_IMAGE_VALID_QCOM :: GLenum +gl_TEXTURE_IMAGE_VALID_QCOM = 0x8BD8 +gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC = 0x9279 +gl_IMAGE_PIXEL_TYPE :: GLenum +gl_IMAGE_PIXEL_TYPE = 0x82AA +gl_EDGE_FLAG_ARRAY_STRIDE :: GLenum +gl_EDGE_FLAG_ARRAY_STRIDE = 0x808C +gl_RED_SCALE :: GLenum +gl_RED_SCALE = 0x0D14 +gl_RENDERBUFFER_ALPHA_SIZE_OES :: GLenum +gl_RENDERBUFFER_ALPHA_SIZE_OES = 0x8D53 +gl_CLIP_DISTANCE7 :: GLenum +gl_CLIP_DISTANCE7 = 0x3007 +gl_INTENSITY32UI_EXT :: GLenum +gl_INTENSITY32UI_EXT = 0x8D73 +gl_DEBUG_SOURCE_WINDOW_SYSTEM_KHR :: GLenum +gl_DEBUG_SOURCE_WINDOW_SYSTEM_KHR = 0x8247 +gl_PN_TRIANGLES_ATI :: GLenum +gl_PN_TRIANGLES_ATI = 0x87F0 +gl_LIGHT5 :: GLenum +gl_LIGHT5 = 0x4005 +gl_QUERY_RESULT_ARB :: GLenum +gl_QUERY_RESULT_ARB = 0x8866 +gl_LUMINANCE16 :: GLenum +gl_LUMINANCE16 = 0x8042 +gl_ALPHA_TEST_QCOM :: GLenum +gl_ALPHA_TEST_QCOM = 0x0BC0 +gl_TEXTURE_BORDER_COLOR_NV :: GLenum +gl_TEXTURE_BORDER_COLOR_NV = 0x1004 +gl_CULL_FRAGMENT_NV :: GLenum +gl_CULL_FRAGMENT_NV = 0x86E7 +gl_PATH_GEN_MODE_NV :: GLenum +gl_PATH_GEN_MODE_NV = 0x90B0 +gl_PROGRAM_POINT_SIZE_ARB :: GLenum +gl_PROGRAM_POINT_SIZE_ARB = 0x8642 +gl_INTERNALFORMAT_DEPTH_TYPE :: GLenum +gl_INTERNALFORMAT_DEPTH_TYPE = 0x827C +gl_UNPACK_SKIP_ROWS :: GLenum +gl_UNPACK_SKIP_ROWS = 0x0CF3 +gl_DEBUG_SEVERITY_NOTIFICATION :: GLenum +gl_DEBUG_SEVERITY_NOTIFICATION = 0x826B +gl_MAX_FRAGMENT_LIGHTS_SGIX :: GLenum +gl_MAX_FRAGMENT_LIGHTS_SGIX = 0x8404 +gl_COUNTER_TYPE_AMD :: GLenum +gl_COUNTER_TYPE_AMD = 0x8BC0 +gl_TEXTURE_FETCH_BARRIER_BIT_EXT :: GLenum +gl_TEXTURE_FETCH_BARRIER_BIT_EXT = 0x00000008 +gl_CURRENT_NORMAL :: GLenum +gl_CURRENT_NORMAL = 0x0B02 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5x4_OES = 0x93E5 +gl_MULTIVIEW_EXT :: GLenum +gl_MULTIVIEW_EXT = 0x90F1 +gl_TESS_GEN_VERTEX_ORDER_EXT :: GLenum +gl_TESS_GEN_VERTEX_ORDER_EXT = 0x8E78 +gl_IMAGE_SCALE_X_HP :: GLenum +gl_IMAGE_SCALE_X_HP = 0x8155 +gl_TEXTURE_COLOR_TABLE_SGI :: GLenum +gl_TEXTURE_COLOR_TABLE_SGI = 0x80BC +gl_DSDT_MAG_NV :: GLenum +gl_DSDT_MAG_NV = 0x86F6 +gl_Z400_BINARY_AMD :: GLenum +gl_Z400_BINARY_AMD = 0x8740 +gl_COLOR_INDEX8_EXT :: GLenum +gl_COLOR_INDEX8_EXT = 0x80E5 +gl_SRGB8_NV :: GLenum +gl_SRGB8_NV = 0x8C41 +gl_UNSIGNED_IDENTITY_NV :: GLenum +gl_UNSIGNED_IDENTITY_NV = 0x8536 +gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES :: GLenum +gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY_OES = 0x9105 +gl_ALPHA_SNORM :: GLenum +gl_ALPHA_SNORM = 0x9010 +gl_MAX_TEXTURE_UNITS :: GLenum +gl_MAX_TEXTURE_UNITS = 0x84E2 +gl_DEBUG_SEVERITY_MEDIUM_KHR :: GLenum +gl_DEBUG_SEVERITY_MEDIUM_KHR = 0x9147 +gl_TEXTURE_RECTANGLE :: GLenum +gl_TEXTURE_RECTANGLE = 0x84F5 +gl_CONTRAST_NV :: GLenum +gl_CONTRAST_NV = 0x92A1 +gl_FILL :: GLenum +gl_FILL = 0x1B02 +gl_BLEND_COLOR :: GLenum +gl_BLEND_COLOR = 0x8005 +gl_POINT_SMOOTH_HINT :: GLenum +gl_POINT_SMOOTH_HINT = 0x0C51 +gl_CONTEXT_ROBUST_ACCESS :: GLenum +gl_CONTEXT_ROBUST_ACCESS = 0x90F3 +gl_FRAGMENT_PROGRAM_NV :: GLenum +gl_FRAGMENT_PROGRAM_NV = 0x8870 +gl_OP_MULTIPLY_MATRIX_EXT :: GLenum +gl_OP_MULTIPLY_MATRIX_EXT = 0x8798 +gl_DEPENDENT_GB_TEXTURE_2D_NV :: GLenum +gl_DEPENDENT_GB_TEXTURE_2D_NV = 0x86EA +gl_DOUBLE_EXT :: GLenum +gl_DOUBLE_EXT = 0x140A +gl_VERTEX_PROGRAM_NV :: GLenum +gl_VERTEX_PROGRAM_NV = 0x8620 +gl_PATH_END_CAPS_NV :: GLenum +gl_PATH_END_CAPS_NV = 0x9076 +gl_PATH_STROKE_MASK_NV :: GLenum +gl_PATH_STROKE_MASK_NV = 0x9084 +gl_SAMPLER_CUBE_SHADOW_EXT :: GLenum +gl_SAMPLER_CUBE_SHADOW_EXT = 0x8DC5 +gl_COLOR_SAMPLES_NV :: GLenum +gl_COLOR_SAMPLES_NV = 0x8E20 +gl_DUAL_INTENSITY16_SGIS :: GLenum +gl_DUAL_INTENSITY16_SGIS = 0x811B +gl_IMPLEMENTATION_COLOR_READ_TYPE_OES :: GLenum +gl_IMPLEMENTATION_COLOR_READ_TYPE_OES = 0x8B9A +gl_MAX_DEBUG_GROUP_STACK_DEPTH_KHR :: GLenum +gl_MAX_DEBUG_GROUP_STACK_DEPTH_KHR = 0x826C +gl_SCISSOR_TEST :: GLenum +gl_SCISSOR_TEST = 0x0C11 +gl_ADJACENT_PAIRS_NV :: GLenum +gl_ADJACENT_PAIRS_NV = 0x90AE +gl_MAX_VERTEX_ATTRIB_BINDINGS :: GLenum +gl_MAX_VERTEX_ATTRIB_BINDINGS = 0x82DA +gl_TEXTURE_GATHER :: GLenum +gl_TEXTURE_GATHER = 0x82A2 +gl_LUMINANCE_ALPHA8UI_EXT :: GLenum +gl_LUMINANCE_ALPHA8UI_EXT = 0x8D81 +gl_RELATIVE_ARC_TO_NV :: GLenum +gl_RELATIVE_ARC_TO_NV = 0xFF +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR = 0x93DA +gl_TEXTURE_BINDING_CUBE_MAP_EXT :: GLenum +gl_TEXTURE_BINDING_CUBE_MAP_EXT = 0x8514 +gl_FRAGMENT_ALPHA_MODULATE_IMG :: GLenum +gl_FRAGMENT_ALPHA_MODULATE_IMG = 0x8C08 +gl_CURRENT_VERTEX_EXT :: GLenum +gl_CURRENT_VERTEX_EXT = 0x87E2 +gl_MAP1_VERTEX_ATTRIB11_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB11_4_NV = 0x866B +gl_MATRIX_INDEX_ARRAY_SIZE_ARB :: GLenum +gl_MATRIX_INDEX_ARRAY_SIZE_ARB = 0x8846 +gl_TRANSFORM_FEEDBACK_BUFFER_MODE :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_MODE = 0x8C7F +gl_PIXEL_TILE_CACHE_SIZE_SGIX :: GLenum +gl_PIXEL_TILE_CACHE_SIZE_SGIX = 0x8145 +gl_MODELVIEW0_EXT :: GLenum +gl_MODELVIEW0_EXT = 0x1700 +gl_FONT_DESCENDER_BIT_NV :: GLenum +gl_FONT_DESCENDER_BIT_NV = 0x00400000 +gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS :: GLenum +gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS = 0x92CE +gl_RASTERIZER_DISCARD :: GLenum +gl_RASTERIZER_DISCARD = 0x8C89 +gl_TRANSFORM_FEEDBACK_BUFFER_SIZE :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_SIZE = 0x8C85 +gl_MAX_DEBUG_MESSAGE_LENGTH_ARB :: GLenum +gl_MAX_DEBUG_MESSAGE_LENGTH_ARB = 0x9143 +gl_EXTENSIONS :: GLenum +gl_EXTENSIONS = 0x1F03 +gl_RESAMPLE_AVERAGE_OML :: GLenum +gl_RESAMPLE_AVERAGE_OML = 0x8988 +gl_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV :: GLenum +gl_Z6Y10Z6CB10Z6Y10Z6CR10_422_NV = 0x9033 +gl_RELATIVE_SMALL_CCW_ARC_TO_NV :: GLenum +gl_RELATIVE_SMALL_CCW_ARC_TO_NV = 0x13 +gl_FRONT :: GLenum +gl_FRONT = 0x0404 +gl_BLEND_COLOR_EXT :: GLenum +gl_BLEND_COLOR_EXT = 0x8005 +gl_BUFFER_ACCESS_OES :: GLenum +gl_BUFFER_ACCESS_OES = 0x88BB +gl_MATRIX29_ARB :: GLenum +gl_MATRIX29_ARB = 0x88DD +gl_GEOMETRY_LINKED_INPUT_TYPE_EXT :: GLenum +gl_GEOMETRY_LINKED_INPUT_TYPE_EXT = 0x8917 +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_OES = 0x8CD0 +gl_COLOR_ATTACHMENT12_EXT :: GLenum +gl_COLOR_ATTACHMENT12_EXT = 0x8CEC +gl_DRAW_BUFFER1 :: GLenum +gl_DRAW_BUFFER1 = 0x8826 +gl_FLOAT_32_UNSIGNED_INT_24_8_REV :: GLenum +gl_FLOAT_32_UNSIGNED_INT_24_8_REV = 0x8DAD +gl_UNSIGNED_INT_SAMPLER_2D_RECT_EXT :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D_RECT_EXT = 0x8DD5 +gl_UNSIGNED_INT_SAMPLER_CUBE :: GLenum +gl_UNSIGNED_INT_SAMPLER_CUBE = 0x8DD4 +gl_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI :: GLenum +gl_PROXY_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D4 +gl_MAX_CULL_DISTANCES :: GLenum +gl_MAX_CULL_DISTANCES = 0x82F9 +gl_TEXTURE_LOD_BIAS_S_SGIX :: GLenum +gl_TEXTURE_LOD_BIAS_S_SGIX = 0x818E +gl_SPRITE_SGIX :: GLenum +gl_SPRITE_SGIX = 0x8148 +gl_VERTEX_ATTRIB_ARRAY3_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY3_NV = 0x8653 +gl_QUAD_INTENSITY4_SGIS :: GLenum +gl_QUAD_INTENSITY4_SGIS = 0x8122 +gl_DIFFERENCE_KHR :: GLenum +gl_DIFFERENCE_KHR = 0x929E +gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT :: GLenum +gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS_EXT = 0x90D9 +gl_VOLATILE_APPLE :: GLenum +gl_VOLATILE_APPLE = 0x8A1A +gl_MAT_EMISSION_BIT_PGI :: GLenum +gl_MAT_EMISSION_BIT_PGI = 0x00800000 +gl_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV :: GLenum +gl_TESS_EVALUATION_PROGRAM_PARAMETER_BUFFER_NV = 0x8C75 +gl_DRAW_FRAMEBUFFER_BINDING :: GLenum +gl_DRAW_FRAMEBUFFER_BINDING = 0x8CA6 +gl_TEXTURE8 :: GLenum +gl_TEXTURE8 = 0x84C8 +gl_MUL_ATI :: GLenum +gl_MUL_ATI = 0x8964 +gl_PROGRAM_OBJECT_EXT :: GLenum +gl_PROGRAM_OBJECT_EXT = 0x8B40 +gl_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB :: GLenum +gl_MAX_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x8810 +gl_MATRIX_INDEX_ARRAY_TYPE_ARB :: GLenum +gl_MATRIX_INDEX_ARRAY_TYPE_ARB = 0x8847 +gl_PIXEL_MAG_FILTER_EXT :: GLenum +gl_PIXEL_MAG_FILTER_EXT = 0x8331 +gl_LESS :: GLenum +gl_LESS = 0x0201 +gl_SOURCE2_RGB_ARB :: GLenum +gl_SOURCE2_RGB_ARB = 0x8582 +gl_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH :: GLenum +gl_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH = 0x8A35 +gl_PATH_STENCIL_VALUE_MASK_NV :: GLenum +gl_PATH_STENCIL_VALUE_MASK_NV = 0x90B9 +gl_IMPLEMENTATION_COLOR_READ_TYPE :: GLenum +gl_IMPLEMENTATION_COLOR_READ_TYPE = 0x8B9A +gl_TEXTURE_CLIPMAP_CENTER_SGIX :: GLenum +gl_TEXTURE_CLIPMAP_CENTER_SGIX = 0x8171 +gl_BUFFER :: GLenum +gl_BUFFER = 0x82E0 +gl_DEBUG_CALLBACK_USER_PARAM_ARB :: GLenum +gl_DEBUG_CALLBACK_USER_PARAM_ARB = 0x8245 +gl_FIXED_OES :: GLenum +gl_FIXED_OES = 0x140C +gl_INT_VEC2 :: GLenum +gl_INT_VEC2 = 0x8B53 +gl_VARIANT_VALUE_EXT :: GLenum +gl_VARIANT_VALUE_EXT = 0x87E4 +gl_QUAD_STRIP :: GLenum +gl_QUAD_STRIP = 0x0008 +gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT :: GLenum +gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT = 0x8E8E +gl_ZERO_TO_ONE :: GLenum +gl_ZERO_TO_ONE = 0x935F +gl_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB :: GLenum +gl_PROGRAM_NATIVE_TEX_INDIRECTIONS_ARB = 0x880A +gl_CND_ATI :: GLenum +gl_CND_ATI = 0x896A +gl_PROGRAM_POINT_SIZE :: GLenum +gl_PROGRAM_POINT_SIZE = 0x8642 +gl_VIEWPORT_BOUNDS_RANGE :: GLenum +gl_VIEWPORT_BOUNDS_RANGE = 0x825D +gl_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL :: GLenum +gl_NORMAL_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F6 +gl_R1UI_T2F_N3F_V3F_SUN :: GLenum +gl_R1UI_T2F_N3F_V3F_SUN = 0x85CA +gl_DEPTH_STENCIL_EXT :: GLenum +gl_DEPTH_STENCIL_EXT = 0x84F9 +gl_RESCALE_NORMAL :: GLenum +gl_RESCALE_NORMAL = 0x803A +gl_INDEX_CLEAR_VALUE :: GLenum +gl_INDEX_CLEAR_VALUE = 0x0C20 +gl_VERTEX_STREAM5_ATI :: GLenum +gl_VERTEX_STREAM5_ATI = 0x8771 +gl_CON_4_ATI :: GLenum +gl_CON_4_ATI = 0x8945 +gl_LAYOUT_DEFAULT_INTEL :: GLenum +gl_LAYOUT_DEFAULT_INTEL = 0 +gl_RGBA8I_EXT :: GLenum +gl_RGBA8I_EXT = 0x8D8E +gl_IMAGE_CLASS_4_X_16 :: GLenum +gl_IMAGE_CLASS_4_X_16 = 0x82BC +gl_RGB8_EXT :: GLenum +gl_RGB8_EXT = 0x8051 +gl_TEXTURE_DS_SIZE_NV :: GLenum +gl_TEXTURE_DS_SIZE_NV = 0x871D +gl_CLAMP_VERTEX_COLOR :: GLenum +gl_CLAMP_VERTEX_COLOR = 0x891A +gl_DEPTH_CLEAR_VALUE :: GLenum +gl_DEPTH_CLEAR_VALUE = 0x0B73 +gl_VERTEX_ATTRIB_ARRAY_SIZE_ARB :: GLenum +gl_VERTEX_ATTRIB_ARRAY_SIZE_ARB = 0x8623 +gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS :: GLenum +gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS = 0x90D8 +gl_RGB_FLOAT16_APPLE :: GLenum +gl_RGB_FLOAT16_APPLE = 0x881B +gl_DOT_PRODUCT_REFLECT_CUBE_MAP_NV :: GLenum +gl_DOT_PRODUCT_REFLECT_CUBE_MAP_NV = 0x86F2 +gl_COLOR_ATTACHMENT1 :: GLenum +gl_COLOR_ATTACHMENT1 = 0x8CE1 +gl_MAX_TESS_GEN_LEVEL_EXT :: GLenum +gl_MAX_TESS_GEN_LEVEL_EXT = 0x8E7E +gl_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER :: GLenum +gl_UNIFORM_BLOCK_REFERENCED_BY_GEOMETRY_SHADER = 0x8A45 +gl_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM :: GLenum +gl_FRAGMENT_SHADER_FRAMEBUFFER_FETCH_MRT_ARM = 0x8F66 +gl_MATRIX3_ARB :: GLenum +gl_MATRIX3_ARB = 0x88C3 +gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB :: GLenum +gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_ARB = 0x8DDF +gl_FRAGMENT_PROGRAM_BINDING_NV :: GLenum +gl_FRAGMENT_PROGRAM_BINDING_NV = 0x8873 +gl_DOT2_ADD_ATI :: GLenum +gl_DOT2_ADD_ATI = 0x896C +gl_CON_2_ATI :: GLenum +gl_CON_2_ATI = 0x8943 +gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_OES = 0x8CD9 +gl_UNIFORM_ARRAY_STRIDE :: GLenum +gl_UNIFORM_ARRAY_STRIDE = 0x8A3C +gl_RECLAIM_MEMORY_HINT_PGI :: GLenum +gl_RECLAIM_MEMORY_HINT_PGI = 0x1A1FE +gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS :: GLenum +gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS = 0x8E80 +gl_DRAW_BUFFER11_ARB :: GLenum +gl_DRAW_BUFFER11_ARB = 0x8830 +gl_NORMAL_ARRAY :: GLenum +gl_NORMAL_ARRAY = 0x8075 +gl_PATH_GEN_COMPONENTS_NV :: GLenum +gl_PATH_GEN_COMPONENTS_NV = 0x90B3 +gl_COLOR_FLOAT_APPLE :: GLenum +gl_COLOR_FLOAT_APPLE = 0x8A0F +gl_WAIT_FAILED :: GLenum +gl_WAIT_FAILED = 0x911D +gl_SAMPLER_1D_ARRAY_SHADOW :: GLenum +gl_SAMPLER_1D_ARRAY_SHADOW = 0x8DC3 +gl_PIXEL_TEX_GEN_Q_CEILING_SGIX :: GLenum +gl_PIXEL_TEX_GEN_Q_CEILING_SGIX = 0x8184 +gl_ALWAYS_FAST_HINT_PGI :: GLenum +gl_ALWAYS_FAST_HINT_PGI = 0x1A20C +gl_GEOMETRY_OUTPUT_TYPE_EXT :: GLenum +gl_GEOMETRY_OUTPUT_TYPE_EXT = 0x8DDC +gl_MAX_PROGRAM_PATCH_ATTRIBS_NV :: GLenum +gl_MAX_PROGRAM_PATCH_ATTRIBS_NV = 0x86D8 +gl_TEXTURE_1D_ARRAY :: GLenum +gl_TEXTURE_1D_ARRAY = 0x8C18 +gl_LIST_MODE :: GLenum +gl_LIST_MODE = 0x0B30 +gl_COLOR_ARRAY_TYPE :: GLenum +gl_COLOR_ARRAY_TYPE = 0x8082 +gl_SAMPLE_MASK_VALUE_EXT :: GLenum +gl_SAMPLE_MASK_VALUE_EXT = 0x80AA +gl_PIXEL_BUFFER_BARRIER_BIT :: GLenum +gl_PIXEL_BUFFER_BARRIER_BIT = 0x00000080 +gl_SCISSOR_BOX :: GLenum +gl_SCISSOR_BOX = 0x0C10 +gl_UNSIGNED_INT_SAMPLER_3D_EXT :: GLenum +gl_UNSIGNED_INT_SAMPLER_3D_EXT = 0x8DD3 +gl_MAX_ATOMIC_COUNTER_BUFFER_SIZE :: GLenum +gl_MAX_ATOMIC_COUNTER_BUFFER_SIZE = 0x92D8 +gl_CLIENT_ALL_ATTRIB_BITS :: GLenum +gl_CLIENT_ALL_ATTRIB_BITS = 0xFFFFFFFF +gl_TRANSPOSE_MODELVIEW_MATRIX_ARB :: GLenum +gl_TRANSPOSE_MODELVIEW_MATRIX_ARB = 0x84E3 +gl_TEXTURE_BINDING_RECTANGLE_NV :: GLenum +gl_TEXTURE_BINDING_RECTANGLE_NV = 0x84F6 +gl_ALPHA_FLOAT32_ATI :: GLenum +gl_ALPHA_FLOAT32_ATI = 0x8816 +gl_MAP1_TEXTURE_COORD_4 :: GLenum +gl_MAP1_TEXTURE_COORD_4 = 0x0D96 +gl_CONSTANT_ALPHA :: GLenum +gl_CONSTANT_ALPHA = 0x8003 +gl_PREVIOUS_EXT :: GLenum +gl_PREVIOUS_EXT = 0x8578 +gl_PACK_COMPRESSED_SIZE_SGIX :: GLenum +gl_PACK_COMPRESSED_SIZE_SGIX = 0x831C +gl_IMAGE_2D_ARRAY_EXT :: GLenum +gl_IMAGE_2D_ARRAY_EXT = 0x9053 +gl_ASYNC_TEX_IMAGE_SGIX :: GLenum +gl_ASYNC_TEX_IMAGE_SGIX = 0x835C +gl_QUERY_RESULT :: GLenum +gl_QUERY_RESULT = 0x8866 +gl_MATRIX0_ARB :: GLenum +gl_MATRIX0_ARB = 0x88C0 +gl_UNPACK_CMYK_HINT_EXT :: GLenum +gl_UNPACK_CMYK_HINT_EXT = 0x800F +gl_MAP1_TEXTURE_COORD_1 :: GLenum +gl_MAP1_TEXTURE_COORD_1 = 0x0D93 +gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH :: GLenum +gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH = 0x82FC +gl_PN_TRIANGLES_POINT_MODE_LINEAR_ATI :: GLenum +gl_PN_TRIANGLES_POINT_MODE_LINEAR_ATI = 0x87F5 +gl_TEXTURE_BLUE_SIZE_EXT :: GLenum +gl_TEXTURE_BLUE_SIZE_EXT = 0x805E +gl_VARIANT_EXT :: GLenum +gl_VARIANT_EXT = 0x87C1 +gl_UNPACK_ROW_LENGTH :: GLenum +gl_UNPACK_ROW_LENGTH = 0x0CF2 +gl_VARIANT_DATATYPE_EXT :: GLenum +gl_VARIANT_DATATYPE_EXT = 0x87E5 +gl_LINEAR_MIPMAP_LINEAR :: GLenum +gl_LINEAR_MIPMAP_LINEAR = 0x2703 +gl_ALPHA8I_EXT :: GLenum +gl_ALPHA8I_EXT = 0x8D90 +gl_OUTPUT_TEXTURE_COORD20_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD20_EXT = 0x87B1 +gl_EYE_LINEAR :: GLenum +gl_EYE_LINEAR = 0x2400 +gl_VIEWPORT :: GLenum +gl_VIEWPORT = 0x0BA2 +gl_SHADER_BINARY_DMP :: GLenum +gl_SHADER_BINARY_DMP = 0x9250 +gl_TEXTURE25_ARB :: GLenum +gl_TEXTURE25_ARB = 0x84D9 +gl_UNSIGNED_SHORT_4_4_4_4_EXT :: GLenum +gl_UNSIGNED_SHORT_4_4_4_4_EXT = 0x8033 +gl_PROXY_HISTOGRAM_EXT :: GLenum +gl_PROXY_HISTOGRAM_EXT = 0x8025 +gl_SCALEBIAS_HINT_SGIX :: GLenum +gl_SCALEBIAS_HINT_SGIX = 0x8322 +gl_MAP_INVALIDATE_RANGE_BIT_EXT :: GLenum +gl_MAP_INVALIDATE_RANGE_BIT_EXT = 0x0004 +gl_FRAGMENT_PROGRAM_CALLBACK_MESA :: GLenum +gl_FRAGMENT_PROGRAM_CALLBACK_MESA = 0x8BB1 +gl_TRANSLATE_3D_NV :: GLenum +gl_TRANSLATE_3D_NV = 0x9091 +gl_PATH_COORD_COUNT_NV :: GLenum +gl_PATH_COORD_COUNT_NV = 0x909E +gl_MAX_ACTIVE_LIGHTS_SGIX :: GLenum +gl_MAX_ACTIVE_LIGHTS_SGIX = 0x8405 +gl_TRANSFORM_FEEDBACK_OVERFLOW_ARB :: GLenum +gl_TRANSFORM_FEEDBACK_OVERFLOW_ARB = 0x82EC +gl_REFERENCE_PLANE_EQUATION_SGIX :: GLenum +gl_REFERENCE_PLANE_EQUATION_SGIX = 0x817E +gl_PATH_TERMINAL_DASH_CAP_NV :: GLenum +gl_PATH_TERMINAL_DASH_CAP_NV = 0x907D +gl_INDEX_ARRAY :: GLenum +gl_INDEX_ARRAY = 0x8077 +gl_INNOCENT_CONTEXT_RESET_ARB :: GLenum +gl_INNOCENT_CONTEXT_RESET_ARB = 0x8254 +gl_TEXTURE_BINDING_1D :: GLenum +gl_TEXTURE_BINDING_1D = 0x8068 +gl_TRANSFORM_FEEDBACK_BUFFER_STRIDE :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_STRIDE = 0x934C +gl_QUERY_OBJECT_EXT :: GLenum +gl_QUERY_OBJECT_EXT = 0x9153 +gl_UNIFORM_BLOCK :: GLenum +gl_UNIFORM_BLOCK = 0x92E2 +gl_CONVOLUTION_HEIGHT :: GLenum +gl_CONVOLUTION_HEIGHT = 0x8019 +gl_STENCIL_FAIL :: GLenum +gl_STENCIL_FAIL = 0x0B94 +gl_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX :: GLenum +gl_POST_TEXTURE_FILTER_BIAS_RANGE_SGIX = 0x817B +gl_TEXTURE_SAMPLES_IMG :: GLenum +gl_TEXTURE_SAMPLES_IMG = 0x9136 +gl_REFLECTION_MAP_NV :: GLenum +gl_REFLECTION_MAP_NV = 0x8512 +gl_GREEN_SCALE :: GLenum +gl_GREEN_SCALE = 0x0D18 +gl_TRANSFORM_FEEDBACK_BUFFER_EXT :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_EXT = 0x8C8E +gl_LIGHTEN_NV :: GLenum +gl_LIGHTEN_NV = 0x9298 +gl_HISTOGRAM_ALPHA_SIZE_EXT :: GLenum +gl_HISTOGRAM_ALPHA_SIZE_EXT = 0x802B +gl_UNSIGNED_INT64_NV :: GLenum +gl_UNSIGNED_INT64_NV = 0x140F +gl_LINE_STIPPLE_REPEAT :: GLenum +gl_LINE_STIPPLE_REPEAT = 0x0B26 +gl_YCBCR_MESA :: GLenum +gl_YCBCR_MESA = 0x8757 +gl_LEQUAL :: GLenum +gl_LEQUAL = 0x0203 +gl_BUFFER_USAGE_ARB :: GLenum +gl_BUFFER_USAGE_ARB = 0x8765 +gl_MAP1_VERTEX_ATTRIB6_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB6_4_NV = 0x8666 +gl_SAMPLER_BUFFER_AMD :: GLenum +gl_SAMPLER_BUFFER_AMD = 0x9001 +gl_OBJECT_DISTANCE_TO_LINE_SGIS :: GLenum +gl_OBJECT_DISTANCE_TO_LINE_SGIS = 0x81F3 +gl_PIXEL_COUNT_NV :: GLenum +gl_PIXEL_COUNT_NV = 0x8866 +gl_VERTEX_PROGRAM_POSITION_MESA :: GLenum +gl_VERTEX_PROGRAM_POSITION_MESA = 0x8BB4 +gl_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI :: GLenum +gl_PN_TRIANGLES_NORMAL_MODE_LINEAR_ATI = 0x87F7 +gl_POST_COLOR_MATRIX_BLUE_BIAS :: GLenum +gl_POST_COLOR_MATRIX_BLUE_BIAS = 0x80BA +gl_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX :: GLenum +gl_GPU_MEMORY_INFO_EVICTED_MEMORY_NVX = 0x904B +gl_VERTEX_ATTRIB_MAP2_APPLE :: GLenum +gl_VERTEX_ATTRIB_MAP2_APPLE = 0x8A01 +gl_PLUS_DARKER_NV :: GLenum +gl_PLUS_DARKER_NV = 0x9292 +gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT :: GLenum +gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_EXT = 0x906B +gl_FRAGMENT_SHADER_INVOCATIONS_ARB :: GLenum +gl_FRAGMENT_SHADER_INVOCATIONS_ARB = 0x82F4 +gl_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT :: GLenum +gl_UNSIGNED_INT_IMAGE_2D_ARRAY_EXT = 0x9069 +gl_PROXY_TEXTURE_CUBE_MAP_ARRAY :: GLenum +gl_PROXY_TEXTURE_CUBE_MAP_ARRAY = 0x900B +gl_UNSIGNED_INT_IMAGE_CUBE_EXT :: GLenum +gl_UNSIGNED_INT_IMAGE_CUBE_EXT = 0x9066 +gl_DYNAMIC_DRAW_ARB :: GLenum +gl_DYNAMIC_DRAW_ARB = 0x88E8 +gl_RGBA_SNORM :: GLenum +gl_RGBA_SNORM = 0x8F93 +gl_MAX_UNIFORM_BLOCK_SIZE :: GLenum +gl_MAX_UNIFORM_BLOCK_SIZE = 0x8A30 +gl_FUNC_REVERSE_SUBTRACT_EXT :: GLenum +gl_FUNC_REVERSE_SUBTRACT_EXT = 0x800B +gl_STENCIL_BUFFER_BIT1_QCOM :: GLenum +gl_STENCIL_BUFFER_BIT1_QCOM = 0x00020000 +gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER = 0x8CDB +gl_TEXTURE_1D_BINDING_EXT :: GLenum +gl_TEXTURE_1D_BINDING_EXT = 0x8068 +gl_RGBA4_EXT :: GLenum +gl_RGBA4_EXT = 0x8056 +gl_PREFER_DOUBLEBUFFER_HINT_PGI :: GLenum +gl_PREFER_DOUBLEBUFFER_HINT_PGI = 0x1A1F8 +gl_UNKNOWN_CONTEXT_RESET_KHR :: GLenum +gl_UNKNOWN_CONTEXT_RESET_KHR = 0x8255 +gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES :: GLenum +gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_OES = 0x8E5C +gl_REFERENCED_BY_COMPUTE_SHADER :: GLenum +gl_REFERENCED_BY_COMPUTE_SHADER = 0x930B +gl_REG_17_ATI :: GLenum +gl_REG_17_ATI = 0x8932 +gl_BUFFER_FLUSHING_UNMAP_APPLE :: GLenum +gl_BUFFER_FLUSHING_UNMAP_APPLE = 0x8A13 +gl_UNIFORM :: GLenum +gl_UNIFORM = 0x92E1 +gl_TEXCOORD4_BIT_PGI :: GLenum +gl_TEXCOORD4_BIT_PGI = 0x80000000 +gl_BIAS_BY_NEGATIVE_ONE_HALF_NV :: GLenum +gl_BIAS_BY_NEGATIVE_ONE_HALF_NV = 0x8541 +gl_OP_FLOOR_EXT :: GLenum +gl_OP_FLOOR_EXT = 0x878F +gl_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV :: GLenum +gl_RGBA_UNSIGNED_DOT_PRODUCT_MAPPING_NV = 0x86D9 +gl_CURRENT_QUERY :: GLenum +gl_CURRENT_QUERY = 0x8865 +gl_UNIFORM_BUFFER_START :: GLenum +gl_UNIFORM_BUFFER_START = 0x8A29 +gl_DEBUG_SEVERITY_HIGH_KHR :: GLenum +gl_DEBUG_SEVERITY_HIGH_KHR = 0x9146 +gl_T2F_C4UB_V3F :: GLenum +gl_T2F_C4UB_V3F = 0x2A29 +gl_FONT_GLYPHS_AVAILABLE_NV :: GLenum +gl_FONT_GLYPHS_AVAILABLE_NV = 0x9368 +gl_MAX_CONVOLUTION_HEIGHT_EXT :: GLenum +gl_MAX_CONVOLUTION_HEIGHT_EXT = 0x801B +gl_STENCIL_BUFFER_BIT3_QCOM :: GLenum +gl_STENCIL_BUFFER_BIT3_QCOM = 0x00080000 +gl_MAP1_VERTEX_ATTRIB3_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB3_4_NV = 0x8663 +gl_BLEND_EQUATION_ALPHA_EXT :: GLenum +gl_BLEND_EQUATION_ALPHA_EXT = 0x883D +gl_RGB_FLOAT32_APPLE :: GLenum +gl_RGB_FLOAT32_APPLE = 0x8815 +gl_CONSTANT_BORDER :: GLenum +gl_CONSTANT_BORDER = 0x8151 +gl_CON_0_ATI :: GLenum +gl_CON_0_ATI = 0x8941 +gl_VERTEX_ARRAY_RANGE_POINTER_NV :: GLenum +gl_VERTEX_ARRAY_RANGE_POINTER_NV = 0x8521 +gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV :: GLenum +gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8852 +gl_INTERLACE_SGIX :: GLenum +gl_INTERLACE_SGIX = 0x8094 +gl_UNPACK_CONSTANT_DATA_SUNX :: GLenum +gl_UNPACK_CONSTANT_DATA_SUNX = 0x81D5 +gl_VERTEX_BINDING_STRIDE :: GLenum +gl_VERTEX_BINDING_STRIDE = 0x82D8 +gl_IS_PER_PATCH :: GLenum +gl_IS_PER_PATCH = 0x92E7 +gl_AVERAGE_HP :: GLenum +gl_AVERAGE_HP = 0x8160 +gl_MAX_VERTEX_ATTRIBS :: GLenum +gl_MAX_VERTEX_ATTRIBS = 0x8869 +gl_MAX_SAMPLES_ANGLE :: GLenum +gl_MAX_SAMPLES_ANGLE = 0x8D57 +gl_RED_EXT :: GLenum +gl_RED_EXT = 0x1903 +gl_MAP1_NORMAL :: GLenum +gl_MAP1_NORMAL = 0x0D92 +gl_TEXTURE_COMPRESSED_BLOCK_HEIGHT :: GLenum +gl_TEXTURE_COMPRESSED_BLOCK_HEIGHT = 0x82B2 +gl_MIN_SAMPLE_SHADING_VALUE_ARB :: GLenum +gl_MIN_SAMPLE_SHADING_VALUE_ARB = 0x8C37 +gl_COMPRESSED_SLUMINANCE_EXT :: GLenum +gl_COMPRESSED_SLUMINANCE_EXT = 0x8C4A +gl_RGBA4 :: GLenum +gl_RGBA4 = 0x8056 +gl_TEXTURE_VIEW_MIN_LAYER :: GLenum +gl_TEXTURE_VIEW_MIN_LAYER = 0x82DD +gl_ONE_EXT :: GLenum +gl_ONE_EXT = 0x87DE +gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES :: GLenum +gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES = 0x9277 +gl_MODELVIEW31_ARB :: GLenum +gl_MODELVIEW31_ARB = 0x873F +gl_MAX_TEXTURE_IMAGE_UNITS :: GLenum +gl_MAX_TEXTURE_IMAGE_UNITS = 0x8872 +gl_COLOR_ATTACHMENT3_NV :: GLenum +gl_COLOR_ATTACHMENT3_NV = 0x8CE3 +gl_LUMINANCE6_ALPHA2 :: GLenum +gl_LUMINANCE6_ALPHA2 = 0x8044 +gl_POINT_SPRITE_R_MODE_NV :: GLenum +gl_POINT_SPRITE_R_MODE_NV = 0x8863 +gl_COMPARE_REF_TO_TEXTURE :: GLenum +gl_COMPARE_REF_TO_TEXTURE = 0x884E +gl_MAX_PROJECTION_STACK_DEPTH :: GLenum +gl_MAX_PROJECTION_STACK_DEPTH = 0x0D38 +gl_BLEND_DST_ALPHA :: GLenum +gl_BLEND_DST_ALPHA = 0x80CA +gl_TEXTURE_1D_STACK_BINDING_MESAX :: GLenum +gl_TEXTURE_1D_STACK_BINDING_MESAX = 0x875D +gl_VERTEX_ATTRIB_ARRAY_LENGTH_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY_LENGTH_NV = 0x8F2A +gl_PROGRAM_PARAMETER_NV :: GLenum +gl_PROGRAM_PARAMETER_NV = 0x8644 +gl_VIDEO_CAPTURE_FRAME_WIDTH_NV :: GLenum +gl_VIDEO_CAPTURE_FRAME_WIDTH_NV = 0x9038 +gl_MATRIX21_ARB :: GLenum +gl_MATRIX21_ARB = 0x88D5 +gl_LIST_BASE :: GLenum +gl_LIST_BASE = 0x0B32 +gl_COLOR_ATTACHMENT5 :: GLenum +gl_COLOR_ATTACHMENT5 = 0x8CE5 +gl_VERTEX_ARRAY_BINDING_APPLE :: GLenum +gl_VERTEX_ARRAY_BINDING_APPLE = 0x85B5 +gl_RELATIVE_LARGE_CW_ARC_TO_NV :: GLenum +gl_RELATIVE_LARGE_CW_ARC_TO_NV = 0x19 +gl_MAX_DEFORMATION_ORDER_SGIX :: GLenum +gl_MAX_DEFORMATION_ORDER_SGIX = 0x8197 +gl_COVERAGE_AUTOMATIC_NV :: GLenum +gl_COVERAGE_AUTOMATIC_NV = 0x8ED7 +gl_FOG_FUNC_SGIS :: GLenum +gl_FOG_FUNC_SGIS = 0x812A +gl_SAMPLER_BUFFER_EXT :: GLenum +gl_SAMPLER_BUFFER_EXT = 0x8DC2 +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_EXT = 0x8CD2 +gl_RGB8 :: GLenum +gl_RGB8 = 0x8051 +gl_PRIMARY_COLOR_NV :: GLenum +gl_PRIMARY_COLOR_NV = 0x852C +gl_DEPTH_TEXTURE_MODE_ARB :: GLenum +gl_DEPTH_TEXTURE_MODE_ARB = 0x884B +gl_LUMINANCE12_ALPHA4 :: GLenum +gl_LUMINANCE12_ALPHA4 = 0x8046 +gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS :: GLenum +gl_MAX_TESS_EVALUATION_SHADER_STORAGE_BLOCKS = 0x90D9 +gl_TEXTURE_BUFFER_EXT :: GLenum +gl_TEXTURE_BUFFER_EXT = 0x8C2A +gl_LINK_STATUS :: GLenum +gl_LINK_STATUS = 0x8B82 +gl_VERTEX_SHADER_EXT :: GLenum +gl_VERTEX_SHADER_EXT = 0x8780 +gl_VERTEX_ARRAY_POINTER :: GLenum +gl_VERTEX_ARRAY_POINTER = 0x808E +gl_ONE_MINUS_SRC1_ALPHA :: GLenum +gl_ONE_MINUS_SRC1_ALPHA = 0x88FB +gl_TEXTURE_BUFFER_SIZE_EXT :: GLenum +gl_TEXTURE_BUFFER_SIZE_EXT = 0x919E +gl_DEBUG_SEVERITY_MEDIUM :: GLenum +gl_DEBUG_SEVERITY_MEDIUM = 0x9147 +gl_ASYNC_READ_PIXELS_SGIX :: GLenum +gl_ASYNC_READ_PIXELS_SGIX = 0x835E +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME = 0x8CD1 +gl_REPLACE_EXT :: GLenum +gl_REPLACE_EXT = 0x8062 +gl_DEBUG_SOURCE_APPLICATION_ARB :: GLenum +gl_DEBUG_SOURCE_APPLICATION_ARB = 0x824A +gl_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB :: GLenum +gl_MAX_COMPUTE_VARIABLE_GROUP_SIZE_ARB = 0x9345 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x3x3_OES = 0x93E1 +gl_BROWSER_DEFAULT_WEBGL :: GLenum +gl_BROWSER_DEFAULT_WEBGL = 0x9244 +gl_MULTISAMPLE_BUFFER_BIT0_QCOM :: GLenum +gl_MULTISAMPLE_BUFFER_BIT0_QCOM = 0x01000000 +gl_DUAL_ALPHA8_SGIS :: GLenum +gl_DUAL_ALPHA8_SGIS = 0x8111 +gl_COMPRESSED_RGB_FXT1_3DFX :: GLenum +gl_COMPRESSED_RGB_FXT1_3DFX = 0x86B0 +gl_BLEND_SRC_RGB_OES :: GLenum +gl_BLEND_SRC_RGB_OES = 0x80C9 +gl_T2F_IUI_V2F_EXT :: GLenum +gl_T2F_IUI_V2F_EXT = 0x81B1 +gl_DRAW_BUFFER13_ARB :: GLenum +gl_DRAW_BUFFER13_ARB = 0x8832 +gl_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV :: GLenum +gl_PATH_TRANSPOSE_MODELVIEW_MATRIX_NV = 0x84E3 +gl_TEXTURE_INTENSITY_TYPE_ARB :: GLenum +gl_TEXTURE_INTENSITY_TYPE_ARB = 0x8C15 +gl_DU8DV8_ATI :: GLenum +gl_DU8DV8_ATI = 0x877A +gl_MAP1_VERTEX_ATTRIB14_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB14_4_NV = 0x866E +gl_VARIANT_ARRAY_STRIDE_EXT :: GLenum +gl_VARIANT_ARRAY_STRIDE_EXT = 0x87E6 +gl_RGB_S3TC :: GLenum +gl_RGB_S3TC = 0x83A0 +gl_NORMAL_ARRAY_POINTER :: GLenum +gl_NORMAL_ARRAY_POINTER = 0x808F +gl_CONSTANT_ALPHA_EXT :: GLenum +gl_CONSTANT_ALPHA_EXT = 0x8003 +gl_COLOR_ATTACHMENT8_NV :: GLenum +gl_COLOR_ATTACHMENT8_NV = 0x8CE8 +gl_MAX_LIST_NESTING :: GLenum +gl_MAX_LIST_NESTING = 0x0B31 +gl_FRAMEBUFFER_UNDEFINED :: GLenum +gl_FRAMEBUFFER_UNDEFINED = 0x8219 +gl_ACTIVE_STENCIL_FACE_EXT :: GLenum +gl_ACTIVE_STENCIL_FACE_EXT = 0x8911 +gl_DEPTH_SCALE :: GLenum +gl_DEPTH_SCALE = 0x0D1E +gl_READ_PIXELS_FORMAT :: GLenum +gl_READ_PIXELS_FORMAT = 0x828D +gl_QUADS_EXT :: GLenum +gl_QUADS_EXT = 0x0007 +gl_MAX_COMBINED_SHADER_STORAGE_BLOCKS :: GLenum +gl_MAX_COMBINED_SHADER_STORAGE_BLOCKS = 0x90DC +gl_OUTPUT_VERTEX_EXT :: GLenum +gl_OUTPUT_VERTEX_EXT = 0x879A +gl_PROGRAM_ATTRIBS_ARB :: GLenum +gl_PROGRAM_ATTRIBS_ARB = 0x88AC +gl_MAP1_VERTEX_ATTRIB8_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB8_4_NV = 0x8668 +gl_INVALID_ENUM :: GLenum +gl_INVALID_ENUM = 0x0500 +gl_1PASS_EXT :: GLenum +gl_1PASS_EXT = 0x80A1 +gl_FUNC_ADD_EXT :: GLenum +gl_FUNC_ADD_EXT = 0x8006 +gl_DISTANCE_ATTENUATION_SGIS :: GLenum +gl_DISTANCE_ATTENUATION_SGIS = 0x8129 +gl_REG_3_ATI :: GLenum +gl_REG_3_ATI = 0x8924 +gl_INTERPOLATE :: GLenum +gl_INTERPOLATE = 0x8575 +gl_MITER_TRUNCATE_NV :: GLenum +gl_MITER_TRUNCATE_NV = 0x90A8 +gl_MAX_PROGRAM_NATIVE_ATTRIBS_ARB :: GLenum +gl_MAX_PROGRAM_NATIVE_ATTRIBS_ARB = 0x88AF +gl_CONTEXT_COMPATIBILITY_PROFILE_BIT :: GLenum +gl_CONTEXT_COMPATIBILITY_PROFILE_BIT = 0x00000002 +gl_MATRIX_STRIDE :: GLenum +gl_MATRIX_STRIDE = 0x92FF +gl_FONT_Y_MIN_BOUNDS_BIT_NV :: GLenum +gl_FONT_Y_MIN_BOUNDS_BIT_NV = 0x00020000 +gl_COMBINER_BIAS_NV :: GLenum +gl_COMBINER_BIAS_NV = 0x8549 +gl_TEXTURE_CUBE_MAP_POSITIVE_X_ARB :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_X_ARB = 0x8515 +gl_CIRCULAR_CW_ARC_TO_NV :: GLenum +gl_CIRCULAR_CW_ARC_TO_NV = 0xFA +gl_UNSIGNED_INT_IMAGE_1D_EXT :: GLenum +gl_UNSIGNED_INT_IMAGE_1D_EXT = 0x9062 +gl_BLUE_SCALE :: GLenum +gl_BLUE_SCALE = 0x0D1A +gl_OFFSET_TEXTURE_SCALE_NV :: GLenum +gl_OFFSET_TEXTURE_SCALE_NV = 0x86E2 +gl_OFFSET_TEXTURE_2D_NV :: GLenum +gl_OFFSET_TEXTURE_2D_NV = 0x86E8 +gl_INTERNALFORMAT_DEPTH_SIZE :: GLenum +gl_INTERNALFORMAT_DEPTH_SIZE = 0x8275 +gl_TIMEOUT_IGNORED :: GLenum +gl_TIMEOUT_IGNORED = 0xFFFFFFFFFFFFFFFF +gl_BGRA_EXT :: GLenum +gl_BGRA_EXT = 0x80E1 +gl_GEQUAL :: GLenum +gl_GEQUAL = 0x0206 +gl_EXCLUSION_KHR :: GLenum +gl_EXCLUSION_KHR = 0x92A0 +gl_LINES_ADJACENCY_ARB :: GLenum +gl_LINES_ADJACENCY_ARB = 0x000A +gl_MAX_COMPUTE_WORK_GROUP_COUNT :: GLenum +gl_MAX_COMPUTE_WORK_GROUP_COUNT = 0x91BE +gl_RENDERBUFFER_EXT :: GLenum +gl_RENDERBUFFER_EXT = 0x8D41 +gl_GENERATE_MIPMAP :: GLenum +gl_GENERATE_MIPMAP = 0x8191 +gl_SOURCE1_ALPHA_EXT :: GLenum +gl_SOURCE1_ALPHA_EXT = 0x8589 +gl_VERTEX_TEXTURE :: GLenum +gl_VERTEX_TEXTURE = 0x829B +gl_LIGHT1 :: GLenum +gl_LIGHT1 = 0x4001 +gl_STATIC_READ_ARB :: GLenum +gl_STATIC_READ_ARB = 0x88E5 +gl_INTERLACE_READ_INGR :: GLenum +gl_INTERLACE_READ_INGR = 0x8568 +gl_COMPRESSED_R11_EAC_OES :: GLenum +gl_COMPRESSED_R11_EAC_OES = 0x9270 +gl_FRAGMENT_SHADER_ARB :: GLenum +gl_FRAGMENT_SHADER_ARB = 0x8B30 +gl_CURRENT_RASTER_POSITION :: GLenum +gl_CURRENT_RASTER_POSITION = 0x0B07 +gl_WEIGHT_ARRAY_BUFFER_BINDING_OES :: GLenum +gl_WEIGHT_ARRAY_BUFFER_BINDING_OES = 0x889E +gl_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT :: GLenum +gl_MAX_TESS_CONTROL_INPUT_COMPONENTS_EXT = 0x886C +gl_RGB_FLOAT32_ATI :: GLenum +gl_RGB_FLOAT32_ATI = 0x8815 +gl_LUMINANCE16_ALPHA16_EXT :: GLenum +gl_LUMINANCE16_ALPHA16_EXT = 0x8048 +gl_RENDERBUFFER_WIDTH_EXT :: GLenum +gl_RENDERBUFFER_WIDTH_EXT = 0x8D42 +gl_DEPTH_RANGE :: GLenum +gl_DEPTH_RANGE = 0x0B70 +gl_4_BYTES :: GLenum +gl_4_BYTES = 0x1409 +gl_VERTEX_WEIGHTING_EXT :: GLenum +gl_VERTEX_WEIGHTING_EXT = 0x8509 +gl_TEXTURE_SWIZZLE_B :: GLenum +gl_TEXTURE_SWIZZLE_B = 0x8E44 +gl_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV :: GLenum +gl_DOT_PRODUCT_TEXTURE_CUBE_MAP_NV = 0x86F0 +gl_FEEDBACK_BUFFER_POINTER :: GLenum +gl_FEEDBACK_BUFFER_POINTER = 0x0DF0 +gl_CULL_VERTEX_IBM :: GLenum +gl_CULL_VERTEX_IBM = 103050 +gl_UNPACK_SKIP_VOLUMES_SGIS :: GLenum +gl_UNPACK_SKIP_VOLUMES_SGIS = 0x8132 +gl_PIXEL_CUBIC_WEIGHT_EXT :: GLenum +gl_PIXEL_CUBIC_WEIGHT_EXT = 0x8333 +gl_DECR_WRAP_EXT :: GLenum +gl_DECR_WRAP_EXT = 0x8508 +gl_TEXTURE31 :: GLenum +gl_TEXTURE31 = 0x84DF +gl_MAX_TESS_GEN_LEVEL :: GLenum +gl_MAX_TESS_GEN_LEVEL = 0x8E7E +gl_YCBAYCR8A_4224_NV :: GLenum +gl_YCBAYCR8A_4224_NV = 0x9032 +gl_POINT_SPRITE_OES :: GLenum +gl_POINT_SPRITE_OES = 0x8861 +gl_SAMPLER_EXTERNAL_OES :: GLenum +gl_SAMPLER_EXTERNAL_OES = 0x8D66 +gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT :: GLenum +gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT = 0x8F63 +gl_PIXEL_PACK_BUFFER_BINDING_ARB :: GLenum +gl_PIXEL_PACK_BUFFER_BINDING_ARB = 0x88ED +gl_DEBUG_CATEGORY_API_ERROR_AMD :: GLenum +gl_DEBUG_CATEGORY_API_ERROR_AMD = 0x9149 +gl_TEXCOORD3_BIT_PGI :: GLenum +gl_TEXCOORD3_BIT_PGI = 0x40000000 +gl_UNIFORM_BUFFER_EXT :: GLenum +gl_UNIFORM_BUFFER_EXT = 0x8DEE +gl_COMPRESSED_RGBA8_ETC2_EAC :: GLenum +gl_COMPRESSED_RGBA8_ETC2_EAC = 0x9278 +gl_COLOR_SUM_CLAMP_NV :: GLenum +gl_COLOR_SUM_CLAMP_NV = 0x854F +gl_SAMPLER_CUBE :: GLenum +gl_SAMPLER_CUBE = 0x8B60 +gl_FRACTIONAL_ODD :: GLenum +gl_FRACTIONAL_ODD = 0x8E7B +gl_ONE_MINUS_DST_COLOR :: GLenum +gl_ONE_MINUS_DST_COLOR = 0x0307 +gl_REG_9_ATI :: GLenum +gl_REG_9_ATI = 0x892A +gl_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV :: GLenum +gl_Z4Y12Z4CB12Z4Y12Z4CR12_422_NV = 0x9035 +gl_PIXEL_MAP_I_TO_G :: GLenum +gl_PIXEL_MAP_I_TO_G = 0x0C73 +gl_FOG_COORD_ARRAY_STRIDE :: GLenum +gl_FOG_COORD_ARRAY_STRIDE = 0x8455 +gl_TRIANGLES_ADJACENCY_EXT :: GLenum +gl_TRIANGLES_ADJACENCY_EXT = 0x000C +gl_DRAW_BUFFER14_EXT :: GLenum +gl_DRAW_BUFFER14_EXT = 0x8833 +gl_TEXTURE_COMPARE_MODE_ARB :: GLenum +gl_TEXTURE_COMPARE_MODE_ARB = 0x884C +gl_REFLECTION_MAP_OES :: GLenum +gl_REFLECTION_MAP_OES = 0x8512 +gl_WARPS_PER_SM_NV :: GLenum +gl_WARPS_PER_SM_NV = 0x933A +gl_QUERY_WAIT :: GLenum +gl_QUERY_WAIT = 0x8E13 +gl_COMPRESSED_SLUMINANCE_ALPHA :: GLenum +gl_COMPRESSED_SLUMINANCE_ALPHA = 0x8C4B +gl_MAP2_TEXTURE_COORD_3 :: GLenum +gl_MAP2_TEXTURE_COORD_3 = 0x0DB5 +gl_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV :: GLenum +gl_GLYPH_HORIZONTAL_BEARING_Y_BIT_NV = 0x08 +gl_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV :: GLenum +gl_DOT_PRODUCT_DIFFUSE_CUBE_MAP_NV = 0x86F1 +gl_INTENSITY_FLOAT32_ATI :: GLenum +gl_INTENSITY_FLOAT32_ATI = 0x8817 +gl_CLAMP_TO_BORDER_SGIS :: GLenum +gl_CLAMP_TO_BORDER_SGIS = 0x812D +gl_FIELDS_NV :: GLenum +gl_FIELDS_NV = 0x8E27 +gl_MAX_GEOMETRY_OUTPUT_VERTICES :: GLenum +gl_MAX_GEOMETRY_OUTPUT_VERTICES = 0x8DE0 +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER = 0x8CD4 +gl_INT_SAMPLER_CUBE_EXT :: GLenum +gl_INT_SAMPLER_CUBE_EXT = 0x8DCC +gl_SOURCE0_RGB_EXT :: GLenum +gl_SOURCE0_RGB_EXT = 0x8580 +gl_DRAW_BUFFER10_ATI :: GLenum +gl_DRAW_BUFFER10_ATI = 0x882F +gl_VERTEX_ATTRIB_ARRAY_INTEGER_EXT :: GLenum +gl_VERTEX_ATTRIB_ARRAY_INTEGER_EXT = 0x88FD +gl_COPY_WRITE_BUFFER_NV :: GLenum +gl_COPY_WRITE_BUFFER_NV = 0x8F37 +gl_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV :: GLenum +gl_TEXTURE_RENDERBUFFER_DATA_STORE_BINDING_NV = 0x8E54 +gl_LUMINANCE8_OES :: GLenum +gl_LUMINANCE8_OES = 0x8040 +gl_POST_CONVOLUTION_RED_BIAS_EXT :: GLenum +gl_POST_CONVOLUTION_RED_BIAS_EXT = 0x8020 +gl_HSL_COLOR_KHR :: GLenum +gl_HSL_COLOR_KHR = 0x92AF +gl_SAMPLE_MASK_VALUE_NV :: GLenum +gl_SAMPLE_MASK_VALUE_NV = 0x8E52 +gl_SLUMINANCE8_NV :: GLenum +gl_SLUMINANCE8_NV = 0x8C47 +gl_ASYNC_MARKER_SGIX :: GLenum +gl_ASYNC_MARKER_SGIX = 0x8329 +gl_TEXTURE17 :: GLenum +gl_TEXTURE17 = 0x84D1 +gl_SYNC_CL_EVENT_COMPLETE_ARB :: GLenum +gl_SYNC_CL_EVENT_COMPLETE_ARB = 0x8241 +gl_INVARIANT_VALUE_EXT :: GLenum +gl_INVARIANT_VALUE_EXT = 0x87EA +gl_BUMP_ROT_MATRIX_SIZE_ATI :: GLenum +gl_BUMP_ROT_MATRIX_SIZE_ATI = 0x8776 +gl_ACTIVE_VARYING_MAX_LENGTH_NV :: GLenum +gl_ACTIVE_VARYING_MAX_LENGTH_NV = 0x8C82 +gl_DEPTH_COMPONENT16 :: GLenum +gl_DEPTH_COMPONENT16 = 0x81A5 +gl_MODELVIEW25_ARB :: GLenum +gl_MODELVIEW25_ARB = 0x8739 +gl_SHADER_BINARY_VIV :: GLenum +gl_SHADER_BINARY_VIV = 0x8FC4 +gl_VERTEX_ARRAY_STRIDE_EXT :: GLenum +gl_VERTEX_ARRAY_STRIDE_EXT = 0x807C +gl_VERTEX_ATTRIB_ARRAY_POINTER_ARB :: GLenum +gl_VERTEX_ATTRIB_ARRAY_POINTER_ARB = 0x8645 +gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB :: GLenum +gl_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB = 0x00000004 +gl_MAX_PALETTE_MATRICES_ARB :: GLenum +gl_MAX_PALETTE_MATRICES_ARB = 0x8842 +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER :: GLenum +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_GEOMETRY_SHADER = 0x92CA +gl_DEPTH_COMPONENT32_ARB :: GLenum +gl_DEPTH_COMPONENT32_ARB = 0x81A7 +gl_PRESERVE_ATI :: GLenum +gl_PRESERVE_ATI = 0x8762 +gl_PIXEL_TEX_GEN_ALPHA_LS_SGIX :: GLenum +gl_PIXEL_TEX_GEN_ALPHA_LS_SGIX = 0x8189 +gl_VERTEX_PROGRAM_TWO_SIDE_NV :: GLenum +gl_VERTEX_PROGRAM_TWO_SIDE_NV = 0x8643 +gl_MAX_ELEMENTS_INDICES_EXT :: GLenum +gl_MAX_ELEMENTS_INDICES_EXT = 0x80E9 +gl_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS :: GLenum +gl_MAX_COMBINED_FRAGMENT_UNIFORM_COMPONENTS = 0x8A33 +gl_CONTEXT_LOST :: GLenum +gl_CONTEXT_LOST = 0x0507 +gl_VERTEX_SUBROUTINE_UNIFORM :: GLenum +gl_VERTEX_SUBROUTINE_UNIFORM = 0x92EE +gl_COMPRESSED_SRGB_EXT :: GLenum +gl_COMPRESSED_SRGB_EXT = 0x8C48 +gl_SAMPLER_2D_MULTISAMPLE_ARRAY :: GLenum +gl_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910B +gl_MAX_PROGRAM_ADDRESS_REGISTERS_ARB :: GLenum +gl_MAX_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B1 +gl_STENCIL_INDEX_OES :: GLenum +gl_STENCIL_INDEX_OES = 0x1901 +gl_PATH_INITIAL_END_CAP_NV :: GLenum +gl_PATH_INITIAL_END_CAP_NV = 0x9077 +gl_INTENSITY32F_ARB :: GLenum +gl_INTENSITY32F_ARB = 0x8817 +gl_SAMPLES_PASSED :: GLenum +gl_SAMPLES_PASSED = 0x8914 +gl_INT_IMAGE_2D_RECT_EXT :: GLenum +gl_INT_IMAGE_2D_RECT_EXT = 0x905A +gl_CLIP_PLANE2 :: GLenum +gl_CLIP_PLANE2 = 0x3002 +gl_PALETTE8_RGB8_OES :: GLenum +gl_PALETTE8_RGB8_OES = 0x8B95 +gl_ALPHA16I_EXT :: GLenum +gl_ALPHA16I_EXT = 0x8D8A +gl_VERTEX_ARRAY :: GLenum +gl_VERTEX_ARRAY = 0x8074 +gl_TEXTURE23_ARB :: GLenum +gl_TEXTURE23_ARB = 0x84D7 +gl_AMBIENT_AND_DIFFUSE :: GLenum +gl_AMBIENT_AND_DIFFUSE = 0x1602 +gl_MULTISAMPLE_BUFFER_BIT2_QCOM :: GLenum +gl_MULTISAMPLE_BUFFER_BIT2_QCOM = 0x04000000 +gl_LUMINANCE_FLOAT16_ATI :: GLenum +gl_LUMINANCE_FLOAT16_ATI = 0x881E +gl_INDEX_ARRAY_TYPE :: GLenum +gl_INDEX_ARRAY_TYPE = 0x8085 +gl_COMPATIBLE_SUBROUTINES :: GLenum +gl_COMPATIBLE_SUBROUTINES = 0x8E4B +gl_VERTEX4_BIT_PGI :: GLenum +gl_VERTEX4_BIT_PGI = 0x00000008 +gl_FOG_COORD_SRC :: GLenum +gl_FOG_COORD_SRC = 0x8450 +gl_FULL_SUPPORT :: GLenum +gl_FULL_SUPPORT = 0x82B7 +gl_STEREO :: GLenum +gl_STEREO = 0x0C33 +gl_LUMINANCE_ALPHA16UI_EXT :: GLenum +gl_LUMINANCE_ALPHA16UI_EXT = 0x8D7B +gl_ONE_MINUS_SRC_COLOR :: GLenum +gl_ONE_MINUS_SRC_COLOR = 0x0301 +gl_MAX_SHADER_STORAGE_BLOCK_SIZE :: GLenum +gl_MAX_SHADER_STORAGE_BLOCK_SIZE = 0x90DE +gl_REPLICATE_BORDER_HP :: GLenum +gl_REPLICATE_BORDER_HP = 0x8153 +gl_VERTEX_ATTRIB_MAP1_ORDER_APPLE :: GLenum +gl_VERTEX_ATTRIB_MAP1_ORDER_APPLE = 0x8A04 +gl_CPU_OPTIMIZED_QCOM :: GLenum +gl_CPU_OPTIMIZED_QCOM = 0x8FB1 +gl_FLOAT16_VEC2_NV :: GLenum +gl_FLOAT16_VEC2_NV = 0x8FF9 +gl_SAMPLE_ALPHA_TO_ONE_SGIS :: GLenum +gl_SAMPLE_ALPHA_TO_ONE_SGIS = 0x809F +gl_MAP2_VERTEX_ATTRIB12_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB12_4_NV = 0x867C +gl_COMBINER_MUX_SUM_NV :: GLenum +gl_COMBINER_MUX_SUM_NV = 0x8547 +gl_UNSIGNED_SHORT_5_6_5_REV_EXT :: GLenum +gl_UNSIGNED_SHORT_5_6_5_REV_EXT = 0x8364 +gl_TEXTURE20_ARB :: GLenum +gl_TEXTURE20_ARB = 0x84D4 +gl_DOT3_RGB :: GLenum +gl_DOT3_RGB = 0x86AE +gl_STENCIL_BUFFER_BIT0_QCOM :: GLenum +gl_STENCIL_BUFFER_BIT0_QCOM = 0x00010000 +gl_LO_SCALE_NV :: GLenum +gl_LO_SCALE_NV = 0x870F +gl_FONT_ASCENDER_BIT_NV :: GLenum +gl_FONT_ASCENDER_BIT_NV = 0x00200000 +gl_DRAW_BUFFER9_EXT :: GLenum +gl_DRAW_BUFFER9_EXT = 0x882E +gl_UNSIGNED_INT_2_10_10_10_REV :: GLenum +gl_UNSIGNED_INT_2_10_10_10_REV = 0x8368 +gl_BINNING_CONTROL_HINT_QCOM :: GLenum +gl_BINNING_CONTROL_HINT_QCOM = 0x8FB0 +gl_PROGRAM_TEMPORARIES_ARB :: GLenum +gl_PROGRAM_TEMPORARIES_ARB = 0x88A4 +gl_MODELVIEW27_ARB :: GLenum +gl_MODELVIEW27_ARB = 0x873B +gl_RGBA16F_EXT :: GLenum +gl_RGBA16F_EXT = 0x881A +gl_INDEX_ARRAY_TYPE_EXT :: GLenum +gl_INDEX_ARRAY_TYPE_EXT = 0x8085 +gl_MAX_VERTEX_SHADER_LOCALS_EXT :: GLenum +gl_MAX_VERTEX_SHADER_LOCALS_EXT = 0x87C9 +gl_TEXTURE_CUBE_MAP_POSITIVE_Z_OES :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_Z_OES = 0x8519 +gl_COMP_BIT_ATI :: GLenum +gl_COMP_BIT_ATI = 0x00000002 +gl_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT :: GLenum +gl_MAX_GEOMETRY_UNIFORM_BLOCKS_EXT = 0x8A2C +gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY :: GLenum +gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x9061 +gl_RGB10_A2_EXT :: GLenum +gl_RGB10_A2_EXT = 0x8059 +gl_MAP1_VERTEX_ATTRIB4_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB4_4_NV = 0x8664 +gl_FLOAT_VEC3 :: GLenum +gl_FLOAT_VEC3 = 0x8B51 +gl_DELETE_STATUS :: GLenum +gl_DELETE_STATUS = 0x8B80 +gl_PN_TRIANGLES_TESSELATION_LEVEL_ATI :: GLenum +gl_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F4 +gl_UNCORRELATED_NV :: GLenum +gl_UNCORRELATED_NV = 0x9282 +gl_RELATIVE_SMALL_CW_ARC_TO_NV :: GLenum +gl_RELATIVE_SMALL_CW_ARC_TO_NV = 0x15 +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT :: GLenum +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT = 0x8C4F +gl_RGB_FLOAT16_ATI :: GLenum +gl_RGB_FLOAT16_ATI = 0x881B +gl_DRAW_BUFFER7_ATI :: GLenum +gl_DRAW_BUFFER7_ATI = 0x882C +gl_COMBINE_ALPHA_ARB :: GLenum +gl_COMBINE_ALPHA_ARB = 0x8572 +gl_RESET_NOTIFICATION_STRATEGY_EXT :: GLenum +gl_RESET_NOTIFICATION_STRATEGY_EXT = 0x8256 +gl_DRAW_BUFFER10_NV :: GLenum +gl_DRAW_BUFFER10_NV = 0x882F +gl_READ_PIXEL_DATA_RANGE_POINTER_NV :: GLenum +gl_READ_PIXEL_DATA_RANGE_POINTER_NV = 0x887D +gl_TRANSFORM_FEEDBACK_ACTIVE :: GLenum +gl_TRANSFORM_FEEDBACK_ACTIVE = 0x8E24 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR = 0x93D4 +gl_PROGRAM_PIPELINE_BINDING :: GLenum +gl_PROGRAM_PIPELINE_BINDING = 0x825A +gl_SRGB8_ALPHA8 :: GLenum +gl_SRGB8_ALPHA8 = 0x8C43 +gl_COLOR_INDEX16_EXT :: GLenum +gl_COLOR_INDEX16_EXT = 0x80E7 +gl_PHONG_WIN :: GLenum +gl_PHONG_WIN = 0x80EA +gl_MAX_TEXTURE_IMAGE_UNITS_NV :: GLenum +gl_MAX_TEXTURE_IMAGE_UNITS_NV = 0x8872 +gl_DSDT8_MAG8_NV :: GLenum +gl_DSDT8_MAG8_NV = 0x870A +gl_COPY_READ_BUFFER :: GLenum +gl_COPY_READ_BUFFER = 0x8F36 +gl_RGBA16F :: GLenum +gl_RGBA16F = 0x881A +gl_UNSIGNED_SHORT_5_6_5 :: GLenum +gl_UNSIGNED_SHORT_5_6_5 = 0x8363 +gl_CLIP_DISTANCE5 :: GLenum +gl_CLIP_DISTANCE5 = 0x3005 +gl_TEXTURE_BINDING_3D_OES :: GLenum +gl_TEXTURE_BINDING_3D_OES = 0x806A +gl_IUI_V2F_EXT :: GLenum +gl_IUI_V2F_EXT = 0x81AD +gl_OFFSET_HILO_TEXTURE_RECTANGLE_NV :: GLenum +gl_OFFSET_HILO_TEXTURE_RECTANGLE_NV = 0x8855 +gl_ONE_MINUS_CONSTANT_ALPHA :: GLenum +gl_ONE_MINUS_CONSTANT_ALPHA = 0x8004 +gl_SMALL_CW_ARC_TO_NV :: GLenum +gl_SMALL_CW_ARC_TO_NV = 0x14 +gl_IMAGE_BINDING_NAME_EXT :: GLenum +gl_IMAGE_BINDING_NAME_EXT = 0x8F3A +gl_CURRENT_FOG_COORDINATE_EXT :: GLenum +gl_CURRENT_FOG_COORDINATE_EXT = 0x8453 +gl_SKIP_COMPONENTS4_NV :: GLenum +gl_SKIP_COMPONENTS4_NV = -3 +gl_CLIP_PLANE5_IMG :: GLenum +gl_CLIP_PLANE5_IMG = 0x3005 +gl_PATH_MITER_LIMIT_NV :: GLenum +gl_PATH_MITER_LIMIT_NV = 0x907A +gl_TEXTURE_3D :: GLenum +gl_TEXTURE_3D = 0x806F +gl_MAX_COMPUTE_SHADER_STORAGE_BLOCKS :: GLenum +gl_MAX_COMPUTE_SHADER_STORAGE_BLOCKS = 0x90DB +gl_COMPRESSED_LUMINANCE_LATC1_EXT :: GLenum +gl_COMPRESSED_LUMINANCE_LATC1_EXT = 0x8C70 +gl_MULTISAMPLE_BUFFER_BIT3_QCOM :: GLenum +gl_MULTISAMPLE_BUFFER_BIT3_QCOM = 0x08000000 +gl_SECONDARY_COLOR_ARRAY_SIZE :: GLenum +gl_SECONDARY_COLOR_ARRAY_SIZE = 0x845A +gl_RENDERBUFFER_SAMPLES_IMG :: GLenum +gl_RENDERBUFFER_SAMPLES_IMG = 0x9133 +gl_R1UI_C4UB_V3F_SUN :: GLenum +gl_R1UI_C4UB_V3F_SUN = 0x85C5 +gl_PIXEL_TEX_GEN_ALPHA_MS_SGIX :: GLenum +gl_PIXEL_TEX_GEN_ALPHA_MS_SGIX = 0x818A +gl_TRANSFORM_FEEDBACK_NV :: GLenum +gl_TRANSFORM_FEEDBACK_NV = 0x8E22 +gl_FRAMEBUFFER_RENDERABLE :: GLenum +gl_FRAMEBUFFER_RENDERABLE = 0x8289 +gl_HARDLIGHT_KHR :: GLenum +gl_HARDLIGHT_KHR = 0x929B +gl_SOURCE0_ALPHA :: GLenum +gl_SOURCE0_ALPHA = 0x8588 +gl_COMBINER4_NV :: GLenum +gl_COMBINER4_NV = 0x8554 +gl_ELEMENT_ARRAY_BUFFER_BINDING :: GLenum +gl_ELEMENT_ARRAY_BUFFER_BINDING = 0x8895 +gl_TEXTURE10_ARB :: GLenum +gl_TEXTURE10_ARB = 0x84CA +gl_CURRENT_BINORMAL_EXT :: GLenum +gl_CURRENT_BINORMAL_EXT = 0x843C +gl_REG_26_ATI :: GLenum +gl_REG_26_ATI = 0x893B +gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS :: GLenum +gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = 0x8DE1 +gl_ACTIVE_VARYINGS_NV :: GLenum +gl_ACTIVE_VARYINGS_NV = 0x8C81 +gl_COMBINE_RGB_EXT :: GLenum +gl_COMBINE_RGB_EXT = 0x8571 +gl_FRAMEBUFFER_COMPLETE_EXT :: GLenum +gl_FRAMEBUFFER_COMPLETE_EXT = 0x8CD5 +gl_MAX_WIDTH :: GLenum +gl_MAX_WIDTH = 0x827E +gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS :: GLenum +gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTERS = 0x92C5 +gl_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT :: GLenum +gl_MAX_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87C8 +gl_COLORDODGE_KHR :: GLenum +gl_COLORDODGE_KHR = 0x9299 +gl_PATH_GEN_COEFF_NV :: GLenum +gl_PATH_GEN_COEFF_NV = 0x90B1 +gl_FLOAT_MAT4x3_NV :: GLenum +gl_FLOAT_MAT4x3_NV = 0x8B6A +gl_MINMAX_SINK :: GLenum +gl_MINMAX_SINK = 0x8030 +gl_FRONT_AND_BACK :: GLenum +gl_FRONT_AND_BACK = 0x0408 +gl_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT :: GLenum +gl_MAX_GEOMETRY_SHADER_INVOCATIONS_EXT = 0x8E5A +gl_MATRIX1_ARB :: GLenum +gl_MATRIX1_ARB = 0x88C1 +gl_VIEWPORT_SUBPIXEL_BITS :: GLenum +gl_VIEWPORT_SUBPIXEL_BITS = 0x825C +gl_MAX_DUAL_SOURCE_DRAW_BUFFERS :: GLenum +gl_MAX_DUAL_SOURCE_DRAW_BUFFERS = 0x88FC +gl_BOOL_VEC3_ARB :: GLenum +gl_BOOL_VEC3_ARB = 0x8B58 +gl_OPERAND2_ALPHA :: GLenum +gl_OPERAND2_ALPHA = 0x859A +gl_MAX_DEBUG_GROUP_STACK_DEPTH :: GLenum +gl_MAX_DEBUG_GROUP_STACK_DEPTH = 0x826C +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR = 0x93DC +gl_PROGRAM :: GLenum +gl_PROGRAM = 0x82E2 +gl_WEIGHT_ARRAY_SIZE_ARB :: GLenum +gl_WEIGHT_ARRAY_SIZE_ARB = 0x86AB +gl_BUFFER_GPU_ADDRESS_NV :: GLenum +gl_BUFFER_GPU_ADDRESS_NV = 0x8F1D +gl_ALPHA8_EXT :: GLenum +gl_ALPHA8_EXT = 0x803C +gl_RGBA_MODE :: GLenum +gl_RGBA_MODE = 0x0C31 +gl_DUDV_ATI :: GLenum +gl_DUDV_ATI = 0x8779 +gl_VERTEX_ATTRIB_ARRAY_INTEGER_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY_INTEGER_NV = 0x88FD +gl_RESAMPLE_DECIMATE_OML :: GLenum +gl_RESAMPLE_DECIMATE_OML = 0x8989 +gl_QUERY_BUFFER :: GLenum +gl_QUERY_BUFFER = 0x9192 +gl_SINGLE_COLOR :: GLenum +gl_SINGLE_COLOR = 0x81F9 +gl_INT_SAMPLER_RENDERBUFFER_NV :: GLenum +gl_INT_SAMPLER_RENDERBUFFER_NV = 0x8E57 +gl_MAT_COLOR_INDEXES_BIT_PGI :: GLenum +gl_MAT_COLOR_INDEXES_BIT_PGI = 0x01000000 +gl_MODELVIEW3_ARB :: GLenum +gl_MODELVIEW3_ARB = 0x8723 +gl_TESS_CONTROL_OUTPUT_VERTICES_EXT :: GLenum +gl_TESS_CONTROL_OUTPUT_VERTICES_EXT = 0x8E75 +gl_PIXEL_MAP_B_TO_B :: GLenum +gl_PIXEL_MAP_B_TO_B = 0x0C78 +gl_VERTEX_ATTRIB_MAP1_SIZE_APPLE :: GLenum +gl_VERTEX_ATTRIB_MAP1_SIZE_APPLE = 0x8A02 +gl_DOUBLE_MAT3 :: GLenum +gl_DOUBLE_MAT3 = 0x8F47 +gl_MAX_COMBINED_UNIFORM_BLOCKS :: GLenum +gl_MAX_COMBINED_UNIFORM_BLOCKS = 0x8A2E +gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT :: GLenum +gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_EXT = 0x900D +gl_MAX_VERTEX_IMAGE_UNIFORMS :: GLenum +gl_MAX_VERTEX_IMAGE_UNIFORMS = 0x90CA +gl_QUERY_RESULT_NO_WAIT_AMD :: GLenum +gl_QUERY_RESULT_NO_WAIT_AMD = 0x9194 +gl_MODELVIEW26_ARB :: GLenum +gl_MODELVIEW26_ARB = 0x873A +gl_DEPTH_COMPONENT24_OES :: GLenum +gl_DEPTH_COMPONENT24_OES = 0x81A6 +gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB :: GLenum +gl_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB = 0x8E8E +gl_EVAL_VERTEX_ATTRIB6_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB6_NV = 0x86CC +gl_OUTPUT_TEXTURE_COORD24_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD24_EXT = 0x87B5 +gl_COMPUTE_SHADER_BIT :: GLenum +gl_COMPUTE_SHADER_BIT = 0x00000020 +gl_MATRIX7_ARB :: GLenum +gl_MATRIX7_ARB = 0x88C7 +gl_RENDER :: GLenum +gl_RENDER = 0x1C00 +gl_VERTEX_ATTRIB_BINDING :: GLenum +gl_VERTEX_ATTRIB_BINDING = 0x82D4 +gl_VIDEO_CAPTURE_TO_422_SUPPORTED_NV :: GLenum +gl_VIDEO_CAPTURE_TO_422_SUPPORTED_NV = 0x9026 +gl_TEXTURE_COORD_ARRAY_ADDRESS_NV :: GLenum +gl_TEXTURE_COORD_ARRAY_ADDRESS_NV = 0x8F25 +gl_UNSIGNED_INT_SAMPLER_2D_RECT :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D_RECT = 0x8DD5 +gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB :: GLenum +gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_ARB = 0x8C29 +gl_GENERATE_MIPMAP_SGIS :: GLenum +gl_GENERATE_MIPMAP_SGIS = 0x8191 +gl_SHADER_IMAGE_STORE :: GLenum +gl_SHADER_IMAGE_STORE = 0x82A5 +gl_INT_SAMPLER_3D :: GLenum +gl_INT_SAMPLER_3D = 0x8DCB +gl_PROGRAM_BINARY_LENGTH :: GLenum +gl_PROGRAM_BINARY_LENGTH = 0x8741 +gl_REFERENCED_BY_GEOMETRY_SHADER :: GLenum +gl_REFERENCED_BY_GEOMETRY_SHADER = 0x9309 +gl_SHADER_IMAGE_ACCESS_BARRIER_BIT :: GLenum +gl_SHADER_IMAGE_ACCESS_BARRIER_BIT = 0x00000020 +gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS :: GLenum +gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS = 0x92D3 +gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT :: GLenum +gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT = 0x919F +gl_LINE :: GLenum +gl_LINE = 0x1B01 +gl_RENDERBUFFER_ALPHA_SIZE_EXT :: GLenum +gl_RENDERBUFFER_ALPHA_SIZE_EXT = 0x8D53 +gl_INTENSITY :: GLenum +gl_INTENSITY = 0x8049 +gl_AFFINE_3D_NV :: GLenum +gl_AFFINE_3D_NV = 0x9094 +gl_ADD_SIGNED_ARB :: GLenum +gl_ADD_SIGNED_ARB = 0x8574 +gl_OBJECT_COMPILE_STATUS_ARB :: GLenum +gl_OBJECT_COMPILE_STATUS_ARB = 0x8B81 +gl_RGB8I_EXT :: GLenum +gl_RGB8I_EXT = 0x8D8F +gl_COMMAND_BARRIER_BIT :: GLenum +gl_COMMAND_BARRIER_BIT = 0x00000040 +gl_COMBINE_RGB :: GLenum +gl_COMBINE_RGB = 0x8571 +gl_VERTEX_SHADER_BINDING_EXT :: GLenum +gl_VERTEX_SHADER_BINDING_EXT = 0x8781 +gl_SECONDARY_COLOR_ARRAY_SIZE_EXT :: GLenum +gl_SECONDARY_COLOR_ARRAY_SIZE_EXT = 0x845A +gl_DEPTH_EXT :: GLenum +gl_DEPTH_EXT = 0x1801 +gl_LINE_RESET_TOKEN :: GLenum +gl_LINE_RESET_TOKEN = 0x0707 +gl_SMOOTH_POINT_SIZE_GRANULARITY :: GLenum +gl_SMOOTH_POINT_SIZE_GRANULARITY = 0x0B13 +gl_SAMPLER_2D_MULTISAMPLE :: GLenum +gl_SAMPLER_2D_MULTISAMPLE = 0x9108 +gl_PRIMARY_COLOR_ARB :: GLenum +gl_PRIMARY_COLOR_ARB = 0x8577 +gl_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY :: GLenum +gl_PROXY_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9103 +gl_GEOMETRY_TEXTURE :: GLenum +gl_GEOMETRY_TEXTURE = 0x829E +gl_SOURCE1_RGB_ARB :: GLenum +gl_SOURCE1_RGB_ARB = 0x8581 +gl_COLOR_ATTACHMENT6_EXT :: GLenum +gl_COLOR_ATTACHMENT6_EXT = 0x8CE6 +gl_PIXEL_MAP_I_TO_I :: GLenum +gl_PIXEL_MAP_I_TO_I = 0x0C70 +gl_EVAL_VERTEX_ATTRIB7_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB7_NV = 0x86CD +gl_OP_MIN_EXT :: GLenum +gl_OP_MIN_EXT = 0x878B +gl_RGB16F_EXT :: GLenum +gl_RGB16F_EXT = 0x881B +gl_TEXTURE_CUBE_MAP_POSITIVE_Z :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_Z = 0x8519 +gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS :: GLenum +gl_MAX_COMBINED_IMAGE_UNITS_AND_FRAGMENT_OUTPUTS = 0x8F39 +gl_PACK_RESAMPLE_SGIX :: GLenum +gl_PACK_RESAMPLE_SGIX = 0x842C +gl_GREEN_BIAS :: GLenum +gl_GREEN_BIAS = 0x0D19 +gl_DEPTH_STENCIL_NV :: GLenum +gl_DEPTH_STENCIL_NV = 0x84F9 +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER :: GLenum +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_TESS_CONTROL_SHADER = 0x92C8 +gl_CON_29_ATI :: GLenum +gl_CON_29_ATI = 0x895E +gl_COLOR_ARRAY_STRIDE_EXT :: GLenum +gl_COLOR_ARRAY_STRIDE_EXT = 0x8083 +gl_ISOLINES_EXT :: GLenum +gl_ISOLINES_EXT = 0x8E7A +gl_MODELVIEW4_ARB :: GLenum +gl_MODELVIEW4_ARB = 0x8724 +gl_LINES_ADJACENCY :: GLenum +gl_LINES_ADJACENCY = 0x000A +gl_PATH_FILL_MASK_NV :: GLenum +gl_PATH_FILL_MASK_NV = 0x9081 +gl_HISTOGRAM_LUMINANCE_SIZE :: GLenum +gl_HISTOGRAM_LUMINANCE_SIZE = 0x802C +gl_TEXTURE_BINDING_RENDERBUFFER_NV :: GLenum +gl_TEXTURE_BINDING_RENDERBUFFER_NV = 0x8E53 +gl_PIXEL_UNPACK_BUFFER_EXT :: GLenum +gl_PIXEL_UNPACK_BUFFER_EXT = 0x88EC +gl_RENDERBUFFER_GREEN_SIZE :: GLenum +gl_RENDERBUFFER_GREEN_SIZE = 0x8D51 +gl_PASS_THROUGH_NV :: GLenum +gl_PASS_THROUGH_NV = 0x86E6 +gl_GEOMETRY_VERTICES_OUT_EXT :: GLenum +gl_GEOMETRY_VERTICES_OUT_EXT = 0x8DDA +gl_EVAL_VERTEX_ATTRIB12_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB12_NV = 0x86D2 +gl_SMOOTH_QUADRATIC_CURVE_TO_NV :: GLenum +gl_SMOOTH_QUADRATIC_CURVE_TO_NV = 0x0E +gl_TEXTURE_BUFFER_SIZE :: GLenum +gl_TEXTURE_BUFFER_SIZE = 0x919E +gl_READ_PIXEL_DATA_RANGE_NV :: GLenum +gl_READ_PIXEL_DATA_RANGE_NV = 0x8879 +gl_ALIASED_LINE_WIDTH_RANGE :: GLenum +gl_ALIASED_LINE_WIDTH_RANGE = 0x846E +gl_TRACK_MATRIX_NV :: GLenum +gl_TRACK_MATRIX_NV = 0x8648 +gl_COLOR_ARRAY_LIST_STRIDE_IBM :: GLenum +gl_COLOR_ARRAY_LIST_STRIDE_IBM = 103082 +gl_WEIGHT_ARRAY_POINTER_ARB :: GLenum +gl_WEIGHT_ARRAY_POINTER_ARB = 0x86AC +gl_SMOOTH_LINE_WIDTH_GRANULARITY :: GLenum +gl_SMOOTH_LINE_WIDTH_GRANULARITY = 0x0B23 +gl_CLIP_DISTANCE6 :: GLenum +gl_CLIP_DISTANCE6 = 0x3006 +gl_FRAMEBUFFER_BINDING :: GLenum +gl_FRAMEBUFFER_BINDING = 0x8CA6 +gl_EVAL_VERTEX_ATTRIB4_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB4_NV = 0x86CA +gl_CURRENT_SECONDARY_COLOR_EXT :: GLenum +gl_CURRENT_SECONDARY_COLOR_EXT = 0x8459 +gl_IMAGE_CLASS_2_X_32 :: GLenum +gl_IMAGE_CLASS_2_X_32 = 0x82BA +gl_PERSPECTIVE_CORRECTION_HINT :: GLenum +gl_PERSPECTIVE_CORRECTION_HINT = 0x0C50 +gl_NATIVE_GRAPHICS_BEGIN_HINT_PGI :: GLenum +gl_NATIVE_GRAPHICS_BEGIN_HINT_PGI = 0x1A203 +gl_SATURATE_BIT_ATI :: GLenum +gl_SATURATE_BIT_ATI = 0x00000040 +gl_FONT_UNITS_PER_EM_BIT_NV :: GLenum +gl_FONT_UNITS_PER_EM_BIT_NV = 0x00100000 +gl_EVAL_VERTEX_ATTRIB3_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB3_NV = 0x86C9 +gl_R16UI :: GLenum +gl_R16UI = 0x8234 +gl_OUTPUT_TEXTURE_COORD17_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD17_EXT = 0x87AE +gl_TEXTURE_MULTI_BUFFER_HINT_SGIX :: GLenum +gl_TEXTURE_MULTI_BUFFER_HINT_SGIX = 0x812E +gl_SKIP_MISSING_GLYPH_NV :: GLenum +gl_SKIP_MISSING_GLYPH_NV = 0x90A9 +gl_MIRROR_CLAMP_TO_EDGE_EXT :: GLenum +gl_MIRROR_CLAMP_TO_EDGE_EXT = 0x8743 +gl_TEXTURE_TYPE_QCOM :: GLenum +gl_TEXTURE_TYPE_QCOM = 0x8BD7 +gl_RGB5_A1 :: GLenum +gl_RGB5_A1 = 0x8057 +gl_UNIFORM_BARRIER_BIT_EXT :: GLenum +gl_UNIFORM_BARRIER_BIT_EXT = 0x00000004 +gl_MULTISAMPLE :: GLenum +gl_MULTISAMPLE = 0x809D +gl_SAMPLES_ARB :: GLenum +gl_SAMPLES_ARB = 0x80A9 +gl_RGBA_INTEGER :: GLenum +gl_RGBA_INTEGER = 0x8D99 +gl_STENCIL_COMPONENTS :: GLenum +gl_STENCIL_COMPONENTS = 0x8285 +gl_DEBUG_SEVERITY_LOW :: GLenum +gl_DEBUG_SEVERITY_LOW = 0x9148 +gl_TEXTURE_COMPARE_SGIX :: GLenum +gl_TEXTURE_COMPARE_SGIX = 0x819A +gl_COLOR_ARRAY_LIST_IBM :: GLenum +gl_COLOR_ARRAY_LIST_IBM = 103072 +gl_COMPRESSED_SIGNED_RED_RGTC1 :: GLenum +gl_COMPRESSED_SIGNED_RED_RGTC1 = 0x8DBC +gl_MATRIX3_NV :: GLenum +gl_MATRIX3_NV = 0x8633 +gl_MAX_FRAGMENT_UNIFORM_BLOCKS :: GLenum +gl_MAX_FRAGMENT_UNIFORM_BLOCKS = 0x8A2D +gl_INT_SAMPLER_3D_EXT :: GLenum +gl_INT_SAMPLER_3D_EXT = 0x8DCB +gl_MODELVIEW19_ARB :: GLenum +gl_MODELVIEW19_ARB = 0x8733 +gl_SWIZZLE_STRQ_DQ_ATI :: GLenum +gl_SWIZZLE_STRQ_DQ_ATI = 0x897B +gl_COMBINE_ARB :: GLenum +gl_COMBINE_ARB = 0x8570 +gl_FRAGMENT_COLOR_EXT :: GLenum +gl_FRAGMENT_COLOR_EXT = 0x834C +gl_RENDERBUFFER_WIDTH :: GLenum +gl_RENDERBUFFER_WIDTH = 0x8D42 +gl_LUMINANCE4_EXT :: GLenum +gl_LUMINANCE4_EXT = 0x803F +gl_UNSIGNED_INT_SAMPLER_2D_EXT :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D_EXT = 0x8DD2 +gl_RGB_SCALE_EXT :: GLenum +gl_RGB_SCALE_EXT = 0x8573 +gl_PIXEL_MAP_I_TO_R :: GLenum +gl_PIXEL_MAP_I_TO_R = 0x0C72 +gl_DOT4_ATI :: GLenum +gl_DOT4_ATI = 0x8967 +gl_MAP1_VERTEX_ATTRIB7_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB7_4_NV = 0x8667 +gl_VERTEX_ATTRIB_ARRAY_ENABLED_ARB :: GLenum +gl_VERTEX_ATTRIB_ARRAY_ENABLED_ARB = 0x8622 +gl_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB :: GLenum +gl_MAX_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x880C +gl_POST_COLOR_MATRIX_BLUE_SCALE_SGI :: GLenum +gl_POST_COLOR_MATRIX_BLUE_SCALE_SGI = 0x80B6 +gl_NUM_VIRTUAL_PAGE_SIZES_ARB :: GLenum +gl_NUM_VIRTUAL_PAGE_SIZES_ARB = 0x91A8 +gl_RENDERBUFFER_FREE_MEMORY_ATI :: GLenum +gl_RENDERBUFFER_FREE_MEMORY_ATI = 0x87FD +gl_FRAMEBUFFER_DEFAULT_LAYERS :: GLenum +gl_FRAMEBUFFER_DEFAULT_LAYERS = 0x9312 +gl_COMPUTE_SUBROUTINE :: GLenum +gl_COMPUTE_SUBROUTINE = 0x92ED +gl_PROGRAM_TEX_INSTRUCTIONS_ARB :: GLenum +gl_PROGRAM_TEX_INSTRUCTIONS_ARB = 0x8806 +gl_SIGNALED_APPLE :: GLenum +gl_SIGNALED_APPLE = 0x9119 +gl_MULTISAMPLE_3DFX :: GLenum +gl_MULTISAMPLE_3DFX = 0x86B2 +gl_TEXTURE_INDEX_SIZE_EXT :: GLenum +gl_TEXTURE_INDEX_SIZE_EXT = 0x80ED +gl_LAYOUT_LINEAR_INTEL :: GLenum +gl_LAYOUT_LINEAR_INTEL = 1 +gl_LERP_ATI :: GLenum +gl_LERP_ATI = 0x8969 +gl_FACTOR_MAX_AMD :: GLenum +gl_FACTOR_MAX_AMD = 0x901D +gl_MATRIX2_ARB :: GLenum +gl_MATRIX2_ARB = 0x88C2 +gl_EQUAL :: GLenum +gl_EQUAL = 0x0202 +gl_COLOR_ATTACHMENT0_OES :: GLenum +gl_COLOR_ATTACHMENT0_OES = 0x8CE0 +gl_MAX_COLOR_MATRIX_STACK_DEPTH_SGI :: GLenum +gl_MAX_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B3 +gl_RGB16 :: GLenum +gl_RGB16 = 0x8054 +gl_COLOR_INDEX4_EXT :: GLenum +gl_COLOR_INDEX4_EXT = 0x80E4 +gl_PROXY_TEXTURE_CUBE_MAP_EXT :: GLenum +gl_PROXY_TEXTURE_CUBE_MAP_EXT = 0x851B +gl_STENCIL_BACK_FUNC_ATI :: GLenum +gl_STENCIL_BACK_FUNC_ATI = 0x8800 +gl_DRAW_BUFFER8_EXT :: GLenum +gl_DRAW_BUFFER8_EXT = 0x882D +gl_DST_ALPHA :: GLenum +gl_DST_ALPHA = 0x0304 +gl_DEBUG_SOURCE_SHADER_COMPILER_KHR :: GLenum +gl_DEBUG_SOURCE_SHADER_COMPILER_KHR = 0x8248 +gl_C4UB_V2F :: GLenum +gl_C4UB_V2F = 0x2A22 +gl_INTERNALFORMAT_BLUE_TYPE :: GLenum +gl_INTERNALFORMAT_BLUE_TYPE = 0x827A +gl_PIXEL_TILE_GRID_DEPTH_SGIX :: GLenum +gl_PIXEL_TILE_GRID_DEPTH_SGIX = 0x8144 +gl_DEPTH_BITS :: GLenum +gl_DEPTH_BITS = 0x0D56 +gl_FLOAT16_VEC3_NV :: GLenum +gl_FLOAT16_VEC3_NV = 0x8FFA +gl_ARRAY_OBJECT_OFFSET_ATI :: GLenum +gl_ARRAY_OBJECT_OFFSET_ATI = 0x8767 +gl_DOUBLE_MAT2_EXT :: GLenum +gl_DOUBLE_MAT2_EXT = 0x8F46 +gl_TEXTURE_COLOR_SAMPLES_NV :: GLenum +gl_TEXTURE_COLOR_SAMPLES_NV = 0x9046 +gl_NORMAL_ARRAY_EXT :: GLenum +gl_NORMAL_ARRAY_EXT = 0x8075 +gl_MIRROR_CLAMP_TO_EDGE_ATI :: GLenum +gl_MIRROR_CLAMP_TO_EDGE_ATI = 0x8743 +gl_EDGE_FLAG_ARRAY_POINTER :: GLenum +gl_EDGE_FLAG_ARRAY_POINTER = 0x8093 +gl_UNSIGNED_INT_24_8_MESA :: GLenum +gl_UNSIGNED_INT_24_8_MESA = 0x8751 +gl_IMAGE_COMPATIBILITY_CLASS :: GLenum +gl_IMAGE_COMPATIBILITY_CLASS = 0x82A8 +gl_BACK_LEFT :: GLenum +gl_BACK_LEFT = 0x0402 +gl_TESS_EVALUATION_SHADER_INVOCATIONS_ARB :: GLenum +gl_TESS_EVALUATION_SHADER_INVOCATIONS_ARB = 0x82F2 +gl_COLOR_TABLE_BIAS :: GLenum +gl_COLOR_TABLE_BIAS = 0x80D7 +gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG :: GLenum +gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV2_IMG = 0x93F1 +gl_DARKEN_KHR :: GLenum +gl_DARKEN_KHR = 0x9297 +gl_OCCLUSION_TEST_RESULT_HP :: GLenum +gl_OCCLUSION_TEST_RESULT_HP = 0x8166 +gl_DEBUG_TYPE_POP_GROUP_KHR :: GLenum +gl_DEBUG_TYPE_POP_GROUP_KHR = 0x826A +gl_CLAMP_TO_BORDER_ARB :: GLenum +gl_CLAMP_TO_BORDER_ARB = 0x812D +gl_UNSIGNED_BYTE_2_3_3_REV :: GLenum +gl_UNSIGNED_BYTE_2_3_3_REV = 0x8362 +gl_SOURCE2_ALPHA_ARB :: GLenum +gl_SOURCE2_ALPHA_ARB = 0x858A +gl_SAMPLE_COVERAGE :: GLenum +gl_SAMPLE_COVERAGE = 0x80A0 +gl_INTERLEAVED_ATTRIBS_EXT :: GLenum +gl_INTERLEAVED_ATTRIBS_EXT = 0x8C8C +gl_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL :: GLenum +gl_PERFQUERY_COUNTER_DATA_DOUBLE_INTEL = 0x94FB +gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING :: GLenum +gl_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING = 0x889F +gl_VERTEX_SHADER :: GLenum +gl_VERTEX_SHADER = 0x8B31 +gl_INDEX_ARRAY_ADDRESS_NV :: GLenum +gl_INDEX_ARRAY_ADDRESS_NV = 0x8F24 +gl_QUERY_COUNTER_BITS :: GLenum +gl_QUERY_COUNTER_BITS = 0x8864 +gl_COMPRESSED_RGBA_ASTC_8x6_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_8x6_KHR = 0x93B6 +gl_FRAMEBUFFER_BINDING_EXT :: GLenum +gl_FRAMEBUFFER_BINDING_EXT = 0x8CA6 +gl_VERTEX_ELEMENT_SWIZZLE_AMD :: GLenum +gl_VERTEX_ELEMENT_SWIZZLE_AMD = 0x91A4 +gl_DEBUG_CATEGORY_SHADER_COMPILER_AMD :: GLenum +gl_DEBUG_CATEGORY_SHADER_COMPILER_AMD = 0x914E +gl_ARRAY_OBJECT_BUFFER_ATI :: GLenum +gl_ARRAY_OBJECT_BUFFER_ATI = 0x8766 +gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES :: GLenum +gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910C +gl_RENDERBUFFER_INTERNAL_FORMAT :: GLenum +gl_RENDERBUFFER_INTERNAL_FORMAT = 0x8D44 +gl_VIEW_CLASS_8_BITS :: GLenum +gl_VIEW_CLASS_8_BITS = 0x82CB +gl_TEXTURE_CUBE_MAP_POSITIVE_Y_OES :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_Y_OES = 0x8517 +gl_SHADER_IMAGE_ATOMIC :: GLenum +gl_SHADER_IMAGE_ATOMIC = 0x82A6 +gl_MAX_GEOMETRY_OUTPUT_VERTICES_ARB :: GLenum +gl_MAX_GEOMETRY_OUTPUT_VERTICES_ARB = 0x8DE0 +gl_COVERAGE_ATTACHMENT_NV :: GLenum +gl_COVERAGE_ATTACHMENT_NV = 0x8ED2 +gl_NUM_PROGRAM_BINARY_FORMATS_OES :: GLenum +gl_NUM_PROGRAM_BINARY_FORMATS_OES = 0x87FE +gl_CURRENT_RASTER_TEXTURE_COORDS :: GLenum +gl_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06 +gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS :: GLenum +gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS = 0x8E86 +gl_PIXEL_MAP_A_TO_A :: GLenum +gl_PIXEL_MAP_A_TO_A = 0x0C79 +gl_TEXTURE_WRAP_T :: GLenum +gl_TEXTURE_WRAP_T = 0x2803 +gl_LINE_SMOOTH_HINT :: GLenum +gl_LINE_SMOOTH_HINT = 0x0C52 +gl_DRAW_BUFFER11_EXT :: GLenum +gl_DRAW_BUFFER11_EXT = 0x8830 +gl_OFFSET_TEXTURE_RECTANGLE_SCALE_NV :: GLenum +gl_OFFSET_TEXTURE_RECTANGLE_SCALE_NV = 0x864D +gl_LUMINANCE16_SNORM :: GLenum +gl_LUMINANCE16_SNORM = 0x9019 +gl_PERFQUERY_FLUSH_INTEL :: GLenum +gl_PERFQUERY_FLUSH_INTEL = 0x83FA +gl_HISTOGRAM_SINK :: GLenum +gl_HISTOGRAM_SINK = 0x802D +gl_MAP1_VERTEX_ATTRIB15_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB15_4_NV = 0x866F +gl_OUTPUT_TEXTURE_COORD7_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD7_EXT = 0x87A4 +gl_HISTOGRAM_BLUE_SIZE :: GLenum +gl_HISTOGRAM_BLUE_SIZE = 0x802A +gl_LUMINANCE32F_EXT :: GLenum +gl_LUMINANCE32F_EXT = 0x8818 +gl_RG16UI :: GLenum +gl_RG16UI = 0x823A +gl_TEXTURE_ALPHA_MODULATE_IMG :: GLenum +gl_TEXTURE_ALPHA_MODULATE_IMG = 0x8C06 +gl_INT_SAMPLER_2D_RECT :: GLenum +gl_INT_SAMPLER_2D_RECT = 0x8DCD +gl_STENCIL_BACK_WRITEMASK :: GLenum +gl_STENCIL_BACK_WRITEMASK = 0x8CA5 +gl_PIXEL_TRANSFORM_2D_MATRIX_EXT :: GLenum +gl_PIXEL_TRANSFORM_2D_MATRIX_EXT = 0x8338 +gl_AUX3 :: GLenum +gl_AUX3 = 0x040C +gl_FRAMEBUFFER_UNSUPPORTED :: GLenum +gl_FRAMEBUFFER_UNSUPPORTED = 0x8CDD +gl_MAX_TEXTURE_MAX_ANISOTROPY_EXT :: GLenum +gl_MAX_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FF +gl_TEXTURE_DEFORMATION_SGIX :: GLenum +gl_TEXTURE_DEFORMATION_SGIX = 0x8195 +gl_CON_23_ATI :: GLenum +gl_CON_23_ATI = 0x8958 +gl_CLIP_DISTANCE0 :: GLenum +gl_CLIP_DISTANCE0 = 0x3000 +gl_COLOR_ATTACHMENT10 :: GLenum +gl_COLOR_ATTACHMENT10 = 0x8CEA +gl_POINT_SIZE_MAX_EXT :: GLenum +gl_POINT_SIZE_MAX_EXT = 0x8127 +gl_TEXTURE5 :: GLenum +gl_TEXTURE5 = 0x84C5 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR = 0x93D6 +gl_PATH_MODELVIEW_MATRIX_NV :: GLenum +gl_PATH_MODELVIEW_MATRIX_NV = 0x0BA6 +gl_LINE_LOOP :: GLenum +gl_LINE_LOOP = 0x0002 +gl_MODELVIEW17_ARB :: GLenum +gl_MODELVIEW17_ARB = 0x8731 +gl_UNSIGNED_INT16_VEC2_NV :: GLenum +gl_UNSIGNED_INT16_VEC2_NV = 0x8FF1 +gl_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES :: GLenum +gl_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898F +gl_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS :: GLenum +gl_MAX_COMPUTE_ATOMIC_COUNTER_BUFFERS = 0x8264 +gl_DRAW_BUFFER3_EXT :: GLenum +gl_DRAW_BUFFER3_EXT = 0x8828 +gl_TEXTURE_SHADOW :: GLenum +gl_TEXTURE_SHADOW = 0x82A1 +gl_STENCIL_ATTACHMENT :: GLenum +gl_STENCIL_ATTACHMENT = 0x8D20 +gl_MAP_STENCIL :: GLenum +gl_MAP_STENCIL = 0x0D11 +gl_PATH_DASH_ARRAY_COUNT_NV :: GLenum +gl_PATH_DASH_ARRAY_COUNT_NV = 0x909F +gl_BLEND :: GLenum +gl_BLEND = 0x0BE2 +gl_UNIFORM_BUFFER_OFFSET_ALIGNMENT :: GLenum +gl_UNIFORM_BUFFER_OFFSET_ALIGNMENT = 0x8A34 +gl_TEXTURE_TARGET_QCOM :: GLenum +gl_TEXTURE_TARGET_QCOM = 0x8BDA +gl_NORMAL_MAP_OES :: GLenum +gl_NORMAL_MAP_OES = 0x8511 +gl_UNSIGNED_SHORT_4_4_4_4_REV_EXT :: GLenum +gl_UNSIGNED_SHORT_4_4_4_4_REV_EXT = 0x8365 +gl_TEXTURE20 :: GLenum +gl_TEXTURE20 = 0x84D4 +gl_EDGE_FLAG_ARRAY_COUNT_EXT :: GLenum +gl_EDGE_FLAG_ARRAY_COUNT_EXT = 0x808D +gl_SMOOTH :: GLenum +gl_SMOOTH = 0x1D01 +gl_SHADER_INCLUDE_ARB :: GLenum +gl_SHADER_INCLUDE_ARB = 0x8DAE +gl_CLAMP_TO_EDGE_SGIS :: GLenum +gl_CLAMP_TO_EDGE_SGIS = 0x812F +gl_COMPRESSED_ALPHA :: GLenum +gl_COMPRESSED_ALPHA = 0x84E9 +gl_TEXTURE_IMAGE_FORMAT :: GLenum +gl_TEXTURE_IMAGE_FORMAT = 0x828F +gl_MAX_FRAMEBUFFER_LAYERS :: GLenum +gl_MAX_FRAMEBUFFER_LAYERS = 0x9317 +gl_WRITEONLY_RENDERING_QCOM :: GLenum +gl_WRITEONLY_RENDERING_QCOM = 0x8823 +gl_BACK_RIGHT :: GLenum +gl_BACK_RIGHT = 0x0403 +gl_INVARIANT_DATATYPE_EXT :: GLenum +gl_INVARIANT_DATATYPE_EXT = 0x87EB +gl_LINE_TO_NV :: GLenum +gl_LINE_TO_NV = 0x04 +gl_PIXEL_UNPACK_BUFFER_BINDING_ARB :: GLenum +gl_PIXEL_UNPACK_BUFFER_BINDING_ARB = 0x88EF +gl_LIST_BIT :: GLenum +gl_LIST_BIT = 0x00020000 +gl_MAX_ATTRIB_STACK_DEPTH :: GLenum +gl_MAX_ATTRIB_STACK_DEPTH = 0x0D35 +gl_FRAGMENT_SHADER :: GLenum +gl_FRAGMENT_SHADER = 0x8B30 +gl_IMPLEMENTATION_COLOR_READ_FORMAT :: GLenum +gl_IMPLEMENTATION_COLOR_READ_FORMAT = 0x8B9B +gl_COLOR_TABLE_WIDTH_SGI :: GLenum +gl_COLOR_TABLE_WIDTH_SGI = 0x80D9 +gl_DEBUG_OBJECT_MESA :: GLenum +gl_DEBUG_OBJECT_MESA = 0x8759 +gl_EYE_LINE_SGIS :: GLenum +gl_EYE_LINE_SGIS = 0x81F6 +gl_COMPRESSED_ALPHA_ARB :: GLenum +gl_COMPRESSED_ALPHA_ARB = 0x84E9 +gl_DEPTH_BUFFER_BIT7_QCOM :: GLenum +gl_DEPTH_BUFFER_BIT7_QCOM = 0x00008000 +gl_OPERAND2_RGB_ARB :: GLenum +gl_OPERAND2_RGB_ARB = 0x8592 +gl_PROGRAM_BINARY_ANGLE :: GLenum +gl_PROGRAM_BINARY_ANGLE = 0x93A6 +gl_MATRIX_EXT :: GLenum +gl_MATRIX_EXT = 0x87C0 +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS = 0x8C80 +gl_RED_NV :: GLenum +gl_RED_NV = 0x1903 +gl_LIGHT7 :: GLenum +gl_LIGHT7 = 0x4007 +gl_LOW_FLOAT :: GLenum +gl_LOW_FLOAT = 0x8DF0 +gl_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_MODE_EXT = 0x8C7F +gl_CON_18_ATI :: GLenum +gl_CON_18_ATI = 0x8953 +gl_UNIFORM_BUFFER_ADDRESS_NV :: GLenum +gl_UNIFORM_BUFFER_ADDRESS_NV = 0x936F +gl_VERTEX_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_VERTEX_ARRAY_BUFFER_BINDING_ARB = 0x8896 +gl_RED_BIT_ATI :: GLenum +gl_RED_BIT_ATI = 0x00000001 +gl_TRACE_TEXTURES_BIT_MESA :: GLenum +gl_TRACE_TEXTURES_BIT_MESA = 0x0008 +gl_GEOMETRY_SHADER :: GLenum +gl_GEOMETRY_SHADER = 0x8DD9 +gl_VERTEX_ARRAY_ADDRESS_NV :: GLenum +gl_VERTEX_ARRAY_ADDRESS_NV = 0x8F21 +gl_TIMEOUT_IGNORED_APPLE :: GLenum +gl_TIMEOUT_IGNORED_APPLE = 0xFFFFFFFFFFFFFFFF +gl_RENDERBUFFER_BINDING :: GLenum +gl_RENDERBUFFER_BINDING = 0x8CA7 +gl_RGB16F :: GLenum +gl_RGB16F = 0x881B +gl_TEXTURE_COORD_ARRAY_LENGTH_NV :: GLenum +gl_TEXTURE_COORD_ARRAY_LENGTH_NV = 0x8F2F +gl_MAX_FRAMEBUFFER_LAYERS_EXT :: GLenum +gl_MAX_FRAMEBUFFER_LAYERS_EXT = 0x9317 +gl_MODELVIEW23_ARB :: GLenum +gl_MODELVIEW23_ARB = 0x8737 +gl_BGR_EXT :: GLenum +gl_BGR_EXT = 0x80E0 +gl_ONE_MINUS_SRC1_COLOR :: GLenum +gl_ONE_MINUS_SRC1_COLOR = 0x88FA +gl_VARIANT_ARRAY_EXT :: GLenum +gl_VARIANT_ARRAY_EXT = 0x87E8 +gl_RGB4 :: GLenum +gl_RGB4 = 0x804F +gl_RENDERBUFFER_DEPTH_SIZE_OES :: GLenum +gl_RENDERBUFFER_DEPTH_SIZE_OES = 0x8D54 +gl_MAX_VARYING_COMPONENTS_EXT :: GLenum +gl_MAX_VARYING_COMPONENTS_EXT = 0x8B4B +gl_CURRENT_MATRIX_NV :: GLenum +gl_CURRENT_MATRIX_NV = 0x8641 +gl_T2F_IUI_N3F_V3F_EXT :: GLenum +gl_T2F_IUI_N3F_V3F_EXT = 0x81B4 +gl_SLUMINANCE8 :: GLenum +gl_SLUMINANCE8 = 0x8C47 +gl_MODELVIEW1_MATRIX_EXT :: GLenum +gl_MODELVIEW1_MATRIX_EXT = 0x8506 +gl_MODELVIEW29_ARB :: GLenum +gl_MODELVIEW29_ARB = 0x873D +gl_COLOR_ATTACHMENT5_EXT :: GLenum +gl_COLOR_ATTACHMENT5_EXT = 0x8CE5 +gl_DOUBLE_MAT2 :: GLenum +gl_DOUBLE_MAT2 = 0x8F46 +gl_RGBA12_EXT :: GLenum +gl_RGBA12_EXT = 0x805A +gl_ACCUM_BLUE_BITS :: GLenum +gl_ACCUM_BLUE_BITS = 0x0D5A +gl_INVARIANT_EXT :: GLenum +gl_INVARIANT_EXT = 0x87C2 +gl_ACTIVE_UNIFORM_MAX_LENGTH :: GLenum +gl_ACTIVE_UNIFORM_MAX_LENGTH = 0x8B87 +gl_FOG_SPECULAR_TEXTURE_WIN :: GLenum +gl_FOG_SPECULAR_TEXTURE_WIN = 0x80EC +gl_COLOR_TABLE_SCALE_SGI :: GLenum +gl_COLOR_TABLE_SCALE_SGI = 0x80D6 +gl_IUI_V3F_EXT :: GLenum +gl_IUI_V3F_EXT = 0x81AE +gl_UNSIGNED_INT_IMAGE_3D_EXT :: GLenum +gl_UNSIGNED_INT_IMAGE_3D_EXT = 0x9064 +gl_MAX_DEBUG_MESSAGE_LENGTH_KHR :: GLenum +gl_MAX_DEBUG_MESSAGE_LENGTH_KHR = 0x9143 +gl_TEXTURE_CUBE_MAP_POSITIVE_Y :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_Y = 0x8517 +gl_DOUBLE_VEC2 :: GLenum +gl_DOUBLE_VEC2 = 0x8FFC +gl_MAX_SAMPLE_MASK_WORDS :: GLenum +gl_MAX_SAMPLE_MASK_WORDS = 0x8E59 +gl_DEBUG_OUTPUT :: GLenum +gl_DEBUG_OUTPUT = 0x92E0 +gl_OBJECT_SHADER_SOURCE_LENGTH_ARB :: GLenum +gl_OBJECT_SHADER_SOURCE_LENGTH_ARB = 0x8B88 +gl_R32F_EXT :: GLenum +gl_R32F_EXT = 0x822E +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV :: GLenum +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_NV = 0x8C4E +gl_COPY_WRITE_BUFFER_BINDING :: GLenum +gl_COPY_WRITE_BUFFER_BINDING = 0x8F37 +gl_TEXTURE15_ARB :: GLenum +gl_TEXTURE15_ARB = 0x84CF +gl_UNIFORM_BLOCK_NAME_LENGTH :: GLenum +gl_UNIFORM_BLOCK_NAME_LENGTH = 0x8A41 +gl_COLOR_ATTACHMENT4_NV :: GLenum +gl_COLOR_ATTACHMENT4_NV = 0x8CE4 +gl_DST_OVER_NV :: GLenum +gl_DST_OVER_NV = 0x9289 +gl_ATOMIC_COUNTER_BUFFER :: GLenum +gl_ATOMIC_COUNTER_BUFFER = 0x92C0 +gl_MAP1_VERTEX_ATTRIB12_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB12_4_NV = 0x866C +gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB :: GLenum +gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS_ARB = 0x8B4C +gl_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV :: GLenum +gl_OFFSET_PROJECTIVE_TEXTURE_2D_SCALE_NV = 0x8851 +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_CUBE_MAP_FACE = 0x8CD3 +gl_RGB_RAW_422_APPLE :: GLenum +gl_RGB_RAW_422_APPLE = 0x8A51 +gl_MAX_RECTANGLE_TEXTURE_SIZE :: GLenum +gl_MAX_RECTANGLE_TEXTURE_SIZE = 0x84F8 +gl_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_LAYERED_EXT = 0x8DA7 +gl_FRAGMENT_COLOR_MATERIAL_SGIX :: GLenum +gl_FRAGMENT_COLOR_MATERIAL_SGIX = 0x8401 +gl_POST_COLOR_MATRIX_RED_SCALE_SGI :: GLenum +gl_POST_COLOR_MATRIX_RED_SCALE_SGI = 0x80B4 +gl_VIBRANCE_SCALE_NV :: GLenum +gl_VIBRANCE_SCALE_NV = 0x8713 +gl_POINT_FADE_THRESHOLD_SIZE :: GLenum +gl_POINT_FADE_THRESHOLD_SIZE = 0x8128 +gl_QUERY_NO_WAIT_NV :: GLenum +gl_QUERY_NO_WAIT_NV = 0x8E14 +gl_FRAGMENT_SHADER_DERIVATIVE_HINT_OES :: GLenum +gl_FRAGMENT_SHADER_DERIVATIVE_HINT_OES = 0x8B8B +gl_RESAMPLE_REPLICATE_OML :: GLenum +gl_RESAMPLE_REPLICATE_OML = 0x8986 +gl_RENDERBUFFER_BINDING_ANGLE :: GLenum +gl_RENDERBUFFER_BINDING_ANGLE = 0x8CA7 +gl_R1UI_V3F_SUN :: GLenum +gl_R1UI_V3F_SUN = 0x85C4 +gl_CONVOLUTION_2D :: GLenum +gl_CONVOLUTION_2D = 0x8011 +gl_OBJECT_TYPE :: GLenum +gl_OBJECT_TYPE = 0x9112 +gl_MAX_MAP_TESSELLATION_NV :: GLenum +gl_MAX_MAP_TESSELLATION_NV = 0x86D6 +gl_DOUBLE_MAT4x3_EXT :: GLenum +gl_DOUBLE_MAT4x3_EXT = 0x8F4E +gl_MULTISAMPLE_BUFFER_BIT4_QCOM :: GLenum +gl_MULTISAMPLE_BUFFER_BIT4_QCOM = 0x10000000 +gl_UNSIGNED_INT64_AMD :: GLenum +gl_UNSIGNED_INT64_AMD = 0x8BC2 +gl_MAX_PATCH_VERTICES :: GLenum +gl_MAX_PATCH_VERTICES = 0x8E7D +gl_TEXTURE_COMPONENTS :: GLenum +gl_TEXTURE_COMPONENTS = 0x1003 +gl_ELEMENT_ARRAY_POINTER_APPLE :: GLenum +gl_ELEMENT_ARRAY_POINTER_APPLE = 0x8A0E +gl_COLOR_ATTACHMENT6_NV :: GLenum +gl_COLOR_ATTACHMENT6_NV = 0x8CE6 +gl_MODELVIEW_PROJECTION_NV :: GLenum +gl_MODELVIEW_PROJECTION_NV = 0x8629 +gl_STATIC_ATI :: GLenum +gl_STATIC_ATI = 0x8760 +gl_TEXTURE_CUBE_MAP_NEGATIVE_Z :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_Z = 0x851A +gl_CONVOLUTION_BORDER_MODE :: GLenum +gl_CONVOLUTION_BORDER_MODE = 0x8013 +gl_2PASS_0_SGIS :: GLenum +gl_2PASS_0_SGIS = 0x80A2 +gl_GREEN_INTEGER_EXT :: GLenum +gl_GREEN_INTEGER_EXT = 0x8D95 +gl_DEBUG_TYPE_OTHER :: GLenum +gl_DEBUG_TYPE_OTHER = 0x8251 +gl_FRAMEBUFFER_SRGB_EXT :: GLenum +gl_FRAMEBUFFER_SRGB_EXT = 0x8DB9 +gl_COLOR_WRITEMASK :: GLenum +gl_COLOR_WRITEMASK = 0x0C23 +gl_TANGENT_ARRAY_EXT :: GLenum +gl_TANGENT_ARRAY_EXT = 0x8439 +gl_FONT_TARGET_UNAVAILABLE_NV :: GLenum +gl_FONT_TARGET_UNAVAILABLE_NV = 0x9369 +gl_FONT_UNAVAILABLE_NV :: GLenum +gl_FONT_UNAVAILABLE_NV = 0x936A +gl_COMBINER2_NV :: GLenum +gl_COMBINER2_NV = 0x8552 +gl_TEXTURE22_ARB :: GLenum +gl_TEXTURE22_ARB = 0x84D6 +gl_PATH_INITIAL_DASH_CAP_NV :: GLenum +gl_PATH_INITIAL_DASH_CAP_NV = 0x907C +gl_SWIZZLE_STRQ_ATI :: GLenum +gl_SWIZZLE_STRQ_ATI = 0x897A +gl_OBJECT_LINE_SGIS :: GLenum +gl_OBJECT_LINE_SGIS = 0x81F7 +gl_MAX_NUM_ACTIVE_VARIABLES :: GLenum +gl_MAX_NUM_ACTIVE_VARIABLES = 0x92F7 +gl_COLOR_ATTACHMENT3_EXT :: GLenum +gl_COLOR_ATTACHMENT3_EXT = 0x8CE3 +gl_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI :: GLenum +gl_COMPRESSED_LUMINANCE_ALPHA_3DC_ATI = 0x8837 +gl_SCREEN_KHR :: GLenum +gl_SCREEN_KHR = 0x9295 +gl_ZOOM_X :: GLenum +gl_ZOOM_X = 0x0D16 +gl_PROGRAM_MATRIX_EXT :: GLenum +gl_PROGRAM_MATRIX_EXT = 0x8E2D +gl_TEXTURE_VIEW :: GLenum +gl_TEXTURE_VIEW = 0x82B5 +gl_NEGATIVE_ONE_TO_ONE :: GLenum +gl_NEGATIVE_ONE_TO_ONE = 0x935E +gl_CONVOLUTION_1D_EXT :: GLenum +gl_CONVOLUTION_1D_EXT = 0x8010 +gl_CLAMP_READ_COLOR :: GLenum +gl_CLAMP_READ_COLOR = 0x891C +gl_REFLECTION_MAP :: GLenum +gl_REFLECTION_MAP = 0x8512 +gl_PROXY_HISTOGRAM :: GLenum +gl_PROXY_HISTOGRAM = 0x8025 +gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS :: GLenum +gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS = 0x886D +gl_HALF_FLOAT_ARB :: GLenum +gl_HALF_FLOAT_ARB = 0x140B +gl_LINE_QUALITY_HINT_SGIX :: GLenum +gl_LINE_QUALITY_HINT_SGIX = 0x835B +gl_MAP_WRITE_BIT_EXT :: GLenum +gl_MAP_WRITE_BIT_EXT = 0x0002 +gl_PIXEL_TRANSFORM_2D_EXT :: GLenum +gl_PIXEL_TRANSFORM_2D_EXT = 0x8330 +gl_INCR :: GLenum +gl_INCR = 0x1E02 +gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT = 0x8CDB +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_3x3x3_OES = 0x93E0 +gl_LUMINANCE_FLOAT32_ATI :: GLenum +gl_LUMINANCE_FLOAT32_ATI = 0x8818 +gl_EVAL_VERTEX_ATTRIB11_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB11_NV = 0x86D1 +gl_TEXTURE_COORD_ARRAY_SIZE :: GLenum +gl_TEXTURE_COORD_ARRAY_SIZE = 0x8088 +gl_IMAGE_BINDING_LEVEL_EXT :: GLenum +gl_IMAGE_BINDING_LEVEL_EXT = 0x8F3B +gl_RGBA16I_EXT :: GLenum +gl_RGBA16I_EXT = 0x8D88 +gl_T2F_IUI_N3F_V2F_EXT :: GLenum +gl_T2F_IUI_N3F_V2F_EXT = 0x81B3 +gl_MIN_PROGRAM_TEXEL_OFFSET_NV :: GLenum +gl_MIN_PROGRAM_TEXEL_OFFSET_NV = 0x8904 +gl_EQUIV :: GLenum +gl_EQUIV = 0x1509 +gl_TEXTURE_BINDING_CUBE_MAP_ARB :: GLenum +gl_TEXTURE_BINDING_CUBE_MAP_ARB = 0x8514 +gl_DRAW_BUFFER1_NV :: GLenum +gl_DRAW_BUFFER1_NV = 0x8826 +gl_INTERLACE_READ_OML :: GLenum +gl_INTERLACE_READ_OML = 0x8981 +gl_TEXTURE15 :: GLenum +gl_TEXTURE15 = 0x84CF +gl_NAND :: GLenum +gl_NAND = 0x150E +gl_VERTEX_ARRAY_RANGE_APPLE :: GLenum +gl_VERTEX_ARRAY_RANGE_APPLE = 0x851D +gl_CONDITION_SATISFIED_APPLE :: GLenum +gl_CONDITION_SATISFIED_APPLE = 0x911C +gl_DISPATCH_INDIRECT_BUFFER_BINDING :: GLenum +gl_DISPATCH_INDIRECT_BUFFER_BINDING = 0x90EF +gl_RG16I :: GLenum +gl_RG16I = 0x8239 +gl_EYE_RADIAL_NV :: GLenum +gl_EYE_RADIAL_NV = 0x855B +gl_SLUMINANCE_ALPHA_EXT :: GLenum +gl_SLUMINANCE_ALPHA_EXT = 0x8C44 +gl_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL :: GLenum +gl_VERTEX_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F5 +gl_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT :: GLenum +gl_VERTEX_ATTRIB_ARRAY_DIVISOR_EXT = 0x88FE +gl_RG32F :: GLenum +gl_RG32F = 0x8230 +gl_SRC1_ALPHA :: GLenum +gl_SRC1_ALPHA = 0x8589 +gl_RGBA2 :: GLenum +gl_RGBA2 = 0x8055 +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_OES = 0x8CD4 +gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT :: GLenum +gl_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN_EXT = 0x8C88 +gl_TEXTURE_COORD_ARRAY_STRIDE_EXT :: GLenum +gl_TEXTURE_COORD_ARRAY_STRIDE_EXT = 0x808A +gl_OUTPUT_TEXTURE_COORD10_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD10_EXT = 0x87A7 +gl_DEPTH_ATTACHMENT :: GLenum +gl_DEPTH_ATTACHMENT = 0x8D00 +gl_NORMAL_ARRAY_POINTER_EXT :: GLenum +gl_NORMAL_ARRAY_POINTER_EXT = 0x808F +gl_OPERAND0_ALPHA_ARB :: GLenum +gl_OPERAND0_ALPHA_ARB = 0x8598 +gl_COMPRESSED_LUMINANCE_ARB :: GLenum +gl_COMPRESSED_LUMINANCE_ARB = 0x84EA +gl_LIST_PRIORITY_SGIX :: GLenum +gl_LIST_PRIORITY_SGIX = 0x8182 +gl_BOUNDING_BOX_NV :: GLenum +gl_BOUNDING_BOX_NV = 0x908D +gl_PATCH_VERTICES_EXT :: GLenum +gl_PATCH_VERTICES_EXT = 0x8E72 +gl_COPY_INVERTED :: GLenum +gl_COPY_INVERTED = 0x150C +gl_FRAMEBUFFER_BARRIER_BIT_EXT :: GLenum +gl_FRAMEBUFFER_BARRIER_BIT_EXT = 0x00000400 +gl_OBJECT_ACTIVE_ATTRIBUTES_ARB :: GLenum +gl_OBJECT_ACTIVE_ATTRIBUTES_ARB = 0x8B89 +gl_DISCRETE_AMD :: GLenum +gl_DISCRETE_AMD = 0x9006 +gl_DOT3_RGBA_ARB :: GLenum +gl_DOT3_RGBA_ARB = 0x86AF +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL_OES = 0x8CD2 +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_OES = 0x8CD1 +gl_SET :: GLenum +gl_SET = 0x150F +gl_TEXTURE_MAX_ANISOTROPY_EXT :: GLenum +gl_TEXTURE_MAX_ANISOTROPY_EXT = 0x84FE +gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 :: GLenum +gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9276 +gl_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB :: GLenum +gl_FRAGMENT_SHADER_DERIVATIVE_HINT_ARB = 0x8B8B +gl_MAP2_GRID_DOMAIN :: GLenum +gl_MAP2_GRID_DOMAIN = 0x0DD2 +gl_RENDERBUFFER_SAMPLES :: GLenum +gl_RENDERBUFFER_SAMPLES = 0x8CAB +gl_MAX_TEXTURE_LOD_BIAS :: GLenum +gl_MAX_TEXTURE_LOD_BIAS = 0x84FD +gl_DEPTH_PASS_INSTRUMENT_SGIX :: GLenum +gl_DEPTH_PASS_INSTRUMENT_SGIX = 0x8310 +gl_TEXTURE_COORD_NV :: GLenum +gl_TEXTURE_COORD_NV = 0x8C79 +gl_PROGRAM_ERROR_POSITION_NV :: GLenum +gl_PROGRAM_ERROR_POSITION_NV = 0x864B +gl_RENDERBUFFER_RED_SIZE_EXT :: GLenum +gl_RENDERBUFFER_RED_SIZE_EXT = 0x8D50 +gl_INDEX_OFFSET :: GLenum +gl_INDEX_OFFSET = 0x0D13 +gl_CURRENT_FOG_COORD :: GLenum +gl_CURRENT_FOG_COORD = 0x8453 +gl_MIRRORED_REPEAT :: GLenum +gl_MIRRORED_REPEAT = 0x8370 +gl_MAP_INVALIDATE_BUFFER_BIT :: GLenum +gl_MAP_INVALIDATE_BUFFER_BIT = 0x0008 +gl_MATRIX_INDEX_ARRAY_OES :: GLenum +gl_MATRIX_INDEX_ARRAY_OES = 0x8844 +gl_DRAW_BUFFER6_ATI :: GLenum +gl_DRAW_BUFFER6_ATI = 0x882B +gl_INTENSITY12 :: GLenum +gl_INTENSITY12 = 0x804C +gl_FLOAT_RGBA_NV :: GLenum +gl_FLOAT_RGBA_NV = 0x8883 +gl_SMOOTH_POINT_SIZE_RANGE :: GLenum +gl_SMOOTH_POINT_SIZE_RANGE = 0x0B12 +gl_COLOR_BUFFER_BIT1_QCOM :: GLenum +gl_COLOR_BUFFER_BIT1_QCOM = 0x00000002 +gl_TEXT_FRAGMENT_SHADER_ATI :: GLenum +gl_TEXT_FRAGMENT_SHADER_ATI = 0x8200 +gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_EXT = 0x8DA8 +gl_CLIP_PLANE3 :: GLenum +gl_CLIP_PLANE3 = 0x3003 +gl_NAMED_STRING_TYPE_ARB :: GLenum +gl_NAMED_STRING_TYPE_ARB = 0x8DEA +gl_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB :: GLenum +gl_MAX_COMPUTE_FIXED_GROUP_INVOCATIONS_ARB = 0x90EB +gl_TEXTURE_VIEW_MIN_LEVEL :: GLenum +gl_TEXTURE_VIEW_MIN_LEVEL = 0x82DB +gl_SWIZZLE_STQ_ATI :: GLenum +gl_SWIZZLE_STQ_ATI = 0x8977 +gl_RGBA_FLOAT_MODE_ARB :: GLenum +gl_RGBA_FLOAT_MODE_ARB = 0x8820 +gl_RG8UI :: GLenum +gl_RG8UI = 0x8238 +gl_FRAGMENT_DEPTH :: GLenum +gl_FRAGMENT_DEPTH = 0x8452 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR = 0x93D2 +gl_MULTISAMPLE_SGIS :: GLenum +gl_MULTISAMPLE_SGIS = 0x809D +gl_PROXY_TEXTURE_1D :: GLenum +gl_PROXY_TEXTURE_1D = 0x8063 +gl_MODELVIEW0_ARB :: GLenum +gl_MODELVIEW0_ARB = 0x1700 +gl_LINE_STRIP_ADJACENCY_EXT :: GLenum +gl_LINE_STRIP_ADJACENCY_EXT = 0x000B +gl_RGBA16UI :: GLenum +gl_RGBA16UI = 0x8D76 +gl_SRC_ATOP_NV :: GLenum +gl_SRC_ATOP_NV = 0x928E +gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE :: GLenum +gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_WRITE = 0x82AE +gl_REG_30_ATI :: GLenum +gl_REG_30_ATI = 0x893F +gl_4PASS_3_EXT :: GLenum +gl_4PASS_3_EXT = 0x80A7 +gl_INT_IMAGE_3D_EXT :: GLenum +gl_INT_IMAGE_3D_EXT = 0x9059 +gl_SYSTEM_FONT_NAME_NV :: GLenum +gl_SYSTEM_FONT_NAME_NV = 0x9073 +gl_DRAW_BUFFER6 :: GLenum +gl_DRAW_BUFFER6 = 0x882B +gl_RG32I :: GLenum +gl_RG32I = 0x823B +gl_COLOR_BUFFER_BIT3_QCOM :: GLenum +gl_COLOR_BUFFER_BIT3_QCOM = 0x00000008 +gl_CURRENT_OCCLUSION_QUERY_ID_NV :: GLenum +gl_CURRENT_OCCLUSION_QUERY_ID_NV = 0x8865 +gl_INTERNALFORMAT_STENCIL_SIZE :: GLenum +gl_INTERNALFORMAT_STENCIL_SIZE = 0x8276 +gl_STATIC_DRAW_ARB :: GLenum +gl_STATIC_DRAW_ARB = 0x88E4 +gl_COMPRESSED_SRGB_ALPHA_EXT :: GLenum +gl_COMPRESSED_SRGB_ALPHA_EXT = 0x8C49 +gl_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI :: GLenum +gl_MAT_AMBIENT_AND_DIFFUSE_BIT_PGI = 0x00200000 +gl_PALETTE8_RGBA4_OES :: GLenum +gl_PALETTE8_RGBA4_OES = 0x8B98 +gl_FOG_START :: GLenum +gl_FOG_START = 0x0B63 +gl_DEBUG_TYPE_POP_GROUP :: GLenum +gl_DEBUG_TYPE_POP_GROUP = 0x826A +gl_DRAW_BUFFER14_ATI :: GLenum +gl_DRAW_BUFFER14_ATI = 0x8833 +gl_IMAGE_1D_ARRAY :: GLenum +gl_IMAGE_1D_ARRAY = 0x9052 +gl_RELATIVE_LARGE_CCW_ARC_TO_NV :: GLenum +gl_RELATIVE_LARGE_CCW_ARC_TO_NV = 0x17 +gl_FONT_MAX_ADVANCE_HEIGHT_BIT_NV :: GLenum +gl_FONT_MAX_ADVANCE_HEIGHT_BIT_NV = 0x02000000 +gl_EXCLUSION_NV :: GLenum +gl_EXCLUSION_NV = 0x92A0 +gl_FONT_X_MAX_BOUNDS_BIT_NV :: GLenum +gl_FONT_X_MAX_BOUNDS_BIT_NV = 0x00040000 +gl_PIXEL_TEX_GEN_Q_FLOOR_SGIX :: GLenum +gl_PIXEL_TEX_GEN_Q_FLOOR_SGIX = 0x8186 +gl_DEPTH_BUFFER_BIT2_QCOM :: GLenum +gl_DEPTH_BUFFER_BIT2_QCOM = 0x00000400 +gl_UNPACK_FLIP_Y_WEBGL :: GLenum +gl_UNPACK_FLIP_Y_WEBGL = 0x9240 +gl_COLOR_ATTACHMENT15_NV :: GLenum +gl_COLOR_ATTACHMENT15_NV = 0x8CEF +gl_RG16F_EXT :: GLenum +gl_RG16F_EXT = 0x822F +gl_PRIMARY_COLOR :: GLenum +gl_PRIMARY_COLOR = 0x8577 +gl_UNIFORM_BLOCK_DATA_SIZE :: GLenum +gl_UNIFORM_BLOCK_DATA_SIZE = 0x8A40 +gl_INTERNALFORMAT_STENCIL_TYPE :: GLenum +gl_INTERNALFORMAT_STENCIL_TYPE = 0x827D +gl_COLOR_MATRIX_STACK_DEPTH_SGI :: GLenum +gl_COLOR_MATRIX_STACK_DEPTH_SGI = 0x80B2 +gl_AND :: GLenum +gl_AND = 0x1501 +gl_GEOMETRY_INPUT_TYPE_ARB :: GLenum +gl_GEOMETRY_INPUT_TYPE_ARB = 0x8DDB +gl_SAMPLER_BUFFER :: GLenum +gl_SAMPLER_BUFFER = 0x8DC2 +gl_COLOR_BUFFER_BIT2_QCOM :: GLenum +gl_COLOR_BUFFER_BIT2_QCOM = 0x00000004 +gl_MAX_CLIP_DISTANCES :: GLenum +gl_MAX_CLIP_DISTANCES = 0x0D32 +gl_OUTPUT_TEXTURE_COORD25_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD25_EXT = 0x87B6 +gl_SLIM8U_SGIX :: GLenum +gl_SLIM8U_SGIX = 0x831D +gl_OP_DOT4_EXT :: GLenum +gl_OP_DOT4_EXT = 0x8785 +gl_INFO_LOG_LENGTH :: GLenum +gl_INFO_LOG_LENGTH = 0x8B84 +gl_REG_25_ATI :: GLenum +gl_REG_25_ATI = 0x893A +gl_MAX_PROGRAM_CALL_DEPTH_NV :: GLenum +gl_MAX_PROGRAM_CALL_DEPTH_NV = 0x88F5 +gl_VIRTUAL_PAGE_SIZE_INDEX_ARB :: GLenum +gl_VIRTUAL_PAGE_SIZE_INDEX_ARB = 0x91A7 +gl_MAX_PROGRAM_RESULT_COMPONENTS_NV :: GLenum +gl_MAX_PROGRAM_RESULT_COMPONENTS_NV = 0x8909 +gl_RELATIVE_CONIC_CURVE_TO_NV :: GLenum +gl_RELATIVE_CONIC_CURVE_TO_NV = 0x1B +gl_CLIP_DISTANCE4 :: GLenum +gl_CLIP_DISTANCE4 = 0x3004 +gl_UTF8_NV :: GLenum +gl_UTF8_NV = 0x909A +gl_INVALID_INDEX :: GLenum +gl_INVALID_INDEX = 0xFFFFFFFF +gl_DOT3_RGBA_IMG :: GLenum +gl_DOT3_RGBA_IMG = 0x86AF +gl_FRAGMENT_MATERIAL_EXT :: GLenum +gl_FRAGMENT_MATERIAL_EXT = 0x8349 +gl_PACK_CMYK_HINT_EXT :: GLenum +gl_PACK_CMYK_HINT_EXT = 0x800E +gl_LUMINANCE_ALPHA8I_EXT :: GLenum +gl_LUMINANCE_ALPHA8I_EXT = 0x8D93 +gl_PIXEL_BUFFER_BARRIER_BIT_EXT :: GLenum +gl_PIXEL_BUFFER_BARRIER_BIT_EXT = 0x00000080 +gl_BUFFER_KHR :: GLenum +gl_BUFFER_KHR = 0x82E0 +gl_STENCIL_BACK_OP_VALUE_AMD :: GLenum +gl_STENCIL_BACK_OP_VALUE_AMD = 0x874D +gl_DST_COLOR :: GLenum +gl_DST_COLOR = 0x0306 +gl_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT :: GLenum +gl_TRANSFORM_FEEDBACK_BARRIER_BIT_EXT = 0x00000800 +gl_ZERO :: GLenum +gl_ZERO = 0 +gl_COORD_REPLACE :: GLenum +gl_COORD_REPLACE = 0x8862 +gl_FRAMEBUFFER_SRGB :: GLenum +gl_FRAMEBUFFER_SRGB = 0x8DB9 +gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_OES :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC_OES = 0x9279 +gl_CONSTANT :: GLenum +gl_CONSTANT = 0x8576 +gl_TEXTURE_CONSTANT_DATA_SUNX :: GLenum +gl_TEXTURE_CONSTANT_DATA_SUNX = 0x81D6 +gl_MAX_DEBUG_MESSAGE_LENGTH :: GLenum +gl_MAX_DEBUG_MESSAGE_LENGTH = 0x9143 +gl_MAX_VARYING_FLOATS :: GLenum +gl_MAX_VARYING_FLOATS = 0x8B4B +gl_PLUS_NV :: GLenum +gl_PLUS_NV = 0x9291 +gl_UNIFORM_NAME_LENGTH :: GLenum +gl_UNIFORM_NAME_LENGTH = 0x8A39 +gl_SECONDARY_COLOR_ARRAY_STRIDE :: GLenum +gl_SECONDARY_COLOR_ARRAY_STRIDE = 0x845C +gl_MAP1_VERTEX_ATTRIB13_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB13_4_NV = 0x866D +gl_TRACK_MATRIX_TRANSFORM_NV :: GLenum +gl_TRACK_MATRIX_TRANSFORM_NV = 0x8649 +gl_MAX_COMPUTE_UNIFORM_COMPONENTS :: GLenum +gl_MAX_COMPUTE_UNIFORM_COMPONENTS = 0x8263 +gl_DOUBLE_MAT4 :: GLenum +gl_DOUBLE_MAT4 = 0x8F48 +gl_TEXTURE_SRGB_DECODE_EXT :: GLenum +gl_TEXTURE_SRGB_DECODE_EXT = 0x8A48 +gl_TEXTURE_BORDER_COLOR :: GLenum +gl_TEXTURE_BORDER_COLOR = 0x1004 +gl_DISPLAY_LIST :: GLenum +gl_DISPLAY_LIST = 0x82E7 +gl_COLOR_ENCODING :: GLenum +gl_COLOR_ENCODING = 0x8296 +gl_EXPAND_NEGATE_NV :: GLenum +gl_EXPAND_NEGATE_NV = 0x8539 +gl_UNPACK_ROW_LENGTH_EXT :: GLenum +gl_UNPACK_ROW_LENGTH_EXT = 0x0CF2 +gl_RGB_SCALE_ARB :: GLenum +gl_RGB_SCALE_ARB = 0x8573 +gl_CURRENT_ATTRIB_NV :: GLenum +gl_CURRENT_ATTRIB_NV = 0x8626 +gl_TEXTURE25 :: GLenum +gl_TEXTURE25 = 0x84D9 +gl_DEPTH :: GLenum +gl_DEPTH = 0x1801 +gl_DRAW_BUFFER2_ARB :: GLenum +gl_DRAW_BUFFER2_ARB = 0x8827 +gl_FENCE_CONDITION_NV :: GLenum +gl_FENCE_CONDITION_NV = 0x84F4 +gl_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB :: GLenum +gl_MAX_PROGRAM_MATRIX_STACK_DEPTH_ARB = 0x862E +gl_OP_POWER_EXT :: GLenum +gl_OP_POWER_EXT = 0x8793 +gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB :: GLenum +gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5E +gl_FRAMEBUFFER_DEFAULT :: GLenum +gl_FRAMEBUFFER_DEFAULT = 0x8218 +gl_COLOR_ATTACHMENT13_EXT :: GLenum +gl_COLOR_ATTACHMENT13_EXT = 0x8CED +gl_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_ALPHA_SIZE = 0x8215 +gl_CUBIC_HP :: GLenum +gl_CUBIC_HP = 0x815F +gl_GREATER :: GLenum +gl_GREATER = 0x0204 +gl_OP_MOV_EXT :: GLenum +gl_OP_MOV_EXT = 0x8799 +gl_RED_SNORM :: GLenum +gl_RED_SNORM = 0x8F90 +gl_ALPHA_MAX_CLAMP_INGR :: GLenum +gl_ALPHA_MAX_CLAMP_INGR = 0x8567 +gl_VERTEX_ATTRIB_ARRAY_LONG :: GLenum +gl_VERTEX_ATTRIB_ARRAY_LONG = 0x874E +gl_DEBUG_SEVERITY_LOW_ARB :: GLenum +gl_DEBUG_SEVERITY_LOW_ARB = 0x9148 +gl_PURGEABLE_APPLE :: GLenum +gl_PURGEABLE_APPLE = 0x8A1D +gl_MAX_SHININESS_NV :: GLenum +gl_MAX_SHININESS_NV = 0x8504 +gl_VERTEX_SHADER_INVARIANTS_EXT :: GLenum +gl_VERTEX_SHADER_INVARIANTS_EXT = 0x87D1 +gl_CLIP_DISTANCE1 :: GLenum +gl_CLIP_DISTANCE1 = 0x3001 +gl_PROGRAM_NATIVE_PARAMETERS_ARB :: GLenum +gl_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AA +gl_SRC_ALPHA_SATURATE :: GLenum +gl_SRC_ALPHA_SATURATE = 0x0308 +gl_COLOR_RENDERABLE :: GLenum +gl_COLOR_RENDERABLE = 0x8286 +gl_LINE_STIPPLE :: GLenum +gl_LINE_STIPPLE = 0x0B24 +gl_COMPILE_AND_EXECUTE :: GLenum +gl_COMPILE_AND_EXECUTE = 0x1301 +gl_FOG_COORDINATE :: GLenum +gl_FOG_COORDINATE = 0x8451 +gl_MULTISAMPLE_COVERAGE_MODES_NV :: GLenum +gl_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E12 +gl_OUTPUT_TEXTURE_COORD16_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD16_EXT = 0x87AD +gl_SCALE_BY_FOUR_NV :: GLenum +gl_SCALE_BY_FOUR_NV = 0x853F +gl_INDEX_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_INDEX_ARRAY_BUFFER_BINDING_ARB = 0x8899 +gl_MAX_TEXTURE_IMAGE_UNITS_ARB :: GLenum +gl_MAX_TEXTURE_IMAGE_UNITS_ARB = 0x8872 +gl_HALF_BIAS_NEGATE_NV :: GLenum +gl_HALF_BIAS_NEGATE_NV = 0x853B +gl_INT_IMAGE_2D_MULTISAMPLE_EXT :: GLenum +gl_INT_IMAGE_2D_MULTISAMPLE_EXT = 0x9060 +gl_CON_30_ATI :: GLenum +gl_CON_30_ATI = 0x895F +gl_SAMPLE_ALPHA_TO_ONE_EXT :: GLenum +gl_SAMPLE_ALPHA_TO_ONE_EXT = 0x809F +gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING_ARB = 0x889A +gl_STORAGE_CACHED_APPLE :: GLenum +gl_STORAGE_CACHED_APPLE = 0x85BE +gl_SAMPLER_2D_SHADOW :: GLenum +gl_SAMPLER_2D_SHADOW = 0x8B62 +gl_ALPHA_FLOAT16_APPLE :: GLenum +gl_ALPHA_FLOAT16_APPLE = 0x881C +gl_PERFQUERY_COUNTER_EVENT_INTEL :: GLenum +gl_PERFQUERY_COUNTER_EVENT_INTEL = 0x94F0 +gl_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB :: GLenum +gl_SPARSE_TEXTURE_FULL_ARRAY_CUBE_MIPMAPS_ARB = 0x91A9 +gl_BACK_PRIMARY_COLOR_NV :: GLenum +gl_BACK_PRIMARY_COLOR_NV = 0x8C77 +gl_PROGRAM_PARAMETERS_ARB :: GLenum +gl_PROGRAM_PARAMETERS_ARB = 0x88A8 +gl_MIN_SPARSE_LEVEL_AMD :: GLenum +gl_MIN_SPARSE_LEVEL_AMD = 0x919B +gl_INT_SAMPLER_1D_ARRAY_EXT :: GLenum +gl_INT_SAMPLER_1D_ARRAY_EXT = 0x8DCE +gl_DOUBLEBUFFER :: GLenum +gl_DOUBLEBUFFER = 0x0C32 +gl_NEGATIVE_W_EXT :: GLenum +gl_NEGATIVE_W_EXT = 0x87DC +gl_VIEW_CLASS_RGTC1_RED :: GLenum +gl_VIEW_CLASS_RGTC1_RED = 0x82D0 +gl_PROGRAM_KHR :: GLenum +gl_PROGRAM_KHR = 0x82E2 +gl_LINEARDODGE_NV :: GLenum +gl_LINEARDODGE_NV = 0x92A4 +gl_NORMALIZED_RANGE_EXT :: GLenum +gl_NORMALIZED_RANGE_EXT = 0x87E0 +gl_BUFFER_SERIALIZED_MODIFY_APPLE :: GLenum +gl_BUFFER_SERIALIZED_MODIFY_APPLE = 0x8A12 +gl_TEXTURE3_ARB :: GLenum +gl_TEXTURE3_ARB = 0x84C3 +gl_INDEX_TEST_FUNC_EXT :: GLenum +gl_INDEX_TEST_FUNC_EXT = 0x81B6 +gl_COMPUTE_TEXTURE :: GLenum +gl_COMPUTE_TEXTURE = 0x82A0 +gl_UNSIGNED_INT_IMAGE_BUFFER_EXT :: GLenum +gl_UNSIGNED_INT_IMAGE_BUFFER_EXT = 0x9067 +gl_CON_9_ATI :: GLenum +gl_CON_9_ATI = 0x894A +gl_RELATIVE_LINE_TO_NV :: GLenum +gl_RELATIVE_LINE_TO_NV = 0x05 +gl_TEXTURE_RECTANGLE_NV :: GLenum +gl_TEXTURE_RECTANGLE_NV = 0x84F5 +gl_COMPRESSED_RGBA_S3TC_DXT5_ANGLE :: GLenum +gl_COMPRESSED_RGBA_S3TC_DXT5_ANGLE = 0x83F3 +gl_COMPRESSED_RGBA_ASTC_6x5_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_6x5_KHR = 0x93B3 +gl_TEXTURE_LUMINANCE_SIZE :: GLenum +gl_TEXTURE_LUMINANCE_SIZE = 0x8060 +gl_PROJECTION_MATRIX :: GLenum +gl_PROJECTION_MATRIX = 0x0BA7 +gl_VIBRANCE_BIAS_NV :: GLenum +gl_VIBRANCE_BIAS_NV = 0x8719 +gl_MAX_VERTEX_ATOMIC_COUNTERS :: GLenum +gl_MAX_VERTEX_ATOMIC_COUNTERS = 0x92D2 +gl_FOG_COORD_ARRAY_POINTER :: GLenum +gl_FOG_COORD_ARRAY_POINTER = 0x8456 +gl_POLYGON_OFFSET_BIAS_EXT :: GLenum +gl_POLYGON_OFFSET_BIAS_EXT = 0x8039 +gl_DEBUG_SOURCE_OTHER :: GLenum +gl_DEBUG_SOURCE_OTHER = 0x824B +gl_LINEAR_SHARPEN_ALPHA_SGIS :: GLenum +gl_LINEAR_SHARPEN_ALPHA_SGIS = 0x80AE +gl_AVERAGE_EXT :: GLenum +gl_AVERAGE_EXT = 0x8335 +gl_PACK_SKIP_IMAGES_EXT :: GLenum +gl_PACK_SKIP_IMAGES_EXT = 0x806B +gl_BITMAP_TOKEN :: GLenum +gl_BITMAP_TOKEN = 0x0704 +gl_TESSELLATION_MODE_AMD :: GLenum +gl_TESSELLATION_MODE_AMD = 0x9004 +gl_POST_CONVOLUTION_COLOR_TABLE_SGI :: GLenum +gl_POST_CONVOLUTION_COLOR_TABLE_SGI = 0x80D1 +gl_MODELVIEW1_EXT :: GLenum +gl_MODELVIEW1_EXT = 0x850A +gl_OPERAND1_RGB_ARB :: GLenum +gl_OPERAND1_RGB_ARB = 0x8591 +gl_4D_COLOR_TEXTURE :: GLenum +gl_4D_COLOR_TEXTURE = 0x0604 +gl_ACTIVE_ATTRIBUTES :: GLenum +gl_ACTIVE_ATTRIBUTES = 0x8B89 +gl_BUFFER_BINDING :: GLenum +gl_BUFFER_BINDING = 0x9302 +gl_VERTEX_STATE_PROGRAM_NV :: GLenum +gl_VERTEX_STATE_PROGRAM_NV = 0x8621 +gl_DST_ATOP_NV :: GLenum +gl_DST_ATOP_NV = 0x928F +gl_TEXTURE_DEPTH_EXT :: GLenum +gl_TEXTURE_DEPTH_EXT = 0x8071 +gl_UNSIGNED_INT_VEC4 :: GLenum +gl_UNSIGNED_INT_VEC4 = 0x8DC8 +gl_GREEN_INTEGER :: GLenum +gl_GREEN_INTEGER = 0x8D95 +gl_DOUBLE_MAT4x2_EXT :: GLenum +gl_DOUBLE_MAT4x2_EXT = 0x8F4D +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR = 0x93D7 +gl_INDEX_ARRAY_LIST_IBM :: GLenum +gl_INDEX_ARRAY_LIST_IBM = 103073 +gl_SAMPLER_2D_ARRAY_SHADOW :: GLenum +gl_SAMPLER_2D_ARRAY_SHADOW = 0x8DC4 +gl_COMPRESSED_SRGB_S3TC_DXT1_NV :: GLenum +gl_COMPRESSED_SRGB_S3TC_DXT1_NV = 0x8C4C +gl_COMPRESSED_RGBA_ASTC_4x3x3_OES :: GLenum +gl_COMPRESSED_RGBA_ASTC_4x3x3_OES = 0x93C1 +gl_DRAW_BUFFER3_ATI :: GLenum +gl_DRAW_BUFFER3_ATI = 0x8828 +gl_MAX_FRAGMENT_UNIFORM_COMPONENTS :: GLenum +gl_MAX_FRAGMENT_UNIFORM_COMPONENTS = 0x8B49 +gl_PROXY_TEXTURE_3D_EXT :: GLenum +gl_PROXY_TEXTURE_3D_EXT = 0x8070 +gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT :: GLenum +gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS_EXT = 0x8E85 +gl_PATH_COMPUTED_LENGTH_NV :: GLenum +gl_PATH_COMPUTED_LENGTH_NV = 0x90A0 +gl_DEPTH_STENCIL_MESA :: GLenum +gl_DEPTH_STENCIL_MESA = 0x8750 +gl_MAT_DIFFUSE_BIT_PGI :: GLenum +gl_MAT_DIFFUSE_BIT_PGI = 0x00400000 +gl_TEXTURE_STENCIL_SIZE :: GLenum +gl_TEXTURE_STENCIL_SIZE = 0x88F1 +gl_PATH_PROJECTION_NV :: GLenum +gl_PATH_PROJECTION_NV = 0x1701 +gl_DUAL_TEXTURE_SELECT_SGIS :: GLenum +gl_DUAL_TEXTURE_SELECT_SGIS = 0x8124 +gl_MATRIX14_ARB :: GLenum +gl_MATRIX14_ARB = 0x88CE +gl_PATH_OBJECT_BOUNDING_BOX_NV :: GLenum +gl_PATH_OBJECT_BOUNDING_BOX_NV = 0x908A +gl_READ_PIXELS :: GLenum +gl_READ_PIXELS = 0x828C +gl_TRIANGLE_LIST_SUN :: GLenum +gl_TRIANGLE_LIST_SUN = 0x81D7 +gl_COMPARE_R_TO_TEXTURE :: GLenum +gl_COMPARE_R_TO_TEXTURE = 0x884E +gl_INTENSITY8UI_EXT :: GLenum +gl_INTENSITY8UI_EXT = 0x8D7F +gl_DEBUG_OUTPUT_SYNCHRONOUS_ARB :: GLenum +gl_DEBUG_OUTPUT_SYNCHRONOUS_ARB = 0x8242 +gl_COLOR_TABLE_GREEN_SIZE :: GLenum +gl_COLOR_TABLE_GREEN_SIZE = 0x80DB +gl_CURRENT_VERTEX_ATTRIB :: GLenum +gl_CURRENT_VERTEX_ATTRIB = 0x8626 +gl_POST_COLOR_MATRIX_GREEN_BIAS :: GLenum +gl_POST_COLOR_MATRIX_GREEN_BIAS = 0x80B9 +gl_GPU_MEMORY_INFO_EVICTION_COUNT_NVX :: GLenum +gl_GPU_MEMORY_INFO_EVICTION_COUNT_NVX = 0x904A +gl_SUBSAMPLE_DISTANCE_AMD :: GLenum +gl_SUBSAMPLE_DISTANCE_AMD = 0x883F +gl_SRGB8_EXT :: GLenum +gl_SRGB8_EXT = 0x8C41 +gl_DETAIL_TEXTURE_FUNC_POINTS_SGIS :: GLenum +gl_DETAIL_TEXTURE_FUNC_POINTS_SGIS = 0x809C +gl_INCR_WRAP_EXT :: GLenum +gl_INCR_WRAP_EXT = 0x8507 +gl_UNPACK_COMPRESSED_BLOCK_SIZE :: GLenum +gl_UNPACK_COMPRESSED_BLOCK_SIZE = 0x912A +gl_OBJECT_VALIDATE_STATUS_ARB :: GLenum +gl_OBJECT_VALIDATE_STATUS_ARB = 0x8B83 +gl_WEIGHT_ARRAY_STRIDE_ARB :: GLenum +gl_WEIGHT_ARRAY_STRIDE_ARB = 0x86AA +gl_OUTPUT_TEXTURE_COORD3_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD3_EXT = 0x87A0 +gl_TEXTURE16_ARB :: GLenum +gl_TEXTURE16_ARB = 0x84D0 +gl_VIDEO_COLOR_CONVERSION_MATRIX_NV :: GLenum +gl_VIDEO_COLOR_CONVERSION_MATRIX_NV = 0x9029 +gl_EYE_DISTANCE_TO_POINT_SGIS :: GLenum +gl_EYE_DISTANCE_TO_POINT_SGIS = 0x81F0 +gl_TEXTURE_COMPARE_FUNC :: GLenum +gl_TEXTURE_COMPARE_FUNC = 0x884D +gl_DEPTH_BUFFER_FLOAT_MODE_NV :: GLenum +gl_DEPTH_BUFFER_FLOAT_MODE_NV = 0x8DAF +gl_TEXTURE_SWIZZLE_G :: GLenum +gl_TEXTURE_SWIZZLE_G = 0x8E43 +gl_DEBUG_TYPE_OTHER_ARB :: GLenum +gl_DEBUG_TYPE_OTHER_ARB = 0x8251 +gl_TESS_EVALUATION_SHADER_BIT_EXT :: GLenum +gl_TESS_EVALUATION_SHADER_BIT_EXT = 0x00000010 +gl_VERTEX_PROGRAM_CALLBACK_DATA_MESA :: GLenum +gl_VERTEX_PROGRAM_CALLBACK_DATA_MESA = 0x8BB7 +gl_INT_SAMPLER_BUFFER_EXT :: GLenum +gl_INT_SAMPLER_BUFFER_EXT = 0x8DD0 +gl_OP_CLAMP_EXT :: GLenum +gl_OP_CLAMP_EXT = 0x878E +gl_POINT_SIZE_MIN :: GLenum +gl_POINT_SIZE_MIN = 0x8126 +gl_UNSIGNED_BYTE_3_3_2_EXT :: GLenum +gl_UNSIGNED_BYTE_3_3_2_EXT = 0x8032 +gl_TEXTURE_CLIPMAP_DEPTH_SGIX :: GLenum +gl_TEXTURE_CLIPMAP_DEPTH_SGIX = 0x8176 +gl_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT :: GLenum +gl_ANY_SAMPLES_PASSED_CONSERVATIVE_EXT = 0x8D6A +gl_DOUBLE_VEC4_EXT :: GLenum +gl_DOUBLE_VEC4_EXT = 0x8FFE +gl_SYNC_CONDITION_APPLE :: GLenum +gl_SYNC_CONDITION_APPLE = 0x9113 +gl_MAX_TEXTURE_COORDS_NV :: GLenum +gl_MAX_TEXTURE_COORDS_NV = 0x8871 +gl_RELATIVE_QUADRATIC_CURVE_TO_NV :: GLenum +gl_RELATIVE_QUADRATIC_CURVE_TO_NV = 0x0B +gl_DEBUG_GROUP_STACK_DEPTH_KHR :: GLenum +gl_DEBUG_GROUP_STACK_DEPTH_KHR = 0x826D +gl_CONTEXT_LOST_KHR :: GLenum +gl_CONTEXT_LOST_KHR = 0x0507 +gl_QUADRATIC_CURVE_TO_NV :: GLenum +gl_QUADRATIC_CURVE_TO_NV = 0x0A +gl_MIN_EXT :: GLenum +gl_MIN_EXT = 0x8007 +gl_VERTEX_ATTRIB_ARRAY11_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY11_NV = 0x865B +gl_FACTOR_ALPHA_MODULATE_IMG :: GLenum +gl_FACTOR_ALPHA_MODULATE_IMG = 0x8C07 +gl_MAP1_GRID_DOMAIN :: GLenum +gl_MAP1_GRID_DOMAIN = 0x0DD0 +gl_COLOR_MATRIX_STACK_DEPTH :: GLenum +gl_COLOR_MATRIX_STACK_DEPTH = 0x80B2 +gl_IMAGE_PIXEL_FORMAT :: GLenum +gl_IMAGE_PIXEL_FORMAT = 0x82A9 +gl_DRAW_BUFFER1_EXT :: GLenum +gl_DRAW_BUFFER1_EXT = 0x8826 +gl_UNSIGNED_INT_VEC2 :: GLenum +gl_UNSIGNED_INT_VEC2 = 0x8DC6 +gl_QUAD_LUMINANCE8_SGIS :: GLenum +gl_QUAD_LUMINANCE8_SGIS = 0x8121 +gl_ELEMENT_ARRAY_UNIFIED_NV :: GLenum +gl_ELEMENT_ARRAY_UNIFIED_NV = 0x8F1F +gl_COLOR_LOGIC_OP :: GLenum +gl_COLOR_LOGIC_OP = 0x0BF2 +gl_GREEN_NV :: GLenum +gl_GREEN_NV = 0x1904 +gl_DEPTH_COMPONENT :: GLenum +gl_DEPTH_COMPONENT = 0x1902 +gl_TEXTURE18 :: GLenum +gl_TEXTURE18 = 0x84D2 +gl_COMBINER_SUM_OUTPUT_NV :: GLenum +gl_COMBINER_SUM_OUTPUT_NV = 0x854C +gl_DUAL_LUMINANCE8_SGIS :: GLenum +gl_DUAL_LUMINANCE8_SGIS = 0x8115 +gl_PATH_DASH_OFFSET_RESET_NV :: GLenum +gl_PATH_DASH_OFFSET_RESET_NV = 0x90B4 +gl_INT_SAMPLER_BUFFER :: GLenum +gl_INT_SAMPLER_BUFFER = 0x8DD0 +gl_DEBUG_SEVERITY_MEDIUM_ARB :: GLenum +gl_DEBUG_SEVERITY_MEDIUM_ARB = 0x9147 +gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT :: GLenum +gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH_EXT = 0x8C76 +gl_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX :: GLenum +gl_FRAGMENT_LIGHT_MODEL_AMBIENT_SGIX = 0x840A +gl_UNSIGNED_SHORT_15_1_MESA :: GLenum +gl_UNSIGNED_SHORT_15_1_MESA = 0x8753 +gl_LUMINANCE32F_ARB :: GLenum +gl_LUMINANCE32F_ARB = 0x8818 +gl_TRANSPOSE_NV :: GLenum +gl_TRANSPOSE_NV = 0x862C +gl_LUMINANCE8_EXT :: GLenum +gl_LUMINANCE8_EXT = 0x8040 +gl_WRITE_DISCARD_NV :: GLenum +gl_WRITE_DISCARD_NV = 0x88BE +gl_STENCIL_BUFFER_BIT5_QCOM :: GLenum +gl_STENCIL_BUFFER_BIT5_QCOM = 0x00200000 +gl_FOG_END :: GLenum +gl_FOG_END = 0x0B64 +gl_DRAW_BUFFER9_NV :: GLenum +gl_DRAW_BUFFER9_NV = 0x882E +gl_PROVOKING_VERTEX_EXT :: GLenum +gl_PROVOKING_VERTEX_EXT = 0x8E4F +gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS :: GLenum +gl_MAX_GEOMETRY_ATOMIC_COUNTER_BUFFERS = 0x92CF +gl_2PASS_0_EXT :: GLenum +gl_2PASS_0_EXT = 0x80A2 +gl_MAP_UNSYNCHRONIZED_BIT :: GLenum +gl_MAP_UNSYNCHRONIZED_BIT = 0x0020 +gl_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI :: GLenum +gl_PN_TRIANGLES_NORMAL_MODE_QUADRATIC_ATI = 0x87F8 +gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV :: GLenum +gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET_NV = 0x8E5E +gl_SAMPLER_CUBE_SHADOW :: GLenum +gl_SAMPLER_CUBE_SHADOW = 0x8DC5 +gl_V2F :: GLenum +gl_V2F = 0x2A20 +gl_IMAGE_2D_EXT :: GLenum +gl_IMAGE_2D_EXT = 0x904D +gl_LUMINANCE32UI_EXT :: GLenum +gl_LUMINANCE32UI_EXT = 0x8D74 +gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT :: GLenum +gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900F +gl_SLUMINANCE8_ALPHA8_NV :: GLenum +gl_SLUMINANCE8_ALPHA8_NV = 0x8C45 +gl_MAX_ASYNC_DRAW_PIXELS_SGIX :: GLenum +gl_MAX_ASYNC_DRAW_PIXELS_SGIX = 0x8360 +gl_POINT_SIZE_ARRAY_TYPE_OES :: GLenum +gl_POINT_SIZE_ARRAY_TYPE_OES = 0x898A +gl_SIGNED_LUMINANCE8_ALPHA8_NV :: GLenum +gl_SIGNED_LUMINANCE8_ALPHA8_NV = 0x8704 +gl_UNSIGNED_INT_24_8_EXT :: GLenum +gl_UNSIGNED_INT_24_8_EXT = 0x84FA +gl_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV :: GLenum +gl_PATH_STENCIL_DEPTH_OFFSET_UNITS_NV = 0x90BE +gl_CONIC_CURVE_TO_NV :: GLenum +gl_CONIC_CURVE_TO_NV = 0x1A +gl_STREAM_DRAW_ARB :: GLenum +gl_STREAM_DRAW_ARB = 0x88E0 +gl_ACTIVE_PROGRAM_EXT :: GLenum +gl_ACTIVE_PROGRAM_EXT = 0x8B8D +gl_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB :: GLenum +gl_MAX_COMPUTE_FIXED_GROUP_SIZE_ARB = 0x91BF +gl_PROGRAM_RESIDENT_NV :: GLenum +gl_PROGRAM_RESIDENT_NV = 0x8647 +gl_COLOR_TABLE_ALPHA_SIZE_SGI :: GLenum +gl_COLOR_TABLE_ALPHA_SIZE_SGI = 0x80DD +gl_INT_IMAGE_2D_ARRAY_EXT :: GLenum +gl_INT_IMAGE_2D_ARRAY_EXT = 0x905E +gl_OUTPUT_TEXTURE_COORD15_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD15_EXT = 0x87AC +gl_SRC_OUT_NV :: GLenum +gl_SRC_OUT_NV = 0x928C +gl_MAP_FLUSH_EXPLICIT_BIT :: GLenum +gl_MAP_FLUSH_EXPLICIT_BIT = 0x0010 +gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB :: GLenum +gl_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB = 0x8E8F +gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS :: GLenum +gl_MAX_TESS_CONTROL_TOTAL_OUTPUT_COMPONENTS = 0x8E85 +gl_EVAL_VERTEX_ATTRIB2_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB2_NV = 0x86C8 +gl_PIXEL_TILE_WIDTH_SGIX :: GLenum +gl_PIXEL_TILE_WIDTH_SGIX = 0x8140 +gl_PROXY_TEXTURE_RECTANGLE :: GLenum +gl_PROXY_TEXTURE_RECTANGLE = 0x84F7 +gl_VERTEX_ARRAY_BINDING :: GLenum +gl_VERTEX_ARRAY_BINDING = 0x85B5 +gl_CLIP_PLANE4 :: GLenum +gl_CLIP_PLANE4 = 0x3004 +gl_EVAL_VERTEX_ATTRIB15_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB15_NV = 0x86D5 +gl_POINT_FADE_THRESHOLD_SIZE_ARB :: GLenum +gl_POINT_FADE_THRESHOLD_SIZE_ARB = 0x8128 +gl_UNSIGNED_INT_5_9_9_9_REV_EXT :: GLenum +gl_UNSIGNED_INT_5_9_9_9_REV_EXT = 0x8C3E +gl_DEBUG_GROUP_STACK_DEPTH :: GLenum +gl_DEBUG_GROUP_STACK_DEPTH = 0x826D +gl_QUERY_WAIT_INVERTED :: GLenum +gl_QUERY_WAIT_INVERTED = 0x8E17 +gl_DRAW_PIXEL_TOKEN :: GLenum +gl_DRAW_PIXEL_TOKEN = 0x0705 +gl_OPERAND2_ALPHA_ARB :: GLenum +gl_OPERAND2_ALPHA_ARB = 0x859A +gl_STACK_UNDERFLOW :: GLenum +gl_STACK_UNDERFLOW = 0x0504 +gl_FLOAT_VEC4_ARB :: GLenum +gl_FLOAT_VEC4_ARB = 0x8B52 +gl_OBJECT_INFO_LOG_LENGTH_ARB :: GLenum +gl_OBJECT_INFO_LOG_LENGTH_ARB = 0x8B84 +gl_DRAW_BUFFER15_EXT :: GLenum +gl_DRAW_BUFFER15_EXT = 0x8834 +gl_PATH_PROJECTION_MATRIX_NV :: GLenum +gl_PATH_PROJECTION_MATRIX_NV = 0x0BA7 +gl_ADD_SIGNED :: GLenum +gl_ADD_SIGNED = 0x8574 +gl_FRAGMENT_INTERPOLATION_OFFSET_BITS :: GLenum +gl_FRAGMENT_INTERPOLATION_OFFSET_BITS = 0x8E5D +gl_VERTEX_SHADER_INSTRUCTIONS_EXT :: GLenum +gl_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CF +gl_NEXT_BUFFER_NV :: GLenum +gl_NEXT_BUFFER_NV = -2 +gl_TRIANGLE_STRIP_ADJACENCY_ARB :: GLenum +gl_TRIANGLE_STRIP_ADJACENCY_ARB = 0x000D +gl_UNSIGNED_BYTE_2_3_3_REV_EXT :: GLenum +gl_UNSIGNED_BYTE_2_3_3_REV_EXT = 0x8362 +gl_QUERY_RESULT_NO_WAIT :: GLenum +gl_QUERY_RESULT_NO_WAIT = 0x9194 +gl_SECONDARY_COLOR_ARRAY_ADDRESS_NV :: GLenum +gl_SECONDARY_COLOR_ARRAY_ADDRESS_NV = 0x8F27 +gl_ALPHA16_SNORM :: GLenum +gl_ALPHA16_SNORM = 0x9018 +gl_COLOR_ARRAY_LENGTH_NV :: GLenum +gl_COLOR_ARRAY_LENGTH_NV = 0x8F2D +gl_SLUMINANCE_EXT :: GLenum +gl_SLUMINANCE_EXT = 0x8C46 +gl_DOT_PRODUCT_TEXTURE_2D_NV :: GLenum +gl_DOT_PRODUCT_TEXTURE_2D_NV = 0x86EE +gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_OES = 0x8CD7 +gl_INT_IMAGE_2D_ARRAY :: GLenum +gl_INT_IMAGE_2D_ARRAY = 0x905E +gl_POLYGON_OFFSET_LINE :: GLenum +gl_POLYGON_OFFSET_LINE = 0x2A02 +gl_ONE_MINUS_DST_ALPHA :: GLenum +gl_ONE_MINUS_DST_ALPHA = 0x0305 +gl_ACCUM_BUFFER_BIT :: GLenum +gl_ACCUM_BUFFER_BIT = 0x00000200 +gl_SOURCE1_ALPHA_ARB :: GLenum +gl_SOURCE1_ALPHA_ARB = 0x8589 +gl_HISTOGRAM_WIDTH_EXT :: GLenum +gl_HISTOGRAM_WIDTH_EXT = 0x8026 +gl_RENDERBUFFER_SAMPLES_EXT :: GLenum +gl_RENDERBUFFER_SAMPLES_EXT = 0x8CAB +gl_FRAGMENT_LIGHTING_SGIX :: GLenum +gl_FRAGMENT_LIGHTING_SGIX = 0x8400 +gl_TEXTURE_WIDTH_QCOM :: GLenum +gl_TEXTURE_WIDTH_QCOM = 0x8BD2 +gl_TEXTURE_BUFFER_FORMAT_EXT :: GLenum +gl_TEXTURE_BUFFER_FORMAT_EXT = 0x8C2E +gl_VERTEX_PROGRAM_TWO_SIDE :: GLenum +gl_VERTEX_PROGRAM_TWO_SIDE = 0x8643 +gl_DEBUG_TYPE_OTHER_KHR :: GLenum +gl_DEBUG_TYPE_OTHER_KHR = 0x8251 +gl_PRIMARY_COLOR_EXT :: GLenum +gl_PRIMARY_COLOR_EXT = 0x8577 +gl_TEXTURE_COMPRESSED_ARB :: GLenum +gl_TEXTURE_COMPRESSED_ARB = 0x86A1 +gl_PROXY_TEXTURE_1D_ARRAY_EXT :: GLenum +gl_PROXY_TEXTURE_1D_ARRAY_EXT = 0x8C19 +gl_NORMAL_ARRAY_TYPE :: GLenum +gl_NORMAL_ARRAY_TYPE = 0x807E +gl_POST_COLOR_MATRIX_RED_BIAS_SGI :: GLenum +gl_POST_COLOR_MATRIX_RED_BIAS_SGI = 0x80B8 +gl_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB :: GLenum +gl_MAX_PROGRAM_NATIVE_TEX_INSTRUCTIONS_ARB = 0x880F +gl_VERTEX_ATTRIB_ARRAY7_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY7_NV = 0x8657 +gl_MAX_VERTEX_ATTRIB_STRIDE :: GLenum +gl_MAX_VERTEX_ATTRIB_STRIDE = 0x82E5 +gl_COLOR :: GLenum +gl_COLOR = 0x1800 +gl_YCBCR_422_APPLE :: GLenum +gl_YCBCR_422_APPLE = 0x85B9 +gl_TESS_GEN_SPACING :: GLenum +gl_TESS_GEN_SPACING = 0x8E77 +gl_VERTEX_SHADER_INVOCATIONS_ARB :: GLenum +gl_VERTEX_SHADER_INVOCATIONS_ARB = 0x82F0 +gl_STENCIL_INDEX4_OES :: GLenum +gl_STENCIL_INDEX4_OES = 0x8D47 +gl_COMBINER_CD_DOT_PRODUCT_NV :: GLenum +gl_COMBINER_CD_DOT_PRODUCT_NV = 0x8546 +gl_VIRTUAL_PAGE_SIZE_Z_ARB :: GLenum +gl_VIRTUAL_PAGE_SIZE_Z_ARB = 0x9197 +gl_RIGHT :: GLenum +gl_RIGHT = 0x0407 +gl_ALPHA16F_ARB :: GLenum +gl_ALPHA16F_ARB = 0x881C +gl_TANGENT_ARRAY_TYPE_EXT :: GLenum +gl_TANGENT_ARRAY_TYPE_EXT = 0x843E +gl_READ_FRAMEBUFFER_NV :: GLenum +gl_READ_FRAMEBUFFER_NV = 0x8CA8 +gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT :: GLenum +gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS_EXT = 0x8C29 +gl_PALETTE4_RGB8_OES :: GLenum +gl_PALETTE4_RGB8_OES = 0x8B90 +gl_UNSIGNED_INT_IMAGE_3D :: GLenum +gl_UNSIGNED_INT_IMAGE_3D = 0x9064 +gl_NORMAL_ARRAY_ADDRESS_NV :: GLenum +gl_NORMAL_ARRAY_ADDRESS_NV = 0x8F22 +gl_NO_RESET_NOTIFICATION_EXT :: GLenum +gl_NO_RESET_NOTIFICATION_EXT = 0x8261 +gl_RGB4_S3TC :: GLenum +gl_RGB4_S3TC = 0x83A1 +gl_AUX1 :: GLenum +gl_AUX1 = 0x040A +gl_MODELVIEW1_ARB :: GLenum +gl_MODELVIEW1_ARB = 0x850A +gl_OP_NEGATE_EXT :: GLenum +gl_OP_NEGATE_EXT = 0x8783 +gl_PACK_COMPRESSED_BLOCK_HEIGHT :: GLenum +gl_PACK_COMPRESSED_BLOCK_HEIGHT = 0x912C +gl_RENDERBUFFER_BINDING_OES :: GLenum +gl_RENDERBUFFER_BINDING_OES = 0x8CA7 +gl_INT_IMAGE_1D :: GLenum +gl_INT_IMAGE_1D = 0x9057 +gl_TEXTURE_GEQUAL_R_SGIX :: GLenum +gl_TEXTURE_GEQUAL_R_SGIX = 0x819D +gl_VERTEX_BINDING_DIVISOR :: GLenum +gl_VERTEX_BINDING_DIVISOR = 0x82D6 +gl_BLEND_SRC_ALPHA_OES :: GLenum +gl_BLEND_SRC_ALPHA_OES = 0x80CB +gl_READ_BUFFER_NV :: GLenum +gl_READ_BUFFER_NV = 0x0C02 +gl_DEBUG_TYPE_ERROR_KHR :: GLenum +gl_DEBUG_TYPE_ERROR_KHR = 0x824C +gl_INT_IMAGE_CUBE_EXT :: GLenum +gl_INT_IMAGE_CUBE_EXT = 0x905B +gl_COMPRESSED_RGBA_ASTC_6x6x6_OES :: GLenum +gl_COMPRESSED_RGBA_ASTC_6x6x6_OES = 0x93C9 +gl_IMAGE_MIN_FILTER_HP :: GLenum +gl_IMAGE_MIN_FILTER_HP = 0x815D +gl_QUAD_ALPHA8_SGIS :: GLenum +gl_QUAD_ALPHA8_SGIS = 0x811F +gl_IMAGE_BINDING_LEVEL :: GLenum +gl_IMAGE_BINDING_LEVEL = 0x8F3B +gl_DOT3_RGB_EXT :: GLenum +gl_DOT3_RGB_EXT = 0x8740 +gl_SAMPLER_3D_OES :: GLenum +gl_SAMPLER_3D_OES = 0x8B5F +gl_INT_VEC4 :: GLenum +gl_INT_VEC4 = 0x8B55 +gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT = 0x8CDC +gl_NO_RESET_NOTIFICATION_ARB :: GLenum +gl_NO_RESET_NOTIFICATION_ARB = 0x8261 +gl_IMAGE_MAG_FILTER_HP :: GLenum +gl_IMAGE_MAG_FILTER_HP = 0x815C +gl_COLOR4_BIT_PGI :: GLenum +gl_COLOR4_BIT_PGI = 0x00020000 +gl_MAX_CLIPMAP_DEPTH_SGIX :: GLenum +gl_MAX_CLIPMAP_DEPTH_SGIX = 0x8177 +gl_DEBUG_CATEGORY_OTHER_AMD :: GLenum +gl_DEBUG_CATEGORY_OTHER_AMD = 0x9150 +gl_INT_IMAGE_2D_MULTISAMPLE :: GLenum +gl_INT_IMAGE_2D_MULTISAMPLE = 0x9060 +gl_PERFQUERY_COUNTER_DATA_FLOAT_INTEL :: GLenum +gl_PERFQUERY_COUNTER_DATA_FLOAT_INTEL = 0x94FA +gl_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB :: GLenum +gl_MAX_PROGRAM_NATIVE_INSTRUCTIONS_ARB = 0x88A3 +gl_BINORMAL_ARRAY_EXT :: GLenum +gl_BINORMAL_ARRAY_EXT = 0x843A +gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_COMPONENT_TYPE_EXT = 0x8211 +gl_DRAW_BUFFER9_ARB :: GLenum +gl_DRAW_BUFFER9_ARB = 0x882E +gl_DSDT8_NV :: GLenum +gl_DSDT8_NV = 0x8709 +gl_MAP1_VERTEX_ATTRIB9_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB9_4_NV = 0x8669 +gl_PROGRAM_OBJECT_ARB :: GLenum +gl_PROGRAM_OBJECT_ARB = 0x8B40 +gl_FONT_UNDERLINE_POSITION_BIT_NV :: GLenum +gl_FONT_UNDERLINE_POSITION_BIT_NV = 0x04000000 +gl_SHADER_OPERATION_NV :: GLenum +gl_SHADER_OPERATION_NV = 0x86DF +gl_QUERY_RESULT_AVAILABLE_EXT :: GLenum +gl_QUERY_RESULT_AVAILABLE_EXT = 0x8867 +gl_VIVIDLIGHT_NV :: GLenum +gl_VIVIDLIGHT_NV = 0x92A6 +gl_HSL_HUE_NV :: GLenum +gl_HSL_HUE_NV = 0x92AD +gl_EMBOSS_MAP_NV :: GLenum +gl_EMBOSS_MAP_NV = 0x855F +gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB :: GLenum +gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB = 0x824D +gl_ALL_BARRIER_BITS :: GLenum +gl_ALL_BARRIER_BITS = 0xFFFFFFFF +gl_TEXTURE11_ARB :: GLenum +gl_TEXTURE11_ARB = 0x84CB +gl_BOLD_BIT_NV :: GLenum +gl_BOLD_BIT_NV = 0x01 +gl_SAMPLE_BUFFERS_3DFX :: GLenum +gl_SAMPLE_BUFFERS_3DFX = 0x86B3 +gl_INTERNALFORMAT_ALPHA_SIZE :: GLenum +gl_INTERNALFORMAT_ALPHA_SIZE = 0x8274 +gl_COMPRESSED_RGBA_ASTC_8x8_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_8x8_KHR = 0x93B7 +gl_VIRTUAL_PAGE_SIZE_Z_AMD :: GLenum +gl_VIRTUAL_PAGE_SIZE_Z_AMD = 0x9197 +gl_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE :: GLenum +gl_VERTEX_ATTRIB_MAP2_DOMAIN_APPLE = 0x8A09 +gl_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB :: GLenum +gl_GEOMETRY_SHADER_PRIMITIVES_EMITTED_ARB = 0x82F3 +gl_DRAW_PIXELS_APPLE :: GLenum +gl_DRAW_PIXELS_APPLE = 0x8A0A +gl_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB = 0x8519 +gl_FRAGMENT_COLOR_MATERIAL_FACE_SGIX :: GLenum +gl_FRAGMENT_COLOR_MATERIAL_FACE_SGIX = 0x8402 +gl_DRAW_INDIRECT_ADDRESS_NV :: GLenum +gl_DRAW_INDIRECT_ADDRESS_NV = 0x8F41 +gl_COVERAGE_BUFFER_BIT_NV :: GLenum +gl_COVERAGE_BUFFER_BIT_NV = 0x00008000 +gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT :: GLenum +gl_MAX_TESS_EVALUATION_IMAGE_UNIFORMS_EXT = 0x90CC +gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_EXT = 0x8DA9 +gl_BLUE_NV :: GLenum +gl_BLUE_NV = 0x1905 +gl_TEXTURE0_ARB :: GLenum +gl_TEXTURE0_ARB = 0x84C0 +gl_DEBUG_SOURCE_THIRD_PARTY_ARB :: GLenum +gl_DEBUG_SOURCE_THIRD_PARTY_ARB = 0x8249 +gl_TEXTURE_NORMAL_EXT :: GLenum +gl_TEXTURE_NORMAL_EXT = 0x85AF +gl_TEXTURE_BUFFER_FORMAT_ARB :: GLenum +gl_TEXTURE_BUFFER_FORMAT_ARB = 0x8C2E +gl_OPERAND0_ALPHA :: GLenum +gl_OPERAND0_ALPHA = 0x8598 +gl_FLOAT_MAT2x3 :: GLenum +gl_FLOAT_MAT2x3 = 0x8B65 +gl_TEXTURE_BINDING :: GLenum +gl_TEXTURE_BINDING = 0x82EB +gl_INT_SAMPLER_2D :: GLenum +gl_INT_SAMPLER_2D = 0x8DCA +gl_OR :: GLenum +gl_OR = 0x1507 +gl_INT16_VEC2_NV :: GLenum +gl_INT16_VEC2_NV = 0x8FE5 +gl_DUAL_ALPHA4_SGIS :: GLenum +gl_DUAL_ALPHA4_SGIS = 0x8110 +gl_FRAMEZOOM_FACTOR_SGIX :: GLenum +gl_FRAMEZOOM_FACTOR_SGIX = 0x818C +gl_IMAGE_2D_MULTISAMPLE_ARRAY_EXT :: GLenum +gl_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x9056 +gl_RGB_INTEGER :: GLenum +gl_RGB_INTEGER = 0x8D98 +gl_UNSIGNED_INT64_VEC2_NV :: GLenum +gl_UNSIGNED_INT64_VEC2_NV = 0x8FF5 +gl_OUTPUT_TEXTURE_COORD21_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD21_EXT = 0x87B2 +gl_ENABLE_BIT :: GLenum +gl_ENABLE_BIT = 0x00002000 +gl_POLYGON_OFFSET_EXT :: GLenum +gl_POLYGON_OFFSET_EXT = 0x8037 +gl_PIXEL_TEX_GEN_MODE_SGIX :: GLenum +gl_PIXEL_TEX_GEN_MODE_SGIX = 0x832B +gl_LINE_SMOOTH :: GLenum +gl_LINE_SMOOTH = 0x0B20 +gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB :: GLenum +gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS_ARB = 0x919A +gl_COLOR_TABLE_LUMINANCE_SIZE_SGI :: GLenum +gl_COLOR_TABLE_LUMINANCE_SIZE_SGI = 0x80DE +gl_COLOR_BUFFER_BIT7_QCOM :: GLenum +gl_COLOR_BUFFER_BIT7_QCOM = 0x00000080 +gl_PATH_FILL_MODE_NV :: GLenum +gl_PATH_FILL_MODE_NV = 0x9080 +gl_IMAGE_CUBE :: GLenum +gl_IMAGE_CUBE = 0x9050 +gl_CON_5_ATI :: GLenum +gl_CON_5_ATI = 0x8946 +gl_COLOR_ATTACHMENT2_EXT :: GLenum +gl_COLOR_ATTACHMENT2_EXT = 0x8CE2 +gl_FAILURE_NV :: GLenum +gl_FAILURE_NV = 0x9030 +gl_VERTEX_ARRAY_LIST_STRIDE_IBM :: GLenum +gl_VERTEX_ARRAY_LIST_STRIDE_IBM = 103080 +gl_MAX_SPARSE_TEXTURE_SIZE_ARB :: GLenum +gl_MAX_SPARSE_TEXTURE_SIZE_ARB = 0x9198 +gl_VERSION_ES_CL_1_1 :: GLenum +gl_VERSION_ES_CL_1_1 = 1 +gl_PERFMON_GLOBAL_MODE_QCOM :: GLenum +gl_PERFMON_GLOBAL_MODE_QCOM = 0x8FA0 +gl_DEPTH_COMPONENT32F :: GLenum +gl_DEPTH_COMPONENT32F = 0x8CAC +gl_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT :: GLenum +gl_MAX_GEOMETRY_OUTPUT_COMPONENTS_EXT = 0x9124 +gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS :: GLenum +gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E7F +gl_IMAGE_2D_MULTISAMPLE_EXT :: GLenum +gl_IMAGE_2D_MULTISAMPLE_EXT = 0x9055 +gl_FRAMEBUFFER_OES :: GLenum +gl_FRAMEBUFFER_OES = 0x8D40 +gl_TRANSPOSE_PROJECTION_MATRIX :: GLenum +gl_TRANSPOSE_PROJECTION_MATRIX = 0x84E4 +gl_BUFFER_MAP_POINTER :: GLenum +gl_BUFFER_MAP_POINTER = 0x88BD +gl_INT_10_10_10_2_OES :: GLenum +gl_INT_10_10_10_2_OES = 0x8DF7 +gl_PROGRAM_PIPELINE_OBJECT_EXT :: GLenum +gl_PROGRAM_PIPELINE_OBJECT_EXT = 0x8A4F +gl_GEOMETRY_SHADER_INVOCATIONS_EXT :: GLenum +gl_GEOMETRY_SHADER_INVOCATIONS_EXT = 0x887F +gl_SPRITE_AXIS_SGIX :: GLenum +gl_SPRITE_AXIS_SGIX = 0x814A +gl_RED_INTEGER_EXT :: GLenum +gl_RED_INTEGER_EXT = 0x8D94 +gl_COMPRESSED_RGBA_ASTC_10x6_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_10x6_KHR = 0x93B9 +gl_TEXTURE_COORD_ARRAY_COUNT_EXT :: GLenum +gl_TEXTURE_COORD_ARRAY_COUNT_EXT = 0x808B +gl_SIGNED_RGB_NV :: GLenum +gl_SIGNED_RGB_NV = 0x86FE +gl_CW :: GLenum +gl_CW = 0x0900 +gl_PACK_SUBSAMPLE_RATE_SGIX :: GLenum +gl_PACK_SUBSAMPLE_RATE_SGIX = 0x85A0 +gl_TEXTURE14_ARB :: GLenum +gl_TEXTURE14_ARB = 0x84CE +gl_OUTPUT_TEXTURE_COORD26_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD26_EXT = 0x87B7 +gl_DRAW_BUFFER :: GLenum +gl_DRAW_BUFFER = 0x0C01 +gl_PACK_ROW_BYTES_APPLE :: GLenum +gl_PACK_ROW_BYTES_APPLE = 0x8A15 +gl_BLUE_INTEGER_EXT :: GLenum +gl_BLUE_INTEGER_EXT = 0x8D96 +gl_STORAGE_CLIENT_APPLE :: GLenum +gl_STORAGE_CLIENT_APPLE = 0x85B4 +gl_ALL_SHADER_BITS :: GLenum +gl_ALL_SHADER_BITS = 0xFFFFFFFF +gl_FOG_COORDINATE_ARRAY_POINTER :: GLenum +gl_FOG_COORDINATE_ARRAY_POINTER = 0x8456 +gl_ACTIVE_PROGRAM :: GLenum +gl_ACTIVE_PROGRAM = 0x8259 +gl_RGBA32F_ARB :: GLenum +gl_RGBA32F_ARB = 0x8814 +gl_VERTEX_ATTRIB_ARRAY_INTEGER :: GLenum +gl_VERTEX_ATTRIB_ARRAY_INTEGER = 0x88FD +gl_MAP2_VERTEX_ATTRIB13_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB13_4_NV = 0x867D +gl_SAMPLER_2D :: GLenum +gl_SAMPLER_2D = 0x8B5E +gl_QUERY :: GLenum +gl_QUERY = 0x82E3 +gl_GEOMETRY_INPUT_TYPE_EXT :: GLenum +gl_GEOMETRY_INPUT_TYPE_EXT = 0x8DDB +gl_RGB5_A1_OES :: GLenum +gl_RGB5_A1_OES = 0x8057 +gl_MATRIX15_ARB :: GLenum +gl_MATRIX15_ARB = 0x88CF +gl_INT_IMAGE_CUBE_MAP_ARRAY :: GLenum +gl_INT_IMAGE_CUBE_MAP_ARRAY = 0x905F +gl_STACK_OVERFLOW :: GLenum +gl_STACK_OVERFLOW = 0x0503 +gl_NORMAL_ARRAY_LENGTH_NV :: GLenum +gl_NORMAL_ARRAY_LENGTH_NV = 0x8F2C +gl_RENDERBUFFER_BLUE_SIZE_EXT :: GLenum +gl_RENDERBUFFER_BLUE_SIZE_EXT = 0x8D52 +gl_TEXTURE_INTENSITY_SIZE_EXT :: GLenum +gl_TEXTURE_INTENSITY_SIZE_EXT = 0x8061 +gl_POINT_SIZE_MIN_SGIS :: GLenum +gl_POINT_SIZE_MIN_SGIS = 0x8126 +gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW :: GLenum +gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW = 0x900D +gl_BEVEL_NV :: GLenum +gl_BEVEL_NV = 0x90A6 +gl_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX :: GLenum +gl_DEPTH_PASS_INSTRUMENT_COUNTERS_SGIX = 0x8311 +gl_SIGNED_RGBA_NV :: GLenum +gl_SIGNED_RGBA_NV = 0x86FB +gl_COLOR_CLEAR_VALUE :: GLenum +gl_COLOR_CLEAR_VALUE = 0x0C22 +gl_ARRAY_BUFFER :: GLenum +gl_ARRAY_BUFFER = 0x8892 +gl_CLIP_PLANE2_IMG :: GLenum +gl_CLIP_PLANE2_IMG = 0x3002 +gl_POLYGON_OFFSET_UNITS :: GLenum +gl_POLYGON_OFFSET_UNITS = 0x2A00 +gl_COLOR_ARRAY_POINTER_EXT :: GLenum +gl_COLOR_ARRAY_POINTER_EXT = 0x8090 +gl_POST_COLOR_MATRIX_COLOR_TABLE :: GLenum +gl_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D2 +gl_SHADOW_AMBIENT_SGIX :: GLenum +gl_SHADOW_AMBIENT_SGIX = 0x80BF +gl_SAMPLES :: GLenum +gl_SAMPLES = 0x80A9 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4x4_OES = 0x93E4 +gl_MIRRORED_REPEAT_IBM :: GLenum +gl_MIRRORED_REPEAT_IBM = 0x8370 +gl_TEXTURE_2D_MULTISAMPLE_ARRAY_OES :: GLenum +gl_TEXTURE_2D_MULTISAMPLE_ARRAY_OES = 0x9102 +gl_FRAMEBUFFER_DEFAULT_WIDTH :: GLenum +gl_FRAMEBUFFER_DEFAULT_WIDTH = 0x9310 +gl_TEXTURE_GEN_MODE_OES :: GLenum +gl_TEXTURE_GEN_MODE_OES = 0x2500 +gl_BLEND_SRC_ALPHA_EXT :: GLenum +gl_BLEND_SRC_ALPHA_EXT = 0x80CB +gl_OUTPUT_COLOR0_EXT :: GLenum +gl_OUTPUT_COLOR0_EXT = 0x879B +gl_SLUMINANCE8_ALPHA8 :: GLenum +gl_SLUMINANCE8_ALPHA8 = 0x8C45 +gl_SAMPLER_3D_ARB :: GLenum +gl_SAMPLER_3D_ARB = 0x8B5F +gl_UNSIGNED_INT_SAMPLER_3D :: GLenum +gl_UNSIGNED_INT_SAMPLER_3D = 0x8DD3 +gl_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT = 0x8CDA +gl_PATH_FORMAT_SVG_NV :: GLenum +gl_PATH_FORMAT_SVG_NV = 0x9070 +gl_MAP1_BINORMAL_EXT :: GLenum +gl_MAP1_BINORMAL_EXT = 0x8446 +gl_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX :: GLenum +gl_PIXEL_TEX_GEN_ALPHA_NO_REPLACE_SGIX = 0x8188 +gl_COLOR_ARRAY_BUFFER_BINDING :: GLenum +gl_COLOR_ARRAY_BUFFER_BINDING = 0x8898 +gl_MATRIX_INDEX_ARRAY_TYPE_OES :: GLenum +gl_MATRIX_INDEX_ARRAY_TYPE_OES = 0x8847 +gl_PROJECTION_STACK_DEPTH :: GLenum +gl_PROJECTION_STACK_DEPTH = 0x0BA4 +gl_AUTO_NORMAL :: GLenum +gl_AUTO_NORMAL = 0x0D80 +gl_FRAGMENT_SHADER_ATI :: GLenum +gl_FRAGMENT_SHADER_ATI = 0x8920 +gl_SAMPLE_BUFFERS_EXT :: GLenum +gl_SAMPLE_BUFFERS_EXT = 0x80A8 +gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT :: GLenum +gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x906C +gl_UNSIGNED_INT_10_10_10_2 :: GLenum +gl_UNSIGNED_INT_10_10_10_2 = 0x8036 +gl_COMPRESSED_RG11_EAC_OES :: GLenum +gl_COMPRESSED_RG11_EAC_OES = 0x9272 +gl_LUMINANCE8I_EXT :: GLenum +gl_LUMINANCE8I_EXT = 0x8D92 +gl_VERTEX_ATTRIB_ARRAY13_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY13_NV = 0x865D +gl_UNIFORM_BUFFER_SIZE :: GLenum +gl_UNIFORM_BUFFER_SIZE = 0x8A2A +gl_TEXTURE2_ARB :: GLenum +gl_TEXTURE2_ARB = 0x84C2 +gl_COMPRESSED_RGBA_BPTC_UNORM_ARB :: GLenum +gl_COMPRESSED_RGBA_BPTC_UNORM_ARB = 0x8E8C +gl_POLYGON :: GLenum +gl_POLYGON = 0x0009 +gl_CLIENT_MAPPED_BUFFER_BARRIER_BIT :: GLenum +gl_CLIENT_MAPPED_BUFFER_BARRIER_BIT = 0x00004000 +gl_ELEMENT_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_ELEMENT_ARRAY_BUFFER_BINDING_ARB = 0x8895 +gl_SAMPLE_BUFFERS_ARB :: GLenum +gl_SAMPLE_BUFFERS_ARB = 0x80A8 +gl_RGBA4_DXT5_S3TC :: GLenum +gl_RGBA4_DXT5_S3TC = 0x83A5 +gl_STREAM_READ :: GLenum +gl_STREAM_READ = 0x88E1 +gl_STATIC_READ :: GLenum +gl_STATIC_READ = 0x88E5 +gl_MAX_FRAGMENT_ATOMIC_COUNTERS :: GLenum +gl_MAX_FRAGMENT_ATOMIC_COUNTERS = 0x92D6 +gl_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT :: GLenum +gl_COMPRESSED_LUMINANCE_ALPHA_LATC2_EXT = 0x8C72 +gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST :: GLenum +gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_TEST = 0x82AD +gl_COUNT_DOWN_NV :: GLenum +gl_COUNT_DOWN_NV = 0x9089 +gl_SLUMINANCE :: GLenum +gl_SLUMINANCE = 0x8C46 +gl_INNOCENT_CONTEXT_RESET :: GLenum +gl_INNOCENT_CONTEXT_RESET = 0x8254 +gl_DRAW_FRAMEBUFFER_BINDING_NV :: GLenum +gl_DRAW_FRAMEBUFFER_BINDING_NV = 0x8CA6 +gl_VERTEX_STREAM3_ATI :: GLenum +gl_VERTEX_STREAM3_ATI = 0x876F +gl_TRIANGULAR_NV :: GLenum +gl_TRIANGULAR_NV = 0x90A5 +gl_SAMPLER_2D_RECT_ARB :: GLenum +gl_SAMPLER_2D_RECT_ARB = 0x8B63 +gl_POST_CONVOLUTION_GREEN_SCALE_EXT :: GLenum +gl_POST_CONVOLUTION_GREEN_SCALE_EXT = 0x801D +gl_SKIP_COMPONENTS2_NV :: GLenum +gl_SKIP_COMPONENTS2_NV = -5 +gl_IMAGE_1D :: GLenum +gl_IMAGE_1D = 0x904C +gl_ATTRIB_ARRAY_TYPE_NV :: GLenum +gl_ATTRIB_ARRAY_TYPE_NV = 0x8625 +gl_ORDER :: GLenum +gl_ORDER = 0x0A01 +gl_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB :: GLenum +gl_MAX_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x880E +gl_RGB4_EXT :: GLenum +gl_RGB4_EXT = 0x804F +gl_COMPRESSED_TEXTURE_FORMATS_ARB :: GLenum +gl_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A3 +gl_STENCIL_INDEX16_EXT :: GLenum +gl_STENCIL_INDEX16_EXT = 0x8D49 +gl_OP_RECIP_SQRT_EXT :: GLenum +gl_OP_RECIP_SQRT_EXT = 0x8795 +gl_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS :: GLenum +gl_MAX_COMBINED_ATOMIC_COUNTER_BUFFERS = 0x92D1 +gl_MAX_PROGRAM_TEXEL_OFFSET :: GLenum +gl_MAX_PROGRAM_TEXEL_OFFSET = 0x8905 +gl_POST_TEXTURE_FILTER_BIAS_SGIX :: GLenum +gl_POST_TEXTURE_FILTER_BIAS_SGIX = 0x8179 +gl_RGB32F_EXT :: GLenum +gl_RGB32F_EXT = 0x8815 +gl_SURFACE_REGISTERED_NV :: GLenum +gl_SURFACE_REGISTERED_NV = 0x86FD +gl_RGBA_FLOAT16_APPLE :: GLenum +gl_RGBA_FLOAT16_APPLE = 0x881A +gl_VIDEO_BUFFER_BINDING_NV :: GLenum +gl_VIDEO_BUFFER_BINDING_NV = 0x9021 +gl_PRIMITIVE_RESTART_INDEX :: GLenum +gl_PRIMITIVE_RESTART_INDEX = 0x8F9E +gl_DOT3_RGB_ARB :: GLenum +gl_DOT3_RGB_ARB = 0x86AE +gl_INT64_VEC4_NV :: GLenum +gl_INT64_VEC4_NV = 0x8FEB +gl_DRAW_BUFFER12_ATI :: GLenum +gl_DRAW_BUFFER12_ATI = 0x8831 +gl_RESAMPLE_REPLICATE_SGIX :: GLenum +gl_RESAMPLE_REPLICATE_SGIX = 0x842E +gl_ALPHA :: GLenum +gl_ALPHA = 0x1906 +gl_MATRIX22_ARB :: GLenum +gl_MATRIX22_ARB = 0x88D6 +gl_DEPTH_TEST :: GLenum +gl_DEPTH_TEST = 0x0B71 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR = 0x93D5 +gl_BLEND_SRC_ALPHA :: GLenum +gl_BLEND_SRC_ALPHA = 0x80CB +gl_MIRROR_CLAMP_ATI :: GLenum +gl_MIRROR_CLAMP_ATI = 0x8742 +gl_COMBINER3_NV :: GLenum +gl_COMBINER3_NV = 0x8553 +gl_TEXTURE_BINDING_1D_ARRAY_EXT :: GLenum +gl_TEXTURE_BINDING_1D_ARRAY_EXT = 0x8C1C +gl_MIRROR_CLAMP_TO_BORDER_EXT :: GLenum +gl_MIRROR_CLAMP_TO_BORDER_EXT = 0x8912 +gl_MAP1_INDEX :: GLenum +gl_MAP1_INDEX = 0x0D91 +gl_VIEW_CLASS_BPTC_FLOAT :: GLenum +gl_VIEW_CLASS_BPTC_FLOAT = 0x82D3 +gl_TRANSPOSE_AFFINE_2D_NV :: GLenum +gl_TRANSPOSE_AFFINE_2D_NV = 0x9096 +gl_IMAGE_CLASS_2_X_8 :: GLenum +gl_IMAGE_CLASS_2_X_8 = 0x82C0 +gl_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB :: GLenum +gl_PROGRAM_NATIVE_ALU_INSTRUCTIONS_ARB = 0x8808 +gl_EYE_POINT_SGIS :: GLenum +gl_EYE_POINT_SGIS = 0x81F4 +gl_TEXTURE_DEPTH_SIZE_ARB :: GLenum +gl_TEXTURE_DEPTH_SIZE_ARB = 0x884A +gl_GLYPH_HAS_KERNING_BIT_NV :: GLenum +gl_GLYPH_HAS_KERNING_BIT_NV = 0x100 +gl_ACTIVE_SUBROUTINES :: GLenum +gl_ACTIVE_SUBROUTINES = 0x8DE5 +gl_MVP_MATRIX_EXT :: GLenum +gl_MVP_MATRIX_EXT = 0x87E3 +gl_READ_FRAMEBUFFER_BINDING :: GLenum +gl_READ_FRAMEBUFFER_BINDING = 0x8CAA +gl_GUILTY_CONTEXT_RESET_EXT :: GLenum +gl_GUILTY_CONTEXT_RESET_EXT = 0x8253 +gl_ALPHA16UI_EXT :: GLenum +gl_ALPHA16UI_EXT = 0x8D78 +gl_TEXTURE_SWIZZLE_B_EXT :: GLenum +gl_TEXTURE_SWIZZLE_B_EXT = 0x8E44 +gl_RGB16I_EXT :: GLenum +gl_RGB16I_EXT = 0x8D89 +gl_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_EDGE_FLAG_ARRAY_BUFFER_BINDING_ARB = 0x889B +gl_VERTEX_WEIGHT_ARRAY_EXT :: GLenum +gl_VERTEX_WEIGHT_ARRAY_EXT = 0x850C +gl_SWIZZLE_STR_DR_ATI :: GLenum +gl_SWIZZLE_STR_DR_ATI = 0x8978 +gl_READ_FRAMEBUFFER :: GLenum +gl_READ_FRAMEBUFFER = 0x8CA8 +gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI :: GLenum +gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D5 +gl_COORD_REPLACE_NV :: GLenum +gl_COORD_REPLACE_NV = 0x8862 +gl_MAX_CLIP_PLANES :: GLenum +gl_MAX_CLIP_PLANES = 0x0D32 +gl_DRAW_BUFFER0 :: GLenum +gl_DRAW_BUFFER0 = 0x8825 +gl_SPRITE_OBJECT_ALIGNED_SGIX :: GLenum +gl_SPRITE_OBJECT_ALIGNED_SGIX = 0x814D +gl_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX :: GLenum +gl_FRAGMENT_LIGHT_MODEL_NORMAL_INTERPOLATION_SGIX = 0x840B +gl_CONSERVE_MEMORY_HINT_PGI :: GLenum +gl_CONSERVE_MEMORY_HINT_PGI = 0x1A1FD +gl_GET_TEXTURE_IMAGE_FORMAT :: GLenum +gl_GET_TEXTURE_IMAGE_FORMAT = 0x8291 +gl_MOVE_TO_RESETS_NV :: GLenum +gl_MOVE_TO_RESETS_NV = 0x90B5 +gl_SHADER_CONSISTENT_NV :: GLenum +gl_SHADER_CONSISTENT_NV = 0x86DD +gl_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_X_EXT = 0x8516 +gl_PACK_ALIGNMENT :: GLenum +gl_PACK_ALIGNMENT = 0x0D05 +gl_HISTOGRAM_ALPHA_SIZE :: GLenum +gl_HISTOGRAM_ALPHA_SIZE = 0x802B +gl_SHARED_TEXTURE_PALETTE_EXT :: GLenum +gl_SHARED_TEXTURE_PALETTE_EXT = 0x81FB +gl_MODELVIEW0_MATRIX_EXT :: GLenum +gl_MODELVIEW0_MATRIX_EXT = 0x0BA6 +gl_MAX_NAME_LENGTH :: GLenum +gl_MAX_NAME_LENGTH = 0x92F6 +gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY :: GLenum +gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY = 0x9105 +gl_IMAGE_2D :: GLenum +gl_IMAGE_2D = 0x904D +gl_QUERY_BUFFER_AMD :: GLenum +gl_QUERY_BUFFER_AMD = 0x9192 +gl_BUMP_ENVMAP_ATI :: GLenum +gl_BUMP_ENVMAP_ATI = 0x877B +gl_POINTS :: GLenum +gl_POINTS = 0x0000 +gl_ARRAY_SIZE :: GLenum +gl_ARRAY_SIZE = 0x92FB +gl_MAX_CLIP_PLANES_IMG :: GLenum +gl_MAX_CLIP_PLANES_IMG = 0x0D32 +gl_TRIANGLE_STRIP_ADJACENCY_EXT :: GLenum +gl_TRIANGLE_STRIP_ADJACENCY_EXT = 0x000D +gl_VERTEX_STREAM6_ATI :: GLenum +gl_VERTEX_STREAM6_ATI = 0x8772 +gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR :: GLenum +gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_KHR = 0x824E +gl_TEXTURE22 :: GLenum +gl_TEXTURE22 = 0x84D6 +gl_CURRENT_FOG_COORDINATE :: GLenum +gl_CURRENT_FOG_COORDINATE = 0x8453 +gl_CON_27_ATI :: GLenum +gl_CON_27_ATI = 0x895C +gl_MAX_VERTEX_UNITS_OES :: GLenum +gl_MAX_VERTEX_UNITS_OES = 0x86A4 +gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT :: GLenum +gl_MAX_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8DDF +gl_SIGNED_INTENSITY8_NV :: GLenum +gl_SIGNED_INTENSITY8_NV = 0x8708 +gl_MAX_EVAL_ORDER :: GLenum +gl_MAX_EVAL_ORDER = 0x0D30 +gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_EXT = 0x8518 +gl_DYNAMIC_READ_ARB :: GLenum +gl_DYNAMIC_READ_ARB = 0x88E9 +gl_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV :: GLenum +gl_DOT_PRODUCT_AFFINE_DEPTH_REPLACE_NV = 0x885D +gl_FLOAT16_NV :: GLenum +gl_FLOAT16_NV = 0x8FF8 +gl_COMPUTE_SHADER_INVOCATIONS_ARB :: GLenum +gl_COMPUTE_SHADER_INVOCATIONS_ARB = 0x82F5 +gl_VERTEX_SHADER_OPTIMIZED_EXT :: GLenum +gl_VERTEX_SHADER_OPTIMIZED_EXT = 0x87D4 +gl_TEXTURE_LOD_BIAS_EXT :: GLenum +gl_TEXTURE_LOD_BIAS_EXT = 0x8501 +gl_INT8_VEC3_NV :: GLenum +gl_INT8_VEC3_NV = 0x8FE2 +gl_4PASS_0_SGIS :: GLenum +gl_4PASS_0_SGIS = 0x80A4 +gl_HISTOGRAM_EXT :: GLenum +gl_HISTOGRAM_EXT = 0x8024 +gl_ALLOW_DRAW_WIN_HINT_PGI :: GLenum +gl_ALLOW_DRAW_WIN_HINT_PGI = 0x1A20F +gl_TEXTURE_GREEN_SIZE_EXT :: GLenum +gl_TEXTURE_GREEN_SIZE_EXT = 0x805D +gl_R32I :: GLenum +gl_R32I = 0x8235 +gl_REG_22_ATI :: GLenum +gl_REG_22_ATI = 0x8937 +gl_UNSIGNED_INT_ATOMIC_COUNTER :: GLenum +gl_UNSIGNED_INT_ATOMIC_COUNTER = 0x92DB +gl_COLOR_ATTACHMENT2 :: GLenum +gl_COLOR_ATTACHMENT2 = 0x8CE2 +gl_INTENSITY8 :: GLenum +gl_INTENSITY8 = 0x804B +gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS :: GLenum +gl_MAX_GEOMETRY_SHADER_STORAGE_BLOCKS = 0x90D7 +gl_FOG_DENSITY :: GLenum +gl_FOG_DENSITY = 0x0B62 +gl_RENDERBUFFER_HEIGHT_EXT :: GLenum +gl_RENDERBUFFER_HEIGHT_EXT = 0x8D43 +gl_Z_EXT :: GLenum +gl_Z_EXT = 0x87D7 +gl_TEXTURE_FETCH_BARRIER_BIT :: GLenum +gl_TEXTURE_FETCH_BARRIER_BIT = 0x00000008 +gl_PROGRAM_BINARY_FORMATS :: GLenum +gl_PROGRAM_BINARY_FORMATS = 0x87FF +gl_UNSIGNED_INT_IMAGE_BUFFER :: GLenum +gl_UNSIGNED_INT_IMAGE_BUFFER = 0x9067 +gl_OPERAND0_RGB :: GLenum +gl_OPERAND0_RGB = 0x8590 +gl_COVERAGE_COMPONENT_NV :: GLenum +gl_COVERAGE_COMPONENT_NV = 0x8ED0 +gl_NEGATE_BIT_ATI :: GLenum +gl_NEGATE_BIT_ATI = 0x00000004 +gl_DEBUG_TYPE_PUSH_GROUP :: GLenum +gl_DEBUG_TYPE_PUSH_GROUP = 0x8269 +gl_SELECT :: GLenum +gl_SELECT = 0x1C02 +gl_IMAGE_BINDING_ACCESS_EXT :: GLenum +gl_IMAGE_BINDING_ACCESS_EXT = 0x8F3E +gl_TEXTURE_GEN_STR_OES :: GLenum +gl_TEXTURE_GEN_STR_OES = 0x8D60 +gl_OCCLUSION_TEST_HP :: GLenum +gl_OCCLUSION_TEST_HP = 0x8165 +gl_BLEND_DST_RGB_OES :: GLenum +gl_BLEND_DST_RGB_OES = 0x80C8 +gl_IMAGE_BINDING_NAME :: GLenum +gl_IMAGE_BINDING_NAME = 0x8F3A +gl_DUAL_LUMINANCE_ALPHA8_SGIS :: GLenum +gl_DUAL_LUMINANCE_ALPHA8_SGIS = 0x811D +gl_POLYGON_BIT :: GLenum +gl_POLYGON_BIT = 0x00000008 +gl_POST_COLOR_MATRIX_GREEN_BIAS_SGI :: GLenum +gl_POST_COLOR_MATRIX_GREEN_BIAS_SGI = 0x80B9 +gl_COLOR_ATTACHMENT8_EXT :: GLenum +gl_COLOR_ATTACHMENT8_EXT = 0x8CE8 +gl_BLUE_BIAS :: GLenum +gl_BLUE_BIAS = 0x0D1B +gl_EMISSION :: GLenum +gl_EMISSION = 0x1600 +gl_DEPTH_ATTACHMENT_OES :: GLenum +gl_DEPTH_ATTACHMENT_OES = 0x8D00 +gl_POLYGON_OFFSET_FACTOR_EXT :: GLenum +gl_POLYGON_OFFSET_FACTOR_EXT = 0x8038 +gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT :: GLenum +gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS_EXT = 0x92D4 +gl_TEXTURE_MATERIAL_FACE_EXT :: GLenum +gl_TEXTURE_MATERIAL_FACE_EXT = 0x8351 +gl_PN_TRIANGLES_POINT_MODE_CUBIC_ATI :: GLenum +gl_PN_TRIANGLES_POINT_MODE_CUBIC_ATI = 0x87F6 +gl_DRAW_FRAMEBUFFER_ANGLE :: GLenum +gl_DRAW_FRAMEBUFFER_ANGLE = 0x8CA9 +gl_DEPTH_BUFFER_BIT3_QCOM :: GLenum +gl_DEPTH_BUFFER_BIT3_QCOM = 0x00000800 +gl_DISTANCE_ATTENUATION_EXT :: GLenum +gl_DISTANCE_ATTENUATION_EXT = 0x8129 +gl_TRACE_ARRAYS_BIT_MESA :: GLenum +gl_TRACE_ARRAYS_BIT_MESA = 0x0004 +gl_MOVE_TO_NV :: GLenum +gl_MOVE_TO_NV = 0x02 +gl_2PASS_1_SGIS :: GLenum +gl_2PASS_1_SGIS = 0x80A3 +gl_DUAL_LUMINANCE4_SGIS :: GLenum +gl_DUAL_LUMINANCE4_SGIS = 0x8114 +gl_PRIMITIVES_SUBMITTED_ARB :: GLenum +gl_PRIMITIVES_SUBMITTED_ARB = 0x82EF +gl_TOP_LEVEL_ARRAY_STRIDE :: GLenum +gl_TOP_LEVEL_ARRAY_STRIDE = 0x930D +gl_NORMAL_ARRAY_STRIDE :: GLenum +gl_NORMAL_ARRAY_STRIDE = 0x807F +gl_TEXTURE_2D_ARRAY_EXT :: GLenum +gl_TEXTURE_2D_ARRAY_EXT = 0x8C1A +gl_UNPACK_COMPRESSED_BLOCK_WIDTH :: GLenum +gl_UNPACK_COMPRESSED_BLOCK_WIDTH = 0x9127 +gl_TEXTURE_FIXED_SAMPLE_LOCATIONS :: GLenum +gl_TEXTURE_FIXED_SAMPLE_LOCATIONS = 0x9107 +gl_YCRCBA_SGIX :: GLenum +gl_YCRCBA_SGIX = 0x8319 +gl_LOCATION_COMPONENT :: GLenum +gl_LOCATION_COMPONENT = 0x934A +gl_TEXTURE27 :: GLenum +gl_TEXTURE27 = 0x84DB +gl_CONTEXT_FLAG_DEBUG_BIT_KHR :: GLenum +gl_CONTEXT_FLAG_DEBUG_BIT_KHR = 0x00000002 +gl_FOG_COORDINATE_EXT :: GLenum +gl_FOG_COORDINATE_EXT = 0x8451 +gl_DEBUG_CALLBACK_USER_PARAM_KHR :: GLenum +gl_DEBUG_CALLBACK_USER_PARAM_KHR = 0x8245 +gl_MIRRORED_REPEAT_OES :: GLenum +gl_MIRRORED_REPEAT_OES = 0x8370 +gl_SYNC_GPU_COMMANDS_COMPLETE :: GLenum +gl_SYNC_GPU_COMMANDS_COMPLETE = 0x9117 +gl_SLUMINANCE8_ALPHA8_EXT :: GLenum +gl_SLUMINANCE8_ALPHA8_EXT = 0x8C45 +gl_TEXTURE_BUFFER_OFFSET :: GLenum +gl_TEXTURE_BUFFER_OFFSET = 0x919D +gl_PROXY_COLOR_TABLE :: GLenum +gl_PROXY_COLOR_TABLE = 0x80D3 +gl_FIXED :: GLenum +gl_FIXED = 0x140C +gl_SRGB8 :: GLenum +gl_SRGB8 = 0x8C41 +gl_COMPRESSED_RGBA :: GLenum +gl_COMPRESSED_RGBA = 0x84EE +gl_IMAGE_BINDING_FORMAT :: GLenum +gl_IMAGE_BINDING_FORMAT = 0x906E +gl_MAX_RENDERBUFFER_SIZE_OES :: GLenum +gl_MAX_RENDERBUFFER_SIZE_OES = 0x84E8 +gl_DEBUG_SOURCE_API :: GLenum +gl_DEBUG_SOURCE_API = 0x8246 +gl_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH :: GLenum +gl_ACTIVE_SUBROUTINE_UNIFORM_MAX_LENGTH = 0x8E49 +gl_CLIP_PLANE3_IMG :: GLenum +gl_CLIP_PLANE3_IMG = 0x3003 +gl_TEXTURE16 :: GLenum +gl_TEXTURE16 = 0x84D0 +gl_FRAGMENTS_INSTRUMENT_SGIX :: GLenum +gl_FRAGMENTS_INSTRUMENT_SGIX = 0x8313 +gl_MATRIX8_ARB :: GLenum +gl_MATRIX8_ARB = 0x88C8 +gl_DOUBLE_MAT2x4 :: GLenum +gl_DOUBLE_MAT2x4 = 0x8F4A +gl_DRAW_BUFFER9_ATI :: GLenum +gl_DRAW_BUFFER9_ATI = 0x882E +gl_CURRENT_TEXTURE_COORDS :: GLenum +gl_CURRENT_TEXTURE_COORDS = 0x0B03 +gl_DOT_PRODUCT_TEXTURE_3D_NV :: GLenum +gl_DOT_PRODUCT_TEXTURE_3D_NV = 0x86EF +gl_SECONDARY_COLOR_ARRAY_STRIDE_EXT :: GLenum +gl_SECONDARY_COLOR_ARRAY_STRIDE_EXT = 0x845C +gl_UNSIGNED_INT_IMAGE_2D_ARRAY :: GLenum +gl_UNSIGNED_INT_IMAGE_2D_ARRAY = 0x9069 +gl_FRAMEBUFFER_BARRIER_BIT :: GLenum +gl_FRAMEBUFFER_BARRIER_BIT = 0x00000400 +gl_MAX_SAMPLES_IMG :: GLenum +gl_MAX_SAMPLES_IMG = 0x9135 +gl_TESS_CONTROL_SHADER_BIT_EXT :: GLenum +gl_TESS_CONTROL_SHADER_BIT_EXT = 0x00000008 +gl_PROGRAM_NATIVE_TEMPORARIES_ARB :: GLenum +gl_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A6 +gl_COMPRESSED_RGB_PVRTC_4BPPV1_IMG :: GLenum +gl_COMPRESSED_RGB_PVRTC_4BPPV1_IMG = 0x8C00 +gl_VERTEX_PROGRAM_ARB :: GLenum +gl_VERTEX_PROGRAM_ARB = 0x8620 +gl_MAP2_BINORMAL_EXT :: GLenum +gl_MAP2_BINORMAL_EXT = 0x8447 +gl_ETC1_RGB8_OES :: GLenum +gl_ETC1_RGB8_OES = 0x8D64 +gl_PROGRAM_MATRIX_STACK_DEPTH_EXT :: GLenum +gl_PROGRAM_MATRIX_STACK_DEPTH_EXT = 0x8E2F +gl_TEXTURE_USAGE_ANGLE :: GLenum +gl_TEXTURE_USAGE_ANGLE = 0x93A2 +gl_TEXTURE_MATRIX :: GLenum +gl_TEXTURE_MATRIX = 0x0BA8 +gl_INT_SAMPLER_CUBE_MAP_ARRAY_EXT :: GLenum +gl_INT_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900E +gl_INDEX_ARRAY_STRIDE :: GLenum +gl_INDEX_ARRAY_STRIDE = 0x8086 +gl_POST_COLOR_MATRIX_BLUE_SCALE :: GLenum +gl_POST_COLOR_MATRIX_BLUE_SCALE = 0x80B6 +gl_TESS_CONTROL_OUTPUT_VERTICES :: GLenum +gl_TESS_CONTROL_OUTPUT_VERTICES = 0x8E75 +gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET :: GLenum +gl_MIN_PROGRAM_TEXTURE_GATHER_OFFSET = 0x8E5E +gl_COMPRESSED_RGBA_ASTC_6x6_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_6x6_KHR = 0x93B4 +gl_INTERNALFORMAT_SHARED_SIZE :: GLenum +gl_INTERNALFORMAT_SHARED_SIZE = 0x8277 +gl_SOURCE1_RGB_EXT :: GLenum +gl_SOURCE1_RGB_EXT = 0x8581 +gl_STENCIL_PASS_DEPTH_FAIL :: GLenum +gl_STENCIL_PASS_DEPTH_FAIL = 0x0B95 +gl_MATRIX_PALETTE_OES :: GLenum +gl_MATRIX_PALETTE_OES = 0x8840 +gl_MIN_FRAGMENT_INTERPOLATION_OFFSET :: GLenum +gl_MIN_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5B +gl_DOT3_RGBA_EXT :: GLenum +gl_DOT3_RGBA_EXT = 0x8741 +gl_CLIP_VOLUME_CLIPPING_HINT_EXT :: GLenum +gl_CLIP_VOLUME_CLIPPING_HINT_EXT = 0x80F0 +gl_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV :: GLenum +gl_GLYPH_VERTICAL_BEARING_ADVANCE_BIT_NV = 0x80 +gl_FONT_X_MIN_BOUNDS_BIT_NV :: GLenum +gl_FONT_X_MIN_BOUNDS_BIT_NV = 0x00010000 +gl_WRAP_BORDER_SUN :: GLenum +gl_WRAP_BORDER_SUN = 0x81D4 +gl_MAP_INVALIDATE_RANGE_BIT :: GLenum +gl_MAP_INVALIDATE_RANGE_BIT = 0x0004 +gl_PATH_MODELVIEW_NV :: GLenum +gl_PATH_MODELVIEW_NV = 0x1700 +gl_TESS_CONTROL_SHADER :: GLenum +gl_TESS_CONTROL_SHADER = 0x8E88 +gl_VERTEX_STREAM1_ATI :: GLenum +gl_VERTEX_STREAM1_ATI = 0x876D +gl_R3_G3_B2 :: GLenum +gl_R3_G3_B2 = 0x2A10 +gl_LARGE_CW_ARC_TO_NV :: GLenum +gl_LARGE_CW_ARC_TO_NV = 0x18 +gl_PRIMITIVE_BOUNDING_BOX_EXT :: GLenum +gl_PRIMITIVE_BOUNDING_BOX_EXT = 0x92BE +gl_ALPHA_BIAS :: GLenum +gl_ALPHA_BIAS = 0x0D1D +gl_DST_IN_NV :: GLenum +gl_DST_IN_NV = 0x928B +gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT :: GLenum +gl_MAX_TESS_CONTROL_ATOMIC_COUNTERS_EXT = 0x92D3 +gl_NUM_FILL_STREAMS_NV :: GLenum +gl_NUM_FILL_STREAMS_NV = 0x8E29 +gl_ATTRIB_ARRAY_POINTER_NV :: GLenum +gl_ATTRIB_ARRAY_POINTER_NV = 0x8645 +gl_SOURCE0_RGB_ARB :: GLenum +gl_SOURCE0_RGB_ARB = 0x8580 +gl_MAX_PROGRAM_TEXEL_OFFSET_EXT :: GLenum +gl_MAX_PROGRAM_TEXEL_OFFSET_EXT = 0x8905 +gl_MATRIX27_ARB :: GLenum +gl_MATRIX27_ARB = 0x88DB +gl_R11F_G11F_B10F :: GLenum +gl_R11F_G11F_B10F = 0x8C3A +gl_ATOMIC_COUNTER_BUFFER_INDEX :: GLenum +gl_ATOMIC_COUNTER_BUFFER_INDEX = 0x9301 +gl_TEXTURE_SWIZZLE_R_EXT :: GLenum +gl_TEXTURE_SWIZZLE_R_EXT = 0x8E42 +gl_MAX_ASYNC_READ_PIXELS_SGIX :: GLenum +gl_MAX_ASYNC_READ_PIXELS_SGIX = 0x8361 +gl_ACTIVE_TEXTURE_ARB :: GLenum +gl_ACTIVE_TEXTURE_ARB = 0x84E0 +gl_VERTEX_SHADER_LOCAL_CONSTANTS_EXT :: GLenum +gl_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87D2 +gl_REFERENCE_PLANE_SGIX :: GLenum +gl_REFERENCE_PLANE_SGIX = 0x817D +gl_UNPACK_CLIENT_STORAGE_APPLE :: GLenum +gl_UNPACK_CLIENT_STORAGE_APPLE = 0x85B2 +gl_SKIP_DECODE_EXT :: GLenum +gl_SKIP_DECODE_EXT = 0x8A4A +gl_MAP2_VERTEX_ATTRIB10_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB10_4_NV = 0x867A +gl_ALIASED_POINT_SIZE_RANGE :: GLenum +gl_ALIASED_POINT_SIZE_RANGE = 0x846D +gl_MATRIX1_NV :: GLenum +gl_MATRIX1_NV = 0x8631 +gl_CCW :: GLenum +gl_CCW = 0x0901 +gl_SIGNED_RGB_UNSIGNED_ALPHA_NV :: GLenum +gl_SIGNED_RGB_UNSIGNED_ALPHA_NV = 0x870C +gl_TEXTURE_BUFFER_BINDING_EXT :: GLenum +gl_TEXTURE_BUFFER_BINDING_EXT = 0x8C2A +gl_LINEAR_ATTENUATION :: GLenum +gl_LINEAR_ATTENUATION = 0x1208 +gl_FACTOR_MIN_AMD :: GLenum +gl_FACTOR_MIN_AMD = 0x901C +gl_POINT_SPRITE_NV :: GLenum +gl_POINT_SPRITE_NV = 0x8861 +gl_IMAGE_FORMAT_COMPATIBILITY_TYPE :: GLenum +gl_IMAGE_FORMAT_COMPATIBILITY_TYPE = 0x90C7 +gl_QUERY_DEPTH_FAIL_EVENT_BIT_AMD :: GLenum +gl_QUERY_DEPTH_FAIL_EVENT_BIT_AMD = 0x00000002 +gl_MAP2_VERTEX_ATTRIB4_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB4_4_NV = 0x8674 +gl_PATCHES_EXT :: GLenum +gl_PATCHES_EXT = 0x000E +gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS :: GLenum +gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS = 0x8E8A +gl_OUTPUT_TEXTURE_COORD14_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD14_EXT = 0x87AB +gl_V3F :: GLenum +gl_V3F = 0x2A21 +gl_4PASS_2_EXT :: GLenum +gl_4PASS_2_EXT = 0x80A6 +gl_SAMPLES_3DFX :: GLenum +gl_SAMPLES_3DFX = 0x86B4 +gl_MINOR_VERSION :: GLenum +gl_MINOR_VERSION = 0x821C +gl_MAX_DEBUG_LOGGED_MESSAGES_ARB :: GLenum +gl_MAX_DEBUG_LOGGED_MESSAGES_ARB = 0x9144 +gl_FUNC_REVERSE_SUBTRACT :: GLenum +gl_FUNC_REVERSE_SUBTRACT = 0x800B +gl_LAYOUT_LINEAR_CPU_CACHED_INTEL :: GLenum +gl_LAYOUT_LINEAR_CPU_CACHED_INTEL = 2 +gl_MULTISAMPLE_BUFFER_BIT1_QCOM :: GLenum +gl_MULTISAMPLE_BUFFER_BIT1_QCOM = 0x02000000 +gl_SIGNED_RGB8_UNSIGNED_ALPHA8_NV :: GLenum +gl_SIGNED_RGB8_UNSIGNED_ALPHA8_NV = 0x870D +gl_PATH_COVER_DEPTH_FUNC_NV :: GLenum +gl_PATH_COVER_DEPTH_FUNC_NV = 0x90BF +gl_MAX_FRAGMENT_IMAGE_UNIFORMS :: GLenum +gl_MAX_FRAGMENT_IMAGE_UNIFORMS = 0x90CE +gl_PROXY_TEXTURE_COLOR_TABLE_SGI :: GLenum +gl_PROXY_TEXTURE_COLOR_TABLE_SGI = 0x80BD +gl_PIXEL_MAP_I_TO_A_SIZE :: GLenum +gl_PIXEL_MAP_I_TO_A_SIZE = 0x0CB5 +gl_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX :: GLenum +gl_FRAGMENT_LIGHT_MODEL_TWO_SIDE_SGIX = 0x8409 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR = 0x93D0 +gl_FRAME_NV :: GLenum +gl_FRAME_NV = 0x8E26 +gl_FLOAT_R_NV :: GLenum +gl_FLOAT_R_NV = 0x8880 +gl_REFLECTION_MAP_EXT :: GLenum +gl_REFLECTION_MAP_EXT = 0x8512 +gl_RG_SNORM :: GLenum +gl_RG_SNORM = 0x8F91 +gl_REPLACE_MIDDLE_SUN :: GLenum +gl_REPLACE_MIDDLE_SUN = 0x0002 +gl_COMBINER_MAPPING_NV :: GLenum +gl_COMBINER_MAPPING_NV = 0x8543 +gl_ELEMENT_ARRAY_BUFFER_ARB :: GLenum +gl_ELEMENT_ARRAY_BUFFER_ARB = 0x8893 +gl_SECONDARY_COLOR_ARRAY_LENGTH_NV :: GLenum +gl_SECONDARY_COLOR_ARRAY_LENGTH_NV = 0x8F31 +gl_INTERPOLATE_ARB :: GLenum +gl_INTERPOLATE_ARB = 0x8575 +gl_POSITION :: GLenum +gl_POSITION = 0x1203 +gl_PIXEL_MAP_S_TO_S :: GLenum +gl_PIXEL_MAP_S_TO_S = 0x0C71 +gl_READ_ONLY_ARB :: GLenum +gl_READ_ONLY_ARB = 0x88B8 +gl_INVALID_FRAMEBUFFER_OPERATION_OES :: GLenum +gl_INVALID_FRAMEBUFFER_OPERATION_OES = 0x0506 +gl_3DC_X_AMD :: GLenum +gl_3DC_X_AMD = 0x87F9 +gl_FRAGMENT_LIGHT2_SGIX :: GLenum +gl_FRAGMENT_LIGHT2_SGIX = 0x840E +gl_IMAGE_SCALE_Y_HP :: GLenum +gl_IMAGE_SCALE_Y_HP = 0x8156 +gl_READ_FRAMEBUFFER_APPLE :: GLenum +gl_READ_FRAMEBUFFER_APPLE = 0x8CA8 +gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES :: GLenum +gl_ATOMIC_COUNTER_BUFFER_ACTIVE_ATOMIC_COUNTER_INDICES = 0x92C6 +gl_INDEX_MATERIAL_PARAMETER_EXT :: GLenum +gl_INDEX_MATERIAL_PARAMETER_EXT = 0x81B9 +gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH :: GLenum +gl_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH = 0x8C76 +gl_CUBIC_CURVE_TO_NV :: GLenum +gl_CUBIC_CURVE_TO_NV = 0x0C +gl_QUAD_ALPHA4_SGIS :: GLenum +gl_QUAD_ALPHA4_SGIS = 0x811E +gl_FORCE_BLUE_TO_ONE_NV :: GLenum +gl_FORCE_BLUE_TO_ONE_NV = 0x8860 +gl_DOT_PRODUCT_DEPTH_REPLACE_NV :: GLenum +gl_DOT_PRODUCT_DEPTH_REPLACE_NV = 0x86ED +gl_MAX_VERTEX_OUTPUT_COMPONENTS :: GLenum +gl_MAX_VERTEX_OUTPUT_COMPONENTS = 0x9122 +gl_COMPRESSED_RGBA_ASTC_4x4x3_OES :: GLenum +gl_COMPRESSED_RGBA_ASTC_4x4x3_OES = 0x93C2 +gl_COLOR_INDEX1_EXT :: GLenum +gl_COLOR_INDEX1_EXT = 0x80E2 +gl_RELATIVE_CUBIC_CURVE_TO_NV :: GLenum +gl_RELATIVE_CUBIC_CURVE_TO_NV = 0x0D +gl_NOR :: GLenum +gl_NOR = 0x1508 +gl_CLIPPING_OUTPUT_PRIMITIVES_ARB :: GLenum +gl_CLIPPING_OUTPUT_PRIMITIVES_ARB = 0x82F7 +gl_VERTEX_ATTRIB_ARRAY12_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY12_NV = 0x865C +gl_LINE_BIT :: GLenum +gl_LINE_BIT = 0x00000004 +gl_FOG_COORDINATE_ARRAY_STRIDE :: GLenum +gl_FOG_COORDINATE_ARRAY_STRIDE = 0x8455 +gl_DUP_FIRST_CUBIC_CURVE_TO_NV :: GLenum +gl_DUP_FIRST_CUBIC_CURVE_TO_NV = 0xF2 +gl_FRAMEBUFFER_INCOMPLETE_FORMATS_OES :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_FORMATS_OES = 0x8CDA +gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS :: GLenum +gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS = 0x8E1E +gl_PATH_MAX_MODELVIEW_STACK_DEPTH_NV :: GLenum +gl_PATH_MAX_MODELVIEW_STACK_DEPTH_NV = 0x0D36 +gl_FRAGMENT_LIGHT1_SGIX :: GLenum +gl_FRAGMENT_LIGHT1_SGIX = 0x840D +gl_PALETTE8_R5_G6_B5_OES :: GLenum +gl_PALETTE8_R5_G6_B5_OES = 0x8B97 +gl_DUAL_INTENSITY4_SGIS :: GLenum +gl_DUAL_INTENSITY4_SGIS = 0x8118 +gl_TEXTURE_RANGE_LENGTH_APPLE :: GLenum +gl_TEXTURE_RANGE_LENGTH_APPLE = 0x85B7 +gl_TEXTURE_RECTANGLE_ARB :: GLenum +gl_TEXTURE_RECTANGLE_ARB = 0x84F5 +gl_LUMINANCE16F_EXT :: GLenum +gl_LUMINANCE16F_EXT = 0x881E +gl_DEPTH_COMPONENT16_ARB :: GLenum +gl_DEPTH_COMPONENT16_ARB = 0x81A5 +gl_BUMP_TARGET_ATI :: GLenum +gl_BUMP_TARGET_ATI = 0x877C +gl_MAX_CUBE_MAP_TEXTURE_SIZE_ARB :: GLenum +gl_MAX_CUBE_MAP_TEXTURE_SIZE_ARB = 0x851C +gl_DOUBLE_MAT3_EXT :: GLenum +gl_DOUBLE_MAT3_EXT = 0x8F47 +gl_QUERY_BY_REGION_NO_WAIT_INVERTED :: GLenum +gl_QUERY_BY_REGION_NO_WAIT_INVERTED = 0x8E1A +gl_MAX_PROGRAM_TEX_INDIRECTIONS_ARB :: GLenum +gl_MAX_PROGRAM_TEX_INDIRECTIONS_ARB = 0x880D +gl_QUADS :: GLenum +gl_QUADS = 0x0007 +gl_ALPHA_INTEGER_EXT :: GLenum +gl_ALPHA_INTEGER_EXT = 0x8D97 +gl_VERTEX_SHADER_BIT_EXT :: GLenum +gl_VERTEX_SHADER_BIT_EXT = 0x00000001 +gl_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX :: GLenum +gl_TEXTURE_CLIPMAP_LOD_OFFSET_SGIX = 0x8175 +gl_COLOR_MATERIAL_FACE :: GLenum +gl_COLOR_MATERIAL_FACE = 0x0B55 +gl_LIGHT_MODEL_TWO_SIDE :: GLenum +gl_LIGHT_MODEL_TWO_SIDE = 0x0B52 +gl_INTERLEAVED_ATTRIBS :: GLenum +gl_INTERLEAVED_ATTRIBS = 0x8C8C +gl_RGBA16I :: GLenum +gl_RGBA16I = 0x8D88 +gl_VERTEX_ATTRIB_ARRAY_TYPE_ARB :: GLenum +gl_VERTEX_ATTRIB_ARRAY_TYPE_ARB = 0x8625 +gl_DEBUG_SEVERITY_LOW_AMD :: GLenum +gl_DEBUG_SEVERITY_LOW_AMD = 0x9148 +gl_POINT_SPRITE_COORD_ORIGIN :: GLenum +gl_POINT_SPRITE_COORD_ORIGIN = 0x8CA0 +gl_DRAW_BUFFER8 :: GLenum +gl_DRAW_BUFFER8 = 0x882D +gl_SPOT_DIRECTION :: GLenum +gl_SPOT_DIRECTION = 0x1204 +gl_SAMPLE_COVERAGE_INVERT_ARB :: GLenum +gl_SAMPLE_COVERAGE_INVERT_ARB = 0x80AB +gl_PERFQUERY_COUNTER_RAW_INTEL :: GLenum +gl_PERFQUERY_COUNTER_RAW_INTEL = 0x94F4 +gl_STRICT_SCISSOR_HINT_PGI :: GLenum +gl_STRICT_SCISSOR_HINT_PGI = 0x1A218 +gl_LUMINANCE16_EXT :: GLenum +gl_LUMINANCE16_EXT = 0x8042 +gl_UNPACK_ALIGNMENT :: GLenum +gl_UNPACK_ALIGNMENT = 0x0CF5 +gl_BIAS_BIT_ATI :: GLenum +gl_BIAS_BIT_ATI = 0x00000008 +gl_LARGE_CCW_ARC_TO_NV :: GLenum +gl_LARGE_CCW_ARC_TO_NV = 0x16 +gl_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB :: GLenum +gl_TEXTURE_COMPRESSED_IMAGE_SIZE_ARB = 0x86A0 +gl_FASTEST :: GLenum +gl_FASTEST = 0x1101 +gl_LUMINANCE8_ALPHA8 :: GLenum +gl_LUMINANCE8_ALPHA8 = 0x8045 +gl_CONVOLUTION_FILTER_BIAS_EXT :: GLenum +gl_CONVOLUTION_FILTER_BIAS_EXT = 0x8015 +gl_VIEW_CLASS_S3TC_DXT5_RGBA :: GLenum +gl_VIEW_CLASS_S3TC_DXT5_RGBA = 0x82CF +gl_DEPTH32F_STENCIL8_NV :: GLenum +gl_DEPTH32F_STENCIL8_NV = 0x8DAC +gl_TRACE_OPERATIONS_BIT_MESA :: GLenum +gl_TRACE_OPERATIONS_BIT_MESA = 0x0001 +gl_QUERY_RESULT_EXT :: GLenum +gl_QUERY_RESULT_EXT = 0x8866 +gl_TRANSFORM_FEEDBACK_BINDING_NV :: GLenum +gl_TRANSFORM_FEEDBACK_BINDING_NV = 0x8E25 +gl_REG_10_ATI :: GLenum +gl_REG_10_ATI = 0x892B +gl_MATRIX16_ARB :: GLenum +gl_MATRIX16_ARB = 0x88D0 +gl_FONT_HAS_KERNING_BIT_NV :: GLenum +gl_FONT_HAS_KERNING_BIT_NV = 0x10000000 +gl_INNOCENT_CONTEXT_RESET_EXT :: GLenum +gl_INNOCENT_CONTEXT_RESET_EXT = 0x8254 +gl_VIDEO_CAPTURE_FRAME_HEIGHT_NV :: GLenum +gl_VIDEO_CAPTURE_FRAME_HEIGHT_NV = 0x9039 +gl_NATIVE_GRAPHICS_END_HINT_PGI :: GLenum +gl_NATIVE_GRAPHICS_END_HINT_PGI = 0x1A204 +gl_HISTOGRAM_LUMINANCE_SIZE_EXT :: GLenum +gl_HISTOGRAM_LUMINANCE_SIZE_EXT = 0x802C +gl_COMBINER0_NV :: GLenum +gl_COMBINER0_NV = 0x8550 +gl_COORD_REPLACE_OES :: GLenum +gl_COORD_REPLACE_OES = 0x8862 +gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT :: GLenum +gl_MAX_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT = 0x8E80 +gl_TIMESTAMP_EXT :: GLenum +gl_TIMESTAMP_EXT = 0x8E28 +gl_MAX_IMAGE_UNITS_EXT :: GLenum +gl_MAX_IMAGE_UNITS_EXT = 0x8F38 +gl_POINT_SIZE_MAX_ARB :: GLenum +gl_POINT_SIZE_MAX_ARB = 0x8127 +gl_DEPTH_WRITEMASK :: GLenum +gl_DEPTH_WRITEMASK = 0x0B72 +gl_FOG_COORDINATE_ARRAY_STRIDE_EXT :: GLenum +gl_FOG_COORDINATE_ARRAY_STRIDE_EXT = 0x8455 +gl_BUMP_NUM_TEX_UNITS_ATI :: GLenum +gl_BUMP_NUM_TEX_UNITS_ATI = 0x8777 +gl_INT_SAMPLER_1D_EXT :: GLenum +gl_INT_SAMPLER_1D_EXT = 0x8DC9 +gl_INDEX_MODE :: GLenum +gl_INDEX_MODE = 0x0C30 +gl_422_EXT :: GLenum +gl_422_EXT = 0x80CC +gl_ATOMIC_COUNTER_BUFFER_START :: GLenum +gl_ATOMIC_COUNTER_BUFFER_START = 0x92C2 +gl_GPU_ADDRESS_NV :: GLenum +gl_GPU_ADDRESS_NV = 0x8F34 +gl_REG_19_ATI :: GLenum +gl_REG_19_ATI = 0x8934 +gl_IMAGE_BUFFER :: GLenum +gl_IMAGE_BUFFER = 0x9051 +gl_HISTOGRAM_GREEN_SIZE :: GLenum +gl_HISTOGRAM_GREEN_SIZE = 0x8029 +gl_VERTEX_ATTRIB_ARRAY_ADDRESS_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY_ADDRESS_NV = 0x8F20 +gl_INTENSITY8_SNORM :: GLenum +gl_INTENSITY8_SNORM = 0x9017 +gl_DEBUG_TYPE_MARKER :: GLenum +gl_DEBUG_TYPE_MARKER = 0x8268 +gl_VERTEX_PROGRAM_TWO_SIDE_ARB :: GLenum +gl_VERTEX_PROGRAM_TWO_SIDE_ARB = 0x8643 +gl_INDEX_MATERIAL_FACE_EXT :: GLenum +gl_INDEX_MATERIAL_FACE_EXT = 0x81BA +gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB :: GLenum +gl_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB = 0x8E8D +gl_CMYKA_EXT :: GLenum +gl_CMYKA_EXT = 0x800D +gl_MAP_ATTRIB_V_ORDER_NV :: GLenum +gl_MAP_ATTRIB_V_ORDER_NV = 0x86C4 +gl_OFFSET_HILO_TEXTURE_2D_NV :: GLenum +gl_OFFSET_HILO_TEXTURE_2D_NV = 0x8854 +gl_CALLIGRAPHIC_FRAGMENT_SGIX :: GLenum +gl_CALLIGRAPHIC_FRAGMENT_SGIX = 0x8183 +gl_MAX_PROGRAM_PARAMETERS_ARB :: GLenum +gl_MAX_PROGRAM_PARAMETERS_ARB = 0x88A9 +gl_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV :: GLenum +gl_RELATIVE_SMOOTH_QUADRATIC_CURVE_TO_NV = 0x0F +gl_MAP_READ_BIT :: GLenum +gl_MAP_READ_BIT = 0x0001 +gl_IMAGE_1D_EXT :: GLenum +gl_IMAGE_1D_EXT = 0x904C +gl_READ_BUFFER :: GLenum +gl_READ_BUFFER = 0x0C02 +gl_POST_CONVOLUTION_RED_SCALE :: GLenum +gl_POST_CONVOLUTION_RED_SCALE = 0x801C +gl_MATRIX23_ARB :: GLenum +gl_MATRIX23_ARB = 0x88D7 +gl_MAX_SAMPLES_NV :: GLenum +gl_MAX_SAMPLES_NV = 0x8D57 +gl_RGB8_SNORM :: GLenum +gl_RGB8_SNORM = 0x8F96 +gl_MATRIX5_NV :: GLenum +gl_MATRIX5_NV = 0x8635 +gl_UNPACK_SWAP_BYTES :: GLenum +gl_UNPACK_SWAP_BYTES = 0x0CF0 +gl_TABLE_TOO_LARGE :: GLenum +gl_TABLE_TOO_LARGE = 0x8031 +gl_MIN_SAMPLE_SHADING_VALUE_OES :: GLenum +gl_MIN_SAMPLE_SHADING_VALUE_OES = 0x8C37 +gl_SWIZZLE_STQ_DQ_ATI :: GLenum +gl_SWIZZLE_STQ_DQ_ATI = 0x8979 +gl_BUFFER_IMMUTABLE_STORAGE :: GLenum +gl_BUFFER_IMMUTABLE_STORAGE = 0x821F +gl_ELEMENT_ARRAY_TYPE_APPLE :: GLenum +gl_ELEMENT_ARRAY_TYPE_APPLE = 0x8A0D +gl_POST_COLOR_MATRIX_BLUE_BIAS_SGI :: GLenum +gl_POST_COLOR_MATRIX_BLUE_BIAS_SGI = 0x80BA +gl_PARTIAL_SUCCESS_NV :: GLenum +gl_PARTIAL_SUCCESS_NV = 0x902E +gl_LOCAL_CONSTANT_EXT :: GLenum +gl_LOCAL_CONSTANT_EXT = 0x87C3 +gl_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB = 0x8517 +gl_GEOMETRY_DEFORMATION_SGIX :: GLenum +gl_GEOMETRY_DEFORMATION_SGIX = 0x8194 +gl_SAMPLER_CUBE_MAP_ARRAY_EXT :: GLenum +gl_SAMPLER_CUBE_MAP_ARRAY_EXT = 0x900C +gl_STENCIL_BACK_PASS_DEPTH_PASS_ATI :: GLenum +gl_STENCIL_BACK_PASS_DEPTH_PASS_ATI = 0x8803 +gl_DISJOINT_NV :: GLenum +gl_DISJOINT_NV = 0x9283 +gl_FLOAT_MAT4x3 :: GLenum +gl_FLOAT_MAT4x3 = 0x8B6A +gl_TRANSFORM_FEEDBACK_PAUSED :: GLenum +gl_TRANSFORM_FEEDBACK_PAUSED = 0x8E23 +gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION :: GLenum +gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION = 0x8E4C +gl_RG8_EXT :: GLenum +gl_RG8_EXT = 0x822B +gl_RECT_NV :: GLenum +gl_RECT_NV = 0xF6 +gl_GEOMETRY_OUTPUT_TYPE_ARB :: GLenum +gl_GEOMETRY_OUTPUT_TYPE_ARB = 0x8DDC +gl_DEBUG_SOURCE_API_ARB :: GLenum +gl_DEBUG_SOURCE_API_ARB = 0x8246 +gl_COLOR_ATTACHMENT15 :: GLenum +gl_COLOR_ATTACHMENT15 = 0x8CEF +gl_MAX_VARYING_FLOATS_ARB :: GLenum +gl_MAX_VARYING_FLOATS_ARB = 0x8B4B +gl_MAX_DRAW_BUFFERS_NV :: GLenum +gl_MAX_DRAW_BUFFERS_NV = 0x8824 +gl_VERTEX_BLEND_ARB :: GLenum +gl_VERTEX_BLEND_ARB = 0x86A7 +gl_DOUBLE_MAT2x3_EXT :: GLenum +gl_DOUBLE_MAT2x3_EXT = 0x8F49 +gl_MAX_DEBUG_LOGGED_MESSAGES_AMD :: GLenum +gl_MAX_DEBUG_LOGGED_MESSAGES_AMD = 0x9144 +gl_VERTICES_SUBMITTED_ARB :: GLenum +gl_VERTICES_SUBMITTED_ARB = 0x82EE +gl_UNSIGNED_SHORT_4_4_4_4_REV_IMG :: GLenum +gl_UNSIGNED_SHORT_4_4_4_4_REV_IMG = 0x8365 +gl_STATE_RESTORE :: GLenum +gl_STATE_RESTORE = 0x8BDC +gl_MAX_COLOR_ATTACHMENTS_EXT :: GLenum +gl_MAX_COLOR_ATTACHMENTS_EXT = 0x8CDF +gl_INDEX_LOGIC_OP :: GLenum +gl_INDEX_LOGIC_OP = 0x0BF1 +gl_PRIMITIVE_RESTART_NV :: GLenum +gl_PRIMITIVE_RESTART_NV = 0x8558 +gl_FLOAT_MAT3x2_NV :: GLenum +gl_FLOAT_MAT3x2_NV = 0x8B67 +gl_VERTEX_CONSISTENT_HINT_PGI :: GLenum +gl_VERTEX_CONSISTENT_HINT_PGI = 0x1A22B +gl_LUMINANCE_ALPHA16F_EXT :: GLenum +gl_LUMINANCE_ALPHA16F_EXT = 0x881F +gl_FLOAT_VEC2_ARB :: GLenum +gl_FLOAT_VEC2_ARB = 0x8B50 +gl_TEXTURE_SWIZZLE_RGBA :: GLenum +gl_TEXTURE_SWIZZLE_RGBA = 0x8E46 +gl_PROGRAM_SEPARABLE_EXT :: GLenum +gl_PROGRAM_SEPARABLE_EXT = 0x8258 +gl_COMPRESSED_RGBA_ASTC_10x8_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_10x8_KHR = 0x93BA +gl_DEPTH_ATTACHMENT_EXT :: GLenum +gl_DEPTH_ATTACHMENT_EXT = 0x8D00 +gl_FRAMEBUFFER_UNSUPPORTED_OES :: GLenum +gl_FRAMEBUFFER_UNSUPPORTED_OES = 0x8CDD +gl_OPERAND1_ALPHA :: GLenum +gl_OPERAND1_ALPHA = 0x8599 +gl_PIXEL_MAP_I_TO_B_SIZE :: GLenum +gl_PIXEL_MAP_I_TO_B_SIZE = 0x0CB4 +gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_EXT = 0x8C8A +gl_EVAL_2D_NV :: GLenum +gl_EVAL_2D_NV = 0x86C0 +gl_GREEN_MIN_CLAMP_INGR :: GLenum +gl_GREEN_MIN_CLAMP_INGR = 0x8561 +gl_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS :: GLenum +gl_MAX_FRAGMENT_ATOMIC_COUNTER_BUFFERS = 0x92D0 +gl_VERTEX_ARRAY_RANGE_NV :: GLenum +gl_VERTEX_ARRAY_RANGE_NV = 0x851D +gl_CONTEXT_LOST_WEBGL :: GLenum +gl_CONTEXT_LOST_WEBGL = 0x9242 +gl_MAX_VERTEX_UNIFORM_BLOCKS :: GLenum +gl_MAX_VERTEX_UNIFORM_BLOCKS = 0x8A2B +gl_VERTEX_ATTRIB_MAP2_COEFF_APPLE :: GLenum +gl_VERTEX_ATTRIB_MAP2_COEFF_APPLE = 0x8A07 +gl_TEXTURE_MAX_CLAMP_T_SGIX :: GLenum +gl_TEXTURE_MAX_CLAMP_T_SGIX = 0x836A +gl_LUMINANCE_SNORM :: GLenum +gl_LUMINANCE_SNORM = 0x9011 +gl_PIXEL_UNPACK_BUFFER_BINDING :: GLenum +gl_PIXEL_UNPACK_BUFFER_BINDING = 0x88EF +gl_RGBA8_SNORM :: GLenum +gl_RGBA8_SNORM = 0x8F97 +gl_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX :: GLenum +gl_GPU_MEMORY_INFO_TOTAL_AVAILABLE_MEMORY_NVX = 0x9048 +gl_PIXEL_SUBSAMPLE_2424_SGIX :: GLenum +gl_PIXEL_SUBSAMPLE_2424_SGIX = 0x85A3 +gl_TEXTURE_GATHER_SHADOW :: GLenum +gl_TEXTURE_GATHER_SHADOW = 0x82A3 +gl_VIEWPORT_INDEX_PROVOKING_VERTEX :: GLenum +gl_VIEWPORT_INDEX_PROVOKING_VERTEX = 0x825F +gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT :: GLenum +gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS_EXT = 0x90CB +gl_UNSIGNED_INT_IMAGE_CUBE :: GLenum +gl_UNSIGNED_INT_IMAGE_CUBE = 0x9066 +gl_WEIGHT_ARRAY_POINTER_OES :: GLenum +gl_WEIGHT_ARRAY_POINTER_OES = 0x86AC +gl_ALL_ATTRIB_BITS :: GLenum +gl_ALL_ATTRIB_BITS = 0xFFFFFFFF +gl_PERFQUERY_COUNTER_TIMESTAMP_INTEL :: GLenum +gl_PERFQUERY_COUNTER_TIMESTAMP_INTEL = 0x94F5 +gl_TESS_EVALUATION_SHADER_EXT :: GLenum +gl_TESS_EVALUATION_SHADER_EXT = 0x8E87 +gl_BUFFER_OBJECT_EXT :: GLenum +gl_BUFFER_OBJECT_EXT = 0x9151 +gl_TIMESTAMP :: GLenum +gl_TIMESTAMP = 0x8E28 +gl_RGBA_INTEGER_EXT :: GLenum +gl_RGBA_INTEGER_EXT = 0x8D99 +gl_RGB16UI :: GLenum +gl_RGB16UI = 0x8D77 +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LAYER_EXT = 0x8CD4 +gl_SAMPLE_SHADING_OES :: GLenum +gl_SAMPLE_SHADING_OES = 0x8C36 +gl_CONVOLUTION_BORDER_COLOR :: GLenum +gl_CONVOLUTION_BORDER_COLOR = 0x8154 +gl_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV :: GLenum +gl_MAX_PROGRAM_PARAMETER_BUFFER_SIZE_NV = 0x8DA1 +gl_VERTEX_ARRAY_BUFFER_BINDING :: GLenum +gl_VERTEX_ARRAY_BUFFER_BINDING = 0x8896 +gl_DEPTH_CLAMP_NEAR_AMD :: GLenum +gl_DEPTH_CLAMP_NEAR_AMD = 0x901E +gl_POLYGON_TOKEN :: GLenum +gl_POLYGON_TOKEN = 0x0703 +gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x889C +gl_R8_SNORM :: GLenum +gl_R8_SNORM = 0x8F94 +gl_DS_BIAS_NV :: GLenum +gl_DS_BIAS_NV = 0x8716 +gl_2X_BIT_ATI :: GLenum +gl_2X_BIT_ATI = 0x00000001 +gl_ALREADY_SIGNALED :: GLenum +gl_ALREADY_SIGNALED = 0x911A +gl_2D :: GLenum +gl_2D = 0x0600 +gl_MAX_VERTEX_UNIFORM_COMPONENTS :: GLenum +gl_MAX_VERTEX_UNIFORM_COMPONENTS = 0x8B4A +gl_DEBUG_CATEGORY_PERFORMANCE_AMD :: GLenum +gl_DEBUG_CATEGORY_PERFORMANCE_AMD = 0x914D +gl_OVERLAY_NV :: GLenum +gl_OVERLAY_NV = 0x9296 +gl_ATOMIC_COUNTER_BUFFER_SIZE :: GLenum +gl_ATOMIC_COUNTER_BUFFER_SIZE = 0x92C3 +gl_COLOR_ATTACHMENT10_EXT :: GLenum +gl_COLOR_ATTACHMENT10_EXT = 0x8CEA +gl_COLOR_TABLE_BLUE_SIZE_SGI :: GLenum +gl_COLOR_TABLE_BLUE_SIZE_SGI = 0x80DC +gl_ADD_SIGNED_EXT :: GLenum +gl_ADD_SIGNED_EXT = 0x8574 +gl_INT_SAMPLER_2D_ARRAY_EXT :: GLenum +gl_INT_SAMPLER_2D_ARRAY_EXT = 0x8DCF +gl_TRANSFORM_FEEDBACK_BUFFER_INDEX :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_INDEX = 0x934B +gl_REFERENCED_BY_TESS_CONTROL_SHADER :: GLenum +gl_REFERENCED_BY_TESS_CONTROL_SHADER = 0x9307 +gl_FIELD_LOWER_NV :: GLenum +gl_FIELD_LOWER_NV = 0x9023 +gl_POST_COLOR_MATRIX_RED_SCALE :: GLenum +gl_POST_COLOR_MATRIX_RED_SCALE = 0x80B4 +gl_IMAGE_BUFFER_EXT :: GLenum +gl_IMAGE_BUFFER_EXT = 0x9051 +gl_3D_COLOR_TEXTURE :: GLenum +gl_3D_COLOR_TEXTURE = 0x0603 +gl_DEBUG_CALLBACK_FUNCTION_KHR :: GLenum +gl_DEBUG_CALLBACK_FUNCTION_KHR = 0x8244 +gl_SCISSOR_BIT :: GLenum +gl_SCISSOR_BIT = 0x00080000 +gl_IMAGE_TRANSLATE_X_HP :: GLenum +gl_IMAGE_TRANSLATE_X_HP = 0x8157 +gl_PIXEL_MAP_I_TO_A :: GLenum +gl_PIXEL_MAP_I_TO_A = 0x0C75 +gl_VERTEX_SUBROUTINE :: GLenum +gl_VERTEX_SUBROUTINE = 0x92E8 +gl_TEXTURE4_ARB :: GLenum +gl_TEXTURE4_ARB = 0x84C4 +gl_PACK_COMPRESSED_BLOCK_DEPTH :: GLenum +gl_PACK_COMPRESSED_BLOCK_DEPTH = 0x912D +gl_SHADER_STORAGE_BLOCK :: GLenum +gl_SHADER_STORAGE_BLOCK = 0x92E6 +gl_SIGNED_ALPHA_NV :: GLenum +gl_SIGNED_ALPHA_NV = 0x8705 +gl_BLEND_DST_ALPHA_EXT :: GLenum +gl_BLEND_DST_ALPHA_EXT = 0x80CA +gl_MAP2_VERTEX_ATTRIB9_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB9_4_NV = 0x8679 +gl_HILO8_NV :: GLenum +gl_HILO8_NV = 0x885E +gl_SHADER_BINARY_FORMATS :: GLenum +gl_SHADER_BINARY_FORMATS = 0x8DF8 +gl_DEBUG_OUTPUT_SYNCHRONOUS :: GLenum +gl_DEBUG_OUTPUT_SYNCHRONOUS = 0x8242 +gl_TEXTURE_GEN_R :: GLenum +gl_TEXTURE_GEN_R = 0x0C62 +gl_PERFORMANCE_MONITOR_AMD :: GLenum +gl_PERFORMANCE_MONITOR_AMD = 0x9152 +gl_INTENSITY_FLOAT16_APPLE :: GLenum +gl_INTENSITY_FLOAT16_APPLE = 0x881D +gl_PROGRAM_PIPELINE :: GLenum +gl_PROGRAM_PIPELINE = 0x82E4 +gl_COLOR_BUFFER_BIT5_QCOM :: GLenum +gl_COLOR_BUFFER_BIT5_QCOM = 0x00000020 +gl_MAX_GEOMETRY_VARYING_COMPONENTS_EXT :: GLenum +gl_MAX_GEOMETRY_VARYING_COMPONENTS_EXT = 0x8DDD +gl_DEBUG_TYPE_PORTABILITY_KHR :: GLenum +gl_DEBUG_TYPE_PORTABILITY_KHR = 0x824F +gl_RGB16F_ARB :: GLenum +gl_RGB16F_ARB = 0x881B +gl_PRIMITIVES_GENERATED_EXT :: GLenum +gl_PRIMITIVES_GENERATED_EXT = 0x8C87 +gl_PROGRAM_BINARY_FORMATS_OES :: GLenum +gl_PROGRAM_BINARY_FORMATS_OES = 0x87FF +gl_AMBIENT :: GLenum +gl_AMBIENT = 0x1200 +gl_QUERY_BY_REGION_NO_WAIT_NV :: GLenum +gl_QUERY_BY_REGION_NO_WAIT_NV = 0x8E16 +gl_VIEW_CLASS_RGTC2_RG :: GLenum +gl_VIEW_CLASS_RGTC2_RG = 0x82D1 +gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT :: GLenum +gl_COMPRESSED_SRGB_ALPHA_PVRTC_4BPPV1_EXT = 0x8A57 +gl_DRAW_BUFFER2_EXT :: GLenum +gl_DRAW_BUFFER2_EXT = 0x8827 +gl_TEXTURE_BUFFER_BINDING :: GLenum +gl_TEXTURE_BUFFER_BINDING = 0x8C2A +gl_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT :: GLenum +gl_COMPRESSED_SRGB_PVRTC_4BPPV1_EXT = 0x8A55 +gl_OPERAND3_ALPHA_NV :: GLenum +gl_OPERAND3_ALPHA_NV = 0x859B +gl_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV :: GLenum +gl_UNSIGNED_INT_SAMPLER_RENDERBUFFER_NV = 0x8E58 +gl_LINEAR_SHARPEN_SGIS :: GLenum +gl_LINEAR_SHARPEN_SGIS = 0x80AD +gl_MAP_UNSYNCHRONIZED_BIT_EXT :: GLenum +gl_MAP_UNSYNCHRONIZED_BIT_EXT = 0x0020 +gl_MODELVIEW28_ARB :: GLenum +gl_MODELVIEW28_ARB = 0x873C +gl_EDGE_FLAG_ARRAY_LIST_IBM :: GLenum +gl_EDGE_FLAG_ARRAY_LIST_IBM = 103075 +gl_PALETTE4_RGB5_A1_OES :: GLenum +gl_PALETTE4_RGB5_A1_OES = 0x8B94 +gl_MULTIPLY_KHR :: GLenum +gl_MULTIPLY_KHR = 0x9294 +gl_GPU_OPTIMIZED_QCOM :: GLenum +gl_GPU_OPTIMIZED_QCOM = 0x8FB2 +gl_FOG_FUNC_POINTS_SGIS :: GLenum +gl_FOG_FUNC_POINTS_SGIS = 0x812B +gl_MAX_IMAGE_SAMPLES :: GLenum +gl_MAX_IMAGE_SAMPLES = 0x906D +gl_DRAW_BUFFER3_NV :: GLenum +gl_DRAW_BUFFER3_NV = 0x8828 +gl_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS :: GLenum +gl_ACTIVE_SUBROUTINE_UNIFORM_LOCATIONS = 0x8E47 +gl_RESET_NOTIFICATION_STRATEGY_ARB :: GLenum +gl_RESET_NOTIFICATION_STRATEGY_ARB = 0x8256 +gl_MAX_TEXTURE_STACK_DEPTH :: GLenum +gl_MAX_TEXTURE_STACK_DEPTH = 0x0D39 +gl_INT64_NV :: GLenum +gl_INT64_NV = 0x140E +gl_DEBUG_SOURCE_APPLICATION :: GLenum +gl_DEBUG_SOURCE_APPLICATION = 0x824A +gl_STENCIL_CLEAR_VALUE :: GLenum +gl_STENCIL_CLEAR_VALUE = 0x0B91 +gl_SRC1_COLOR :: GLenum +gl_SRC1_COLOR = 0x88F9 +gl_LIGHT4 :: GLenum +gl_LIGHT4 = 0x4004 +gl_PIXEL_PACK_BUFFER_BINDING :: GLenum +gl_PIXEL_PACK_BUFFER_BINDING = 0x88ED +gl_MAX_LIGHTS :: GLenum +gl_MAX_LIGHTS = 0x0D31 +gl_OPERAND1_ALPHA_EXT :: GLenum +gl_OPERAND1_ALPHA_EXT = 0x8599 +gl_PIXEL_MAP_B_TO_B_SIZE :: GLenum +gl_PIXEL_MAP_B_TO_B_SIZE = 0x0CB8 +gl_COLOR_TABLE_FORMAT_SGI :: GLenum +gl_COLOR_TABLE_FORMAT_SGI = 0x80D8 +gl_MODELVIEW22_ARB :: GLenum +gl_MODELVIEW22_ARB = 0x8736 +gl_UNSIGNED_INT64_VEC4_NV :: GLenum +gl_UNSIGNED_INT64_VEC4_NV = 0x8FF7 +gl_COLOR_ARRAY_TYPE_EXT :: GLenum +gl_COLOR_ARRAY_TYPE_EXT = 0x8082 +gl_LOSE_CONTEXT_ON_RESET_EXT :: GLenum +gl_LOSE_CONTEXT_ON_RESET_EXT = 0x8252 +gl_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV :: GLenum +gl_Z6Y10Z6CB10Z6A10Z6Y10Z6CR10Z6A10_4224_NV = 0x9034 +gl_TEXTURE_PRIORITY_EXT :: GLenum +gl_TEXTURE_PRIORITY_EXT = 0x8066 +gl_UNPACK_COMPRESSED_SIZE_SGIX :: GLenum +gl_UNPACK_COMPRESSED_SIZE_SGIX = 0x831A +gl_SEPARATE_ATTRIBS_EXT :: GLenum +gl_SEPARATE_ATTRIBS_EXT = 0x8C8D +gl_IMAGE_BINDING_LAYERED :: GLenum +gl_IMAGE_BINDING_LAYERED = 0x8F3C +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR = 0x93D8 +gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE :: GLenum +gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = 0x906B +gl_READ_ONLY :: GLenum +gl_READ_ONLY = 0x88B8 +gl_TEXTURE_3D_BINDING_OES :: GLenum +gl_TEXTURE_3D_BINDING_OES = 0x806A +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER :: GLenum +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_VERTEX_SHADER = 0x92C7 +gl_COVERAGE_ALL_FRAGMENTS_NV :: GLenum +gl_COVERAGE_ALL_FRAGMENTS_NV = 0x8ED5 +gl_SRC2_ALPHA :: GLenum +gl_SRC2_ALPHA = 0x858A +gl_PRIMITIVE_ID_NV :: GLenum +gl_PRIMITIVE_ID_NV = 0x8C7C +gl_VIDEO_COLOR_CONVERSION_MAX_NV :: GLenum +gl_VIDEO_COLOR_CONVERSION_MAX_NV = 0x902A +gl_MAP2_TANGENT_EXT :: GLenum +gl_MAP2_TANGENT_EXT = 0x8445 +gl_LIGHTING :: GLenum +gl_LIGHTING = 0x0B50 +gl_PROGRAM_UNDER_NATIVE_LIMITS_ARB :: GLenum +gl_PROGRAM_UNDER_NATIVE_LIMITS_ARB = 0x88B6 +gl_VERTEX_ATTRIB_ARRAY2_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY2_NV = 0x8652 +gl_PRESENT_TIME_NV :: GLenum +gl_PRESENT_TIME_NV = 0x8E2A +gl_PATCH_DEFAULT_INNER_LEVEL :: GLenum +gl_PATCH_DEFAULT_INNER_LEVEL = 0x8E73 +gl_NEVER :: GLenum +gl_NEVER = 0x0200 +gl_PATH_STROKE_WIDTH_NV :: GLenum +gl_PATH_STROKE_WIDTH_NV = 0x9075 +gl_INVERT_RGB_NV :: GLenum +gl_INVERT_RGB_NV = 0x92A3 +gl_BUFFER_MAP_POINTER_ARB :: GLenum +gl_BUFFER_MAP_POINTER_ARB = 0x88BD +gl_MAP2_GRID_SEGMENTS :: GLenum +gl_MAP2_GRID_SEGMENTS = 0x0DD3 +gl_INVALID_VALUE :: GLenum +gl_INVALID_VALUE = 0x0501 +gl_BLEND_EQUATION_ALPHA_OES :: GLenum +gl_BLEND_EQUATION_ALPHA_OES = 0x883D +gl_MAX_RATIONAL_EVAL_ORDER_NV :: GLenum +gl_MAX_RATIONAL_EVAL_ORDER_NV = 0x86D7 +gl_VERTEX_ATTRIB_ARRAY10_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY10_NV = 0x865A +gl_UNPACK_IMAGE_DEPTH_SGIS :: GLenum +gl_UNPACK_IMAGE_DEPTH_SGIS = 0x8133 +gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_OES = 0x8CDC +gl_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS :: GLenum +gl_MAX_COMBINED_COMPUTE_UNIFORM_COMPONENTS = 0x8266 +gl_TRANSPOSE_PROJECTION_MATRIX_ARB :: GLenum +gl_TRANSPOSE_PROJECTION_MATRIX_ARB = 0x84E4 +gl_REDUCE_EXT :: GLenum +gl_REDUCE_EXT = 0x8016 +gl_RGB8UI_EXT :: GLenum +gl_RGB8UI_EXT = 0x8D7D +gl_MAX_CLIENT_ATTRIB_STACK_DEPTH :: GLenum +gl_MAX_CLIENT_ATTRIB_STACK_DEPTH = 0x0D3B +gl_RGB9_E5_EXT :: GLenum +gl_RGB9_E5_EXT = 0x8C3D +gl_OUTPUT_TEXTURE_COORD18_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD18_EXT = 0x87AF +gl_COLOR_ATTACHMENT0_EXT :: GLenum +gl_COLOR_ATTACHMENT0_EXT = 0x8CE0 +gl_ALPHA_SCALE :: GLenum +gl_ALPHA_SCALE = 0x0D1C +gl_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV :: GLenum +gl_PATH_STENCIL_DEPTH_OFFSET_FACTOR_NV = 0x90BD +gl_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_DEPTH_SIZE = 0x8216 +gl_BLEND_SRC :: GLenum +gl_BLEND_SRC = 0x0BE1 +gl_TEXTURE_MAX_CLAMP_R_SGIX :: GLenum +gl_TEXTURE_MAX_CLAMP_R_SGIX = 0x836B +gl_MAX_PROGRAM_TEXEL_OFFSET_NV :: GLenum +gl_MAX_PROGRAM_TEXEL_OFFSET_NV = 0x8905 +gl_TEXTURE_LOD_BIAS_R_SGIX :: GLenum +gl_TEXTURE_LOD_BIAS_R_SGIX = 0x8190 +gl_UNSIGNED_INT_SAMPLER_2D :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D = 0x8DD2 +gl_TEXTURE_FILTER_CONTROL_EXT :: GLenum +gl_TEXTURE_FILTER_CONTROL_EXT = 0x8500 +gl_VARIABLE_G_NV :: GLenum +gl_VARIABLE_G_NV = 0x8529 +gl_SELECTION_BUFFER_POINTER :: GLenum +gl_SELECTION_BUFFER_POINTER = 0x0DF3 +gl_INT_SAMPLER_1D :: GLenum +gl_INT_SAMPLER_1D = 0x8DC9 +gl_COMBINE_ALPHA :: GLenum +gl_COMBINE_ALPHA = 0x8572 +gl_FONT_Y_MAX_BOUNDS_BIT_NV :: GLenum +gl_FONT_Y_MAX_BOUNDS_BIT_NV = 0x00080000 +gl_UNIFORM_BARRIER_BIT :: GLenum +gl_UNIFORM_BARRIER_BIT = 0x00000004 +gl_TEXTURE_BLUE_TYPE_ARB :: GLenum +gl_TEXTURE_BLUE_TYPE_ARB = 0x8C12 +gl_STENCIL_INDEX16 :: GLenum +gl_STENCIL_INDEX16 = 0x8D49 +gl_SRC_OVER_NV :: GLenum +gl_SRC_OVER_NV = 0x9288 +gl_INT_SAMPLER_2D_MULTISAMPLE :: GLenum +gl_INT_SAMPLER_2D_MULTISAMPLE = 0x9109 +gl_COLOR_TABLE_GREEN_SIZE_SGI :: GLenum +gl_COLOR_TABLE_GREEN_SIZE_SGI = 0x80DB +gl_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV :: GLenum +gl_MAX_PROGRAM_EXEC_INSTRUCTIONS_NV = 0x88F4 +gl_TEXTURE_COMPRESSED_IMAGE_SIZE :: GLenum +gl_TEXTURE_COMPRESSED_IMAGE_SIZE = 0x86A0 +gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV :: GLenum +gl_MAX_FRAGMENT_INTERPOLATION_OFFSET_NV = 0x8E5C +gl_REFERENCED_BY_TESS_EVALUATION_SHADER :: GLenum +gl_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x9308 +gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING_EXT = 0x8210 +gl_MAX_HEIGHT :: GLenum +gl_MAX_HEIGHT = 0x827F +gl_ALPHA32F_ARB :: GLenum +gl_ALPHA32F_ARB = 0x8816 +gl_COLOR_ATTACHMENT13 :: GLenum +gl_COLOR_ATTACHMENT13 = 0x8CED +gl_OP_SET_GE_EXT :: GLenum +gl_OP_SET_GE_EXT = 0x878C +gl_RGBA16_EXT :: GLenum +gl_RGBA16_EXT = 0x805B +gl_OPERAND3_RGB_NV :: GLenum +gl_OPERAND3_RGB_NV = 0x8593 +gl_RENDERBUFFER_BLUE_SIZE_OES :: GLenum +gl_RENDERBUFFER_BLUE_SIZE_OES = 0x8D52 +gl_LUMINANCE_ALPHA_FLOAT16_ATI :: GLenum +gl_LUMINANCE_ALPHA_FLOAT16_ATI = 0x881F +gl_VERTEX_ATTRIB_ARRAY_DIVISOR_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY_DIVISOR_NV = 0x88FE +gl_PERFQUERY_COUNTER_DURATION_RAW_INTEL :: GLenum +gl_PERFQUERY_COUNTER_DURATION_RAW_INTEL = 0x94F2 +gl_MAX_DEPTH :: GLenum +gl_MAX_DEPTH = 0x8280 +gl_LINEAR_MIPMAP_NEAREST :: GLenum +gl_LINEAR_MIPMAP_NEAREST = 0x2701 +gl_UNSIGNED_INT_8_8_S8_S8_REV_NV :: GLenum +gl_UNSIGNED_INT_8_8_S8_S8_REV_NV = 0x86DB +gl_N3F_V3F :: GLenum +gl_N3F_V3F = 0x2A25 +gl_PACK_MAX_COMPRESSED_SIZE_SGIX :: GLenum +gl_PACK_MAX_COMPRESSED_SIZE_SGIX = 0x831B +gl_QUERY_BUFFER_BINDING_AMD :: GLenum +gl_QUERY_BUFFER_BINDING_AMD = 0x9193 +gl_FOG_MODE :: GLenum +gl_FOG_MODE = 0x0B65 +gl_RGBA32F :: GLenum +gl_RGBA32F = 0x8814 +gl_FRAGMENT_SHADER_DERIVATIVE_HINT :: GLenum +gl_FRAGMENT_SHADER_DERIVATIVE_HINT = 0x8B8B +gl_UNPACK_SKIP_ROWS_EXT :: GLenum +gl_UNPACK_SKIP_ROWS_EXT = 0x0CF3 +gl_LINES :: GLenum +gl_LINES = 0x0001 +gl_SPOT_EXPONENT :: GLenum +gl_SPOT_EXPONENT = 0x1205 +gl_MAX_NUM_COMPATIBLE_SUBROUTINES :: GLenum +gl_MAX_NUM_COMPATIBLE_SUBROUTINES = 0x92F8 +gl_RGBA_FLOAT32_APPLE :: GLenum +gl_RGBA_FLOAT32_APPLE = 0x8814 +gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT :: GLenum +gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCALS_EXT = 0x87CE +gl_BLEND_EQUATION_ALPHA :: GLenum +gl_BLEND_EQUATION_ALPHA = 0x883D +gl_PATH_MODELVIEW_STACK_DEPTH_NV :: GLenum +gl_PATH_MODELVIEW_STACK_DEPTH_NV = 0x0BA3 +gl_TEXTURE_SHARED_SIZE_EXT :: GLenum +gl_TEXTURE_SHARED_SIZE_EXT = 0x8C3F +gl_RGBA16 :: GLenum +gl_RGBA16 = 0x805B +gl_UNDEFINED_VERTEX_EXT :: GLenum +gl_UNDEFINED_VERTEX_EXT = 0x8260 +gl_PALETTE8_RGB5_A1_OES :: GLenum +gl_PALETTE8_RGB5_A1_OES = 0x8B99 +gl_MAX_GEOMETRY_OUTPUT_VERTICES_EXT :: GLenum +gl_MAX_GEOMETRY_OUTPUT_VERTICES_EXT = 0x8DE0 +gl_IMAGE_CLASS_11_11_10 :: GLenum +gl_IMAGE_CLASS_11_11_10 = 0x82C2 +gl_HISTOGRAM_GREEN_SIZE_EXT :: GLenum +gl_HISTOGRAM_GREEN_SIZE_EXT = 0x8029 +gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT :: GLenum +gl_MAX_TESS_CONTROL_SHADER_STORAGE_BLOCKS_EXT = 0x90D8 +gl_MAX_COMPUTE_IMAGE_UNIFORMS :: GLenum +gl_MAX_COMPUTE_IMAGE_UNIFORMS = 0x91BD +gl_MAX_PATCH_VERTICES_EXT :: GLenum +gl_MAX_PATCH_VERTICES_EXT = 0x8E7D +gl_ISOLINES :: GLenum +gl_ISOLINES = 0x8E7A +gl_LUMINANCE_ALPHA_SNORM :: GLenum +gl_LUMINANCE_ALPHA_SNORM = 0x9012 +gl_PROGRAM_PIPELINE_BINDING_EXT :: GLenum +gl_PROGRAM_PIPELINE_BINDING_EXT = 0x825A +gl_FIRST_VERTEX_CONVENTION_EXT :: GLenum +gl_FIRST_VERTEX_CONVENTION_EXT = 0x8E4D +gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT :: GLenum +gl_MAX_TESS_EVALUATION_OUTPUT_COMPONENTS_EXT = 0x8E86 +gl_UTF16_NV :: GLenum +gl_UTF16_NV = 0x909B +gl_PRESENT_DURATION_NV :: GLenum +gl_PRESENT_DURATION_NV = 0x8E2B +gl_TEXTURE_SAMPLES :: GLenum +gl_TEXTURE_SAMPLES = 0x9106 +gl_BGR :: GLenum +gl_BGR = 0x80E0 +gl_CULL_VERTEX_OBJECT_POSITION_EXT :: GLenum +gl_CULL_VERTEX_OBJECT_POSITION_EXT = 0x81AC +gl_FRAGMENT_PROGRAM_POSITION_MESA :: GLenum +gl_FRAGMENT_PROGRAM_POSITION_MESA = 0x8BB0 +gl_FLOAT_RG_NV :: GLenum +gl_FLOAT_RG_NV = 0x8881 +gl_PROXY_TEXTURE_2D_MULTISAMPLE :: GLenum +gl_PROXY_TEXTURE_2D_MULTISAMPLE = 0x9101 +gl_CON_21_ATI :: GLenum +gl_CON_21_ATI = 0x8956 +gl_MAX_GEOMETRY_IMAGE_UNIFORMS :: GLenum +gl_MAX_GEOMETRY_IMAGE_UNIFORMS = 0x90CD +gl_FLOAT_MAT3x4_NV :: GLenum +gl_FLOAT_MAT3x4_NV = 0x8B68 +gl_BUFFER_VARIABLE :: GLenum +gl_BUFFER_VARIABLE = 0x92E5 +gl_ANY_SAMPLES_PASSED_EXT :: GLenum +gl_ANY_SAMPLES_PASSED_EXT = 0x8C2F +gl_TEXTURE_GEN_Q :: GLenum +gl_TEXTURE_GEN_Q = 0x0C63 +gl_GEOMETRY_VERTICES_OUT_ARB :: GLenum +gl_GEOMETRY_VERTICES_OUT_ARB = 0x8DDA +gl_POLYGON_SMOOTH_HINT :: GLenum +gl_POLYGON_SMOOTH_HINT = 0x0C53 +gl_TEXTURE_BINDING_CUBE_MAP_ARRAY :: GLenum +gl_TEXTURE_BINDING_CUBE_MAP_ARRAY = 0x900A +gl_SEPARABLE_2D_EXT :: GLenum +gl_SEPARABLE_2D_EXT = 0x8012 +gl_VERSION_ES_CL_1_0 :: GLenum +gl_VERSION_ES_CL_1_0 = 1 +gl_VERTEX_PROGRAM_PARAMETER_BUFFER_NV :: GLenum +gl_VERTEX_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA2 +gl_RED_INTEGER :: GLenum +gl_RED_INTEGER = 0x8D94 +gl_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD :: GLenum +gl_DEBUG_CATEGORY_WINDOW_SYSTEM_AMD = 0x914A +gl_OFFSET_TEXTURE_RECTANGLE_NV :: GLenum +gl_OFFSET_TEXTURE_RECTANGLE_NV = 0x864C +gl_TEXTURE_COORD_ARRAY_TYPE_EXT :: GLenum +gl_TEXTURE_COORD_ARRAY_TYPE_EXT = 0x8089 +gl_INT8_NV :: GLenum +gl_INT8_NV = 0x8FE0 +gl_VIDEO_COLOR_CONVERSION_MIN_NV :: GLenum +gl_VIDEO_COLOR_CONVERSION_MIN_NV = 0x902B +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV :: GLenum +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_NV = 0x8C4D +gl_FRAMEBUFFER_ATTACHMENT_ANGLE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_ANGLE = 0x93A3 +gl_SRC1_RGB :: GLenum +gl_SRC1_RGB = 0x8581 +gl_CON_24_ATI :: GLenum +gl_CON_24_ATI = 0x8959 +gl_DEBUG_CALLBACK_USER_PARAM :: GLenum +gl_DEBUG_CALLBACK_USER_PARAM = 0x8245 +gl_MALI_SHADER_BINARY_ARM :: GLenum +gl_MALI_SHADER_BINARY_ARM = 0x8F60 +gl_VIEW_CLASS_16_BITS :: GLenum +gl_VIEW_CLASS_16_BITS = 0x82CA +gl_DITHER :: GLenum +gl_DITHER = 0x0BD0 +gl_PATH_STROKE_COVER_MODE_NV :: GLenum +gl_PATH_STROKE_COVER_MODE_NV = 0x9083 +gl_BGR_INTEGER :: GLenum +gl_BGR_INTEGER = 0x8D9A +gl_TEXTURE_MATERIAL_PARAMETER_EXT :: GLenum +gl_TEXTURE_MATERIAL_PARAMETER_EXT = 0x8352 +gl_COMPRESSED_RGBA_ASTC_5x4_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_5x4_KHR = 0x93B1 +gl_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT :: GLenum +gl_MAX_GEOMETRY_BINDABLE_UNIFORMS_EXT = 0x8DE4 +gl_POST_CONVOLUTION_GREEN_BIAS_EXT :: GLenum +gl_POST_CONVOLUTION_GREEN_BIAS_EXT = 0x8021 +gl_PATH_ERROR_POSITION_NV :: GLenum +gl_PATH_ERROR_POSITION_NV = 0x90AB +gl_SAMPLE_ALPHA_TO_COVERAGE :: GLenum +gl_SAMPLE_ALPHA_TO_COVERAGE = 0x809E +gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910D +gl_NUM_COMPATIBLE_SUBROUTINES :: GLenum +gl_NUM_COMPATIBLE_SUBROUTINES = 0x8E4A +gl_RGBA16UI_EXT :: GLenum +gl_RGBA16UI_EXT = 0x8D76 +gl_VERTEX_SHADER_ARB :: GLenum +gl_VERTEX_SHADER_ARB = 0x8B31 +gl_RGB :: GLenum +gl_RGB = 0x1907 +gl_MAP_PERSISTENT_BIT :: GLenum +gl_MAP_PERSISTENT_BIT = 0x0040 +gl_QUERY_COUNTER_BITS_ARB :: GLenum +gl_QUERY_COUNTER_BITS_ARB = 0x8864 +gl_BLEND_EQUATION_RGB_OES :: GLenum +gl_BLEND_EQUATION_RGB_OES = 0x8009 +gl_FRAGMENT_SHADER_BIT :: GLenum +gl_FRAGMENT_SHADER_BIT = 0x00000002 +gl_MATRIX_INDEX_ARRAY_ARB :: GLenum +gl_MATRIX_INDEX_ARRAY_ARB = 0x8844 +gl_OUTPUT_TEXTURE_COORD29_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD29_EXT = 0x87BA +gl_HISTOGRAM_FORMAT :: GLenum +gl_HISTOGRAM_FORMAT = 0x8027 +gl_MAX_ASYNC_HISTOGRAM_SGIX :: GLenum +gl_MAX_ASYNC_HISTOGRAM_SGIX = 0x832D +gl_MAX_VERTEX_ATTRIBS_ARB :: GLenum +gl_MAX_VERTEX_ATTRIBS_ARB = 0x8869 +gl_SAMPLE_MASK_NV :: GLenum +gl_SAMPLE_MASK_NV = 0x8E51 +gl_COLOR_INDEXES :: GLenum +gl_COLOR_INDEXES = 0x1603 +gl_QUAD_TEXTURE_SELECT_SGIS :: GLenum +gl_QUAD_TEXTURE_SELECT_SGIS = 0x8125 +gl_RG16_SNORM :: GLenum +gl_RG16_SNORM = 0x8F99 +gl_ACTIVE_SUBROUTINE_MAX_LENGTH :: GLenum +gl_ACTIVE_SUBROUTINE_MAX_LENGTH = 0x8E48 +gl_LOGIC_OP_MODE :: GLenum +gl_LOGIC_OP_MODE = 0x0BF0 +gl_DEPTH_COMPONENT16_NONLINEAR_NV :: GLenum +gl_DEPTH_COMPONENT16_NONLINEAR_NV = 0x8E2C +gl_PRIMITIVE_RESTART_INDEX_NV :: GLenum +gl_PRIMITIVE_RESTART_INDEX_NV = 0x8559 +gl_UNKNOWN_CONTEXT_RESET :: GLenum +gl_UNKNOWN_CONTEXT_RESET = 0x8255 +gl_VBO_FREE_MEMORY_ATI :: GLenum +gl_VBO_FREE_MEMORY_ATI = 0x87FB +gl_TEXTURE_CUBE_MAP_POSITIVE_X_OES :: GLenum +gl_TEXTURE_CUBE_MAP_POSITIVE_X_OES = 0x8515 +gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR :: GLenum +gl_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR = 0x82FC +gl_TEXTURE_2D_STACK_MESAX :: GLenum +gl_TEXTURE_2D_STACK_MESAX = 0x875A +gl_DRAW_BUFFER10 :: GLenum +gl_DRAW_BUFFER10 = 0x882F +gl_FLOAT16_VEC4_NV :: GLenum +gl_FLOAT16_VEC4_NV = 0x8FFB +gl_SIGNED_HILO16_NV :: GLenum +gl_SIGNED_HILO16_NV = 0x86FA +gl_BUFFER_MAPPED_OES :: GLenum +gl_BUFFER_MAPPED_OES = 0x88BC +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT = 0x8CD1 +gl_DRAW_BUFFER5_EXT :: GLenum +gl_DRAW_BUFFER5_EXT = 0x882A +gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS_ARB = 0x8DA8 +gl_NUM_EXTENSIONS :: GLenum +gl_NUM_EXTENSIONS = 0x821D +gl_WARP_SIZE_NV :: GLenum +gl_WARP_SIZE_NV = 0x9339 +gl_TEXTURE23 :: GLenum +gl_TEXTURE23 = 0x84D7 +gl_INT_SAMPLER_2D_RECT_EXT :: GLenum +gl_INT_SAMPLER_2D_RECT_EXT = 0x8DCD +gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_OES = 0x8CDB +gl_REG_4_ATI :: GLenum +gl_REG_4_ATI = 0x8925 +gl_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG :: GLenum +gl_COMPRESSED_RGBA_PVRTC_2BPPV2_IMG = 0x9137 +gl_FOG_INDEX :: GLenum +gl_FOG_INDEX = 0x0B61 +gl_QUADRATIC_ATTENUATION :: GLenum +gl_QUADRATIC_ATTENUATION = 0x1209 +gl_COLOR_MATERIAL :: GLenum +gl_COLOR_MATERIAL = 0x0B57 +gl_SAMPLE_MASK :: GLenum +gl_SAMPLE_MASK = 0x8E51 +gl_DRAW_FRAMEBUFFER_BINDING_EXT :: GLenum +gl_DRAW_FRAMEBUFFER_BINDING_EXT = 0x8CA6 +gl_MULTISAMPLE_BUFFER_BIT5_QCOM :: GLenum +gl_MULTISAMPLE_BUFFER_BIT5_QCOM = 0x20000000 +gl_DEPTH_STENCIL_OES :: GLenum +gl_DEPTH_STENCIL_OES = 0x84F9 +gl_STENCIL_BITS :: GLenum +gl_STENCIL_BITS = 0x0D57 +gl_CURRENT_VERTEX_ATTRIB_ARB :: GLenum +gl_CURRENT_VERTEX_ATTRIB_ARB = 0x8626 +gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_LAYER_COUNT_ARB = 0x8DA9 +gl_COORD_REPLACE_ARB :: GLenum +gl_COORD_REPLACE_ARB = 0x8862 +gl_RGBA32I_EXT :: GLenum +gl_RGBA32I_EXT = 0x8D82 +gl_TEXTURE6 :: GLenum +gl_TEXTURE6 = 0x84C6 +gl_FLOAT_RGB16_NV :: GLenum +gl_FLOAT_RGB16_NV = 0x8888 +gl_TEXTURE_IMMUTABLE_FORMAT :: GLenum +gl_TEXTURE_IMMUTABLE_FORMAT = 0x912F +gl_ZERO_EXT :: GLenum +gl_ZERO_EXT = 0x87DD +gl_SOFTLIGHT_NV :: GLenum +gl_SOFTLIGHT_NV = 0x929C +gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT = 0x8CD9 +gl_TEXTURE_BASE_LEVEL :: GLenum +gl_TEXTURE_BASE_LEVEL = 0x813C +gl_COMPRESSED_SRGB_ALPHA :: GLenum +gl_COMPRESSED_SRGB_ALPHA = 0x8C49 +gl_TEXTURE18_ARB :: GLenum +gl_TEXTURE18_ARB = 0x84D2 +gl_AND_INVERTED :: GLenum +gl_AND_INVERTED = 0x1504 +gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_BINDING_EXT = 0x8C8F +gl_ARRAY_BUFFER_ARB :: GLenum +gl_ARRAY_BUFFER_ARB = 0x8892 +gl_RGBA32F_EXT :: GLenum +gl_RGBA32F_EXT = 0x8814 +gl_BLEND_EQUATION_RGB_EXT :: GLenum +gl_BLEND_EQUATION_RGB_EXT = 0x8009 +gl_FRONT_FACE :: GLenum +gl_FRONT_FACE = 0x0B46 +gl_SINGLE_COLOR_EXT :: GLenum +gl_SINGLE_COLOR_EXT = 0x81F9 +gl_QUERY_COUNTER_BITS_EXT :: GLenum +gl_QUERY_COUNTER_BITS_EXT = 0x8864 +gl_TESS_CONTROL_SHADER_PATCHES_ARB :: GLenum +gl_TESS_CONTROL_SHADER_PATCHES_ARB = 0x82F1 +gl_SPOT_CUTOFF :: GLenum +gl_SPOT_CUTOFF = 0x1206 +gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB = 0x851A +gl_OUTPUT_TEXTURE_COORD6_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD6_EXT = 0x87A3 +gl_COLOR_ATTACHMENT13_NV :: GLenum +gl_COLOR_ATTACHMENT13_NV = 0x8CED +gl_COMPRESSED_RGBA_S3TC_DXT3_EXT :: GLenum +gl_COMPRESSED_RGBA_S3TC_DXT3_EXT = 0x83F2 +gl_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV :: GLenum +gl_MAX_GEOMETRY_PROGRAM_INVOCATIONS_NV = 0x8E5A +gl_TRANSPOSE_TEXTURE_MATRIX :: GLenum +gl_TRANSPOSE_TEXTURE_MATRIX = 0x84E5 +gl_MULTISAMPLE_ARB :: GLenum +gl_MULTISAMPLE_ARB = 0x809D +gl_DEPTH_COMPONENT24 :: GLenum +gl_DEPTH_COMPONENT24 = 0x81A6 +gl_PIXEL_MAP_G_TO_G :: GLenum +gl_PIXEL_MAP_G_TO_G = 0x0C77 +gl_NAMED_STRING_LENGTH_ARB :: GLenum +gl_NAMED_STRING_LENGTH_ARB = 0x8DE9 +gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT :: GLenum +gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS_EXT = 0x8E83 +gl_UNIFORM_SIZE :: GLenum +gl_UNIFORM_SIZE = 0x8A38 +gl_MODELVIEW21_ARB :: GLenum +gl_MODELVIEW21_ARB = 0x8735 +gl_FRAGMENT_LIGHT7_SGIX :: GLenum +gl_FRAGMENT_LIGHT7_SGIX = 0x8413 +gl_DRAW_BUFFER3_ARB :: GLenum +gl_DRAW_BUFFER3_ARB = 0x8828 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x5_OES = 0x93E8 +gl_UNSIGNED_SHORT :: GLenum +gl_UNSIGNED_SHORT = 0x1403 +gl_MULTISAMPLE_BIT_ARB :: GLenum +gl_MULTISAMPLE_BIT_ARB = 0x20000000 +gl_FOG :: GLenum +gl_FOG = 0x0B60 +gl_TEXTURE_COMPARE_MODE :: GLenum +gl_TEXTURE_COMPARE_MODE = 0x884C +gl_SPHERE_MAP :: GLenum +gl_SPHERE_MAP = 0x2402 +gl_TIMEOUT_EXPIRED_APPLE :: GLenum +gl_TIMEOUT_EXPIRED_APPLE = 0x911B +gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT :: GLenum +gl_MAX_TESS_CONTROL_UNIFORM_COMPONENTS_EXT = 0x8E7F +gl_PROXY_TEXTURE_1D_ARRAY :: GLenum +gl_PROXY_TEXTURE_1D_ARRAY = 0x8C19 +gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT = 0x8CD6 +gl_TEXTURE_BINDING_CUBE_MAP :: GLenum +gl_TEXTURE_BINDING_CUBE_MAP = 0x8514 +gl_COLOR_ATTACHMENT14 :: GLenum +gl_COLOR_ATTACHMENT14 = 0x8CEE +gl_STENCIL_BUFFER_BIT :: GLenum +gl_STENCIL_BUFFER_BIT = 0x00000400 +gl_SIGNALED :: GLenum +gl_SIGNALED = 0x9119 +gl_TEXTURE_WIDTH :: GLenum +gl_TEXTURE_WIDTH = 0x1000 +gl_EVAL_BIT :: GLenum +gl_EVAL_BIT = 0x00010000 +gl_REG_28_ATI :: GLenum +gl_REG_28_ATI = 0x893D +gl_TEXTURE_BIT :: GLenum +gl_TEXTURE_BIT = 0x00040000 +gl_CONTEXT_ROBUST_ACCESS_EXT :: GLenum +gl_CONTEXT_ROBUST_ACCESS_EXT = 0x90F3 +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_NV = 0x8C80 +gl_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB :: GLenum +gl_TRANSFORM_FEEDBACK_STREAM_OVERFLOW_ARB = 0x82ED +gl_DEPTH_BUFFER_BIT :: GLenum +gl_DEPTH_BUFFER_BIT = 0x00000100 +gl_TEXCOORD2_BIT_PGI :: GLenum +gl_TEXCOORD2_BIT_PGI = 0x20000000 +gl_POST_CONVOLUTION_RED_SCALE_EXT :: GLenum +gl_POST_CONVOLUTION_RED_SCALE_EXT = 0x801C +gl_QUERY_KHR :: GLenum +gl_QUERY_KHR = 0x82E3 +gl_PACK_IMAGE_HEIGHT_EXT :: GLenum +gl_PACK_IMAGE_HEIGHT_EXT = 0x806C +gl_COMPRESSED_RGBA_ASTC_5x5_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_5x5_KHR = 0x93B2 +gl_MAX_VERTEX_UNIFORM_COMPONENTS_ARB :: GLenum +gl_MAX_VERTEX_UNIFORM_COMPONENTS_ARB = 0x8B4A +gl_DEPTH_STENCIL_ATTACHMENT :: GLenum +gl_DEPTH_STENCIL_ATTACHMENT = 0x821A +gl_HSL_HUE_KHR :: GLenum +gl_HSL_HUE_KHR = 0x92AD +gl_ATC_RGB_AMD :: GLenum +gl_ATC_RGB_AMD = 0x8C92 +gl_DECR_WRAP :: GLenum +gl_DECR_WRAP = 0x8508 +gl_GEOMETRY_VERTICES_OUT :: GLenum +gl_GEOMETRY_VERTICES_OUT = 0x8916 +gl_OFFSET_TEXTURE_BIAS_NV :: GLenum +gl_OFFSET_TEXTURE_BIAS_NV = 0x86E3 +gl_COLOR_ATTACHMENT5_NV :: GLenum +gl_COLOR_ATTACHMENT5_NV = 0x8CE5 +gl_POINT_SIZE_ARRAY_POINTER_OES :: GLenum +gl_POINT_SIZE_ARRAY_POINTER_OES = 0x898C +gl_TEXTURE_COMPARE_FAIL_VALUE_ARB :: GLenum +gl_TEXTURE_COMPARE_FAIL_VALUE_ARB = 0x80BF +gl_RENDERBUFFER_COLOR_SAMPLES_NV :: GLenum +gl_RENDERBUFFER_COLOR_SAMPLES_NV = 0x8E10 +gl_CON_10_ATI :: GLenum +gl_CON_10_ATI = 0x894B +gl_IMAGE_ROTATE_ANGLE_HP :: GLenum +gl_IMAGE_ROTATE_ANGLE_HP = 0x8159 +gl_UNIFORM_BUFFER_UNIFIED_NV :: GLenum +gl_UNIFORM_BUFFER_UNIFIED_NV = 0x936E +gl_INTENSITY4 :: GLenum +gl_INTENSITY4 = 0x804A +gl_DEBUG_LOGGED_MESSAGES_KHR :: GLenum +gl_DEBUG_LOGGED_MESSAGES_KHR = 0x9145 +gl_MINUS_CLAMPED_NV :: GLenum +gl_MINUS_CLAMPED_NV = 0x92B3 +gl_BUFFER_SIZE :: GLenum +gl_BUFFER_SIZE = 0x8764 +gl_SRGB_EXT :: GLenum +gl_SRGB_EXT = 0x8C40 +gl_PIXEL_TEX_GEN_Q_ROUND_SGIX :: GLenum +gl_PIXEL_TEX_GEN_Q_ROUND_SGIX = 0x8185 +gl_R16I :: GLenum +gl_R16I = 0x8233 +gl_COLOR_COMPONENTS :: GLenum +gl_COLOR_COMPONENTS = 0x8283 +gl_TEXTURE_VIEW_NUM_LEVELS :: GLenum +gl_TEXTURE_VIEW_NUM_LEVELS = 0x82DC +gl_COLOR_ATTACHMENT11 :: GLenum +gl_COLOR_ATTACHMENT11 = 0x8CEB +gl_OBJECT_PLANE :: GLenum +gl_OBJECT_PLANE = 0x2501 +gl_IMAGE_3D_EXT :: GLenum +gl_IMAGE_3D_EXT = 0x904E +gl_MAX_GEOMETRY_INPUT_COMPONENTS :: GLenum +gl_MAX_GEOMETRY_INPUT_COMPONENTS = 0x9123 +gl_TEXTURE_COORD_ARRAY_LIST_IBM :: GLenum +gl_TEXTURE_COORD_ARRAY_LIST_IBM = 103074 +gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS :: GLenum +gl_MAX_VERTEX_TEXTURE_IMAGE_UNITS = 0x8B4C +gl_CLIENT_ACTIVE_TEXTURE :: GLenum +gl_CLIENT_ACTIVE_TEXTURE = 0x84E1 +gl_MAX_GEOMETRY_VARYING_COMPONENTS_ARB :: GLenum +gl_MAX_GEOMETRY_VARYING_COMPONENTS_ARB = 0x8DDD +gl_OPERAND1_RGB :: GLenum +gl_OPERAND1_RGB = 0x8591 +gl_POINT_SIZE_ARRAY_OES :: GLenum +gl_POINT_SIZE_ARRAY_OES = 0x8B9C +gl_GLYPH_VERTICAL_BEARING_Y_BIT_NV :: GLenum +gl_GLYPH_VERTICAL_BEARING_Y_BIT_NV = 0x40 +gl_MODELVIEW6_ARB :: GLenum +gl_MODELVIEW6_ARB = 0x8726 +gl_DEBUG_OUTPUT_SYNCHRONOUS_KHR :: GLenum +gl_DEBUG_OUTPUT_SYNCHRONOUS_KHR = 0x8242 +gl_AND_REVERSE :: GLenum +gl_AND_REVERSE = 0x1502 +gl_CLAMP_TO_BORDER_NV :: GLenum +gl_CLAMP_TO_BORDER_NV = 0x812D +gl_GUILTY_CONTEXT_RESET_ARB :: GLenum +gl_GUILTY_CONTEXT_RESET_ARB = 0x8253 +gl_INT64_VEC2_NV :: GLenum +gl_INT64_VEC2_NV = 0x8FE9 +gl_C3F_V3F :: GLenum +gl_C3F_V3F = 0x2A24 +gl_OBJECT_LINEAR_NV :: GLenum +gl_OBJECT_LINEAR_NV = 0x2401 +gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT :: GLenum +gl_MAX_COMBINED_TESS_EVALUATION_UNIFORM_COMPONENTS_EXT = 0x8E1F +gl_TEXTURE_FLOAT_COMPONENTS_NV :: GLenum +gl_TEXTURE_FLOAT_COMPONENTS_NV = 0x888C +gl_SOURCE3_ALPHA_NV :: GLenum +gl_SOURCE3_ALPHA_NV = 0x858B +gl_OPERAND2_ALPHA_EXT :: GLenum +gl_OPERAND2_ALPHA_EXT = 0x859A +gl_CON_12_ATI :: GLenum +gl_CON_12_ATI = 0x894D +gl_SYNC_STATUS :: GLenum +gl_SYNC_STATUS = 0x9114 +gl_BLEND_SRC_RGB_EXT :: GLenum +gl_BLEND_SRC_RGB_EXT = 0x80C9 +gl_DEBUG_SOURCE_WINDOW_SYSTEM_ARB :: GLenum +gl_DEBUG_SOURCE_WINDOW_SYSTEM_ARB = 0x8247 +gl_TEXTURE_2D_MULTISAMPLE_ARRAY :: GLenum +gl_TEXTURE_2D_MULTISAMPLE_ARRAY = 0x9102 +gl_LEFT :: GLenum +gl_LEFT = 0x0406 +gl_UNSIGNED_INT_SAMPLER_1D :: GLenum +gl_UNSIGNED_INT_SAMPLER_1D = 0x8DD1 +gl_PIXEL_MAP_I_TO_R_SIZE :: GLenum +gl_PIXEL_MAP_I_TO_R_SIZE = 0x0CB2 +gl_VERTEX_ARRAY_BINDING_OES :: GLenum +gl_VERTEX_ARRAY_BINDING_OES = 0x85B5 +gl_COMBINE_ALPHA_EXT :: GLenum +gl_COMBINE_ALPHA_EXT = 0x8572 +gl_TRANSFORM_FEEDBACK_ATTRIBS_NV :: GLenum +gl_TRANSFORM_FEEDBACK_ATTRIBS_NV = 0x8C7E +gl_CURRENT_WEIGHT_ARB :: GLenum +gl_CURRENT_WEIGHT_ARB = 0x86A8 +gl_RASTERIZER_DISCARD_NV :: GLenum +gl_RASTERIZER_DISCARD_NV = 0x8C89 +gl_SRC_IN_NV :: GLenum +gl_SRC_IN_NV = 0x928A +gl_OBJECT_DISTANCE_TO_POINT_SGIS :: GLenum +gl_OBJECT_DISTANCE_TO_POINT_SGIS = 0x81F1 +gl_COMPRESSED_RGB8_ETC2 :: GLenum +gl_COMPRESSED_RGB8_ETC2 = 0x9274 +gl_MAX_VERTEX_SHADER_STORAGE_BLOCKS :: GLenum +gl_MAX_VERTEX_SHADER_STORAGE_BLOCKS = 0x90D6 +gl_RGB_SNORM :: GLenum +gl_RGB_SNORM = 0x8F92 +gl_INTENSITY4_EXT :: GLenum +gl_INTENSITY4_EXT = 0x804A +gl_R8I :: GLenum +gl_R8I = 0x8231 +gl_MAX_SUBROUTINE_UNIFORM_LOCATIONS :: GLenum +gl_MAX_SUBROUTINE_UNIFORM_LOCATIONS = 0x8DE8 +gl_EDGEFLAG_BIT_PGI :: GLenum +gl_EDGEFLAG_BIT_PGI = 0x00040000 +gl_MAX_FRAMEBUFFER_SAMPLES :: GLenum +gl_MAX_FRAMEBUFFER_SAMPLES = 0x9318 +gl_SECONDARY_COLOR_ARRAY_TYPE :: GLenum +gl_SECONDARY_COLOR_ARRAY_TYPE = 0x845B +gl_ALL_BARRIER_BITS_EXT :: GLenum +gl_ALL_BARRIER_BITS_EXT = 0xFFFFFFFF +gl_TEXTURE14 :: GLenum +gl_TEXTURE14 = 0x84CE +gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER :: GLenum +gl_UNIFORM_BLOCK_REFERENCED_BY_TESS_EVALUATION_SHADER = 0x84F1 +gl_SRC0_ALPHA :: GLenum +gl_SRC0_ALPHA = 0x8588 +gl_MODELVIEW16_ARB :: GLenum +gl_MODELVIEW16_ARB = 0x8730 +gl_DARKEN_NV :: GLenum +gl_DARKEN_NV = 0x9297 +gl_INTENSITY_EXT :: GLenum +gl_INTENSITY_EXT = 0x8049 +gl_CURRENT_BIT :: GLenum +gl_CURRENT_BIT = 0x00000001 +gl_FLOAT_RGBA32_NV :: GLenum +gl_FLOAT_RGBA32_NV = 0x888B +gl_SHADOW_ATTENUATION_EXT :: GLenum +gl_SHADOW_ATTENUATION_EXT = 0x834E +gl_COMPRESSED_SRGB8_ETC2 :: GLenum +gl_COMPRESSED_SRGB8_ETC2 = 0x9275 +gl_DRAW_BUFFER15 :: GLenum +gl_DRAW_BUFFER15 = 0x8834 +gl_COMPARE_R_TO_TEXTURE_ARB :: GLenum +gl_COMPARE_R_TO_TEXTURE_ARB = 0x884E +gl_R11F_G11F_B10F_EXT :: GLenum +gl_R11F_G11F_B10F_EXT = 0x8C3A +gl_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG :: GLenum +gl_COMPRESSED_RGBA_PVRTC_4BPPV2_IMG = 0x9138 +gl_MULTISAMPLE_BUFFER_BIT6_QCOM :: GLenum +gl_MULTISAMPLE_BUFFER_BIT6_QCOM = 0x40000000 +gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT :: GLenum +gl_MAX_SHADER_PIXEL_LOCAL_STORAGE_SIZE_EXT = 0x8F67 +gl_FEEDBACK_BUFFER_TYPE :: GLenum +gl_FEEDBACK_BUFFER_TYPE = 0x0DF2 +gl_IMAGE_BINDING_FORMAT_EXT :: GLenum +gl_IMAGE_BINDING_FORMAT_EXT = 0x906E +gl_PROXY_TEXTURE_2D_EXT :: GLenum +gl_PROXY_TEXTURE_2D_EXT = 0x8064 +gl_DEPTH32F_STENCIL8 :: GLenum +gl_DEPTH32F_STENCIL8 = 0x8CAD +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS = 0x8C8B +gl_TESS_EVALUATION_SUBROUTINE :: GLenum +gl_TESS_EVALUATION_SUBROUTINE = 0x92EA +gl_TEXTURE_LOD_BIAS_T_SGIX :: GLenum +gl_TEXTURE_LOD_BIAS_T_SGIX = 0x818F +gl_COVERAGE_COMPONENT4_NV :: GLenum +gl_COVERAGE_COMPONENT4_NV = 0x8ED1 +gl_TEXTURE6_ARB :: GLenum +gl_TEXTURE6_ARB = 0x84C6 +gl_MAX_3D_TEXTURE_SIZE_EXT :: GLenum +gl_MAX_3D_TEXTURE_SIZE_EXT = 0x8073 +gl_TEXTURE_RESIDENT :: GLenum +gl_TEXTURE_RESIDENT = 0x8067 +gl_FOG_COORD_ARRAY_TYPE :: GLenum +gl_FOG_COORD_ARRAY_TYPE = 0x8454 +gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR :: GLenum +gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR = 0x824D +gl_QUERY_BY_REGION_WAIT :: GLenum +gl_QUERY_BY_REGION_WAIT = 0x8E15 +gl_SLUMINANCE_ALPHA :: GLenum +gl_SLUMINANCE_ALPHA = 0x8C44 +gl_INT_SAMPLER_CUBE :: GLenum +gl_INT_SAMPLER_CUBE = 0x8DCC +gl_UNSIGNED_SHORT_4_4_4_4_REV :: GLenum +gl_UNSIGNED_SHORT_4_4_4_4_REV = 0x8365 +gl_MAX_PROGRAM_NATIVE_PARAMETERS_ARB :: GLenum +gl_MAX_PROGRAM_NATIVE_PARAMETERS_ARB = 0x88AB +gl_LUMINANCE4_ALPHA4_EXT :: GLenum +gl_LUMINANCE4_ALPHA4_EXT = 0x8043 +gl_OPERAND0_RGB_ARB :: GLenum +gl_OPERAND0_RGB_ARB = 0x8590 +gl_PROXY_TEXTURE_2D_STACK_MESAX :: GLenum +gl_PROXY_TEXTURE_2D_STACK_MESAX = 0x875C +gl_TEXTURE_3D_EXT :: GLenum +gl_TEXTURE_3D_EXT = 0x806F +gl_STREAM_RASTERIZATION_AMD :: GLenum +gl_STREAM_RASTERIZATION_AMD = 0x91A0 +gl_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT :: GLenum +gl_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT = 0x8DD6 +gl_DEPTH_COMPONENT32_SGIX :: GLenum +gl_DEPTH_COMPONENT32_SGIX = 0x81A7 +gl_LINE_STRIP :: GLenum +gl_LINE_STRIP = 0x0003 +gl_CON_25_ATI :: GLenum +gl_CON_25_ATI = 0x895A +gl_SLIM10U_SGIX :: GLenum +gl_SLIM10U_SGIX = 0x831E +gl_COLOR_INDEX2_EXT :: GLenum +gl_COLOR_INDEX2_EXT = 0x80E3 +gl_CON_22_ATI :: GLenum +gl_CON_22_ATI = 0x8957 +gl_DEFORMATIONS_MASK_SGIX :: GLenum +gl_DEFORMATIONS_MASK_SGIX = 0x8196 +gl_INVERSE_TRANSPOSE_NV :: GLenum +gl_INVERSE_TRANSPOSE_NV = 0x862D +gl_MULT :: GLenum +gl_MULT = 0x0103 +gl_ATTRIB_ARRAY_STRIDE_NV :: GLenum +gl_ATTRIB_ARRAY_STRIDE_NV = 0x8624 +gl_RGBA16_SNORM :: GLenum +gl_RGBA16_SNORM = 0x8F9B +gl_MIN_SAMPLE_SHADING_VALUE :: GLenum +gl_MIN_SAMPLE_SHADING_VALUE = 0x8C37 +gl_RG8_SNORM :: GLenum +gl_RG8_SNORM = 0x8F95 +gl_OBJECT_ATTACHED_OBJECTS_ARB :: GLenum +gl_OBJECT_ATTACHED_OBJECTS_ARB = 0x8B85 +gl_UNPACK_SKIP_PIXELS_EXT :: GLenum +gl_UNPACK_SKIP_PIXELS_EXT = 0x0CF4 +gl_ACTIVE_VERTEX_UNITS_ARB :: GLenum +gl_ACTIVE_VERTEX_UNITS_ARB = 0x86A5 +gl_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT :: GLenum +gl_MAX_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87C5 +gl_INTERNALFORMAT_RED_TYPE :: GLenum +gl_INTERNALFORMAT_RED_TYPE = 0x8278 +gl_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV :: GLenum +gl_MAX_PROGRAM_PARAMETER_BUFFER_BINDINGS_NV = 0x8DA0 +gl_FLOAT_RGB_NV :: GLenum +gl_FLOAT_RGB_NV = 0x8882 +gl_MAP_FLUSH_EXPLICIT_BIT_EXT :: GLenum +gl_MAP_FLUSH_EXPLICIT_BIT_EXT = 0x0010 +gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS = 0x8DA8 +gl_HALF_FLOAT_NV :: GLenum +gl_HALF_FLOAT_NV = 0x140B +gl_DEPTH_STENCIL :: GLenum +gl_DEPTH_STENCIL = 0x84F9 +gl_PROGRAM_ERROR_POSITION_ARB :: GLenum +gl_PROGRAM_ERROR_POSITION_ARB = 0x864B +gl_TRACE_ERRORS_BIT_MESA :: GLenum +gl_TRACE_ERRORS_BIT_MESA = 0x0020 +gl_STENCIL_OP_VALUE_AMD :: GLenum +gl_STENCIL_OP_VALUE_AMD = 0x874C +gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_OES = 0x8CD6 +gl_COMPRESSED_SIGNED_R11_EAC :: GLenum +gl_COMPRESSED_SIGNED_R11_EAC = 0x9271 +gl_FLOAT_MAT3x2 :: GLenum +gl_FLOAT_MAT3x2 = 0x8B67 +gl_PROGRAM_ERROR_STRING_NV :: GLenum +gl_PROGRAM_ERROR_STRING_NV = 0x8874 +gl_VERTEX_ID_NV :: GLenum +gl_VERTEX_ID_NV = 0x8C7B +gl_VERTEX_BINDING_OFFSET :: GLenum +gl_VERTEX_BINDING_OFFSET = 0x82D7 +gl_RESTART_SUN :: GLenum +gl_RESTART_SUN = 0x0001 +gl_INT_IMAGE_CUBE_MAP_ARRAY_EXT :: GLenum +gl_INT_IMAGE_CUBE_MAP_ARRAY_EXT = 0x905F +gl_COLOR_INDEX :: GLenum +gl_COLOR_INDEX = 0x1900 +gl_TEXTURE31_ARB :: GLenum +gl_TEXTURE31_ARB = 0x84DF +gl_MAX_DRAW_BUFFERS_ARB :: GLenum +gl_MAX_DRAW_BUFFERS_ARB = 0x8824 +gl_MAX_IMAGE_UNITS :: GLenum +gl_MAX_IMAGE_UNITS = 0x8F38 +gl_OUTPUT_TEXTURE_COORD4_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD4_EXT = 0x87A1 +gl_COLOR_ARRAY_POINTER :: GLenum +gl_COLOR_ARRAY_POINTER = 0x8090 +gl_MAX_COLOR_TEXTURE_SAMPLES :: GLenum +gl_MAX_COLOR_TEXTURE_SAMPLES = 0x910E +gl_SIGNED_NEGATE_NV :: GLenum +gl_SIGNED_NEGATE_NV = 0x853D +gl_MAX_GEOMETRY_UNIFORM_BLOCKS :: GLenum +gl_MAX_GEOMETRY_UNIFORM_BLOCKS = 0x8A2C +gl_DEBUG_TYPE_ERROR :: GLenum +gl_DEBUG_TYPE_ERROR = 0x824C +gl_HISTOGRAM_RED_SIZE_EXT :: GLenum +gl_HISTOGRAM_RED_SIZE_EXT = 0x8028 +gl_SECONDARY_COLOR_ARRAY_POINTER_EXT :: GLenum +gl_SECONDARY_COLOR_ARRAY_POINTER_EXT = 0x845D +gl_UNSIGNALED :: GLenum +gl_UNSIGNALED = 0x9118 +gl_CON_8_ATI :: GLenum +gl_CON_8_ATI = 0x8949 +gl_COMPRESSED_RED :: GLenum +gl_COMPRESSED_RED = 0x8225 +gl_RGBA2_EXT :: GLenum +gl_RGBA2_EXT = 0x8055 +gl_T2F_C3F_V3F :: GLenum +gl_T2F_C3F_V3F = 0x2A2A +gl_SECONDARY_COLOR_ARRAY :: GLenum +gl_SECONDARY_COLOR_ARRAY = 0x845E +gl_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT :: GLenum +gl_MAX_OPTIMIZED_VERTEX_SHADER_INVARIANTS_EXT = 0x87CD +gl_COLOR3_BIT_PGI :: GLenum +gl_COLOR3_BIT_PGI = 0x00010000 +gl_CLIP_DISTANCE3 :: GLenum +gl_CLIP_DISTANCE3 = 0x3003 +gl_TEXTURE_SWIZZLE_G_EXT :: GLenum +gl_TEXTURE_SWIZZLE_G_EXT = 0x8E43 +gl_SAMPLER_CUBE_MAP_ARRAY :: GLenum +gl_SAMPLER_CUBE_MAP_ARRAY = 0x900C +gl_4PASS_3_SGIS :: GLenum +gl_4PASS_3_SGIS = 0x80A7 +gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT = 0x8CD7 +gl_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT :: GLenum +gl_MAX_GEOMETRY_ATOMIC_COUNTERS_EXT = 0x92D5 +gl_VERTEX_ARRAY_STRIDE :: GLenum +gl_VERTEX_ARRAY_STRIDE = 0x807C +gl_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS :: GLenum +gl_FRAMEBUFFER_DEFAULT_FIXED_SAMPLE_LOCATIONS = 0x9314 +gl_TEXTURE_SWIZZLE_A :: GLenum +gl_TEXTURE_SWIZZLE_A = 0x8E45 +gl_DOUBLE_MAT3x2 :: GLenum +gl_DOUBLE_MAT3x2 = 0x8F4B +gl_TEXTURE_UPDATE_BARRIER_BIT_EXT :: GLenum +gl_TEXTURE_UPDATE_BARRIER_BIT_EXT = 0x00000100 +gl_SHADING_LANGUAGE_VERSION :: GLenum +gl_SHADING_LANGUAGE_VERSION = 0x8B8C +gl_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP :: GLenum +gl_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8162 +gl_FIXED_ONLY_ARB :: GLenum +gl_FIXED_ONLY_ARB = 0x891D +gl_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI :: GLenum +gl_NUM_INPUT_INTERPOLATOR_COMPONENTS_ATI = 0x8973 +gl_CON_19_ATI :: GLenum +gl_CON_19_ATI = 0x8954 +gl_CONTEXT_RELEASE_BEHAVIOR :: GLenum +gl_CONTEXT_RELEASE_BEHAVIOR = 0x82FB +gl_ARRAY_BUFFER_BINDING :: GLenum +gl_ARRAY_BUFFER_BINDING = 0x8894 +gl_UNPACK_COLORSPACE_CONVERSION_WEBGL :: GLenum +gl_UNPACK_COLORSPACE_CONVERSION_WEBGL = 0x9243 +gl_CONVEX_HULL_NV :: GLenum +gl_CONVEX_HULL_NV = 0x908B +gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB :: GLenum +gl_SAMPLER_CUBE_MAP_ARRAY_SHADOW_ARB = 0x900D +gl_FIRST_TO_REST_NV :: GLenum +gl_FIRST_TO_REST_NV = 0x90AF +gl_MAX_TEXTURE_COORDS :: GLenum +gl_MAX_TEXTURE_COORDS = 0x8871 +gl_TEXTURE_DEPTH :: GLenum +gl_TEXTURE_DEPTH = 0x8071 +gl_LIGHT0 :: GLenum +gl_LIGHT0 = 0x4000 +gl_VERTEX_STREAM4_ATI :: GLenum +gl_VERTEX_STREAM4_ATI = 0x8770 +gl_POST_COLOR_MATRIX_ALPHA_BIAS_SGI :: GLenum +gl_POST_COLOR_MATRIX_ALPHA_BIAS_SGI = 0x80BB +gl_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS :: GLenum +gl_MAX_VERTEX_ATOMIC_COUNTER_BUFFERS = 0x92CC +gl_SAMPLER_2D_RECT_SHADOW_ARB :: GLenum +gl_SAMPLER_2D_RECT_SHADOW_ARB = 0x8B64 +gl_DRAW_BUFFER1_ATI :: GLenum +gl_DRAW_BUFFER1_ATI = 0x8826 +gl_SAMPLE_BUFFERS_SGIS :: GLenum +gl_SAMPLE_BUFFERS_SGIS = 0x80A8 +gl_SIGNED_LUMINANCE_ALPHA_NV :: GLenum +gl_SIGNED_LUMINANCE_ALPHA_NV = 0x8703 +gl_R16_SNORM :: GLenum +gl_R16_SNORM = 0x8F98 +gl_DRAW_BUFFER13_ATI :: GLenum +gl_DRAW_BUFFER13_ATI = 0x8832 +gl_TEXTURE_LIGHT_EXT :: GLenum +gl_TEXTURE_LIGHT_EXT = 0x8350 +gl_BOOL_ARB :: GLenum +gl_BOOL_ARB = 0x8B56 +gl_BGRA_IMG :: GLenum +gl_BGRA_IMG = 0x80E1 +gl_SRGB_ALPHA_EXT :: GLenum +gl_SRGB_ALPHA_EXT = 0x8C42 +gl_RELATIVE_ROUNDED_RECT2_NV :: GLenum +gl_RELATIVE_ROUNDED_RECT2_NV = 0xEB +gl_LUMINANCE16UI_EXT :: GLenum +gl_LUMINANCE16UI_EXT = 0x8D7A +gl_MATRIX7_NV :: GLenum +gl_MATRIX7_NV = 0x8637 +gl_INTENSITY16 :: GLenum +gl_INTENSITY16 = 0x804D +gl_DRAW_INDIRECT_BUFFER :: GLenum +gl_DRAW_INDIRECT_BUFFER = 0x8F3F +gl_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM :: GLenum +gl_EDGE_FLAG_ARRAY_LIST_STRIDE_IBM = 103085 +gl_MAX_IMAGE_SAMPLES_EXT :: GLenum +gl_MAX_IMAGE_SAMPLES_EXT = 0x906D +gl_DEBUG_SOURCE_OTHER_ARB :: GLenum +gl_DEBUG_SOURCE_OTHER_ARB = 0x824B +gl_POINT_BIT :: GLenum +gl_POINT_BIT = 0x00000002 +gl_MAX_VARYING_VECTORS :: GLenum +gl_MAX_VARYING_VECTORS = 0x8DFC +gl_SUBTRACT_ARB :: GLenum +gl_SUBTRACT_ARB = 0x84E7 +gl_INT_SAMPLER_BUFFER_AMD :: GLenum +gl_INT_SAMPLER_BUFFER_AMD = 0x9002 +gl_SAMPLE_MASK_INVERT_SGIS :: GLenum +gl_SAMPLE_MASK_INVERT_SGIS = 0x80AB +gl_POINT_DISTANCE_ATTENUATION_ARB :: GLenum +gl_POINT_DISTANCE_ATTENUATION_ARB = 0x8129 +gl_GREEN_BIT_ATI :: GLenum +gl_GREEN_BIT_ATI = 0x00000002 +gl_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT :: GLenum +gl_MAX_OPTIMIZED_VERTEX_SHADER_INSTRUCTIONS_EXT = 0x87CA +gl_FRAMEBUFFER :: GLenum +gl_FRAMEBUFFER = 0x8D40 +gl_TEXTURE_COMPRESSION_HINT_ARB :: GLenum +gl_TEXTURE_COMPRESSION_HINT_ARB = 0x84EF +gl_PROGRAM_INPUT :: GLenum +gl_PROGRAM_INPUT = 0x92E3 +gl_SCREEN_NV :: GLenum +gl_SCREEN_NV = 0x9295 +gl_TEXTURE_CUBE_MAP_ARRAY_EXT :: GLenum +gl_TEXTURE_CUBE_MAP_ARRAY_EXT = 0x9009 +gl_FENCE_STATUS_NV :: GLenum +gl_FENCE_STATUS_NV = 0x84F3 +gl_MAX_BINDABLE_UNIFORM_SIZE_EXT :: GLenum +gl_MAX_BINDABLE_UNIFORM_SIZE_EXT = 0x8DED +gl_PACK_COMPRESSED_BLOCK_WIDTH :: GLenum +gl_PACK_COMPRESSED_BLOCK_WIDTH = 0x912B +gl_RELATIVE_VERTICAL_LINE_TO_NV :: GLenum +gl_RELATIVE_VERTICAL_LINE_TO_NV = 0x09 +gl_POST_COLOR_MATRIX_COLOR_TABLE_SGI :: GLenum +gl_POST_COLOR_MATRIX_COLOR_TABLE_SGI = 0x80D2 +gl_ALPHA_INTEGER :: GLenum +gl_ALPHA_INTEGER = 0x8D97 +gl_MAX_SUBROUTINES :: GLenum +gl_MAX_SUBROUTINES = 0x8DE7 +gl_UNSIGNED_INT_VEC3_EXT :: GLenum +gl_UNSIGNED_INT_VEC3_EXT = 0x8DC7 +gl_ELEMENT_ARRAY_ATI :: GLenum +gl_ELEMENT_ARRAY_ATI = 0x8768 +gl_ONE_MINUS_CONSTANT_COLOR :: GLenum +gl_ONE_MINUS_CONSTANT_COLOR = 0x8002 +gl_MODELVIEW18_ARB :: GLenum +gl_MODELVIEW18_ARB = 0x8732 +gl_CONSTANT_ARB :: GLenum +gl_CONSTANT_ARB = 0x8576 +gl_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV :: GLenum +gl_GEOMETRY_PROGRAM_PARAMETER_BUFFER_NV = 0x8DA3 +gl_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL :: GLenum +gl_PERFQUERY_QUERY_NAME_LENGTH_MAX_INTEL = 0x94FD +gl_DRAW_BUFFER_EXT :: GLenum +gl_DRAW_BUFFER_EXT = 0x0C01 +gl_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT :: GLenum +gl_UNSIGNED_INT_IMAGE_1D_ARRAY_EXT = 0x9068 +gl_FLOAT_MAT2x4_NV :: GLenum +gl_FLOAT_MAT2x4_NV = 0x8B66 +gl_CULL_VERTEX_EXT :: GLenum +gl_CULL_VERTEX_EXT = 0x81AA +gl_MATRIX_PALETTE_ARB :: GLenum +gl_MATRIX_PALETTE_ARB = 0x8840 +gl_VERTEX_PROGRAM_POINT_SIZE_ARB :: GLenum +gl_VERTEX_PROGRAM_POINT_SIZE_ARB = 0x8642 +gl_FLOAT_RG16_NV :: GLenum +gl_FLOAT_RG16_NV = 0x8886 +gl_CON_1_ATI :: GLenum +gl_CON_1_ATI = 0x8942 +gl_BLEND_EQUATION_RGB :: GLenum +gl_BLEND_EQUATION_RGB = 0x8009 +gl_OP_CROSS_PRODUCT_EXT :: GLenum +gl_OP_CROSS_PRODUCT_EXT = 0x8797 +gl_VERTEX_WEIGHT_ARRAY_STRIDE_EXT :: GLenum +gl_VERTEX_WEIGHT_ARRAY_STRIDE_EXT = 0x850F +gl_TESS_CONTROL_PROGRAM_NV :: GLenum +gl_TESS_CONTROL_PROGRAM_NV = 0x891E +gl_FIXED_ONLY :: GLenum +gl_FIXED_ONLY = 0x891D +gl_4PASS_1_EXT :: GLenum +gl_4PASS_1_EXT = 0x80A5 +gl_SAMPLER_2D_MULTISAMPLE_ARRAY_OES :: GLenum +gl_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910B +gl_UNSIGNED_INT_8_8_8_8_REV :: GLenum +gl_UNSIGNED_INT_8_8_8_8_REV = 0x8367 +gl_UNIFORM_BLOCK_ACTIVE_UNIFORMS :: GLenum +gl_UNIFORM_BLOCK_ACTIVE_UNIFORMS = 0x8A42 +gl_SLUMINANCE_ALPHA_NV :: GLenum +gl_SLUMINANCE_ALPHA_NV = 0x8C44 +gl_PROXY_TEXTURE_CUBE_MAP :: GLenum +gl_PROXY_TEXTURE_CUBE_MAP = 0x851B +gl_IMAGE_CLASS_1_X_32 :: GLenum +gl_IMAGE_CLASS_1_X_32 = 0x82BB +gl_STACK_OVERFLOW_KHR :: GLenum +gl_STACK_OVERFLOW_KHR = 0x0503 +gl_COMPRESSED_RGBA_ASTC_5x5x5_OES :: GLenum +gl_COMPRESSED_RGBA_ASTC_5x5x5_OES = 0x93C6 +gl_CLOSE_PATH_NV :: GLenum +gl_CLOSE_PATH_NV = 0x00 +gl_PIXEL_COUNT_AVAILABLE_NV :: GLenum +gl_PIXEL_COUNT_AVAILABLE_NV = 0x8867 +gl_PATH_DASH_OFFSET_NV :: GLenum +gl_PATH_DASH_OFFSET_NV = 0x907E +gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_INTERLEAVED_COMPONENTS_NV = 0x8C8A +gl_GLOBAL_ALPHA_FACTOR_SUN :: GLenum +gl_GLOBAL_ALPHA_FACTOR_SUN = 0x81DA +gl_INDEX_ARRAY_COUNT_EXT :: GLenum +gl_INDEX_ARRAY_COUNT_EXT = 0x8087 +gl_PACK_RESAMPLE_OML :: GLenum +gl_PACK_RESAMPLE_OML = 0x8984 +gl_LAYER_NV :: GLenum +gl_LAYER_NV = 0x8DAA +gl_DRAW_FRAMEBUFFER :: GLenum +gl_DRAW_FRAMEBUFFER = 0x8CA9 +gl_LINEAR_DETAIL_ALPHA_SGIS :: GLenum +gl_LINEAR_DETAIL_ALPHA_SGIS = 0x8098 +gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT :: GLenum +gl_MAX_TESS_CONTROL_UNIFORM_BLOCKS_EXT = 0x8E89 +gl_EDGE_FLAG_ARRAY :: GLenum +gl_EDGE_FLAG_ARRAY = 0x8079 +gl_TEXTURE_DEFORMATION_BIT_SGIX :: GLenum +gl_TEXTURE_DEFORMATION_BIT_SGIX = 0x00000001 +gl_SOURCE1_RGB :: GLenum +gl_SOURCE1_RGB = 0x8581 +gl_TEXTURE_3D_OES :: GLenum +gl_TEXTURE_3D_OES = 0x806F +gl_ALLOW_DRAW_OBJ_HINT_PGI :: GLenum +gl_ALLOW_DRAW_OBJ_HINT_PGI = 0x1A20E +gl_PATH_STROKE_BOUNDING_BOX_NV :: GLenum +gl_PATH_STROKE_BOUNDING_BOX_NV = 0x90A2 +gl_HINT_BIT :: GLenum +gl_HINT_BIT = 0x00008000 +gl_VERTICAL_LINE_TO_NV :: GLenum +gl_VERTICAL_LINE_TO_NV = 0x08 +gl_MAX_TEXTURE_BUFFER_SIZE_EXT :: GLenum +gl_MAX_TEXTURE_BUFFER_SIZE_EXT = 0x8C2B +gl_MAX_DRAW_BUFFERS_ATI :: GLenum +gl_MAX_DRAW_BUFFERS_ATI = 0x8824 +gl_R8_EXT :: GLenum +gl_R8_EXT = 0x8229 +gl_TEXTURE_COVERAGE_SAMPLES_NV :: GLenum +gl_TEXTURE_COVERAGE_SAMPLES_NV = 0x9045 +gl_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV :: GLenum +gl_NEXT_VIDEO_CAPTURE_BUFFER_STATUS_NV = 0x9025 +gl_REFERENCED_BY_VERTEX_SHADER :: GLenum +gl_REFERENCED_BY_VERTEX_SHADER = 0x9306 +gl_FLOAT_RG32_NV :: GLenum +gl_FLOAT_RG32_NV = 0x8887 +gl_TESSELLATION_FACTOR_AMD :: GLenum +gl_TESSELLATION_FACTOR_AMD = 0x9005 +gl_MAX_PROGRAM_TEMPORARIES_ARB :: GLenum +gl_MAX_PROGRAM_TEMPORARIES_ARB = 0x88A5 +gl_COMPRESSED_RGBA_ASTC_12x12_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_12x12_KHR = 0x93BD +gl_PROJECTION :: GLenum +gl_PROJECTION = 0x1701 +gl_S :: GLenum +gl_S = 0x2000 +gl_ALPHA_FLOAT32_APPLE :: GLenum +gl_ALPHA_FLOAT32_APPLE = 0x8816 +gl_LUMINANCE8_ALPHA8_OES :: GLenum +gl_LUMINANCE8_ALPHA8_OES = 0x8045 +gl_4_BYTES_NV :: GLenum +gl_4_BYTES_NV = 0x1409 +gl_CONST_EYE_NV :: GLenum +gl_CONST_EYE_NV = 0x86E5 +gl_MAT_SPECULAR_BIT_PGI :: GLenum +gl_MAT_SPECULAR_BIT_PGI = 0x04000000 +gl_TEXTURE1_ARB :: GLenum +gl_TEXTURE1_ARB = 0x84C1 +gl_LINE_WIDTH_GRANULARITY :: GLenum +gl_LINE_WIDTH_GRANULARITY = 0x0B23 +gl_DRAW_INDIRECT_BUFFER_BINDING :: GLenum +gl_DRAW_INDIRECT_BUFFER_BINDING = 0x8F43 +gl_BLEND_EQUATION :: GLenum +gl_BLEND_EQUATION = 0x8009 +gl_RGBA8UI_EXT :: GLenum +gl_RGBA8UI_EXT = 0x8D7C +gl_NORMALIZE :: GLenum +gl_NORMALIZE = 0x0BA1 +gl_LUMINANCE_ALPHA_FLOAT16_APPLE :: GLenum +gl_LUMINANCE_ALPHA_FLOAT16_APPLE = 0x881F +gl_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX :: GLenum +gl_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX = 0x9049 +gl_INVERSE_NV :: GLenum +gl_INVERSE_NV = 0x862B +gl_TEXTURE_SWIZZLE_A_EXT :: GLenum +gl_TEXTURE_SWIZZLE_A_EXT = 0x8E45 +gl_DEPTH24_STENCIL8_OES :: GLenum +gl_DEPTH24_STENCIL8_OES = 0x88F0 +gl_UNPACK_COMPRESSED_BLOCK_HEIGHT :: GLenum +gl_UNPACK_COMPRESSED_BLOCK_HEIGHT = 0x9128 +gl_RGBA32UI :: GLenum +gl_RGBA32UI = 0x8D70 +gl_MAP1_COLOR_4 :: GLenum +gl_MAP1_COLOR_4 = 0x0D90 +gl_MAX_ELEMENTS_VERTICES :: GLenum +gl_MAX_ELEMENTS_VERTICES = 0x80E8 +gl_CLIENT_VERTEX_ARRAY_BIT :: GLenum +gl_CLIENT_VERTEX_ARRAY_BIT = 0x00000002 +gl_TEXTURE_GREEN_TYPE :: GLenum +gl_TEXTURE_GREEN_TYPE = 0x8C11 +gl_TEXTURE_BINDING_BUFFER_ARB :: GLenum +gl_TEXTURE_BINDING_BUFFER_ARB = 0x8C2C +gl_MAX_RECTANGLE_TEXTURE_SIZE_NV :: GLenum +gl_MAX_RECTANGLE_TEXTURE_SIZE_NV = 0x84F8 +gl_INTERNALFORMAT_GREEN_TYPE :: GLenum +gl_INTERNALFORMAT_GREEN_TYPE = 0x8279 +gl_OP_ADD_EXT :: GLenum +gl_OP_ADD_EXT = 0x8787 +gl_UNSIGNED_INT_24_8 :: GLenum +gl_UNSIGNED_INT_24_8 = 0x84FA +gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS :: GLenum +gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS = 0x8A32 +gl_3D_COLOR :: GLenum +gl_3D_COLOR = 0x0602 +gl_MODULATE_COLOR_IMG :: GLenum +gl_MODULATE_COLOR_IMG = 0x8C04 +gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB = 0x8518 +gl_TEXTURE_CLIPMAP_FRAME_SGIX :: GLenum +gl_TEXTURE_CLIPMAP_FRAME_SGIX = 0x8172 +gl_NORMAL_ARRAY_STRIDE_EXT :: GLenum +gl_NORMAL_ARRAY_STRIDE_EXT = 0x807F +gl_R16 :: GLenum +gl_R16 = 0x822A +gl_PIXEL_PACK_BUFFER :: GLenum +gl_PIXEL_PACK_BUFFER = 0x88EB +gl_SOFTLIGHT_KHR :: GLenum +gl_SOFTLIGHT_KHR = 0x929C +gl_POST_CONVOLUTION_BLUE_SCALE :: GLenum +gl_POST_CONVOLUTION_BLUE_SCALE = 0x801E +gl_INTERLEAVED_ATTRIBS_NV :: GLenum +gl_INTERLEAVED_ATTRIBS_NV = 0x8C8C +gl_COLOR_ATTACHMENT8 :: GLenum +gl_COLOR_ATTACHMENT8 = 0x8CE8 +gl_DEBUG_TYPE_PUSH_GROUP_KHR :: GLenum +gl_DEBUG_TYPE_PUSH_GROUP_KHR = 0x8269 +gl_PERFQUERY_COUNTER_DATA_UINT64_INTEL :: GLenum +gl_PERFQUERY_COUNTER_DATA_UINT64_INTEL = 0x94F9 +gl_MOV_ATI :: GLenum +gl_MOV_ATI = 0x8961 +gl_PROGRAM_SEPARABLE :: GLenum +gl_PROGRAM_SEPARABLE = 0x8258 +gl_REG_20_ATI :: GLenum +gl_REG_20_ATI = 0x8935 +gl_DOUBLE_VEC3 :: GLenum +gl_DOUBLE_VEC3 = 0x8FFD +gl_8X_BIT_ATI :: GLenum +gl_8X_BIT_ATI = 0x00000004 +gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY :: GLenum +gl_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = 0x910C +gl_MATRIX26_ARB :: GLenum +gl_MATRIX26_ARB = 0x88DA +gl_PROXY_TEXTURE_RECTANGLE_ARB :: GLenum +gl_PROXY_TEXTURE_RECTANGLE_ARB = 0x84F7 +gl_TRANSFORM_HINT_APPLE :: GLenum +gl_TRANSFORM_HINT_APPLE = 0x85B1 +gl_UNPACK_ROW_BYTES_APPLE :: GLenum +gl_UNPACK_ROW_BYTES_APPLE = 0x8A16 +gl_POST_COLOR_MATRIX_ALPHA_SCALE_SGI :: GLenum +gl_POST_COLOR_MATRIX_ALPHA_SCALE_SGI = 0x80B7 +gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB :: GLenum +gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_ARB = 0x8E5F +gl_ONE_MINUS_CONSTANT_COLOR_EXT :: GLenum +gl_ONE_MINUS_CONSTANT_COLOR_EXT = 0x8002 +gl_TEXTURE_BINDING_CUBE_MAP_OES :: GLenum +gl_TEXTURE_BINDING_CUBE_MAP_OES = 0x8514 +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT :: GLenum +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT = 0x8C4E +gl_VERTEX_ARRAY_STORAGE_HINT_APPLE :: GLenum +gl_VERTEX_ARRAY_STORAGE_HINT_APPLE = 0x851F +gl_VERTEX_BINDING_BUFFER :: GLenum +gl_VERTEX_BINDING_BUFFER = 0x8F4F +gl_FRAGMENT_LIGHT0_SGIX :: GLenum +gl_FRAGMENT_LIGHT0_SGIX = 0x840C +gl_GLYPH_HORIZONTAL_BEARING_X_BIT_NV :: GLenum +gl_GLYPH_HORIZONTAL_BEARING_X_BIT_NV = 0x04 +gl_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT :: GLenum +gl_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT = 0x8DBE +gl_SRC2_RGB :: GLenum +gl_SRC2_RGB = 0x8582 +gl_NUM_COMPRESSED_TEXTURE_FORMATS :: GLenum +gl_NUM_COMPRESSED_TEXTURE_FORMATS = 0x86A2 +gl_OUTPUT_TEXTURE_COORD2_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD2_EXT = 0x879F +gl_DEPTH_TEXTURE_MODE :: GLenum +gl_DEPTH_TEXTURE_MODE = 0x884B +gl_SAMPLE_PATTERN_EXT :: GLenum +gl_SAMPLE_PATTERN_EXT = 0x80AC +gl_ELEMENT_ARRAY_APPLE :: GLenum +gl_ELEMENT_ARRAY_APPLE = 0x8A0C +gl_MAX_FOG_FUNC_POINTS_SGIS :: GLenum +gl_MAX_FOG_FUNC_POINTS_SGIS = 0x812C +gl_TEXTURE_APPLICATION_MODE_EXT :: GLenum +gl_TEXTURE_APPLICATION_MODE_EXT = 0x834F +gl_COLOR_ARRAY_SIZE_EXT :: GLenum +gl_COLOR_ARRAY_SIZE_EXT = 0x8081 +gl_VERTEX_SOURCE_ATI :: GLenum +gl_VERTEX_SOURCE_ATI = 0x8774 +gl_MAP2_VERTEX_ATTRIB3_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB3_4_NV = 0x8673 +gl_LIGHTEN_KHR :: GLenum +gl_LIGHTEN_KHR = 0x9298 +gl_INT_SAMPLER_1D_ARRAY :: GLenum +gl_INT_SAMPLER_1D_ARRAY = 0x8DCE +gl_UNSIGNED_INT_10F_11F_11F_REV_EXT :: GLenum +gl_UNSIGNED_INT_10F_11F_11F_REV_EXT = 0x8C3B +gl_LUMINANCE8 :: GLenum +gl_LUMINANCE8 = 0x8040 +gl_ACCUM_ALPHA_BITS :: GLenum +gl_ACCUM_ALPHA_BITS = 0x0D5B +gl_MINMAX_FORMAT :: GLenum +gl_MINMAX_FORMAT = 0x802F +gl_NOOP :: GLenum +gl_NOOP = 0x1505 +gl_READ_FRAMEBUFFER_EXT :: GLenum +gl_READ_FRAMEBUFFER_EXT = 0x8CA8 +gl_SHADER :: GLenum +gl_SHADER = 0x82E1 +gl_UNSIGNED_INT_10_10_10_2_OES :: GLenum +gl_UNSIGNED_INT_10_10_10_2_OES = 0x8DF6 +gl_TEXTURE_COMPRESSED_BLOCK_WIDTH :: GLenum +gl_TEXTURE_COMPRESSED_BLOCK_WIDTH = 0x82B1 +gl_DEBUG_OUTPUT_KHR :: GLenum +gl_DEBUG_OUTPUT_KHR = 0x92E0 +gl_SOURCE0_ALPHA_ARB :: GLenum +gl_SOURCE0_ALPHA_ARB = 0x8588 +gl_SAMPLER_1D_ARRAY_EXT :: GLenum +gl_SAMPLER_1D_ARRAY_EXT = 0x8DC0 +gl_T2F_V3F :: GLenum +gl_T2F_V3F = 0x2A27 +gl_SAMPLE_MASK_SGIS :: GLenum +gl_SAMPLE_MASK_SGIS = 0x80A0 +gl_CIRCULAR_TANGENT_ARC_TO_NV :: GLenum +gl_CIRCULAR_TANGENT_ARC_TO_NV = 0xFC +gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS :: GLenum +gl_MAX_TESS_CONTROL_OUTPUT_COMPONENTS = 0x8E83 +gl_MAX_DEBUG_LOGGED_MESSAGES :: GLenum +gl_MAX_DEBUG_LOGGED_MESSAGES = 0x9144 +gl_SOURCE1_ALPHA :: GLenum +gl_SOURCE1_ALPHA = 0x8589 +gl_RGB_422_APPLE :: GLenum +gl_RGB_422_APPLE = 0x8A1F +gl_COLOR_TABLE :: GLenum +gl_COLOR_TABLE = 0x80D0 +gl_MAP1_TEXTURE_COORD_3 :: GLenum +gl_MAP1_TEXTURE_COORD_3 = 0x0D95 +gl_DEBUG_SEVERITY_HIGH_AMD :: GLenum +gl_DEBUG_SEVERITY_HIGH_AMD = 0x9146 +gl_UNSIGNED_INT :: GLenum +gl_UNSIGNED_INT = 0x1405 +gl_VERTEX_PROGRAM_CALLBACK_MESA :: GLenum +gl_VERTEX_PROGRAM_CALLBACK_MESA = 0x8BB5 +gl_BLOCK_INDEX :: GLenum +gl_BLOCK_INDEX = 0x92FD +gl_FLOAT :: GLenum +gl_FLOAT = 0x1406 +gl_TRACE_PIXELS_BIT_MESA :: GLenum +gl_TRACE_PIXELS_BIT_MESA = 0x0010 +gl_BACK :: GLenum +gl_BACK = 0x0405 +gl_PATH_JOIN_STYLE_NV :: GLenum +gl_PATH_JOIN_STYLE_NV = 0x9079 +gl_LUMINANCE_ALPHA16I_EXT :: GLenum +gl_LUMINANCE_ALPHA16I_EXT = 0x8D8D +gl_FLOAT_MAT2 :: GLenum +gl_FLOAT_MAT2 = 0x8B5A +gl_SIGNED_IDENTITY_NV :: GLenum +gl_SIGNED_IDENTITY_NV = 0x853C +gl_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA :: GLenum +gl_FRAGMENT_PROGRAM_CALLBACK_DATA_MESA = 0x8BB3 +gl_DEPTH_PASS_INSTRUMENT_MAX_SGIX :: GLenum +gl_DEPTH_PASS_INSTRUMENT_MAX_SGIX = 0x8312 +gl_CLIP_DEPTH_MODE :: GLenum +gl_CLIP_DEPTH_MODE = 0x935D +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_SAMPLES_EXT = 0x8D6C +gl_CULL_FACE :: GLenum +gl_CULL_FACE = 0x0B44 +gl_DETAIL_TEXTURE_LEVEL_SGIS :: GLenum +gl_DETAIL_TEXTURE_LEVEL_SGIS = 0x809A +gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB :: GLenum +gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH_ARB = 0x8243 +gl_PACK_SKIP_ROWS :: GLenum +gl_PACK_SKIP_ROWS = 0x0D03 +gl_COEFF :: GLenum +gl_COEFF = 0x0A00 +gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT :: GLenum +gl_MAX_COMBINED_TESS_CONTROL_UNIFORM_COMPONENTS_EXT = 0x8E1E +gl_NUM_INSTRUCTIONS_PER_PASS_ATI :: GLenum +gl_NUM_INSTRUCTIONS_PER_PASS_ATI = 0x8971 +gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB :: GLenum +gl_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS_ARB = 0x8DE1 +gl_RGBA8 :: GLenum +gl_RGBA8 = 0x8058 +gl_TESS_GEN_VERTEX_ORDER :: GLenum +gl_TESS_GEN_VERTEX_ORDER = 0x8E78 +gl_TEXTURE_CUBE_MAP :: GLenum +gl_TEXTURE_CUBE_MAP = 0x8513 +gl_VERTEX_PRECLIP_HINT_SGIX :: GLenum +gl_VERTEX_PRECLIP_HINT_SGIX = 0x83EF +gl_NUM_SHADING_LANGUAGE_VERSIONS :: GLenum +gl_NUM_SHADING_LANGUAGE_VERSIONS = 0x82E9 +gl_OUTPUT_TEXTURE_COORD9_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD9_EXT = 0x87A6 +gl_MAX_PROGRAM_GENERIC_RESULTS_NV :: GLenum +gl_MAX_PROGRAM_GENERIC_RESULTS_NV = 0x8DA6 +gl_COLOR_ATTACHMENT7_NV :: GLenum +gl_COLOR_ATTACHMENT7_NV = 0x8CE7 +gl_OUT_OF_MEMORY :: GLenum +gl_OUT_OF_MEMORY = 0x0505 +gl_TEXTURE_COORD_ARRAY_POINTER_EXT :: GLenum +gl_TEXTURE_COORD_ARRAY_POINTER_EXT = 0x8092 +gl_FLOAT_MAT2_ARB :: GLenum +gl_FLOAT_MAT2_ARB = 0x8B5A +gl_COMBINER_AB_DOT_PRODUCT_NV :: GLenum +gl_COMBINER_AB_DOT_PRODUCT_NV = 0x8545 +gl_INDEX_ARRAY_POINTER_EXT :: GLenum +gl_INDEX_ARRAY_POINTER_EXT = 0x8091 +gl_WRITE_PIXEL_DATA_RANGE_POINTER_NV :: GLenum +gl_WRITE_PIXEL_DATA_RANGE_POINTER_NV = 0x887C +gl_3D :: GLenum +gl_3D = 0x0601 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5x5_OES = 0x93E7 +gl_UPPER_LEFT :: GLenum +gl_UPPER_LEFT = 0x8CA2 +gl_IMAGE_1D_ARRAY_EXT :: GLenum +gl_IMAGE_1D_ARRAY_EXT = 0x9052 +gl_GREEN :: GLenum +gl_GREEN = 0x1904 +gl_RGB12 :: GLenum +gl_RGB12 = 0x8053 +gl_GEOMETRY_DEFORMATION_BIT_SGIX :: GLenum +gl_GEOMETRY_DEFORMATION_BIT_SGIX = 0x00000002 +gl_LUMINANCE_ALPHA_FLOAT32_ATI :: GLenum +gl_LUMINANCE_ALPHA_FLOAT32_ATI = 0x8819 +gl_INT_SAMPLER_CUBE_MAP_ARRAY :: GLenum +gl_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900E +gl_EVAL_TRIANGULAR_2D_NV :: GLenum +gl_EVAL_TRIANGULAR_2D_NV = 0x86C1 +gl_QUERY_BY_REGION_WAIT_INVERTED :: GLenum +gl_QUERY_BY_REGION_WAIT_INVERTED = 0x8E19 +gl_CONTEXT_ROBUST_ACCESS_KHR :: GLenum +gl_CONTEXT_ROBUST_ACCESS_KHR = 0x90F3 +gl_STREAM_READ_ARB :: GLenum +gl_STREAM_READ_ARB = 0x88E1 +gl_INT_IMAGE_1D_ARRAY_EXT :: GLenum +gl_INT_IMAGE_1D_ARRAY_EXT = 0x905D +gl_QUERY_NO_WAIT_INVERTED :: GLenum +gl_QUERY_NO_WAIT_INVERTED = 0x8E18 +gl_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT :: GLenum +gl_SHADER_STORAGE_BUFFER_OFFSET_ALIGNMENT = 0x90DF +gl_COLOR_ATTACHMENT4_EXT :: GLenum +gl_COLOR_ATTACHMENT4_EXT = 0x8CE4 +gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR :: GLenum +gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR = 0x824E +gl_LOSE_CONTEXT_ON_RESET :: GLenum +gl_LOSE_CONTEXT_ON_RESET = 0x8252 +gl_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM :: GLenum +gl_TEXTURE_COORD_ARRAY_LIST_STRIDE_IBM = 103084 +gl_REPLACEMENT_CODE_SUN :: GLenum +gl_REPLACEMENT_CODE_SUN = 0x81D8 +gl_422_REV_EXT :: GLenum +gl_422_REV_EXT = 0x80CD +gl_COMPILE_STATUS :: GLenum +gl_COMPILE_STATUS = 0x8B81 +gl_VERTEX_ATTRIB_MAP1_COEFF_APPLE :: GLenum +gl_VERTEX_ATTRIB_MAP1_COEFF_APPLE = 0x8A03 +gl_TRANSPOSE_COLOR_MATRIX :: GLenum +gl_TRANSPOSE_COLOR_MATRIX = 0x84E6 +gl_COLOR_TABLE_FORMAT :: GLenum +gl_COLOR_TABLE_FORMAT = 0x80D8 +gl_VERSION_ES_CM_1_1 :: GLenum +gl_VERSION_ES_CM_1_1 = 1 +gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE = 0x8E24 +gl_BUFFER_STORAGE_FLAGS :: GLenum +gl_BUFFER_STORAGE_FLAGS = 0x8220 +gl_UNSIGNED_NORMALIZED_EXT :: GLenum +gl_UNSIGNED_NORMALIZED_EXT = 0x8C17 +gl_LIGHT_MODEL_SPECULAR_VECTOR_APPLE :: GLenum +gl_LIGHT_MODEL_SPECULAR_VECTOR_APPLE = 0x85B0 +gl_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT :: GLenum +gl_CONTEXT_FLAG_FORWARD_COMPATIBLE_BIT = 0x00000001 +gl_3_BYTES :: GLenum +gl_3_BYTES = 0x1408 +gl_CND0_ATI :: GLenum +gl_CND0_ATI = 0x896B +gl_TEXTURE_MAX_LEVEL_APPLE :: GLenum +gl_TEXTURE_MAX_LEVEL_APPLE = 0x813D +gl_POINT :: GLenum +gl_POINT = 0x1B00 +gl_MODELVIEW11_ARB :: GLenum +gl_MODELVIEW11_ARB = 0x872B +gl_RED_BITS :: GLenum +gl_RED_BITS = 0x0D52 +gl_PIXEL_TILE_GRID_WIDTH_SGIX :: GLenum +gl_PIXEL_TILE_GRID_WIDTH_SGIX = 0x8142 +gl_DRAW_BUFFER7_NV :: GLenum +gl_DRAW_BUFFER7_NV = 0x882C +gl_OP_SET_LT_EXT :: GLenum +gl_OP_SET_LT_EXT = 0x878D +gl_TEXTURE24_ARB :: GLenum +gl_TEXTURE24_ARB = 0x84D8 +gl_TESS_GEN_POINT_MODE :: GLenum +gl_TESS_GEN_POINT_MODE = 0x8E79 +gl_INTERNALFORMAT_PREFERRED :: GLenum +gl_INTERNALFORMAT_PREFERRED = 0x8270 +gl_VERTEX_SHADER_VARIANTS_EXT :: GLenum +gl_VERTEX_SHADER_VARIANTS_EXT = 0x87D0 +gl_COMBINER_CD_OUTPUT_NV :: GLenum +gl_COMBINER_CD_OUTPUT_NV = 0x854B +gl_TRANSPOSE_CURRENT_MATRIX_ARB :: GLenum +gl_TRANSPOSE_CURRENT_MATRIX_ARB = 0x88B7 +gl_MAX_ARRAY_TEXTURE_LAYERS_EXT :: GLenum +gl_MAX_ARRAY_TEXTURE_LAYERS_EXT = 0x88FF +gl_UNSIGNED_SHORT_8_8_MESA :: GLenum +gl_UNSIGNED_SHORT_8_8_MESA = 0x85BA +gl_BLEND_ADVANCED_COHERENT_NV :: GLenum +gl_BLEND_ADVANCED_COHERENT_NV = 0x9285 +gl_VERTEX_ARRAY_EXT :: GLenum +gl_VERTEX_ARRAY_EXT = 0x8074 +gl_BOOL_VEC4_ARB :: GLenum +gl_BOOL_VEC4_ARB = 0x8B59 +gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV :: GLenum +gl_OFFSET_PROJECTIVE_TEXTURE_RECTANGLE_SCALE_NV = 0x8853 +gl_UNSIGNED_SHORT_5_5_5_1 :: GLenum +gl_UNSIGNED_SHORT_5_5_5_1 = 0x8034 +gl_SHADE_MODEL :: GLenum +gl_SHADE_MODEL = 0x0B54 +gl_MIRROR_CLAMP_TO_EDGE :: GLenum +gl_MIRROR_CLAMP_TO_EDGE = 0x8743 +gl_RGB5_EXT :: GLenum +gl_RGB5_EXT = 0x8050 +gl_TEXTURE_GEN_S :: GLenum +gl_TEXTURE_GEN_S = 0x0C60 +gl_TEXTURE_COMPRESSED :: GLenum +gl_TEXTURE_COMPRESSED = 0x86A1 +gl_FRAMEBUFFER_BLEND :: GLenum +gl_FRAMEBUFFER_BLEND = 0x828B +gl_REPLACE_VALUE_AMD :: GLenum +gl_REPLACE_VALUE_AMD = 0x874B +gl_YCRCB_SGIX :: GLenum +gl_YCRCB_SGIX = 0x8318 +gl_UNIFORM_BLOCK_INDEX :: GLenum +gl_UNIFORM_BLOCK_INDEX = 0x8A3A +gl_TEXTURE_TOO_LARGE_EXT :: GLenum +gl_TEXTURE_TOO_LARGE_EXT = 0x8065 +gl_MIRRORED_REPEAT_ARB :: GLenum +gl_MIRRORED_REPEAT_ARB = 0x8370 +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER :: GLenum +gl_ATOMIC_COUNTER_BUFFER_REFERENCED_BY_FRAGMENT_SHADER = 0x92CB +gl_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB :: GLenum +gl_PROXY_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x900B +gl_MAX_SAMPLES :: GLenum +gl_MAX_SAMPLES = 0x8D57 +gl_ATTENUATION_EXT :: GLenum +gl_ATTENUATION_EXT = 0x834D +gl_MIRROR_CLAMP_EXT :: GLenum +gl_MIRROR_CLAMP_EXT = 0x8742 +gl_DEBUG_LOGGED_MESSAGES :: GLenum +gl_DEBUG_LOGGED_MESSAGES = 0x9145 +gl_DOT3_ATI :: GLenum +gl_DOT3_ATI = 0x8966 +gl_EMBOSS_CONSTANT_NV :: GLenum +gl_EMBOSS_CONSTANT_NV = 0x855E +gl_OUTPUT_TEXTURE_COORD11_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD11_EXT = 0x87A8 +gl_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL :: GLenum +gl_TEXTURE_COORD_ARRAY_PARALLEL_POINTERS_INTEL = 0x83F8 +gl_INDEX :: GLenum +gl_INDEX = 0x8222 +gl_CURRENT_MATRIX_ARB :: GLenum +gl_CURRENT_MATRIX_ARB = 0x8641 +gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS :: GLenum +gl_MAX_TESS_EVALUATION_ATOMIC_COUNTERS = 0x92D4 +gl_MAX_DRAW_BUFFERS_EXT :: GLenum +gl_MAX_DRAW_BUFFERS_EXT = 0x8824 +gl_ADD_BLEND_IMG :: GLenum +gl_ADD_BLEND_IMG = 0x8C09 +gl_CLIP_FAR_HINT_PGI :: GLenum +gl_CLIP_FAR_HINT_PGI = 0x1A221 +gl_POST_CONVOLUTION_COLOR_TABLE :: GLenum +gl_POST_CONVOLUTION_COLOR_TABLE = 0x80D1 +gl_RGBA4_OES :: GLenum +gl_RGBA4_OES = 0x8056 +gl_QUERY_RESULT_AVAILABLE_ARB :: GLenum +gl_QUERY_RESULT_AVAILABLE_ARB = 0x8867 +gl_RGB8UI :: GLenum +gl_RGB8UI = 0x8D7D +gl_DYNAMIC_READ :: GLenum +gl_DYNAMIC_READ = 0x88E9 +gl_TEXTURE_BINDING_2D_MULTISAMPLE :: GLenum +gl_TEXTURE_BINDING_2D_MULTISAMPLE = 0x9104 +gl_OBJECT_TYPE_APPLE :: GLenum +gl_OBJECT_TYPE_APPLE = 0x9112 +gl_PERCENTAGE_AMD :: GLenum +gl_PERCENTAGE_AMD = 0x8BC3 +gl_LIGHT_MODEL_LOCAL_VIEWER :: GLenum +gl_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51 +gl_SPARE0_PLUS_SECONDARY_COLOR_NV :: GLenum +gl_SPARE0_PLUS_SECONDARY_COLOR_NV = 0x8532 +gl_OP_INDEX_EXT :: GLenum +gl_OP_INDEX_EXT = 0x8782 +gl_VIEW_CLASS_S3TC_DXT3_RGBA :: GLenum +gl_VIEW_CLASS_S3TC_DXT3_RGBA = 0x82CE +gl_TEXTURE_DEPTH_TYPE_ARB :: GLenum +gl_TEXTURE_DEPTH_TYPE_ARB = 0x8C16 +gl_TEXTURE_ALPHA_SIZE :: GLenum +gl_TEXTURE_ALPHA_SIZE = 0x805F +gl_YCRCB_422_SGIX :: GLenum +gl_YCRCB_422_SGIX = 0x81BB +gl_INDEX_ARRAY_LENGTH_NV :: GLenum +gl_INDEX_ARRAY_LENGTH_NV = 0x8F2E +gl_TRANSPOSE_AFFINE_3D_NV :: GLenum +gl_TRANSPOSE_AFFINE_3D_NV = 0x9098 +gl_MATRIX17_ARB :: GLenum +gl_MATRIX17_ARB = 0x88D1 +gl_SRGB_ALPHA :: GLenum +gl_SRGB_ALPHA = 0x8C42 +gl_MAP_TESSELLATION_NV :: GLenum +gl_MAP_TESSELLATION_NV = 0x86C2 +gl_PACK_SKIP_VOLUMES_SGIS :: GLenum +gl_PACK_SKIP_VOLUMES_SGIS = 0x8130 +gl_COLOR_BUFFER_BIT :: GLenum +gl_COLOR_BUFFER_BIT = 0x00004000 +gl_REG_6_ATI :: GLenum +gl_REG_6_ATI = 0x8927 +gl_ATOMIC_COUNTER_BUFFER_BINDING :: GLenum +gl_ATOMIC_COUNTER_BUFFER_BINDING = 0x92C1 +gl_POST_CONVOLUTION_ALPHA_BIAS :: GLenum +gl_POST_CONVOLUTION_ALPHA_BIAS = 0x8023 +gl_HARDLIGHT_NV :: GLenum +gl_HARDLIGHT_NV = 0x929B +gl_INTENSITY16_SNORM :: GLenum +gl_INTENSITY16_SNORM = 0x901B +gl_TEXCOORD1_BIT_PGI :: GLenum +gl_TEXCOORD1_BIT_PGI = 0x10000000 +gl_DEBUG_CALLBACK_FUNCTION :: GLenum +gl_DEBUG_CALLBACK_FUNCTION = 0x8244 +gl_TEXTURE8_ARB :: GLenum +gl_TEXTURE8_ARB = 0x84C8 +gl_DOUBLE_VEC2_EXT :: GLenum +gl_DOUBLE_VEC2_EXT = 0x8FFC +gl_TRIANGLES_ADJACENCY :: GLenum +gl_TRIANGLES_ADJACENCY = 0x000C +gl_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER :: GLenum +gl_UNIFORM_BLOCK_REFERENCED_BY_VERTEX_SHADER = 0x8A44 +gl_R16F :: GLenum +gl_R16F = 0x822D +gl_OUTPUT_TEXTURE_COORD19_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD19_EXT = 0x87B0 +gl_QUAD_LUMINANCE4_SGIS :: GLenum +gl_QUAD_LUMINANCE4_SGIS = 0x8120 +gl_SAMPLER_OBJECT_AMD :: GLenum +gl_SAMPLER_OBJECT_AMD = 0x9155 +gl_COMPRESSED_RGBA_S3TC_DXT3_ANGLE :: GLenum +gl_COMPRESSED_RGBA_S3TC_DXT3_ANGLE = 0x83F2 +gl_UNSIGNED_INT_IMAGE_2D :: GLenum +gl_UNSIGNED_INT_IMAGE_2D = 0x9063 +gl_ALPHA_TEST :: GLenum +gl_ALPHA_TEST = 0x0BC0 +gl_CONVOLUTION_WIDTH :: GLenum +gl_CONVOLUTION_WIDTH = 0x8018 +gl_SLUMINANCE_NV :: GLenum +gl_SLUMINANCE_NV = 0x8C46 +gl_FRAMEBUFFER_UNDEFINED_OES :: GLenum +gl_FRAMEBUFFER_UNDEFINED_OES = 0x8219 +gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_PAUSED = 0x8E23 +gl_HALF_FLOAT_OES :: GLenum +gl_HALF_FLOAT_OES = 0x8D61 +gl_CONVOLUTION_FORMAT_EXT :: GLenum +gl_CONVOLUTION_FORMAT_EXT = 0x8017 +gl_FALSE :: GLenum +gl_FALSE = 0 +gl_ADD_ATI :: GLenum +gl_ADD_ATI = 0x8963 +gl_STENCIL_BACK_FAIL :: GLenum +gl_STENCIL_BACK_FAIL = 0x8801 +gl_DOUBLE_VEC4 :: GLenum +gl_DOUBLE_VEC4 = 0x8FFE +gl_STANDARD_FONT_NAME_NV :: GLenum +gl_STANDARD_FONT_NAME_NV = 0x9072 +gl_ALPHA4_EXT :: GLenum +gl_ALPHA4_EXT = 0x803B +gl_EXPAND_NORMAL_NV :: GLenum +gl_EXPAND_NORMAL_NV = 0x8538 +gl_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB :: GLenum +gl_OBJECT_ACTIVE_ATTRIBUTE_MAX_LENGTH_ARB = 0x8B8A +gl_TRACE_MASK_MESA :: GLenum +gl_TRACE_MASK_MESA = 0x8755 +gl_VARIABLE_B_NV :: GLenum +gl_VARIABLE_B_NV = 0x8524 +gl_RGB16_EXT :: GLenum +gl_RGB16_EXT = 0x8054 +gl_TEXTURE :: GLenum +gl_TEXTURE = 0x1702 +gl_PIXEL_UNPACK_BUFFER_BINDING_EXT :: GLenum +gl_PIXEL_UNPACK_BUFFER_BINDING_EXT = 0x88EF +gl_IMAGE_CLASS_1_X_8 :: GLenum +gl_IMAGE_CLASS_1_X_8 = 0x82C1 +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE = 0x8D56 +gl_BOOL_VEC2_ARB :: GLenum +gl_BOOL_VEC2_ARB = 0x8B57 +gl_MAP2_VERTEX_3 :: GLenum +gl_MAP2_VERTEX_3 = 0x0DB7 +gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH :: GLenum +gl_DEBUG_NEXT_LOGGED_MESSAGE_LENGTH = 0x8243 +gl_TEXTURE_WRAP_S :: GLenum +gl_TEXTURE_WRAP_S = 0x2802 +gl_TEXTURE_CUBE_MAP_NEGATIVE_X :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_X = 0x8516 +gl_TEXTURE_CUBE_MAP_ARRAY :: GLenum +gl_TEXTURE_CUBE_MAP_ARRAY = 0x9009 +gl_TEXTURE_ALPHA_TYPE :: GLenum +gl_TEXTURE_ALPHA_TYPE = 0x8C13 +gl_MAX_COLOR_ATTACHMENTS_NV :: GLenum +gl_MAX_COLOR_ATTACHMENTS_NV = 0x8CDF +gl_MAX_CUBE_MAP_TEXTURE_SIZE :: GLenum +gl_MAX_CUBE_MAP_TEXTURE_SIZE = 0x851C +gl_ANY_SAMPLES_PASSED :: GLenum +gl_ANY_SAMPLES_PASSED = 0x8C2F +gl_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_GREEN_SIZE = 0x8213 +gl_COLOR_ARRAY_STRIDE :: GLenum +gl_COLOR_ARRAY_STRIDE = 0x8083 +gl_MULTISAMPLE_BIT_EXT :: GLenum +gl_MULTISAMPLE_BIT_EXT = 0x20000000 +gl_VERTEX_ATTRIB_ARRAY_DIVISOR :: GLenum +gl_VERTEX_ATTRIB_ARRAY_DIVISOR = 0x88FE +gl_UNSIGNED_INT64_VEC3_NV :: GLenum +gl_UNSIGNED_INT64_VEC3_NV = 0x8FF6 +gl_WAIT_FAILED_APPLE :: GLenum +gl_WAIT_FAILED_APPLE = 0x911D +gl_DRAW_BUFFER5_ATI :: GLenum +gl_DRAW_BUFFER5_ATI = 0x882A +gl_MAX_CUBE_MAP_TEXTURE_SIZE_EXT :: GLenum +gl_MAX_CUBE_MAP_TEXTURE_SIZE_EXT = 0x851C +gl_ONE_MINUS_CONSTANT_ALPHA_EXT :: GLenum +gl_ONE_MINUS_CONSTANT_ALPHA_EXT = 0x8004 +gl_UNSIGNED_INT_8_24_REV_MESA :: GLenum +gl_UNSIGNED_INT_8_24_REV_MESA = 0x8752 +gl_MAX_PROGRAM_ENV_PARAMETERS_ARB :: GLenum +gl_MAX_PROGRAM_ENV_PARAMETERS_ARB = 0x88B5 +gl_MAX_VERTEX_VARYING_COMPONENTS_EXT :: GLenum +gl_MAX_VERTEX_VARYING_COMPONENTS_EXT = 0x8DDE +gl_CURRENT_TANGENT_EXT :: GLenum +gl_CURRENT_TANGENT_EXT = 0x843B +gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB :: GLenum +gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ARB = 0x88FE +gl_ALPHA16 :: GLenum +gl_ALPHA16 = 0x803E +gl_MAP1_VERTEX_4 :: GLenum +gl_MAP1_VERTEX_4 = 0x0D98 +gl_SAMPLER_CUBE_SHADOW_NV :: GLenum +gl_SAMPLER_CUBE_SHADOW_NV = 0x8DC5 +gl_SAMPLER_2D_SHADOW_ARB :: GLenum +gl_SAMPLER_2D_SHADOW_ARB = 0x8B62 +gl_PROGRAM_LENGTH_NV :: GLenum +gl_PROGRAM_LENGTH_NV = 0x8627 +gl_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM :: GLenum +gl_FOG_COORDINATE_ARRAY_LIST_STRIDE_IBM = 103086 +gl_IGNORE_BORDER_HP :: GLenum +gl_IGNORE_BORDER_HP = 0x8150 +gl_DEBUG_SOURCE_SHADER_COMPILER :: GLenum +gl_DEBUG_SOURCE_SHADER_COMPILER = 0x8248 +gl_TEXTURE_BORDER_VALUES_NV :: GLenum +gl_TEXTURE_BORDER_VALUES_NV = 0x871A +gl_FRAGMENT_SUBROUTINE :: GLenum +gl_FRAGMENT_SUBROUTINE = 0x92EC +gl_MAX_DEPTH_TEXTURE_SAMPLES :: GLenum +gl_MAX_DEPTH_TEXTURE_SAMPLES = 0x910F +gl_VERTEX_ATTRIB_ARRAY_POINTER :: GLenum +gl_VERTEX_ATTRIB_ARRAY_POINTER = 0x8645 +gl_COLOR_ATTACHMENT7 :: GLenum +gl_COLOR_ATTACHMENT7 = 0x8CE7 +gl_LAST_VERTEX_CONVENTION_EXT :: GLenum +gl_LAST_VERTEX_CONVENTION_EXT = 0x8E4E +gl_TEXTURE_LO_SIZE_NV :: GLenum +gl_TEXTURE_LO_SIZE_NV = 0x871C +gl_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER :: GLenum +gl_UNIFORM_BLOCK_REFERENCED_BY_FRAGMENT_SHADER = 0x8A46 +gl_COMPRESSED_RGB8_ETC2_OES :: GLenum +gl_COMPRESSED_RGB8_ETC2_OES = 0x9274 +gl_NORMAL_MAP_NV :: GLenum +gl_NORMAL_MAP_NV = 0x8511 +gl_COLOR_ARRAY_COUNT_EXT :: GLenum +gl_COLOR_ARRAY_COUNT_EXT = 0x8084 +gl_TEXTURE_COMPARE_MODE_EXT :: GLenum +gl_TEXTURE_COMPARE_MODE_EXT = 0x884C +gl_BINORMAL_ARRAY_TYPE_EXT :: GLenum +gl_BINORMAL_ARRAY_TYPE_EXT = 0x8440 +gl_OPERAND0_RGB_EXT :: GLenum +gl_OPERAND0_RGB_EXT = 0x8590 +gl_MAX_VERTEX_VARYING_COMPONENTS_ARB :: GLenum +gl_MAX_VERTEX_VARYING_COMPONENTS_ARB = 0x8DDE +gl_PIXEL_MIN_FILTER_EXT :: GLenum +gl_PIXEL_MIN_FILTER_EXT = 0x8332 +gl_ACCUM_ADJACENT_PAIRS_NV :: GLenum +gl_ACCUM_ADJACENT_PAIRS_NV = 0x90AD +gl_BLEND_DST :: GLenum +gl_BLEND_DST = 0x0BE0 +gl_W_EXT :: GLenum +gl_W_EXT = 0x87D8 +gl_RENDERBUFFER_COVERAGE_SAMPLES_NV :: GLenum +gl_RENDERBUFFER_COVERAGE_SAMPLES_NV = 0x8CAB +gl_STENCIL_FUNC :: GLenum +gl_STENCIL_FUNC = 0x0B92 +gl_MAX_VERTEX_STREAMS :: GLenum +gl_MAX_VERTEX_STREAMS = 0x8E71 +gl_GEOMETRY_INPUT_TYPE :: GLenum +gl_GEOMETRY_INPUT_TYPE = 0x8917 +gl_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV :: GLenum +gl_OFFSET_HILO_PROJECTIVE_TEXTURE_RECTANGLE_NV = 0x8857 +gl_MINMAX_SINK_EXT :: GLenum +gl_MINMAX_SINK_EXT = 0x8030 +gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_READ_BUFFER = 0x8CDC +gl_DOUBLE_MAT2x3 :: GLenum +gl_DOUBLE_MAT2x3 = 0x8F49 +gl_FRACTIONAL_EVEN_EXT :: GLenum +gl_FRACTIONAL_EVEN_EXT = 0x8E7C +gl_VERTEX_ARRAY_TYPE_EXT :: GLenum +gl_VERTEX_ARRAY_TYPE_EXT = 0x807B +gl_BINORMAL_ARRAY_POINTER_EXT :: GLenum +gl_BINORMAL_ARRAY_POINTER_EXT = 0x8443 +gl_SAMPLE_MASK_EXT :: GLenum +gl_SAMPLE_MASK_EXT = 0x80A0 +gl_TESS_CONTROL_SHADER_EXT :: GLenum +gl_TESS_CONTROL_SHADER_EXT = 0x8E88 +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_COMPONENTS_EXT = 0x8C80 +gl_TANGENT_ARRAY_STRIDE_EXT :: GLenum +gl_TANGENT_ARRAY_STRIDE_EXT = 0x843F +gl_GET_TEXTURE_IMAGE_TYPE :: GLenum +gl_GET_TEXTURE_IMAGE_TYPE = 0x8292 +gl_OFFSET :: GLenum +gl_OFFSET = 0x92FC +gl_ALL_STATIC_DATA_IBM :: GLenum +gl_ALL_STATIC_DATA_IBM = 103060 +gl_READ_PIXEL_DATA_RANGE_LENGTH_NV :: GLenum +gl_READ_PIXEL_DATA_RANGE_LENGTH_NV = 0x887B +gl_CONSTANT_COLOR :: GLenum +gl_CONSTANT_COLOR = 0x8001 +gl_UNSIGNED_SHORT_1_5_5_5_REV_EXT :: GLenum +gl_UNSIGNED_SHORT_1_5_5_5_REV_EXT = 0x8366 +gl_MATERIAL_SIDE_HINT_PGI :: GLenum +gl_MATERIAL_SIDE_HINT_PGI = 0x1A22C +gl_UNPACK_RESAMPLE_OML :: GLenum +gl_UNPACK_RESAMPLE_OML = 0x8985 +gl_SAMPLE_SHADING :: GLenum +gl_SAMPLE_SHADING = 0x8C36 +gl_OUTPUT_TEXTURE_COORD13_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD13_EXT = 0x87AA +gl_MAX_COLOR_MATRIX_STACK_DEPTH :: GLenum +gl_MAX_COLOR_MATRIX_STACK_DEPTH = 0x80B3 +gl_INT64_VEC3_NV :: GLenum +gl_INT64_VEC3_NV = 0x8FEA +gl_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV :: GLenum +gl_SHADER_GLOBAL_ACCESS_BARRIER_BIT_NV = 0x00000010 +gl_TEXTURE_STACK_DEPTH :: GLenum +gl_TEXTURE_STACK_DEPTH = 0x0BA5 +gl_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL :: GLenum +gl_PERFQUERY_GPA_EXTENDED_COUNTERS_INTEL = 0x9500 +gl_FRAMEBUFFER_UNSUPPORTED_EXT :: GLenum +gl_FRAMEBUFFER_UNSUPPORTED_EXT = 0x8CDD +gl_QUERY_TARGET :: GLenum +gl_QUERY_TARGET = 0x82EA +gl_LUMINANCE4_ALPHA4 :: GLenum +gl_LUMINANCE4_ALPHA4 = 0x8043 +gl_TRANSFORM_FEEDBACK_BARRIER_BIT :: GLenum +gl_TRANSFORM_FEEDBACK_BARRIER_BIT = 0x00000800 +gl_RGB32UI :: GLenum +gl_RGB32UI = 0x8D71 +gl_STATIC_DRAW :: GLenum +gl_STATIC_DRAW = 0x88E4 +gl_MAX_COMPUTE_UNIFORM_BLOCKS :: GLenum +gl_MAX_COMPUTE_UNIFORM_BLOCKS = 0x91BB +gl_PALETTE4_RGBA8_OES :: GLenum +gl_PALETTE4_RGBA8_OES = 0x8B91 +gl_UNPACK_PREMULTIPLY_ALPHA_WEBGL :: GLenum +gl_UNPACK_PREMULTIPLY_ALPHA_WEBGL = 0x9241 +gl_TEXTURE21 :: GLenum +gl_TEXTURE21 = 0x84D5 +gl_RGB32I :: GLenum +gl_RGB32I = 0x8D83 +gl_MAX_TEXTURE_LOD_BIAS_EXT :: GLenum +gl_MAX_TEXTURE_LOD_BIAS_EXT = 0x84FD +gl_PATH_GEN_COLOR_FORMAT_NV :: GLenum +gl_PATH_GEN_COLOR_FORMAT_NV = 0x90B2 +gl_RGB10_A2UI :: GLenum +gl_RGB10_A2UI = 0x906F +gl_GREEN_BITS :: GLenum +gl_GREEN_BITS = 0x0D53 +gl_POLYGON_MODE :: GLenum +gl_POLYGON_MODE = 0x0B40 +gl_SUCCESS_NV :: GLenum +gl_SUCCESS_NV = 0x902F +gl_RGBA12 :: GLenum +gl_RGBA12 = 0x805A +gl_PATCHES :: GLenum +gl_PATCHES = 0x000E +gl_ACCUM :: GLenum +gl_ACCUM = 0x0100 +gl_NUM_PASSES_ATI :: GLenum +gl_NUM_PASSES_ATI = 0x8970 +gl_DEBUG_TYPE_ERROR_ARB :: GLenum +gl_DEBUG_TYPE_ERROR_ARB = 0x824C +gl_TEXTURE_LIGHTING_MODE_HP :: GLenum +gl_TEXTURE_LIGHTING_MODE_HP = 0x8167 +gl_HISTOGRAM_SINK_EXT :: GLenum +gl_HISTOGRAM_SINK_EXT = 0x802D +gl_POINT_SIZE_GRANULARITY :: GLenum +gl_POINT_SIZE_GRANULARITY = 0x0B13 +gl_R32F :: GLenum +gl_R32F = 0x822E +gl_STATIC_COPY :: GLenum +gl_STATIC_COPY = 0x88E6 +gl_FOG_COORDINATE_ARRAY_TYPE_EXT :: GLenum +gl_FOG_COORDINATE_ARRAY_TYPE_EXT = 0x8454 +gl_SPARE0_NV :: GLenum +gl_SPARE0_NV = 0x852E +gl_3DC_XY_AMD :: GLenum +gl_3DC_XY_AMD = 0x87FA +gl_LUMINANCE_ALPHA32F_ARB :: GLenum +gl_LUMINANCE_ALPHA32F_ARB = 0x8819 +gl_VERTEX_ARRAY_RANGE_VALID_NV :: GLenum +gl_VERTEX_ARRAY_RANGE_VALID_NV = 0x851F +gl_DEPTH_BUFFER_BIT6_QCOM :: GLenum +gl_DEPTH_BUFFER_BIT6_QCOM = 0x00004000 +gl_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX :: GLenum +gl_FRAGMENTS_INSTRUMENT_COUNTERS_SGIX = 0x8314 +gl_LINE_WIDTH :: GLenum +gl_LINE_WIDTH = 0x0B21 +gl_FOG_OFFSET_SGIX :: GLenum +gl_FOG_OFFSET_SGIX = 0x8198 +gl_GEOMETRY_SHADER_BIT_EXT :: GLenum +gl_GEOMETRY_SHADER_BIT_EXT = 0x00000004 +gl_TEXTURE_BLUE_SIZE :: GLenum +gl_TEXTURE_BLUE_SIZE = 0x805E +gl_TEXTURE_SHADER_NV :: GLenum +gl_TEXTURE_SHADER_NV = 0x86DE +gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV :: GLenum +gl_MAX_PROGRAM_TEXTURE_GATHER_OFFSET_NV = 0x8E5F +gl_FRAMEZOOM_SGIX :: GLenum +gl_FRAMEZOOM_SGIX = 0x818B +gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT :: GLenum +gl_MAX_TESS_EVALUATION_INPUT_COMPONENTS_EXT = 0x886D +gl_DEPTH_RENDERABLE :: GLenum +gl_DEPTH_RENDERABLE = 0x8287 +gl_MAX_TEXTURE_BUFFER_SIZE :: GLenum +gl_MAX_TEXTURE_BUFFER_SIZE = 0x8C2B +gl_COLOR_ALPHA_PAIRING_ATI :: GLenum +gl_COLOR_ALPHA_PAIRING_ATI = 0x8975 +gl_PACK_REVERSE_ROW_ORDER_ANGLE :: GLenum +gl_PACK_REVERSE_ROW_ORDER_ANGLE = 0x93A4 +gl_VERTEX_ATTRIB_ARRAY_NORMALIZED :: GLenum +gl_VERTEX_ATTRIB_ARRAY_NORMALIZED = 0x886A +gl_OP_MADD_EXT :: GLenum +gl_OP_MADD_EXT = 0x8788 +gl_TEXTURE7 :: GLenum +gl_TEXTURE7 = 0x84C7 +gl_RGB32I_EXT :: GLenum +gl_RGB32I_EXT = 0x8D83 +gl_RED_BIAS :: GLenum +gl_RED_BIAS = 0x0D15 +gl_FLOAT_VEC2 :: GLenum +gl_FLOAT_VEC2 = 0x8B50 +gl_HALF_APPLE :: GLenum +gl_HALF_APPLE = 0x140B +gl_SGX_BINARY_IMG :: GLenum +gl_SGX_BINARY_IMG = 0x8C0A +gl_CON_28_ATI :: GLenum +gl_CON_28_ATI = 0x895D +gl_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP :: GLenum +gl_PROXY_POST_IMAGE_TRANSFORM_COLOR_TABLE_HP = 0x8163 +gl_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV :: GLenum +gl_VERTEX_ARRAY_RANGE_WITHOUT_FLUSH_NV = 0x8533 +gl_MAP2_VERTEX_ATTRIB2_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB2_4_NV = 0x8672 +gl_TRANSFORM_BIT :: GLenum +gl_TRANSFORM_BIT = 0x00001000 +gl_R8 :: GLenum +gl_R8 = 0x8229 +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_NV = 0x8D56 +gl_T :: GLenum +gl_T = 0x2001 +gl_TEXTURE_ENV_MODE :: GLenum +gl_TEXTURE_ENV_MODE = 0x2200 +gl_HIGH_INT :: GLenum +gl_HIGH_INT = 0x8DF5 +gl_TEXTURE_UNSIGNED_REMAP_MODE_NV :: GLenum +gl_TEXTURE_UNSIGNED_REMAP_MODE_NV = 0x888F +gl_MAX_PROGRAM_LOOP_COUNT_NV :: GLenum +gl_MAX_PROGRAM_LOOP_COUNT_NV = 0x88F8 +gl_PERFQUERY_WAIT_INTEL :: GLenum +gl_PERFQUERY_WAIT_INTEL = 0x83FB +gl_INVALID_FRAMEBUFFER_OPERATION_EXT :: GLenum +gl_INVALID_FRAMEBUFFER_OPERATION_EXT = 0x0506 +gl_TEXTURE_2D_BINDING_EXT :: GLenum +gl_TEXTURE_2D_BINDING_EXT = 0x8069 +gl_TEXTURE_NUM_LEVELS_QCOM :: GLenum +gl_TEXTURE_NUM_LEVELS_QCOM = 0x8BD9 +gl_TEXTURE_BUFFER_ARB :: GLenum +gl_TEXTURE_BUFFER_ARB = 0x8C2A +gl_TRUE :: GLenum +gl_TRUE = 1 +gl_MAX_LAYERS :: GLenum +gl_MAX_LAYERS = 0x8281 +gl_MAX_TEXTURE_UNITS_ARB :: GLenum +gl_MAX_TEXTURE_UNITS_ARB = 0x84E2 +gl_MAP2_NORMAL :: GLenum +gl_MAP2_NORMAL = 0x0DB2 +gl_DUAL_ALPHA16_SGIS :: GLenum +gl_DUAL_ALPHA16_SGIS = 0x8113 +gl_PROGRAM_OUTPUT :: GLenum +gl_PROGRAM_OUTPUT = 0x92E4 +gl_OUTPUT_TEXTURE_COORD22_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD22_EXT = 0x87B3 +gl_SAMPLER_1D_ARB :: GLenum +gl_SAMPLER_1D_ARB = 0x8B5D +gl_POST_CONVOLUTION_GREEN_BIAS :: GLenum +gl_POST_CONVOLUTION_GREEN_BIAS = 0x8021 +gl_INT_IMAGE_CUBE :: GLenum +gl_INT_IMAGE_CUBE = 0x905B +gl_CURRENT_VERTEX_WEIGHT_EXT :: GLenum +gl_CURRENT_VERTEX_WEIGHT_EXT = 0x850B +gl_SIGNED_LUMINANCE8_NV :: GLenum +gl_SIGNED_LUMINANCE8_NV = 0x8702 +gl_TEXTURE_VIEW_NUM_LAYERS_EXT :: GLenum +gl_TEXTURE_VIEW_NUM_LAYERS_EXT = 0x82DE +gl_RG16F :: GLenum +gl_RG16F = 0x822F +gl_PROGRAM_POINT_SIZE_EXT :: GLenum +gl_PROGRAM_POINT_SIZE_EXT = 0x8642 +gl_FILE_NAME_NV :: GLenum +gl_FILE_NAME_NV = 0x9074 +gl_INT_IMAGE_BUFFER_EXT :: GLenum +gl_INT_IMAGE_BUFFER_EXT = 0x905C +gl_TEXTURE_UPDATE_BARRIER_BIT :: GLenum +gl_TEXTURE_UPDATE_BARRIER_BIT = 0x00000100 +gl_HARDMIX_NV :: GLenum +gl_HARDMIX_NV = 0x92A9 +gl_FLOAT_MAT3x4 :: GLenum +gl_FLOAT_MAT3x4 = 0x8B68 +gl_TEXTURE_INTERNAL_FORMAT_QCOM :: GLenum +gl_TEXTURE_INTERNAL_FORMAT_QCOM = 0x8BD5 +gl_INTERNALFORMAT_BLUE_SIZE :: GLenum +gl_INTERNALFORMAT_BLUE_SIZE = 0x8273 +gl_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV :: GLenum +gl_MAX_PROGRAM_TOTAL_OUTPUT_COMPONENTS_NV = 0x8C28 +gl_HSL_COLOR_NV :: GLenum +gl_HSL_COLOR_NV = 0x92AF +gl_CONDITION_SATISFIED :: GLenum +gl_CONDITION_SATISFIED = 0x911C +gl_UNIFORM_BUFFER_LENGTH_NV :: GLenum +gl_UNIFORM_BUFFER_LENGTH_NV = 0x9370 +gl_ALPHA8UI_EXT :: GLenum +gl_ALPHA8UI_EXT = 0x8D7E +gl_REG_23_ATI :: GLenum +gl_REG_23_ATI = 0x8938 +gl_UNSIGNED_SHORT_5_6_5_EXT :: GLenum +gl_UNSIGNED_SHORT_5_6_5_EXT = 0x8363 +gl_EDGE_FLAG_ARRAY_LENGTH_NV :: GLenum +gl_EDGE_FLAG_ARRAY_LENGTH_NV = 0x8F30 +gl_IMAGE_CLASS_1_X_16 :: GLenum +gl_IMAGE_CLASS_1_X_16 = 0x82BE +gl_LUMINANCE8_ALPHA8_SNORM :: GLenum +gl_LUMINANCE8_ALPHA8_SNORM = 0x9016 +gl_PATH_FILL_COVER_MODE_NV :: GLenum +gl_PATH_FILL_COVER_MODE_NV = 0x9082 +gl_LUMINANCE_ALPHA_FLOAT32_APPLE :: GLenum +gl_LUMINANCE_ALPHA_FLOAT32_APPLE = 0x8819 +gl_INTENSITY16UI_EXT :: GLenum +gl_INTENSITY16UI_EXT = 0x8D79 +gl_RENDERBUFFER_SAMPLES_APPLE :: GLenum +gl_RENDERBUFFER_SAMPLES_APPLE = 0x8CAB +gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE :: GLenum +gl_SIMULTANEOUS_TEXTURE_AND_STENCIL_WRITE = 0x82AF +gl_LUMINANCE_ALPHA32I_EXT :: GLenum +gl_LUMINANCE_ALPHA32I_EXT = 0x8D87 +gl_REGISTER_COMBINERS_NV :: GLenum +gl_REGISTER_COMBINERS_NV = 0x8522 +gl_R1UI_N3F_V3F_SUN :: GLenum +gl_R1UI_N3F_V3F_SUN = 0x85C7 +gl_FOG_COORDINATE_SOURCE :: GLenum +gl_FOG_COORDINATE_SOURCE = 0x8450 +gl_DEBUG_SEVERITY_MEDIUM_AMD :: GLenum +gl_DEBUG_SEVERITY_MEDIUM_AMD = 0x9147 +gl_MODELVIEW30_ARB :: GLenum +gl_MODELVIEW30_ARB = 0x873E +gl_COMPRESSED_RGBA_S3TC_DXT5_EXT :: GLenum +gl_COMPRESSED_RGBA_S3TC_DXT5_EXT = 0x83F3 +gl_DRAW_BUFFER0_NV :: GLenum +gl_DRAW_BUFFER0_NV = 0x8825 +gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT :: GLenum +gl_MAX_OPTIMIZED_VERTEX_SHADER_LOCAL_CONSTANTS_EXT = 0x87CC +gl_ELEMENT_ARRAY_BARRIER_BIT :: GLenum +gl_ELEMENT_ARRAY_BARRIER_BIT = 0x00000002 +gl_SHADER_PIXEL_LOCAL_STORAGE_EXT :: GLenum +gl_SHADER_PIXEL_LOCAL_STORAGE_EXT = 0x8F64 +gl_FRONT_LEFT :: GLenum +gl_FRONT_LEFT = 0x0400 +gl_UNIFORM_BUFFER_BINDING :: GLenum +gl_UNIFORM_BUFFER_BINDING = 0x8A28 +gl_SIGNED_RGBA8_NV :: GLenum +gl_SIGNED_RGBA8_NV = 0x86FC +gl_EYE_PLANE :: GLenum +gl_EYE_PLANE = 0x2502 +gl_TEXTURE_1D :: GLenum +gl_TEXTURE_1D = 0x0DE0 +gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT :: GLenum +gl_MAX_TESS_EVALUATION_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CE +gl_MALI_PROGRAM_BINARY_ARM :: GLenum +gl_MALI_PROGRAM_BINARY_ARM = 0x8F61 +gl_SKIP_COMPONENTS3_NV :: GLenum +gl_SKIP_COMPONENTS3_NV = -4 +gl_LUMINANCE_ALPHA :: GLenum +gl_LUMINANCE_ALPHA = 0x190A +gl_ACCUM_RED_BITS :: GLenum +gl_ACCUM_RED_BITS = 0x0D58 +gl_POLYGON_OFFSET_FACTOR :: GLenum +gl_POLYGON_OFFSET_FACTOR = 0x8038 +gl_SAMPLER_2D_ARRAY_SHADOW_NV :: GLenum +gl_SAMPLER_2D_ARRAY_SHADOW_NV = 0x8DC4 +gl_VARIABLE_D_NV :: GLenum +gl_VARIABLE_D_NV = 0x8526 +gl_TEXTURE_LEQUAL_R_SGIX :: GLenum +gl_TEXTURE_LEQUAL_R_SGIX = 0x819C +gl_INT :: GLenum +gl_INT = 0x1404 +gl_IMAGE_TRANSLATE_Y_HP :: GLenum +gl_IMAGE_TRANSLATE_Y_HP = 0x8158 +gl_POINT_TOKEN :: GLenum +gl_POINT_TOKEN = 0x0701 +gl_RESAMPLE_ZERO_FILL_OML :: GLenum +gl_RESAMPLE_ZERO_FILL_OML = 0x8987 +gl_DEBUG_SOURCE_THIRD_PARTY_KHR :: GLenum +gl_DEBUG_SOURCE_THIRD_PARTY_KHR = 0x8249 +gl_TEXTURE_MAG_SIZE_NV :: GLenum +gl_TEXTURE_MAG_SIZE_NV = 0x871F +gl_PER_STAGE_CONSTANTS_NV :: GLenum +gl_PER_STAGE_CONSTANTS_NV = 0x8535 +gl_VIRTUAL_PAGE_SIZE_Y_ARB :: GLenum +gl_VIRTUAL_PAGE_SIZE_Y_ARB = 0x9196 +gl_SPRITE_EYE_ALIGNED_SGIX :: GLenum +gl_SPRITE_EYE_ALIGNED_SGIX = 0x814E +gl_EVAL_VERTEX_ATTRIB14_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB14_NV = 0x86D4 +gl_TRANSFORM_FEEDBACK_VARYINGS_NV :: GLenum +gl_TRANSFORM_FEEDBACK_VARYINGS_NV = 0x8C83 +gl_RGB10 :: GLenum +gl_RGB10 = 0x8052 +gl_MAX_VIEWPORT_DIMS :: GLenum +gl_MAX_VIEWPORT_DIMS = 0x0D3A +gl_BLUE_MAX_CLAMP_INGR :: GLenum +gl_BLUE_MAX_CLAMP_INGR = 0x8566 +gl_INCR_WRAP :: GLenum +gl_INCR_WRAP = 0x8507 +gl_VIRTUAL_PAGE_SIZE_X_AMD :: GLenum +gl_VIRTUAL_PAGE_SIZE_X_AMD = 0x9195 +gl_BOOL_VEC3 :: GLenum +gl_BOOL_VEC3 = 0x8B58 +gl_CON_17_ATI :: GLenum +gl_CON_17_ATI = 0x8952 +gl_MAX_CUBE_MAP_TEXTURE_SIZE_OES :: GLenum +gl_MAX_CUBE_MAP_TEXTURE_SIZE_OES = 0x851C +gl_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT :: GLenum +gl_MAX_OPTIMIZED_VERTEX_SHADER_VARIANTS_EXT = 0x87CB +gl_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI :: GLenum +gl_MAX_PN_TRIANGLES_TESSELATION_LEVEL_ATI = 0x87F1 +gl_MINMAX :: GLenum +gl_MINMAX = 0x802E +gl_CONSTANT_BORDER_HP :: GLenum +gl_CONSTANT_BORDER_HP = 0x8151 +gl_SRGB_WRITE :: GLenum +gl_SRGB_WRITE = 0x8298 +gl_MAX_TEXTURE_BUFFER_SIZE_ARB :: GLenum +gl_MAX_TEXTURE_BUFFER_SIZE_ARB = 0x8C2B +gl_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV :: GLenum +gl_OFFSET_HILO_PROJECTIVE_TEXTURE_2D_NV = 0x8856 +gl_DECAL :: GLenum +gl_DECAL = 0x2101 +gl_REG_7_ATI :: GLenum +gl_REG_7_ATI = 0x8928 +gl_TESS_GEN_SPACING_EXT :: GLenum +gl_TESS_GEN_SPACING_EXT = 0x8E77 +gl_ELEMENT_ARRAY_LENGTH_NV :: GLenum +gl_ELEMENT_ARRAY_LENGTH_NV = 0x8F33 +gl_MATRIX31_ARB :: GLenum +gl_MATRIX31_ARB = 0x88DF +gl_TRANSFORM_FEEDBACK_VARYING :: GLenum +gl_TRANSFORM_FEEDBACK_VARYING = 0x92F4 +gl_VERTEX_ATTRIB_ARRAY_SIZE :: GLenum +gl_VERTEX_ATTRIB_ARRAY_SIZE = 0x8623 +gl_NOTEQUAL :: GLenum +gl_NOTEQUAL = 0x0205 +gl_READ_PIXELS_TYPE :: GLenum +gl_READ_PIXELS_TYPE = 0x828E +gl_MODELVIEW_STACK_DEPTH :: GLenum +gl_MODELVIEW_STACK_DEPTH = 0x0BA3 +gl_COMPRESSED_RGBA_ASTC_6x6x5_OES :: GLenum +gl_COMPRESSED_RGBA_ASTC_6x6x5_OES = 0x93C8 +gl_COMBINE_EXT :: GLenum +gl_COMBINE_EXT = 0x8570 +gl_NICEST :: GLenum +gl_NICEST = 0x1102 +gl_MODELVIEW2_ARB :: GLenum +gl_MODELVIEW2_ARB = 0x8722 +gl_UNPACK_IMAGE_HEIGHT :: GLenum +gl_UNPACK_IMAGE_HEIGHT = 0x806E +gl_TEXTURE_CUBE_MAP_ARRAY_ARB :: GLenum +gl_TEXTURE_CUBE_MAP_ARRAY_ARB = 0x9009 +gl_DRAW_BUFFER12 :: GLenum +gl_DRAW_BUFFER12 = 0x8831 +gl_MAX_FRAGMENT_INTERPOLATION_OFFSET :: GLenum +gl_MAX_FRAGMENT_INTERPOLATION_OFFSET = 0x8E5C +gl_FRAMEBUFFER_DEFAULT_HEIGHT :: GLenum +gl_FRAMEBUFFER_DEFAULT_HEIGHT = 0x9311 +gl_DT_BIAS_NV :: GLenum +gl_DT_BIAS_NV = 0x8717 +gl_DSDT_NV :: GLenum +gl_DSDT_NV = 0x86F5 +gl_IMAGE_CUBE_MAP_ARRAY :: GLenum +gl_IMAGE_CUBE_MAP_ARRAY = 0x9054 +gl_STENCIL_INDEX4 :: GLenum +gl_STENCIL_INDEX4 = 0x8D47 +gl_ROUND_NV :: GLenum +gl_ROUND_NV = 0x90A4 +gl_Y_EXT :: GLenum +gl_Y_EXT = 0x87D6 +gl_PATH_DASH_CAPS_NV :: GLenum +gl_PATH_DASH_CAPS_NV = 0x907B +gl_TEXTURE_PRIORITY :: GLenum +gl_TEXTURE_PRIORITY = 0x8066 +gl_TEXTURE_4D_BINDING_SGIS :: GLenum +gl_TEXTURE_4D_BINDING_SGIS = 0x814F +gl_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD :: GLenum +gl_DEBUG_CATEGORY_UNDEFINED_BEHAVIOR_AMD = 0x914C +gl_CULL_MODES_NV :: GLenum +gl_CULL_MODES_NV = 0x86E0 +gl_VERTEX_ATTRIB_MAP2_SIZE_APPLE :: GLenum +gl_VERTEX_ATTRIB_MAP2_SIZE_APPLE = 0x8A06 +gl_REFERENCED_BY_GEOMETRY_SHADER_EXT :: GLenum +gl_REFERENCED_BY_GEOMETRY_SHADER_EXT = 0x9309 +gl_MODELVIEW_MATRIX :: GLenum +gl_MODELVIEW_MATRIX = 0x0BA6 +gl_VIDEO_BUFFER_NV :: GLenum +gl_VIDEO_BUFFER_NV = 0x9020 +gl_TEXTURE12 :: GLenum +gl_TEXTURE12 = 0x84CC +gl_COLORBURN_NV :: GLenum +gl_COLORBURN_NV = 0x929A +gl_COLOR_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_COLOR_ARRAY_BUFFER_BINDING_ARB = 0x8898 +gl_READ_BUFFER_EXT :: GLenum +gl_READ_BUFFER_EXT = 0x0C02 +gl_RENDERBUFFER_RED_SIZE_OES :: GLenum +gl_RENDERBUFFER_RED_SIZE_OES = 0x8D50 +gl_TEXTURE_SHARED_SIZE :: GLenum +gl_TEXTURE_SHARED_SIZE = 0x8C3F +gl_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS :: GLenum +gl_PIXEL_FRAGMENT_ALPHA_SOURCE_SGIS = 0x8355 +gl_ALL_SHADER_BITS_EXT :: GLenum +gl_ALL_SHADER_BITS_EXT = 0xFFFFFFFF +gl_PERFQUERY_SINGLE_CONTEXT_INTEL :: GLenum +gl_PERFQUERY_SINGLE_CONTEXT_INTEL = 0x00000000 +gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT :: GLenum +gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS_EXT = 0x8E82 +gl_PERFMON_RESULT_AMD :: GLenum +gl_PERFMON_RESULT_AMD = 0x8BC6 +gl_GUILTY_CONTEXT_RESET :: GLenum +gl_GUILTY_CONTEXT_RESET = 0x8253 +gl_PREVIOUS :: GLenum +gl_PREVIOUS = 0x8578 +gl_UNSIGNED_INT16_VEC3_NV :: GLenum +gl_UNSIGNED_INT16_VEC3_NV = 0x8FF2 +gl_VERTEX_ATTRIB_MAP1_APPLE :: GLenum +gl_VERTEX_ATTRIB_MAP1_APPLE = 0x8A00 +gl_LIGHT3 :: GLenum +gl_LIGHT3 = 0x4003 +gl_TESS_EVALUATION_SUBROUTINE_UNIFORM :: GLenum +gl_TESS_EVALUATION_SUBROUTINE_UNIFORM = 0x92F0 +gl_DUAL_INTENSITY8_SGIS :: GLenum +gl_DUAL_INTENSITY8_SGIS = 0x8119 +gl_PARAMETER_BUFFER_BINDING_ARB :: GLenum +gl_PARAMETER_BUFFER_BINDING_ARB = 0x80EF +gl_CURRENT_SECONDARY_COLOR :: GLenum +gl_CURRENT_SECONDARY_COLOR = 0x8459 +gl_RENDERBUFFER_ALPHA_SIZE :: GLenum +gl_RENDERBUFFER_ALPHA_SIZE = 0x8D53 +gl_DUAL_INTENSITY12_SGIS :: GLenum +gl_DUAL_INTENSITY12_SGIS = 0x811A +gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING :: GLenum +gl_TEXTURE_COORD_ARRAY_BUFFER_BINDING = 0x889A +gl_OP_MAX_EXT :: GLenum +gl_OP_MAX_EXT = 0x878A +gl_EDGE_FLAG_ARRAY_EXT :: GLenum +gl_EDGE_FLAG_ARRAY_EXT = 0x8079 +gl_COLOR_TABLE_LUMINANCE_SIZE :: GLenum +gl_COLOR_TABLE_LUMINANCE_SIZE = 0x80DE +gl_FOG_COORD_ARRAY_ADDRESS_NV :: GLenum +gl_FOG_COORD_ARRAY_ADDRESS_NV = 0x8F28 +gl_COPY :: GLenum +gl_COPY = 0x1503 +gl_DRAW_BUFFER2_NV :: GLenum +gl_DRAW_BUFFER2_NV = 0x8827 +gl_SAMPLER_BINDING :: GLenum +gl_SAMPLER_BINDING = 0x8919 +gl_COPY_WRITE_BUFFER :: GLenum +gl_COPY_WRITE_BUFFER = 0x8F37 +gl_PIXEL_UNPACK_BUFFER :: GLenum +gl_PIXEL_UNPACK_BUFFER = 0x88EC +gl_VIEW_CLASS_S3TC_DXT1_RGBA :: GLenum +gl_VIEW_CLASS_S3TC_DXT1_RGBA = 0x82CD +gl_DRAW_FRAMEBUFFER_APPLE :: GLenum +gl_DRAW_FRAMEBUFFER_APPLE = 0x8CA9 +gl_PIXEL_MAP_A_TO_A_SIZE :: GLenum +gl_PIXEL_MAP_A_TO_A_SIZE = 0x0CB9 +gl_EDGE_FLAG :: GLenum +gl_EDGE_FLAG = 0x0B43 +gl_CLIP_DISTANCE2 :: GLenum +gl_CLIP_DISTANCE2 = 0x3002 +gl_TEXTURE_GEN_MODE :: GLenum +gl_TEXTURE_GEN_MODE = 0x2500 +gl_HALF_BIAS_NORMAL_NV :: GLenum +gl_HALF_BIAS_NORMAL_NV = 0x853A +gl_RESAMPLE_ZERO_FILL_SGIX :: GLenum +gl_RESAMPLE_ZERO_FILL_SGIX = 0x842F +gl_OUTPUT_TEXTURE_COORD12_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD12_EXT = 0x87A9 +gl_UNSIGNED_SHORT_8_8_REV_MESA :: GLenum +gl_UNSIGNED_SHORT_8_8_REV_MESA = 0x85BB +gl_PALETTE8_RGBA8_OES :: GLenum +gl_PALETTE8_RGBA8_OES = 0x8B96 +gl_TEXTURE_4D_SGIS :: GLenum +gl_TEXTURE_4D_SGIS = 0x8134 +gl_PIXEL_PACK_BUFFER_EXT :: GLenum +gl_PIXEL_PACK_BUFFER_EXT = 0x88EB +gl_MAP_ATTRIB_U_ORDER_NV :: GLenum +gl_MAP_ATTRIB_U_ORDER_NV = 0x86C3 +gl_FUNC_SUBTRACT :: GLenum +gl_FUNC_SUBTRACT = 0x800A +gl_PIXEL_SUBSAMPLE_4444_SGIX :: GLenum +gl_PIXEL_SUBSAMPLE_4444_SGIX = 0x85A2 +gl_TEXTURE_CUBE_MAP_NEGATIVE_Y :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_Y = 0x8518 +gl_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT :: GLenum +gl_TEXTURE_BUFFER_DATA_STORE_BINDING_EXT = 0x8C2D +gl_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT :: GLenum +gl_MAX_GEOMETRY_IMAGE_UNIFORMS_EXT = 0x90CD +gl_DYNAMIC_COPY :: GLenum +gl_DYNAMIC_COPY = 0x88EA +gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_EXT = 0x851A +gl_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT :: GLenum +gl_MAX_FRAGMENT_BINDABLE_UNIFORMS_EXT = 0x8DE3 +gl_PROGRAM_LENGTH_ARB :: GLenum +gl_PROGRAM_LENGTH_ARB = 0x8627 +gl_MODELVIEW14_ARB :: GLenum +gl_MODELVIEW14_ARB = 0x872E +gl_ITALIC_BIT_NV :: GLenum +gl_ITALIC_BIT_NV = 0x02 +gl_OR_INVERTED :: GLenum +gl_OR_INVERTED = 0x150D +gl_CLIP_NEAR_HINT_PGI :: GLenum +gl_CLIP_NEAR_HINT_PGI = 0x1A220 +gl_COVERAGE_EDGE_FRAGMENTS_NV :: GLenum +gl_COVERAGE_EDGE_FRAGMENTS_NV = 0x8ED6 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR = 0x93D3 +gl_PROGRAM_BINARY_LENGTH_OES :: GLenum +gl_PROGRAM_BINARY_LENGTH_OES = 0x8741 +gl_DRAW_BUFFER8_ARB :: GLenum +gl_DRAW_BUFFER8_ARB = 0x882D +gl_DRAW_FRAMEBUFFER_EXT :: GLenum +gl_DRAW_FRAMEBUFFER_EXT = 0x8CA9 +gl_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET :: GLenum +gl_MAX_VERTEX_ATTRIB_RELATIVE_OFFSET = 0x82D9 +gl_SYNC_CL_EVENT_ARB :: GLenum +gl_SYNC_CL_EVENT_ARB = 0x8240 +gl_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE :: GLenum +gl_IMAGE_FORMAT_COMPATIBILITY_BY_SIZE = 0x90C8 +gl_MAX_VERTEX_HINT_PGI :: GLenum +gl_MAX_VERTEX_HINT_PGI = 0x1A22D +gl_UNPACK_IMAGE_HEIGHT_EXT :: GLenum +gl_UNPACK_IMAGE_HEIGHT_EXT = 0x806E +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV :: GLenum +gl_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_NV = 0x8C4F +gl_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_BLUE_SIZE = 0x8214 +gl_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB :: GLenum +gl_MAX_FRAGMENT_UNIFORM_COMPONENTS_ARB = 0x8B49 +gl_STENCIL_BACK_REF :: GLenum +gl_STENCIL_BACK_REF = 0x8CA3 +gl_CLAMP_READ_COLOR_ARB :: GLenum +gl_CLAMP_READ_COLOR_ARB = 0x891C +gl_INTERNALFORMAT_RED_SIZE :: GLenum +gl_INTERNALFORMAT_RED_SIZE = 0x8271 +gl_PATCH_DEFAULT_INNER_LEVEL_EXT :: GLenum +gl_PATCH_DEFAULT_INNER_LEVEL_EXT = 0x8E73 +gl_OUTPUT_TEXTURE_COORD27_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD27_EXT = 0x87B8 +gl_QUERY_STENCIL_FAIL_EVENT_BIT_AMD :: GLenum +gl_QUERY_STENCIL_FAIL_EVENT_BIT_AMD = 0x00000004 +gl_MAX_COMPUTE_TEXTURE_IMAGE_UNITS :: GLenum +gl_MAX_COMPUTE_TEXTURE_IMAGE_UNITS = 0x91BC +gl_LOCATION :: GLenum +gl_LOCATION = 0x930E +gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS :: GLenum +gl_MAX_TESS_EVALUATION_TEXTURE_IMAGE_UNITS = 0x8E82 +gl_POST_COLOR_MATRIX_GREEN_SCALE :: GLenum +gl_POST_COLOR_MATRIX_GREEN_SCALE = 0x80B5 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR = 0x93D9 +gl_POST_COLOR_MATRIX_ALPHA_SCALE :: GLenum +gl_POST_COLOR_MATRIX_ALPHA_SCALE = 0x80B7 +gl_HORIZONTAL_LINE_TO_NV :: GLenum +gl_HORIZONTAL_LINE_TO_NV = 0x06 +gl_MAX_FRAGMENT_INPUT_COMPONENTS :: GLenum +gl_MAX_FRAGMENT_INPUT_COMPONENTS = 0x9125 +gl_PROGRAM_STRING_ARB :: GLenum +gl_PROGRAM_STRING_ARB = 0x8628 +gl_EDGE_FLAG_ARRAY_ADDRESS_NV :: GLenum +gl_EDGE_FLAG_ARRAY_ADDRESS_NV = 0x8F26 +gl_VENDOR :: GLenum +gl_VENDOR = 0x1F00 +gl_CLIPPING_INPUT_PRIMITIVES_ARB :: GLenum +gl_CLIPPING_INPUT_PRIMITIVES_ARB = 0x82F6 +gl_TEXTURE_RENDERBUFFER_NV :: GLenum +gl_TEXTURE_RENDERBUFFER_NV = 0x8E55 +gl_ELEMENT_ARRAY_ADDRESS_NV :: GLenum +gl_ELEMENT_ARRAY_ADDRESS_NV = 0x8F29 +gl_LOCAL_EXT :: GLenum +gl_LOCAL_EXT = 0x87C4 +gl_GEOMETRY_SHADER_INVOCATIONS :: GLenum +gl_GEOMETRY_SHADER_INVOCATIONS = 0x887F +gl_INT_VEC4_ARB :: GLenum +gl_INT_VEC4_ARB = 0x8B55 +gl_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_STENCIL_SIZE = 0x8217 +gl_SEPARATE_ATTRIBS_NV :: GLenum +gl_SEPARATE_ATTRIBS_NV = 0x8C8D +gl_FLOAT_MAT4_ARB :: GLenum +gl_FLOAT_MAT4_ARB = 0x8B5C +gl_COLOR_ATTACHMENT_EXT :: GLenum +gl_COLOR_ATTACHMENT_EXT = 0x90F0 +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE = 0x8CD0 +gl_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB :: GLenum +gl_MAX_MATRIX_PALETTE_STACK_DEPTH_ARB = 0x8841 +gl_SHININESS :: GLenum +gl_SHININESS = 0x1601 +gl_INTERPOLATE_EXT :: GLenum +gl_INTERPOLATE_EXT = 0x8575 +gl_TRANSFORM_FEEDBACK :: GLenum +gl_TRANSFORM_FEEDBACK = 0x8E22 +gl_TEXTURE_DEPTH_QCOM :: GLenum +gl_TEXTURE_DEPTH_QCOM = 0x8BD4 +gl_DOUBLE_MAT4x2 :: GLenum +gl_DOUBLE_MAT4x2 = 0x8F4D +gl_NORMAL_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_NORMAL_ARRAY_BUFFER_BINDING_ARB = 0x8897 +gl_PIXEL_TEX_GEN_SGIX :: GLenum +gl_PIXEL_TEX_GEN_SGIX = 0x8139 +gl_TRANSFORM_FEEDBACK_BUFFER_START :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_START = 0x8C84 +gl_GLYPH_WIDTH_BIT_NV :: GLenum +gl_GLYPH_WIDTH_BIT_NV = 0x01 +gl_STENCIL_ATTACHMENT_EXT :: GLenum +gl_STENCIL_ATTACHMENT_EXT = 0x8D20 +gl_VERTEX_ARRAY_RANGE_POINTER_APPLE :: GLenum +gl_VERTEX_ARRAY_RANGE_POINTER_APPLE = 0x8521 +gl_VERTEX_WEIGHT_ARRAY_TYPE_EXT :: GLenum +gl_VERTEX_WEIGHT_ARRAY_TYPE_EXT = 0x850E +gl_MATRIX4_NV :: GLenum +gl_MATRIX4_NV = 0x8634 +gl_READ_FRAMEBUFFER_ANGLE :: GLenum +gl_READ_FRAMEBUFFER_ANGLE = 0x8CA8 +gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS :: GLenum +gl_MAX_SPARSE_ARRAY_TEXTURE_LAYERS = 0x919A +gl_VERTEX_ARRAY_POINTER_EXT :: GLenum +gl_VERTEX_ARRAY_POINTER_EXT = 0x808E +gl_RELATIVE_ROUNDED_RECT_NV :: GLenum +gl_RELATIVE_ROUNDED_RECT_NV = 0xE9 +gl_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV :: GLenum +gl_RELATIVE_SMOOTH_CUBIC_CURVE_TO_NV = 0x11 +gl_MAX_PROGRAM_GENERIC_ATTRIBS_NV :: GLenum +gl_MAX_PROGRAM_GENERIC_ATTRIBS_NV = 0x8DA5 +gl_TEXTURE_MEMORY_LAYOUT_INTEL :: GLenum +gl_TEXTURE_MEMORY_LAYOUT_INTEL = 0x83FF +gl_REG_0_ATI :: GLenum +gl_REG_0_ATI = 0x8921 +gl_VERTEX_ATTRIB_ARRAY15_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY15_NV = 0x865F +gl_RGB12_EXT :: GLenum +gl_RGB12_EXT = 0x8053 +gl_FRAGMENT_LIGHT6_SGIX :: GLenum +gl_FRAGMENT_LIGHT6_SGIX = 0x8412 +gl_MAX_PROGRAM_ATTRIB_COMPONENTS_NV :: GLenum +gl_MAX_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8908 +gl_QUERY_ALL_EVENT_BITS_AMD :: GLenum +gl_QUERY_ALL_EVENT_BITS_AMD = 0xFFFFFFFF +gl_INTENSITY_FLOAT32_APPLE :: GLenum +gl_INTENSITY_FLOAT32_APPLE = 0x8817 +gl_LIST_INDEX :: GLenum +gl_LIST_INDEX = 0x0B33 +gl_COMPRESSED_RGB_PVRTC_2BPPV1_IMG :: GLenum +gl_COMPRESSED_RGB_PVRTC_2BPPV1_IMG = 0x8C01 +gl_REG_18_ATI :: GLenum +gl_REG_18_ATI = 0x8933 +gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT :: GLenum +gl_INT_IMAGE_2D_MULTISAMPLE_ARRAY_EXT = 0x9061 +gl_COMPILE :: GLenum +gl_COMPILE = 0x1300 +gl_VIEW_CLASS_128_BITS :: GLenum +gl_VIEW_CLASS_128_BITS = 0x82C4 +gl_4X_BIT_ATI :: GLenum +gl_4X_BIT_ATI = 0x00000002 +gl_CLIENT_PIXEL_STORE_BIT :: GLenum +gl_CLIENT_PIXEL_STORE_BIT = 0x00000001 +gl_OPERAND2_RGB :: GLenum +gl_OPERAND2_RGB = 0x8592 +gl_MINMAX_FORMAT_EXT :: GLenum +gl_MINMAX_FORMAT_EXT = 0x802F +gl_UNSIGNED_INT_IMAGE_1D :: GLenum +gl_UNSIGNED_INT_IMAGE_1D = 0x9062 +gl_INSTRUMENT_MEASUREMENTS_SGIX :: GLenum +gl_INSTRUMENT_MEASUREMENTS_SGIX = 0x8181 +gl_VALIDATE_STATUS :: GLenum +gl_VALIDATE_STATUS = 0x8B83 +gl_NORMAL_ARRAY_COUNT_EXT :: GLenum +gl_NORMAL_ARRAY_COUNT_EXT = 0x8080 +gl_PATH_STENCIL_REF_NV :: GLenum +gl_PATH_STENCIL_REF_NV = 0x90B8 +gl_DRAW_BUFFER5_NV :: GLenum +gl_DRAW_BUFFER5_NV = 0x882A +gl_COMPRESSED_RGBA_ARB :: GLenum +gl_COMPRESSED_RGBA_ARB = 0x84EE +gl_MAX_MULTISAMPLE_COVERAGE_MODES_NV :: GLenum +gl_MAX_MULTISAMPLE_COVERAGE_MODES_NV = 0x8E11 +gl_MAX_3D_TEXTURE_SIZE :: GLenum +gl_MAX_3D_TEXTURE_SIZE = 0x8073 +gl_FRAGMENT_NORMAL_EXT :: GLenum +gl_FRAGMENT_NORMAL_EXT = 0x834A +gl_SHADER_KHR :: GLenum +gl_SHADER_KHR = 0x82E1 +gl_TEXTURE_DEPTH_TYPE :: GLenum +gl_TEXTURE_DEPTH_TYPE = 0x8C16 +gl_VERTEX_PROGRAM_CALLBACK_FUNC_MESA :: GLenum +gl_VERTEX_PROGRAM_CALLBACK_FUNC_MESA = 0x8BB6 +gl_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE :: GLenum +gl_TRANSLATED_SHADER_SOURCE_LENGTH_ANGLE = 0x93A0 +gl_TEXTURE_2D_STACK_BINDING_MESAX :: GLenum +gl_TEXTURE_2D_STACK_BINDING_MESAX = 0x875E +gl_NUM_COMPRESSED_TEXTURE_FORMATS_ARB :: GLenum +gl_NUM_COMPRESSED_TEXTURE_FORMATS_ARB = 0x86A2 +gl_INT_SAMPLER_2D_EXT :: GLenum +gl_INT_SAMPLER_2D_EXT = 0x8DCA +gl_RGBA4_S3TC :: GLenum +gl_RGBA4_S3TC = 0x83A3 +gl_MAX_SPOT_EXPONENT_NV :: GLenum +gl_MAX_SPOT_EXPONENT_NV = 0x8505 +gl_NEGATIVE_X_EXT :: GLenum +gl_NEGATIVE_X_EXT = 0x87D9 +gl_SYNC_X11_FENCE_EXT :: GLenum +gl_SYNC_X11_FENCE_EXT = 0x90E1 +gl_OP_DOT3_EXT :: GLenum +gl_OP_DOT3_EXT = 0x8784 +gl_LUMINANCE8_SNORM :: GLenum +gl_LUMINANCE8_SNORM = 0x9015 +gl_SAMPLE_SHADING_ARB :: GLenum +gl_SAMPLE_SHADING_ARB = 0x8C36 +gl_CONVOLUTION_2D_EXT :: GLenum +gl_CONVOLUTION_2D_EXT = 0x8011 +gl_MAP2_TEXTURE_COORD_2 :: GLenum +gl_MAP2_TEXTURE_COORD_2 = 0x0DB4 +gl_SHADER_IMAGE_LOAD :: GLenum +gl_SHADER_IMAGE_LOAD = 0x82A4 +gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_NV = 0x8C85 +gl_TEXTURE_VIEW_NUM_LEVELS_EXT :: GLenum +gl_TEXTURE_VIEW_NUM_LEVELS_EXT = 0x82DC +gl_ACTIVE_UNIFORMS :: GLenum +gl_ACTIVE_UNIFORMS = 0x8B86 +gl_ACCUM_GREEN_BITS :: GLenum +gl_ACCUM_GREEN_BITS = 0x0D59 +gl_TESS_EVALUATION_PROGRAM_NV :: GLenum +gl_TESS_EVALUATION_PROGRAM_NV = 0x891F +gl_COMPRESSED_SLUMINANCE :: GLenum +gl_COMPRESSED_SLUMINANCE = 0x8C4A +gl_COLOR_ATTACHMENT14_EXT :: GLenum +gl_COLOR_ATTACHMENT14_EXT = 0x8CEE +gl_VERTEX23_BIT_PGI :: GLenum +gl_VERTEX23_BIT_PGI = 0x00000004 +gl_BUMP_ROT_MATRIX_ATI :: GLenum +gl_BUMP_ROT_MATRIX_ATI = 0x8775 +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT = 0x8D56 +gl_MAX_PALETTE_MATRICES_OES :: GLenum +gl_MAX_PALETTE_MATRICES_OES = 0x8842 +gl_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV :: GLenum +gl_Z4Y12Z4CB12Z4A12Z4Y12Z4CR12Z4A12_4224_NV = 0x9036 +gl_CONVOLUTION_BORDER_MODE_EXT :: GLenum +gl_CONVOLUTION_BORDER_MODE_EXT = 0x8013 +gl_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE :: GLenum +gl_VERTEX_ATTRIB_MAP1_DOMAIN_APPLE = 0x8A05 +gl_INTENSITY32I_EXT :: GLenum +gl_INTENSITY32I_EXT = 0x8D85 +gl_RASTERIZER_DISCARD_EXT :: GLenum +gl_RASTERIZER_DISCARD_EXT = 0x8C89 +gl_MAX_SAMPLES_EXT :: GLenum +gl_MAX_SAMPLES_EXT = 0x8D57 +gl_DRAW_BUFFER10_EXT :: GLenum +gl_DRAW_BUFFER10_EXT = 0x882F +gl_INT_IMAGE_2D :: GLenum +gl_INT_IMAGE_2D = 0x9058 +gl_PROVOKING_VERTEX :: GLenum +gl_PROVOKING_VERTEX = 0x8E4F +gl_UNPACK_RESAMPLE_SGIX :: GLenum +gl_UNPACK_RESAMPLE_SGIX = 0x842D +gl_SAMPLE_POSITION_NV :: GLenum +gl_SAMPLE_POSITION_NV = 0x8E50 +gl_MAX_PROGRAM_MATRICES_ARB :: GLenum +gl_MAX_PROGRAM_MATRICES_ARB = 0x862F +gl_SHADER_STORAGE_BUFFER_BINDING :: GLenum +gl_SHADER_STORAGE_BUFFER_BINDING = 0x90D3 +gl_TEXTURE0 :: GLenum +gl_TEXTURE0 = 0x84C0 +gl_DSDT_MAG_VIB_NV :: GLenum +gl_DSDT_MAG_VIB_NV = 0x86F7 +gl_DOUBLE_MAT4x3 :: GLenum +gl_DOUBLE_MAT4x3 = 0x8F4E +gl_TEXTURE27_ARB :: GLenum +gl_TEXTURE27_ARB = 0x84DB +gl_ACTIVE_ATOMIC_COUNTER_BUFFERS :: GLenum +gl_ACTIVE_ATOMIC_COUNTER_BUFFERS = 0x92D9 +gl_LUMINANCE32I_EXT :: GLenum +gl_LUMINANCE32I_EXT = 0x8D86 +gl_SAMPLER_KHR :: GLenum +gl_SAMPLER_KHR = 0x82E6 +gl_MITER_REVERT_NV :: GLenum +gl_MITER_REVERT_NV = 0x90A7 +gl_RGB32UI_EXT :: GLenum +gl_RGB32UI_EXT = 0x8D71 +gl_DUAL_LUMINANCE12_SGIS :: GLenum +gl_DUAL_LUMINANCE12_SGIS = 0x8116 +gl_BOOL_VEC2 :: GLenum +gl_BOOL_VEC2 = 0x8B57 +gl_COLOR_ATTACHMENT1_NV :: GLenum +gl_COLOR_ATTACHMENT1_NV = 0x8CE1 +gl_MAX_CONVOLUTION_WIDTH :: GLenum +gl_MAX_CONVOLUTION_WIDTH = 0x801A +gl_DRAW_BUFFER14_NV :: GLenum +gl_DRAW_BUFFER14_NV = 0x8833 +gl_BLEND_DST_RGB_EXT :: GLenum +gl_BLEND_DST_RGB_EXT = 0x80C8 +gl_LUMINANCE12_ALPHA12_EXT :: GLenum +gl_LUMINANCE12_ALPHA12_EXT = 0x8047 +gl_DEPTH_BOUNDS_EXT :: GLenum +gl_DEPTH_BOUNDS_EXT = 0x8891 +gl_CIRCULAR_CCW_ARC_TO_NV :: GLenum +gl_CIRCULAR_CCW_ARC_TO_NV = 0xF8 +gl_COMPRESSED_LUMINANCE_ALPHA :: GLenum +gl_COMPRESSED_LUMINANCE_ALPHA = 0x84EB +gl_SAMPLE_COVERAGE_VALUE_ARB :: GLenum +gl_SAMPLE_COVERAGE_VALUE_ARB = 0x80AA +gl_DEPTH_STENCIL_TO_RGBA_NV :: GLenum +gl_DEPTH_STENCIL_TO_RGBA_NV = 0x886E +gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING :: GLenum +gl_SECONDARY_COLOR_ARRAY_BUFFER_BINDING = 0x889C +gl_NAME_LENGTH :: GLenum +gl_NAME_LENGTH = 0x92F9 +gl_STENCIL_TEST_TWO_SIDE_EXT :: GLenum +gl_STENCIL_TEST_TWO_SIDE_EXT = 0x8910 +gl_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES :: GLenum +gl_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES = 0x898D +gl_VERTEX_ATTRIB_ARRAY_STRIDE_ARB :: GLenum +gl_VERTEX_ATTRIB_ARRAY_STRIDE_ARB = 0x8624 +gl_OUTPUT_TEXTURE_COORD30_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD30_EXT = 0x87BB +gl_MAX_PROGRAM_SUBROUTINE_NUM_NV :: GLenum +gl_MAX_PROGRAM_SUBROUTINE_NUM_NV = 0x8F45 +gl_MULTIPLY_NV :: GLenum +gl_MULTIPLY_NV = 0x9294 +gl_TEXTURE19 :: GLenum +gl_TEXTURE19 = 0x84D3 +gl_INVERT_OVG_NV :: GLenum +gl_INVERT_OVG_NV = 0x92B4 +gl_IMPLEMENTATION_COLOR_READ_FORMAT_OES :: GLenum +gl_IMPLEMENTATION_COLOR_READ_FORMAT_OES = 0x8B9B +gl_NEAREST_CLIPMAP_LINEAR_SGIX :: GLenum +gl_NEAREST_CLIPMAP_LINEAR_SGIX = 0x844E +gl_VARIABLE_A_NV :: GLenum +gl_VARIABLE_A_NV = 0x8523 +gl_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT :: GLenum +gl_COMPRESSED_SIGNED_LUMINANCE_LATC1_EXT = 0x8C71 +gl_TEXTURE_2D_MULTISAMPLE :: GLenum +gl_TEXTURE_2D_MULTISAMPLE = 0x9100 +gl_DEBUG_SOURCE_THIRD_PARTY :: GLenum +gl_DEBUG_SOURCE_THIRD_PARTY = 0x8249 +gl_DRAW_BUFFER7_ARB :: GLenum +gl_DRAW_BUFFER7_ARB = 0x882C +gl_MAX_DRAW_BUFFERS :: GLenum +gl_MAX_DRAW_BUFFERS = 0x8824 +gl_MAX_SERVER_WAIT_TIMEOUT :: GLenum +gl_MAX_SERVER_WAIT_TIMEOUT = 0x9111 +gl_COMPRESSED_SIGNED_RG11_EAC :: GLenum +gl_COMPRESSED_SIGNED_RG11_EAC = 0x9273 +gl_VERTEX_PROGRAM_POINT_SIZE :: GLenum +gl_VERTEX_PROGRAM_POINT_SIZE = 0x8642 +gl_STENCIL_PASS_DEPTH_PASS :: GLenum +gl_STENCIL_PASS_DEPTH_PASS = 0x0B96 +gl_RENDERBUFFER_STENCIL_SIZE :: GLenum +gl_RENDERBUFFER_STENCIL_SIZE = 0x8D55 +gl_TEXTURE_BINDING_2D :: GLenum +gl_TEXTURE_BINDING_2D = 0x8069 +gl_DATA_BUFFER_AMD :: GLenum +gl_DATA_BUFFER_AMD = 0x9151 +gl_DEBUG_CATEGORY_APPLICATION_AMD :: GLenum +gl_DEBUG_CATEGORY_APPLICATION_AMD = 0x914F +gl_ASYNC_HISTOGRAM_SGIX :: GLenum +gl_ASYNC_HISTOGRAM_SGIX = 0x832C +gl_UNPACK_LSB_FIRST :: GLenum +gl_UNPACK_LSB_FIRST = 0x0CF1 +gl_UNSIGNED_INT_SAMPLER_CUBE_EXT :: GLenum +gl_UNSIGNED_INT_SAMPLER_CUBE_EXT = 0x8DD4 +gl_DEPTH_CLAMP_FAR_AMD :: GLenum +gl_DEPTH_CLAMP_FAR_AMD = 0x901F +gl_TRANSFORM_FEEDBACK_BUFFER_MODE_NV :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_MODE_NV = 0x8C7F +gl_VERTEX_ATTRIB_ARRAY_STRIDE :: GLenum +gl_VERTEX_ATTRIB_ARRAY_STRIDE = 0x8624 +gl_UNSIGNED_INT16_VEC4_NV :: GLenum +gl_UNSIGNED_INT16_VEC4_NV = 0x8FF3 +gl_OBJECT_BUFFER_SIZE_ATI :: GLenum +gl_OBJECT_BUFFER_SIZE_ATI = 0x8764 +gl_YCRCB_444_SGIX :: GLenum +gl_YCRCB_444_SGIX = 0x81BC +gl_LOSE_CONTEXT_ON_RESET_KHR :: GLenum +gl_LOSE_CONTEXT_ON_RESET_KHR = 0x8252 +gl_TEXTURE_VIEW_NUM_LAYERS :: GLenum +gl_TEXTURE_VIEW_NUM_LAYERS = 0x82DE +gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB :: GLenum +gl_MAX_COMBINED_TEXTURE_IMAGE_UNITS_ARB = 0x8B4D +gl_PERFQUERY_COUNTER_DATA_BOOL32_INTEL :: GLenum +gl_PERFQUERY_COUNTER_DATA_BOOL32_INTEL = 0x94FC +gl_OBJECT_DELETE_STATUS_ARB :: GLenum +gl_OBJECT_DELETE_STATUS_ARB = 0x8B80 +gl_SQUARE_NV :: GLenum +gl_SQUARE_NV = 0x90A3 +gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT :: GLenum +gl_MAX_TESS_CONTROL_TEXTURE_IMAGE_UNITS_EXT = 0x8E81 +gl_DEBUG_SEVERITY_NOTIFICATION_KHR :: GLenum +gl_DEBUG_SEVERITY_NOTIFICATION_KHR = 0x826B +gl_EYE_LINEAR_NV :: GLenum +gl_EYE_LINEAR_NV = 0x2400 +gl_REG_16_ATI :: GLenum +gl_REG_16_ATI = 0x8931 +gl_LUMINANCE_ALPHA32UI_EXT :: GLenum +gl_LUMINANCE_ALPHA32UI_EXT = 0x8D75 +gl_OUTPUT_TEXTURE_COORD31_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD31_EXT = 0x87BC +gl_COMPRESSED_RG_RGTC2 :: GLenum +gl_COMPRESSED_RG_RGTC2 = 0x8DBD +gl_FLOAT_MAT3 :: GLenum +gl_FLOAT_MAT3 = 0x8B5B +gl_INDEX_ARRAY_POINTER :: GLenum +gl_INDEX_ARRAY_POINTER = 0x8091 +gl_FOG_COORD :: GLenum +gl_FOG_COORD = 0x8451 +gl_DRAW_BUFFER13 :: GLenum +gl_DRAW_BUFFER13 = 0x8832 +gl_SCALED_RESOLVE_NICEST_EXT :: GLenum +gl_SCALED_RESOLVE_NICEST_EXT = 0x90BB +gl_QUERY_RESULT_AVAILABLE :: GLenum +gl_QUERY_RESULT_AVAILABLE = 0x8867 +gl_UNPACK_SUBSAMPLE_RATE_SGIX :: GLenum +gl_UNPACK_SUBSAMPLE_RATE_SGIX = 0x85A1 +gl_3_BYTES_NV :: GLenum +gl_3_BYTES_NV = 0x1408 +gl_CLEAR :: GLenum +gl_CLEAR = 0x1500 +gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT :: GLenum +gl_MAX_TESS_CONTROL_ATOMIC_COUNTER_BUFFERS_EXT = 0x92CD +gl_R8UI :: GLenum +gl_R8UI = 0x8232 +gl_OFFSET_TEXTURE_2D_MATRIX_NV :: GLenum +gl_OFFSET_TEXTURE_2D_MATRIX_NV = 0x86E1 +gl_BGRA_INTEGER :: GLenum +gl_BGRA_INTEGER = 0x8D9B +gl_MAX_ARRAY_TEXTURE_LAYERS :: GLenum +gl_MAX_ARRAY_TEXTURE_LAYERS = 0x88FF +gl_COMPRESSED_RGB_ARB :: GLenum +gl_COMPRESSED_RGB_ARB = 0x84ED +gl_FOG_COORDINATE_ARRAY_POINTER_EXT :: GLenum +gl_FOG_COORDINATE_ARRAY_POINTER_EXT = 0x8456 +gl_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT :: GLenum +gl_SHADER_IMAGE_ACCESS_BARRIER_BIT_EXT = 0x00000020 +gl_TEXTURE_MAG_FILTER :: GLenum +gl_TEXTURE_MAG_FILTER = 0x2800 +gl_DEPTH_COMPONENT32 :: GLenum +gl_DEPTH_COMPONENT32 = 0x81A7 +gl_VIEW_CLASS_S3TC_DXT1_RGB :: GLenum +gl_VIEW_CLASS_S3TC_DXT1_RGB = 0x82CC +gl_FRONT_RIGHT :: GLenum +gl_FRONT_RIGHT = 0x0401 +gl_HISTOGRAM_WIDTH :: GLenum +gl_HISTOGRAM_WIDTH = 0x8026 +gl_SAMPLER_CUBE_MAP_ARRAY_ARB :: GLenum +gl_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900C +gl_WEIGHT_ARRAY_STRIDE_OES :: GLenum +gl_WEIGHT_ARRAY_STRIDE_OES = 0x86AA +gl_PIXEL_PACK_BUFFER_ARB :: GLenum +gl_PIXEL_PACK_BUFFER_ARB = 0x88EB +gl_DOT_PRODUCT_PASS_THROUGH_NV :: GLenum +gl_DOT_PRODUCT_PASS_THROUGH_NV = 0x885B +gl_COMPRESSED_RG11_EAC :: GLenum +gl_COMPRESSED_RG11_EAC = 0x9272 +gl_SRGB_DECODE_ARB :: GLenum +gl_SRGB_DECODE_ARB = 0x8299 +gl_OP_SUB_EXT :: GLenum +gl_OP_SUB_EXT = 0x8796 +gl_SLIM12S_SGIX :: GLenum +gl_SLIM12S_SGIX = 0x831F +gl_SECONDARY_COLOR_NV :: GLenum +gl_SECONDARY_COLOR_NV = 0x852D +gl_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS :: GLenum +gl_MAX_FRAGMENT_SHADER_STORAGE_BLOCKS = 0x90DA +gl_MAP1_VERTEX_3 :: GLenum +gl_MAP1_VERTEX_3 = 0x0D97 +gl_RELATIVE_ROUNDED_RECT8_NV :: GLenum +gl_RELATIVE_ROUNDED_RECT8_NV = 0xEF +gl_PALETTE4_R5_G6_B5_OES :: GLenum +gl_PALETTE4_R5_G6_B5_OES = 0x8B92 +gl_UNSIGNED_INT8_NV :: GLenum +gl_UNSIGNED_INT8_NV = 0x8FEC +gl_CURRENT_MATRIX_STACK_DEPTH_ARB :: GLenum +gl_CURRENT_MATRIX_STACK_DEPTH_ARB = 0x8640 +gl_PIXEL_MODE_BIT :: GLenum +gl_PIXEL_MODE_BIT = 0x00000020 +gl_FONT_UNINTELLIGIBLE_NV :: GLenum +gl_FONT_UNINTELLIGIBLE_NV = 0x936B +gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_ATTACHMENT = 0x8CD6 +gl_LUMINANCE8UI_EXT :: GLenum +gl_LUMINANCE8UI_EXT = 0x8D80 +gl_HILO16_NV :: GLenum +gl_HILO16_NV = 0x86F8 +gl_MAP2_VERTEX_ATTRIB8_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB8_4_NV = 0x8678 +gl_ATTACHED_SHADERS :: GLenum +gl_ATTACHED_SHADERS = 0x8B85 +gl_OBJECT_POINT_SGIS :: GLenum +gl_OBJECT_POINT_SGIS = 0x81F5 +gl_TEXTURE_CUBE_MAP_SEAMLESS :: GLenum +gl_TEXTURE_CUBE_MAP_SEAMLESS = 0x884F +gl_COLOR_ATTACHMENT0 :: GLenum +gl_COLOR_ATTACHMENT0 = 0x8CE0 +gl_POST_CONVOLUTION_ALPHA_BIAS_EXT :: GLenum +gl_POST_CONVOLUTION_ALPHA_BIAS_EXT = 0x8023 +gl_SAMPLE_PATTERN_SGIS :: GLenum +gl_SAMPLE_PATTERN_SGIS = 0x80AC +gl_COPY_PIXEL_TOKEN :: GLenum +gl_COPY_PIXEL_TOKEN = 0x0706 +gl_BUFFER_SIZE_ARB :: GLenum +gl_BUFFER_SIZE_ARB = 0x8764 +gl_DEPTH_BOUNDS_TEST_EXT :: GLenum +gl_DEPTH_BOUNDS_TEST_EXT = 0x8890 +gl_SAMPLE_POSITION :: GLenum +gl_SAMPLE_POSITION = 0x8E50 +gl_FULL_STIPPLE_HINT_PGI :: GLenum +gl_FULL_STIPPLE_HINT_PGI = 0x1A219 +gl_DEBUG_ASSERT_MESA :: GLenum +gl_DEBUG_ASSERT_MESA = 0x875B +gl_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB :: GLenum +gl_VERTEX_ATTRIB_ARRAY_NORMALIZED_ARB = 0x886A +gl_RENDERBUFFER_WIDTH_OES :: GLenum +gl_RENDERBUFFER_WIDTH_OES = 0x8D42 +gl_FLOAT_RGBA16_NV :: GLenum +gl_FLOAT_RGBA16_NV = 0x888A +gl_MODELVIEW5_ARB :: GLenum +gl_MODELVIEW5_ARB = 0x8725 +gl_VERSION :: GLenum +gl_VERSION = 0x1F02 +gl_TEXTURE17_ARB :: GLenum +gl_TEXTURE17_ARB = 0x84D1 +gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT :: GLenum +gl_MAX_COMBINED_GEOMETRY_UNIFORM_COMPONENTS_EXT = 0x8A32 +gl_MODELVIEW0_STACK_DEPTH_EXT :: GLenum +gl_MODELVIEW0_STACK_DEPTH_EXT = 0x0BA3 +gl_OUTPUT_TEXTURE_COORD1_EXT :: GLenum +gl_OUTPUT_TEXTURE_COORD1_EXT = 0x879E +gl_REQUIRED_TEXTURE_IMAGE_UNITS_OES :: GLenum +gl_REQUIRED_TEXTURE_IMAGE_UNITS_OES = 0x8D68 +gl_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX :: GLenum +gl_FRAGMENT_LIGHT_MODEL_LOCAL_VIEWER_SGIX = 0x8408 +gl_IMAGE_TRANSFORM_2D_HP :: GLenum +gl_IMAGE_TRANSFORM_2D_HP = 0x8161 +gl_HSL_SATURATION_NV :: GLenum +gl_HSL_SATURATION_NV = 0x92AE +gl_UNSIGNED_SHORT_5_6_5_REV :: GLenum +gl_UNSIGNED_SHORT_5_6_5_REV = 0x8364 +gl_LINEAR_CLIPMAP_NEAREST_SGIX :: GLenum +gl_LINEAR_CLIPMAP_NEAREST_SGIX = 0x844F +gl_PREVIOUS_ARB :: GLenum +gl_PREVIOUS_ARB = 0x8578 +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_3D_ZOFFSET_EXT = 0x8CD4 +gl_PERFQUERY_COUNTER_DURATION_NORM_INTEL :: GLenum +gl_PERFQUERY_COUNTER_DURATION_NORM_INTEL = 0x94F1 +gl_SLUMINANCE8_EXT :: GLenum +gl_SLUMINANCE8_EXT = 0x8C47 +gl_RGBA16F_ARB :: GLenum +gl_RGBA16F_ARB = 0x881A +gl_PIXEL_UNPACK_BUFFER_ARB :: GLenum +gl_PIXEL_UNPACK_BUFFER_ARB = 0x88EC +gl_STENCIL_REF :: GLenum +gl_STENCIL_REF = 0x0B97 +gl_TEXTURE_VIEW_MIN_LAYER_EXT :: GLenum +gl_TEXTURE_VIEW_MIN_LAYER_EXT = 0x82DD +gl_HISTOGRAM_RED_SIZE :: GLenum +gl_HISTOGRAM_RED_SIZE = 0x8028 +gl_CLIP_PLANE1 :: GLenum +gl_CLIP_PLANE1 = 0x3001 +gl_UNKNOWN_CONTEXT_RESET_ARB :: GLenum +gl_UNKNOWN_CONTEXT_RESET_ARB = 0x8255 +gl_CMYK_EXT :: GLenum +gl_CMYK_EXT = 0x800C +gl_TEXTURE_COMPRESSED_BLOCK_SIZE :: GLenum +gl_TEXTURE_COMPRESSED_BLOCK_SIZE = 0x82B3 +gl_RGBA8I :: GLenum +gl_RGBA8I = 0x8D8E +gl_TEXTURE29_ARB :: GLenum +gl_TEXTURE29_ARB = 0x84DD +gl_STENCIL_BUFFER_BIT2_QCOM :: GLenum +gl_STENCIL_BUFFER_BIT2_QCOM = 0x00040000 +gl_RED_MIN_CLAMP_INGR :: GLenum +gl_RED_MIN_CLAMP_INGR = 0x8560 +gl_ATC_RGBA_EXPLICIT_ALPHA_AMD :: GLenum +gl_ATC_RGBA_EXPLICIT_ALPHA_AMD = 0x8C93 +gl_ALL_COMPLETED_NV :: GLenum +gl_ALL_COMPLETED_NV = 0x84F2 +gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE :: GLenum +gl_PROXY_POST_COLOR_MATRIX_COLOR_TABLE = 0x80D5 +gl_MATRIX10_ARB :: GLenum +gl_MATRIX10_ARB = 0x88CA +gl_MAP1_VERTEX_ATTRIB1_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB1_4_NV = 0x8661 +gl_MAX_4D_TEXTURE_SIZE_SGIS :: GLenum +gl_MAX_4D_TEXTURE_SIZE_SGIS = 0x8138 +gl_VIEW_CLASS_32_BITS :: GLenum +gl_VIEW_CLASS_32_BITS = 0x82C8 +gl_TEXTURE7_ARB :: GLenum +gl_TEXTURE7_ARB = 0x84C7 +gl_DEBUG_TYPE_PERFORMANCE_ARB :: GLenum +gl_DEBUG_TYPE_PERFORMANCE_ARB = 0x8250 +gl_ACTIVE_VARIABLES :: GLenum +gl_ACTIVE_VARIABLES = 0x9305 +gl_SOURCE2_RGB_EXT :: GLenum +gl_SOURCE2_RGB_EXT = 0x8582 +gl_PACK_INVERT_MESA :: GLenum +gl_PACK_INVERT_MESA = 0x8758 +gl_QUERY_BY_REGION_WAIT_NV :: GLenum +gl_QUERY_BY_REGION_WAIT_NV = 0x8E15 +gl_VERTEX_ID_SWIZZLE_AMD :: GLenum +gl_VERTEX_ID_SWIZZLE_AMD = 0x91A5 +gl_SPRITE_TRANSLATION_SGIX :: GLenum +gl_SPRITE_TRANSLATION_SGIX = 0x814B +gl_RENDERBUFFER_HEIGHT :: GLenum +gl_RENDERBUFFER_HEIGHT = 0x8D43 +gl_CUBIC_EXT :: GLenum +gl_CUBIC_EXT = 0x8334 +gl_TEXTURE19_ARB :: GLenum +gl_TEXTURE19_ARB = 0x84D3 +gl_T2F_N3F_V3F :: GLenum +gl_T2F_N3F_V3F = 0x2A2B +gl_ATOMIC_COUNTER_BARRIER_BIT_EXT :: GLenum +gl_ATOMIC_COUNTER_BARRIER_BIT_EXT = 0x00001000 +gl_ARRAY_ELEMENT_LOCK_FIRST_EXT :: GLenum +gl_ARRAY_ELEMENT_LOCK_FIRST_EXT = 0x81A8 +gl_PROGRAM_RESULT_COMPONENTS_NV :: GLenum +gl_PROGRAM_RESULT_COMPONENTS_NV = 0x8907 +gl_MAX_RECTANGLE_TEXTURE_SIZE_ARB :: GLenum +gl_MAX_RECTANGLE_TEXTURE_SIZE_ARB = 0x84F8 +gl_TRIANGLE_MESH_SUN :: GLenum +gl_TRIANGLE_MESH_SUN = 0x8615 +gl_TEXTURE_WRAP_Q_SGIS :: GLenum +gl_TEXTURE_WRAP_Q_SGIS = 0x8137 +gl_ATTRIB_ARRAY_SIZE_NV :: GLenum +gl_ATTRIB_ARRAY_SIZE_NV = 0x8623 +gl_DEBUG_LOGGED_MESSAGES_AMD :: GLenum +gl_DEBUG_LOGGED_MESSAGES_AMD = 0x9145 +gl_BOOL :: GLenum +gl_BOOL = 0x8B56 +gl_MIN_LOD_WARNING_AMD :: GLenum +gl_MIN_LOD_WARNING_AMD = 0x919C +gl_PACK_SKIP_PIXELS :: GLenum +gl_PACK_SKIP_PIXELS = 0x0D04 +gl_IMAGE_TEXEL_SIZE :: GLenum +gl_IMAGE_TEXEL_SIZE = 0x82A7 +gl_SRC_ALPHA :: GLenum +gl_SRC_ALPHA = 0x0302 +gl_DEPENDENT_HILO_TEXTURE_2D_NV :: GLenum +gl_DEPENDENT_HILO_TEXTURE_2D_NV = 0x8858 +gl_FRAMEBUFFER_ATTACHMENT_LAYERED :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_LAYERED = 0x8DA7 +gl_PERFQUERY_COUNTER_DATA_UINT32_INTEL :: GLenum +gl_PERFQUERY_COUNTER_DATA_UINT32_INTEL = 0x94F8 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR = 0x93D1 +gl_VERTEX_ARRAY_RANGE_LENGTH_NV :: GLenum +gl_VERTEX_ARRAY_RANGE_LENGTH_NV = 0x851E +gl_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS :: GLenum +gl_IMAGE_FORMAT_COMPATIBILITY_BY_CLASS = 0x90C9 +gl_POST_CONVOLUTION_GREEN_SCALE :: GLenum +gl_POST_CONVOLUTION_GREEN_SCALE = 0x801D +gl_SEPARATE_ATTRIBS :: GLenum +gl_SEPARATE_ATTRIBS = 0x8C8D +gl_UNSIGNED_BYTE_3_3_2 :: GLenum +gl_UNSIGNED_BYTE_3_3_2 = 0x8032 +gl_SCALAR_EXT :: GLenum +gl_SCALAR_EXT = 0x87BE +gl_POINT_SIZE_ARRAY_STRIDE_OES :: GLenum +gl_POINT_SIZE_ARRAY_STRIDE_OES = 0x898B +gl_DOUBLE_MAT3x4 :: GLenum +gl_DOUBLE_MAT3x4 = 0x8F4C +gl_SRC0_RGB :: GLenum +gl_SRC0_RGB = 0x8580 +gl_VIEW_CLASS_BPTC_UNORM :: GLenum +gl_VIEW_CLASS_BPTC_UNORM = 0x82D2 +gl_SYNC_FLAGS :: GLenum +gl_SYNC_FLAGS = 0x9115 +gl_TEXTURE_SWIZZLE_RGBA_EXT :: GLenum +gl_TEXTURE_SWIZZLE_RGBA_EXT = 0x8E46 +gl_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX :: GLenum +gl_POST_TEXTURE_FILTER_SCALE_RANGE_SGIX = 0x817C +gl_TEXTURE29 :: GLenum +gl_TEXTURE29 = 0x84DD +gl_MEDIUM_INT :: GLenum +gl_MEDIUM_INT = 0x8DF4 +gl_CURRENT_QUERY_ARB :: GLenum +gl_CURRENT_QUERY_ARB = 0x8865 +gl_DT_SCALE_NV :: GLenum +gl_DT_SCALE_NV = 0x8711 +gl_CLAMP_VERTEX_COLOR_ARB :: GLenum +gl_CLAMP_VERTEX_COLOR_ARB = 0x891A +gl_DEPTH_BUFFER_BIT4_QCOM :: GLenum +gl_DEPTH_BUFFER_BIT4_QCOM = 0x00001000 +gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 :: GLenum +gl_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2 = 0x9277 +gl_USE_MISSING_GLYPH_NV :: GLenum +gl_USE_MISSING_GLYPH_NV = 0x90AA +gl_MAX_ASYNC_TEX_IMAGE_SGIX :: GLenum +gl_MAX_ASYNC_TEX_IMAGE_SGIX = 0x835F +gl_TESS_CONTROL_TEXTURE :: GLenum +gl_TESS_CONTROL_TEXTURE = 0x829C +gl_DEPTH_FUNC :: GLenum +gl_DEPTH_FUNC = 0x0B74 +gl_RG8I :: GLenum +gl_RG8I = 0x8237 +gl_MAX_VERTEX_SHADER_VARIANTS_EXT :: GLenum +gl_MAX_VERTEX_SHADER_VARIANTS_EXT = 0x87C6 +gl_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB :: GLenum +gl_PROGRAM_NATIVE_ADDRESS_REGISTERS_ARB = 0x88B2 +gl_COMPRESSED_SRGB :: GLenum +gl_COMPRESSED_SRGB = 0x8C48 +gl_PROGRAM_BINDING_ARB :: GLenum +gl_PROGRAM_BINDING_ARB = 0x8677 +gl_SAMPLER_2D_ARRAY :: GLenum +gl_SAMPLER_2D_ARRAY = 0x8DC1 +gl_IMAGE_CUBE_MAP_ARRAY_EXT :: GLenum +gl_IMAGE_CUBE_MAP_ARRAY_EXT = 0x9054 +gl_BUFFER_ACCESS_FLAGS :: GLenum +gl_BUFFER_ACCESS_FLAGS = 0x911F +gl_EIGHTH_BIT_ATI :: GLenum +gl_EIGHTH_BIT_ATI = 0x00000020 +gl_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV :: GLenum +gl_MAX_FRAGMENT_PROGRAM_LOCAL_PARAMETERS_NV = 0x8868 +gl_INT8_VEC4_NV :: GLenum +gl_INT8_VEC4_NV = 0x8FE3 +gl_CLEAR_TEXTURE :: GLenum +gl_CLEAR_TEXTURE = 0x9365 +gl_TEXTURE_CUBE_MAP_OES :: GLenum +gl_TEXTURE_CUBE_MAP_OES = 0x8513 +gl_FONT_NUM_GLYPH_INDICES_BIT_NV :: GLenum +gl_FONT_NUM_GLYPH_INDICES_BIT_NV = 0x20000000 +gl_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV :: GLenum +gl_MAX_VERTEX_ARRAY_RANGE_ELEMENT_NV = 0x8520 +gl_RENDERBUFFER_DEPTH_SIZE :: GLenum +gl_RENDERBUFFER_DEPTH_SIZE = 0x8D54 +gl_DOT_PRODUCT_TEXTURE_1D_NV :: GLenum +gl_DOT_PRODUCT_TEXTURE_1D_NV = 0x885C +gl_DOUBLE_VEC3_EXT :: GLenum +gl_DOUBLE_VEC3_EXT = 0x8FFD +gl_VERTEX_ATTRIB_ARRAY_UNIFIED_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY_UNIFIED_NV = 0x8F1E +gl_TEXTURE_LUMINANCE_TYPE :: GLenum +gl_TEXTURE_LUMINANCE_TYPE = 0x8C14 +gl_CONTEXT_FLAGS :: GLenum +gl_CONTEXT_FLAGS = 0x821E +gl_NORMAL_ARRAY_BUFFER_BINDING :: GLenum +gl_NORMAL_ARRAY_BUFFER_BINDING = 0x8897 +gl_PROGRAM_FORMAT_ARB :: GLenum +gl_PROGRAM_FORMAT_ARB = 0x8876 +gl_MOVE_TO_CONTINUES_NV :: GLenum +gl_MOVE_TO_CONTINUES_NV = 0x90B6 +gl_LO_BIAS_NV :: GLenum +gl_LO_BIAS_NV = 0x8715 +gl_CONVOLUTION_WIDTH_EXT :: GLenum +gl_CONVOLUTION_WIDTH_EXT = 0x8018 +gl_FRAGMENT_TEXTURE :: GLenum +gl_FRAGMENT_TEXTURE = 0x829F +gl_NORMAL_BIT_PGI :: GLenum +gl_NORMAL_BIT_PGI = 0x08000000 +gl_COMPRESSED_SIGNED_RG11_EAC_OES :: GLenum +gl_COMPRESSED_SIGNED_RG11_EAC_OES = 0x9273 +gl_FIRST_VERTEX_CONVENTION :: GLenum +gl_FIRST_VERTEX_CONVENTION = 0x8E4D +gl_ROUNDED_RECT2_NV :: GLenum +gl_ROUNDED_RECT2_NV = 0xEA +gl_POST_COLOR_MATRIX_RED_BIAS :: GLenum +gl_POST_COLOR_MATRIX_RED_BIAS = 0x80B8 +gl_UNIFORM_BUFFER :: GLenum +gl_UNIFORM_BUFFER = 0x8A11 +gl_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT :: GLenum +gl_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8336 +gl_NUM_SAMPLE_COUNTS :: GLenum +gl_NUM_SAMPLE_COUNTS = 0x9380 +gl_FOG_OFFSET_VALUE_SGIX :: GLenum +gl_FOG_OFFSET_VALUE_SGIX = 0x8199 +gl_DIFFUSE :: GLenum +gl_DIFFUSE = 0x1201 +gl_CLIP_PLANE5 :: GLenum +gl_CLIP_PLANE5 = 0x3005 +gl_OUTPUT_FOG_EXT :: GLenum +gl_OUTPUT_FOG_EXT = 0x87BD +gl_PROGRAM_ATTRIB_COMPONENTS_NV :: GLenum +gl_PROGRAM_ATTRIB_COMPONENTS_NV = 0x8906 +gl_RGBA_SIGNED_COMPONENTS_EXT :: GLenum +gl_RGBA_SIGNED_COMPONENTS_EXT = 0x8C3C +gl_COLOR_ARRAY_EXT :: GLenum +gl_COLOR_ARRAY_EXT = 0x8076 +gl_PROXY_TEXTURE_1D_STACK_MESAX :: GLenum +gl_PROXY_TEXTURE_1D_STACK_MESAX = 0x875B +gl_TEXTURE_COORD_ARRAY_POINTER :: GLenum +gl_TEXTURE_COORD_ARRAY_POINTER = 0x8092 +gl_MAX_COLOR_ATTACHMENTS :: GLenum +gl_MAX_COLOR_ATTACHMENTS = 0x8CDF +gl_TEXTURE28_ARB :: GLenum +gl_TEXTURE28_ARB = 0x84DC +gl_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX :: GLenum +gl_FRAGMENT_COLOR_MATERIAL_PARAMETER_SGIX = 0x8403 +gl_DEPTH24_STENCIL8_EXT :: GLenum +gl_DEPTH24_STENCIL8_EXT = 0x88F0 +gl_MAX :: GLenum +gl_MAX = 0x8008 +gl_MODELVIEW12_ARB :: GLenum +gl_MODELVIEW12_ARB = 0x872C +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6x6_OES = 0x93E9 +gl_PIXEL_MAP_I_TO_I_SIZE :: GLenum +gl_PIXEL_MAP_I_TO_I_SIZE = 0x0CB0 +gl_NORMAL_ARRAY_LIST_STRIDE_IBM :: GLenum +gl_NORMAL_ARRAY_LIST_STRIDE_IBM = 103081 +gl_SOURCE3_RGB_NV :: GLenum +gl_SOURCE3_RGB_NV = 0x8583 +gl_ALPHA12_EXT :: GLenum +gl_ALPHA12_EXT = 0x803D +gl_STREAM_COPY_ARB :: GLenum +gl_STREAM_COPY_ARB = 0x88E2 +gl_STENCIL_BACK_PASS_DEPTH_FAIL_ATI :: GLenum +gl_STENCIL_BACK_PASS_DEPTH_FAIL_ATI = 0x8802 +gl_FRAGMENT_SUBROUTINE_UNIFORM :: GLenum +gl_FRAGMENT_SUBROUTINE_UNIFORM = 0x92F2 +gl_IS_ROW_MAJOR :: GLenum +gl_IS_ROW_MAJOR = 0x9300 +gl_UNPACK_SKIP_IMAGES :: GLenum +gl_UNPACK_SKIP_IMAGES = 0x806D +gl_NUM_GENERAL_COMBINERS_NV :: GLenum +gl_NUM_GENERAL_COMBINERS_NV = 0x854E +gl_STENCIL_CLEAR_TAG_VALUE_EXT :: GLenum +gl_STENCIL_CLEAR_TAG_VALUE_EXT = 0x88F3 +gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS :: GLenum +gl_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS = 0x8C29 +gl_DRAW_BUFFER12_ARB :: GLenum +gl_DRAW_BUFFER12_ARB = 0x8831 +gl_OFFSET_PROJECTIVE_TEXTURE_2D_NV :: GLenum +gl_OFFSET_PROJECTIVE_TEXTURE_2D_NV = 0x8850 +gl_VERTEX_ARRAY_OBJECT_EXT :: GLenum +gl_VERTEX_ARRAY_OBJECT_EXT = 0x9154 +gl_PN_TRIANGLES_NORMAL_MODE_ATI :: GLenum +gl_PN_TRIANGLES_NORMAL_MODE_ATI = 0x87F3 +gl_C4UB_V3F :: GLenum +gl_C4UB_V3F = 0x2A23 +gl_REPEAT :: GLenum +gl_REPEAT = 0x2901 +gl_MAX_SAMPLE_MASK_WORDS_NV :: GLenum +gl_MAX_SAMPLE_MASK_WORDS_NV = 0x8E59 +gl_STORAGE_SHARED_APPLE :: GLenum +gl_STORAGE_SHARED_APPLE = 0x85BF +gl_TEXTURE9_ARB :: GLenum +gl_TEXTURE9_ARB = 0x84C9 +gl_QUERY_BUFFER_BINDING :: GLenum +gl_QUERY_BUFFER_BINDING = 0x9193 +gl_UNSIGNED_SHORT_8_8_REV_APPLE :: GLenum +gl_UNSIGNED_SHORT_8_8_REV_APPLE = 0x85BB +gl_MAX_FRAGMENT_UNIFORM_VECTORS :: GLenum +gl_MAX_FRAGMENT_UNIFORM_VECTORS = 0x8DFD +gl_UNDEFINED_APPLE :: GLenum +gl_UNDEFINED_APPLE = 0x8A1C +gl_TABLE_TOO_LARGE_EXT :: GLenum +gl_TABLE_TOO_LARGE_EXT = 0x8031 +gl_MAX_TESS_PATCH_COMPONENTS_EXT :: GLenum +gl_MAX_TESS_PATCH_COMPONENTS_EXT = 0x8E84 +gl_XOR_NV :: GLenum +gl_XOR_NV = 0x1506 +gl_MAX_SHADER_BUFFER_ADDRESS_NV :: GLenum +gl_MAX_SHADER_BUFFER_ADDRESS_NV = 0x8F35 +gl_DEBUG_SOURCE_WINDOW_SYSTEM :: GLenum +gl_DEBUG_SOURCE_WINDOW_SYSTEM = 0x8247 +gl_UNSIGNALED_APPLE :: GLenum +gl_UNSIGNALED_APPLE = 0x9118 +gl_SIGNED_LUMINANCE_NV :: GLenum +gl_SIGNED_LUMINANCE_NV = 0x8701 +gl_FOG_DISTANCE_MODE_NV :: GLenum +gl_FOG_DISTANCE_MODE_NV = 0x855A +gl_PN_TRIANGLES_POINT_MODE_ATI :: GLenum +gl_PN_TRIANGLES_POINT_MODE_ATI = 0x87F2 +gl_GEOMETRY_SUBROUTINE_UNIFORM :: GLenum +gl_GEOMETRY_SUBROUTINE_UNIFORM = 0x92F1 +gl_NEGATIVE_Z_EXT :: GLenum +gl_NEGATIVE_Z_EXT = 0x87DB +gl_PIXEL_MAP_R_TO_R :: GLenum +gl_PIXEL_MAP_R_TO_R = 0x0C76 +gl_OBJECT_LINK_STATUS_ARB :: GLenum +gl_OBJECT_LINK_STATUS_ARB = 0x8B82 +gl_NUM_ACTIVE_VARIABLES :: GLenum +gl_NUM_ACTIVE_VARIABLES = 0x9304 +gl_BUFFER_UPDATE_BARRIER_BIT_EXT :: GLenum +gl_BUFFER_UPDATE_BARRIER_BIT_EXT = 0x00000200 +gl_IMAGE_CUBE_EXT :: GLenum +gl_IMAGE_CUBE_EXT = 0x9050 +gl_RGB_INTEGER_EXT :: GLenum +gl_RGB_INTEGER_EXT = 0x8D98 +gl_DRAW_BUFFER13_EXT :: GLenum +gl_DRAW_BUFFER13_EXT = 0x8832 +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_OBJECT_TYPE_EXT = 0x8CD0 +gl_SYNC_GPU_COMMANDS_COMPLETE_APPLE :: GLenum +gl_SYNC_GPU_COMMANDS_COMPLETE_APPLE = 0x9117 +gl_RGB_SCALE :: GLenum +gl_RGB_SCALE = 0x8573 +gl_DOUBLE_MAT3x4_EXT :: GLenum +gl_DOUBLE_MAT3x4_EXT = 0x8F4C +gl_EXP :: GLenum +gl_EXP = 0x0800 +gl_PERFMON_RESULT_AVAILABLE_AMD :: GLenum +gl_PERFMON_RESULT_AVAILABLE_AMD = 0x8BC4 +gl_STENCIL_VALUE_MASK :: GLenum +gl_STENCIL_VALUE_MASK = 0x0B93 +gl_COLOR_ATTACHMENT12_NV :: GLenum +gl_COLOR_ATTACHMENT12_NV = 0x8CEC +gl_VERTEX_STREAM2_ATI :: GLenum +gl_VERTEX_STREAM2_ATI = 0x876E +gl_MAP_COHERENT_BIT :: GLenum +gl_MAP_COHERENT_BIT = 0x0080 +gl_COMPRESSED_SIGNED_RG_RGTC2 :: GLenum +gl_COMPRESSED_SIGNED_RG_RGTC2 = 0x8DBE +gl_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER :: GLenum +gl_UNIFORM_BLOCK_REFERENCED_BY_COMPUTE_SHADER = 0x90EC +gl_FRAGMENT_PROGRAM_ARB :: GLenum +gl_FRAGMENT_PROGRAM_ARB = 0x8804 +gl_COLOR_BUFFER_BIT6_QCOM :: GLenum +gl_COLOR_BUFFER_BIT6_QCOM = 0x00000040 +gl_FLOAT_32_UNSIGNED_INT_24_8_REV_NV :: GLenum +gl_FLOAT_32_UNSIGNED_INT_24_8_REV_NV = 0x8DAD +gl_WIDE_LINE_HINT_PGI :: GLenum +gl_WIDE_LINE_HINT_PGI = 0x1A222 +gl_FRAGMENT_LIGHT4_SGIX :: GLenum +gl_FRAGMENT_LIGHT4_SGIX = 0x8410 +gl_RGBA_FLOAT_MODE_ATI :: GLenum +gl_RGBA_FLOAT_MODE_ATI = 0x8820 +gl_UNSIGNED_INT_10F_11F_11F_REV :: GLenum +gl_UNSIGNED_INT_10F_11F_11F_REV = 0x8C3B +gl_MODELVIEW1_STACK_DEPTH_EXT :: GLenum +gl_MODELVIEW1_STACK_DEPTH_EXT = 0x8502 +gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_ACTIVE_NV = 0x8E24 +gl_POINT_SIZE_MAX :: GLenum +gl_POINT_SIZE_MAX = 0x8127 +gl_ALPHA_TEST_REF_QCOM :: GLenum +gl_ALPHA_TEST_REF_QCOM = 0x0BC2 +gl_RELATIVE_HORIZONTAL_LINE_TO_NV :: GLenum +gl_RELATIVE_HORIZONTAL_LINE_TO_NV = 0x07 +gl_FILTER4_SGIS :: GLenum +gl_FILTER4_SGIS = 0x8146 +gl_TEXTURE4 :: GLenum +gl_TEXTURE4 = 0x84C4 +gl_INDEX_MATERIAL_EXT :: GLenum +gl_INDEX_MATERIAL_EXT = 0x81B8 +gl_FETCH_PER_SAMPLE_ARM :: GLenum +gl_FETCH_PER_SAMPLE_ARM = 0x8F65 +gl_VARIANT_ARRAY_TYPE_EXT :: GLenum +gl_VARIANT_ARRAY_TYPE_EXT = 0x87E7 +gl_ALPHA_MAX_SGIX :: GLenum +gl_ALPHA_MAX_SGIX = 0x8321 +gl_NUM_INSTRUCTIONS_TOTAL_ATI :: GLenum +gl_NUM_INSTRUCTIONS_TOTAL_ATI = 0x8972 +gl_TEXTURE_IMAGE_TYPE :: GLenum +gl_TEXTURE_IMAGE_TYPE = 0x8290 +gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS :: GLenum +gl_MAX_TESS_CONTROL_IMAGE_UNIFORMS = 0x90CB +gl_DRAW_BUFFER11_NV :: GLenum +gl_DRAW_BUFFER11_NV = 0x8830 +gl_SURFACE_STATE_NV :: GLenum +gl_SURFACE_STATE_NV = 0x86EB +gl_BLEND_SRC_RGB :: GLenum +gl_BLEND_SRC_RGB = 0x80C9 +gl_OBJECT_ACTIVE_UNIFORMS_ARB :: GLenum +gl_OBJECT_ACTIVE_UNIFORMS_ARB = 0x8B86 +gl_COLORDODGE_NV :: GLenum +gl_COLORDODGE_NV = 0x9299 +gl_PRIMITIVES_GENERATED_NV :: GLenum +gl_PRIMITIVES_GENERATED_NV = 0x8C87 +gl_IMAGE_2D_ARRAY :: GLenum +gl_IMAGE_2D_ARRAY = 0x9053 +gl_LOSE_CONTEXT_ON_RESET_ARB :: GLenum +gl_LOSE_CONTEXT_ON_RESET_ARB = 0x8252 +gl_RG_INTEGER :: GLenum +gl_RG_INTEGER = 0x8228 +gl_UNSIGNED_INT_SAMPLER_1D_EXT :: GLenum +gl_UNSIGNED_INT_SAMPLER_1D_EXT = 0x8DD1 +gl_REFLECTION_MAP_ARB :: GLenum +gl_REFLECTION_MAP_ARB = 0x8512 +gl_NORMAL_ARRAY_TYPE_EXT :: GLenum +gl_NORMAL_ARRAY_TYPE_EXT = 0x807E +gl_BLUE_BITS :: GLenum +gl_BLUE_BITS = 0x0D54 +gl_ATOMIC_COUNTER_BARRIER_BIT :: GLenum +gl_ATOMIC_COUNTER_BARRIER_BIT = 0x00001000 +gl_INTENSITY8I_EXT :: GLenum +gl_INTENSITY8I_EXT = 0x8D91 +gl_TEXTURE_BINDING_RECTANGLE_ARB :: GLenum +gl_TEXTURE_BINDING_RECTANGLE_ARB = 0x84F6 +gl_SCALE_BY_TWO_NV :: GLenum +gl_SCALE_BY_TWO_NV = 0x853E +gl_PACK_IMAGE_HEIGHT :: GLenum +gl_PACK_IMAGE_HEIGHT = 0x806C +gl_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL :: GLenum +gl_PERFQUERY_COUNTER_DESC_LENGTH_MAX_INTEL = 0x94FF +gl_DEPTH_COMPONENT24_SGIX :: GLenum +gl_DEPTH_COMPONENT24_SGIX = 0x81A6 +gl_NUM_FRAGMENT_CONSTANTS_ATI :: GLenum +gl_NUM_FRAGMENT_CONSTANTS_ATI = 0x896F +gl_EDGE_FLAG_ARRAY_STRIDE_EXT :: GLenum +gl_EDGE_FLAG_ARRAY_STRIDE_EXT = 0x808C +gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT :: GLenum +gl_TEXTURE_BINDING_CUBE_MAP_ARRAY_EXT = 0x900A +gl_SAMPLE_ALPHA_TO_COVERAGE_ARB :: GLenum +gl_SAMPLE_ALPHA_TO_COVERAGE_ARB = 0x809E +gl_UNPACK_SKIP_IMAGES_EXT :: GLenum +gl_UNPACK_SKIP_IMAGES_EXT = 0x806D +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL :: GLenum +gl_FRAMEBUFFER_ATTACHMENT_TEXTURE_LEVEL = 0x8CD2 +gl_RGBA8_OES :: GLenum +gl_RGBA8_OES = 0x8058 +gl_STENCIL_INDEX8_OES :: GLenum +gl_STENCIL_INDEX8_OES = 0x8D48 +gl_MAX_SPARSE_3D_TEXTURE_SIZE_AMD :: GLenum +gl_MAX_SPARSE_3D_TEXTURE_SIZE_AMD = 0x9199 +gl_COMPUTE_SHADER :: GLenum +gl_COMPUTE_SHADER = 0x91B9 +gl_QUERY_WAIT_NV :: GLenum +gl_QUERY_WAIT_NV = 0x8E13 +gl_TEXTURE_COMPARE_FUNC_ARB :: GLenum +gl_TEXTURE_COMPARE_FUNC_ARB = 0x884D +gl_SCREEN_COORDINATES_REND :: GLenum +gl_SCREEN_COORDINATES_REND = 0x8490 +gl_DRAW_BUFFER4_EXT :: GLenum +gl_DRAW_BUFFER4_EXT = 0x8829 +gl_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT :: GLenum +gl_MAX_PIXEL_TRANSFORM_2D_STACK_DEPTH_EXT = 0x8337 +gl_TOP_LEVEL_ARRAY_SIZE :: GLenum +gl_TOP_LEVEL_ARRAY_SIZE = 0x930C +gl_STATIC_COPY_ARB :: GLenum +gl_STATIC_COPY_ARB = 0x88E6 +gl_MAP1_TANGENT_EXT :: GLenum +gl_MAP1_TANGENT_EXT = 0x8444 +gl_MAP2_VERTEX_ATTRIB11_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB11_4_NV = 0x867B +gl_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX :: GLenum +gl_PIXEL_TEX_GEN_ALPHA_REPLACE_SGIX = 0x8187 +gl_DRAW_BUFFER9 :: GLenum +gl_DRAW_BUFFER9 = 0x882E +gl_COMPRESSED_INTENSITY_ARB :: GLenum +gl_COMPRESSED_INTENSITY_ARB = 0x84EC +gl_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB = 0x8516 +gl_MATRIX19_ARB :: GLenum +gl_MATRIX19_ARB = 0x88D3 +gl_MAX_MULTIVIEW_BUFFERS_EXT :: GLenum +gl_MAX_MULTIVIEW_BUFFERS_EXT = 0x90F2 +gl_CONJOINT_NV :: GLenum +gl_CONJOINT_NV = 0x9284 +gl_INTENSITY_SNORM :: GLenum +gl_INTENSITY_SNORM = 0x9013 +gl_DRAW_BUFFER14 :: GLenum +gl_DRAW_BUFFER14 = 0x8833 +gl_MAX_PROGRAM_INSTRUCTIONS_ARB :: GLenum +gl_MAX_PROGRAM_INSTRUCTIONS_ARB = 0x88A1 +gl_TEXTURE_BINDING_RECTANGLE :: GLenum +gl_TEXTURE_BINDING_RECTANGLE = 0x84F6 +gl_DEBUG_SOURCE_SHADER_COMPILER_ARB :: GLenum +gl_DEBUG_SOURCE_SHADER_COMPILER_ARB = 0x8248 +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR :: GLenum +gl_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR = 0x93DD +gl_MULTISAMPLE_EXT :: GLenum +gl_MULTISAMPLE_EXT = 0x809D +gl_NEAREST_MIPMAP_NEAREST :: GLenum +gl_NEAREST_MIPMAP_NEAREST = 0x2700 +gl_COLOR_ATTACHMENT7_EXT :: GLenum +gl_COLOR_ATTACHMENT7_EXT = 0x8CE7 +gl_STENCIL_BUFFER_BIT6_QCOM :: GLenum +gl_STENCIL_BUFFER_BIT6_QCOM = 0x00400000 +gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_SIZE_EXT = 0x8C85 +gl_REG_29_ATI :: GLenum +gl_REG_29_ATI = 0x893E +gl_COVERAGE_SAMPLES_NV :: GLenum +gl_COVERAGE_SAMPLES_NV = 0x8ED4 +gl_RELEASED_APPLE :: GLenum +gl_RELEASED_APPLE = 0x8A19 +gl_ALPHA_TEST_FUNC :: GLenum +gl_ALPHA_TEST_FUNC = 0x0BC1 +gl_DRAW_BUFFER2 :: GLenum +gl_DRAW_BUFFER2 = 0x8827 +gl_VERTEX_PROGRAM_BINDING_NV :: GLenum +gl_VERTEX_PROGRAM_BINDING_NV = 0x864A +gl_IMAGE_2D_RECT :: GLenum +gl_IMAGE_2D_RECT = 0x904F +gl_COLOR_TABLE_BIAS_SGI :: GLenum +gl_COLOR_TABLE_BIAS_SGI = 0x80D7 +gl_CLIENT_ACTIVE_TEXTURE_ARB :: GLenum +gl_CLIENT_ACTIVE_TEXTURE_ARB = 0x84E1 +gl_CURRENT_MATRIX_INDEX_ARB :: GLenum +gl_CURRENT_MATRIX_INDEX_ARB = 0x8845 +gl_TEXTURE_COORD_ARRAY_STRIDE :: GLenum +gl_TEXTURE_COORD_ARRAY_STRIDE = 0x808A +gl_FILTER :: GLenum +gl_FILTER = 0x829A +gl_MAX_MODELVIEW_STACK_DEPTH :: GLenum +gl_MAX_MODELVIEW_STACK_DEPTH = 0x0D36 +gl_VERTEX_ATTRIB_ARRAY5_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY5_NV = 0x8655 +gl_UNSIGNED_BYTE :: GLenum +gl_UNSIGNED_BYTE = 0x1401 +gl_DETAIL_TEXTURE_2D_SGIS :: GLenum +gl_DETAIL_TEXTURE_2D_SGIS = 0x8095 +gl_POST_CONVOLUTION_BLUE_BIAS :: GLenum +gl_POST_CONVOLUTION_BLUE_BIAS = 0x8022 +gl_TYPE :: GLenum +gl_TYPE = 0x92FA +gl_COMPRESSED_RG :: GLenum +gl_COMPRESSED_RG = 0x8226 +gl_4PASS_1_SGIS :: GLenum +gl_4PASS_1_SGIS = 0x80A5 +gl_SOURCE2_RGB :: GLenum +gl_SOURCE2_RGB = 0x8582 +gl_TEXTURE_MAX_LOD :: GLenum +gl_TEXTURE_MAX_LOD = 0x813B +gl_EYE_DISTANCE_TO_LINE_SGIS :: GLenum +gl_EYE_DISTANCE_TO_LINE_SGIS = 0x81F2 +gl_LUMINANCE_ALPHA32F_EXT :: GLenum +gl_LUMINANCE_ALPHA32F_EXT = 0x8819 +gl_MATRIX_INDEX_ARRAY_STRIDE_ARB :: GLenum +gl_MATRIX_INDEX_ARRAY_STRIDE_ARB = 0x8848 +gl_COLOR_ATTACHMENT4 :: GLenum +gl_COLOR_ATTACHMENT4 = 0x8CE4 +gl_INDEX_ARRAY_BUFFER_BINDING :: GLenum +gl_INDEX_ARRAY_BUFFER_BINDING = 0x8899 +gl_UNSIGNED_INT_SAMPLER_2D_ARRAY :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D_ARRAY = 0x8DD7 +gl_PIXEL_TILE_BEST_ALIGNMENT_SGIX :: GLenum +gl_PIXEL_TILE_BEST_ALIGNMENT_SGIX = 0x813E +gl_SPECULAR :: GLenum +gl_SPECULAR = 0x1202 +gl_PACK_IMAGE_DEPTH_SGIS :: GLenum +gl_PACK_IMAGE_DEPTH_SGIS = 0x8131 +gl_PLUS_CLAMPED_NV :: GLenum +gl_PLUS_CLAMPED_NV = 0x92B1 +gl_INVALID_FRAMEBUFFER_OPERATION :: GLenum +gl_INVALID_FRAMEBUFFER_OPERATION = 0x0506 +gl_RG :: GLenum +gl_RG = 0x8227 +gl_COLOR_ATTACHMENT11_NV :: GLenum +gl_COLOR_ATTACHMENT11_NV = 0x8CEB +gl_UNPACK_SKIP_PIXELS :: GLenum +gl_UNPACK_SKIP_PIXELS = 0x0CF4 +gl_SAMPLE_BUFFERS :: GLenum +gl_SAMPLE_BUFFERS = 0x80A8 +gl_DRAW_BUFFER1_ARB :: GLenum +gl_DRAW_BUFFER1_ARB = 0x8826 +gl_COMBINER6_NV :: GLenum +gl_COMBINER6_NV = 0x8556 +gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES :: GLenum +gl_TEXTURE_CUBE_MAP_NEGATIVE_Z_OES = 0x851A +gl_TEXTURE_ENV :: GLenum +gl_TEXTURE_ENV = 0x2300 +gl_QUAD_MESH_SUN :: GLenum +gl_QUAD_MESH_SUN = 0x8614 +gl_REFERENCED_BY_TESS_CONTROL_SHADER_EXT :: GLenum +gl_REFERENCED_BY_TESS_CONTROL_SHADER_EXT = 0x9307 +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV :: GLenum +gl_MAX_TRANSFORM_FEEDBACK_SEPARATE_ATTRIBS_NV = 0x8C8B +gl_TIMEOUT_EXPIRED :: GLenum +gl_TIMEOUT_EXPIRED = 0x911B +gl_FLOAT_MAT4x2_NV :: GLenum +gl_FLOAT_MAT4x2_NV = 0x8B69 +gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES :: GLenum +gl_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY_OES = 0x910D +gl_COMBINER1_NV :: GLenum +gl_COMBINER1_NV = 0x8551 +gl_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB :: GLenum +gl_MAX_PROGRAM_NATIVE_TEMPORARIES_ARB = 0x88A7 +gl_RENDERBUFFER_SAMPLES_ANGLE :: GLenum +gl_RENDERBUFFER_SAMPLES_ANGLE = 0x8CAB +gl_VERTEX_ARRAY_SIZE :: GLenum +gl_VERTEX_ARRAY_SIZE = 0x807A +gl_TEXTURE2 :: GLenum +gl_TEXTURE2 = 0x84C2 +gl_RELATIVE_MOVE_TO_NV :: GLenum +gl_RELATIVE_MOVE_TO_NV = 0x03 +gl_ALPHA_TEST_FUNC_QCOM :: GLenum +gl_ALPHA_TEST_FUNC_QCOM = 0x0BC1 +gl_INNOCENT_CONTEXT_RESET_KHR :: GLenum +gl_INNOCENT_CONTEXT_RESET_KHR = 0x8254 +gl_MAP1_VERTEX_ATTRIB5_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB5_4_NV = 0x8665 +gl_SAMPLER_1D_SHADOW :: GLenum +gl_SAMPLER_1D_SHADOW = 0x8B61 +gl_TEXTURE_1D_ARRAY_EXT :: GLenum +gl_TEXTURE_1D_ARRAY_EXT = 0x8C18 +gl_STENCIL_INDEX :: GLenum +gl_STENCIL_INDEX = 0x1901 +gl_SOURCE2_ALPHA_EXT :: GLenum +gl_SOURCE2_ALPHA_EXT = 0x858A +gl_NORMAL_MAP_EXT :: GLenum +gl_NORMAL_MAP_EXT = 0x8511 +gl_FOG_COORDINATE_SOURCE_EXT :: GLenum +gl_FOG_COORDINATE_SOURCE_EXT = 0x8450 +gl_TEXTURE_FILTER_CONTROL :: GLenum +gl_TEXTURE_FILTER_CONTROL = 0x8500 +gl_REPLACE_OLDEST_SUN :: GLenum +gl_REPLACE_OLDEST_SUN = 0x0003 +gl_PROGRAM_ADDRESS_REGISTERS_ARB :: GLenum +gl_PROGRAM_ADDRESS_REGISTERS_ARB = 0x88B0 +gl_2PASS_1_EXT :: GLenum +gl_2PASS_1_EXT = 0x80A3 +gl_LIGHT_ENV_MODE_SGIX :: GLenum +gl_LIGHT_ENV_MODE_SGIX = 0x8407 +gl_OP_FRAC_EXT :: GLenum +gl_OP_FRAC_EXT = 0x8789 +gl_PROXY_TEXTURE_RECTANGLE_NV :: GLenum +gl_PROXY_TEXTURE_RECTANGLE_NV = 0x84F7 +gl_RENDERBUFFER :: GLenum +gl_RENDERBUFFER = 0x8D41 +gl_MAP2_TEXTURE_COORD_4 :: GLenum +gl_MAP2_TEXTURE_COORD_4 = 0x0DB6 +gl_TEXTURE_BORDER_COLOR_EXT :: GLenum +gl_TEXTURE_BORDER_COLOR_EXT = 0x1004 +gl_SEPARABLE_2D :: GLenum +gl_SEPARABLE_2D = 0x8012 +gl_COMPRESSED_SRGB_S3TC_DXT1_EXT :: GLenum +gl_COMPRESSED_SRGB_S3TC_DXT1_EXT = 0x8C4C +gl_DRAW_BUFFER0_ATI :: GLenum +gl_DRAW_BUFFER0_ATI = 0x8825 +gl_TEXTURE_IMMUTABLE_LEVELS :: GLenum +gl_TEXTURE_IMMUTABLE_LEVELS = 0x82DF +gl_E_TIMES_F_NV :: GLenum +gl_E_TIMES_F_NV = 0x8531 +gl_MATRIX24_ARB :: GLenum +gl_MATRIX24_ARB = 0x88D8 +gl_PIXEL_GROUP_COLOR_SGIS :: GLenum +gl_PIXEL_GROUP_COLOR_SGIS = 0x8356 +gl_CURRENT_RASTER_COLOR :: GLenum +gl_CURRENT_RASTER_COLOR = 0x0B04 +gl_DOUBLE_MAT2x4_EXT :: GLenum +gl_DOUBLE_MAT2x4_EXT = 0x8F4A +gl_BUMP_TEX_UNITS_ATI :: GLenum +gl_BUMP_TEX_UNITS_ATI = 0x8778 +gl_FOG_COORDINATE_ARRAY_EXT :: GLenum +gl_FOG_COORDINATE_ARRAY_EXT = 0x8457 +gl_ALWAYS :: GLenum +gl_ALWAYS = 0x0207 +gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES :: GLenum +gl_MIN_FRAGMENT_INTERPOLATION_OFFSET_OES = 0x8E5B +gl_MAP2_VERTEX_4 :: GLenum +gl_MAP2_VERTEX_4 = 0x0DB8 +gl_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG :: GLenum +gl_COMPRESSED_RGBA_PVRTC_2BPPV1_IMG = 0x8C03 +gl_MODULATE_SIGNED_ADD_ATI :: GLenum +gl_MODULATE_SIGNED_ADD_ATI = 0x8745 +gl_RG8 :: GLenum +gl_RG8 = 0x822B +gl_ACTIVE_UNIFORM_BLOCKS :: GLenum +gl_ACTIVE_UNIFORM_BLOCKS = 0x8A36 +gl_MAX_SPARSE_TEXTURE_SIZE_AMD :: GLenum +gl_MAX_SPARSE_TEXTURE_SIZE_AMD = 0x9198 +gl_COLOR_ATTACHMENT11_EXT :: GLenum +gl_COLOR_ATTACHMENT11_EXT = 0x8CEB +gl_POST_CONVOLUTION_BLUE_BIAS_EXT :: GLenum +gl_POST_CONVOLUTION_BLUE_BIAS_EXT = 0x8022 +gl_BUFFER_OBJECT_APPLE :: GLenum +gl_BUFFER_OBJECT_APPLE = 0x85B3 +gl_UNIFORM_TYPE :: GLenum +gl_UNIFORM_TYPE = 0x8A37 +gl_VARIABLE_E_NV :: GLenum +gl_VARIABLE_E_NV = 0x8527 +gl_MAX_COMPUTE_ATOMIC_COUNTERS :: GLenum +gl_MAX_COMPUTE_ATOMIC_COUNTERS = 0x8265 +gl_COMPRESSED_RED_RGTC1 :: GLenum +gl_COMPRESSED_RED_RGTC1 = 0x8DBB +gl_LUMINANCE_INTEGER_EXT :: GLenum +gl_LUMINANCE_INTEGER_EXT = 0x8D9C +gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY :: GLenum +gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = 0x900F +gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE :: GLenum +gl_VERTEX_ATTRIB_ARRAY_DIVISOR_ANGLE = 0x88FE +gl_R16F_EXT :: GLenum +gl_R16F_EXT = 0x822D +gl_MATRIX4_ARB :: GLenum +gl_MATRIX4_ARB = 0x88C4 +gl_MATRIX_INDEX_ARRAY_SIZE_OES :: GLenum +gl_MATRIX_INDEX_ARRAY_SIZE_OES = 0x8846 +gl_POLYGON_STIPPLE :: GLenum +gl_POLYGON_STIPPLE = 0x0B42 +gl_DUAL_ALPHA12_SGIS :: GLenum +gl_DUAL_ALPHA12_SGIS = 0x8112 +gl_PIXEL_MAP_I_TO_B :: GLenum +gl_PIXEL_MAP_I_TO_B = 0x0C74 +gl_VERTEX_ATTRIB_ARRAY6_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY6_NV = 0x8656 +gl_REG_21_ATI :: GLenum +gl_REG_21_ATI = 0x8936 +gl_PERFMON_RESULT_SIZE_AMD :: GLenum +gl_PERFMON_RESULT_SIZE_AMD = 0x8BC5 +gl_ALPHA8_OES :: GLenum +gl_ALPHA8_OES = 0x803C +gl_OBJECT_BUFFER_USAGE_ATI :: GLenum +gl_OBJECT_BUFFER_USAGE_ATI = 0x8765 +gl_PATH_STENCIL_FUNC_NV :: GLenum +gl_PATH_STENCIL_FUNC_NV = 0x90B7 +gl_TEXTURE12_ARB :: GLenum +gl_TEXTURE12_ARB = 0x84CC +gl_DEPTH_COMPONENT16_OES :: GLenum +gl_DEPTH_COMPONENT16_OES = 0x81A5 +gl_MODELVIEW20_ARB :: GLenum +gl_MODELVIEW20_ARB = 0x8734 +gl_ALPHA12 :: GLenum +gl_ALPHA12 = 0x803D +gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT :: GLenum +gl_TEXTURE_BUFFER_OFFSET_ALIGNMENT_EXT = 0x919F +gl_MODULATE_ADD_ATI :: GLenum +gl_MODULATE_ADD_ATI = 0x8744 +gl_CLAMP_TO_BORDER_EXT :: GLenum +gl_CLAMP_TO_BORDER_EXT = 0x812D +gl_CONSTANT_EXT :: GLenum +gl_CONSTANT_EXT = 0x8576 +gl_OP_LOG_BASE_2_EXT :: GLenum +gl_OP_LOG_BASE_2_EXT = 0x8792 +gl_SET_AMD :: GLenum +gl_SET_AMD = 0x874A +gl_ONE_MINUS_SRC_ALPHA :: GLenum +gl_ONE_MINUS_SRC_ALPHA = 0x0303 +gl_COMPRESSED_LUMINANCE_ALPHA_ARB :: GLenum +gl_COMPRESSED_LUMINANCE_ALPHA_ARB = 0x84EB +gl_MAX_SERVER_WAIT_TIMEOUT_APPLE :: GLenum +gl_MAX_SERVER_WAIT_TIMEOUT_APPLE = 0x9111 +gl_LINE_TOKEN :: GLenum +gl_LINE_TOKEN = 0x0702 +gl_PROXY_POST_CONVOLUTION_COLOR_TABLE :: GLenum +gl_PROXY_POST_CONVOLUTION_COLOR_TABLE = 0x80D4 +gl_TEXTURE_BINDING_3D :: GLenum +gl_TEXTURE_BINDING_3D = 0x806A +gl_INTENSITY16I_EXT :: GLenum +gl_INTENSITY16I_EXT = 0x8D8B +gl_DEPENDENT_AR_TEXTURE_2D_NV :: GLenum +gl_DEPENDENT_AR_TEXTURE_2D_NV = 0x86E9 +gl_CURRENT_RASTER_NORMAL_SGIX :: GLenum +gl_CURRENT_RASTER_NORMAL_SGIX = 0x8406 +gl_TEXTURE_INTENSITY_TYPE :: GLenum +gl_TEXTURE_INTENSITY_TYPE = 0x8C15 +gl_TEXTURE_STORAGE_SPARSE_BIT_AMD :: GLenum +gl_TEXTURE_STORAGE_SPARSE_BIT_AMD = 0x00000001 +gl_RENDERBUFFER_INTERNAL_FORMAT_EXT :: GLenum +gl_RENDERBUFFER_INTERNAL_FORMAT_EXT = 0x8D44 +gl_VERTEX_ATTRIB_ARRAY1_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY1_NV = 0x8651 +gl_TEXTURE_RED_SIZE :: GLenum +gl_TEXTURE_RED_SIZE = 0x805C +gl_CURRENT_COLOR :: GLenum +gl_CURRENT_COLOR = 0x0B00 +gl_COMPRESSED_RGBA_ASTC_8x5_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_8x5_KHR = 0x93B5 +gl_STENCIL_BUFFER_BIT7_QCOM :: GLenum +gl_STENCIL_BUFFER_BIT7_QCOM = 0x00800000 +gl_CLIP_PLANE0_IMG :: GLenum +gl_CLIP_PLANE0_IMG = 0x3000 +gl_ALPHA_TEST_REF :: GLenum +gl_ALPHA_TEST_REF = 0x0BC2 +gl_POINT_SMOOTH :: GLenum +gl_POINT_SMOOTH = 0x0B10 +gl_WEIGHT_ARRAY_SIZE_OES :: GLenum +gl_WEIGHT_ARRAY_SIZE_OES = 0x86AB +gl_DECODE_EXT :: GLenum +gl_DECODE_EXT = 0x8A49 +gl_SPARSE_BUFFER_PAGE_SIZE_ARB :: GLenum +gl_SPARSE_BUFFER_PAGE_SIZE_ARB = 0x82F8 +gl_CLIENT_ATTRIB_STACK_DEPTH :: GLenum +gl_CLIENT_ATTRIB_STACK_DEPTH = 0x0BB1 +gl_TEXTURE_BINDING_EXTERNAL_OES :: GLenum +gl_TEXTURE_BINDING_EXTERNAL_OES = 0x8D67 +gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT :: GLenum +gl_MAX_TESS_EVALUATION_UNIFORM_BLOCKS_EXT = 0x8E8A +gl_RENDERBUFFER_STENCIL_SIZE_OES :: GLenum +gl_RENDERBUFFER_STENCIL_SIZE_OES = 0x8D55 +gl_POST_COLOR_MATRIX_ALPHA_BIAS :: GLenum +gl_POST_COLOR_MATRIX_ALPHA_BIAS = 0x80BB +gl_COMPARE_REF_DEPTH_TO_TEXTURE_EXT :: GLenum +gl_COMPARE_REF_DEPTH_TO_TEXTURE_EXT = 0x884E +gl_HSL_LUMINOSITY_KHR :: GLenum +gl_HSL_LUMINOSITY_KHR = 0x92B0 +gl_MAX_VERTEX_STREAMS_ATI :: GLenum +gl_MAX_VERTEX_STREAMS_ATI = 0x876B +gl_PERFQUERY_COUNTER_THROUGHPUT_INTEL :: GLenum +gl_PERFQUERY_COUNTER_THROUGHPUT_INTEL = 0x94F3 +gl_COMPRESSED_SIGNED_RED_RGTC1_EXT :: GLenum +gl_COMPRESSED_SIGNED_RED_RGTC1_EXT = 0x8DBC +gl_DEPTH_COMPONENT32_OES :: GLenum +gl_DEPTH_COMPONENT32_OES = 0x81A7 +gl_CON_3_ATI :: GLenum +gl_CON_3_ATI = 0x8944 +gl_COMPRESSED_RGBA_S3TC_DXT1_EXT :: GLenum +gl_COMPRESSED_RGBA_S3TC_DXT1_EXT = 0x83F1 +gl_MATRIX6_ARB :: GLenum +gl_MATRIX6_ARB = 0x88C6 +gl_MAP2_VERTEX_ATTRIB5_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB5_4_NV = 0x8675 +gl_LINE_WIDTH_RANGE :: GLenum +gl_LINE_WIDTH_RANGE = 0x0B22 +gl_GLYPH_VERTICAL_BEARING_X_BIT_NV :: GLenum +gl_GLYPH_VERTICAL_BEARING_X_BIT_NV = 0x20 +gl_FOG_COORDINATE_ARRAY :: GLenum +gl_FOG_COORDINATE_ARRAY = 0x8457 +gl_VERTEX_ARRAY_RANGE_LENGTH_APPLE :: GLenum +gl_VERTEX_ARRAY_RANGE_LENGTH_APPLE = 0x851E +gl_CLAMP_FRAGMENT_COLOR :: GLenum +gl_CLAMP_FRAGMENT_COLOR = 0x891B +gl_COMPRESSED_RGBA_ASTC_10x5_KHR :: GLenum +gl_COMPRESSED_RGBA_ASTC_10x5_KHR = 0x93B8 +gl_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB :: GLenum +gl_TEXTURE_BUFFER_DATA_STORE_BINDING_ARB = 0x8C2D +gl_COLOR_BUFFER_BIT4_QCOM :: GLenum +gl_COLOR_BUFFER_BIT4_QCOM = 0x00000010 +gl_TEXTURE13 :: GLenum +gl_TEXTURE13 = 0x84CD +gl_MAX_DEBUG_MESSAGE_LENGTH_AMD :: GLenum +gl_MAX_DEBUG_MESSAGE_LENGTH_AMD = 0x9143 +gl_EVAL_VERTEX_ATTRIB0_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB0_NV = 0x86C6 +gl_ALPHA_MIN_CLAMP_INGR :: GLenum +gl_ALPHA_MIN_CLAMP_INGR = 0x8563 +gl_SUB_ATI :: GLenum +gl_SUB_ATI = 0x8965 +gl_SECONDARY_COLOR_ARRAY_LIST_IBM :: GLenum +gl_SECONDARY_COLOR_ARRAY_LIST_IBM = 103077 +gl_RGBA_INTEGER_MODE_EXT :: GLenum +gl_RGBA_INTEGER_MODE_EXT = 0x8D9E +gl_DEBUG_TYPE_MARKER_KHR :: GLenum +gl_DEBUG_TYPE_MARKER_KHR = 0x8268 +gl_VERTEX_ATTRIB_ARRAY14_NV :: GLenum +gl_VERTEX_ATTRIB_ARRAY14_NV = 0x865E +gl_TEXTURE_MIN_LOD :: GLenum +gl_TEXTURE_MIN_LOD = 0x813A +gl_INDEX_TEST_REF_EXT :: GLenum +gl_INDEX_TEST_REF_EXT = 0x81B7 +gl_AUX0 :: GLenum +gl_AUX0 = 0x0409 +gl_UNSIGNED_INT_IMAGE_2D_RECT :: GLenum +gl_UNSIGNED_INT_IMAGE_2D_RECT = 0x9065 +gl_2_BYTES :: GLenum +gl_2_BYTES = 0x1407 +gl_UNDEFINED_VERTEX :: GLenum +gl_UNDEFINED_VERTEX = 0x8260 +gl_LINE_STIPPLE_PATTERN :: GLenum +gl_LINE_STIPPLE_PATTERN = 0x0B25 +gl_FRAMEBUFFER_SRGB_CAPABLE_EXT :: GLenum +gl_FRAMEBUFFER_SRGB_CAPABLE_EXT = 0x8DBA +gl_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB :: GLenum +gl_MAX_PROGRAM_TEXTURE_GATHER_COMPONENTS_ARB = 0x8F9F +gl_UNSIGNED_INT_SAMPLER_1D_ARRAY :: GLenum +gl_UNSIGNED_INT_SAMPLER_1D_ARRAY = 0x8DD6 +gl_LOAD :: GLenum +gl_LOAD = 0x0101 +gl_SIGNED_ALPHA8_NV :: GLenum +gl_SIGNED_ALPHA8_NV = 0x8706 +gl_STENCIL_INDEX8_EXT :: GLenum +gl_STENCIL_INDEX8_EXT = 0x8D48 +gl_VIEW_CLASS_24_BITS :: GLenum +gl_VIEW_CLASS_24_BITS = 0x82C9 +gl_SHADER_STORAGE_BARRIER_BIT :: GLenum +gl_SHADER_STORAGE_BARRIER_BIT = 0x00002000 +gl_UNSIGNED_INT_SAMPLER_BUFFER_AMD :: GLenum +gl_UNSIGNED_INT_SAMPLER_BUFFER_AMD = 0x9003 +gl_IMAGE_BINDING_LAYER :: GLenum +gl_IMAGE_BINDING_LAYER = 0x8F3D +gl_MULTISAMPLE_FILTER_HINT_NV :: GLenum +gl_MULTISAMPLE_FILTER_HINT_NV = 0x8534 +gl_SPARE1_NV :: GLenum +gl_SPARE1_NV = 0x852F +gl_MAP_READ_BIT_EXT :: GLenum +gl_MAP_READ_BIT_EXT = 0x0001 +gl_COMPRESSED_LUMINANCE :: GLenum +gl_COMPRESSED_LUMINANCE = 0x84EA +gl_COMPRESSED_TEXTURE_FORMATS :: GLenum +gl_COMPRESSED_TEXTURE_FORMATS = 0x86A3 +gl_UNIFORM_IS_ROW_MAJOR :: GLenum +gl_UNIFORM_IS_ROW_MAJOR = 0x8A3E +gl_OFFSET_TEXTURE_2D_SCALE_NV :: GLenum +gl_OFFSET_TEXTURE_2D_SCALE_NV = 0x86E2 +gl_RGBA_DXT5_S3TC :: GLenum +gl_RGBA_DXT5_S3TC = 0x83A4 +gl_MAX_PROGRAM_LOCAL_PARAMETERS_ARB :: GLenum +gl_MAX_PROGRAM_LOCAL_PARAMETERS_ARB = 0x88B4 +gl_MAX_UNIFORM_BUFFER_BINDINGS :: GLenum +gl_MAX_UNIFORM_BUFFER_BINDINGS = 0x8A2F +gl_RGB16UI_EXT :: GLenum +gl_RGB16UI_EXT = 0x8D77 +gl_TEXTURE_COMPARE_OPERATOR_SGIX :: GLenum +gl_TEXTURE_COMPARE_OPERATOR_SGIX = 0x819B +gl_VIDEO_BUFFER_PITCH_NV :: GLenum +gl_VIDEO_BUFFER_PITCH_NV = 0x9028 +gl_RELATIVE_RECT_NV :: GLenum +gl_RELATIVE_RECT_NV = 0xF7 +gl_DRAW_BUFFER8_ATI :: GLenum +gl_DRAW_BUFFER8_ATI = 0x882D +gl_SRC_COLOR :: GLenum +gl_SRC_COLOR = 0x0300 +gl_SHADER_OBJECT_EXT :: GLenum +gl_SHADER_OBJECT_EXT = 0x8B48 +gl_GUILTY_CONTEXT_RESET_KHR :: GLenum +gl_GUILTY_CONTEXT_RESET_KHR = 0x8253 +gl_EVAL_VERTEX_ATTRIB5_NV :: GLenum +gl_EVAL_VERTEX_ATTRIB5_NV = 0x86CB +gl_PALETTE4_RGBA4_OES :: GLenum +gl_PALETTE4_RGBA4_OES = 0x8B93 +gl_LUMINANCE12_EXT :: GLenum +gl_LUMINANCE12_EXT = 0x8041 +gl_DONT_CARE :: GLenum +gl_DONT_CARE = 0x1100 +gl_TEXTURE_BUFFER :: GLenum +gl_TEXTURE_BUFFER = 0x8C2A +gl_COMPRESSED_RGBA_ASTC_4x4x4_OES :: GLenum +gl_COMPRESSED_RGBA_ASTC_4x4x4_OES = 0x93C3 +gl_TEXTURE_BINDING_1D_ARRAY :: GLenum +gl_TEXTURE_BINDING_1D_ARRAY = 0x8C1C +gl_SEPARATE_SPECULAR_COLOR :: GLenum +gl_SEPARATE_SPECULAR_COLOR = 0x81FA +gl_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED :: GLenum +gl_PRIMITIVE_RESTART_FOR_PATCHES_SUPPORTED = 0x8221 +gl_NORMAL_ARRAY_LIST_IBM :: GLenum +gl_NORMAL_ARRAY_LIST_IBM = 103071 +gl_CURRENT_MATRIX_STACK_DEPTH_NV :: GLenum +gl_CURRENT_MATRIX_STACK_DEPTH_NV = 0x8640 +gl_INT_IMAGE_3D :: GLenum +gl_INT_IMAGE_3D = 0x9059 +gl_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV :: GLenum +gl_DOT_PRODUCT_CONST_EYE_REFLECT_CUBE_MAP_NV = 0x86F3 +gl_CONTEXT_FLAG_DEBUG_BIT :: GLenum +gl_CONTEXT_FLAG_DEBUG_BIT = 0x00000002 +gl_WEIGHT_ARRAY_BUFFER_BINDING_ARB :: GLenum +gl_WEIGHT_ARRAY_BUFFER_BINDING_ARB = 0x889E +gl_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX :: GLenum +gl_UNIFORM_ATOMIC_COUNTER_BUFFER_INDEX = 0x92DA +gl_VECTOR_EXT :: GLenum +gl_VECTOR_EXT = 0x87BF +gl_TEXTURE_BUFFER_DATA_STORE_BINDING :: GLenum +gl_TEXTURE_BUFFER_DATA_STORE_BINDING = 0x8C2D +gl_TEXTURE_LOD_BIAS :: GLenum +gl_TEXTURE_LOD_BIAS = 0x8501 +gl_GEOMETRY_SHADER_EXT :: GLenum +gl_GEOMETRY_SHADER_EXT = 0x8DD9 +gl_TEXTURE30 :: GLenum +gl_TEXTURE30 = 0x84DE +gl_VERTEX_SHADER_BIT :: GLenum +gl_VERTEX_SHADER_BIT = 0x00000001 +gl_HISTOGRAM_BLUE_SIZE_EXT :: GLenum +gl_HISTOGRAM_BLUE_SIZE_EXT = 0x802A +gl_PATH_COMMAND_COUNT_NV :: GLenum +gl_PATH_COMMAND_COUNT_NV = 0x909D +gl_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV :: GLenum +gl_VIDEO_CAPTURE_FIELD_LOWER_HEIGHT_NV = 0x903B +gl_STENCIL_TAG_BITS_EXT :: GLenum +gl_STENCIL_TAG_BITS_EXT = 0x88F2 +gl_MAX_PROGRAM_LOOP_DEPTH_NV :: GLenum +gl_MAX_PROGRAM_LOOP_DEPTH_NV = 0x88F7 +gl_FLOAT_MAT2x3_NV :: GLenum +gl_FLOAT_MAT2x3_NV = 0x8B65 +gl_CURRENT_RASTER_DISTANCE :: GLenum +gl_CURRENT_RASTER_DISTANCE = 0x0B09 +gl_COMPRESSED_SRGB8_ETC2_OES :: GLenum +gl_COMPRESSED_SRGB8_ETC2_OES = 0x9275 +gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES :: GLenum +gl_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2_OES = 0x9276 +gl_PIXEL_MAP_I_TO_G_SIZE :: GLenum +gl_PIXEL_MAP_I_TO_G_SIZE = 0x0CB3 +gl_COMBINE :: GLenum +gl_COMBINE = 0x8570 +gl_FOG_HINT :: GLenum +gl_FOG_HINT = 0x0C54 +gl_COMPUTE_SUBROUTINE_UNIFORM :: GLenum +gl_COMPUTE_SUBROUTINE_UNIFORM = 0x92F3 +gl_FRAGMENT_LIGHT3_SGIX :: GLenum +gl_FRAGMENT_LIGHT3_SGIX = 0x840F +gl_DEBUG_TYPE_PORTABILITY_ARB :: GLenum +gl_DEBUG_TYPE_PORTABILITY_ARB = 0x824F +gl_MIN_PROGRAM_TEXEL_OFFSET_EXT :: GLenum +gl_MIN_PROGRAM_TEXEL_OFFSET_EXT = 0x8904 +gl_TRANSFORM_FEEDBACK_BUFFER_NV :: GLenum +gl_TRANSFORM_FEEDBACK_BUFFER_NV = 0x8C8E +gl_UNKNOWN_CONTEXT_RESET_EXT :: GLenum +gl_UNKNOWN_CONTEXT_RESET_EXT = 0x8255 +gl_INT_SAMPLER_CUBE_MAP_ARRAY_ARB :: GLenum +gl_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900E +gl_UNSIGNED_INT_24_8_NV :: GLenum +gl_UNSIGNED_INT_24_8_NV = 0x84FA +gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY :: GLenum +gl_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = 0x906C +gl_MANUAL_GENERATE_MIPMAP :: GLenum +gl_MANUAL_GENERATE_MIPMAP = 0x8294 +gl_MAP2_VERTEX_ATTRIB6_4_NV :: GLenum +gl_MAP2_VERTEX_ATTRIB6_4_NV = 0x8676 +gl_FRAMEBUFFER_EXT :: GLenum +gl_FRAMEBUFFER_EXT = 0x8D40 +gl_INT16_NV :: GLenum +gl_INT16_NV = 0x8FE4 +gl_FULL_RANGE_EXT :: GLenum +gl_FULL_RANGE_EXT = 0x87E1 +gl_MAP1_VERTEX_ATTRIB2_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB2_4_NV = 0x8662 +gl_UNSIGNED_INT_8_8_8_8_EXT :: GLenum +gl_UNSIGNED_INT_8_8_8_8_EXT = 0x8035 +gl_TESS_CONTROL_SUBROUTINE_UNIFORM :: GLenum +gl_TESS_CONTROL_SUBROUTINE_UNIFORM = 0x92EF +gl_PREVIOUS_TEXTURE_INPUT_NV :: GLenum +gl_PREVIOUS_TEXTURE_INPUT_NV = 0x86E4 +gl_ATOMIC_COUNTER_BUFFER_DATA_SIZE :: GLenum +gl_ATOMIC_COUNTER_BUFFER_DATA_SIZE = 0x92C4 +gl_SYNC_STATUS_APPLE :: GLenum +gl_SYNC_STATUS_APPLE = 0x9114 +gl_4PASS_0_EXT :: GLenum +gl_4PASS_0_EXT = 0x80A4 +gl_POLYGON_SMOOTH :: GLenum +gl_POLYGON_SMOOTH = 0x0B41 +gl_FEEDBACK_BUFFER_SIZE :: GLenum +gl_FEEDBACK_BUFFER_SIZE = 0x0DF1 +gl_COLORBURN_KHR :: GLenum +gl_COLORBURN_KHR = 0x929A +gl_DEPTH24_STENCIL8 :: GLenum +gl_DEPTH24_STENCIL8 = 0x88F0 +gl_LINEAR_CLIPMAP_LINEAR_SGIX :: GLenum +gl_LINEAR_CLIPMAP_LINEAR_SGIX = 0x8170 +gl_TEXTURE_MAX_LEVEL :: GLenum +gl_TEXTURE_MAX_LEVEL = 0x813D +gl_TEXTURE_WRAP_R_EXT :: GLenum +gl_TEXTURE_WRAP_R_EXT = 0x8072 +gl_OBJECT_SUBTYPE_ARB :: GLenum +gl_OBJECT_SUBTYPE_ARB = 0x8B4F +gl_MATRIX18_ARB :: GLenum +gl_MATRIX18_ARB = 0x88D2 +gl_MATRIX_INDEX_ARRAY_POINTER_OES :: GLenum +gl_MATRIX_INDEX_ARRAY_POINTER_OES = 0x8849 +gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB :: GLenum +gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB = 0x824E +gl_ALPHA8_SNORM :: GLenum +gl_ALPHA8_SNORM = 0x9014 +gl_TESS_CONTROL_SUBROUTINE :: GLenum +gl_TESS_CONTROL_SUBROUTINE = 0x92E9 +gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB :: GLenum +gl_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY_ARB = 0x900F +gl_POST_CONVOLUTION_ALPHA_SCALE_EXT :: GLenum +gl_POST_CONVOLUTION_ALPHA_SCALE_EXT = 0x801F +gl_RGB5_A1_EXT :: GLenum +gl_RGB5_A1_EXT = 0x8057 +gl_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS :: GLenum +gl_MAX_ATOMIC_COUNTER_BUFFER_BINDINGS = 0x92DC +gl_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM :: GLenum +gl_RENDER_DIRECT_TO_FRAMEBUFFER_QCOM = 0x8FB3 +gl_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV :: GLenum +gl_DEPENDENT_RGB_TEXTURE_CUBE_MAP_NV = 0x885A +gl_TEXTURE21_ARB :: GLenum +gl_TEXTURE21_ARB = 0x84D5 +gl_SAMPLER_2D_RECT_SHADOW :: GLenum +gl_SAMPLER_2D_RECT_SHADOW = 0x8B64 +gl_DEPTH_STENCIL_TEXTURE_MODE :: GLenum +gl_DEPTH_STENCIL_TEXTURE_MODE = 0x90EA +gl_MAP1_VERTEX_ATTRIB10_4_NV :: GLenum +gl_MAP1_VERTEX_ATTRIB10_4_NV = 0x866A +gl_PINLIGHT_NV :: GLenum +gl_PINLIGHT_NV = 0x92A8 +gl_TEXTURE_INTERNAL_FORMAT :: GLenum +gl_TEXTURE_INTERNAL_FORMAT = 0x1003 +gl_VERTEX_ARRAY_OBJECT_AMD :: GLenum +gl_VERTEX_ARRAY_OBJECT_AMD = 0x9154 +gl_OBJECT_LINEAR :: GLenum +gl_OBJECT_LINEAR = 0x2401 +gl_TEXTURE_IMMUTABLE_FORMAT_EXT :: GLenum +gl_TEXTURE_IMMUTABLE_FORMAT_EXT = 0x912F +gl_COMBINER_COMPONENT_USAGE_NV :: GLenum +gl_COMBINER_COMPONENT_USAGE_NV = 0x8544 +gl_RENDERBUFFER_GREEN_SIZE_EXT :: GLenum +gl_RENDERBUFFER_GREEN_SIZE_EXT = 0x8D51 +gl_CONVOLUTION_FILTER_SCALE :: GLenum +gl_CONVOLUTION_FILTER_SCALE = 0x8014 +gl_TEXTURE11 :: GLenum +gl_TEXTURE11 = 0x84CB +gl_BITMAP :: GLenum +gl_BITMAP = 0x1A00 +gl_VIEW_COMPATIBILITY_CLASS :: GLenum +gl_VIEW_COMPATIBILITY_CLASS = 0x82B6 +gl_TEXTURE26 :: GLenum +gl_TEXTURE26 = 0x84DA +gl_UNSIGNED_INT8_VEC4_NV :: GLenum +gl_UNSIGNED_INT8_VEC4_NV = 0x8FEF +gl_UNSIGNED_INT_VEC3 :: GLenum +gl_UNSIGNED_INT_VEC3 = 0x8DC7 +gl_VERTEX_PRECLIP_SGIX :: GLenum +gl_VERTEX_PRECLIP_SGIX = 0x83EE +gl_PACK_LSB_FIRST :: GLenum +gl_PACK_LSB_FIRST = 0x0D01 +gl_NEGATIVE_Y_EXT :: GLenum +gl_NEGATIVE_Y_EXT = 0x87DA +gl_FRAMEBUFFER_BINDING_ANGLE :: GLenum +gl_FRAMEBUFFER_BINDING_ANGLE = 0x8CA6 +gl_MAP_INVALIDATE_BUFFER_BIT_EXT :: GLenum +gl_MAP_INVALIDATE_BUFFER_BIT_EXT = 0x0008 +gl_NO_RESET_NOTIFICATION :: GLenum +gl_NO_RESET_NOTIFICATION = 0x8261 +gl_MINMAX_EXT :: GLenum +gl_MINMAX_EXT = 0x802E +gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST :: GLenum +gl_SIMULTANEOUS_TEXTURE_AND_DEPTH_TEST = 0x82AC +gl_QUARTER_BIT_ATI :: GLenum +gl_QUARTER_BIT_ATI = 0x00000010 +gl_TEXTURE9 :: GLenum +gl_TEXTURE9 = 0x84C9 +gl_FLOAT_R16_NV :: GLenum +gl_FLOAT_R16_NV = 0x8884 +gl_BLEND_ADVANCED_COHERENT_KHR :: GLenum +gl_BLEND_ADVANCED_COHERENT_KHR = 0x9285 +gl_MATRIX_INDEX_ARRAY_POINTER_ARB :: GLenum +gl_MATRIX_INDEX_ARRAY_POINTER_ARB = 0x8849 +gl_PROXY_TEXTURE_1D_EXT :: GLenum +gl_PROXY_TEXTURE_1D_EXT = 0x8063 +gl_PERTURB_EXT :: GLenum +gl_PERTURB_EXT = 0x85AE +gl_IUI_N3F_V3F_EXT :: GLenum +gl_IUI_N3F_V3F_EXT = 0x81B0 +gl_COMBINE_RGB_ARB :: GLenum +gl_COMBINE_RGB_ARB = 0x8571 +gl_DEBUG_SOURCE_APPLICATION_KHR :: GLenum +gl_DEBUG_SOURCE_APPLICATION_KHR = 0x824A +gl_MAX_GEOMETRY_UNIFORM_COMPONENTS :: GLenum +gl_MAX_GEOMETRY_UNIFORM_COMPONENTS = 0x8DDF +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE :: GLenum +gl_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_ANGLE = 0x8D56 +gl_PROGRAM_ALU_INSTRUCTIONS_ARB :: GLenum +gl_PROGRAM_ALU_INSTRUCTIONS_ARB = 0x8805 +gl_VERTEX_STREAM0_ATI :: GLenum +gl_VERTEX_STREAM0_ATI = 0x876C +gl_EDGE_FLAG_ARRAY_POINTER_EXT :: GLenum +gl_EDGE_FLAG_ARRAY_POINTER_EXT = 0x8093 +gl_INT_IMAGE_2D_EXT :: GLenum +gl_INT_IMAGE_2D_EXT = 0x9058 +gl_READ_FRAMEBUFFER_BINDING_EXT :: GLenum +gl_READ_FRAMEBUFFER_BINDING_EXT = 0x8CAA +gl_TEXTURE_CUBE_MAP_ARB :: GLenum +gl_TEXTURE_CUBE_MAP_ARB = 0x8513 +gl_LUMINANCE12_ALPHA12 :: GLenum +gl_LUMINANCE12_ALPHA12 = 0x8047 +gl_FUNC_ADD :: GLenum +gl_FUNC_ADD = 0x8006 +gl_TRANSPOSE_COLOR_MATRIX_ARB :: GLenum +gl_TRANSPOSE_COLOR_MATRIX_ARB = 0x84E6 +gl_COLOR_ATTACHMENT6 :: GLenum +gl_COLOR_ATTACHMENT6 = 0x8CE6 +gl_GEOMETRY_SUBROUTINE :: GLenum +gl_GEOMETRY_SUBROUTINE = 0x92EB +gl_MAX_ELEMENT_INDEX :: GLenum +gl_MAX_ELEMENT_INDEX = 0x8D6B +gl_QUERY_OBJECT_AMD :: GLenum +gl_QUERY_OBJECT_AMD = 0x9153 +gl_TEXTURE_CUBE_MAP_EXT :: GLenum +gl_TEXTURE_CUBE_MAP_EXT = 0x8513 +gl_CONSTANT_ATTENUATION :: GLenum +gl_CONSTANT_ATTENUATION = 0x1207 +gl_LUMINANCE_FLOAT32_APPLE :: GLenum +gl_LUMINANCE_FLOAT32_APPLE = 0x8818 +gl_R32UI :: GLenum +gl_R32UI = 0x8236 +gl_UNSIGNED_INT_VEC4_EXT :: GLenum +gl_UNSIGNED_INT_VEC4_EXT = 0x8DC8 +gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT :: GLenum +gl_QUADS_FOLLOW_PROVOKING_VERTEX_CONVENTION_EXT = 0x8E4C +gl_SAMPLE_MASK_VALUE :: GLenum +gl_SAMPLE_MASK_VALUE = 0x8E52 +gl_STRICT_DEPTHFUNC_HINT_PGI :: GLenum +gl_STRICT_DEPTHFUNC_HINT_PGI = 0x1A216 +gl_CONVOLUTION_HEIGHT_EXT :: GLenum +gl_CONVOLUTION_HEIGHT_EXT = 0x8019 +gl_DEPTH_BUFFER_BIT1_QCOM :: GLenum +gl_DEPTH_BUFFER_BIT1_QCOM = 0x00000200 +gl_CLIP_DISTANCE_NV :: GLenum +gl_CLIP_DISTANCE_NV = 0x8C7A +gl_DISPATCH_INDIRECT_BUFFER :: GLenum +gl_DISPATCH_INDIRECT_BUFFER = 0x90EE +gl_LUMINANCE4 :: GLenum +gl_LUMINANCE4 = 0x803F +gl_CLAMP :: GLenum +gl_CLAMP = 0x2900 +gl_CONVOLUTION_FORMAT :: GLenum +gl_CONVOLUTION_FORMAT = 0x8017 +gl_IMAGE_2D_MULTISAMPLE :: GLenum +gl_IMAGE_2D_MULTISAMPLE = 0x9055 +gl_TRIANGLE_STRIP :: GLenum +gl_TRIANGLE_STRIP = 0x0005 +gl_BGRA_INTEGER_EXT :: GLenum +gl_BGRA_INTEGER_EXT = 0x8D9B +gl_FRAGMENTS_INSTRUMENT_MAX_SGIX :: GLenum +gl_FRAGMENTS_INSTRUMENT_MAX_SGIX = 0x8315 +gl_TESS_CONTROL_SHADER_BIT :: GLenum +gl_TESS_CONTROL_SHADER_BIT = 0x00000008 +gl_POINT_SIZE_ARRAY_BUFFER_BINDING_OES :: GLenum +gl_POINT_SIZE_ARRAY_BUFFER_BINDING_OES = 0x8B9F +gl_BACK_NORMALS_HINT_PGI :: GLenum +gl_BACK_NORMALS_HINT_PGI = 0x1A223 +gl_FOG_COORD_ARRAY :: GLenum +gl_FOG_COORD_ARRAY = 0x8457 +gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR :: GLenum +gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR_KHR = 0x824D +gl_OPERAND1_RGB_EXT :: GLenum +gl_OPERAND1_RGB_EXT = 0x8591 +gl_LINEAR_SHARPEN_COLOR_SGIS :: GLenum +gl_LINEAR_SHARPEN_COLOR_SGIS = 0x80AF +gl_POST_TEXTURE_FILTER_SCALE_SGIX :: GLenum +gl_POST_TEXTURE_FILTER_SCALE_SGIX = 0x817A +gl_FRAMEBUFFER_COMPLETE_OES :: GLenum +gl_FRAMEBUFFER_COMPLETE_OES = 0x8CD5 +gl_SYNC_OBJECT_APPLE :: GLenum +gl_SYNC_OBJECT_APPLE = 0x8A53 +gl_INDEX_WRITEMASK :: GLenum +gl_INDEX_WRITEMASK = 0x0C21 +gl_SIGNED_INTENSITY_NV :: GLenum +gl_SIGNED_INTENSITY_NV = 0x8707 +gl_SGX_PROGRAM_BINARY_IMG :: GLenum +gl_SGX_PROGRAM_BINARY_IMG = 0x9130 +gl_T4F_V4F :: GLenum +gl_T4F_V4F = 0x2A28 + +data GLsyncob +type GLsync = Ptr GLsyncob + +type GLhalf = Word16 +type GLhalfARB = Word16 +type GLintptrARB = CPtrdiff +type GLsizeiptrARB = CPtrdiff +type GLDEBUGPROC = + FunPtr (GLenum -> GLenum -> GLuint -> GLenum -> GLsizei -> Ptr GLchar -> Ptr () -> IO ()) +type GLDEBUGPROCARB = GLDEBUGPROC +type GLDEBUGPROCKHR = GLDEBUGPROC +type GLDEBUGPROCAMD = + FunPtr (GLuint -> GLenum -> GLenum -> GLsizei -> Ptr GLchar -> Ptr () -> IO ()) +type GLbyte = CChar +type GLubyte = CUChar +type GLfloat = CFloat +type GLclampf = CFloat +type GLfixed = Int32 +type GLint64 = Int64 +type GLuint64 = Word64 +type GLint64EXT = Int64 +type GLuint64EXT = Word64 +type GLintptr = CIntPtr +type GLsizeiptr = CSize +type GLhalfNV = CUShort +type GLvdpauSurfaceNV = GLintptr +type GLenum = CUInt +type GLboolean = CUChar +type GLvoid = () +type GLbitfield = CUInt +type GLshort = CShort +type GLint = CInt +type GLclampx = CInt +type GLushort = CUShort +type GLuint = CUInt +type GLsizei = CInt +type GLdouble = CDouble +type GLclampd = CDouble +data GLeglImageOESob +type GLeglImageOES = Ptr GLeglImageOESob +type GLchar = CChar +type GLcharARB = CChar +#ifdef __APPLE__ +type GLhandleARB = Ptr () +#else +type GLhandleARB = CUInt +#endif + diff --git a/src/Caramia/Internal/Lens.hs b/src/Caramia/Internal/Lens.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Internal/Lens.hs @@ -0,0 +1,22 @@ +-- | 'lens' package compatible Lens. +-- +-- This is used to avoid 'lens' dependency. +-- + +{-# LANGUAGE RankNTypes, NoImplicitPrelude #-} + +module Caramia.Internal.Lens + ( Lens + , Lens' + , lens ) + where + +import Caramia.Prelude + +type Lens s t a b = forall f. Functor f => (a -> f b) -> s -> f t +type Lens' s a = Lens s s a a + +lens :: (s -> a) -> (s -> a -> s) -> Lens' s a +lens sa sbt afb s = sbt s `fmap` afb (sa s) +{-# INLINE lens #-} + diff --git a/src/Caramia/Internal/OpenGLCApi.hs b/src/Caramia/Internal/OpenGLCApi.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Internal/OpenGLCApi.hs @@ -0,0 +1,306 @@ +-- | Module for using the raw OpenGL API. +-- +-- This is a mixture from the OpenGLRaw package and some of our own stuff. +-- +-- TODO: Some of this stuff should probably be in OpenGLRaw so we could add +-- stuff there instead. +-- + +{-# LANGUAGE ForeignFunctionInterface, NoImplicitPrelude #-} + +module Caramia.Internal.OpenGLCApi + ( module Ex + + , gi + , gf + + , withBoundVAO + , withBoundBuffer + , withBoundElementBuffer + , withBoundPixelUnpackBuffer + , withBoundProgram + , withBoundDrawFramebuffer + + , setBoundProgram + , setBoundElementBuffer + + -- Functions that I made up that I wish were in OpenGL. + , mglDeleteBuffer + , mglGenBuffer + , mglDeleteVertexArray + , mglGenVertexArray + , mglDeleteFramebuffer + , mglGenFramebuffer + , mglNamedBufferData + , mglVertexArrayVertexAttribOffsetAndEnable + , mglVertexArrayVertexAttribIOffsetAndEnable + , mglVertexArrayVertexAttribDivisor + -- GL_ARB_separate_shader_objects...but I want them even if that extension + -- is not available. + , mglProgramUniform1ui + , mglProgramUniform2ui + , mglProgramUniform3ui + , mglProgramUniform4ui + , mglProgramUniform1i + , mglProgramUniform2i + , mglProgramUniform3i + , mglProgramUniform4i + , mglProgramUniform1f + , mglProgramUniform2f + , mglProgramUniform3f + , mglProgramUniform4f + , mglProgramUniformMatrix4fv + , mglProgramUniformMatrix3fv + , mglMapNamedBufferRange + , mglUnmapNamedBuffer + , mglNamedCopyBufferSubData + ) + where + +import Caramia.Prelude + +import Caramia.Internal.FlextGL as Ex +import Foreign.Ptr +import Foreign.C.Types +import Foreign.Storable +import Foreign.Marshal.Alloc +import Foreign.Marshal.Utils +import Control.Exception + +{-# ANN module ("HLint: ignore Use camelCase" :: String) #-} + +whenExt :: IO Bool -> IO a -> IO a -> IO a +whenExt test action other_action = do + x <- test + if x then action else other_action +{-# INLINE whenExt #-} + +mglDeleteBuffer :: GLuint -> IO () +mglDeleteBuffer x = with x $ \x_ptr -> glDeleteBuffers 1 x_ptr + +mglDeleteVertexArray :: GLuint -> IO () +mglDeleteVertexArray x = with x $ \x_ptr -> glDeleteVertexArrays 1 x_ptr + +mglGenBuffer :: IO GLuint +mglGenBuffer = alloca $ \x_ptr -> glGenBuffers 1 x_ptr *> peek x_ptr + +mglGenVertexArray :: IO GLuint +mglGenVertexArray = alloca $ \x_ptr -> glGenVertexArrays 1 x_ptr *> peek x_ptr + +mglGenFramebuffer :: IO GLuint +mglGenFramebuffer = alloca $ \x_ptr -> glGenFramebuffers 1 x_ptr *> peek x_ptr + +mglDeleteFramebuffer :: GLuint -> IO () +mglDeleteFramebuffer x = with x $ \x_ptr -> glDeleteFramebuffers 1 x_ptr + +withBoundDrawFramebuffer :: GLuint -> IO a -> IO a +withBoundDrawFramebuffer x action = do + old <- gi gl_DRAW_FRAMEBUFFER_BINDING + finally (glBindFramebuffer gl_DRAW_FRAMEBUFFER x *> action) + (glBindFramebuffer gl_DRAW_FRAMEBUFFER old) + +withBoundProgram :: GLuint -> IO a -> IO a +withBoundProgram program action = do + old <- + alloca $ \x_ptr -> glGetIntegerv gl_CURRENT_PROGRAM x_ptr *> peek x_ptr + finally (glUseProgram program *> action) + (glUseProgram $ fromIntegral old) + +setBoundProgram :: GLuint -> IO () +setBoundProgram = glUseProgram + +withBoundBuffer :: GLuint -> IO a -> IO a +withBoundBuffer buf action = do + old <- + alloca $ \x_ptr -> glGetIntegerv gl_ARRAY_BUFFER_BINDING x_ptr *> + peek x_ptr + finally (glBindBuffer gl_ARRAY_BUFFER buf *> action) + (glBindBuffer gl_ARRAY_BUFFER $ fromIntegral old) + +setBoundElementBuffer :: GLuint -> IO () +setBoundElementBuffer = + glBindBuffer gl_ELEMENT_ARRAY_BUFFER + +withBoundElementBuffer :: GLuint -> IO a -> IO a +withBoundElementBuffer buf action = do + old <- + alloca $ \x_ptr -> glGetIntegerv gl_ELEMENT_ARRAY_BUFFER_BINDING x_ptr *> + peek x_ptr + finally (glBindBuffer gl_ELEMENT_ARRAY_BUFFER buf *> action) + (glBindBuffer gl_ELEMENT_ARRAY_BUFFER $ fromIntegral old) + +withBoundPixelUnpackBuffer :: GLuint -> IO a -> IO a +withBoundPixelUnpackBuffer buf action = do + old <- + alloca $ \x_ptr -> glGetIntegerv gl_PIXEL_UNPACK_BUFFER_BINDING x_ptr *> + peek x_ptr + finally (glBindBuffer gl_PIXEL_UNPACK_BUFFER buf *> action) + (glBindBuffer gl_PIXEL_UNPACK_BUFFER $ fromIntegral old) + +withBoundVAO :: GLuint -> IO a -> IO a +withBoundVAO vao action = do + old <- + alloca $ \x_ptr -> glGetIntegerv gl_VERTEX_ARRAY_BINDING x_ptr *> + peek x_ptr + finally (glBindVertexArray vao *> action) + (glBindVertexArray $ fromIntegral old) + +mglVertexArrayVertexAttribDivisor :: + GLuint -> GLuint -> GLuint -> IO () +mglVertexArrayVertexAttribDivisor vaobj index divisor = mask_ $ + withBoundVAO vaobj $ + glVertexAttribDivisor index divisor + +mglVertexArrayVertexAttribOffsetAndEnable :: + GLuint -> GLuint -> GLuint -> GLint -> GLenum + -> GLboolean -> GLsizei -> CPtrdiff -> IO () +mglVertexArrayVertexAttribOffsetAndEnable + vaobj buffer index size dtype normalized stride (CPtrdiff offset) = mask_ $ + + withBoundVAO vaobj $ + withBoundBuffer buffer $ do + glEnableVertexAttribArray index + glVertexAttribPointer index size dtype normalized stride + (intPtrToPtr $ fromIntegral offset) + +mglVertexArrayVertexAttribIOffsetAndEnable :: + GLuint -> GLuint -> GLuint -> GLint -> GLenum + -> GLsizei -> GLintptr -> IO () +mglVertexArrayVertexAttribIOffsetAndEnable + vaobj buffer index size dtype stride offset = mask_ $ + + withBoundVAO vaobj $ + withBoundBuffer buffer $ do + glEnableVertexAttribArray index + glVertexAttribIPointer index size dtype stride + (intPtrToPtr $ fromIntegral offset) + +mglNamedBufferData :: GLuint + -> GLsizeiptr + -> Ptr () + -> GLenum + -> IO () +mglNamedBufferData buf size ptr usage = + whenExt has_GL_EXT_direct_state_access + (glNamedBufferDataEXT buf size ptr usage) + (withBoundBuffer buf $ glBufferData gl_ARRAY_BUFFER size ptr usage) + +mglProgramUniform1ui :: GLuint -> GLint -> GLuint -> IO () +mglProgramUniform1ui program loc v1 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniform1ui program loc v1) + (withBoundProgram program $ glUniform1ui loc v1) + +mglProgramUniform2ui :: GLuint -> GLint -> GLuint -> GLuint -> IO () +mglProgramUniform2ui program loc v1 v2 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniform2ui program loc v1 v2) + (withBoundProgram program $ glUniform2ui loc v1 v2) + +mglProgramUniform3ui :: GLuint -> GLint -> GLuint -> GLuint -> GLuint -> IO () +mglProgramUniform3ui program loc v1 v2 v3 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniform3ui program loc v1 v2 v3) + (withBoundProgram program $ glUniform3ui loc v1 v2 v3) + +mglProgramUniform4ui :: GLuint -> GLint -> GLuint -> GLuint -> GLuint + -> GLuint -> IO () +mglProgramUniform4ui program loc v1 v2 v3 v4 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniform4ui program loc v1 v2 v3 v4) + (withBoundProgram program $ glUniform4ui loc v1 v2 v3 v4) + +mglProgramUniform1i :: GLuint -> GLint -> GLint -> IO () +mglProgramUniform1i program loc v1 = + whenExt has_GL_ARB_separate_shader_objects (glProgramUniform1i program loc v1) + (withBoundProgram program $ glUniform1i loc v1) + +mglProgramUniform2i :: GLuint -> GLint -> GLint -> GLint -> IO () +mglProgramUniform2i program loc v1 v2 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniform2i program loc v1 v2) + (withBoundProgram program $ glUniform2i loc v1 v2) + +mglProgramUniform3i :: GLuint -> GLint -> GLint -> GLint -> GLint -> IO () +mglProgramUniform3i program loc v1 v2 v3 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniform3i program loc v1 v2 v3) + (withBoundProgram program $ glUniform3i loc v1 v2 v3) + +mglProgramUniform4i :: GLuint -> GLint -> GLint -> GLint -> GLint + -> GLint -> IO () +mglProgramUniform4i program loc v1 v2 v3 v4 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniform4i program loc v1 v2 v3 v4) + (withBoundProgram program $ glUniform4i loc v1 v2 v3 v4) + +mglProgramUniform1f :: GLuint -> GLint -> GLfloat -> IO () +mglProgramUniform1f program loc v1 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniform1f program loc v1) + (withBoundProgram program $ glUniform1f loc v1) + +mglProgramUniform2f :: GLuint -> GLint -> GLfloat -> GLfloat -> IO () +mglProgramUniform2f program loc v1 v2 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniform2f program loc v1 v2) + (withBoundProgram program $ glUniform2f loc v1 v2) + +mglProgramUniform3f :: GLuint -> GLint -> GLfloat -> GLfloat -> GLfloat -> IO () +mglProgramUniform3f program loc v1 v2 v3 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniform3f program loc v1 v2 v3) + (withBoundProgram program $ glUniform3f loc v1 v2 v3) + +mglProgramUniform4f :: GLuint -> GLint + -> GLfloat -> GLfloat -> GLfloat -> GLfloat -> IO () +mglProgramUniform4f program loc v1 v2 v3 v4 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniform4f program loc v1 v2 v3 v4) + (withBoundProgram program $ glUniform4f loc v1 v2 v3 v4) + +mglProgramUniformMatrix4fv :: GLuint -> GLint + -> GLsizei -> GLboolean -> Ptr GLfloat -> IO () +mglProgramUniformMatrix4fv program loc count transpose m44 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniformMatrix4fv program loc count transpose m44) + (withBoundProgram program $ + glUniformMatrix4fv loc count transpose m44) + +mglProgramUniformMatrix3fv :: GLuint -> GLint + -> GLsizei -> GLboolean -> Ptr GLfloat -> IO () +mglProgramUniformMatrix3fv program loc count transpose m33 = + whenExt has_GL_ARB_separate_shader_objects + (glProgramUniformMatrix3fv program loc count transpose m33) + (withBoundProgram program $ + glUniformMatrix3fv loc count transpose m33) + +mglMapNamedBufferRange :: GLuint -> GLintptr + -> GLsizeiptr -> GLbitfield -> IO (Ptr ()) +mglMapNamedBufferRange buffer offset length access = + withBoundBuffer buffer $ + glMapBufferRange gl_ARRAY_BUFFER offset length access + +mglUnmapNamedBuffer :: GLuint -> IO GLboolean +mglUnmapNamedBuffer buffer = + withBoundBuffer buffer $ glUnmapBuffer gl_ARRAY_BUFFER + +mglNamedCopyBufferSubData :: GLuint -> GLuint + -> GLintptr -> GLintptr -> GLsizeiptr -> IO () +mglNamedCopyBufferSubData src dst src_offset dst_offset num_bytes = + withBoundElementBuffer src $ + withBoundBuffer dst $ + glCopyBufferSubData gl_ELEMENT_ARRAY_BUFFER + gl_ARRAY_BUFFER + src_offset + dst_offset + num_bytes + +-- | Shortcut to `glGetIntegerv` when you query only one integer. +gi :: GLenum -> IO GLuint +gi x = alloca $ \get_ptr -> glGetIntegerv x (castPtr get_ptr) *> + peek get_ptr + +gf :: GLenum -> IO GLfloat +gf x = alloca $ \get_ptr -> glGetFloatv x (castPtr get_ptr) *> peek get_ptr + diff --git a/src/Caramia/Internal/OpenGLDebug.hs b/src/Caramia/Internal/OpenGLDebug.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Internal/OpenGLDebug.hs @@ -0,0 +1,116 @@ +-- | Module for using the OpenGL debug extensions for debug output. + +{-# LANGUAGE NoImplicitPrelude, DeriveDataTypeable #-} + +module Caramia.Internal.OpenGLDebug + ( activateDebugMode + , flushDebugMessages ) + where + +import Caramia.Prelude +import Caramia.Internal.OpenGLCApi +import Caramia.Internal.ContextLocalData +import Control.Monad.Trans.State.Strict +import Control.Monad.IO.Class +import Control.Exception +import System.IO +import Foreign.Storable +import Foreign.C.String +import Foreign.Marshal.Array +import Foreign.Ptr + +newtype DebugModeActivated = DebugModeActivated Bool + deriving ( Typeable ) + +activateDebugMode :: IO () +activateDebugMode = do + necessary_extensions <- has_GL_KHR_debug + when necessary_extensions reallyActivateDebugMode + where + reallyActivateDebugMode = mask_ $ do + glDebugMessageControl gl_DONT_CARE + gl_DONT_CARE + gl_DONT_CARE + 0 + nullPtr + (fromIntegral gl_TRUE) + glEnable gl_DEBUG_OUTPUT + withCStringLen "Debug output activated." $ \(cstr, len) -> + glDebugMessageInsert gl_DEBUG_SOURCE_APPLICATION + gl_DEBUG_TYPE_OTHER + 0 + gl_DEBUG_SEVERITY_LOW + (fromIntegral len) + cstr + storeContextLocalData (DebugModeActivated True) + +flushDebugMessages :: IO () +flushDebugMessages = do + DebugModeActivated debug_mode <- + retrieveContextLocalData $ return $ DebugModeActivated False + when debug_mode $ + allocaArray 65535 $ \cstr_msg -> + allocaArray maxMsgs $ \sources -> + allocaArray maxMsgs $ \types -> + allocaArray maxMsgs $ \ids -> + allocaArray maxMsgs $ \severities -> + allocaArray maxMsgs $ \lengths -> do + num_msgs <- fromIntegral <$> + glGetDebugMessageLog (fromIntegral maxMsgs) + 65535 + sources + types + ids + severities + lengths + cstr_msg + + flip evalStateT cstr_msg $ for_ [0..num_msgs-1] $ \index -> do + src <- peo sources index + typ <- peo types index + id <- peo ids index + severity <- peo severities index + length <- peo lengths index + cur_ptr <- get + + str <- liftIO $ peekCStringLen (cur_ptr, fromIntegral length) + liftIO $ hPutStrLn stderr $ + "[" <> show id <> ", " <> + showSrc src <> ", " <> + showType typ <> ", " <> + showSeverity severity <> "] " <> + str + + put (plusPtr cur_ptr $ fromIntegral length) + + when (num_msgs >= maxMsgs) flushDebugMessages + where + peo ptr idx = liftIO $ peekElemOff ptr idx + + maxMsgs = 10000 + +showSeverity :: GLenum -> String +showSeverity x | x == gl_DEBUG_SEVERITY_HIGH = "high" + | x == gl_DEBUG_SEVERITY_MEDIUM = "medium" + | x == gl_DEBUG_SEVERITY_LOW = "low" +showSeverity _ = "unknown" + +showType :: GLenum -> String +showType x | x == gl_DEBUG_TYPE_ERROR = "error" + | x == gl_DEBUG_TYPE_DEPRECATED_BEHAVIOR = "deprecated" + | x == gl_DEBUG_TYPE_UNDEFINED_BEHAVIOR = "undefined" + | x == gl_DEBUG_TYPE_PORTABILITY = "portability" + | x == gl_DEBUG_TYPE_PERFORMANCE = "performance" + | x == gl_DEBUG_TYPE_OTHER = "other" +showType _ = "unknown" + +showSrc :: GLenum -> String +showSrc x | x == gl_DEBUG_SOURCE_APPLICATION = "application" + | x == gl_DEBUG_SOURCE_OTHER = "other" + | x == gl_DEBUG_SOURCE_API = "api" + | x == gl_DEBUG_SOURCE_WINDOW_SYSTEM = "windowsystem" + | x == gl_DEBUG_SOURCE_SHADER_COMPILER = "shadercompiler" + | x == gl_DEBUG_SOURCE_THIRD_PARTY = "thirdparty" +showSrc _ = "unknown" + + diff --git a/src/Caramia/Math.hs b/src/Caramia/Math.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Math.hs @@ -0,0 +1,1647 @@ +{-# LANGUAGE NoImplicitPrelude, BangPatterns, DeriveDataTypeable #-} +{-# OPTIONS_GHC -fno-warn-name-shadowing #-} + +-- | Matrix, vector and quaternion math module. This module is concerned about +-- common functions for graphics programming and the types from this module are +-- used by the rest of Caramia. +-- +-- If you require more functionality or types, I suggest you look at a +-- dedicated linear algebra package such as \'hmatrix\' or \'linear\'. +-- +-- #storable# +-- `Matrix44`, `Matrix33`, `Quaternion` and `Vector3` are all `Storable`s. +-- +-- The matrices are stored as column vectors. That is, if a `Matrix4` is +-- labelled like this: +-- +-- @ +-- Col.1 Col.2 Col.3 Col.4 +-- --------------------------- +-- Row 1 m11 m12 m13 m14 +-- Row 2 m21 m22 m23 m24 +-- Row 3 m31 m32 m33 m34 +-- Row 4 m41 m42 m43 m44 +-- --------------------------- +-- @ +-- +-- The matrix would occupy memory (as a `Storable`) as follows: +-- +-- @ +-- m11, m21, m31, m41, m12, m22, m32, m42, m13 ... +-- @ +-- +-- where each value is a 32-bit floating point value. This is what OpenGL uses. +-- +-- (if the above matrix was a translation matrix, then m14, m24 and m34 would +-- contain the x, y and z coordinates of a translation). +-- +-- The scheme is the same for a `Matrix33`, just drop the fourth row and +-- column. +-- +-- `Vector3` is stored as three consecutive floating point values. +-- +-- @ +-- x, y, z +-- @ +-- +-- `Quaternion` first stores the `w` as the last element. So, the layout of a +-- quaternion is: +-- +-- @ +-- x, y, z, w +-- @ +-- +-- This is also how `Caramia.Shader` maps quaternions to vectors in shaders. +-- + +module Caramia.Math + ( Matrix44(..) + , Matrix33(..) + , Vector3(..) + , Quaternion(..) + + -- * sizeOfs + , sizeOfMatrix44 + , sizeOfMatrix33 + , sizeOfVector3 + , sizeOfQuaternion + + -- * 4x4 matrices + , matrix44 + , withMatrix44Ptr + , inverse44 + , identity44 + , multiply44 + , determinant44 + , zero44 + , perspective44 + , distance44 + , frustum44 + , ortho44 + , lookat44 + , translate44 + , transpose44 + , scale44 + , rotate44 + + -- * 3x3 matrices + , matrix33 + , withMatrix33Ptr + , inverse33 + , identity33 + , multiply33 + , determinant33 + , zero33 + , distance33 + , transpose33 + , matrix33ToMatrix44 + , matrix44ToMatrix33 + + + -- * quaternions + , quaternion + , identityq + , canonicalizeq + , distanceq + , lengthq + , normalizeq + , multiplyq + , zeroq + , axisAngleToQuaternion + , matrix44ToQuaternion + , quaternionToMatrix44 + + , toTupleq + , fromTupleq + + -- * 3-component vectors + , vector3 + , zero3 + , distance3 + , length3 + , plus3 + , minus3 + , normalize3 + , angle3 + , cross3 + , dot3 + , negative3 + , scalarMultiply3 + , vector3_1ToQuaternion + , vector3Transform44 + , toTuple3 + , fromTuple3 + + -- ** Lenses + , _x + , _y + , _z + + -- * Misc + , prettyShow ) + where + +-- Hacking guide: +-- +-- All data types are unpacked and strict. (Almost) all functions use bang +-- patterns to make sure everything is strict (mostly unneeded as they would be +-- strict anyway but, for consistency, in this module, use them everywhere). +-- +-- Everything is also inlined. +-- +-- Matrix44 functions have 44 at the end. +-- Matrix33 functions have 33 at the end. +-- Vector3 functions have 3 at the end. +-- Quaternion functions have q at the end. +-- +-- +-- Hlint likes to complain about this file, mostly about the repetitions. +-- + +import Caramia.Prelude + +import Foreign.Ptr ( Ptr, castPtr ) +import Foreign.Storable ( pokeElemOff, Storable(..) ) +import Foreign.Marshal.Array ( allocaArray ) +import Foreign.C.Types ( CFloat(..) ) +import Caramia.Internal.Lens + +{-# ANN module ("HLint: ignore Reduce duplication" :: String) #-} + +-- | A 4x4 matrix. Each mXX function accesses an individual element of the +-- matrix. +data Matrix44 = Matrix44 { m11 :: {-# UNPACK #-} !Float + , m21 :: {-# UNPACK #-} !Float + , m31 :: {-# UNPACK #-} !Float + , m41 :: {-# UNPACK #-} !Float + , m12 :: {-# UNPACK #-} !Float + , m22 :: {-# UNPACK #-} !Float + , m32 :: {-# UNPACK #-} !Float + , m42 :: {-# UNPACK #-} !Float + , m13 :: {-# UNPACK #-} !Float + , m23 :: {-# UNPACK #-} !Float + , m33 :: {-# UNPACK #-} !Float + , m43 :: {-# UNPACK #-} !Float + , m14 :: {-# UNPACK #-} !Float + , m24 :: {-# UNPACK #-} !Float + , m34 :: {-# UNPACK #-} !Float + , m44 :: {-# UNPACK #-} !Float } + deriving ( Eq, Show, Read, Ord, Typeable ) + +-- | A 3x3 matrix. Each nXX function accesses an individual element of the +-- matrix. +data Matrix33 = Matrix33 { n11 :: {-# UNPACK #-} !Float + , n21 :: {-# UNPACK #-} !Float + , n31 :: {-# UNPACK #-} !Float + , n12 :: {-# UNPACK #-} !Float + , n22 :: {-# UNPACK #-} !Float + , n32 :: {-# UNPACK #-} !Float + , n13 :: {-# UNPACK #-} !Float + , n23 :: {-# UNPACK #-} !Float + , n33 :: {-# UNPACK #-} !Float } + deriving ( Eq, Show, Read, Ord, Typeable ) + +-- | A 3-dimensional vector. `x`, `y` and `z` access each individual +-- component. +data Vector3 = Vector3 { x :: {-# UNPACK #-} !Float + , y :: {-# UNPACK #-} !Float + , z :: {-# UNPACK #-} !Float } + deriving ( Eq, Show, Read, Ord, Typeable ) + +_x :: Lens' Vector3 Float +_x = lens x (\old_vec new_x -> old_vec { x = new_x }) +_y :: Lens' Vector3 Float +_y = lens y (\old_vec new_y -> old_vec { y = new_y }) +_z :: Lens' Vector3 Float +_z = lens z (\old_vec new_z -> old_vec { z = new_z }) + +-- | A quaternion. It's composed of four values, `qx`, `qy`, `qz` and `qw`. +-- +-- In the context of Caramia, quaternions are used exclusively to represent +-- rotations. +data Quaternion = Quaternion { qx :: {-# UNPACK #-} !Float + , qy :: {-# UNPACK #-} !Float + , qz :: {-# UNPACK #-} !Float + , qw :: {-# UNPACK #-} !Float } + deriving ( Eq, Show, Read, Ord, Typeable ) + +-- | Returns the size of a `Vector3`. This is just a shortcut to calling +-- `sizeOf` on a vector. +sizeOfVector3 :: Int +sizeOfVector3 = sizeOf (undefined :: Vector3) + +-- | Returns the size of a `Matrix3`. This is just a shortcut to calling +-- `sizeOf` on a matrix. +sizeOfMatrix33 :: Int +sizeOfMatrix33 = sizeOf (undefined :: Matrix33) + +-- | Returns the size of a `Matrix4`. This is just a shortcut to calling +-- `sizeOf` on a matrix. +sizeOfMatrix44 :: Int +sizeOfMatrix44 = sizeOf (undefined :: Matrix44) + +-- | Returns the size of a `Quaternion`. This is just a shortcut to calling +-- `sizeOf` on a quaternion. +sizeOfQuaternion :: Int +sizeOfQuaternion = sizeOf (undefined :: Quaternion) + +instance Storable Vector3 where + sizeOf _ = sizeOf (undefined :: Float) * 3 + alignment _ = alignment (undefined :: Float) + peek ptr = {-# SCC "Vector3_peek" #-} do + x <- peekElemOff cptr 0 :: IO Float + y <- peekElemOff cptr 1 :: IO Float + z <- peekElemOff cptr 2 :: IO Float + return $ Vector3 x y z + where + cptr = castPtr ptr :: Ptr Float + + poke ptr (Vector3 x y z) = {-# SCC "Vector3_poke" #-} do + pokeElemOff cptr 0 x + pokeElemOff cptr 1 y + pokeElemOff cptr 2 z + where + cptr = castPtr ptr :: Ptr Float + +instance Storable Quaternion where + sizeOf _ = sizeOf (undefined :: Float) * 4 + alignment _ = alignment (undefined :: Float) + peek ptr = {-# SCC "Quaternion_peek" #-} do + x <- peekElemOff cptr 0 :: IO Float + y <- peekElemOff cptr 1 :: IO Float + z <- peekElemOff cptr 2 :: IO Float + w <- peekElemOff cptr 3 :: IO Float + return $ Quaternion x y z w + where + cptr = castPtr ptr :: Ptr Float + + poke ptr (Quaternion x y z w) = {-# SCC "Quaternion_poke" #-} do + pokeElemOff cptr 0 x + pokeElemOff cptr 1 y + pokeElemOff cptr 2 z + pokeElemOff cptr 3 w + where + cptr = castPtr ptr :: Ptr Float + +instance Storable Matrix44 where + sizeOf _ = sizeOf (undefined :: Float) * 16 + alignment _ = alignment (undefined :: Float) + peek ptr = {-# SCC "Matrix44_peek" #-} do + r11 <- peekElemOff cptr 0 :: IO Float + r21 <- peekElemOff cptr 1 :: IO Float + r31 <- peekElemOff cptr 2 :: IO Float + r41 <- peekElemOff cptr 3 :: IO Float + r12 <- peekElemOff cptr 4 :: IO Float + r22 <- peekElemOff cptr 5 :: IO Float + r32 <- peekElemOff cptr 6 :: IO Float + r42 <- peekElemOff cptr 7 :: IO Float + r13 <- peekElemOff cptr 8 :: IO Float + r23 <- peekElemOff cptr 9 :: IO Float + r33 <- peekElemOff cptr 10 :: IO Float + r43 <- peekElemOff cptr 11 :: IO Float + r14 <- peekElemOff cptr 12 :: IO Float + r24 <- peekElemOff cptr 13 :: IO Float + r34 <- peekElemOff cptr 14 :: IO Float + r44 <- peekElemOff cptr 15 :: IO Float + return $ matrix44 r11 r12 r13 r14 + r21 r22 r23 r24 + r31 r32 r33 r34 + r41 r42 r43 r44 + where + cptr = castPtr ptr :: Ptr Float + + poke ptr mat = {-# SCC "Matrix44_poke" #-} do + pokeElemOff cptr 0 f11 + pokeElemOff cptr 1 f21 + pokeElemOff cptr 2 f31 + pokeElemOff cptr 3 f41 + pokeElemOff cptr 4 f12 + pokeElemOff cptr 5 f22 + pokeElemOff cptr 6 f32 + pokeElemOff cptr 7 f42 + pokeElemOff cptr 8 f13 + pokeElemOff cptr 9 f23 + pokeElemOff cptr 10 f33 + pokeElemOff cptr 11 f43 + pokeElemOff cptr 12 f14 + pokeElemOff cptr 13 f24 + pokeElemOff cptr 14 f34 + pokeElemOff cptr 15 f44 + where + cptr = castPtr ptr :: Ptr Float + f11 = m11 mat + f21 = m21 mat + f31 = m31 mat + f41 = m41 mat + f12 = m12 mat + f22 = m22 mat + f32 = m32 mat + f42 = m42 mat + f13 = m13 mat + f23 = m23 mat + f33 = m33 mat + f43 = m43 mat + f14 = m14 mat + f24 = m24 mat + f34 = m34 mat + f44 = m44 mat + +instance Storable Matrix33 where + sizeOf _ = sizeOf (undefined :: CFloat) * 9 + alignment _ = alignment (undefined :: CFloat) + peek ptr = {-# SCC "Matrix33_peek" #-} do + r11 <- peekElemOff cptr 0 :: IO Float + r21 <- peekElemOff cptr 1 :: IO Float + r31 <- peekElemOff cptr 2 :: IO Float + r12 <- peekElemOff cptr 3 :: IO Float + r22 <- peekElemOff cptr 4 :: IO Float + r32 <- peekElemOff cptr 5 :: IO Float + r13 <- peekElemOff cptr 6 :: IO Float + r23 <- peekElemOff cptr 7 :: IO Float + r33 <- peekElemOff cptr 8 :: IO Float + return $ matrix33 r11 r12 r13 + r21 r22 r23 + r31 r32 r33 + where + cptr = castPtr ptr :: Ptr Float + + poke ptr mat = {-# SCC "Matrix33_poke" #-} do + pokeElemOff cptr 0 f11 + pokeElemOff cptr 1 f21 + pokeElemOff cptr 2 f31 + pokeElemOff cptr 3 f12 + pokeElemOff cptr 4 f22 + pokeElemOff cptr 5 f32 + pokeElemOff cptr 6 f13 + pokeElemOff cptr 7 f23 + pokeElemOff cptr 8 f33 + where + cptr = castPtr ptr :: Ptr Float + f11 = n11 mat + f21 = n21 mat + f31 = n31 mat + f12 = n12 mat + f22 = n22 mat + f32 = n32 mat + f13 = n13 mat + f23 = n23 mat + f33 = n33 mat + +-- | Constructs a `Vector3` out of three values. +vector3 :: Float -- ^ X-coodinate. + -> Float -- ^ Y-coodinate. + -> Float -- ^ Z-coodinate. + -> Vector3 +{-# INLINE vector3 #-} +vector3 !x !y !z = Vector3 { x = x, y = y, z = z } + +-- | Constructs a `Matrix44` out of 16 values. +-- +-- The order of the values is column-first. That is, in this order: +-- +-- @ +-- m11 m12 m13 m14 m21 m22 m23 m24 m31 ... +-- @ +-- +-- This allows you to write the matrix out this way: +-- +-- @ +-- let the_greatest_4x4_matrix_of_them_all = +-- matrix4 m11 m12 m13 m14 +-- m21 m22 m23 m24 +-- m31 m32 m33 m34 +-- m41 m42 m43 m44 +-- in ... +-- @ +matrix44 :: Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Matrix44 +{-# INLINE matrix44 #-} +matrix44 !m11 !m12 !m13 !m14 + !m21 !m22 !m23 !m24 + !m31 !m32 !m33 !m34 + !m41 !m42 !m43 !m44 = {-# SCC "matrix44" #-} + Matrix44 { m11 = m11 + , m21 = m21 + , m31 = m31 + , m41 = m41 + , m12 = m12 + , m22 = m22 + , m32 = m32 + , m42 = m42 + , m13 = m13 + , m23 = m23 + , m33 = m33 + , m43 = m43 + , m14 = m14 + , m24 = m24 + , m34 = m34 + , m44 = m44 } + +-- | Constructs a `Matrix3` out of 9 values. +-- +-- The order of the values is the same as for `matrix4`, just drop the fourth +-- row and column. +matrix33 :: Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Float + -> Matrix33 +{-# INLINE matrix33 #-} +matrix33 !m11 !m12 !m13 + !m21 !m22 !m23 + !m31 !m32 !m33 = {-# SCC "matrix33" #-} + Matrix33 { n11 = m11 + , n21 = m21 + , n31 = m31 + , n12 = m12 + , n22 = m22 + , n32 = m32 + , n13 = m13 + , n23 = m23 + , n33 = m33 } + +-- | Transforms a `Matrix33` into a `Matrix44`. +-- +-- If this is the original 3x3 matrix: +-- +-- @ +-- --------------------- +-- m11 m12 m13 +-- m21 m22 m23 +-- m31 m32 m33 +-- --------------------- +-- @ +-- +-- Then this is the resulting matrix: +-- +-- @ +-- ------------------------- +-- m11 m12 m13 0 +-- m21 m22 m23 0 +-- m31 m32 m33 0 +-- 0 0 0 1 +-- ------------------------- +-- @ +matrix33ToMatrix44 :: Matrix33 -> Matrix44 +{-# INLINE matrix33ToMatrix44 #-} +matrix33ToMatrix44 !mat = {-# SCC "matrix33ToMatrix44" #-} + Matrix44 { m11 = f11 + , m21 = f21 + , m31 = f31 + , m12 = f12 + , m22 = f22 + , m32 = f32 + , m13 = f13 + , m23 = f23 + , m33 = f33 + + , m41 = 0.0 + , m42 = 0.0 + , m43 = 0.0 + , m44 = 1.0 + , m14 = 0.0 + , m24 = 0.0 + , m34 = 0.0 } + where + f11 = n11 mat + f21 = n21 mat + f31 = n31 mat + f12 = n12 mat + f22 = n22 mat + f32 = n32 mat + f13 = n13 mat + f23 = n23 mat + f33 = n33 mat + + +-- | Transforms a `Matrix44` into a `Matrix33`. +-- +-- If this is the original 4x4 matrix: +-- +-- @ +-- ---------------------------- +-- m11 m12 m13 m14 +-- m21 m22 m23 m24 +-- m31 m32 m33 m34 +-- m41 m42 m43 m44 +-- ---------------------------- +-- @ +-- +-- Then this is the resulting 3x3 matrix: +-- +-- @ +-- --------------------- +-- m11 m12 m13 +-- m21 m22 m23 +-- m31 m32 m33 +-- --------------------- +-- @ +-- +-- The fourth row and column are discarded. +matrix44ToMatrix33 :: Matrix44 -> Matrix33 +{-# INLINE matrix44ToMatrix33 #-} +matrix44ToMatrix33 !mat = {-# SCC "matrix44ToMatrix33" #-} + Matrix33 { n11 = f11 + , n21 = f21 + , n31 = f31 + , n12 = f12 + , n22 = f22 + , n32 = f32 + , n13 = f13 + , n23 = f23 + , n33 = f33 } + where + f11 = m11 mat + f21 = m21 mat + f31 = m31 mat + f12 = m12 mat + f22 = m22 mat + f32 = m32 mat + f13 = m13 mat + f23 = m23 mat + f33 = m33 mat + +-- | Runs an IO action with a pointer to a Matrix44. The pointer is valid only +-- during the given IO action. +-- +-- The pointer points to an array of 16 floating point values. See +-- "Caramia.Math#storable" for a description in which order the values appear. +withMatrix44Ptr :: Matrix44 -- ^ The matrix to marshal. + -> (Ptr CFloat -> IO a) -- ^ An IO action that receives a + -- pointer to floating point values + -- describing the matrix. + -> IO a +{-# INLINE withMatrix44Ptr #-} +withMatrix44Ptr mat action = {-# SCC "withMatrix44Ptr" #-} + allocaArray 16 $ \ptr -> do + pokeElemOff ptr 0 (CFloat $ m11 mat) + pokeElemOff ptr 1 (CFloat $ m21 mat) + pokeElemOff ptr 2 (CFloat $ m31 mat) + pokeElemOff ptr 3 (CFloat $ m41 mat) + pokeElemOff ptr 4 (CFloat $ m12 mat) + pokeElemOff ptr 5 (CFloat $ m22 mat) + pokeElemOff ptr 6 (CFloat $ m32 mat) + pokeElemOff ptr 7 (CFloat $ m42 mat) + pokeElemOff ptr 8 (CFloat $ m13 mat) + pokeElemOff ptr 9 (CFloat $ m23 mat) + pokeElemOff ptr 10 (CFloat $ m33 mat) + pokeElemOff ptr 11 (CFloat $ m43 mat) + pokeElemOff ptr 12 (CFloat $ m14 mat) + pokeElemOff ptr 13 (CFloat $ m24 mat) + pokeElemOff ptr 14 (CFloat $ m34 mat) + pokeElemOff ptr 15 (CFloat $ m44 mat) + action ptr + +-- | Same as `withMatrix44Ptr`, only with 9 floating values. +withMatrix33Ptr :: Matrix33 -> (Ptr CFloat -> IO a) -> IO a +{-# INLINE withMatrix33Ptr #-} +withMatrix33Ptr mat action = {-# SCC "withMatrix33Ptr" #-} + allocaArray 9 $ \ptr -> do + pokeElemOff ptr 0 (CFloat $ n11 mat) + pokeElemOff ptr 1 (CFloat $ n21 mat) + pokeElemOff ptr 2 (CFloat $ n31 mat) + pokeElemOff ptr 3 (CFloat $ n12 mat) + pokeElemOff ptr 4 (CFloat $ n22 mat) + pokeElemOff ptr 5 (CFloat $ n32 mat) + pokeElemOff ptr 6 (CFloat $ n13 mat) + pokeElemOff ptr 7 (CFloat $ n23 mat) + pokeElemOff ptr 8 (CFloat $ n33 mat) + action ptr + +-- | Returns the identity 3x3 matrix. +identity33 :: Matrix33 +{-# INLINE identity33 #-} +identity33 = {-# SCC "identity33" #-} + Matrix33 { n11 = 1.0 + , n21 = 0.0 + , n31 = 0.0 + , n12 = 0.0 + , n22 = 1.0 + , n32 = 0.0 + , n13 = 0.0 + , n23 = 0.0 + , n33 = 1.0 } + +-- | Returns the 3x3 matrix where all components are zero. +zero33 :: Matrix33 +{-# INLINE zero33 #-} +zero33 = {-# SCC "zero33" #-} + Matrix33 { n11 = 0.0 + , n21 = 0.0 + , n31 = 0.0 + , n12 = 0.0 + , n22 = 0.0 + , n32 = 0.0 + , n13 = 0.0 + , n23 = 0.0 + , n33 = 0.0 } + +-- | Returns the identity 4x4 matrix. +identity44 :: Matrix44 +{-# INLINE identity44 #-} +identity44 = {-# SCC "identity44" #-} + Matrix44 { m11 = 1.0 + , m21 = 0.0 + , m31 = 0.0 + , m41 = 0.0 + , m12 = 0.0 + , m22 = 1.0 + , m32 = 0.0 + , m42 = 0.0 + , m13 = 0.0 + , m23 = 0.0 + , m33 = 1.0 + , m43 = 0.0 + , m14 = 0.0 + , m24 = 0.0 + , m34 = 0.0 + , m44 = 1.0 } + +-- | Returns the 4x4 matrix where all components are zero. +zero44 :: Matrix44 +{-# INLINE zero44 #-} +zero44 = {-# SCC "zero44" #-} + Matrix44 { m11 = 0.0 + , m21 = 0.0 + , m31 = 0.0 + , m41 = 0.0 + , m12 = 0.0 + , m22 = 0.0 + , m32 = 0.0 + , m42 = 0.0 + , m13 = 0.0 + , m23 = 0.0 + , m33 = 0.0 + , m43 = 0.0 + , m14 = 0.0 + , m24 = 0.0 + , m34 = 0.0 + , m44 = 0.0 } + +-- | Calculates the inverse of a 4x4 matrix. +-- +-- A matrix doesn't always have an inverse. In this case, the matrix values +-- will most likely end up being NaNs. +inverse44 :: Matrix44 -> Matrix44 +{-# INLINE inverse44 #-} +inverse44 !mat4 = {-# SCC "inverse44" #-} + Matrix44 { m11 = (f11 * b11 - f12 * b10 + f13 * b9) * det + , m12 = (f02 * b10 - f01 * b11 - f03 * b9) * det + , m13 = (f31 * b5 - f32 * b4 + f33 * b3) * det + , m14 = (f22 * b4 - f21 * b5 - f23 * b3) * det + , m21 = (f12 * b8 - f10 * b11 - f13 * b7) * det + , m22 = (f00 * b11 - f02 * b8 + f03 * b7) * det + , m23 = (f32 * b2 - f30 * b5 - f33 * b1) * det + , m24 = (f20 * b5 - f22 * b2 + f23 * b1) * det + , m31 = (f10 * b10 - f11 * b8 + f13 * b6) * det + , m32 = (f01 * b8 - f00 * b10 - f03 * b6) * det + , m33 = (f30 * b4 - f31 * b2 + f33 * b0) * det + , m34 = (f21 * b2 - f20 * b4 - f23 * b0) * det + , m41 = (f11 * b7 - f10 * b9 - f12 * b6) * det + , m42 = (f00 * b9 - f01 * b7 + f02 * b6) * det + , m43 = (f31 * b1 - f30 * b3 - f32 * b0) * det + , m44 = (f20 * b3 - f21 * b1 + f22 * b0) * det } + where + f00 = m11 mat4 + f10 = m21 mat4 + f20 = m31 mat4 + f30 = m41 mat4 + f01 = m12 mat4 + f11 = m22 mat4 + f21 = m32 mat4 + f31 = m42 mat4 + f02 = m13 mat4 + f12 = m23 mat4 + f22 = m33 mat4 + f32 = m43 mat4 + f03 = m14 mat4 + f13 = m24 mat4 + f23 = m34 mat4 + f33 = m44 mat4 + + b0 = f00 * f11 - f01 * f10 + b1 = f00 * f12 - f02 * f10 + b2 = f00 * f13 - f03 * f10 + b3 = f01 * f12 - f02 * f11 + b4 = f01 * f13 - f03 * f11 + b5 = f02 * f13 - f03 * f12 + b6 = f20 * f31 - f21 * f30 + b7 = f20 * f32 - f22 * f30 + b8 = f20 * f33 - f23 * f30 + b9 = f21 * f32 - f22 * f31 + b10 = f21 * f33 - f23 * f31 + b11 = f22 * f33 - f23 * f32 + + det' = b0*b11 - b1*b10 + b2*b9 + b3*b8 - b4*b7 + b5*b6 + det = 1.0 / det' + +-- | Calculates the determinant of a 3x3 matrix. +determinant33 :: Matrix33 -> Float +{-# INLINE determinant33 #-} +determinant33 !mat = {-# SCC "determinant33" #-} det' + where + det' = f11*f22*f33 + f12*f23*f31 + f13*f21*f32 - + f13*f22*f31 - f12*f21*f33 - f11*f23*f32 + f11 = n11 mat + f21 = n21 mat + f31 = n31 mat + f12 = n12 mat + f22 = n22 mat + f32 = n32 mat + f13 = n13 mat + f23 = n23 mat + f33 = n33 mat + +-- | Calculats the inverse of a 3x3 matrix. +-- +-- A matrix doesn't always have an inverse. In this case, the matrix values +-- will most likely end up being NaNs. +inverse33 :: Matrix33 -> Matrix33 +{-# INLINE inverse33 #-} +inverse33 !mat = {-# SCC "inverse33" #-} + Matrix33 { n11 = (f22*f33-f23*f32)*det' + , n12 = (f13*f32-f12*f33)*det' + , n13 = (f12*f23-f13*f22)*det' + , n21 = (f23*f31-f21*f33)*det' + , n22 = (f11*f33-f13*f31)*det' + , n23 = (f13*f21-f11*f23)*det' + , n31 = (f21*f32-f22*f31)*det' + , n32 = (f12*f31-f11*f32)*det' + , n33 = (f11*f22-f12*f21)*det' } + where + det' = 1.0 / + (f11*f22*f33 + f12*f23*f31 + f13*f21*f32 - + f13*f22*f31 - f12*f21*f33 - f11*f23*f32) + f11 = n11 mat + f21 = n21 mat + f31 = n31 mat + f12 = n12 mat + f22 = n22 mat + f32 = n32 mat + f13 = n13 mat + f23 = n23 mat + f33 = n33 mat + +-- | Calculates the determinant of a 4x4 matrix. +determinant44 :: Matrix44 -> Float +{-# INLINE determinant44 #-} +determinant44 !mat = {-# SCC "determinant44" #-} det' + where + det' = b0*b11 - b1*b10 + b2*b9 + b3*b8 - b4*b7 + b5*b6 + + f00 = m11 mat + f10 = m21 mat + f20 = m31 mat + f30 = m41 mat + f01 = m12 mat + f11 = m22 mat + f21 = m32 mat + f31 = m42 mat + f02 = m13 mat + f12 = m23 mat + f22 = m33 mat + f32 = m43 mat + f03 = m14 mat + f13 = m24 mat + f23 = m34 mat + f33 = m44 mat + + b0 = f00 * f11 - f01 * f10 + b1 = f00 * f12 - f02 * f10 + b2 = f00 * f13 - f03 * f10 + b3 = f01 * f12 - f02 * f11 + b4 = f01 * f13 - f03 * f11 + b5 = f02 * f13 - f03 * f12 + b6 = f20 * f31 - f21 * f30 + b7 = f20 * f32 - f22 * f30 + b8 = f20 * f33 - f23 * f30 + b9 = f21 * f32 - f22 * f31 + b10 = f21 * f33 - f23 * f31 + b11 = f22 * f33 - f23 * f32 + +-- | Multiplies two 3x3 matrices together. +multiply33 :: Matrix33 -> Matrix33 -> Matrix33 +{-# INLINE multiply33 #-} +multiply33 !mat1 !mat2 = {-# SCC "multiply33" #-} + Matrix33 { n11 = s11*f11 + s21*f12 + s31*f13 + , n21 = s11*f21 + s21*f22 + s31*f23 + , n31 = s11*f31 + s21*f32 + s31*f33 + , n12 = s12*f11 + s22*f12 + s32*f13 + , n22 = s12*f21 + s22*f22 + s32*f23 + , n32 = s12*f31 + s22*f32 + s32*f33 + , n13 = s13*f11 + s23*f12 + s33*f13 + , n23 = s13*f21 + s23*f22 + s33*f23 + , n33 = s13*f31 + s23*f32 + s33*f33 } + where + f11 = n11 mat1 + f21 = n21 mat1 + f31 = n31 mat1 + f12 = n12 mat1 + f22 = n22 mat1 + f32 = n32 mat1 + f13 = n13 mat1 + f23 = n23 mat1 + f33 = n33 mat1 + s11 = n11 mat2 + s21 = n21 mat2 + s31 = n31 mat2 + s12 = n12 mat2 + s22 = n22 mat2 + s32 = n32 mat2 + s13 = n13 mat2 + s23 = n23 mat2 + s33 = n33 mat2 + +-- | Multiplies two 4x4 matrices together. +multiply44 :: Matrix44 -> Matrix44 -> Matrix44 +{-# INLINE multiply44 #-} +multiply44 !mat1 !mat2 = {-# SCC "multiply44" #-} + Matrix44 { m11 = s11*f11 + s21*f12 + s31*f13 + s41*f14 + , m21 = s11*f21 + s21*f22 + s31*f23 + s41*f24 + , m31 = s11*f31 + s21*f32 + s31*f33 + s41*f34 + , m41 = s11*f41 + s21*f42 + s31*f43 + s41*f44 + , m12 = s12*f11 + s22*f12 + s32*f13 + s42*f14 + , m22 = s12*f21 + s22*f22 + s32*f23 + s42*f24 + , m32 = s12*f31 + s22*f32 + s32*f33 + s42*f34 + , m42 = s12*f41 + s22*f42 + s32*f43 + s42*f44 + , m13 = s13*f11 + s23*f12 + s33*f13 + s43*f14 + , m23 = s13*f21 + s23*f22 + s33*f23 + s43*f24 + , m33 = s13*f31 + s23*f32 + s33*f33 + s43*f34 + , m43 = s13*f41 + s23*f42 + s33*f43 + s43*f44 + , m14 = s14*f11 + s24*f12 + s34*f13 + s44*f14 + , m24 = s14*f21 + s24*f22 + s34*f23 + s44*f24 + , m34 = s14*f31 + s24*f32 + s34*f33 + s44*f34 + , m44 = s14*f41 + s24*f42 + s34*f43 + s44*f44 } + where + f11 = m11 mat1 + f21 = m21 mat1 + f31 = m31 mat1 + f41 = m41 mat1 + f12 = m12 mat1 + f22 = m22 mat1 + f32 = m32 mat1 + f42 = m42 mat1 + f13 = m13 mat1 + f23 = m23 mat1 + f33 = m33 mat1 + f43 = m43 mat1 + f14 = m14 mat1 + f24 = m24 mat1 + f34 = m34 mat1 + f44 = m44 mat1 + s11 = m11 mat2 + s21 = m21 mat2 + s31 = m31 mat2 + s41 = m41 mat2 + s12 = m12 mat2 + s22 = m22 mat2 + s32 = m32 mat2 + s42 = m42 mat2 + s13 = m13 mat2 + s23 = m23 mat2 + s33 = m33 mat2 + s43 = m43 mat2 + s14 = m14 mat2 + s24 = m24 mat2 + s34 = m34 mat2 + s44 = m44 mat2 + +-- | Returns the Euclidean distance between two 3x3 matrices, where the +-- matrices are taken to be 9-vectors. +-- +-- This can be used as a rough estimate how close, or similar two matrices are +-- to each other. +distance33 :: Matrix33 -> Matrix33 -> Float +{-# INLINE distance33 #-} +distance33 !mat1 !mat2 = {-# SCC "distance33" #-} + sqrt $ (f11-s11)**2+ + (f12-s12)**2+ + (f13-s13)**2+ + (f21-s21)**2+ + (f22-s22)**2+ + (f23-s23)**2+ + (f31-s31)**2+ + (f32-s32)**2+ + (f33-s33)**2 + where + f11 = n11 mat1 + f21 = n21 mat1 + f31 = n31 mat1 + f12 = n12 mat1 + f22 = n22 mat1 + f32 = n32 mat1 + f13 = n13 mat1 + f23 = n23 mat1 + f33 = n33 mat1 + s11 = n11 mat2 + s21 = n21 mat2 + s31 = n31 mat2 + s12 = n12 mat2 + s22 = n22 mat2 + s32 = n32 mat2 + s13 = n13 mat2 + s23 = n23 mat2 + s33 = n33 mat2 + +-- | Returns the Euclidean distance between two 4x4 matrices, where the +-- matrices are taken to be 9-vectors. +-- +-- This can be used as a rough estimate how close, or similar two matrices are +-- to each other. +distance44 :: Matrix44 -> Matrix44 -> Float +{-# INLINE distance44 #-} +distance44 !mat1 !mat2 = {-# SCC "distance44" #-} + sqrt $ (f11-s11)**2+ + (f12-s12)**2+ + (f13-s13)**2+ + (f14-s14)**2+ + (f21-s21)**2+ + (f22-s22)**2+ + (f23-s23)**2+ + (f24-s24)**2+ + (f31-s31)**2+ + (f32-s32)**2+ + (f33-s33)**2+ + (f34-s34)**2+ + (f41-s41)**2+ + (f42-s42)**2+ + (f43-s43)**2+ + (f44-s44)**2 + where + f11 = m11 mat1 + f21 = m21 mat1 + f31 = m31 mat1 + f41 = m41 mat1 + f12 = m12 mat1 + f22 = m22 mat1 + f32 = m32 mat1 + f42 = m42 mat1 + f13 = m13 mat1 + f23 = m23 mat1 + f33 = m33 mat1 + f43 = m43 mat1 + f14 = m14 mat1 + f24 = m24 mat1 + f34 = m34 mat1 + f44 = m44 mat1 + s11 = m11 mat2 + s21 = m21 mat2 + s31 = m31 mat2 + s41 = m41 mat2 + s12 = m12 mat2 + s22 = m22 mat2 + s32 = m32 mat2 + s42 = m42 mat2 + s13 = m13 mat2 + s23 = m23 mat2 + s33 = m33 mat2 + s43 = m43 mat2 + s14 = m14 mat2 + s24 = m24 mat2 + s34 = m34 mat2 + s44 = m44 mat2 + +-- | Constructs a perspective projection matrix. +perspective44 :: Float -- ^ Field of view in radians. + -> Float -- ^ Aspect ratio. + -> Float -- ^ Near plane distance. + -> Float -- ^ Far plane distance. + -> Matrix44 +{-# INLINE perspective44 #-} +perspective44 !fov_y !aspect_ratio !near !far = {-# SCC "perspective44" #-} + frustum44 (-right) right (-top) top near far + where + top = near * tan fov_y + right = top * aspect_ratio + + +-- | Constructs a perspective projection matrix by frustum planes. +frustum44 :: Float -- ^ Left plane. + -> Float -- ^ Right plane. + -> Float -- ^ Bottom plane. + -> Float -- ^ Top plane. + -> Float -- ^ Near plane. + -> Float -- ^ Far plane. + -> Matrix44 +{-# INLINE frustum44 #-} +frustum44 !left !right !bottom !top !near !far = {-# SCC "frustum44" #-} + zero44 { m11 = n2 * rl + , m22 = n2 * tb + , m13 = (right + left) * rl + , m23 = (top + bottom) * tb + , m33 = (far + near) * nf + , m43 = -1.0 + , m34 = far * n2 * nf } + where + rl = 1.0 / (right - left) + tb = 1.0 / (top - bottom) + nf = 1.0 / (near - far) + n2 = near * 2.0 + +-- | Constructs an orthogonal projection matrix by planes. +ortho44 :: Float -- ^ Left plane. + -> Float -- ^ Right plane. + -> Float -- ^ Bottom plane. + -> Float -- ^ Top plane. + -> Float -- ^ Near plane. + -> Float -- ^ Far plane. + -> Matrix44 +{-# INLINE ortho44 #-} +ortho44 !left !right !bottom !top !near !far = {-# SCC "ortho44" #-} + zero44 { m11 = (-2.0) * lr + , m22 = (-2.0) * bt + , m33 = 2.0 * nf + , m14 = (left + right) * lr + , m24 = (top + bottom) * bt + , m34 = (far + near) * nf + , m44 = 1.0 } + where + lr = 1.0 / (left - right) + bt = 1.0 / (bottom - top) + nf = 1.0 / (near - far) + +-- | Constructs a look-at view matrix. +lookat44 :: Vector3 -- ^ Eye position. + -> Vector3 -- ^ Center position (that is, the point we are going + -- to stare at). + -> Vector3 -- ^ Up vector. You probably want to normalize this. + -> Matrix44 +{-# INLINE lookat44 #-} +lookat44 eye@(Vector3 !eyex !eyey !eyez) !center (Vector3 !ux !uy !uz) + | ec_len < 0.000001 = identity44 + | otherwise = {-# SCC "lookat44" #-} + Matrix44 { m11 = xx, m21 = yx, m31 = ecx, m41 = 0.0 + , m12 = xy, m22 = yy, m32 = ecy, m42 = 0.0 + , m13 = xz, m23 = yz, m33 = ecz, m43 = 0.0 + , m14 = -(xx * eyex + xy * eyey + xz * eyez) + , m24 = -(yx * eyex + yy * eyey + yz * eyez) + , m34 = -(ecx * eyex + ecy * eyey + ecz * eyez) + , m44 = 1.0 } + where + ec = eye `minus3` center + Vector3 ecx ecy ecz = normalize3 ec + ec_len = length3 ec + + yvec = Vector3 (ecy*xz - ecz*xy) + (ecz*xx - ecx*xz) + (ecx*xy - ecy*xx) + Vector3 yx yy yz = + if length3 yvec == 0.0 + then Vector3 0 0 0 + else normalize3 yvec + + xvec = Vector3 (uy*ecz - uz*ecy) + (uz*ecx - ux*ecz) + (ux*ecy - uy*ecx) + Vector3 xx xy xz = + if length3 xvec == 0.0 + then Vector3 0 0 0 + else normalize3 xvec + +-- | Normalizes a 3-vector to unit length. +-- +-- If the vector is a zero vector then this probably gives you a vector with +-- NaNs as values. +normalize3 :: Vector3 -> Vector3 +{-# INLINE normalize3 #-} +normalize3 v@(Vector3 !x !y !z) = {-# SCC "normalize3" #-} + Vector3 (x*ilen) (y*ilen) (z*ilen) + where + ilen = 1.0 / length3 v + +-- | Returns the Euclidean distance between to 3-vectors. +distance3 :: Vector3 -> Vector3 -> Float +{-# INLINE distance3 #-} +distance3 (Vector3 !x1 !y1 !z1) (Vector3 !x2 !y2 !z2) = {-# SCC "distance3" #-} + sqrt $ (x2-x1)**2 + (y2-y1)**2 + (z2-z1)**2 + +-- | Returns the length of a 3-vector. +length3 :: Vector3 -> Float +{-# INLINE length3 #-} +length3 (Vector3 !x !y !z) = {-# SCC "length3" #-} sqrt $ x**2 + y**2 + z**2 + +-- | Sums two 3-vectors together. +plus3 :: Vector3 -> Vector3 -> Vector3 +{-# INLINE plus3 #-} +plus3 (Vector3 !x1 !y1 !z1) (Vector3 !x2 !y2 !z2) = {-# SCC "plus3" #-} + Vector3 (x1+x2) (y1+y2) (z1+z2) + +-- | Subtracts the second 3-vector from the first. +minus3 :: Vector3 -> Vector3 -> Vector3 +{-# INLINE minus3 #-} +minus3 (Vector3 !x1 !y1 !z1) (Vector3 !x2 !y2 !z2) = {-# SCC "minus3" #-} + Vector3 (x1-x2) (y1-y2) (z1-z2) + +-- | Negates all components of a 3-vector. +negative3 :: Vector3 -> Vector3 +{-# INLINE negative3 #-} +negative3 (Vector3 !x !y !z) = {-# SCC "negative3" #-} Vector3 (-x) (-y) (-z) + +-- | Multiplies all components of a 3-vector with a scalar. +scalarMultiply3 :: Float -> Vector3 -> Vector3 +{-# INLINE scalarMultiply3 #-} +scalarMultiply3 scalar (Vector3 !x !y !z) = {-# SCC "scalarMultiply3" #-} + Vector3 (x*scalar) (y*scalar) (z*scalar) + +-- | Modify a 4x4 matrix to scale everything by given vector. +scale44 :: Vector3 -- ^ The scale vector. + -> Matrix44 -- ^ The matrix to modify. + -> Matrix44 +{-# INLINE scale44 #-} +scale44 (Vector3 !x !y !z) !mat = {-# SCC "scale44" #-} + mat { m11 = f11*x + , m21 = f21*x + , m31 = f31*x + , m41 = f41*x + , m12 = f12*y + , m22 = f22*y + , m32 = f32*y + , m42 = f42*y + , m13 = f13*z + , m23 = f23*z + , m33 = f33*z + , m43 = f43*z } + where + f11 = m11 mat + f21 = m21 mat + f31 = m31 mat + f41 = m41 mat + f12 = m12 mat + f22 = m22 mat + f32 = m32 mat + f42 = m42 mat + f13 = m13 mat + f23 = m23 mat + f33 = m33 mat + f43 = m43 mat + +-- | Transposes a 3x3 matrix. +transpose33 :: Matrix33 -> Matrix33 +{-# INLINE transpose33 #-} +transpose33 !mat = {-# SCC "transpose33" #-} + Matrix33 { n11 = f11 + , n12 = f21 + , n13 = f31 + , n21 = f12 + , n22 = f22 + , n23 = f32 + , n31 = f13 + , n32 = f23 + , n33 = f33 } + where + f11 = n11 mat + f21 = n21 mat + f31 = n31 mat + f12 = n12 mat + f22 = n22 mat + f32 = n32 mat + f13 = n13 mat + f23 = n23 mat + f33 = n33 mat + +-- | Transposes a 4x4 matrix. +transpose44 :: Matrix44 -> Matrix44 +{-# INLINE transpose44 #-} +transpose44 !mat = {-# SCC "transpose44" #-} + Matrix44 { m11 = f11 + , m12 = f21 + , m13 = f31 + , m14 = f41 + , m21 = f12 + , m22 = f22 + , m23 = f32 + , m24 = f42 + , m31 = f13 + , m32 = f23 + , m33 = f33 + , m34 = f43 + , m41 = f14 + , m42 = f24 + , m43 = f34 + , m44 = f44 } + where + f11 = m11 mat + f21 = m21 mat + f31 = m31 mat + f41 = m41 mat + f12 = m12 mat + f22 = m22 mat + f32 = m32 mat + f42 = m42 mat + f13 = m13 mat + f23 = m23 mat + f33 = m33 mat + f43 = m43 mat + f14 = m14 mat + f24 = m24 mat + f34 = m34 mat + f44 = m44 mat + +-- | Modifies a 4x4 matrix to include translation. +-- +-- This is the same as multiplying a 4x4 matrix with a translation matrix. +translate44 :: Vector3 -- ^ The translation vector. + -> Matrix44 -- ^ The matrix to modify. + -> Matrix44 +{-# INLINE translate44 #-} +translate44 (Vector3 !x !y !z) !mat = {-# SCC "translate44" #-} + mat { m14 = f11*x + f12*y + f13*z + f14 + , m24 = f21*x + f22*y + f23*z + f24 + , m34 = f31*x + f32*y + f33*z + f34 + , m44 = f41*x + f42*y + f43*z + f44 } + where + f11 = m11 mat + f21 = m21 mat + f31 = m31 mat + f41 = m41 mat + f12 = m12 mat + f22 = m22 mat + f32 = m32 mat + f42 = m42 mat + f13 = m13 mat + f23 = m23 mat + f33 = m33 mat + f43 = m43 mat + f14 = m14 mat + f24 = m24 mat + f34 = m34 mat + f44 = m44 mat + +-- | Modifies a 4x4 matrix to include rotation as specified by an axis-angle +-- representation. +-- +-- This is the same as multiplying a matrix with a rotation matrix. +rotate44 :: Float -- ^ The angle, how much to rotate. In radians. + -> Vector3 -- ^ The rotation axis. + -> Matrix44 -- ^ The matrix to modify. + -> Matrix44 +{-# INLINE rotate44 #-} +rotate44 !radians !axis !mat = {-# SCC "rotate44" #-} + mat { m11 = f11*r11 + f21*r12 + f31*r13 + , m21 = f12*r11 + f21*r12 + f32*r13 + , m31 = f13*r11 + f23*r12 + f33*r13 + , m41 = f14*r11 + f24*r12 + f34*r13 + , m12 = f11*r21 + f21*r22 + f31*r23 + , m22 = f12*r21 + f22*r22 + f32*r23 + , m32 = f13*r21 + f23*r22 + f33*r23 + , m42 = f14*r21 + f24*r22 + f34*r23 + , m13 = f11*r31 + f21*r32 + f31*r33 + , m23 = f12*r31 + f22*r32 + f32*r33 + , m33 = f13*r31 + f23*r32 + f33*r33 + , m43 = f14*r31 + f24*r32 + f31*r33 } + where + r11 = x*x*t+cosf + r12 = y*x*t+z*sinf + r13 = z*x*t-y*sinf + r21 = x*y*t-z*sinf + r22 = y*y*t+cosf + r23 = z*y*t+x*sinf + r31 = x*z*t+y*sinf + r32 = y*z*t-x*sinf + r33 = z*z*t+cosf + + f11 = m11 mat + f21 = m21 mat + f31 = m31 mat + f12 = m12 mat + f22 = m22 mat + f32 = m32 mat + f13 = m13 mat + f23 = m23 mat + f33 = m33 mat + f14 = m14 mat + f24 = m24 mat + f34 = m34 mat + + t = 1 - cosf + sinf = sin radians + cosf = cos radians + (Vector3 !x !y !z) = normalize3 axis + +-- | Transforms a 3-vector with a 4x4 matrix. +-- +-- This would be the same as transforming a 4-vector with a 4x4 matrix but the +-- fourth component is taken to be 1 and is not returned. +vector3Transform44 :: Matrix44 -> Vector3 -> Vector3 +{-# INLINE vector3Transform44 #-} +vector3Transform44 !mat (Vector3 !x !y !z) = {-# SCC "vector3Transform44" #-} + Vector3 { x = f11*x + f12*y + f13*z + f14 + , y = f21*x + f22*y + f23*z + f24 + , z = f31*x + f32*y + f33*z + f34 } + where + f11 = m11 mat + f21 = m21 mat + f31 = m31 mat + f12 = m12 mat + f22 = m22 mat + f32 = m32 mat + f13 = m13 mat + f23 = m23 mat + f33 = m33 mat + f14 = m14 mat + f24 = m24 mat + f34 = m34 mat + +-- | Returns the cross product between two 3-vectors. +cross3 :: Vector3 -> Vector3 -> Vector3 +{-# INLINE cross3 #-} +cross3 (Vector3 !x1 !y1 !z1) (Vector3 !x2 !y2 !z2) = {-# SCC "cross3" #-} + Vector3 { x = y1*z2 - z1*y2 + , y = z1*x2 - x1*z2 + , z = x1*y2 - y1*x2 } + +-- | Returns the angle, in radians, between two 3-vectors. +-- +-- The vectors are normalized by this function so you need not to do that +-- yourself. +angle3 :: Vector3 -> Vector3 -> Float +{-# INLINE angle3 #-} +angle3 v1 v2 = {-# SCC "angle3" #-} acos $ n1 `dot3` n2 + where + n1 = normalize3 v1 + n2 = normalize3 v2 + +-- | Returns the dot product between two 3-vectors. +dot3 :: Vector3 -> Vector3 -> Float +{-# INLINE dot3 #-} +dot3 (Vector3 !x1 !y1 !z1) (Vector3 !x2 !y2 !z2) = {-# SCC "dot3" #-} + x1*x2 + y1*y2 + z1*z2 + +-- | Transforms a 3-vector into a tuple. +toTuple3 :: Vector3 -> (Float, Float, Float) +{-# INLINE toTuple3 #-} +toTuple3 (Vector3 !x !y !z) = {-# SCC "toTuple3" #-} (x, y, z) + +-- | Transforms a tuple into a 3-vector. +fromTuple3 :: (Float, Float, Float) -> Vector3 +{-# INLINE fromTuple3 #-} +fromTuple3 (!x, !y, !z) = {-# SCC "fromTuple3" #-} + Vector3 { x = x, y = y, z = z } + +-- | Returns a vector where all components are 0. +zero3 :: Vector3 +{-# INLINE zero3 #-} +zero3 = {-# SCC "zero3" #-} Vector3 { x = 0, y = 0, z = 0 } + +-- | Transforms a 4x4 matrix to a list of floats. +-- +-- The list follows the same order as the `Storable` instance does for +-- `Matrix44` floating point values. The list will always have 16 elements. +toList4 :: Matrix44 -> [Float] +toList4 mat = {-# SCC "toList4" #-} + (\f -> f mat) <$> + [m11, m21, m31, m41 + ,m12, m22, m32, m42 + ,m13, m23, m33, m43 + ,m14, m24, m34, m44] + +-- | Construct a quaternion out of 4 values. +quaternion :: Float -- ^ The x-component. + -> Float -- ^ The y-component. + -> Float -- ^ The z-component. + -> Float -- ^ The w-component. + -> Quaternion +{-# INLINE quaternion #-} +quaternion !x !y !z !w = {-# SCC "quaternion" #-} + Quaternion { qx = x, qy = y, qz = z, qw = w } + +-- | Turns a quaternion into a 4-tuple. +toTupleq :: Quaternion -> (Float, Float, Float, Float) +{-# INLINE toTupleq #-} +toTupleq (Quaternion !x !y !z !w) = {-# SCC "toTupleq" #-} (x, y, z, w) + +-- | Turns a 4-tuple into a quaternion. +fromTupleq :: (Float, Float, Float, Float) -> Quaternion +{-# INLINE fromTupleq #-} +fromTupleq (!x, !y, !z, !w) = {-# SCC "fromTupleq" #-} Quaternion x y z w + +-- | \"canonicalizes\" a quaternion. +-- +-- Some rotations have different representations as a quaternion. This function +-- canonicalizes the quaternion so that those rotations are the same. +-- +-- Don't rely on this. This is used in some automatic tests to see that the +-- quaternions work correctly. +canonicalizeq :: Quaternion -> Quaternion +{-# INLINE canonicalizeq #-} +canonicalizeq q@(Quaternion !x !y !z !w) = {-# SCC "canonicalizeq" #-} + canonicalizeq' + where + canonicalizeq' + | w > 0 = q + | otherwise = Quaternion (-x) (-y) (-z) (-w) + +-- | Normalizes a quaternion to unit length. +normalizeq :: Quaternion -> Quaternion +{-# INLINE normalizeq #-} +normalizeq (Quaternion !x !y !z !w) = {-# SCC "normalizeq" #-} + Quaternion (x*t) (y*t) (z*t) (w*t) + where + t = 1.0 / sqrt (x*x + y*y + z*z + w*w) + +-- | Returns the Euclidean distance between two quaternions. +distanceq :: Quaternion -> Quaternion -> Float +{-# INLINE distanceq #-} +distanceq (Quaternion !x1 !y1 !z1 !w1) + (Quaternion !x2 !y2 !z2 !w2) = {-# SCC "distanceq" #-} + sqrt $ (x1-x2)**2 + (y1-y2)**2 + (z1-z2)**2 + (w1-w2)**2 + +-- | Returns the length of a quaternion. +lengthq :: Quaternion -> Float +{-# INLINE lengthq #-} +lengthq (Quaternion !x !y !z !w) = {-# SCC "lengthq" #-} + sqrt $ x*x + y*y + z*z + w*w + +-- | Turns an axis angle rotation into a quaternion. +axisAngleToQuaternion :: Float -- ^ The angle, in radians. + -> Vector3 -- ^ The rotation axis. + -> Quaternion +{-# INLINE axisAngleToQuaternion #-} +axisAngleToQuaternion !radians !vec = {-# SCC "axisAngleToQuaternion" #-} + Quaternion { qx = x * sin_angle + , qy = y * sin_angle + , qz = z * sin_angle + , qw = cos hangle } + where + Vector3 x y z = normalize3 vec + sin_angle = sin hangle + hangle = radians * 0.5 + +-- | Returns a quaternion where all the elements are zero. +zeroq :: Quaternion +{-# INLINE zeroq #-} +zeroq = {-# SCC "zeroq" #-} Quaternion 0 0 0 0 + +-- | Turns the quaternion into a 4x4 rotation matrix. +quaternionToMatrix44 :: Quaternion -> Matrix44 +{-# INLINE quaternionToMatrix44 #-} +quaternionToMatrix44 !q = {-# SCC "quaternionToMatrix44" #-} + identity44 { m11 = 1 - yy2 - zz2 + , m22 = 1 - xx2 - zz2 + , m33 = 1 - xx2 - yy2 + + , m32 = yz2 - wx2 + , m23 = yz2 + wx2 + , m21 = xy2 - wz2 + , m12 = xy2 + wz2 + , m13 = xz2 - wy2 + , m31 = xz2 + wy2 } + where + Quaternion x y z w = normalizeq q + x2 = x+x + y2 = y+y + z2 = z+z + xx2 = x*x2 + yy2 = y*y2 + zz2 = z*z2 + yz2 = y*z2 + wx2 = w*x2 + xy2 = x*y2 + wz2 = w*z2 + xz2 = x*z2 + wy2 = w*y2 + +-- | Extracts rotation from a 4x4 matrix and returns it as a quaternion. +-- +-- Note that +-- +-- @ +-- matrix44ToQuaternion . quaternionToMatrix44 +-- @ +-- +-- may not be the identity function. The signs on the quaternion components may +-- be different and because the floating point calculation is not completely +-- precise, the values are often slightly different than they were originally. +matrix44ToQuaternion :: Matrix44 -> Quaternion +{-# INLINE matrix44ToQuaternion #-} +matrix44ToQuaternion !mat = {-# SCC "matrix44ToQuaternion" #-} + matrix44ToQuaternion' + where + matrix44ToQuaternion' + | trace > 0 = + let t = trace + 1 + s = 0.5 * isqrt t + in Quaternion { qw = s * t + , qz = (f12 - f21) * s + , qy = (f31 - f13) * s + , qx = (f23 - f32) * s } + + | f11 > f22 && f11 > f33 = + let t = f11 - f22 - f33 + 1 + s = 0.5 * isqrt t + in Quaternion { qx = s * t + , qy = (f12 + f21) * s + , qz = (f31 + f13) * s + , qw = (f23 - f32) * s } + + | f22 > f33 = + let t = (-f11) + f22 - f33 + 1 + s = 0.5 * isqrt t + in Quaternion { qy = s * t + , qx = (f12 + f21) * s + , qw = (f31 - f13) * s + , qz = (f23 + f32) * s } + + | otherwise = + let t = (-f11) - f22 + f33 + 1 + s = 0.5 * isqrt t + in Quaternion { qz = s * t + , qw = (f12 - f21) * s + , qx = (f31 + f13) * s + , qy = (f23 + f32) * s } + + trace = f11 + f22 + f33 + isqrt = (1.0 /) . sqrt + + f11 = m11 mat + f21 = m21 mat + f31 = m31 mat + f12 = m12 mat + f22 = m22 mat + f32 = m32 mat + f13 = m13 mat + f23 = m23 mat + f33 = m33 mat + +-- | Returns the identity quaternion. It won't rotate anything. +identityq :: Quaternion +{-# INLINE identityq #-} +identityq = {-# SCC "identityq" #-} quaternion 0 0 0 1 + +{-# ANN vector3_1ToQuaternion ("HLint: ignore Use camelCase" :: String) #-} +-- | Turns a `Vector3` and an extra value to a quaternion. +vector3_1ToQuaternion :: Vector3 -> Float -> Quaternion +{-# INLINE vector3_1ToQuaternion #-} +vector3_1ToQuaternion (Vector3 x y z) = quaternion x y z + +-- | Multiplies two quaternions together. +multiplyq :: Quaternion -> Quaternion -> Quaternion +multiplyq (Quaternion !x1 !y1 !z1 !w1) + (Quaternion !x2 !y2 !z2 !w2) = {-# SCC "multiplyq" #-} + Quaternion { qw = w1*w2 - x1*x2 - y1*y2 - z1*z2 + , qx = w1*x2 + x1*w2 + y1*z2 - z1*y2 + , qy = w1*y2 - x1*z2 + y1*w2 + z1*x2 + , qz = w1*z2 + x1*y2 - y1*x2 + z1*w2 } + +pad :: Int -> String -> String +pad wanted_len str + | len < wanted_len = str ++ replicate (wanted_len - len) ' ' + | otherwise = str + where + len = length str + +-- | Returns a \"pretty\" string that represents a 4x4 matrix. +-- +-- This could be useful for debugging (and has been used as such in the +-- development of Caramia). The default `Show` instance for `Matrix44` is +-- machine-readable but annoying for humans to read. This function returns a +-- somewhat more human-readable string that you can display. +-- +-- The string will contain newlines. +prettyShow :: Matrix44 -> String +prettyShow mat = + lines [[f11,f12,f13,f14],[f21,f22,f23,f24], + [f31,f32,f33,f34],[f41,f42,f43,f44]] + where + lines = concatMap ((++ "\n") . line) + line marks = + "[ " ++ concatMap ((" " ++) . pad wanted_len . show) marks ++ " ]" + wanted_len = 1 + maximum (map (length . show) $ toList4 mat) + + f11 = m11 mat + f21 = m21 mat + f31 = m31 mat + f41 = m41 mat + f12 = m12 mat + f22 = m22 mat + f32 = m32 mat + f42 = m42 mat + f13 = m13 mat + f23 = m23 mat + f33 = m33 mat + f43 = m43 mat + f14 = m14 mat + f24 = m24 mat + f34 = m34 mat + f44 = m44 mat + diff --git a/src/Caramia/Memory.hs b/src/Caramia/Memory.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Memory.hs @@ -0,0 +1,64 @@ +-- | Retrieve video memory information. +-- + +{-# LANGUAGE MultiWayIf, NoImplicitPrelude, DeriveDataTypeable #-} + +module Caramia.Memory + ( getMemoryInfo + , MemoryInfo(..) ) + where + +import Caramia.Prelude +import Caramia.Context +import Caramia.Internal.OpenGLCApi +import Foreign.Marshal.Alloc +import Foreign.Storable + +data MemoryInfo = MemoryInfo + { availableVideoMemory :: !(Maybe Int) + , totalVideoMemory :: !(Maybe Int) } + deriving ( Eq, Ord, Show, Read, Typeable ) + +-- | Returns information about current state of video memory. +-- +-- There is no guarantee that all, or even any information is actually +-- returned. You need either \'GL_ATI_meminfo\' or \'GL_NVX_gpu_memory_info\' +-- extension to get any results. +-- +-- No guarantees for accuracy either. Seriously, don't rely on this for +-- anything but rough estimation. +getMemoryInfo :: IO MemoryInfo +getMemoryInfo = do + _ <- currentContextID -- Just checking that OpenGL context is active. + has_meminfo <- has_GL_ATI_meminfo + has_gpu_memory_info <- has_GL_NVX_gpu_memory_info + if | has_meminfo -> atiGetMem + | has_gpu_memory_info -> nvidiaGetMem + | otherwise -> return noInformation + +noInformation :: MemoryInfo +noInformation = MemoryInfo + { availableVideoMemory = Nothing + , totalVideoMemory = Nothing } + +atiGetMem :: IO MemoryInfo +atiGetMem = + alloca $ \result_ptr -> do + glGetIntegerv gl_TEXTURE_FREE_MEMORY_ATI result_ptr + result <- peek result_ptr + return MemoryInfo { availableVideoMemory = Just $ fromIntegral result + , totalVideoMemory = Nothing } + +nvidiaGetMem :: IO MemoryInfo +nvidiaGetMem = + alloca $ \result_ptr -> alloca $ \result2_ptr -> do + glGetIntegerv gl_GPU_MEMORY_INFO_DEDICATED_VIDMEM_NVX + result_ptr + glGetIntegerv gl_GPU_MEMORY_INFO_CURRENT_AVAILABLE_VIDMEM_NVX + result2_ptr + result <- peek result_ptr + result2 <- peek result2_ptr + return MemoryInfo { availableVideoMemory = Just $ fromIntegral result2 + , totalVideoMemory = Just $ fromIntegral result } + + diff --git a/src/Caramia/Prelude.hs b/src/Caramia/Prelude.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Prelude.hs @@ -0,0 +1,56 @@ +-- | This module is used as the prelude module inside Caramia. +-- + +{-# LANGUAGE ScopedTypeVariables #-} + +module Caramia.Prelude + ( module Ex + , safeFromIntegral + , showT + , atomicModifyIORef_' ) + where + +import Prelude as Ex hiding + ( sequence, mapM, or, concat, notElem, elem + , foldl, foldr1, concatMap, any, sum, foldr + , and, all, mapM_, sequence_, product, maximum + , foldl1, minimum, (.), id ) + +import Data.Foldable as Ex +import Data.Traversable as Ex +import Data.Int as Ex +import Data.Word as Ex +import Data.Typeable as Ex +import Control.Category as Ex +import Control.Arrow as Ex +import Control.Monad as Ex hiding ( msum, forM, forM_, sequence, mapM, mapM_ + , sequence_ ) +import Control.Applicative as Ex +import Data.Semigroup as Ex +import Data.Maybe as Ex +import Data.IORef as Ex +import qualified Data.Text as T + +-- | Same as `show` but the result will be a `T.Text`, not `String`. +showT :: Show a => a -> T.Text +showT = T.pack . show +{-# INLINE showT #-} + +-- | Same as `atomicModifyIORef'` but does not return a value. +atomicModifyIORef_' :: IORef a -> (a -> a) -> IO () +atomicModifyIORef_' ref fun = atomicModifyIORef' ref $ \old -> ( fun old, () ) +{-# INLINE atomicModifyIORef_' #-} + +-- | Similar to `fromIntegral` but raises a user error if the source +-- integer cannot be represented in the target type. +-- +-- This cannot turn an integral into a non-integral type. +safeFromIntegral :: forall a b. (Num a, Integral a, Num b, Integral b) => + a -> b +safeFromIntegral from + | from /= (fromIntegral result :: a) = error "Invalid coercion." + | otherwise = result + where + result = fromIntegral from :: b +{-# INLINE safeFromIntegral #-} + diff --git a/src/Caramia/Render.hs b/src/Caramia/Render.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Render.hs @@ -0,0 +1,455 @@ +-- | Rendering things. +-- + +{-# LANGUAGE RecordWildCards, GeneralizedNewtypeDeriving #-} +{-# LANGUAGE ViewPatterns, NoImplicitPrelude, DeriveDataTypeable #-} + +module Caramia.Render + ( + -- * The drawing functions + draw + , runDraws + -- * Draw command stream + , Draw() + , drawR + , setPipeline + , setTextureBindings + , setBlending + , setTargetFramebuffer + , setFragmentPassTests + , setPolygonOffset + -- * Specifying what to draw + , DrawCommand(..) + , drawCommand + , DrawParams(..) + , defaultDrawParams + , SourceData(..) + , IndexType(..) + , Primitive(..) + , IndexTypeable(..) + -- * Fragment pass tests + , FragmentPassTests(..) + , defaultFragmentPassTests + , ComparisonFunc(..) + , StencilOp(..) + , Culling(..) ) + where + +import Caramia.Prelude + +import qualified Caramia.VAO.Internal as VAO +import qualified Caramia.Shader.Internal as Shader +import qualified Caramia.Framebuffer as FBuf +import qualified Caramia.Framebuffer.Internal as FBuf +import qualified Caramia.Texture.Internal as Texture +import qualified Data.IntMap.Strict as IM +import Caramia.Render.Internal hiding ( setFragmentPassTests ) +import qualified Caramia.Render.Internal as I +import Caramia.Blend +import Caramia.Blend.Internal +import Caramia.Texture +import Caramia.Texture.Internal ( withTextureBinding ) +import Caramia.Resource +import Caramia.Buffer.Internal +import Caramia.Internal.OpenGLCApi +import Control.Monad.IO.Class +import Control.Monad.Trans.State.Strict +import Control.Exception +import Foreign +import Foreign.C.Types + +-- | The different types of primitives you can use for rendering. +-- +-- +data Primitive = + Triangles + | TriangleStrip + | TriangleFan + | Points + | Lines + | LineStrip + | LineLoop + | LinesAdjacency + | LineStripAdjacency + | TriangleStripAdjacency + | TrianglesAdjacency + deriving ( Eq, Ord, Show, Read ) + +toConstant :: Primitive -> GLenum +toConstant Triangles = gl_TRIANGLES +toConstant TriangleStrip = gl_TRIANGLE_STRIP +toConstant TriangleFan = gl_TRIANGLE_FAN +toConstant Points = gl_POINTS +toConstant Lines = gl_LINES +toConstant LineStrip = gl_LINE_STRIP +toConstant LineLoop = gl_LINE_LOOP +toConstant LinesAdjacency = gl_LINES_ADJACENCY +toConstant LineStripAdjacency = gl_LINE_STRIP_ADJACENCY +toConstant TriangleStripAdjacency = gl_TRIANGLE_STRIP_ADJACENCY +toConstant TrianglesAdjacency = gl_TRIANGLES_ADJACENCY + +-- | The type of indices in an index buffer. See `indexBuffer`. +data IndexType = + IWord32 + | IWord16 + | IWord8 + deriving ( Eq, Ord, Show, Read ) + +toConstantIT :: IndexType -> GLenum +toConstantIT IWord32 = gl_UNSIGNED_INT +toConstantIT IWord16 = gl_UNSIGNED_SHORT +toConstantIT IWord8 = gl_UNSIGNED_BYTE + +class IndexTypeable a where + -- | Turns a Haskell type to `IndexType`. + toIndexType :: a -- ^ Used to pass the type, not evaluated. + -> IndexType + +instance IndexTypeable Word32 where + toIndexType _ = IWord32 + +instance IndexTypeable Word16 where + toIndexType _ = IWord16 + +instance IndexTypeable Word8 where + toIndexType _ = IWord8 + +instance IndexTypeable CUInt where + toIndexType _ = IWord32 + +instance IndexTypeable CUShort where + toIndexType _ = IWord16 + +instance IndexTypeable CUChar where + toIndexType _ = IWord8 + +-- | Contains drawing parameters. +-- +-- You can use `defaultDrawParams` to obtain default draw parameters. +data DrawParams = DrawParams + { + pipeline :: Shader.Pipeline + -- ^ Which shader pipeline to use. + , fragmentPassTests :: !FragmentPassTests + -- ^ What kind of fragment pass tests to use. + , blending :: BlendSpec -- ^ Which blending to use. + , targetFramebuffer :: FBuf.Framebuffer + -- ^ Where do you want to render? + , bindTextures :: IM.IntMap Texture + -- ^ Which textures do you want to bind? The keys in this integer map are + -- `TextureUnit`s and tell which texture units you want to bind given + -- textures. + , polygonOffset :: !(Float, Float) + -- ^ Modify the depth values that are being written. + -- + -- @ (factor, units) @. + -- + -- By default this is (0, 0) (that is, do nothing). See @ glPolygonOffset @ + -- for the meaning of these values. + } + deriving ( Eq, Typeable ) + +-- | Default drawing parameters. +-- +-- `pipeline` is not set (that is, it's undefined). You must set it. +-- +-- No textures are bound. +-- +-- Blending mode is premultiplied alpha. +-- +-- `targetFramebuffer` is the screen framebuffer. +defaultDrawParams :: DrawParams +defaultDrawParams = DrawParams { + pipeline = error "defaultDrawParams: pipeline is not set." + , fragmentPassTests = defaultFragmentPassTests + , blending = preMultipliedAlpha + , bindTextures = IM.empty + , targetFramebuffer = FBuf.screenFramebuffer + , polygonOffset = (0, 0) } + +-- | Contains a specification of what to draw. +-- +-- It is recommended to use `drawCommand` instead of this constructor. +data DrawCommand = DrawCommand + { primitiveType :: Primitive + , primitivesVAO :: VAO.VAO -- ^ This is the VAO from which attributes + -- are retrieved in the shader pipeline. + , numIndices :: Int -- ^ How many indices to render? + , numInstances :: Int -- ^ How many instances to render. + , sourceData :: SourceData + -- ^ How to select the attribute data from `primitivesVAO`. + } + deriving ( Eq, Typeable ) + +-- | Returns a default draw command. +-- +-- Several fields are undefined so you must set them. These are +-- +-- * `primitiveType` +-- * `primitivesVAO` +-- * `numIndices` +-- * `sourceData` +-- +-- `numInstances` is set to 1. In future (minor) versions if we add any new +-- fields those fields will have a sane default value. +drawCommand :: DrawCommand +drawCommand = DrawCommand + { primitiveType = error "drawCommand: primitiveType is not set." + , primitivesVAO = error "drawCommand: primitivesVAO is not set." + , numIndices = error "drawCommand: numIndices is not set." + , sourceData = error "drawCommand: sourceData is not set." + , numInstances = 1 } +{-# INLINE drawCommand #-} + +-- | Values of this type tell how to select attribute data from +-- `primitivesVAO`. +-- +-- Future minor versions will not add any new fields or remove any fields from +-- these values. Instead, new constructors are introduced. +data SourceData = + -- | Simply start from some index and continue from there, 0, 1, 2, etc. + -- + -- OpenGL equivalent is @ glDrawArrays() @ or @ glDrawArraysInstanced() @. + Primitives + { firstIndex :: Int } + -- | Use an index buffer. + -- + -- OpenGL equivalent is @ glDrawElements() @ or @ glDrawElementsInstanced() + -- @. Index buffer contains indices that point to offsets in the vertex + -- arrays. + | PrimitivesWithIndices + { indexBuffer :: Buffer + , indexOffset :: Int + , indexType :: IndexType } + deriving ( Eq, Ord, Typeable ) + +-- | Draws according to a `DrawCommand`. +-- +-- There is a very large overhead in doing a single `draw` call. You probably +-- want to use `runDraws` and `drawR` instead. +draw :: DrawCommand -> DrawParams -> IO () +draw cmd params = runDraws params (drawR cmd) + +-- | Same as `draw` but in a `Draw` command stream. +drawR :: DrawCommand -> Draw () +drawR (DrawCommand {..}) + | numIndices == 0 = return () + | otherwise = Draw $ do + old_ebo <- boundEbo <$> get + liftIO $ + withResource (VAO.resource primitivesVAO) $ \(VAO.VAO_ vao_name) -> + withBoundVAO vao_name $ + case sourceData of + Primitives {..} -> + glDrawArraysInstanced + (toConstant primitiveType) + (safeFromIntegral firstIndex) + (safeFromIntegral numIndices) + (safeFromIntegral numInstances) + PrimitivesWithIndices {..} -> + withResource (resource indexBuffer) $ + \(Buffer_ buf_name) -> do + when (buf_name /= old_ebo) $ + setBoundElementBuffer buf_name + glDrawElementsInstanced + (toConstant primitiveType) + (safeFromIntegral numIndices) + (toConstantIT indexType) + (intPtrToPtr $ + fromIntegral indexOffset) + (safeFromIntegral numInstances) +-- inline `draw` because it's probably quite common to directly construct +-- `DrawCommand` right there, so we can avoid all sorts of boxing and checking +-- that happens. +{-# INLINE draw #-} + +-- We use a state to keep track of what we have bound. Why? For garbage +-- collection! If we don't keep references, it's possible things get garbage +-- collected under our feet because `runDraws` might have bound resources in +-- OpenGL with no Haskell values pointing to them. +data DrawState = DrawState + { boundPipeline :: !Shader.Pipeline + , boundEbo :: !GLuint + , boundTextures :: !(IM.IntMap Texture) + , boundBlending :: !BlendSpec + , boundFramebuffer :: !FBuf.Framebuffer + , boundFragmentPassTests :: !FragmentPassTests + , activeTexture :: !GLuint } + +newtype Draw a = Draw (StateT DrawState IO a) + deriving ( Monad, Applicative, Functor, Typeable ) + +-- | Using `liftIO` is safe inside a `Draw` stream. It is possible to run +-- nested `Draw` streams this way as well. +-- +-- One useful thing to do is to set uniforms to pipelines with `setUniform`. +instance MonadIO Draw where + liftIO = Draw . liftIO + +-- | Runs a drawing specification. +-- +-- You can think of this as running many `draw` commands with similar draw +-- command specifications. This call is an optimization to `draw` which has a +-- high overhead by itself. +-- +-- Another way to think of this is a place where the functional, \"no hidden +-- state\" design of the Caramia API is relaxed inside the `Draw` stream. +runDraws :: DrawParams -- ^ Initial drawing parameters. These can be + -- changed in the `Draw` command stream. + -> Draw a -- ^ Draw command stream. + -> IO a +runDraws params (Draw cmd_stream) = + withParams params $ do + (result, st) <- + runStateT cmd_stream DrawState + { boundPipeline = pipeline params + , boundFragmentPassTests = fragmentPassTests params + , boundEbo = 0 + , boundBlending = blending params + , boundFramebuffer = targetFramebuffer params + , boundTextures = bindTextures params + , activeTexture = 0 + } + st `seq` return result + +withParams :: DrawParams -> IO a -> IO a +withParams (DrawParams {..}) action = + FBuf.withBinding targetFramebuffer $ + withPipeline pipeline $ + withFragmentPassTests fragmentPassTests $ + withBlendings blending $ + withBoundTextures bindTextures $ + withBoundElementBuffer 0 $ + withPolygonOffset polygonOffset $ do + old_active <- gi gl_ACTIVE_TEXTURE + -- Framebuffer may not restore the viewport so we have to do it here. + allocaArray 4 $ \viewport_ptr -> do + glGetIntegerv gl_VIEWPORT viewport_ptr + ox <- peekElemOff viewport_ptr 0 + oy <- peekElemOff viewport_ptr 1 + ow <- peekElemOff viewport_ptr 2 + oh <- peekElemOff viewport_ptr 3 + finally (glActiveTexture gl_TEXTURE0 *> + action) + (glActiveTexture old_active *> + glViewport ox oy ow oh) + +withPolygonOffset :: (Float, Float) -> IO a -> IO a +withPolygonOffset (factor, units) action = do + old_factor <- gf gl_POLYGON_OFFSET_FACTOR + old_units <- gf gl_POLYGON_OFFSET_UNITS + finally (do glPolygonOffset (CFloat factor) (CFloat units) + action) $ + glPolygonOffset old_factor old_units + +-- | Sets the active texture (not public API! What would they use this for +-- anyway?). +setActiveTexture :: GLuint -> Draw () +setActiveTexture unit = Draw $ do + old_active <- activeTexture <$> get + when (old_active /= unit) $ + liftIO (glActiveTexture $ gl_TEXTURE0 + unit) *> + modify (\old -> old { activeTexture = unit }) + +-- | Sets new texture bindings. +setTextureBindings :: IM.IntMap Texture -> Draw () +setTextureBindings texes = do + old_texes <- Draw $ boundTextures <$> get + -- Iterate over the old bindings. + for_ (IM.assocs old_texes) $ \(index, tex) -> + case IM.lookup index texes of + -- A texture was bound previously, new bindings don't bind the + -- texture at this unit. + Nothing -> setActiveTexture (safeFromIntegral index) *> + let (bind_target, _) = + Texture.getTopologyBindPoints $ + topology $ viewSpecification tex + in liftIO $ glBindTexture bind_target 0 + -- A texture was bound previously, new bindings also bind some + -- texture here. + Just new_tex -> do + old_name <- + liftIO $ withResource (Texture.resource tex) $ + \(Texture.Texture_ old_name) -> return old_name + name <- + liftIO $ withResource (Texture.resource new_tex) $ + \(Texture.Texture_ name) -> return name + -- Only bind if the texture changed. + when (name /= old_name) $ do + setActiveTexture (safeFromIntegral index) + let (bind_target, _) = + Texture.getTopologyBindPoints $ + topology $ viewSpecification new_tex + in liftIO $ glBindTexture bind_target name + -- Iterate over new bindings. We need to only check those that were not + -- part of the old bindings. + for_ (IM.assocs texes) $ \(index, tex) -> + case IM.lookup index old_texes of + Just _ -> pure () -- already handled in the above for_ + Nothing -> do + name <- liftIO $ withResource (Texture.resource tex) $ + \(Texture.Texture_ name) -> return name + setActiveTexture (safeFromIntegral index) + let (bind_target, _) = + Texture.getTopologyBindPoints $ + topology $ viewSpecification tex + in liftIO $ glBindTexture bind_target name + + Draw $ modify (\old -> old { boundTextures = texes }) + +-- | Changes the pipeline in a `Draw` command stream. +setPipeline :: Shader.Pipeline -> Draw () +setPipeline pl = Draw $ do + old_pl <- boundPipeline <$> get + when (old_pl /= pl) $ do + liftIO $ withResource (Shader.resourcePL pl) $ + \(Shader.Pipeline_ program) -> + setBoundProgram program + modify (\old -> old { boundPipeline = pl }) +{-# INLINE setPipeline #-} + +-- | Changes the current blending mode. +setBlending :: BlendSpec -> Draw () +setBlending blends = Draw $ do + old_blending <- boundBlending <$> get + when (blends /= old_blending) $ do + liftIO $ setBlendings blends + modify (\old -> old { boundBlending = blends }) +{-# INLINE setBlending #-} + +-- | Sets the new fragment pass tests. +setFragmentPassTests :: FragmentPassTests -> Draw () +setFragmentPassTests tests = Draw $ do + old_tests <- boundFragmentPassTests <$> get + when (old_tests /= tests) $ do + liftIO $ I.setFragmentPassTests tests + modify (\old -> old { boundFragmentPassTests = tests }) +{-# INLINE setFragmentPassTests #-} + +-- | Sets polygon offset. +setPolygonOffset :: Float -> Float -> Draw () +setPolygonOffset factor units = Draw $ + liftIO $ glPolygonOffset (CFloat factor) (CFloat units) + +-- | Sets the current framebuffer. +setTargetFramebuffer :: FBuf.Framebuffer -> Draw () +setTargetFramebuffer fbuf = Draw $ do + old_fbuf <- boundFramebuffer <$> get + when (old_fbuf /= fbuf) $ do + liftIO $ FBuf.setBinding fbuf + modify (\old -> old { boundFramebuffer = fbuf }) +{-# INLINE setTargetFramebuffer #-} + +withBoundTextures :: IM.IntMap Texture -> IO a -> IO a +withBoundTextures (IM.assocs -> bindings) action = rec bindings + where + rec [] = action + rec ((unit, tex):rest) = + withTextureBinding tex unit $ rec rest + +withPipeline :: Shader.Pipeline -> IO a -> IO a +withPipeline pipeline action = + withResource (Shader.resourcePL pipeline) $ \(Shader.Pipeline_ program) -> + withBoundProgram program action +{-# INLINE withPipeline #-} + diff --git a/src/Caramia/Render/Internal.hs b/src/Caramia/Render/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Render/Internal.hs @@ -0,0 +1,239 @@ +{-# LANGUAGE RecordWildCards, NoImplicitPrelude, DeriveDataTypeable #-} + +module Caramia.Render.Internal where + +import Caramia.Prelude + +import Caramia.Internal.OpenGLCApi +import Control.Exception + +-- | A comparison function. Incoming value is compared with this function to +-- the existing value. +-- +-- This can be used with depth and stencil tests. +-- +-- See @ glDepthFunc @ from OpenGL specification or man pages for more detailed +-- explanation. +data ComparisonFunc = + Never + | Less + | Equal + | LEqual + | Greater + | NotEqual + | GEqual + | Always + deriving ( Eq, Ord, Show, Read, Typeable ) + +comparisonFuncToConstant :: ComparisonFunc -> GLenum +comparisonFuncToConstant Never = gl_NEVER +comparisonFuncToConstant Less = gl_LESS +comparisonFuncToConstant Equal = gl_EQUAL +comparisonFuncToConstant LEqual = gl_LEQUAL +comparisonFuncToConstant Greater = gl_GREATER +comparisonFuncToConstant NotEqual = gl_NOTEQUAL +comparisonFuncToConstant GEqual = gl_GEQUAL +comparisonFuncToConstant Always = gl_ALWAYS + +-- | Stencil buffer operations. +-- +-- See @ glStencilOp @ for explanations of each constructor. +data StencilOp = + Keep + | Zero + | Replace + -- ^ This one replaces the old value in the stencil buffer with the given + -- reference value and ANDs the result with mask. + | Increment + | IncrementAndWrap + | Decrease + | DecreaseAndWrap + | Invert + deriving ( Eq, Ord, Show, Read, Typeable ) + +stencilOpToConstant :: StencilOp -> GLenum +stencilOpToConstant Keep = gl_KEEP +stencilOpToConstant Zero = gl_ZERO +stencilOpToConstant Replace = gl_REPLACE +stencilOpToConstant Increment = gl_INCR +stencilOpToConstant IncrementAndWrap = gl_INCR_WRAP +stencilOpToConstant Decrease = gl_DECR +stencilOpToConstant DecreaseAndWrap = gl_DECR_WRAP +stencilOpToConstant Invert = gl_INVERT + +setStencilFunc :: ComparisonFunc + -> StencilOp + -> StencilOp + -> StencilOp + -> Word32 + -> Word32 + -> IO () +setStencilFunc func op1 op2 op3 ref mask = do + glStencilFunc (comparisonFuncToConstant func) + (fromIntegral ref) + (fromIntegral mask) + glStencilOp (stencilOpToConstant op1) + (stencilOpToConstant op2) + (stencilOpToConstant op3) +{-# INLINE setStencilFunc #-} + +withStencilFunc :: ComparisonFunc + -> StencilOp + -> StencilOp + -> StencilOp + -> Word32 + -> Word32 + -> IO a + -> IO a +withStencilFunc func op1 op2 op3 ref mask action = do + old_func <- gi gl_STENCIL_FUNC + old_ref <- gi gl_STENCIL_REF + old_mask <- gi gl_STENCIL_VALUE_MASK + old_op1 <- gi gl_STENCIL_FAIL + old_op2 <- gi gl_STENCIL_PASS_DEPTH_FAIL + old_op3 <- gi gl_STENCIL_PASS_DEPTH_PASS + finally (setStencilFunc func op1 op2 op3 ref mask *> action) + (glStencilFunc old_func (fromIntegral old_ref) old_mask *> + glStencilOp old_op1 old_op2 old_op3) + +withCulling :: Culling -> IO a -> IO a +withCulling culling action = do + old_culling <- gi gl_CULL_FACE_MODE + was_enabled <- glIsEnabled gl_CULL_FACE + finally (setCulling culling *> action) + (do if was_enabled == fromIntegral gl_TRUE + then glEnable gl_CULL_FACE + else glDisable gl_CULL_FACE + glCullFace old_culling) + +setCulling :: Culling -> IO () +setCulling NoCulling = glDisable gl_CULL_FACE +setCulling x = mask_ $ + glEnable gl_CULL_FACE *> + glCullFace (cullingToConstant x) + +setDepthFunc :: ComparisonFunc -> Bool -> IO () +setDepthFunc func write_depth = + glDepthFunc (comparisonFuncToConstant func) *> + glDepthMask (fromIntegral $ if write_depth then gl_TRUE else gl_FALSE) + +withDepthFunc :: ComparisonFunc -> Bool -> IO a -> IO a +withDepthFunc func write_depth action = do + old_depth_func <- gi gl_DEPTH_FUNC + old_depth_write <- gi gl_DEPTH_WRITEMASK + finally (setDepthFunc func write_depth *> action) + (glDepthFunc old_depth_func *> + glDepthMask (fromIntegral old_depth_write)) + +setFragmentPassTests :: FragmentPassTests -> IO () +setFragmentPassTests (FragmentPassTests {..}) = do + case depthTest of + Nothing -> glDisable gl_DEPTH_TEST + Just dt -> glEnable gl_DEPTH_TEST *> + setDepthFunc dt writeDepth + case stencilTest of + Nothing -> glDisable gl_STENCIL_TEST + Just st -> glEnable gl_STENCIL_TEST *> + setStencilFunc st + failStencilOp + depthFailStencilOp + depthPassStencilOp + stencilReference + stencilMask + setCulling cullFace + +withFragmentPassTests :: FragmentPassTests -> IO a -> IO a +withFragmentPassTests (FragmentPassTests {..}) action = do + was_it_enabled <- glIsEnabled gl_DEPTH_TEST + finally + (case depthTest of + Nothing -> glDisable gl_DEPTH_TEST *> next + Just dt -> glEnable gl_DEPTH_TEST *> + withDepthFunc dt writeDepth next) $ + if was_it_enabled == fromIntegral gl_TRUE + then glEnable gl_DEPTH_TEST + else glDisable gl_DEPTH_TEST + where + next = do + was_it_enabled <- glIsEnabled gl_STENCIL_TEST + finally + (case stencilTest of + Nothing -> glDisable gl_STENCIL_TEST *> next' + Just st -> glEnable gl_STENCIL_TEST *> + withStencilFunc st + failStencilOp + depthFailStencilOp + depthPassStencilOp + stencilReference + stencilMask + next') $ + if was_it_enabled == fromIntegral gl_TRUE + then glEnable gl_STENCIL_TEST + else glDisable gl_STENCIL_TEST + + next' = withCulling cullFace action + +data Culling = + Back + | Front + | FrontAndBack -- ^ This stops the drawing of any faces but points and lines + -- (or other non-facey like primitives) are drawn. + | NoCulling + deriving ( Eq, Ord, Show, Read, Typeable ) + +cullingToConstant :: Culling -> GLenum +cullingToConstant Back = gl_BACK +cullingToConstant Front = gl_FRONT +cullingToConstant FrontAndBack = gl_FRONT_AND_BACK +cullingToConstant NoCulling = 0 + +-- | Specifies the tests that are run on a fragment to decide if it should be +-- seen. +data FragmentPassTests = FragmentPassTests { + depthTest :: !(Maybe ComparisonFunc) + -- ^ Which depth test to use, if any? + , writeDepth :: Bool + -- ^ If depth test is specified, should we also update the depth buffer with + -- new depth values? The depth buffer will not be written if `depthTest` is + -- not specified regardless of the value in this field. + , stencilTest :: !(Maybe ComparisonFunc) + -- ^ Which stencil test to use, if any? + , stencilReference :: !Word32 + , stencilMask :: !Word32 + , failStencilOp :: !StencilOp + -- ^ What to do with the stencil buffer if stencil test fails. + , depthFailStencilOp :: !StencilOp + -- ^ What to do with the stencil buffer if stencil test passes but depth + -- testing fails). + , depthPassStencilOp :: !StencilOp + -- ^ What to do with the stencil buffer if stencil and depth test passes, or + -- if depth buffer is not present or depth test is disabled. + , cullFace :: !Culling + -- ^ What kind of face culling should we do. + } + deriving ( Eq, Ord, Show, Read, Typeable ) + +-- | Returns the default fragment pass tests. +-- +-- Neither depth or stencil test is enabled. `writeDepth` is set to true but +-- that value is only used if you specify with depth test to use. +-- +-- All stencil operations are set to `Keep`. +-- +-- Culling is set to `Back`. +defaultFragmentPassTests :: FragmentPassTests +defaultFragmentPassTests = FragmentPassTests + { depthTest = Nothing + , writeDepth = True + , stencilTest = Nothing + , stencilReference = 0 + , stencilMask = 0xffffffff + , failStencilOp = Keep + , depthFailStencilOp = Keep + , depthPassStencilOp = Keep + , cullFace = Back } + +-- TODO: separate stencil tests for backsides of triangles +-- (glStencilOpSeparate) + + diff --git a/src/Caramia/Resource.hs b/src/Caramia/Resource.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Resource.hs @@ -0,0 +1,144 @@ +-- | Caramia resources. +-- +-- Resources in Caramia encapsulate OpenGL resources which have some +-- constraints on their use: +-- +-- * They are, in the general case, only valid in a specific operating +-- system thread. +-- * They need an implicit OpenGL context active to be used. +-- +-- This module helps with the correct finalization of OpenGL resources as +-- according to those constraints. +-- +-- Most of the time, Caramia keeps `Resource` objects hidden so you, the user, +-- is unlikely to see these directly. +-- + +{-# LANGUAGE BangPatterns #-} + +module Caramia.Resource + ( Resource() + , newResource + , withResource ) + where + +import Caramia.Prelude +import Caramia.Context +import Control.Exception + +-- | The data type of a Caramia resource. +data Resource a = Resource + { rawResource :: !(IORef (Maybe + ( a -- the unmanaged resource + , IO () -- opengl finalizer + , IO ()))) -- normal finalizer + , nativeCid :: !ContextID + } + +instance Eq (Resource a) where + res1 == res2 = rawResource res1 == rawResource res2 + +-- | Creates a new resource. +-- +-- Must be called in a thread that has an OpenGL context active. Otherwise, an +-- error will be thrown. +-- +-- If you throw an exception in the OpenGL finalizer, then this will disrupt +-- Caramia context and make it invalid. So try not to throw those exceptions? +newResource :: IO a -- ^ Action that returns the raw, unmanaged + -- resource. Good place to create it. + -> (a -> IO ()) -- ^ OpenGL finalizer. Will only be called in + -- the same thread as this `newResource` is + -- called, but only if the same OpenGL + -- context is still alive. + -> IO () -- ^ \'Ordinary\' finalizer. This will be + -- called immediately when garbage collector + -- collects the resource which means before + -- the OpenGL finalizer and in a separate + -- thread. If this finalizer throws an + -- exception then the OpenGL finalizer is + -- cancelled and the resource is marked as + -- finalized. This will be run even if the + -- OpenGL context is gone. + -> IO (Resource a) +newResource resource_creator finalizer normal_finalizer = mask_ $ + -- We need the context ID for correct finalization so we cannot take away + -- this check with NO_RESOURCE_RUNTIME_CHECKS. + maybe (error "newResource: no OpenGL context active.") + (\cid -> do + resource <- resource_creator + let opengl_finalizer = finalizer resource + ref <- newIORef (Just ( resource + , opengl_finalizer + , normal_finalizer )) + let res = Resource { rawResource = ref + , nativeCid = cid } + void $ mkWeakIORef ref $ finalizeNow res + return res) + =<< + currentContextID + +-- | Promptly finalize a resource. +-- +-- The ordinary finalizer will be run immediately. The OpenGL finalizer will be +-- run if the current thread is the same OpenGL thread where the resource was +-- created. +-- +-- If you want asynchronous finalization, then use `finalizeAsync`, which +-- behaves more like actual garbage collection, only more promptly. +-- +-- I recommend you use `finalizeAsync` because it is more consistent with +-- normal garbage collection behaviour and thus is more difficult to use +-- incorrectly. +-- +-- If ordinary finalizer throws an exception, the OpenGL finalizer is not run +-- and the resource is marked as finalized. The exception propagates out from +-- this call to you. +-- +-- Does nothing if the resource is already finalized. +-- +-- *********************** +-- TODO: this is not actually exported API. Some resources cannot be finalized +-- like this because other resources might refer to them. How do we handle +-- resources that can refer to each other? Right now, we cannot. So we can't +-- allow users to finalize things by themselves. +finalizeNow :: Resource a -> IO () +finalizeNow resource = mask_ $ do + maybe_res <- atomicModifyIORef (rawResource resource) $ + \old -> ( Nothing, old ) + case maybe_res of + Nothing -> return () + Just (_, opengl_finalizer, normal_finalizer) -> do + normal_finalizer + let schedule = scheduleFinalizer (nativeCid resource) + opengl_finalizer + maybe schedule + (\cid -> + if cid == nativeCid resource + then opengl_finalizer + else schedule) + =<< + currentContextID + +-- | Uses a resource. +-- +-- Throws an user error if the resource is used in a wrong or dead context. +withResource :: Resource a + -> (a -> IO b) -- ^ Use the resource inside this action. Don't + -- return the unmanaged resource from this + -- because behaviour is then undefined. + -> IO b +withResource resource action = + maybe (error "withResource: resource has been finalized.") + (\(res, _, _) -> do + cid <- currentContextID + if cid == Just (nativeCid resource) + then action res <* touchIORef ref + else error $ "withResource: attempted resource use " <> + "in a wrong context.") + =<< + readIORef ref + where + ref = rawResource resource + touchIORef !_ = return () + diff --git a/src/Caramia/Shader.hs b/src/Caramia/Shader.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Shader.hs @@ -0,0 +1,539 @@ +-- | Shaders. +-- +-- This module lets you use GLSL shaders in rendering. +-- +-- This abstracts OpenGL shaders and shader objects. In the future, we might +-- implement separate shader programs (that is, +-- GL_ARB_separate_shader_objects). +-- +-- At the moment, you need to use explicit attribute locations in shaders +-- themselves. There is no functionality to retrieve attribute locations in +-- this API; you simply have to know them. +-- +-- +-- + +-- TODO: separable program objects. This is an extension and only became core +-- in OpenGL 4.1 (GL_ARB_separate_shader_objects). As of writing of this, I +-- think it's not prime time to use those yet. Maybe in a few years. +-- + +{-# LANGUAGE NoImplicitPrelude, FlexibleInstances, DeriveDataTypeable #-} +{-# LANGUAGE ExistentialQuantification, ViewPatterns, OverloadedStrings #-} + +module Caramia.Shader + ( newShader + , newPipeline + , newPipelineVF + , Shader() + , Pipeline() + -- * Uniforms + , setUniform + , getUniformLocation + , Uniformable() + , UniformLocation + -- * Shader stages + , ShaderStage(..) + -- * Views + , viewStage + -- * Misc + , nopPipeline + -- * Exception + , ShaderCompilationError(..) + , ShaderLinkingError(..) + , ShaderBuildingError(..) + ) + where + +import Caramia.Prelude + +import Caramia.Shader.Internal + +import Caramia.Context +import Caramia.Resource +import Caramia.Internal.OpenGLCApi +import Caramia.Math + +import GHC.Float ( double2Float ) + +import Control.Exception +import Foreign +import Foreign.C.Types +import qualified Data.ByteString as B +import qualified Data.Text as T +import qualified Data.Text.Encoding as T +import qualified Data.Text.Foreign as T + +type UniformLocation = Int + +-- TODO: add tesselation shaders + +toConstant :: ShaderStage -> GLenum +toConstant Vertex = gl_VERTEX_SHADER +toConstant Fragment = gl_FRAGMENT_SHADER +toConstant Geometry = gl_GEOMETRY_SHADER + +-- | Thrown when either a compilation or linking error occurs. +data ShaderBuildingError = forall e. Exception e => ShaderBuildingError e + deriving ( Typeable ) + +instance Show ShaderBuildingError where + show (ShaderBuildingError e) = show e + +-- | Thrown when a shader compilation error occurs. The text is the error log +-- for compilation. +-- +-- Can also be caught as `ShaderBuildingError`. +data ShaderCompilationError = ShaderCompilationError !T.Text + deriving ( Eq, Typeable, Show ) + +-- | Thrown when a shader linking error occurs. The text is the error log for +-- linking. +-- +-- Can also be caught as `ShaderBuildingError`. +data ShaderLinkingError = ShaderLinkingError !T.Text + deriving ( Eq, Typeable, Show ) + +instance Exception ShaderBuildingError + +shaderExceptionToException :: Exception e => e -> SomeException +shaderExceptionToException = toException . ShaderBuildingError + +shaderExceptionFromException :: Exception e => SomeException -> Maybe e +shaderExceptionFromException exc = do + ShaderBuildingError a <- fromException exc + cast a + +instance Exception ShaderCompilationError where + toException = shaderExceptionToException + fromException = shaderExceptionFromException + +instance Exception ShaderLinkingError where + toException = shaderExceptionToException + fromException = shaderExceptionFromException + +-- | Sets a uniform in a pipeline. +setUniform :: Uniformable a + => a + -> UniformLocation + -> Pipeline + -> IO () +setUniform uniformable location pipeline = + withResource (resourcePL pipeline) $ \(Pipeline_ program) -> + setUniform_ program (safeFromIntegral location) uniformable +{-# INLINE [1] setUniform #-} + +-- | Creates a shader from GLSL shader source. +-- +-- This can throw `ShaderCompilationError` if compilation fails. +newShader :: T.Text -- ^ The shader source code. + -> ShaderStage + -> IO Shader +newShader source_code stage = mask_ $ do + res <- newResource create + deleter + (return ()) + nid <- atomicModifyIORef' shaderIdentifierSupply $ \old -> + ( old + 1, old ) + return Shader { resource = res + , identifier = nid + , viewStage = stage } + where + deleter (CompiledShader shader) = + glDeleteShader shader + + create = do + shader_name <- glCreateShader (toConstant stage) + T.withCStringLen source_code $ \(cstr, len) -> + with cstr $ \cstr_ptr -> + with (fromIntegral len :: GLint) $ \len_ptr -> + glShaderSource + shader_name + 1 + cstr_ptr + len_ptr + glCompileShader shader_name + checkCompilationErrors shader_name + return $ CompiledShader shader_name + +-- | Checks that there are no compilation errors in an OpenGL shader object. +-- +-- DELETES the shader if there were errors. +checkCompilationErrors :: GLuint -> IO () +checkCompilationErrors shader_name = do + status <- gget $ glGetShaderiv shader_name gl_COMPILE_STATUS + when (status == fromIntegral gl_FALSE) $ do + log_len <- gget $ glGetShaderiv shader_name gl_INFO_LOG_LENGTH + allocaBytes (safeFromIntegral log_len) $ \str -> do + glGetShaderInfoLog shader_name log_len nullPtr str + log <- T.peekCStringLen ( str + , safeFromIntegral $ max 0 $ log_len-1 ) + glDeleteShader shader_name + throwIO $ ShaderCompilationError log + +-- | Same as `checkCompilationErrors` but for linking. +-- +-- DELETES the program if there were errors. +checkLinkingErrors :: GLuint -> IO () +checkLinkingErrors program_name = do + status <- gget $ glGetProgramiv program_name gl_LINK_STATUS + when (status == fromIntegral gl_FALSE) $ do + log_len <- gget $ glGetProgramiv program_name gl_INFO_LOG_LENGTH + allocaBytes (safeFromIntegral log_len) $ \str -> do + glGetProgramInfoLog program_name log_len nullPtr str + log <- T.peekCStringLen ( str + , safeFromIntegral $ max 0 $ log_len-1) + glDeleteProgram program_name + throwIO $ ShaderLinkingError log + +-- | Creates a pipeline from vertex and fragment shader source. +-- +-- This is a convenience function for a common use case. +newPipelineVF :: T.Text -- ^ Vertex shader source. + -> T.Text -- ^ Fragment shader source. + -> IO Pipeline +newPipelineVF vert_src frag_src = do + vsh <- newShader vert_src Vertex + fsh <- newShader frag_src Fragment + newPipeline [vsh, fsh] + +-- | Creates a pipeline composed of different shaders. +newPipeline :: [Shader] -> IO Pipeline +newPipeline = newTraditionalPipeline + +newTraditionalPipeline :: [Shader] -> IO Pipeline +newTraditionalPipeline shaders = mask_ $ do + res <- newResource creator + deleter + (return ()) + nid <- atomicModifyIORef' shaderIdentifierSupply $ \old -> + ( old+1, old ) + return Pipeline { resourcePL = res + , pipelineIdentifier = nid + , shaders = shaders } + where + creator = do + program <- glCreateProgram + for_ shaders $ \shader -> + withResource (resource shader) $ \(CompiledShader sname) -> + glAttachShader program sname + glLinkProgram program + checkLinkingErrors program + return $ Pipeline_ program + + deleter (Pipeline_ program) = glDeleteProgram program + +gget :: Storable a => (Ptr a -> IO ()) -> IO a +gget action = alloca $ \ptr -> action ptr >> peek ptr + +-- | Class of data types that can be set to a uniform in a shader pipeline. +-- +-- We provide instances for large integer values (such as `Integer`) but you +-- should know that uniforms are rarely larger than 32-bit. We throw a user +-- error if you pass a value that is larger than what the OpenGL API can accept +-- (which is 2^32-1 for unsigned integer types and 2^31-1 for signed integer +-- types). +class Uniformable a where + setUniform_ :: GLuint -> GLint -> a -> IO () + +type USetter1 a = GLuint -> GLint -> a -> IO () +type USetter2 a = GLuint -> GLint -> (a, a) -> IO () +type USetter3 a = GLuint -> GLint -> (a, a, a) -> IO () +type USetter4 a = GLuint -> GLint -> (a, a, a, a) -> IO () + +setUi1 :: Integral a => USetter1 a +setUi1 program loc w = + mglProgramUniform1ui program loc (safeFromIntegral w) +{-# INLINE setUi1 #-} + +setUi2 :: Integral a => USetter2 a +setUi2 program loc (w1, w2) = + mglProgramUniform2ui program loc (safeFromIntegral w1) + (safeFromIntegral w2) +{-# INLINE setUi2 #-} + +setUi3 :: Integral a => USetter3 a +setUi3 program loc (w1, w2, w3) = + mglProgramUniform3ui program loc (safeFromIntegral w1) + (safeFromIntegral w2) + (safeFromIntegral w3) +{-# INLINE setUi3 #-} + +setUi4 :: Integral a => USetter4 a +setUi4 program loc (w1, w2, w3, w4) = + mglProgramUniform4ui program loc (safeFromIntegral w1) + (safeFromIntegral w2) + (safeFromIntegral w3) + (safeFromIntegral w4) +{-# INLINE setUi4 #-} + +setI1 :: Integral a => USetter1 a +setI1 program loc w = + mglProgramUniform1i program loc (safeFromIntegral w) +{-# INLINE setI1 #-} + +setI2 :: Integral a => USetter2 a +setI2 program loc (w1, w2) = + mglProgramUniform2i program loc (safeFromIntegral w1) + (safeFromIntegral w2) +{-# INLINE setI2 #-} + +setI3 :: Integral a => USetter3 a +setI3 program loc (w1, w2, w3) = + mglProgramUniform3i program loc (safeFromIntegral w1) + (safeFromIntegral w2) + (safeFromIntegral w3) +{-# INLINE setI3 #-} + +setI4 :: Integral a => USetter4 a +setI4 program loc (w1, w2, w3, w4) = + mglProgramUniform4i program loc (safeFromIntegral w1) + (safeFromIntegral w2) + (safeFromIntegral w3) + (safeFromIntegral w4) +{-# INLINE setI4 #-} + +instance Uniformable Word8 where + setUniform_ = setUi1 +instance Uniformable (Word8, Word8) where + setUniform_ = setUi2 +instance Uniformable (Word8, Word8, Word8) where + setUniform_ = setUi3 +instance Uniformable (Word8, Word8, Word8, Word8) where + setUniform_ = setUi4 +instance Uniformable Word16 where + setUniform_ = setUi1 +instance Uniformable (Word16, Word16) where + setUniform_ = setUi2 +instance Uniformable (Word16, Word16, Word16) where + setUniform_ = setUi3 +instance Uniformable (Word16, Word16, Word16, Word16) where + setUniform_ = setUi4 +instance Uniformable Word32 where + setUniform_ = setUi1 +instance Uniformable (Word32, Word32) where + setUniform_ = setUi2 +instance Uniformable (Word32, Word32, Word32) where + setUniform_ = setUi3 +instance Uniformable (Word32, Word32, Word32, Word32) where + setUniform_ = setUi4 +instance Uniformable Word64 where + setUniform_ = setUi1 +instance Uniformable (Word64, Word64) where + setUniform_ = setUi2 +instance Uniformable (Word64, Word64, Word64) where + setUniform_ = setUi3 +instance Uniformable (Word64, Word64, Word64, Word64) where + setUniform_ = setUi4 +instance Uniformable CUInt where + setUniform_ = setUi1 +instance Uniformable (CUInt, CUInt) where + setUniform_ = setUi2 +instance Uniformable (CUInt, CUInt, CUInt) where + setUniform_ = setUi3 +instance Uniformable (CUInt, CUInt, CUInt, CUInt) where + setUniform_ = setUi4 +instance Uniformable CInt where + setUniform_ = setI1 +instance Uniformable (CInt, CInt) where + setUniform_ = setI2 +instance Uniformable (CInt, CInt, CInt) where + setUniform_ = setI3 +instance Uniformable (CInt, CInt, CInt, CInt) where + setUniform_ = setI4 + +instance Uniformable Int8 where + setUniform_ = setI1 +instance Uniformable (Int8, Int8) where + setUniform_ = setI2 +instance Uniformable (Int8, Int8, Int8) where + setUniform_ = setI3 +instance Uniformable (Int8, Int8, Int8, Int8) where + setUniform_ = setI4 +instance Uniformable Int16 where + setUniform_ = setI1 +instance Uniformable (Int16, Int16) where + setUniform_ = setI2 +instance Uniformable (Int16, Int16, Int16) where + setUniform_ = setI3 +instance Uniformable (Int16, Int16, Int16, Int16) where + setUniform_ = setI4 +instance Uniformable Int32 where + setUniform_ = setI1 +instance Uniformable (Int32, Int32) where + setUniform_ = setI2 +instance Uniformable (Int32, Int32, Int32) where + setUniform_ = setI3 +instance Uniformable (Int32, Int32, Int32, Int32) where + setUniform_ = setI4 +instance Uniformable Int64 where + setUniform_ = setI1 +instance Uniformable (Int64, Int64) where + setUniform_ = setI2 +instance Uniformable (Int64, Int64, Int64) where + setUniform_ = setI3 +instance Uniformable (Int64, Int64, Int64, Int64) where + setUniform_ = setI4 +instance Uniformable Int where + setUniform_ = setI1 +instance Uniformable (Int, Int) where + setUniform_ = setI2 +instance Uniformable (Int, Int, Int) where + setUniform_ = setI3 +instance Uniformable (Int, Int, Int, Int) where + setUniform_ = setI4 +instance Uniformable Integer where + setUniform_ = setI1 +instance Uniformable (Integer, Integer) where + setUniform_ = setI2 +instance Uniformable (Integer, Integer, Integer) where + setUniform_ = setI3 +instance Uniformable (Integer, Integer, Integer, Integer) where + setUniform_ = setI4 +instance Uniformable Float where + setUniform_ program loc f1 = + mglProgramUniform1f program loc (CFloat f1) +instance Uniformable (Float, Float) where + setUniform_ program loc (f1, f2) = + mglProgramUniform2f program loc (CFloat f1) (CFloat f2) +instance Uniformable (Float, Float, Float) where + setUniform_ program loc (f1, f2, f3) = + mglProgramUniform3f program loc + (CFloat f1) + (CFloat f2) + (CFloat f3) +instance Uniformable (Float, Float, Float, Float) where + setUniform_ program loc (f1, f2, f3, f4) = + mglProgramUniform4f program loc + (CFloat f1) + (CFloat f2) + (CFloat f3) + (CFloat f4) +instance Uniformable CFloat where + setUniform_ = mglProgramUniform1f +instance Uniformable (CFloat, CFloat) where + setUniform_ program loc (f1, f2) = + mglProgramUniform2f program loc f1 f2 +instance Uniformable (CFloat, CFloat, CFloat) where + setUniform_ program loc (f1, f2, f3) = + mglProgramUniform3f program loc f1 f2 f3 +instance Uniformable (CFloat, CFloat, CFloat, CFloat) where + setUniform_ program loc (f1, f2, f3, f4) = + mglProgramUniform4f program loc f1 f2 f3 f4 + +instance Uniformable Double where + setUniform_ program loc f1 = + mglProgramUniform1f program loc (double2CFloat f1) +instance Uniformable (Double, Double) where + setUniform_ program loc (f1, f2) = + mglProgramUniform2f program loc (double2CFloat f1) (double2CFloat f2) +instance Uniformable (Double, Double, Double) where + setUniform_ program loc (f1, f2, f3) = + mglProgramUniform3f program loc + (double2CFloat f1) + (double2CFloat f2) + (double2CFloat f3) +instance Uniformable (Double, Double, Double, Double) where + setUniform_ program loc (f1, f2, f3, f4) = + mglProgramUniform4f program loc + (double2CFloat f1) + (double2CFloat f2) + (double2CFloat f3) + (double2CFloat f4) +instance Uniformable CDouble where + setUniform_ program loc f1 = + mglProgramUniform1f program loc (cdouble2CFloat f1) +instance Uniformable (CDouble, CDouble) where + setUniform_ program loc (f1, f2) = + mglProgramUniform2f program loc (cdouble2CFloat f1) (cdouble2CFloat f2) +instance Uniformable (CDouble, CDouble, CDouble) where + setUniform_ program loc (f1, f2, f3) = + mglProgramUniform3f program loc + (cdouble2CFloat f1) + (cdouble2CFloat f2) + (cdouble2CFloat f3) +instance Uniformable (CDouble, CDouble, CDouble, CDouble) where + setUniform_ program loc (f1, f2, f3, f4) = + mglProgramUniform4f program loc + (cdouble2CFloat f1) + (cdouble2CFloat f2) + (cdouble2CFloat f3) + (cdouble2CFloat f4) + +instance Uniformable Vector3 where + setUniform_ program loc (toTuple3 -> tuple) = + setUniform_ program loc tuple + +instance Uniformable Quaternion where + setUniform_ program loc (toTupleq -> tuple) = + setUniform_ program loc tuple + +instance Uniformable Matrix33 where + setUniform_ program loc m33 = + withMatrix33Ptr m33 $ + mglProgramUniformMatrix3fv program loc 1 + (fromIntegral gl_FALSE) + +instance Uniformable Matrix44 where + setUniform_ program loc m44 = + withMatrix44Ptr m44 $ mglProgramUniformMatrix4fv program loc 1 + (fromIntegral gl_FALSE) + +-- these are for RULES firing +newtype Transpose33 = Transpose33 Matrix33 +newtype Transpose44 = Transpose44 Matrix44 + +instance Uniformable Transpose33 where + setUniform_ program loc (Transpose33 m33) = + withMatrix33Ptr m33 $ + mglProgramUniformMatrix3fv program loc 1 (fromIntegral gl_TRUE) + +instance Uniformable Transpose44 where + setUniform_ program loc (Transpose44 m44) = + withMatrix44Ptr m44 $ mglProgramUniformMatrix4fv program loc 1 + (fromIntegral gl_TRUE) + +double2CFloat :: Double -> CFloat +double2CFloat dbl = CFloat $ double2Float dbl + +cdouble2CFloat :: CDouble -> CFloat +cdouble2CFloat (CDouble dbl) = CFloat $ double2Float dbl + +{-# RULES "transpose/glProgramUniformMatrix3fv" forall (a :: Matrix33) b c. + setUniform (transpose33 a) b c = + setUniform (Transpose33 a) b c #-} + +{-# RULES "transpose/glProgramUniformMatrix4fv" forall (a :: Matrix44) b c. + setUniform (transpose44 a) b c = + setUniform (Transpose44 a) b c #-} + +-- | Returns a uniform location for a given name. +-- +-- The uniform may not be in the shader or it may not be active. If this +-- happens, a special uniform location is returned that can be used in +-- `setUniform` to make it do nothing. +getUniformLocation :: T.Text -> Pipeline -> IO UniformLocation +getUniformLocation name pipeline = fromIntegral <$> + withResource (resourcePL pipeline) (\(Pipeline_ program) -> + B.useAsCString (T.encodeUtf8 name) $ \cstr -> + glGetUniformLocation program cstr) + +-- context local pipeline +newtype CLNopPipeline = CLNopPipeline { unwrapCLNop :: Pipeline } + deriving ( Typeable ) + +-- | Returns a pipeline that does not do anything. +-- +-- Within the same context, this returns the same pipeline for each invocation. +nopPipeline :: IO Pipeline +nopPipeline = + unwrapCLNop <$> retrieveContextLocalData (CLNopPipeline <$> cr) + where + cr = do + vsh <- newShader vsh_src Vertex + fsh <- newShader fsh_src Fragment + newPipeline [vsh, fsh] + where + vsh_src = "#version 330\nvoid main() { }\n" + fsh_src = "#version 330\nvoid main() { }\n" + diff --git a/src/Caramia/Shader/Internal.hs b/src/Caramia/Shader/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Shader/Internal.hs @@ -0,0 +1,65 @@ +{-# LANGUAGE ViewPatterns, NoImplicitPrelude, DeriveDataTypeable #-} + +module Caramia.Shader.Internal + ( Shader(..) + , Pipeline(..) + , Pipeline_(..) + , Shader_(..) + , ShaderStage(..) + , shaderIdentifierSupply ) + where + +import Caramia.Prelude + +import Caramia.Resource +import System.IO.Unsafe +import Caramia.Internal.OpenGLCApi + +-- | A shader object for a specific shader stage. +-- +-- OpenGL equivalent is the shader object. +data Shader = Shader + { resource :: !(Resource Shader_) + , viewStage :: !ShaderStage + -- ^ Which stage does this shader belong to. + , identifier :: !Int + } + deriving ( Typeable ) + +instance Eq Shader where + (resource -> res1) == (resource -> res2) = res1 == res2 + +-- | The ordering has no inherent meaning but it allows shaders to be stored +-- correctly in containers that have `Ord` constraint. +instance Ord Shader where + (identifier -> id1) `compare` (identifier -> id2) = id1 `compare` id2 + +data Shader_ = CompiledShader !GLuint -- OpenGL shader + +-- | A pipeline object that references a collection of shaders. +-- +-- OpenGL equivalent is the shader program object. +data Pipeline = Pipeline + { resourcePL :: !(Resource Pipeline_) + , pipelineIdentifier :: !Int + , shaders :: [Shader] } + deriving ( Typeable ) + +instance Eq Pipeline where + p1 == p2 = resourcePL p1 == resourcePL p2 + +instance Ord Pipeline where + p1 `compare` p2 = pipelineIdentifier p1 `compare` pipelineIdentifier p2 + +newtype Pipeline_ = Pipeline_ GLuint + +shaderIdentifierSupply :: IORef Int +shaderIdentifierSupply = unsafePerformIO $ newIORef 0 +{-# NOINLINE shaderIdentifierSupply #-} + +data ShaderStage = + Vertex + | Fragment + | Geometry + deriving ( Eq, Ord, Show, Read ) + diff --git a/src/Caramia/Sync.hs b/src/Caramia/Sync.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Sync.hs @@ -0,0 +1,68 @@ +-- | Synchronization primitives. +-- +-- This module implements fence synchronization objects. They can be used to +-- check when a GPU operation has been done. +-- +-- At the moment, the only place where these objects are useful in Caramia is +-- unsynchronized buffer mapping. +-- + +{-# LANGUAGE NoImplicitPrelude, DeriveDataTypeable, MultiWayIf #-} + +module Caramia.Sync + ( + -- * Operations + fence + , waitFence + , isFenceSignalled + -- * Types + , Fence() ) + where + +import Caramia.Internal.OpenGLCApi +import Caramia.Prelude +import Caramia.Resource +import Control.Exception + +newtype Fence = Fence (Resource GLsync) + deriving ( Eq, Typeable ) + +-- | Create a fence. +fence :: IO Fence +fence = mask_ $ do + resource <- + newResource createFence + glDeleteSync + (return ()) + return $ Fence resource + where + createFence = glFenceSync gl_SYNC_GPU_COMMANDS_COMPLETE 0 + +-- | Waits for a fence to signal. +-- +-- IMPORTANT: this is not interruptible by asynchronous exceptions. +waitFence :: Int -- ^ Number of microseconds to wait. + -> Fence + -> IO Bool -- ^ `True` if the fence was signalled, + -- `False` if waiting timed out. +waitFence useconds (Fence resource) = + withResource resource $ \fencesync -> do + ret <- glClientWaitSync fencesync gl_SYNC_FLUSH_COMMANDS_BIT + (fromIntegral actual_seconds) + if | ret == gl_ALREADY_SIGNALED -> return True + | ret == gl_TIMEOUT_EXPIRED -> return False + | ret == gl_CONDITION_SATISFIED -> return True + | ret == gl_WAIT_FAILED -> return True -- should we throw an error? + where + actual_seconds :: Word64 + actual_seconds = + if useconds * 1000 < useconds + then maxBound + else safeFromIntegral $ useconds * 1000 + +-- | Checks if a fence has been signalled. +-- +-- @ isFenceSignalled = waitFence 0 @ +isFenceSignalled :: Fence -> IO Bool +isFenceSignalled = waitFence 0 + diff --git a/src/Caramia/Texture.hs b/src/Caramia/Texture.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Texture.hs @@ -0,0 +1,728 @@ +-- | Textures. +-- + +{-# LANGUAGE RecordWildCards, ScopedTypeVariables, NoImplicitPrelude #-} +{-# LANGUAGE MultiWayIf, ViewPatterns, DeriveDataTypeable #-} + +module Caramia.Texture + ( + -- * Creating textures + newTexture + , Texture() + , TextureSpecification(..) + , textureSpecification + , Topology(..) + -- * Uploading to textures + , uploadToTexture + , Uploading(..) + , uploading1D + , uploading2D + , uploading3D + , UploadFormat(..) + , CubeSide(..) + -- * Texture units + , TextureUnit + -- * Mipmapping + , generateMipmaps + -- * Texture parameters + , setWrapping + , getWrapping + , setMinFilter + , setMagFilter + , getMinFilter + , getMagFilter + , setAnisotropy + , getAnisotropy + , setCompareMode + , getCompareMode + , MinFilter(..) + , MagFilter(..) + , Wrapping(..) + , CompareMode(..) + -- * Views + , viewSpecification + , viewWidth + , viewHeight + , viewDepth + , viewMipmapLevels + -- * Utilities + , maxMipmapLevels ) + where + +import Caramia.Prelude + +import Caramia.Texture.Internal +import Caramia.Internal.OpenGLCApi +import qualified Caramia.Buffer.Internal as Buf +import Caramia.ImageFormats.Internal +import Caramia.Resource +import Control.Exception +import Foreign +import Foreign.C.Types + +textureSpecification :: TextureSpecification +textureSpecification = TextureSpecification { + topology = error "textureSpecification: topology is not set." + , imageFormat = error "textureSpecification: image format is not set." + , mipmapLevels = 1 } + +-- | Returns the width of a texture. +viewWidth :: Texture -> Int +viewWidth (viewSpecification -> spec) = viewWidth' (topology spec) + where + viewWidth' (Tex1D {..}) = width1D + viewWidth' (Tex2D {..}) = width2D + viewWidth' (Tex3D {..}) = width3D + viewWidth' (Tex1DArray {..}) = width1DArray + viewWidth' (Tex2DArray {..}) = width2DArray + viewWidth' (Tex2DMultisample {..}) = width2DMS + viewWidth' (Tex2DMultisampleArray {..}) = width2DMSArray + viewWidth' (TexCube {..}) = widthCube + viewWidth' (TexBuffer {}) = + error "viewWidth: buffer texture has no meaningful width." + -- TODO: you can actually infer that from the buffer size + -- so implement it + +-- | Returns the height of a texture. +-- +-- This is 1 for one-dimensional textures. +viewHeight :: Texture -> Int +viewHeight (viewSpecification -> spec) = viewHeight' (topology spec) + where + viewHeight' (Tex1D {..}) = 1 + viewHeight' (Tex2D {..}) = height2D + viewHeight' (Tex3D {..}) = height3D + viewHeight' (Tex1DArray {..}) = 1 + viewHeight' (Tex2DArray {..}) = height2DArray + viewHeight' (Tex2DMultisample {..}) = height2DMS + viewHeight' (Tex2DMultisampleArray {..}) = height2DMSArray + viewHeight' (TexCube {..}) = widthCube + viewHeight' (TexBuffer {}) = 1 + +-- | Returns the depth of a 3D texture or number of layers in array textures. +-- +-- This is 1 for any other type of texture. +viewDepth :: Texture -> Int +viewDepth (viewSpecification -> spec) = viewDepth' (topology spec) + where + viewDepth' (Tex1D {..}) = 1 + viewDepth' (Tex2D {..}) = 1 + viewDepth' (Tex3D {..}) = depth3D + viewDepth' (Tex1DArray {..}) = layers1D + viewDepth' (Tex2DArray {..}) = layers2D + viewDepth' (Tex2DMultisample {..}) = 1 + viewDepth' (Tex2DMultisampleArray {..}) = layers2DMS + viewDepth' (TexCube {..}) = 1 + viewDepth' (TexBuffer {}) = 1 + +viewMipmapLevels :: Texture -> Int +viewMipmapLevels = mipmapLevels . viewSpecification + +isMultisamplingTopology :: Topology -> Bool +isMultisamplingTopology (Tex2DMultisample {..}) = True +isMultisamplingTopology (Tex2DMultisampleArray {..}) = True +isMultisamplingTopology _ = False + +-- | Creates a new texture. +-- +-- Initially the contents of the texture are undefined. +-- +-- Texture dimensions must be positive. +newTexture :: TextureSpecification + -> IO Texture +newTexture spec = mask_ $ do + topologySanityCheck (topology spec) + when (not (isMultisamplingTopology (topology spec)) && + mipmapLevels spec < 1) $ + error "newTexture: mipmapLevels is not positive." + + res <- newResource creator + deleter + (return ()) + + index <- atomicModifyIORef' ordIndices $ \old -> ( old+1, old ) + return Texture { resource = res + , ordIndex = index + , viewSpecification = spec } + where + num_mipmaps = mipmapLevels spec + + -- a lot of code just to check that all the dimensions are positive... + topologySanityCheck t@(Tex1D {..}) + | width1D <= 0 = badTopology t + | not (isValidMipmap width1D num_mipmaps) = badMipmaps + | otherwise = return () + topologySanityCheck t@(Tex2D {..}) + | width2D <= 0 || height2D <= 0 = badTopology t + | not (isValidMipmap (max width2D height2D) num_mipmaps) = badMipmaps + | otherwise = return () + topologySanityCheck t@(Tex3D {..}) + | width3D <= 0 || height3D <= 0 || depth3D <= 0 = badTopology t + | not (isValidMipmap (max width3D $ max height3D depth3D) num_mipmaps) = + badMipmaps + | otherwise = return () + topologySanityCheck t@(Tex1DArray {..}) + | width1DArray <= 0 || layers1D <= 0 = badTopology t + | not (isValidMipmap width1DArray num_mipmaps) = + badMipmaps + | otherwise = return () + topologySanityCheck t@(Tex2DArray {..}) + | width2DArray <= 0 || height2DArray <= 0 || + layers2D <= 0 = badTopology t + | not (isValidMipmap (max width2DArray height2DArray) num_mipmaps) = + badMipmaps + | otherwise = return () + topologySanityCheck t@(Tex2DMultisample {..}) + | width2DMS <= 0 || height2DMS <= 0 = badTopology t + | otherwise = return () + topologySanityCheck t@(Tex2DMultisampleArray {..}) + | width2DMSArray <= 0 || height2DMSArray <= 0 || + layers2DMS <= 0 = badTopology t + | otherwise = return () + topologySanityCheck t@(TexCube {..}) + | widthCube <= 0 = badTopology t + | not (isValidMipmap widthCube num_mipmaps) = + badMipmaps + | otherwise = return () + topologySanityCheck (TexBuffer {}) = return () + + badTopology _ = error "newTexture: bad topology." + + badMipmaps = + error $ "newTexture: bad number of mipmap levels: " <> show num_mipmaps + + deleter (Texture_ name) = + with name $ glDeleteTextures 1 + + creator = do + name <- bracketOnError + (alloca $ \name_ptr -> + glGenTextures 1 name_ptr *> peek name_ptr) + (deleter . Texture_ ) + (\name -> do + createByTopology name (topology spec) + return name) + return (Texture_ name) + + -- TODO: use DSA when available, perhaps add mglTextureStorage* functions + -- to Caramia.Internal.OpenGLCApi? + createByTopology :: GLuint -> Topology -> IO () + createByTopology name (Tex1D {..}) = + withBinding gl_TEXTURE_1D gl_TEXTURE_BINDING_1D name $ + glTexStorage1D gl_TEXTURE_1D + (safeFromIntegral num_mipmaps) + (toConstantIF (imageFormat spec)) + (safeFromIntegral width1D) + createByTopology name (Tex2D {..}) = + withBinding gl_TEXTURE_2D gl_TEXTURE_BINDING_2D name $ + glTexStorage2D gl_TEXTURE_2D + (safeFromIntegral num_mipmaps) + (toConstantIF (imageFormat spec)) + (safeFromIntegral width2D) + (safeFromIntegral height2D) + createByTopology name (Tex3D {..}) = + withBinding gl_TEXTURE_3D gl_TEXTURE_BINDING_3D name $ + glTexStorage3D gl_TEXTURE_3D + (safeFromIntegral num_mipmaps) + (toConstantIF (imageFormat spec)) + (safeFromIntegral width3D) + (safeFromIntegral height3D) + (safeFromIntegral depth3D) + createByTopology name (Tex1DArray {..}) = + withBinding gl_TEXTURE_1D_ARRAY gl_TEXTURE_BINDING_1D_ARRAY name $ + glTexStorage2D gl_TEXTURE_1D_ARRAY + (safeFromIntegral num_mipmaps) + (toConstantIF (imageFormat spec)) + (safeFromIntegral width1DArray) + (safeFromIntegral layers1D) + createByTopology name (Tex2DArray {..}) = + withBinding gl_TEXTURE_2D_ARRAY gl_TEXTURE_BINDING_2D_ARRAY name $ + glTexStorage3D gl_TEXTURE_2D_ARRAY + (safeFromIntegral num_mipmaps) + (toConstantIF (imageFormat spec)) + (safeFromIntegral width2DArray) + (safeFromIntegral height2DArray) + (safeFromIntegral layers2D) + createByTopology name (Tex2DMultisample {..}) = + withBinding gl_TEXTURE_2D_MULTISAMPLE + gl_TEXTURE_BINDING_2D_MULTISAMPLE + name $ + glTexImage2DMultisample + gl_TEXTURE_2D_MULTISAMPLE + (safeFromIntegral samples2DMS) + (fromIntegral $ toConstantIF (imageFormat spec)) + (safeFromIntegral width2DMS) + (safeFromIntegral height2DMS) + (if fixedSampleLocations2DMS + then 1 else 0) + createByTopology name (Tex2DMultisampleArray {..}) = + withBinding gl_TEXTURE_2D_MULTISAMPLE_ARRAY + gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY + name $ + glTexImage3DMultisample + gl_TEXTURE_2D_MULTISAMPLE_ARRAY + (safeFromIntegral samples2DMSArray) + (fromIntegral $ toConstantIF (imageFormat spec)) + (safeFromIntegral width2DMSArray) + (safeFromIntegral height2DMSArray) + (safeFromIntegral layers2DMS) + (if fixedSampleLocations2DMSArray + then 1 else 0) + createByTopology name (TexCube {..}) = + withBinding gl_TEXTURE_CUBE_MAP + gl_TEXTURE_BINDING_CUBE_MAP + name $ + glTexStorage2D gl_TEXTURE_CUBE_MAP + (safeFromIntegral num_mipmaps) + (fromIntegral $ toConstantIF (imageFormat spec)) + (safeFromIntegral widthCube) + (safeFromIntegral widthCube) + createByTopology name (TexBuffer {..}) = + withBinding gl_TEXTURE_BUFFER + gl_TEXTURE_BINDING_BUFFER + name $ + withResource (Buf.resource texBuffer) $ \(Buf.Buffer_ bufname) -> + glTexBuffer gl_TEXTURE_BUFFER + (fromIntegral $ toConstantIF (imageFormat spec)) + bufname + +-- | Generate all mipmaps for a texture. If mipmap levels were specified, that +-- is. +generateMipmaps :: Texture -> IO () +generateMipmaps = flip withBindingByTopology glGenerateMipmap + +-- | Specifies the format in which buffer data is for the purposes of uploading +-- said data to a texture. +data UploadFormat = + UR -- ^ Just red. + | URG -- ^ Red and green. + | URGB -- ^ You know the drill. + | URGBA + | UBGR + | UBGRA + | UDEPTH_COMPONENT -- ^ Depth values. + | USTENCIL_INDEX -- ^ Stencil values. + deriving ( Eq, Ord, Show, Read, Typeable ) + +-- TODO: add UDEPTH_STENCIL when `SpecificationType` has special interpretation +-- formats. + +toConstantUF :: UploadFormat -> GLenum +toConstantUF UR = gl_RED +toConstantUF URG = gl_RG +toConstantUF URGB = gl_RGB +toConstantUF URGBA = gl_RGBA +toConstantUF UBGR = gl_BGR +toConstantUF UBGRA = gl_BGRA +toConstantUF UDEPTH_COMPONENT = gl_DEPTH_COMPONENT +toConstantUF USTENCIL_INDEX = gl_STENCIL_INDEX + +-- | Used to specify how to move the data from a `Buffer` to a `Texture` in +-- `uploadToTexture`. +-- +-- This is common for all texture topologies. However, some fields are ignored +-- depending on the topology. +-- +-- For example, if you upload into a 1D texture, then all fields that deal with +-- higher dimensions (`yOffset`, `zOffset`, `uHeight` etc.) are ignored. +-- +-- It is recommended that you use one of the smart constructors as they +-- implement the common use cases so you don't have to fill all these fields by +-- yourself. +data Uploading = Uploading + { fromBuffer :: !Buf.Buffer -- ^ From which buffer to upload. + , bufferOffset :: !Int -- ^ Offset in the buffer, in bytes, + -- from where to start uploading. + , toMipmapLevel :: !Int -- ^ To which mipmap level to upload. + -- (0 = base level). + , specificationType :: !SpecificationType + -- ^ What data type is used for each component value in a pixel. + , uploadFormat :: !UploadFormat + -- ^ What format is the source data in. + , xOffset :: !Int -- ^ X offset where to put the data. + , yOffset :: !Int -- ^ Y offset where to put the data. + , zOffset :: !Int -- ^ Z offset where to put the data. + , uWidth :: !Int -- ^ Width of the data to put. + , uHeight :: !Int -- ^ Height of the data to put. + , uDepth :: !Int -- ^ Number of 2D images to put. + , cubeSide :: CubeSide -- ^ Only used for cube map textures. + -- Specifies which side of the cube to upload. + -- Not evaluated if the texture is not a cube + -- texture. + , numColumns :: !Int + -- ^ Number of columns in the image in the source buffer. This value is + -- also sometimes known as \'pitch\'. It is the same as `uWidth` except in + -- cases where the next row in source data does not come immediately after + -- the current row but after `numColumns` from the first pixel in the row. + , numRows :: !Int + -- ^ Same as `numColumns` but for images in 3D uploading. + , pixelAlignment :: !Int + -- ^ Alignment in which the source texture data is. Every row is aligned to + -- this value. Allowed values are 1, 2, 4 and 8. The default value in smart + -- constructors is 1. + } + deriving ( Eq, Typeable ) + +-- | Values of this type refer to sides of a cube. +data CubeSide = + PositiveY + | NegativeY + | PositiveX + | NegativeX + | PositiveZ + | NegativeZ + deriving ( Eq, Ord, Show, Read, Typeable ) + +toConstantCS :: CubeSide -> GLenum +toConstantCS PositiveX = gl_TEXTURE_CUBE_MAP_POSITIVE_X +toConstantCS NegativeX = gl_TEXTURE_CUBE_MAP_NEGATIVE_X +toConstantCS PositiveY = gl_TEXTURE_CUBE_MAP_POSITIVE_Y +toConstantCS NegativeY = gl_TEXTURE_CUBE_MAP_NEGATIVE_Y +toConstantCS PositiveZ = gl_TEXTURE_CUBE_MAP_POSITIVE_Z +toConstantCS NegativeZ = gl_TEXTURE_CUBE_MAP_NEGATIVE_Z + +-- | Constructs a common 1D uploading. +uploading1D :: Buf.Buffer + -> Int -- ^ How many pixels to upload. + -> SpecificationType + -> UploadFormat + -> Uploading +uploading1D buffer pixels stype uf = + Uploading { + fromBuffer = buffer + , bufferOffset = 0 + , specificationType = stype + , uploadFormat = uf + , toMipmapLevel = 0 + , xOffset = 0 + , yOffset = 0 + , zOffset = 0 + , uWidth = pixels + , uHeight = 1 + , uDepth = 1 + , numColumns = pixels + , cubeSide = PositiveY + , numRows = 1 + , pixelAlignment = 1 } + +-- | Constructs a common 2D uploading. +-- +-- This can also be used for uploading into 1D texture arrays. +uploading2D :: Buf.Buffer + -> Int -- ^ Width of the image to upload. + -> Int -- ^ Height of the image to upload. + -> SpecificationType + -> UploadFormat + -> Uploading +uploading2D buffer width height stype uf = + Uploading { + fromBuffer = buffer + , bufferOffset = 0 + , specificationType = stype + , uploadFormat = uf + , toMipmapLevel = 0 + , xOffset = 0 + , yOffset = 0 + , zOffset = 0 + , uWidth = width + , uHeight = height + , uDepth = 1 + , numColumns = width + , cubeSide = PositiveY + , numRows = height + , pixelAlignment = 1 } + +-- | Constructs a common 3D uploading. +-- +-- This can also be used for uploading into 2D texture arrays. +uploading3D :: Buf.Buffer + -> Int -- ^ Width of the image to upload. + -> Int -- ^ Height of the image to upload. + -> Int -- ^ Number of images to upload. + -> SpecificationType + -> UploadFormat + -> Uploading +uploading3D buffer width height depth stype uf = + Uploading { + fromBuffer = buffer + , bufferOffset = 0 + , specificationType = stype + , uploadFormat = uf + , toMipmapLevel = 0 + , xOffset = 0 + , yOffset = 0 + , zOffset = 0 + , uWidth = width + , uHeight = height + , uDepth = depth + , numColumns = width + , cubeSide = PositiveY + , numRows = height + , pixelAlignment = 1 } + +-- | Uploads an image to a texture. +uploadToTexture :: Uploading + -> Texture + -> IO () +uploadToTexture uploading tex = mask_ $ + withResource (Buf.resource (fromBuffer uploading)) $ \(Buf.Buffer_ buf) -> + withBoundPixelUnpackBuffer buf $ do + old_num_cols <- fromIntegral <$> gi gl_UNPACK_ROW_LENGTH + old_num_rows <- fromIntegral <$> gi gl_UNPACK_IMAGE_HEIGHT + old_alignment <- fromIntegral <$> gi gl_UNPACK_ALIGNMENT + glPixelStorei gl_UNPACK_ROW_LENGTH + (safeFromIntegral $ numColumns uploading) + flip finally (glPixelStorei gl_UNPACK_ROW_LENGTH old_num_cols) $ do + glPixelStorei gl_UNPACK_IMAGE_HEIGHT + (safeFromIntegral $ numRows uploading) + flip finally (glPixelStorei gl_UNPACK_IMAGE_HEIGHT old_num_rows) $ do + glPixelStorei gl_UNPACK_ALIGNMENT + (safeFromIntegral $ pixelAlignment uploading) + flip finally (glPixelStorei gl_UNPACK_ALIGNMENT old_alignment) $ + withResource (resource tex) $ \(Texture_ texname) -> + case topology $ viewSpecification tex of + Tex1D {..} -> + upload1D gl_TEXTURE_1D gl_TEXTURE_BINDING_1D + texname uploading + Tex2D {..} -> + upload2D gl_TEXTURE_2D gl_TEXTURE_BINDING_2D + texname uploading + Tex3D {..} -> + upload3D gl_TEXTURE_3D gl_TEXTURE_BINDING_3D + texname uploading + Tex1DArray {..} -> + upload2D gl_TEXTURE_1D_ARRAY gl_TEXTURE_BINDING_1D_ARRAY + texname uploading + Tex2DArray {..} -> + upload3D gl_TEXTURE_2D_ARRAY gl_TEXTURE_BINDING_2D_ARRAY + texname uploading + Tex2DMultisample {..} -> + error $ "uploadToTexture: cannot upload to " <> + "multisampling textures." + Tex2DMultisampleArray {..} -> + error $ "uploadToTexture: cannot upload to " <> + "multisampling array textures." + TexCube {..} -> + uploadCube gl_TEXTURE_CUBE_MAP + gl_TEXTURE_BINDING_CUBE_MAP + texname uploading + TexBuffer {..} -> + error $ "uploadToTexture: cannot upload to " <> + "buffer textures. (please upload directly to the " <> + "associated buffer instead.)" + +upload1D :: GLenum -> GLenum -> GLuint -> Uploading -> IO () +upload1D target binding tex (Uploading {..}) = + withBinding target binding tex $ + glTexSubImage1D target + (safeFromIntegral toMipmapLevel) + (safeFromIntegral xOffset) + (safeFromIntegral uWidth) + (toConstantUF uploadFormat) + (toConstantST specificationType) + (intPtrToPtr $ + fromIntegral bufferOffset) + +upload2D :: GLenum -> GLenum -> GLuint -> Uploading -> IO () +upload2D target binding tex (Uploading {..}) = + withBinding target binding tex $ + glTexSubImage2D target + (safeFromIntegral toMipmapLevel) + (safeFromIntegral xOffset) + (safeFromIntegral yOffset) + (safeFromIntegral uWidth) + (safeFromIntegral uHeight) + (toConstantUF uploadFormat) + (toConstantST specificationType) + (intPtrToPtr $ + fromIntegral bufferOffset) + +upload3D :: GLenum -> GLenum -> GLuint -> Uploading -> IO () +upload3D target binding tex (Uploading {..}) = + withBinding target binding tex $ + glTexSubImage3D target + (safeFromIntegral toMipmapLevel) + (safeFromIntegral xOffset) + (safeFromIntegral yOffset) + (safeFromIntegral zOffset) + (safeFromIntegral uWidth) + (safeFromIntegral uHeight) + (safeFromIntegral uDepth) + (toConstantUF uploadFormat) + (toConstantST specificationType) + (intPtrToPtr $ + fromIntegral bufferOffset) + +uploadCube :: GLenum -> GLenum -> GLuint -> Uploading -> IO () +uploadCube target binding tex (Uploading {..}) = + withBinding target binding tex $ + glTexSubImage2D (toConstantCS cubeSide) + (safeFromIntegral toMipmapLevel) + (safeFromIntegral xOffset) + (safeFromIntegral yOffset) + (safeFromIntegral uWidth) + (safeFromIntegral uHeight) + (toConstantUF uploadFormat) + (toConstantST specificationType) + (intPtrToPtr $ + fromIntegral bufferOffset) + +isValidMipmap :: Int -> Int -> Bool +isValidMipmap w level + | w <= 0 = False + | level < 0 = False + | level > floor (logBase (2 :: Double) (fromIntegral w)) + 1 = False + | otherwise = True + +-- | Returns the maximal number of mipmap levels when given a side length. +maxMipmapLevels :: Int -> Int +maxMipmapLevels width + | width <= 0 = 0 + | otherwise = floor (logBase (2 :: Double) (fromIntegral width)) + 1 + +class TexParam a where + tpEnum :: a -> GLenum + tpToConstant :: a -> GLenum + tpFromConstant :: GLenum -> a + +data MinFilter = + MiNearest + | MiLinear + | MiNearestMipmapNearest + | MiLinearMipmapNearest + | MiNearestMipmapLinear + | MiLinearMipmapLinear + deriving ( Eq, Ord, Show, Read, Typeable ) + +data MagFilter = + MaNearest + | MaLinear + deriving ( Eq, Ord, Show, Read, Typeable ) + +data Wrapping = + Clamp + | Repeat + deriving ( Eq, Ord, Show, Read, Typeable ) + +-- | Texture comparison modes. +-- +-- See @ glTexParameteri @ documentation in OpenGL. +data CompareMode + = NoCompare + | CompareRefToTexture + deriving ( Eq, Ord, Show, Read, Typeable ) + +toConstantC :: CompareMode -> GLenum +toConstantC NoCompare = gl_NONE +toConstantC CompareRefToTexture = gl_COMPARE_REF_TO_TEXTURE + +toConstantW :: Wrapping -> GLenum +toConstantW Clamp = gl_CLAMP_TO_EDGE +toConstantW Repeat = gl_REPEAT + +instance TexParam MinFilter where + tpEnum _ = gl_TEXTURE_MIN_FILTER + tpToConstant MiNearest = gl_NEAREST + tpToConstant MiLinear = gl_LINEAR + tpToConstant MiNearestMipmapNearest = gl_NEAREST_MIPMAP_NEAREST + tpToConstant MiLinearMipmapNearest = gl_LINEAR_MIPMAP_NEAREST + tpToConstant MiNearestMipmapLinear = gl_NEAREST_MIPMAP_LINEAR + tpToConstant MiLinearMipmapLinear = gl_LINEAR_MIPMAP_LINEAR + tpFromConstant c + | c == gl_NEAREST = MiNearest + | c == gl_LINEAR = MiLinear + | c == gl_NEAREST_MIPMAP_NEAREST = MiNearestMipmapNearest + | c == gl_LINEAR_MIPMAP_NEAREST = MiLinearMipmapNearest + | c == gl_NEAREST_MIPMAP_LINEAR = MiNearestMipmapLinear + | c == gl_LINEAR_MIPMAP_LINEAR = MiLinearMipmapLinear + | otherwise = error "MinFilter: unexpected filtering value." + +instance TexParam MagFilter where + tpEnum _ = gl_TEXTURE_MAG_FILTER + tpToConstant MaNearest = gl_NEAREST + tpToConstant MaLinear = gl_LINEAR + + tpFromConstant c + | c == gl_NEAREST = MaNearest + | c == gl_LINEAR = MaLinear + | otherwise = error "MagFilter: unexpected filtering value." + +setMinFilter :: MinFilter -> Texture -> IO () +setMinFilter = setTexParam + +setMagFilter :: MagFilter -> Texture -> IO () +setMagFilter = setTexParam + +getMinFilter :: Texture -> IO MinFilter +getMinFilter = getTexParam + +getMagFilter :: Texture -> IO MagFilter +getMagFilter = getTexParam + +setTexParam :: TexParam a => a -> Texture -> IO () +setTexParam param tex = withBindingByTopology tex $ \target -> + glTexParameteri target (tpEnum param) (fromIntegral $ tpToConstant param) + +getTexParam :: forall a. TexParam a => Texture -> IO a +getTexParam tex = withBindingByTopology tex $ \target -> + alloca $ \result_ptr -> do + glGetTexParameteriv target (tpEnum (undefined :: a)) result_ptr + tpFromConstant . fromIntegral <$> peek result_ptr + +setWrapping :: Wrapping -> Texture -> IO () +setWrapping wrapping tex = withBindingByTopology tex $ \target -> do + glTexParameteri target gl_TEXTURE_WRAP_S + (fromIntegral $ toConstantW wrapping) + glTexParameteri target gl_TEXTURE_WRAP_T + (fromIntegral $ toConstantW wrapping) + glTexParameteri target gl_TEXTURE_WRAP_R + (fromIntegral $ toConstantW wrapping) + +setCompareMode :: CompareMode -> Texture -> IO () +setCompareMode cmp_mode tex = withBindingByTopology tex $ \target -> + glTexParameteri target gl_TEXTURE_COMPARE_MODE + (fromIntegral $ toConstantC cmp_mode) + +getCompareMode :: Texture -> IO CompareMode +getCompareMode tex = withBindingByTopology tex $ \target -> + alloca $ \result_ptr -> do + glGetTexParameteriv target gl_TEXTURE_COMPARE_MODE result_ptr + result <- fromIntegral <$> peek result_ptr + return $ if + | result == gl_NONE -> NoCompare + | result == gl_COMPARE_REF_TO_TEXTURE -> CompareRefToTexture + | otherwise -> error "getCompareMode: unexpected comparing mode." + +getWrapping :: Texture -> IO Wrapping +getWrapping tex = withBindingByTopology tex $ \target -> + alloca $ \result_ptr -> do + glGetTexParameteriv target gl_TEXTURE_WRAP_S result_ptr + result <- fromIntegral <$> peek result_ptr + return $ if + | result == gl_CLAMP_TO_EDGE -> Clamp + | result == gl_REPEAT -> Repeat + | otherwise -> error "getWrapping: unexpected wrapping mode." + +setAnisotropy :: Float -> Texture -> IO () +setAnisotropy ani tex = withBindingByTopology tex $ \target -> + glTexParameterf target gl_TEXTURE_MAX_ANISOTROPY_EXT (CFloat ani) + +getAnisotropy :: Texture -> IO Float +getAnisotropy tex = withBindingByTopology tex $ \target -> + alloca $ \ani_ptr -> do + glGetTexParameterfv target gl_TEXTURE_MAX_ANISOTROPY_EXT ani_ptr + unwrap <$> peek ani_ptr + where + unwrap (CFloat f) = f + +{- +nextMipmapLevel :: Int -> Int +nextMipmapLevel 0 = 0 +nextMipmapLevel 1 = 1 +nextMipmapLevel x = max 1 (x `div` 2) + +nthMipmapLevel :: Int -> Int -> Int +nthMipmapLevel x 0 = x +nthMipmapLevel x n = nthMipmapLevel (nextMipmapLevel x) (n-1) +-} + diff --git a/src/Caramia/Texture/Internal.hs b/src/Caramia/Texture/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/Texture/Internal.hs @@ -0,0 +1,129 @@ +{-# LANGUAGE RecordWildCards, NoImplicitPrelude, LambdaCase #-} +{-# LANGUAGE DeriveDataTypeable #-} + +module Caramia.Texture.Internal where + +import Caramia.Prelude + +import Caramia.Resource +import Caramia.Internal.OpenGLCApi +import qualified Caramia.Buffer.Internal as Buf +import Caramia.ImageFormats +import System.IO.Unsafe +import Control.Exception + +data Texture = Texture + { resource :: !(Resource Texture_) + , ordIndex :: !Int + , viewSpecification :: !TextureSpecification } + deriving ( Typeable ) + +newtype Texture_ = Texture_ GLuint + +-- | The type of a texture unit. +-- +-- The minimum valid value is 0 and maximum is implementation dependant but +-- in OpenGL at least 48 units will work at the same time in shaders. +type TextureUnit = Int + +ordIndices :: IORef Int +ordIndices = unsafePerformIO $ newIORef 0 +{-# NOINLINE ordIndices #-} + +instance Eq Texture where + tex1 == tex2 = resource tex1 == resource tex2 + +instance Ord Texture where + tex1 `compare` tex2 = ordIndex tex1 `compare` ordIndex tex2 + +-- | Specification on what the texture should be like. +-- +-- Use `textureSpecification` and set at least `topology` and `imageFormat`. +-- Future minor versions remain compatible if you use `textureSpecification` +-- instead of the constructor directly. +data TextureSpecification = TextureSpecification + { topology :: Topology + , imageFormat :: ImageFormat + , mipmapLevels :: Int -- ^ How many mipmap levels including the base + -- level? Must be at least 1. + -- + -- Ignored and not evaluated for multisampling + -- textures. + } + deriving ( Eq, Typeable ) + +-- | Specifies a topology of a texture. +data Topology = + Tex1D { width1D :: !Int } + | Tex2D { width2D :: !Int + , height2D :: !Int } + | Tex3D { width3D :: !Int + , height3D :: !Int + , depth3D :: !Int } + | Tex1DArray + { width1DArray :: !Int + , layers1D :: !Int } + | Tex2DArray + { width2DArray :: !Int + , height2DArray :: !Int + , layers2D :: !Int } + | Tex2DMultisample + { width2DMS :: !Int + , height2DMS :: !Int + , samples2DMS :: !Int + , fixedSampleLocations2DMS :: !Bool } + | Tex2DMultisampleArray + { width2DMSArray :: !Int + , height2DMSArray :: !Int + , layers2DMS :: !Int + , samples2DMSArray :: !Int + , fixedSampleLocations2DMSArray :: !Bool } + | TexCube { widthCube :: Int } + | TexBuffer { texBuffer :: !Buf.Buffer } + -- ^ Buffer textures, see + -- + deriving ( Eq, Typeable ) + +withBinding :: GLenum -> GLenum -> GLuint -> IO a -> IO a +withBinding tex tex_binding tex_name action = do + old <- gi tex_binding + finally + (glBindTexture tex tex_name *> + action) + (glBindTexture tex old) + +getTopologyBindPoints :: Topology -> (GLenum, GLenum) +getTopologyBindPoints = \case + Tex1D {..} -> (gl_TEXTURE_1D, gl_TEXTURE_BINDING_1D) + Tex2D {..} -> (gl_TEXTURE_2D, gl_TEXTURE_BINDING_2D) + Tex3D {..} -> (gl_TEXTURE_3D, gl_TEXTURE_BINDING_3D) + Tex1DArray {..} -> (gl_TEXTURE_1D_ARRAY, gl_TEXTURE_BINDING_1D_ARRAY) + Tex2DArray {..} -> (gl_TEXTURE_2D_ARRAY, gl_TEXTURE_BINDING_2D_ARRAY) + Tex2DMultisample {..} -> + (gl_TEXTURE_2D_MULTISAMPLE + ,gl_TEXTURE_BINDING_2D_MULTISAMPLE) + Tex2DMultisampleArray {..} -> + (gl_TEXTURE_2D_MULTISAMPLE_ARRAY + ,gl_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY) + TexCube {..} -> + (gl_TEXTURE_CUBE_MAP + ,gl_TEXTURE_BINDING_CUBE_MAP) + TexBuffer {} -> + (gl_TEXTURE_BUFFER + ,gl_TEXTURE_BINDING_BUFFER) + +withBindingByTopology :: Texture -> (GLenum -> IO a) -> IO a +withBindingByTopology tex action = + withResource (resource tex) $ \(Texture_ name) -> + let (bind_target, bind_query) = getTopologyBindPoints topo + in withBinding bind_target bind_query name $ action bind_target + where + topo = topology $ viewSpecification tex + +withTextureBinding :: Texture -> TextureUnit -> IO a -> IO a +withTextureBinding tex unit action = do + old_active <- gi gl_ACTIVE_TEXTURE + glActiveTexture (gl_TEXTURE0 + fromIntegral unit) + finally (withBindingByTopology tex $ const action) $ + glActiveTexture old_active + diff --git a/src/Caramia/VAO.hs b/src/Caramia/VAO.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/VAO.hs @@ -0,0 +1,283 @@ +-- | Vertex array objects, or VAOs as we abbreviate them. +-- +-- These are used to specify how data in a `Caramia.Buffer.Buffer` is made +-- available in a shader program. +-- +-- +-- + +module Caramia.VAO + ( -- * Creation + newVAO + , VAO() + -- * Sourcing + , sourceVertexData + , Sourcing(..) + , defaultSourcing + , defaultSourcingType + -- * Sourceable types + , SourceableType(..) + , SourceType(..) + , sourceTypeSize ) + where + +import Caramia.Prelude + +import Caramia.VAO.Internal +import Caramia.Resource +import qualified Caramia.Buffer.Internal as Buf +import Caramia.Internal.OpenGLCApi +import Control.Exception + +-- | Creates a vertex array object. +-- +-- Initially, the vertex array object makes no data available to a shader +-- program. +newVAO :: IO VAO +newVAO = mask_ $ do + res <- newResource create + (\(VAO_ vao) -> mglDeleteVertexArray vao) + (return ()) + ref <- newIORef [] + return VAO { resource = res + , boundBuffers = ref } + where + create = VAO_ <$> mglGenVertexArray + +-- | Types allowed for sourcing. +-- +-- These are mostly Haskell types except for `SHalfFloat` which has no Haskell +-- equivalent. +data SourceType = + SWord8 + | SWord16 + | SWord32 + | SInt8 + | SInt16 + | SInt32 + | SHalfFloat -- ^ 16-bit floating point value. + | SFloat + | SDouble + deriving ( Eq, Ord, Show, Read ) + +-- | This returns the size of a `SourceType`, in bytes. +sourceTypeSize :: SourceType -> Int +sourceTypeSize SWord8 = 1 +sourceTypeSize SWord16 = 2 +sourceTypeSize SWord32 = 4 +sourceTypeSize SInt8 = 1 +sourceTypeSize SInt16 = 2 +sourceTypeSize SInt32 = 4 +sourceTypeSize SHalfFloat = 2 +sourceTypeSize SFloat = 4 +sourceTypeSize SDouble = 8 + +isIntegerType :: SourceType -> Bool +isIntegerType SWord8 = True +isIntegerType SWord16 = True +isIntegerType SWord32 = True +isIntegerType SInt8 = True +isIntegerType SInt16 = True +isIntegerType SInt32 = True +isIntegerType SHalfFloat = False +isIntegerType SFloat = False +isIntegerType SDouble = False + +toConstant :: SourceType -> GLenum +toConstant SWord8 = gl_UNSIGNED_BYTE +toConstant SWord16 = gl_UNSIGNED_SHORT +toConstant SWord32 = gl_UNSIGNED_INT +toConstant SInt8 = gl_BYTE +toConstant SInt16 = gl_SHORT +toConstant SInt32 = gl_INT +toConstant SHalfFloat = gl_HALF_FLOAT +toConstant SFloat = gl_FLOAT +toConstant SDouble = gl_DOUBLE + +-- | Class of types that are valid for sourcing data. +-- +-- This is a convenience class to turn Haskell types to `SourceType`. +class SourceableType a where + -- ^ Reify the type to a compatible `SourceType`. + reifyType :: a -> SourceType + +instance SourceableType Word8 where + reifyType _ = SWord8 + +instance SourceableType Word16 where + reifyType _ = SWord16 + +instance SourceableType Word32 where + reifyType _ = SWord32 + +instance SourceableType Int8 where + reifyType _ = SInt8 + +instance SourceableType Int16 where + reifyType _ = SInt16 + +instance SourceableType Int32 where + reifyType _ = SInt32 + +instance SourceableType Float where + reifyType _ = SFloat + +instance SourceableType Double where + reifyType _ = SDouble + +-- | Specifies how to source data. +-- +-- For forward compatibility, you might want to use `defaultSourcing` or +-- `defaultSourcingType` and then set the fields that are of interest to you. +data Sourcing = Sourcing + { offset :: Int + -- ^ Offset, in bytes, at which point from buffer to start sourcing. + , attributeIndex :: Int + -- ^ Which attribute index in a shader program to source this data. See + -- `Caramia.Shader` on attributes. + , components :: Int + -- ^ Number of components in one piece of data (that is, per vertex). + -- This must be an integer between 1 and 4. + , stride :: Int + -- ^ How many bytes there are between pieces of data. Because of OpenGL + -- inconsistencies behind the scenes, 0 means the data is tightly packed, + -- that is, @ stride = components * sizeOf sourceType @ + , normalize :: Bool + -- ^ This only applies when an integer type is used in `sourceType` and + -- `integerMapping` is false. It determines whether integer values should + -- be normalized. + -- + -- Normalization maps the integer value to [-1..1] or [0..1] range. For + -- example, if you use `Word16` as the type parameter, then 0 is mapped to + -- 0.0 and 65535 is mapped to 1.0. Signed types (for example, `Int16`) are + -- mapped to [-1..1] instead so for `Int16` 32767 is mapped to 1 and -32768 + -- is mapped to -1. + -- + -- This value is ignored and unevaluated for types that are one of the + -- floating point types. + , integerMapping :: Bool + -- ^ Don't convert integers to floats in any way. Normally integers are + -- converted to floating point. If this is set, then `normalize` is ignored + -- and not evalutated. + , instancingDivisor :: Int + -- ^ When doing instanced rendering (`Caramia.Render.numInstances` > 1), + -- this value tells how many instances must be rendered before the + -- attribute from this source advances. + -- + -- If zero (the default) then the attribute is advanced after every vertex. + -- + -- You can look up @ glVertexAttribDivisor @ from OpenGL to find more + -- information about this. + , sourceType :: SourceType + -- ^ The data type of values in the buffer. It tells the type of a single + -- component. + } + +-- | The default sourcing. +-- +-- Offset and stride are set to 0. +-- +-- At the very least you must set `components` and `attributeIndex`. +-- +-- You must also set `normalize`, `integerMapping` and `sourceType` in a +-- consistent way. See `Sourcing`. +defaultSourcing :: Sourcing +defaultSourcing = Sourcing + { offset = 0 + , components = + error "defaultSourcing: number of components is not set." + , stride = 0 + , instancingDivisor = 0 + , attributeIndex = + error "defaultSourcing: attribute index is not set." + , integerMapping = + error "defaultSourcing: whether to do integer mapping is not set." + , normalize = + error "defaultSourcing: normalize is not set for an integer type." + , sourceType = + error "defaultSourcing: source type is not set." } + +-- | Same as `defaultSourcing` but sets `sourceType` according to a Haskell +-- type. +defaultSourcingType :: SourceableType a + => a -- ^ Used to pass the type; not evaluated. + -> Sourcing +defaultSourcingType x = + defaultSourcing { sourceType = reifyType x } + +-- | Specifies that some data from a buffer should be sourced for each vertex. +-- +-- The vertex array object retains a reference to the buffer which means it +-- will not be garbage collected as long as the VAO remains active. +-- +-- Consequences are undefined if your `Sourcing` does not make sense. There is +-- some error checking but it can only detect obviously invalid values in the +-- sourcing. +sourceVertexData :: Buf.Buffer -- ^ From which buffer to source the data. + -> Sourcing -- ^ Specifies how the sourcing is done. + -> VAO + -> IO () +sourceVertexData buffer sourcing vao = mask_ $ + withResource (resource vao) $ \(VAO_ name) -> + withResource (Buf.resource buffer) $ \(Buf.Buffer_ bufname) -> do + errorChecking + + if isIntegerType stype && integerMapping sourcing + then doIntegerMapping name bufname + else doOrdinaryMapping name bufname + + mglVertexArrayVertexAttribDivisor + name + (safeFromIntegral $ attributeIndex sourcing) + (safeFromIntegral $ instancingDivisor sourcing) + + atomicModifyIORef' (boundBuffers vao) $ \old -> + ( addIfNotUnique buffer old, () ) + where + addIfNotUnique new old = + maybe (new:old) + (const old) + (find (new ==) old) + + stype = sourceType sourcing + ncomponents = components sourcing + + doIntegerMapping name bufname = + mglVertexArrayVertexAttribIOffsetAndEnable + name + bufname + (safeFromIntegral $ attributeIndex sourcing) + (safeFromIntegral ncomponents) + (toConstant stype) + (safeFromIntegral $ stride sourcing) + (safeFromIntegral $ offset sourcing) + + doOrdinaryMapping name bufname = + mglVertexArrayVertexAttribOffsetAndEnable + name + bufname + (safeFromIntegral $ attributeIndex sourcing) + (safeFromIntegral ncomponents) + (toConstant stype) + (fromIntegral $ if isIntegerType stype && normalize sourcing + then gl_TRUE + else gl_FALSE) + (safeFromIntegral $ stride sourcing) + (safeFromIntegral $ offset sourcing) + + errorChecking = do + when (isIntegerType stype) $ + unless (integerMapping sourcing) $ + let x = normalize sourcing + in x `seq` return () + + attributeIndex sourcing `seq` return () + when (stride sourcing < 0) $ + error "sourceVertexData: stride is negative." + when (offset sourcing < 0) $ + error "sourceVertexData: offset is negative." + when (ncomponents < 1 || + ncomponents > 4) $ error $ + "sourceVertexData: number of components must be between " <> + "1 and 4. I was given " <> show ncomponents + diff --git a/src/Caramia/VAO/Internal.hs b/src/Caramia/VAO/Internal.hs new file mode 100644 --- /dev/null +++ b/src/Caramia/VAO/Internal.hs @@ -0,0 +1,24 @@ +{-# LANGUAGE NoImplicitPrelude, ViewPatterns, DeriveDataTypeable #-} + +module Caramia.VAO.Internal + ( VAO(..) + , VAO_(..) ) + where + +import Caramia.Prelude + +import Caramia.Resource +import Caramia.Internal.OpenGLCApi +import qualified Caramia.Buffer.Internal as Buf + +-- | The vertex array object data type. +data VAO = VAO + { resource :: !(Resource VAO_) + , boundBuffers :: !(IORef [Buf.Buffer]) } + deriving ( Typeable ) + +instance Eq VAO where + (resource -> res1) == (resource -> res2) = res1 == res2 + +newtype VAO_ = VAO_ GLuint +