diff --git a/GLURaw.cabal b/GLURaw.cabal
--- a/GLURaw.cabal
+++ b/GLURaw.cabal
@@ -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)
diff --git a/include/HsGLURaw.h b/include/HsGLURaw.h
deleted file mode 100644
--- a/include/HsGLURaw.h
+++ /dev/null
@@ -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
diff --git a/src/Graphics/Rendering/GLU/Raw/APIEntry.hs b/src/Graphics/Rendering/GLU/Raw/APIEntry.hs
deleted file mode 100644
--- a/src/Graphics/Rendering/GLU/Raw/APIEntry.hs
+++ /dev/null
@@ -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)
diff --git a/src/Graphics/Rendering/GLU/Raw/Functions.hs b/src/Graphics/Rendering/GLU/Raw/Functions.hs
--- a/src/Graphics/Rendering/GLU/Raw/Functions.hs
+++ b/src/Graphics/Rendering/GLU/Raw/Functions.hs
@@ -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"