GLURaw 1.4.0.2 → 1.5.0.0

raw patch · 4 files changed

+795/−153 lines, 4 filesdep +transformersdep ~OpenGLRawdep ~basePVP ok

version bump matches the API change (PVP)

Dependencies added: transformers

Dependency ranges changed: OpenGLRaw, base

API changes (from Hackage documentation)

Files

• GLURaw.cabal +7/−6
• include/HsGLURaw.h +0/−35
• src/Graphics/Rendering/GLU/Raw/APIEntry.hs +0/−48
• src/Graphics/Rendering/GLU/Raw/Functions.hs +788/−64

@@ -1,5 +1,5 @@ name: GLURaw-version: 1.4.0.2+version: 1.5.0.0 synopsis: A raw binding for the OpenGL graphics system description:   GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL utility library. It is@@ -14,6 +14,7 @@   and <http://www.opengl.org/registry/>. homepage: http://www.haskell.org/haskellwiki/Opengl bug-reports: https://github.com/haskell-opengl/GLURaw/issues+copyright: Copyright (C) 2009-2015 Sven Panne license: BSD3 license-file: LICENSE author: Sven Panne@@ -23,7 +24,6 @@ cabal-version:  >= 1.10 extra-source-files:   README.md-  include/HsGLURaw.h  flag UseNativeWindowsLibraries   description:@@ -38,15 +38,16 @@     Graphics.Rendering.GLU.Raw.Tokens     Graphics.Rendering.GLU.Raw.Types   other-modules:-    Graphics.Rendering.GLU.Raw.APIEntry     Graphics.Rendering.GLU.Raw.TypesInternal   c-sources:     cbits/HsGLURaw.c   hs-source-dirs: src-  include-dirs: include-  build-depends: base >= 3 && < 5, OpenGLRaw >= 1.3.0.0+  build-depends:+    base         >= 4   && < 5,+    transformers >= 0.2 && < 0.5,+    OpenGLRaw    >= 2.4 && < 2.5   default-language: Haskell2010-  ghc-options: -Wall -O2+  ghc-options: -Wall   other-extensions: CPP   if os(windows) && flag(UseNativeWindowsLibraries)     if arch(i386)

@@ -1,35 +0,0 @@-/* ------------------------------------------------------------------------------ *- * Module      :  GL extension support for Graphics.Rendering.GLU.Raw- * Copyright   :  (c) Sven Panne 2013- * License     :  BSD3- * - * Maintainer  :  Sven Panne <svenpanne@gmail.com>- * Stability   :  stable- * Portability :  portable- *- * This header should only define preprocessor macros!- *- * -------------------------------------------------------------------------- */--#ifndef HSGLURAW_H-#define HSGLURAW_H--#define HASH #--/* NOTE: The macro must immediately start with the foreign declaration,-   otherwise the magic mangler (hack_foreign) in the Hugs build system-   doesn't recognize it. */-#define API_ENTRY_INTERNAL(_dyn_entry,_ptr_entry,_str_entry,_entry,_ty,_safety) \-foreign import CALLCONV _safety "dynamic" _dyn_entry :: Graphics.Rendering.GLU.Raw.APIEntry.Invoker (_ty) ; \-_entry :: (_ty) ; \-_entry = _dyn_entry _ptr_entry ; \-_ptr_entry :: FunPtr a ; \-_ptr_entry = unsafePerformIO (Graphics.Rendering.GLU.Raw.APIEntry.getAPIEntry _str_entry) ; \-{-HASH NOINLINE _ptr_entry HASH-}--#define API_ENTRY(_dyn_entry,_ptr_entry,_str_entry,_entry,_ty) API_ENTRY_INTERNAL(_dyn_entry,_ptr_entry,_str_entry,_entry,_ty,unsafe)--#define API_ENTRY_SAFE(_dyn_entry,_ptr_entry,_str_entry,_entry,_ty) API_ENTRY_INTERNAL(_dyn_entry,_ptr_entry,_str_entry,_entry,_ty,safe)--#endif

@@ -1,48 +0,0 @@-{-# LANGUAGE CPP #-}-{-# OPTIONS_HADDOCK hide #-}------------------------------------------------------------------------------------ |--- Module      :  Graphics.Rendering.GLU.Raw.APIEntry--- Copyright   :  (c) Sven Panne 2013--- License     :  BSD3------ Maintainer  :  Sven Panne <svenpanne@gmail.com>--- Stability   :  stable--- Portability :  portable------ This module offers a portable way to retrieve GLUT entries, providing a--- portability layer upon platform-specific mechanisms like @dlsym@,--- @GetProcAddress@ or @NSAddressOfSymbol@.--------------------------------------------------------------------------------------module Graphics.Rendering.GLU.Raw.APIEntry (-   Invoker, getAPIEntry,-   FunPtr, unsafePerformIO-) where--import Foreign.C.String-import Foreign.Marshal.Error-import Foreign.Ptr-import System.IO.Unsafe--#ifdef __HUGS__-{-# CFILES cbits/HsOpenGLRaw.c #-}-#endif------------------------------------------------------------------------------------type Invoker a = FunPtr a -> a---- | Retrieve a GLU API entry by name. Throws a userError when no entry with the--- given name was found.-getAPIEntry :: String -> IO (FunPtr a)-getAPIEntry extensionEntry =-   throwIfNullFunPtr ("unknown GLU entry " ++ extensionEntry) $-      withCString extensionEntry hs_GLU_getProcAddress--throwIfNullFunPtr :: String -> IO (FunPtr a) -> IO (FunPtr a)-throwIfNullFunPtr = throwIf (== nullFunPtr) . const--foreign import ccall unsafe "hs_GLU_getProcAddress"-   hs_GLU_getProcAddress :: CString -> IO (FunPtr a)

@@ -75,72 +75,796 @@    gluUnProject4, ) where -import Foreign.Ptr+-- Make the foreign imports happy. import Foreign.C.Types-import Graphics.Rendering.GLU.Raw.APIEntry-import Graphics.Rendering.GLU.Raw.Types-import Graphics.Rendering.OpenGL.Raw.Core31 -#include "HsGLURaw.h"+import Control.Monad.IO.Class ( MonadIO(..) )+import Foreign.C.String ( withCString, CString )+import Foreign.Marshal.Error ( throwIf )+import Foreign.Ptr ( Ptr, FunPtr, nullFunPtr )+import System.IO.Unsafe ( unsafePerformIO ) +import Graphics.Rendering.GLU.Raw.Types+import Graphics.Rendering.OpenGL.Raw.Types+ -------------------------------------------------------------------------------- -API_ENTRY_SAFE(dyn_gluBeginCurve,ptr_gluBeginCurve,"gluBeginCurve",gluBeginCurve,Ptr GLUnurbs -> IO ())-API_ENTRY_SAFE(dyn_gluBeginPolygon,ptr_gluBeginPolygon,"gluBeginPolygon",gluBeginPolygon,Ptr GLUtesselator -> IO ())-API_ENTRY_SAFE(dyn_gluBeginSurface,ptr_gluBeginSurface,"gluBeginSurface",gluBeginSurface,Ptr GLUnurbs -> IO ())-API_ENTRY_SAFE(dyn_gluBeginTrim,ptr_gluBeginTrim,"gluBeginTrim",gluBeginTrim,Ptr GLUnurbs -> IO ())-API_ENTRY(dyn_gluBuild1DMipmapLevels,ptr_gluBuild1DMipmapLevels,"gluBuild1DMipmapLevels",gluBuild1DMipmapLevels,GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint)-API_ENTRY(dyn_gluBuild1DMipmaps,ptr_gluBuild1DMipmaps,"gluBuild1DMipmaps",gluBuild1DMipmaps,GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint)-API_ENTRY(dyn_gluBuild2DMipmapLevels,ptr_gluBuild2DMipmapLevels,"gluBuild2DMipmapLevels",gluBuild2DMipmapLevels,GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint)-API_ENTRY(dyn_gluBuild2DMipmaps,ptr_gluBuild2DMipmaps,"gluBuild2DMipmaps",gluBuild2DMipmaps,GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint)-API_ENTRY(dyn_gluBuild3DMipmapLevels,ptr_gluBuild3DMipmapLevels,"gluBuild3DMipmapLevels",gluBuild3DMipmapLevels,GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint)-API_ENTRY(dyn_gluBuild3DMipmaps,ptr_gluBuild3DMipmaps,"gluBuild3DMipmaps",gluBuild3DMipmaps,GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint)-API_ENTRY(dyn_gluCheckExtension,ptr_gluCheckExtension,"gluCheckExtension",gluCheckExtension,Ptr GLubyte -> Ptr GLubyte -> IO GLboolean)-API_ENTRY_SAFE(dyn_gluCylinder,ptr_gluCylinder,"gluCylinder",gluCylinder,Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())-API_ENTRY_SAFE(dyn_gluDeleteNurbsRenderer,ptr_gluDeleteNurbsRenderer,"gluDeleteNurbsRenderer",gluDeleteNurbsRenderer,Ptr GLUnurbs -> IO ())-API_ENTRY(dyn_gluDeleteQuadric,ptr_gluDeleteQuadric,"gluDeleteQuadric",gluDeleteQuadric,Ptr GLUquadric -> IO ())-API_ENTRY_SAFE(dyn_gluDeleteTess,ptr_gluDeleteTess,"gluDeleteTess",gluDeleteTess,Ptr GLUtesselator -> IO ())-API_ENTRY_SAFE(dyn_gluDisk,ptr_gluDisk,"gluDisk",gluDisk,Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())-API_ENTRY_SAFE(dyn_gluEndCurve,ptr_gluEndCurve,"gluEndCurve",gluEndCurve,Ptr GLUnurbs -> IO ())-API_ENTRY_SAFE(dyn_gluEndPolygon,ptr_gluEndPolygon,"gluEndPolygon",gluEndPolygon,Ptr GLUtesselator -> IO ())-API_ENTRY_SAFE(dyn_gluEndSurface,ptr_gluEndSurface,"gluEndSurface",gluEndSurface,Ptr GLUnurbs -> IO ())-API_ENTRY_SAFE(dyn_gluEndTrim,ptr_gluEndTrim,"gluEndTrim",gluEndTrim,Ptr GLUnurbs -> IO ())-API_ENTRY(dyn_gluErrorString,ptr_gluErrorString,"gluErrorString",gluErrorString,GLenum -> IO (Ptr GLubyte))-API_ENTRY_SAFE(dyn_gluGetNurbsProperty,ptr_gluGetNurbsProperty,"gluGetNurbsProperty",gluGetNurbsProperty,Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ())-API_ENTRY(dyn_gluGetString,ptr_gluGetString,"gluGetString",gluGetString,GLenum -> IO (Ptr GLubyte))-API_ENTRY_SAFE(dyn_gluGetTessProperty,ptr_gluGetTessProperty,"gluGetTessProperty",gluGetTessProperty,Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ())-API_ENTRY_SAFE(dyn_gluLoadSamplingMatrices,ptr_gluLoadSamplingMatrices,"gluLoadSamplingMatrices",gluLoadSamplingMatrices,Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ())-API_ENTRY(dyn_gluLookAt,ptr_gluLookAt,"gluLookAt",gluLookAt,GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())-API_ENTRY_SAFE(dyn_gluNewNurbsRenderer,ptr_gluNewNurbsRenderer,"gluNewNurbsRenderer",gluNewNurbsRenderer,IO (Ptr GLUnurbs))-API_ENTRY(dyn_gluNewQuadric,ptr_gluNewQuadric,"gluNewQuadric",gluNewQuadric,IO (Ptr GLUquadric))-API_ENTRY(dyn_gluNewTess,ptr_gluNewTess,"gluNewTess",gluNewTess,IO (Ptr GLUtesselator))-API_ENTRY_SAFE(dyn_gluNextContour,ptr_gluNextContour,"gluNextContour",gluNextContour,Ptr GLUtesselator -> GLenum -> IO ())-API_ENTRY_SAFE(dyn_gluNurbsCallback,ptr_gluNurbsCallback,"gluNurbsCallback",gluNurbsCallback,Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ())-API_ENTRY_SAFE(dyn_gluNurbsCallbackData,ptr_gluNurbsCallbackData,"gluNurbsCallbackData",gluNurbsCallbackData,Ptr GLUnurbs -> Ptr a -> IO ())-API_ENTRY_SAFE(dyn_gluNurbsCallbackDataEXT,ptr_gluNurbsCallbackDataEXT,"gluNurbsCallbackDataEXT",gluNurbsCallbackDataEXT,Ptr GLUnurbs -> Ptr a -> IO ())-API_ENTRY_SAFE(dyn_gluNurbsCurve,ptr_gluNurbsCurve,"gluNurbsCurve",gluNurbsCurve,Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ())-API_ENTRY_SAFE(dyn_gluNurbsProperty,ptr_gluNurbsProperty,"gluNurbsProperty",gluNurbsProperty,Ptr GLUnurbs -> GLenum -> GLfloat -> IO ())-API_ENTRY_SAFE(dyn_gluNurbsSurface,ptr_gluNurbsSurface,"gluNurbsSurface",gluNurbsSurface,Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> IO ())-API_ENTRY(dyn_gluOrtho2D,ptr_gluOrtho2D,"gluOrtho2D",gluOrtho2D,GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())-API_ENTRY_SAFE(dyn_gluPartialDisk,ptr_gluPartialDisk,"gluPartialDisk",gluPartialDisk,Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> IO ())-API_ENTRY(dyn_gluPerspective,ptr_gluPerspective,"gluPerspective",gluPerspective,GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())-API_ENTRY(dyn_gluPickMatrix,ptr_gluPickMatrix,"gluPickMatrix",gluPickMatrix,GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO ())-API_ENTRY(dyn_gluProject,ptr_gluProject,"gluProject",gluProject,GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint)-API_ENTRY_SAFE(dyn_gluPwlCurve,ptr_gluPwlCurve,"gluPwlCurve",gluPwlCurve,Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ())-API_ENTRY_SAFE(dyn_gluQuadricCallback,ptr_gluQuadricCallback,"gluQuadricCallback",gluQuadricCallback,Ptr GLUquadric -> GLenum -> FunPtr a -> IO ())-API_ENTRY_SAFE(dyn_gluQuadricDrawStyle,ptr_gluQuadricDrawStyle,"gluQuadricDrawStyle",gluQuadricDrawStyle,Ptr GLUquadric -> GLenum -> IO ())-API_ENTRY_SAFE(dyn_gluQuadricNormals,ptr_gluQuadricNormals,"gluQuadricNormals",gluQuadricNormals,Ptr GLUquadric -> GLenum -> IO ())-API_ENTRY_SAFE(dyn_gluQuadricOrientation,ptr_gluQuadricOrientation,"gluQuadricOrientation",gluQuadricOrientation,Ptr GLUquadric -> GLenum -> IO ())-API_ENTRY_SAFE(dyn_gluQuadricTexture,ptr_gluQuadricTexture,"gluQuadricTexture",gluQuadricTexture,Ptr GLUquadric -> GLboolean -> IO ())-API_ENTRY(dyn_gluScaleImage,ptr_gluScaleImage,"gluScaleImage",gluScaleImage,GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> IO GLint)-API_ENTRY_SAFE(dyn_gluSphere,ptr_gluSphere,"gluSphere",gluSphere,Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ())-API_ENTRY_SAFE(dyn_gluTessBeginContour,ptr_gluTessBeginContour,"gluTessBeginContour",gluTessBeginContour,Ptr GLUtesselator -> IO ())-API_ENTRY_SAFE(dyn_gluTessBeginPolygon,ptr_gluTessBeginPolygon,"gluTessBeginPolygon",gluTessBeginPolygon,Ptr GLUtesselator -> Ptr a -> IO ())-API_ENTRY_SAFE(dyn_gluTessCallback,ptr_gluTessCallback,"gluTessCallback",gluTessCallback,Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ())-API_ENTRY_SAFE(dyn_gluTessEndContour,ptr_gluTessEndContour,"gluTessEndContour",gluTessEndContour,Ptr GLUtesselator -> IO ())-API_ENTRY_SAFE(dyn_gluTessEndPolygon,ptr_gluTessEndPolygon,"gluTessEndPolygon",gluTessEndPolygon,Ptr GLUtesselator -> IO ())-API_ENTRY(dyn_gluTessNormal,ptr_gluTessNormal,"gluTessNormal",gluTessNormal,Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ())-API_ENTRY_SAFE(dyn_gluTessProperty,ptr_gluTessProperty,"gluTessProperty",gluTessProperty,Ptr GLUtesselator -> GLenum -> GLdouble -> IO ())-API_ENTRY_SAFE(dyn_gluTessVertex,ptr_gluTessVertex,"gluTessVertex",gluTessVertex,Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ())-API_ENTRY(dyn_gluUnProject,ptr_gluUnProject,"gluUnProject",gluUnProject,GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint)-API_ENTRY(dyn_gluUnProject4,ptr_gluUnProject4,"gluUnProject4",gluUnProject4,GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> GLclampd -> GLclampd -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint)+-- | Retrieve a GLU API entry by name. Throws a userError when no entry with the+-- given name was found.+getAPIEntry :: String -> IO (FunPtr a)+getAPIEntry extensionEntry =+   throwIfNullFunPtr ("unknown GLU entry " ++ extensionEntry) $+      withCString extensionEntry hs_GLU_getProcAddress++throwIfNullFunPtr :: String -> IO (FunPtr a) -> IO (FunPtr a)+throwIfNullFunPtr = throwIf (== nullFunPtr) . const++foreign import ccall unsafe "hs_GLU_getProcAddress"+   hs_GLU_getProcAddress :: CString -> IO (FunPtr a)++-- gluBeginCurve ----------------------------------------------------------------------++gluBeginCurve :: MonadIO m => Ptr GLUnurbs -> m ()+gluBeginCurve v1 = liftIO $ dyn_gluBeginCurve ptr_gluBeginCurve v1++foreign import CALLCONV "dynamic" dyn_gluBeginCurve+  :: FunPtr (Ptr GLUnurbs -> IO ())+  ->         Ptr GLUnurbs -> IO ()++{-# NOINLINE ptr_gluBeginCurve #-}+ptr_gluBeginCurve :: FunPtr a+ptr_gluBeginCurve = unsafePerformIO $ getAPIEntry "gluBeginCurve"++-- gluBeginPolygon ----------------------------------------------------------------------++gluBeginPolygon :: MonadIO m => Ptr GLUtesselator -> m ()+gluBeginPolygon v1 = liftIO $ dyn_gluBeginPolygon ptr_gluBeginPolygon v1++foreign import CALLCONV "dynamic" dyn_gluBeginPolygon+  :: FunPtr (Ptr GLUtesselator -> IO ())+  ->         Ptr GLUtesselator -> IO ()++{-# NOINLINE ptr_gluBeginPolygon #-}+ptr_gluBeginPolygon :: FunPtr a+ptr_gluBeginPolygon = unsafePerformIO $ getAPIEntry "gluBeginPolygon"++-- gluBeginSurface ----------------------------------------------------------------------++gluBeginSurface :: MonadIO m => Ptr GLUnurbs -> m ()+gluBeginSurface v1 = liftIO $ dyn_gluBeginSurface ptr_gluBeginSurface v1++foreign import CALLCONV "dynamic" dyn_gluBeginSurface+  :: FunPtr (Ptr GLUnurbs -> IO ())+  ->         Ptr GLUnurbs -> IO ()++{-# NOINLINE ptr_gluBeginSurface #-}+ptr_gluBeginSurface :: FunPtr a+ptr_gluBeginSurface = unsafePerformIO $ getAPIEntry "gluBeginSurface"++-- gluBeginTrim ----------------------------------------------------------------------++gluBeginTrim :: MonadIO m => Ptr GLUnurbs -> m ()+gluBeginTrim v1 = liftIO $ dyn_gluBeginTrim ptr_gluBeginTrim v1++foreign import CALLCONV "dynamic" dyn_gluBeginTrim+  :: FunPtr (Ptr GLUnurbs -> IO ())+  ->         Ptr GLUnurbs -> IO ()++{-# NOINLINE ptr_gluBeginTrim #-}+ptr_gluBeginTrim :: FunPtr a+ptr_gluBeginTrim = unsafePerformIO $ getAPIEntry "gluBeginTrim"++-- gluBuild1DMipmapLevels ----------------------------------------------------------------------++gluBuild1DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint+gluBuild1DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9 = liftIO $ dyn_gluBuild1DMipmapLevels ptr_gluBuild1DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9++foreign import CALLCONV "dynamic" dyn_gluBuild1DMipmapLevels+  :: FunPtr (GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint)+  ->         GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint++{-# NOINLINE ptr_gluBuild1DMipmapLevels #-}+ptr_gluBuild1DMipmapLevels :: FunPtr a+ptr_gluBuild1DMipmapLevels = unsafePerformIO $ getAPIEntry "gluBuild1DMipmapLevels"++-- gluBuild1DMipmaps ----------------------------------------------------------------------++gluBuild1DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint+gluBuild1DMipmaps v1 v2 v3 v4 v5 v6 = liftIO $ dyn_gluBuild1DMipmaps ptr_gluBuild1DMipmaps v1 v2 v3 v4 v5 v6++foreign import CALLCONV "dynamic" dyn_gluBuild1DMipmaps+  :: FunPtr (GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint)+  ->         GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint++{-# NOINLINE ptr_gluBuild1DMipmaps #-}+ptr_gluBuild1DMipmaps :: FunPtr a+ptr_gluBuild1DMipmaps = unsafePerformIO $ getAPIEntry "gluBuild1DMipmaps"++-- gluBuild2DMipmapLevels ----------------------------------------------------------------------++gluBuild2DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint+gluBuild2DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 = liftIO $ dyn_gluBuild2DMipmapLevels ptr_gluBuild2DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9 v10++foreign import CALLCONV "dynamic" dyn_gluBuild2DMipmapLevels+  :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint)+  ->         GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint++{-# NOINLINE ptr_gluBuild2DMipmapLevels #-}+ptr_gluBuild2DMipmapLevels :: FunPtr a+ptr_gluBuild2DMipmapLevels = unsafePerformIO $ getAPIEntry "gluBuild2DMipmapLevels"++-- gluBuild2DMipmaps ----------------------------------------------------------------------++gluBuild2DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint+gluBuild2DMipmaps v1 v2 v3 v4 v5 v6 v7 = liftIO $ dyn_gluBuild2DMipmaps ptr_gluBuild2DMipmaps v1 v2 v3 v4 v5 v6 v7++foreign import CALLCONV "dynamic" dyn_gluBuild2DMipmaps+  :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint)+  ->         GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint++{-# NOINLINE ptr_gluBuild2DMipmaps #-}+ptr_gluBuild2DMipmaps :: FunPtr a+ptr_gluBuild2DMipmaps = unsafePerformIO $ getAPIEntry "gluBuild2DMipmaps"++-- gluBuild3DMipmapLevels ----------------------------------------------------------------------++gluBuild3DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint+gluBuild3DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11= liftIO $ dyn_gluBuild3DMipmapLevels ptr_gluBuild3DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11++foreign import CALLCONV "dynamic" dyn_gluBuild3DMipmapLevels+  :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint)+  ->         GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint++{-# NOINLINE ptr_gluBuild3DMipmapLevels #-}+ptr_gluBuild3DMipmapLevels :: FunPtr a+ptr_gluBuild3DMipmapLevels = unsafePerformIO $ getAPIEntry "gluBuild3DMipmapLevels"++-- gluBuild3DMipmaps ----------------------------------------------------------------------++gluBuild3DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint+gluBuild3DMipmaps v1 v2 v3 v4 v5 v6 v7 v8 = liftIO $ dyn_gluBuild3DMipmaps ptr_gluBuild3DMipmaps v1 v2 v3 v4 v5 v6 v7 v8++foreign import CALLCONV "dynamic" dyn_gluBuild3DMipmaps+  :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint)+  ->         GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint++{-# NOINLINE ptr_gluBuild3DMipmaps #-}+ptr_gluBuild3DMipmaps :: FunPtr a+ptr_gluBuild3DMipmaps = unsafePerformIO $ getAPIEntry "gluBuild3DMipmaps"++-- gluCheckExtension ----------------------------------------------------------------------++gluCheckExtension :: MonadIO m => Ptr GLubyte -> Ptr GLubyte -> m GLboolean+gluCheckExtension v1 v2 = liftIO $ dyn_gluCheckExtension ptr_gluCheckExtension v1 v2++foreign import CALLCONV "dynamic" dyn_gluCheckExtension+  :: FunPtr (Ptr GLubyte -> Ptr GLubyte -> IO GLboolean)+  ->         Ptr GLubyte -> Ptr GLubyte -> IO GLboolean++{-# NOINLINE ptr_gluCheckExtension #-}+ptr_gluCheckExtension :: FunPtr a+ptr_gluCheckExtension = unsafePerformIO $ getAPIEntry "gluCheckExtension"++-- gluCylinder ----------------------------------------------------------------------++gluCylinder :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> m ()+gluCylinder v1 v2 v3 v4 v5 v6 = liftIO $ dyn_gluCylinder ptr_gluCylinder v1 v2 v3 v4 v5 v6++foreign import CALLCONV "dynamic" dyn_gluCylinder+  :: FunPtr (Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())+  ->         Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()++{-# NOINLINE ptr_gluCylinder #-}+ptr_gluCylinder :: FunPtr a+ptr_gluCylinder = unsafePerformIO $ getAPIEntry "gluCylinder"++-- gluDeleteNurbsRenderer ----------------------------------------------------------------------++gluDeleteNurbsRenderer :: MonadIO m => Ptr GLUnurbs -> m ()+gluDeleteNurbsRenderer v1 = liftIO $ dyn_gluDeleteNurbsRenderer ptr_gluDeleteNurbsRenderer v1++foreign import CALLCONV "dynamic" dyn_gluDeleteNurbsRenderer+  :: FunPtr (Ptr GLUnurbs -> IO ())+  ->         Ptr GLUnurbs -> IO ()++{-# NOINLINE ptr_gluDeleteNurbsRenderer #-}+ptr_gluDeleteNurbsRenderer :: FunPtr a+ptr_gluDeleteNurbsRenderer = unsafePerformIO $ getAPIEntry "gluDeleteNurbsRenderer"++-- gluDeleteQuadric ----------------------------------------------------------------------++gluDeleteQuadric :: MonadIO m => Ptr GLUquadric -> m ()+gluDeleteQuadric v1 = liftIO $ dyn_gluDeleteQuadric ptr_gluDeleteQuadric v1++foreign import CALLCONV "dynamic" dyn_gluDeleteQuadric+  :: FunPtr (Ptr GLUquadric -> IO ())+  ->         Ptr GLUquadric -> IO ()++{-# NOINLINE ptr_gluDeleteQuadric #-}+ptr_gluDeleteQuadric :: FunPtr a+ptr_gluDeleteQuadric = unsafePerformIO $ getAPIEntry "gluDeleteQuadric"++-- gluDeleteTess ----------------------------------------------------------------------++gluDeleteTess :: MonadIO m => Ptr GLUtesselator -> m ()+gluDeleteTess v1 = liftIO $ dyn_gluDeleteTess ptr_gluDeleteTess v1++foreign import CALLCONV "dynamic" dyn_gluDeleteTess+  :: FunPtr (Ptr GLUtesselator -> IO ())+  ->         Ptr GLUtesselator -> IO ()++{-# NOINLINE ptr_gluDeleteTess #-}+ptr_gluDeleteTess :: FunPtr a+ptr_gluDeleteTess = unsafePerformIO $ getAPIEntry "gluDeleteTess"++-- gluDisk ----------------------------------------------------------------------++gluDisk :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> m ()+gluDisk v1 v2 v3 v4 v5 = liftIO $ dyn_gluDisk ptr_gluDisk v1 v2 v3 v4 v5++foreign import CALLCONV "dynamic" dyn_gluDisk+  :: FunPtr (Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())+  ->         Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()++{-# NOINLINE ptr_gluDisk #-}+ptr_gluDisk :: FunPtr a+ptr_gluDisk = unsafePerformIO $ getAPIEntry "gluDisk"++-- gluEndCurve ----------------------------------------------------------------------++gluEndCurve :: MonadIO m => Ptr GLUnurbs -> m ()+gluEndCurve v1 = liftIO $ dyn_gluEndCurve ptr_gluEndCurve v1++foreign import CALLCONV "dynamic" dyn_gluEndCurve+  :: FunPtr (Ptr GLUnurbs -> IO ())+  ->         Ptr GLUnurbs -> IO ()++{-# NOINLINE ptr_gluEndCurve #-}+ptr_gluEndCurve :: FunPtr a+ptr_gluEndCurve = unsafePerformIO $ getAPIEntry "gluEndCurve"++-- gluEndPolygon ----------------------------------------------------------------------++gluEndPolygon :: MonadIO m => Ptr GLUtesselator -> m ()+gluEndPolygon v1 = liftIO $ dyn_gluEndPolygon ptr_gluEndPolygon v1++foreign import CALLCONV "dynamic" dyn_gluEndPolygon+  :: FunPtr (Ptr GLUtesselator -> IO ())+  ->         Ptr GLUtesselator -> IO ()++{-# NOINLINE ptr_gluEndPolygon #-}+ptr_gluEndPolygon :: FunPtr a+ptr_gluEndPolygon = unsafePerformIO $ getAPIEntry "gluEndPolygon"++-- gluEndSurface ----------------------------------------------------------------------++gluEndSurface :: MonadIO m => Ptr GLUnurbs -> m ()+gluEndSurface v1 = liftIO $ dyn_gluEndSurface ptr_gluEndSurface v1++foreign import CALLCONV "dynamic" dyn_gluEndSurface+  :: FunPtr (Ptr GLUnurbs -> IO ())+  ->         Ptr GLUnurbs -> IO ()++{-# NOINLINE ptr_gluEndSurface #-}+ptr_gluEndSurface :: FunPtr a+ptr_gluEndSurface = unsafePerformIO $ getAPIEntry "gluEndSurface"++-- gluEndTrim ----------------------------------------------------------------------++gluEndTrim :: MonadIO m => Ptr GLUnurbs -> m ()+gluEndTrim v1 = liftIO $ dyn_gluEndTrim ptr_gluEndTrim v1++foreign import CALLCONV "dynamic" dyn_gluEndTrim+  :: FunPtr (Ptr GLUnurbs -> IO ())+  ->         Ptr GLUnurbs -> IO ()++{-# NOINLINE ptr_gluEndTrim #-}+ptr_gluEndTrim :: FunPtr a+ptr_gluEndTrim = unsafePerformIO $ getAPIEntry "gluEndTrim"++-- gluErrorString ----------------------------------------------------------------------++gluErrorString :: MonadIO m => GLenum -> m (Ptr GLubyte)+gluErrorString v1 = liftIO $ dyn_gluErrorString ptr_gluErrorString v1++foreign import CALLCONV "dynamic" dyn_gluErrorString+  :: FunPtr (GLenum -> IO (Ptr GLubyte))+  ->         GLenum -> IO (Ptr GLubyte)++{-# NOINLINE ptr_gluErrorString #-}+ptr_gluErrorString :: FunPtr a+ptr_gluErrorString = unsafePerformIO $ getAPIEntry "gluErrorString"++-- gluGetNurbsProperty ----------------------------------------------------------------------++gluGetNurbsProperty :: MonadIO m => Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> m ()+gluGetNurbsProperty v1 v2 v3 = liftIO $ dyn_gluGetNurbsProperty ptr_gluGetNurbsProperty v1 v2 v3++foreign import CALLCONV "dynamic" dyn_gluGetNurbsProperty+  :: FunPtr (Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ())+  ->         Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ()++{-# NOINLINE ptr_gluGetNurbsProperty #-}+ptr_gluGetNurbsProperty :: FunPtr a+ptr_gluGetNurbsProperty = unsafePerformIO $ getAPIEntry "gluGetNurbsProperty"++-- gluGetString ----------------------------------------------------------------------++gluGetString :: MonadIO m => GLenum -> m (Ptr GLubyte)+gluGetString v1 = liftIO $ dyn_gluGetString ptr_gluGetString v1++foreign import CALLCONV "dynamic" dyn_gluGetString+  :: FunPtr (GLenum -> IO (Ptr GLubyte))+  ->         GLenum -> IO (Ptr GLubyte)++{-# NOINLINE ptr_gluGetString #-}+ptr_gluGetString :: FunPtr a+ptr_gluGetString = unsafePerformIO $ getAPIEntry "gluGetString"++-- gluGetTessProperty ----------------------------------------------------------------------++gluGetTessProperty :: MonadIO m => Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> m ()+gluGetTessProperty v1 v2 v3 = liftIO $ dyn_gluGetTessProperty ptr_gluGetTessProperty v1 v2 v3++foreign import CALLCONV "dynamic" dyn_gluGetTessProperty+  :: FunPtr (Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ())+  ->         Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ()++{-# NOINLINE ptr_gluGetTessProperty #-}+ptr_gluGetTessProperty :: FunPtr a+ptr_gluGetTessProperty = unsafePerformIO $ getAPIEntry "gluGetTessProperty"++-- gluLoadSamplingMatrices ----------------------------------------------------------------------++gluLoadSamplingMatrices :: MonadIO m => Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> m ()+gluLoadSamplingMatrices v1 v2 v3 v4 = liftIO $ dyn_gluLoadSamplingMatrices ptr_gluLoadSamplingMatrices v1 v2 v3 v4++foreign import CALLCONV "dynamic" dyn_gluLoadSamplingMatrices+  :: FunPtr (Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ())+  ->         Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ()++{-# NOINLINE ptr_gluLoadSamplingMatrices #-}+ptr_gluLoadSamplingMatrices :: FunPtr a+ptr_gluLoadSamplingMatrices = unsafePerformIO $ getAPIEntry "gluLoadSamplingMatrices"++-- gluLookAt ----------------------------------------------------------------------++gluLookAt :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()+gluLookAt v1 v2 v3 v4 v5 v6 v7 v8 v9 = liftIO $ dyn_gluLookAt ptr_gluLookAt v1 v2 v3 v4 v5 v6 v7 v8 v9++foreign import CALLCONV "dynamic" dyn_gluLookAt+  :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())+  ->         GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()++{-# NOINLINE ptr_gluLookAt #-}+ptr_gluLookAt :: FunPtr a+ptr_gluLookAt = unsafePerformIO $ getAPIEntry "gluLookAt"++-- gluNewNurbsRenderer ----------------------------------------------------------------------++gluNewNurbsRenderer :: MonadIO m => m (Ptr GLUnurbs)+gluNewNurbsRenderer = liftIO $ dyn_gluNewNurbsRenderer ptr_gluNewNurbsRenderer++foreign import CALLCONV "dynamic" dyn_gluNewNurbsRenderer+  :: FunPtr (IO (Ptr GLUnurbs))+  ->         IO (Ptr GLUnurbs)++{-# NOINLINE ptr_gluNewNurbsRenderer #-}+ptr_gluNewNurbsRenderer :: FunPtr a+ptr_gluNewNurbsRenderer = unsafePerformIO $ getAPIEntry "gluNewNurbsRenderer"++-- gluNewQuadric ----------------------------------------------------------------------++gluNewQuadric :: MonadIO m => m (Ptr GLUquadric)+gluNewQuadric = liftIO $ dyn_gluNewQuadric ptr_gluNewQuadric++foreign import CALLCONV "dynamic" dyn_gluNewQuadric+  :: FunPtr (IO (Ptr GLUquadric))+  ->         IO (Ptr GLUquadric)++{-# NOINLINE ptr_gluNewQuadric #-}+ptr_gluNewQuadric :: FunPtr a+ptr_gluNewQuadric = unsafePerformIO $ getAPIEntry "gluNewQuadric"++-- gluNewTess ----------------------------------------------------------------------++gluNewTess :: MonadIO m => m (Ptr GLUtesselator)+gluNewTess = liftIO $ dyn_gluNewTess ptr_gluNewTess++foreign import CALLCONV "dynamic" dyn_gluNewTess+  :: FunPtr (IO (Ptr GLUtesselator))+  ->         IO (Ptr GLUtesselator)++{-# NOINLINE ptr_gluNewTess #-}+ptr_gluNewTess :: FunPtr a+ptr_gluNewTess = unsafePerformIO $ getAPIEntry "gluNewTess"++-- gluNextContour ----------------------------------------------------------------------++gluNextContour :: MonadIO m => Ptr GLUtesselator -> GLenum -> m ()+gluNextContour v1 v2 = liftIO $ dyn_gluNextContour ptr_gluNextContour v1 v2++foreign import CALLCONV "dynamic" dyn_gluNextContour+  :: FunPtr (Ptr GLUtesselator -> GLenum -> IO ())+  ->         Ptr GLUtesselator -> GLenum -> IO ()++{-# NOINLINE ptr_gluNextContour #-}+ptr_gluNextContour :: FunPtr a+ptr_gluNextContour = unsafePerformIO $ getAPIEntry "gluNextContour"++-- gluNurbsCallback ----------------------------------------------------------------------++gluNurbsCallback :: MonadIO m => Ptr GLUnurbs -> GLenum -> FunPtr a -> m ()+gluNurbsCallback v1 v2 v3 = liftIO $ dyn_gluNurbsCallback ptr_gluNurbsCallback v1 v2 v3++foreign import CALLCONV "dynamic" dyn_gluNurbsCallback+  :: FunPtr (Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ())+  ->         Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ()++{-# NOINLINE ptr_gluNurbsCallback #-}+ptr_gluNurbsCallback :: FunPtr a+ptr_gluNurbsCallback = unsafePerformIO $ getAPIEntry "gluNurbsCallback"++-- gluNurbsCallbackData ----------------------------------------------------------------------++gluNurbsCallbackData :: MonadIO m => Ptr GLUnurbs -> Ptr a -> m ()+gluNurbsCallbackData v1 v2 = liftIO $ dyn_gluNurbsCallbackData ptr_gluNurbsCallbackData v1 v2++foreign import CALLCONV "dynamic" dyn_gluNurbsCallbackData+  :: FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())+  ->         Ptr GLUnurbs -> Ptr a -> IO ()++{-# NOINLINE ptr_gluNurbsCallbackData #-}+ptr_gluNurbsCallbackData :: FunPtr a+ptr_gluNurbsCallbackData = unsafePerformIO $ getAPIEntry "gluNurbsCallbackData"++-- gluNurbsCallbackDataEXT ----------------------------------------------------------------------++gluNurbsCallbackDataEXT :: MonadIO m => Ptr GLUnurbs -> Ptr a -> m ()+gluNurbsCallbackDataEXT v1 v2 = liftIO $ dyn_gluNurbsCallbackDataEXT ptr_gluNurbsCallbackDataEXT v1 v2++foreign import CALLCONV "dynamic" dyn_gluNurbsCallbackDataEXT+  :: FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())+  ->         Ptr GLUnurbs -> Ptr a -> IO ()++{-# NOINLINE ptr_gluNurbsCallbackDataEXT #-}+ptr_gluNurbsCallbackDataEXT :: FunPtr a+ptr_gluNurbsCallbackDataEXT = unsafePerformIO $ getAPIEntry "gluNurbsCallbackDataEXT"++-- gluNurbsCurve ----------------------------------------------------------------------++gluNurbsCurve :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> m ()+gluNurbsCurve v1 v2 v3 v4 v5 v6 v7 = liftIO $ dyn_gluNurbsCurve ptr_gluNurbsCurve v1 v2 v3 v4 v5 v6 v7++foreign import CALLCONV "dynamic" dyn_gluNurbsCurve+  :: FunPtr (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ())+  ->         Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ()++{-# NOINLINE ptr_gluNurbsCurve #-}+ptr_gluNurbsCurve :: FunPtr a+ptr_gluNurbsCurve = unsafePerformIO $ getAPIEntry "gluNurbsCurve"++-- gluNurbsProperty ----------------------------------------------------------------------++gluNurbsProperty :: MonadIO m => Ptr GLUnurbs -> GLenum -> GLfloat -> m ()+gluNurbsProperty v1 v2 v3 = liftIO $ dyn_gluNurbsProperty ptr_gluNurbsProperty v1 v2 v3++foreign import CALLCONV "dynamic" dyn_gluNurbsProperty+  :: FunPtr (Ptr GLUnurbs -> GLenum -> GLfloat -> IO ())+  ->         Ptr GLUnurbs -> GLenum -> GLfloat -> IO ()++{-# NOINLINE ptr_gluNurbsProperty #-}+ptr_gluNurbsProperty :: FunPtr a+ptr_gluNurbsProperty = unsafePerformIO $ getAPIEntry "gluNurbsProperty"++-- gluNurbsSurface ----------------------------------------------------------------------++gluNurbsSurface :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> m ()+gluNurbsSurface v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 = liftIO $ dyn_gluNurbsSurface ptr_gluNurbsSurface v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11++foreign import CALLCONV "dynamic" dyn_gluNurbsSurface+  :: FunPtr (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> IO ())+  ->         Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> IO ()++{-# NOINLINE ptr_gluNurbsSurface #-}+ptr_gluNurbsSurface :: FunPtr a+ptr_gluNurbsSurface = unsafePerformIO $ getAPIEntry "gluNurbsSurface"++-- gluOrtho2D ----------------------------------------------------------------------++gluOrtho2D :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()+gluOrtho2D v1 v2 v3 v4 = liftIO $ dyn_gluOrtho2D ptr_gluOrtho2D v1 v2 v3 v4++foreign import CALLCONV "dynamic" dyn_gluOrtho2D+  :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())+  ->         GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()++{-# NOINLINE ptr_gluOrtho2D #-}+ptr_gluOrtho2D :: FunPtr a+ptr_gluOrtho2D = unsafePerformIO $ getAPIEntry "gluOrtho2D"++-- gluPartialDisk ----------------------------------------------------------------------++gluPartialDisk :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> m ()+gluPartialDisk v1 v2 v3 v4 v5 v6 v7 = liftIO $ dyn_gluPartialDisk ptr_gluPartialDisk v1 v2 v3 v4 v5 v6 v7++foreign import CALLCONV "dynamic" dyn_gluPartialDisk+  :: FunPtr (Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> IO ())+  ->         Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> IO ()++{-# NOINLINE ptr_gluPartialDisk #-}+ptr_gluPartialDisk :: FunPtr a+ptr_gluPartialDisk = unsafePerformIO $ getAPIEntry "gluPartialDisk"++-- gluPerspective ----------------------------------------------------------------------++gluPerspective :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()+gluPerspective v1 v2 v3 v4 = liftIO $ dyn_gluPerspective ptr_gluPerspective v1 v2 v3 v4++foreign import CALLCONV "dynamic" dyn_gluPerspective+  :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())+  ->         GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()++{-# NOINLINE ptr_gluPerspective #-}+ptr_gluPerspective :: FunPtr a+ptr_gluPerspective = unsafePerformIO $ getAPIEntry "gluPerspective"++-- gluPickMatrix ----------------------------------------------------------------------++gluPickMatrix :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> m ()+gluPickMatrix v1 v2 v3 v4 v5 = liftIO $ dyn_gluPickMatrix ptr_gluPickMatrix v1 v2 v3 v4 v5++foreign import CALLCONV "dynamic" dyn_gluPickMatrix+  :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO ())+  ->         GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO ()++{-# NOINLINE ptr_gluPickMatrix #-}+ptr_gluPickMatrix :: FunPtr a+ptr_gluPickMatrix = unsafePerformIO $ getAPIEntry "gluPickMatrix"++-- gluProject ----------------------------------------------------------------------++gluProject :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> m GLint+gluProject v1 v2 v3 v4 v5 v6 v7 v8 v9 = liftIO $ dyn_gluProject ptr_gluProject v1 v2 v3 v4 v5 v6 v7 v8 v9++foreign import CALLCONV "dynamic" dyn_gluProject+  :: FunPtr (GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint)+  ->         GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint++{-# NOINLINE ptr_gluProject #-}+ptr_gluProject :: FunPtr a+ptr_gluProject = unsafePerformIO $ getAPIEntry "gluProject"++-- gluPwlCurve ----------------------------------------------------------------------++gluPwlCurve :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> m ()+gluPwlCurve v1 v2 v3 v4 v5 = liftIO $ dyn_gluPwlCurve ptr_gluPwlCurve v1 v2 v3 v4 v5++foreign import CALLCONV "dynamic" dyn_gluPwlCurve+  :: FunPtr (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ())+  ->         Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ()++{-# NOINLINE ptr_gluPwlCurve #-}+ptr_gluPwlCurve :: FunPtr a+ptr_gluPwlCurve = unsafePerformIO $ getAPIEntry "gluPwlCurve"++-- gluQuadricCallback ----------------------------------------------------------------------++gluQuadricCallback :: MonadIO m => Ptr GLUquadric -> GLenum -> FunPtr a -> m ()+gluQuadricCallback v1 v2 v3 = liftIO $ dyn_gluQuadricCallback ptr_gluQuadricCallback v1 v2 v3++foreign import CALLCONV "dynamic" dyn_gluQuadricCallback+  :: FunPtr (Ptr GLUquadric -> GLenum -> FunPtr a -> IO ())+  ->         Ptr GLUquadric -> GLenum -> FunPtr a -> IO ()++{-# NOINLINE ptr_gluQuadricCallback #-}+ptr_gluQuadricCallback :: FunPtr a+ptr_gluQuadricCallback = unsafePerformIO $ getAPIEntry "gluQuadricCallback"++-- gluQuadricDrawStyle ----------------------------------------------------------------------++gluQuadricDrawStyle :: MonadIO m => Ptr GLUquadric -> GLenum -> m ()+gluQuadricDrawStyle v1 v2 = liftIO $ dyn_gluQuadricDrawStyle ptr_gluQuadricDrawStyle v1 v2++foreign import CALLCONV "dynamic" dyn_gluQuadricDrawStyle+  :: FunPtr (Ptr GLUquadric -> GLenum -> IO ())+  ->         Ptr GLUquadric -> GLenum -> IO ()++{-# NOINLINE ptr_gluQuadricDrawStyle #-}+ptr_gluQuadricDrawStyle :: FunPtr a+ptr_gluQuadricDrawStyle = unsafePerformIO $ getAPIEntry "gluQuadricDrawStyle"++-- gluQuadricNormals ----------------------------------------------------------------------++gluQuadricNormals :: MonadIO m => Ptr GLUquadric -> GLenum -> m ()+gluQuadricNormals v1 v2 = liftIO $ dyn_gluQuadricNormals ptr_gluQuadricNormals v1 v2++foreign import CALLCONV "dynamic" dyn_gluQuadricNormals+  :: FunPtr (Ptr GLUquadric -> GLenum -> IO ())+  ->         Ptr GLUquadric -> GLenum -> IO ()++{-# NOINLINE ptr_gluQuadricNormals #-}+ptr_gluQuadricNormals :: FunPtr a+ptr_gluQuadricNormals = unsafePerformIO $ getAPIEntry "gluQuadricNormals"++-- gluQuadricOrientation ----------------------------------------------------------------------++gluQuadricOrientation :: MonadIO m => Ptr GLUquadric -> GLenum -> m ()+gluQuadricOrientation v1 v2 = liftIO $ dyn_gluQuadricOrientation ptr_gluQuadricOrientation v1 v2++foreign import CALLCONV "dynamic" dyn_gluQuadricOrientation+  :: FunPtr (Ptr GLUquadric -> GLenum -> IO ())+  ->         Ptr GLUquadric -> GLenum -> IO ()++{-# NOINLINE ptr_gluQuadricOrientation #-}+ptr_gluQuadricOrientation :: FunPtr a+ptr_gluQuadricOrientation = unsafePerformIO $ getAPIEntry "gluQuadricOrientation"++-- gluQuadricTexture ----------------------------------------------------------------------++gluQuadricTexture :: MonadIO m => Ptr GLUquadric -> GLboolean -> m ()+gluQuadricTexture v1 v2 = liftIO $ dyn_gluQuadricTexture ptr_gluQuadricTexture v1 v2++foreign import CALLCONV "dynamic" dyn_gluQuadricTexture+  :: FunPtr (Ptr GLUquadric -> GLboolean -> IO ())+  ->         Ptr GLUquadric -> GLboolean -> IO ()++{-# NOINLINE ptr_gluQuadricTexture #-}+ptr_gluQuadricTexture :: FunPtr a+ptr_gluQuadricTexture = unsafePerformIO $ getAPIEntry "gluQuadricTexture"++-- gluScaleImage ----------------------------------------------------------------------++gluScaleImage :: MonadIO m => GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> m GLint+gluScaleImage v1 v2 v3 v4 v5 v6 v7 v8 v9 = liftIO $ dyn_gluScaleImage ptr_gluScaleImage v1 v2 v3 v4 v5 v6 v7 v8 v9++foreign import CALLCONV "dynamic" dyn_gluScaleImage+  :: FunPtr (GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> IO GLint)+  ->         GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> IO GLint++{-# NOINLINE ptr_gluScaleImage #-}+ptr_gluScaleImage :: FunPtr a+ptr_gluScaleImage = unsafePerformIO $ getAPIEntry "gluScaleImage"++-- gluSphere ----------------------------------------------------------------------++gluSphere :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLint -> GLint -> m ()+gluSphere v1 v2 v3 v4 = liftIO $ dyn_gluSphere ptr_gluSphere v1 v2 v3 v4++foreign import CALLCONV "dynamic" dyn_gluSphere+  :: FunPtr (Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ())+  ->         Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ()++{-# NOINLINE ptr_gluSphere #-}+ptr_gluSphere :: FunPtr a+ptr_gluSphere = unsafePerformIO $ getAPIEntry "gluSphere"++-- gluTessBeginContour ----------------------------------------------------------------------++gluTessBeginContour :: MonadIO m => Ptr GLUtesselator -> m ()+gluTessBeginContour v1 = liftIO $ dyn_gluTessBeginContour ptr_gluTessBeginContour v1++foreign import CALLCONV "dynamic" dyn_gluTessBeginContour+  :: FunPtr (Ptr GLUtesselator -> IO ())+  ->         Ptr GLUtesselator -> IO ()++{-# NOINLINE ptr_gluTessBeginContour #-}+ptr_gluTessBeginContour :: FunPtr a+ptr_gluTessBeginContour = unsafePerformIO $ getAPIEntry "gluTessBeginContour"++-- gluTessBeginPolygon ----------------------------------------------------------------------++gluTessBeginPolygon :: MonadIO m => Ptr GLUtesselator -> Ptr a -> m ()+gluTessBeginPolygon v1 v2 = liftIO $ dyn_gluTessBeginPolygon ptr_gluTessBeginPolygon v1 v2++foreign import CALLCONV "dynamic" dyn_gluTessBeginPolygon+  :: FunPtr (Ptr GLUtesselator -> Ptr a -> IO ())+  ->         Ptr GLUtesselator -> Ptr a -> IO ()++{-# NOINLINE ptr_gluTessBeginPolygon #-}+ptr_gluTessBeginPolygon :: FunPtr a+ptr_gluTessBeginPolygon = unsafePerformIO $ getAPIEntry "gluTessBeginPolygon"++-- gluTessCallback ----------------------------------------------------------------------++gluTessCallback :: MonadIO m => Ptr GLUtesselator -> GLenum -> FunPtr a -> m ()+gluTessCallback v1 v2 v3 = liftIO $ dyn_gluTessCallback ptr_gluTessCallback v1 v2 v3++foreign import CALLCONV "dynamic" dyn_gluTessCallback+  :: FunPtr (Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ())+  ->         Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ()++{-# NOINLINE ptr_gluTessCallback #-}+ptr_gluTessCallback :: FunPtr a+ptr_gluTessCallback = unsafePerformIO $ getAPIEntry "gluTessCallback"++-- gluTessEndContour ----------------------------------------------------------------------++gluTessEndContour :: MonadIO m => Ptr GLUtesselator -> m ()+gluTessEndContour v1 = liftIO $ dyn_gluTessEndContour ptr_gluTessEndContour v1++foreign import CALLCONV "dynamic" dyn_gluTessEndContour+  :: FunPtr (Ptr GLUtesselator -> IO ())+  ->         Ptr GLUtesselator -> IO ()++{-# NOINLINE ptr_gluTessEndContour #-}+ptr_gluTessEndContour :: FunPtr a+ptr_gluTessEndContour = unsafePerformIO $ getAPIEntry "gluTessEndContour"++-- gluTessEndPolygon ----------------------------------------------------------------------++gluTessEndPolygon :: MonadIO m => Ptr GLUtesselator -> m ()+gluTessEndPolygon v1 = liftIO $ dyn_gluTessEndPolygon ptr_gluTessEndPolygon v1++foreign import CALLCONV "dynamic" dyn_gluTessEndPolygon+  :: FunPtr (Ptr GLUtesselator -> IO ())+  ->         Ptr GLUtesselator -> IO ()++{-# NOINLINE ptr_gluTessEndPolygon #-}+ptr_gluTessEndPolygon :: FunPtr a+ptr_gluTessEndPolygon = unsafePerformIO $ getAPIEntry "gluTessEndPolygon"++-- gluTessNormal ----------------------------------------------------------------------++gluTessNormal :: MonadIO m => Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> m ()+gluTessNormal v1 v2 v3 v4 = liftIO $ dyn_gluTessNormal ptr_gluTessNormal v1 v2 v3 v4++foreign import CALLCONV "dynamic" dyn_gluTessNormal+  :: FunPtr (Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ())+  ->         Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ()++{-# NOINLINE ptr_gluTessNormal #-}+ptr_gluTessNormal :: FunPtr a+ptr_gluTessNormal = unsafePerformIO $ getAPIEntry "gluTessNormal"++-- gluTessProperty ----------------------------------------------------------------------++gluTessProperty :: MonadIO m => Ptr GLUtesselator -> GLenum -> GLdouble -> m ()+gluTessProperty v1 v2 v3 = liftIO $ dyn_gluTessProperty ptr_gluTessProperty v1 v2 v3++foreign import CALLCONV "dynamic" dyn_gluTessProperty+  :: FunPtr (Ptr GLUtesselator -> GLenum -> GLdouble -> IO ())+  ->         Ptr GLUtesselator -> GLenum -> GLdouble -> IO ()++{-# NOINLINE ptr_gluTessProperty #-}+ptr_gluTessProperty :: FunPtr a+ptr_gluTessProperty = unsafePerformIO $ getAPIEntry "gluTessProperty"++-- gluTessVertex ----------------------------------------------------------------------++gluTessVertex :: MonadIO m => Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> m ()+gluTessVertex v1 v2 v3 = liftIO $ dyn_gluTessVertex ptr_gluTessVertex v1 v2 v3++foreign import CALLCONV "dynamic" dyn_gluTessVertex+  :: FunPtr (Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ())+  ->         Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ()++{-# NOINLINE ptr_gluTessVertex #-}+ptr_gluTessVertex :: FunPtr a+ptr_gluTessVertex = unsafePerformIO $ getAPIEntry "gluTessVertex"++-- gluUnProject ----------------------------------------------------------------------++gluUnProject :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> m GLint+gluUnProject v1 v2 v3 v4 v5 v6 v7 v8 v9 = liftIO $ dyn_gluUnProject ptr_gluUnProject v1 v2 v3 v4 v5 v6 v7 v8 v9++foreign import CALLCONV "dynamic" dyn_gluUnProject+  :: FunPtr (GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint)+  ->         GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint++{-# NOINLINE ptr_gluUnProject #-}+ptr_gluUnProject :: FunPtr a+ptr_gluUnProject = unsafePerformIO $ getAPIEntry "gluUnProject"++-- gluUnProject4 ----------------------------------------------------------------------++gluUnProject4 :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> GLclampd -> GLclampd -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> m GLint+gluUnProject4 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 = liftIO $ dyn_gluUnProject4 ptr_gluUnProject4 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13++foreign import CALLCONV "dynamic" dyn_gluUnProject4+  :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> GLclampd -> GLclampd -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint)+  ->         GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> GLclampd -> GLclampd -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint++{-# NOINLINE ptr_gluUnProject4 #-}+ptr_gluUnProject4 :: FunPtr a+ptr_gluUnProject4 = unsafePerformIO $ getAPIEntry "gluUnProject4"