{-# LANGUAGE CPP #-}
--------------------------------------------------------------------------------
-- |
-- Module      :  Graphics.GLU.Functions
-- Copyright   :  (c) Sven Panne 2018
-- License     :  BSD3
--
-- Maintainer  :  Sven Panne <svenpanne@gmail.com>
-- Stability   :  stable
-- Portability :  portable
--
-- All functions from GLU 1.3, see <http://www.opengl.org/>.
--
--------------------------------------------------------------------------------

module Graphics.GLU.Functions (
   gluBeginCurve,
   gluBeginPolygon,
   gluBeginSurface,
   gluBeginTrim,
   gluBuild1DMipmapLevels,
   gluBuild1DMipmaps,
   gluBuild2DMipmapLevels,
   gluBuild2DMipmaps,
   gluBuild3DMipmapLevels,
   gluBuild3DMipmaps,
   gluCheckExtension,
   gluCylinder,
   gluDeleteNurbsRenderer,
   gluDeleteQuadric,
   gluDeleteTess,
   gluDisk,
   gluEndCurve,
   gluEndPolygon,
   gluEndSurface,
   gluEndTrim,
   gluErrorString,
   gluGetNurbsProperty,
   gluGetString,
   gluGetTessProperty,
   gluLoadSamplingMatrices,
   gluLookAt,
   gluNewNurbsRenderer,
   gluNewQuadric,
   gluNewTess,
   gluNextContour,
   gluNurbsCallback,
   gluNurbsCallbackData,
   gluNurbsCallbackDataEXT,
   gluNurbsCurve,
   gluNurbsProperty,
   gluNurbsSurface,
   gluOrtho2D,
   gluPartialDisk,
   gluPerspective,
   gluPickMatrix,
   gluProject,
   gluPwlCurve,
   gluQuadricCallback,
   gluQuadricDrawStyle,
   gluQuadricNormals,
   gluQuadricOrientation,
   gluQuadricTexture,
   gluScaleImage,
   gluSphere,
   gluTessBeginContour,
   gluTessBeginPolygon,
   gluTessCallback,
   gluTessEndContour,
   gluTessEndPolygon,
   gluTessNormal,
   gluTessProperty,
   gluTessVertex,
   gluUnProject,
   gluUnProject4,
) where

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.GLU.Types
import Graphics.GL.Types

--------------------------------------------------------------------------------

-- | 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 :: String -> IO (FunPtr a)
getAPIEntry String
extensionEntry =
   String -> IO (FunPtr a) -> IO (FunPtr a)
forall a. String -> IO (FunPtr a) -> IO (FunPtr a)
throwIfNullFunPtr (String
"unknown GLU entry " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
extensionEntry) (IO (FunPtr a) -> IO (FunPtr a)) -> IO (FunPtr a) -> IO (FunPtr a)
forall a b. (a -> b) -> a -> b
$
      String -> (CString -> IO (FunPtr a)) -> IO (FunPtr a)
forall a. String -> (CString -> IO a) -> IO a
withCString String
extensionEntry CString -> IO (FunPtr a)
forall a. CString -> IO (FunPtr a)
hs_GLU_getProcAddress

throwIfNullFunPtr :: String -> IO (FunPtr a) -> IO (FunPtr a)
throwIfNullFunPtr :: String -> IO (FunPtr a) -> IO (FunPtr a)
throwIfNullFunPtr = (FunPtr a -> Bool)
-> (FunPtr a -> String) -> IO (FunPtr a) -> IO (FunPtr a)
forall a. (a -> Bool) -> (a -> String) -> IO a -> IO a
throwIf (FunPtr a -> FunPtr a -> Bool
forall a. Eq a => a -> a -> Bool
== FunPtr a
forall a. FunPtr a
nullFunPtr) ((FunPtr a -> String) -> IO (FunPtr a) -> IO (FunPtr a))
-> (String -> FunPtr a -> String)
-> String
-> IO (FunPtr a)
-> IO (FunPtr a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> FunPtr a -> String
forall a b. a -> b -> a
const

foreign import ccall unsafe "hs_GLU_getProcAddress"
   hs_GLU_getProcAddress :: CString -> IO (FunPtr a)

-- gluBeginCurve ----------------------------------------------------------------------

gluBeginCurve :: MonadIO m => Ptr GLUnurbs -> m ()
gluBeginCurve :: Ptr GLUnurbs -> m ()
gluBeginCurve Ptr GLUnurbs
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
dyn_gluBeginCurve FunPtr (Ptr GLUnurbs -> IO ())
forall a. FunPtr a
ptr_gluBeginCurve Ptr GLUnurbs
v1

foreign import CALLCONV "dynamic" dyn_gluBeginCurve
  :: FunPtr (Ptr GLUnurbs -> IO ())
  ->         Ptr GLUnurbs -> IO ()

{-# NOINLINE ptr_gluBeginCurve #-}
ptr_gluBeginCurve :: FunPtr a
ptr_gluBeginCurve :: FunPtr a
ptr_gluBeginCurve = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluBeginCurve"

-- gluBeginPolygon ----------------------------------------------------------------------

gluBeginPolygon :: MonadIO m => Ptr GLUtesselator -> m ()
gluBeginPolygon :: Ptr GLUtesselator -> m ()
gluBeginPolygon Ptr GLUtesselator
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
dyn_gluBeginPolygon FunPtr (Ptr GLUtesselator -> IO ())
forall a. FunPtr a
ptr_gluBeginPolygon Ptr GLUtesselator
v1

foreign import CALLCONV "dynamic" dyn_gluBeginPolygon
  :: FunPtr (Ptr GLUtesselator -> IO ())
  ->         Ptr GLUtesselator -> IO ()

{-# NOINLINE ptr_gluBeginPolygon #-}
ptr_gluBeginPolygon :: FunPtr a
ptr_gluBeginPolygon :: FunPtr a
ptr_gluBeginPolygon = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluBeginPolygon"

-- gluBeginSurface ----------------------------------------------------------------------

gluBeginSurface :: MonadIO m => Ptr GLUnurbs -> m ()
gluBeginSurface :: Ptr GLUnurbs -> m ()
gluBeginSurface Ptr GLUnurbs
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
dyn_gluBeginSurface FunPtr (Ptr GLUnurbs -> IO ())
forall a. FunPtr a
ptr_gluBeginSurface Ptr GLUnurbs
v1

foreign import CALLCONV "dynamic" dyn_gluBeginSurface
  :: FunPtr (Ptr GLUnurbs -> IO ())
  ->         Ptr GLUnurbs -> IO ()

{-# NOINLINE ptr_gluBeginSurface #-}
ptr_gluBeginSurface :: FunPtr a
ptr_gluBeginSurface :: FunPtr a
ptr_gluBeginSurface = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluBeginSurface"

-- gluBeginTrim ----------------------------------------------------------------------

gluBeginTrim :: MonadIO m => Ptr GLUnurbs -> m ()
gluBeginTrim :: Ptr GLUnurbs -> m ()
gluBeginTrim Ptr GLUnurbs
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
dyn_gluBeginTrim FunPtr (Ptr GLUnurbs -> IO ())
forall a. FunPtr a
ptr_gluBeginTrim Ptr GLUnurbs
v1

foreign import CALLCONV "dynamic" dyn_gluBeginTrim
  :: FunPtr (Ptr GLUnurbs -> IO ())
  ->         Ptr GLUnurbs -> IO ()

{-# NOINLINE ptr_gluBeginTrim #-}
ptr_gluBeginTrim :: FunPtr a
ptr_gluBeginTrim :: FunPtr a
ptr_gluBeginTrim = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluBeginTrim"

-- gluBuild1DMipmapLevels ----------------------------------------------------------------------

gluBuild1DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint
gluBuild1DMipmapLevels :: GLenum
-> GLint
-> GLint
-> GLenum
-> GLenum
-> GLint
-> GLint
-> GLint
-> Ptr a
-> m GLint
gluBuild1DMipmapLevels GLenum
v1 GLint
v2 GLint
v3 GLenum
v4 GLenum
v5 GLint
v6 GLint
v7 GLint
v8 Ptr a
v9 = IO GLint -> m GLint
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> GLint
   -> GLint
   -> GLint
   -> Ptr a
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLenum
-> GLenum
-> GLint
-> GLint
-> GLint
-> Ptr a
-> IO GLint
forall a.
FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> GLint
   -> GLint
   -> GLint
   -> Ptr a
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLenum
-> GLenum
-> GLint
-> GLint
-> GLint
-> Ptr a
-> IO GLint
dyn_gluBuild1DMipmapLevels FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> GLint
   -> GLint
   -> GLint
   -> Ptr a
   -> IO GLint)
forall a. FunPtr a
ptr_gluBuild1DMipmapLevels GLenum
v1 GLint
v2 GLint
v3 GLenum
v4 GLenum
v5 GLint
v6 GLint
v7 GLint
v8 Ptr a
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 :: FunPtr a
ptr_gluBuild1DMipmapLevels = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluBuild1DMipmapLevels"

-- gluBuild1DMipmaps ----------------------------------------------------------------------

gluBuild1DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint
gluBuild1DMipmaps :: GLenum -> GLint -> GLint -> GLenum -> GLenum -> Ptr a -> m GLint
gluBuild1DMipmaps GLenum
v1 GLint
v2 GLint
v3 GLenum
v4 GLenum
v5 Ptr a
v6 = IO GLint -> m GLint
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLenum -> GLint -> GLint -> GLenum -> GLenum -> Ptr a -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLenum
-> GLenum
-> Ptr a
-> IO GLint
forall a.
FunPtr
  (GLenum -> GLint -> GLint -> GLenum -> GLenum -> Ptr a -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLenum
-> GLenum
-> Ptr a
-> IO GLint
dyn_gluBuild1DMipmaps FunPtr
  (GLenum -> GLint -> GLint -> GLenum -> GLenum -> Ptr a -> IO GLint)
forall a. FunPtr a
ptr_gluBuild1DMipmaps GLenum
v1 GLint
v2 GLint
v3 GLenum
v4 GLenum
v5 Ptr a
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 :: FunPtr a
ptr_gluBuild1DMipmaps = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluBuild1DMipmaps"

-- gluBuild2DMipmapLevels ----------------------------------------------------------------------

gluBuild2DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint
gluBuild2DMipmapLevels :: GLenum
-> GLint
-> GLint
-> GLint
-> GLenum
-> GLenum
-> GLint
-> GLint
-> GLint
-> Ptr a
-> m GLint
gluBuild2DMipmapLevels GLenum
v1 GLint
v2 GLint
v3 GLint
v4 GLenum
v5 GLenum
v6 GLint
v7 GLint
v8 GLint
v9 Ptr a
v10 = IO GLint -> m GLint
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> GLint
   -> GLint
   -> GLint
   -> Ptr a
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLint
-> GLenum
-> GLenum
-> GLint
-> GLint
-> GLint
-> Ptr a
-> IO GLint
forall a.
FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> GLint
   -> GLint
   -> GLint
   -> Ptr a
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLint
-> GLenum
-> GLenum
-> GLint
-> GLint
-> GLint
-> Ptr a
-> IO GLint
dyn_gluBuild2DMipmapLevels FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> GLint
   -> GLint
   -> GLint
   -> Ptr a
   -> IO GLint)
forall a. FunPtr a
ptr_gluBuild2DMipmapLevels GLenum
v1 GLint
v2 GLint
v3 GLint
v4 GLenum
v5 GLenum
v6 GLint
v7 GLint
v8 GLint
v9 Ptr a
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 :: FunPtr a
ptr_gluBuild2DMipmapLevels = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluBuild2DMipmapLevels"

-- gluBuild2DMipmaps ----------------------------------------------------------------------

gluBuild2DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint
gluBuild2DMipmaps :: GLenum
-> GLint -> GLint -> GLint -> GLenum -> GLenum -> Ptr a -> m GLint
gluBuild2DMipmaps GLenum
v1 GLint
v2 GLint
v3 GLint
v4 GLenum
v5 GLenum
v6 Ptr a
v7 = IO GLint -> m GLint
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> Ptr a
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLint
-> GLenum
-> GLenum
-> Ptr a
-> IO GLint
forall a.
FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> Ptr a
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLint
-> GLenum
-> GLenum
-> Ptr a
-> IO GLint
dyn_gluBuild2DMipmaps FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> Ptr a
   -> IO GLint)
forall a. FunPtr a
ptr_gluBuild2DMipmaps GLenum
v1 GLint
v2 GLint
v3 GLint
v4 GLenum
v5 GLenum
v6 Ptr a
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 :: FunPtr a
ptr_gluBuild2DMipmaps = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluBuild2DMipmaps"

-- gluBuild3DMipmapLevels ----------------------------------------------------------------------

gluBuild3DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint
gluBuild3DMipmapLevels :: GLenum
-> GLint
-> GLint
-> GLint
-> GLint
-> GLenum
-> GLenum
-> GLint
-> GLint
-> GLint
-> Ptr a
-> m GLint
gluBuild3DMipmapLevels GLenum
v1 GLint
v2 GLint
v3 GLint
v4 GLint
v5 GLenum
v6 GLenum
v7 GLint
v8 GLint
v9 GLint
v10 Ptr a
v11= IO GLint -> m GLint
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> GLint
   -> GLint
   -> GLint
   -> Ptr a
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLint
-> GLint
-> GLenum
-> GLenum
-> GLint
-> GLint
-> GLint
-> Ptr a
-> IO GLint
forall a.
FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> GLint
   -> GLint
   -> GLint
   -> Ptr a
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLint
-> GLint
-> GLenum
-> GLenum
-> GLint
-> GLint
-> GLint
-> Ptr a
-> IO GLint
dyn_gluBuild3DMipmapLevels FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> GLint
   -> GLint
   -> GLint
   -> Ptr a
   -> IO GLint)
forall a. FunPtr a
ptr_gluBuild3DMipmapLevels GLenum
v1 GLint
v2 GLint
v3 GLint
v4 GLint
v5 GLenum
v6 GLenum
v7 GLint
v8 GLint
v9 GLint
v10 Ptr a
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 :: FunPtr a
ptr_gluBuild3DMipmapLevels = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluBuild3DMipmapLevels"

-- gluBuild3DMipmaps ----------------------------------------------------------------------

gluBuild3DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint
gluBuild3DMipmaps :: GLenum
-> GLint
-> GLint
-> GLint
-> GLint
-> GLenum
-> GLenum
-> Ptr a
-> m GLint
gluBuild3DMipmaps GLenum
v1 GLint
v2 GLint
v3 GLint
v4 GLint
v5 GLenum
v6 GLenum
v7 Ptr a
v8 = IO GLint -> m GLint
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> Ptr a
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLint
-> GLint
-> GLenum
-> GLenum
-> Ptr a
-> IO GLint
forall a.
FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> Ptr a
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLint
-> GLint
-> GLenum
-> GLenum
-> Ptr a
-> IO GLint
dyn_gluBuild3DMipmaps FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLint
   -> GLint
   -> GLenum
   -> GLenum
   -> Ptr a
   -> IO GLint)
forall a. FunPtr a
ptr_gluBuild3DMipmaps GLenum
v1 GLint
v2 GLint
v3 GLint
v4 GLint
v5 GLenum
v6 GLenum
v7 Ptr a
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 :: FunPtr a
ptr_gluBuild3DMipmaps = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluBuild3DMipmaps"

-- gluCheckExtension ----------------------------------------------------------------------

gluCheckExtension :: MonadIO m => Ptr GLubyte -> Ptr GLubyte -> m GLboolean
gluCheckExtension :: Ptr GLubyte -> Ptr GLubyte -> m GLubyte
gluCheckExtension Ptr GLubyte
v1 Ptr GLubyte
v2 = IO GLubyte -> m GLubyte
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLubyte -> m GLubyte) -> IO GLubyte -> m GLubyte
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLubyte -> Ptr GLubyte -> IO GLubyte)
-> Ptr GLubyte -> Ptr GLubyte -> IO GLubyte
dyn_gluCheckExtension FunPtr (Ptr GLubyte -> Ptr GLubyte -> IO GLubyte)
forall a. FunPtr a
ptr_gluCheckExtension Ptr GLubyte
v1 Ptr GLubyte
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 :: FunPtr a
ptr_gluCheckExtension = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluCheckExtension"

-- gluCylinder ----------------------------------------------------------------------

gluCylinder :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> m ()
gluCylinder :: Ptr GLUquadric
-> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> m ()
gluCylinder Ptr GLUquadric
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLint
v5 GLint
v6 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (Ptr GLUquadric
   -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())
-> Ptr GLUquadric
-> GLdouble
-> GLdouble
-> GLdouble
-> GLint
-> GLint
-> IO ()
dyn_gluCylinder FunPtr
  (Ptr GLUquadric
   -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())
forall a. FunPtr a
ptr_gluCylinder Ptr GLUquadric
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLint
v5 GLint
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 :: FunPtr a
ptr_gluCylinder = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluCylinder"

-- gluDeleteNurbsRenderer ----------------------------------------------------------------------

gluDeleteNurbsRenderer :: MonadIO m => Ptr GLUnurbs -> m ()
gluDeleteNurbsRenderer :: Ptr GLUnurbs -> m ()
gluDeleteNurbsRenderer Ptr GLUnurbs
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
dyn_gluDeleteNurbsRenderer FunPtr (Ptr GLUnurbs -> IO ())
forall a. FunPtr a
ptr_gluDeleteNurbsRenderer Ptr GLUnurbs
v1

foreign import CALLCONV "dynamic" dyn_gluDeleteNurbsRenderer
  :: FunPtr (Ptr GLUnurbs -> IO ())
  ->         Ptr GLUnurbs -> IO ()

{-# NOINLINE ptr_gluDeleteNurbsRenderer #-}
ptr_gluDeleteNurbsRenderer :: FunPtr a
ptr_gluDeleteNurbsRenderer :: FunPtr a
ptr_gluDeleteNurbsRenderer = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluDeleteNurbsRenderer"

-- gluDeleteQuadric ----------------------------------------------------------------------

gluDeleteQuadric :: MonadIO m => Ptr GLUquadric -> m ()
gluDeleteQuadric :: Ptr GLUquadric -> m ()
gluDeleteQuadric Ptr GLUquadric
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUquadric -> IO ()) -> Ptr GLUquadric -> IO ()
dyn_gluDeleteQuadric FunPtr (Ptr GLUquadric -> IO ())
forall a. FunPtr a
ptr_gluDeleteQuadric Ptr GLUquadric
v1

foreign import CALLCONV "dynamic" dyn_gluDeleteQuadric
  :: FunPtr (Ptr GLUquadric -> IO ())
  ->         Ptr GLUquadric -> IO ()

{-# NOINLINE ptr_gluDeleteQuadric #-}
ptr_gluDeleteQuadric :: FunPtr a
ptr_gluDeleteQuadric :: FunPtr a
ptr_gluDeleteQuadric = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluDeleteQuadric"

-- gluDeleteTess ----------------------------------------------------------------------

gluDeleteTess :: MonadIO m => Ptr GLUtesselator -> m ()
gluDeleteTess :: Ptr GLUtesselator -> m ()
gluDeleteTess Ptr GLUtesselator
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
dyn_gluDeleteTess FunPtr (Ptr GLUtesselator -> IO ())
forall a. FunPtr a
ptr_gluDeleteTess Ptr GLUtesselator
v1

foreign import CALLCONV "dynamic" dyn_gluDeleteTess
  :: FunPtr (Ptr GLUtesselator -> IO ())
  ->         Ptr GLUtesselator -> IO ()

{-# NOINLINE ptr_gluDeleteTess #-}
ptr_gluDeleteTess :: FunPtr a
ptr_gluDeleteTess :: FunPtr a
ptr_gluDeleteTess = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluDeleteTess"

-- gluDisk ----------------------------------------------------------------------

gluDisk :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> m ()
gluDisk :: Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> m ()
gluDisk Ptr GLUquadric
v1 GLdouble
v2 GLdouble
v3 GLint
v4 GLint
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())
-> Ptr GLUquadric
-> GLdouble
-> GLdouble
-> GLint
-> GLint
-> IO ()
dyn_gluDisk FunPtr
  (Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO ())
forall a. FunPtr a
ptr_gluDisk Ptr GLUquadric
v1 GLdouble
v2 GLdouble
v3 GLint
v4 GLint
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 :: FunPtr a
ptr_gluDisk = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluDisk"

-- gluEndCurve ----------------------------------------------------------------------

gluEndCurve :: MonadIO m => Ptr GLUnurbs -> m ()
gluEndCurve :: Ptr GLUnurbs -> m ()
gluEndCurve Ptr GLUnurbs
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
dyn_gluEndCurve FunPtr (Ptr GLUnurbs -> IO ())
forall a. FunPtr a
ptr_gluEndCurve Ptr GLUnurbs
v1

foreign import CALLCONV "dynamic" dyn_gluEndCurve
  :: FunPtr (Ptr GLUnurbs -> IO ())
  ->         Ptr GLUnurbs -> IO ()

{-# NOINLINE ptr_gluEndCurve #-}
ptr_gluEndCurve :: FunPtr a
ptr_gluEndCurve :: FunPtr a
ptr_gluEndCurve = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluEndCurve"

-- gluEndPolygon ----------------------------------------------------------------------

gluEndPolygon :: MonadIO m => Ptr GLUtesselator -> m ()
gluEndPolygon :: Ptr GLUtesselator -> m ()
gluEndPolygon Ptr GLUtesselator
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
dyn_gluEndPolygon FunPtr (Ptr GLUtesselator -> IO ())
forall a. FunPtr a
ptr_gluEndPolygon Ptr GLUtesselator
v1

foreign import CALLCONV "dynamic" dyn_gluEndPolygon
  :: FunPtr (Ptr GLUtesselator -> IO ())
  ->         Ptr GLUtesselator -> IO ()

{-# NOINLINE ptr_gluEndPolygon #-}
ptr_gluEndPolygon :: FunPtr a
ptr_gluEndPolygon :: FunPtr a
ptr_gluEndPolygon = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluEndPolygon"

-- gluEndSurface ----------------------------------------------------------------------

gluEndSurface :: MonadIO m => Ptr GLUnurbs -> m ()
gluEndSurface :: Ptr GLUnurbs -> m ()
gluEndSurface Ptr GLUnurbs
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
dyn_gluEndSurface FunPtr (Ptr GLUnurbs -> IO ())
forall a. FunPtr a
ptr_gluEndSurface Ptr GLUnurbs
v1

foreign import CALLCONV "dynamic" dyn_gluEndSurface
  :: FunPtr (Ptr GLUnurbs -> IO ())
  ->         Ptr GLUnurbs -> IO ()

{-# NOINLINE ptr_gluEndSurface #-}
ptr_gluEndSurface :: FunPtr a
ptr_gluEndSurface :: FunPtr a
ptr_gluEndSurface = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluEndSurface"

-- gluEndTrim ----------------------------------------------------------------------

gluEndTrim :: MonadIO m => Ptr GLUnurbs -> m ()
gluEndTrim :: Ptr GLUnurbs -> m ()
gluEndTrim Ptr GLUnurbs
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> IO ()) -> Ptr GLUnurbs -> IO ()
dyn_gluEndTrim FunPtr (Ptr GLUnurbs -> IO ())
forall a. FunPtr a
ptr_gluEndTrim Ptr GLUnurbs
v1

foreign import CALLCONV "dynamic" dyn_gluEndTrim
  :: FunPtr (Ptr GLUnurbs -> IO ())
  ->         Ptr GLUnurbs -> IO ()

{-# NOINLINE ptr_gluEndTrim #-}
ptr_gluEndTrim :: FunPtr a
ptr_gluEndTrim :: FunPtr a
ptr_gluEndTrim = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluEndTrim"

-- gluErrorString ----------------------------------------------------------------------

gluErrorString :: MonadIO m => GLenum -> m (Ptr GLubyte)
gluErrorString :: GLenum -> m (Ptr GLubyte)
gluErrorString GLenum
v1 = IO (Ptr GLubyte) -> m (Ptr GLubyte)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr GLubyte) -> m (Ptr GLubyte))
-> IO (Ptr GLubyte) -> m (Ptr GLubyte)
forall a b. (a -> b) -> a -> b
$ FunPtr (GLenum -> IO (Ptr GLubyte)) -> GLenum -> IO (Ptr GLubyte)
dyn_gluErrorString FunPtr (GLenum -> IO (Ptr GLubyte))
forall a. FunPtr a
ptr_gluErrorString GLenum
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 :: FunPtr a
ptr_gluErrorString = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluErrorString"

-- gluGetNurbsProperty ----------------------------------------------------------------------

gluGetNurbsProperty :: MonadIO m => Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> m ()
gluGetNurbsProperty :: Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> m ()
gluGetNurbsProperty Ptr GLUnurbs
v1 GLenum
v2 Ptr GLfloat
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ())
-> Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ()
dyn_gluGetNurbsProperty FunPtr (Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ())
forall a. FunPtr a
ptr_gluGetNurbsProperty Ptr GLUnurbs
v1 GLenum
v2 Ptr GLfloat
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 :: FunPtr a
ptr_gluGetNurbsProperty = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluGetNurbsProperty"

-- gluGetString ----------------------------------------------------------------------

gluGetString :: MonadIO m => GLenum -> m (Ptr GLubyte)
gluGetString :: GLenum -> m (Ptr GLubyte)
gluGetString GLenum
v1 = IO (Ptr GLubyte) -> m (Ptr GLubyte)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr GLubyte) -> m (Ptr GLubyte))
-> IO (Ptr GLubyte) -> m (Ptr GLubyte)
forall a b. (a -> b) -> a -> b
$ FunPtr (GLenum -> IO (Ptr GLubyte)) -> GLenum -> IO (Ptr GLubyte)
dyn_gluGetString FunPtr (GLenum -> IO (Ptr GLubyte))
forall a. FunPtr a
ptr_gluGetString GLenum
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 :: FunPtr a
ptr_gluGetString = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluGetString"

-- gluGetTessProperty ----------------------------------------------------------------------

gluGetTessProperty :: MonadIO m => Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> m ()
gluGetTessProperty :: Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> m ()
gluGetTessProperty Ptr GLUtesselator
v1 GLenum
v2 Ptr GLdouble
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ())
-> Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ()
dyn_gluGetTessProperty FunPtr (Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ())
forall a. FunPtr a
ptr_gluGetTessProperty Ptr GLUtesselator
v1 GLenum
v2 Ptr GLdouble
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 :: FunPtr a
ptr_gluGetTessProperty = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluGetTessProperty"

-- gluLoadSamplingMatrices ----------------------------------------------------------------------

gluLoadSamplingMatrices :: MonadIO m => Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> m ()
gluLoadSamplingMatrices :: Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> m ()
gluLoadSamplingMatrices Ptr GLUnurbs
v1 Ptr GLfloat
v2 Ptr GLfloat
v3 Ptr GLint
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ())
-> Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ()
dyn_gluLoadSamplingMatrices FunPtr
  (Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ())
forall a. FunPtr a
ptr_gluLoadSamplingMatrices Ptr GLUnurbs
v1 Ptr GLfloat
v2 Ptr GLfloat
v3 Ptr GLint
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 :: FunPtr a
ptr_gluLoadSamplingMatrices = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluLoadSamplingMatrices"

-- gluLookAt ----------------------------------------------------------------------

gluLookAt :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
gluLookAt :: GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> m ()
gluLookAt GLdouble
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5 GLdouble
v6 GLdouble
v7 GLdouble
v8 GLdouble
v9 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> IO ())
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> IO ()
dyn_gluLookAt FunPtr
  (GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> IO ())
forall a. FunPtr a
ptr_gluLookAt GLdouble
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 GLdouble
v5 GLdouble
v6 GLdouble
v7 GLdouble
v8 GLdouble
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 :: FunPtr a
ptr_gluLookAt = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluLookAt"

-- gluNewNurbsRenderer ----------------------------------------------------------------------

gluNewNurbsRenderer :: MonadIO m => m (Ptr GLUnurbs)
gluNewNurbsRenderer :: m (Ptr GLUnurbs)
gluNewNurbsRenderer = IO (Ptr GLUnurbs) -> m (Ptr GLUnurbs)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr GLUnurbs) -> m (Ptr GLUnurbs))
-> IO (Ptr GLUnurbs) -> m (Ptr GLUnurbs)
forall a b. (a -> b) -> a -> b
$ FunPtr (IO (Ptr GLUnurbs)) -> IO (Ptr GLUnurbs)
dyn_gluNewNurbsRenderer FunPtr (IO (Ptr GLUnurbs))
forall a. FunPtr a
ptr_gluNewNurbsRenderer

foreign import CALLCONV "dynamic" dyn_gluNewNurbsRenderer
  :: FunPtr (IO (Ptr GLUnurbs))
  ->         IO (Ptr GLUnurbs)

{-# NOINLINE ptr_gluNewNurbsRenderer #-}
ptr_gluNewNurbsRenderer :: FunPtr a
ptr_gluNewNurbsRenderer :: FunPtr a
ptr_gluNewNurbsRenderer = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluNewNurbsRenderer"

-- gluNewQuadric ----------------------------------------------------------------------

gluNewQuadric :: MonadIO m => m (Ptr GLUquadric)
gluNewQuadric :: m (Ptr GLUquadric)
gluNewQuadric = IO (Ptr GLUquadric) -> m (Ptr GLUquadric)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr GLUquadric) -> m (Ptr GLUquadric))
-> IO (Ptr GLUquadric) -> m (Ptr GLUquadric)
forall a b. (a -> b) -> a -> b
$ FunPtr (IO (Ptr GLUquadric)) -> IO (Ptr GLUquadric)
dyn_gluNewQuadric FunPtr (IO (Ptr GLUquadric))
forall a. FunPtr a
ptr_gluNewQuadric

foreign import CALLCONV "dynamic" dyn_gluNewQuadric
  :: FunPtr (IO (Ptr GLUquadric))
  ->         IO (Ptr GLUquadric)

{-# NOINLINE ptr_gluNewQuadric #-}
ptr_gluNewQuadric :: FunPtr a
ptr_gluNewQuadric :: FunPtr a
ptr_gluNewQuadric = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluNewQuadric"

-- gluNewTess ----------------------------------------------------------------------

gluNewTess :: MonadIO m => m (Ptr GLUtesselator)
gluNewTess :: m (Ptr GLUtesselator)
gluNewTess = IO (Ptr GLUtesselator) -> m (Ptr GLUtesselator)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr GLUtesselator) -> m (Ptr GLUtesselator))
-> IO (Ptr GLUtesselator) -> m (Ptr GLUtesselator)
forall a b. (a -> b) -> a -> b
$ FunPtr (IO (Ptr GLUtesselator)) -> IO (Ptr GLUtesselator)
dyn_gluNewTess FunPtr (IO (Ptr GLUtesselator))
forall a. FunPtr a
ptr_gluNewTess

foreign import CALLCONV "dynamic" dyn_gluNewTess
  :: FunPtr (IO (Ptr GLUtesselator))
  ->         IO (Ptr GLUtesselator)

{-# NOINLINE ptr_gluNewTess #-}
ptr_gluNewTess :: FunPtr a
ptr_gluNewTess :: FunPtr a
ptr_gluNewTess = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluNewTess"

-- gluNextContour ----------------------------------------------------------------------

gluNextContour :: MonadIO m => Ptr GLUtesselator -> GLenum -> m ()
gluNextContour :: Ptr GLUtesselator -> GLenum -> m ()
gluNextContour Ptr GLUtesselator
v1 GLenum
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> GLenum -> IO ())
-> Ptr GLUtesselator -> GLenum -> IO ()
dyn_gluNextContour FunPtr (Ptr GLUtesselator -> GLenum -> IO ())
forall a. FunPtr a
ptr_gluNextContour Ptr GLUtesselator
v1 GLenum
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 :: FunPtr a
ptr_gluNextContour = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluNextContour"

-- gluNurbsCallback ----------------------------------------------------------------------

gluNurbsCallback :: MonadIO m => Ptr GLUnurbs -> GLenum -> FunPtr a -> m ()
gluNurbsCallback :: Ptr GLUnurbs -> GLenum -> FunPtr a -> m ()
gluNurbsCallback Ptr GLUnurbs
v1 GLenum
v2 FunPtr a
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ())
-> Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ()
forall a.
FunPtr (Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ())
-> Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ()
dyn_gluNurbsCallback FunPtr (Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ())
forall a. FunPtr a
ptr_gluNurbsCallback Ptr GLUnurbs
v1 GLenum
v2 FunPtr a
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 :: FunPtr a
ptr_gluNurbsCallback = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluNurbsCallback"

-- gluNurbsCallbackData ----------------------------------------------------------------------

gluNurbsCallbackData :: MonadIO m => Ptr GLUnurbs -> Ptr a -> m ()
gluNurbsCallbackData :: Ptr GLUnurbs -> Ptr a -> m ()
gluNurbsCallbackData Ptr GLUnurbs
v1 Ptr a
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
-> Ptr GLUnurbs -> Ptr a -> IO ()
forall a.
FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
-> Ptr GLUnurbs -> Ptr a -> IO ()
dyn_gluNurbsCallbackData FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
forall a. FunPtr a
ptr_gluNurbsCallbackData Ptr GLUnurbs
v1 Ptr a
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 :: FunPtr a
ptr_gluNurbsCallbackData = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluNurbsCallbackData"

-- gluNurbsCallbackDataEXT ----------------------------------------------------------------------

gluNurbsCallbackDataEXT :: MonadIO m => Ptr GLUnurbs -> Ptr a -> m ()
gluNurbsCallbackDataEXT :: Ptr GLUnurbs -> Ptr a -> m ()
gluNurbsCallbackDataEXT Ptr GLUnurbs
v1 Ptr a
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
-> Ptr GLUnurbs -> Ptr a -> IO ()
forall a.
FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
-> Ptr GLUnurbs -> Ptr a -> IO ()
dyn_gluNurbsCallbackDataEXT FunPtr (Ptr GLUnurbs -> Ptr a -> IO ())
forall a. FunPtr a
ptr_gluNurbsCallbackDataEXT Ptr GLUnurbs
v1 Ptr a
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 :: FunPtr a
ptr_gluNurbsCallbackDataEXT = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluNurbsCallbackDataEXT"

-- gluNurbsCurve ----------------------------------------------------------------------

gluNurbsCurve :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> m ()
gluNurbsCurve :: Ptr GLUnurbs
-> GLint
-> Ptr GLfloat
-> GLint
-> Ptr GLfloat
-> GLint
-> GLenum
-> m ()
gluNurbsCurve Ptr GLUnurbs
v1 GLint
v2 Ptr GLfloat
v3 GLint
v4 Ptr GLfloat
v5 GLint
v6 GLenum
v7 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (Ptr GLUnurbs
   -> GLint
   -> Ptr GLfloat
   -> GLint
   -> Ptr GLfloat
   -> GLint
   -> GLenum
   -> IO ())
-> Ptr GLUnurbs
-> GLint
-> Ptr GLfloat
-> GLint
-> Ptr GLfloat
-> GLint
-> GLenum
-> IO ()
dyn_gluNurbsCurve FunPtr
  (Ptr GLUnurbs
   -> GLint
   -> Ptr GLfloat
   -> GLint
   -> Ptr GLfloat
   -> GLint
   -> GLenum
   -> IO ())
forall a. FunPtr a
ptr_gluNurbsCurve Ptr GLUnurbs
v1 GLint
v2 Ptr GLfloat
v3 GLint
v4 Ptr GLfloat
v5 GLint
v6 GLenum
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 :: FunPtr a
ptr_gluNurbsCurve = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluNurbsCurve"

-- gluNurbsProperty ----------------------------------------------------------------------

gluNurbsProperty :: MonadIO m => Ptr GLUnurbs -> GLenum -> GLfloat -> m ()
gluNurbsProperty :: Ptr GLUnurbs -> GLenum -> GLfloat -> m ()
gluNurbsProperty Ptr GLUnurbs
v1 GLenum
v2 GLfloat
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUnurbs -> GLenum -> GLfloat -> IO ())
-> Ptr GLUnurbs -> GLenum -> GLfloat -> IO ()
dyn_gluNurbsProperty FunPtr (Ptr GLUnurbs -> GLenum -> GLfloat -> IO ())
forall a. FunPtr a
ptr_gluNurbsProperty Ptr GLUnurbs
v1 GLenum
v2 GLfloat
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 :: FunPtr a
ptr_gluNurbsProperty = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluNurbsProperty"

-- gluNurbsSurface ----------------------------------------------------------------------

gluNurbsSurface :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> m ()
gluNurbsSurface :: Ptr GLUnurbs
-> GLint
-> Ptr GLfloat
-> GLint
-> Ptr GLfloat
-> GLint
-> GLint
-> Ptr GLfloat
-> GLint
-> GLint
-> GLenum
-> m ()
gluNurbsSurface Ptr GLUnurbs
v1 GLint
v2 Ptr GLfloat
v3 GLint
v4 Ptr GLfloat
v5 GLint
v6 GLint
v7 Ptr GLfloat
v8 GLint
v9 GLint
v10 GLenum
v11 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ 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 ()
dyn_gluNurbsSurface FunPtr
  (Ptr GLUnurbs
   -> GLint
   -> Ptr GLfloat
   -> GLint
   -> Ptr GLfloat
   -> GLint
   -> GLint
   -> Ptr GLfloat
   -> GLint
   -> GLint
   -> GLenum
   -> IO ())
forall a. FunPtr a
ptr_gluNurbsSurface Ptr GLUnurbs
v1 GLint
v2 Ptr GLfloat
v3 GLint
v4 Ptr GLfloat
v5 GLint
v6 GLint
v7 Ptr GLfloat
v8 GLint
v9 GLint
v10 GLenum
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 :: FunPtr a
ptr_gluNurbsSurface = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluNurbsSurface"

-- gluOrtho2D ----------------------------------------------------------------------

gluOrtho2D :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
gluOrtho2D :: GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
gluOrtho2D GLdouble
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
-> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()
dyn_gluOrtho2D FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
forall a. FunPtr a
ptr_gluOrtho2D GLdouble
v1 GLdouble
v2 GLdouble
v3 GLdouble
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 :: FunPtr a
ptr_gluOrtho2D = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluOrtho2D"

-- gluPartialDisk ----------------------------------------------------------------------

gluPartialDisk :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> m ()
gluPartialDisk :: Ptr GLUquadric
-> GLdouble
-> GLdouble
-> GLint
-> GLint
-> GLdouble
-> GLdouble
-> m ()
gluPartialDisk Ptr GLUquadric
v1 GLdouble
v2 GLdouble
v3 GLint
v4 GLint
v5 GLdouble
v6 GLdouble
v7 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (Ptr GLUquadric
   -> GLdouble
   -> GLdouble
   -> GLint
   -> GLint
   -> GLdouble
   -> GLdouble
   -> IO ())
-> Ptr GLUquadric
-> GLdouble
-> GLdouble
-> GLint
-> GLint
-> GLdouble
-> GLdouble
-> IO ()
dyn_gluPartialDisk FunPtr
  (Ptr GLUquadric
   -> GLdouble
   -> GLdouble
   -> GLint
   -> GLint
   -> GLdouble
   -> GLdouble
   -> IO ())
forall a. FunPtr a
ptr_gluPartialDisk Ptr GLUquadric
v1 GLdouble
v2 GLdouble
v3 GLint
v4 GLint
v5 GLdouble
v6 GLdouble
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 :: FunPtr a
ptr_gluPartialDisk = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluPartialDisk"

-- gluPerspective ----------------------------------------------------------------------

gluPerspective :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
gluPerspective :: GLdouble -> GLdouble -> GLdouble -> GLdouble -> m ()
gluPerspective GLdouble
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
-> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()
dyn_gluPerspective FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ())
forall a. FunPtr a
ptr_gluPerspective GLdouble
v1 GLdouble
v2 GLdouble
v3 GLdouble
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 :: FunPtr a
ptr_gluPerspective = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluPerspective"

-- gluPickMatrix ----------------------------------------------------------------------

gluPickMatrix :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> m ()
gluPickMatrix :: GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> m ()
gluPickMatrix GLdouble
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 Ptr GLint
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLdouble
   -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO ())
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> Ptr GLint
-> IO ()
dyn_gluPickMatrix FunPtr
  (GLdouble
   -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO ())
forall a. FunPtr a
ptr_gluPickMatrix GLdouble
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 Ptr GLint
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 :: FunPtr a
ptr_gluPickMatrix = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluPickMatrix"

-- gluProject ----------------------------------------------------------------------

gluProject :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> m GLint
gluProject :: GLdouble
-> GLdouble
-> GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> Ptr GLint
-> Ptr GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> m GLint
gluProject GLdouble
v1 GLdouble
v2 GLdouble
v3 Ptr GLdouble
v4 Ptr GLdouble
v5 Ptr GLint
v6 Ptr GLdouble
v7 Ptr GLdouble
v8 Ptr GLdouble
v9 = IO GLint -> m GLint
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
forall a b. (a -> b) -> a -> b
$ 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
dyn_gluProject FunPtr
  (GLdouble
   -> GLdouble
   -> GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> Ptr GLint
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> IO GLint)
forall a. FunPtr a
ptr_gluProject GLdouble
v1 GLdouble
v2 GLdouble
v3 Ptr GLdouble
v4 Ptr GLdouble
v5 Ptr GLint
v6 Ptr GLdouble
v7 Ptr GLdouble
v8 Ptr GLdouble
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 :: FunPtr a
ptr_gluProject = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluProject"

-- gluPwlCurve ----------------------------------------------------------------------

gluPwlCurve :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> m ()
gluPwlCurve :: Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> m ()
gluPwlCurve Ptr GLUnurbs
v1 GLint
v2 Ptr GLfloat
v3 GLint
v4 GLenum
v5 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ())
-> Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ()
dyn_gluPwlCurve FunPtr
  (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ())
forall a. FunPtr a
ptr_gluPwlCurve Ptr GLUnurbs
v1 GLint
v2 Ptr GLfloat
v3 GLint
v4 GLenum
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 :: FunPtr a
ptr_gluPwlCurve = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluPwlCurve"

-- gluQuadricCallback ----------------------------------------------------------------------

gluQuadricCallback :: MonadIO m => Ptr GLUquadric -> GLenum -> FunPtr a -> m ()
gluQuadricCallback :: Ptr GLUquadric -> GLenum -> FunPtr a -> m ()
gluQuadricCallback Ptr GLUquadric
v1 GLenum
v2 FunPtr a
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUquadric -> GLenum -> FunPtr a -> IO ())
-> Ptr GLUquadric -> GLenum -> FunPtr a -> IO ()
forall a.
FunPtr (Ptr GLUquadric -> GLenum -> FunPtr a -> IO ())
-> Ptr GLUquadric -> GLenum -> FunPtr a -> IO ()
dyn_gluQuadricCallback FunPtr (Ptr GLUquadric -> GLenum -> FunPtr a -> IO ())
forall a. FunPtr a
ptr_gluQuadricCallback Ptr GLUquadric
v1 GLenum
v2 FunPtr a
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 :: FunPtr a
ptr_gluQuadricCallback = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluQuadricCallback"

-- gluQuadricDrawStyle ----------------------------------------------------------------------

gluQuadricDrawStyle :: MonadIO m => Ptr GLUquadric -> GLenum -> m ()
gluQuadricDrawStyle :: Ptr GLUquadric -> GLenum -> m ()
gluQuadricDrawStyle Ptr GLUquadric
v1 GLenum
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUquadric -> GLenum -> IO ())
-> Ptr GLUquadric -> GLenum -> IO ()
dyn_gluQuadricDrawStyle FunPtr (Ptr GLUquadric -> GLenum -> IO ())
forall a. FunPtr a
ptr_gluQuadricDrawStyle Ptr GLUquadric
v1 GLenum
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 :: FunPtr a
ptr_gluQuadricDrawStyle = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluQuadricDrawStyle"

-- gluQuadricNormals ----------------------------------------------------------------------

gluQuadricNormals :: MonadIO m => Ptr GLUquadric -> GLenum -> m ()
gluQuadricNormals :: Ptr GLUquadric -> GLenum -> m ()
gluQuadricNormals Ptr GLUquadric
v1 GLenum
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUquadric -> GLenum -> IO ())
-> Ptr GLUquadric -> GLenum -> IO ()
dyn_gluQuadricNormals FunPtr (Ptr GLUquadric -> GLenum -> IO ())
forall a. FunPtr a
ptr_gluQuadricNormals Ptr GLUquadric
v1 GLenum
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 :: FunPtr a
ptr_gluQuadricNormals = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluQuadricNormals"

-- gluQuadricOrientation ----------------------------------------------------------------------

gluQuadricOrientation :: MonadIO m => Ptr GLUquadric -> GLenum -> m ()
gluQuadricOrientation :: Ptr GLUquadric -> GLenum -> m ()
gluQuadricOrientation Ptr GLUquadric
v1 GLenum
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUquadric -> GLenum -> IO ())
-> Ptr GLUquadric -> GLenum -> IO ()
dyn_gluQuadricOrientation FunPtr (Ptr GLUquadric -> GLenum -> IO ())
forall a. FunPtr a
ptr_gluQuadricOrientation Ptr GLUquadric
v1 GLenum
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 :: FunPtr a
ptr_gluQuadricOrientation = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluQuadricOrientation"

-- gluQuadricTexture ----------------------------------------------------------------------

gluQuadricTexture :: MonadIO m => Ptr GLUquadric -> GLboolean -> m ()
gluQuadricTexture :: Ptr GLUquadric -> GLubyte -> m ()
gluQuadricTexture Ptr GLUquadric
v1 GLubyte
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUquadric -> GLubyte -> IO ())
-> Ptr GLUquadric -> GLubyte -> IO ()
dyn_gluQuadricTexture FunPtr (Ptr GLUquadric -> GLubyte -> IO ())
forall a. FunPtr a
ptr_gluQuadricTexture Ptr GLUquadric
v1 GLubyte
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 :: FunPtr a
ptr_gluQuadricTexture = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluQuadricTexture"

-- gluScaleImage ----------------------------------------------------------------------

gluScaleImage :: MonadIO m => GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> m GLint
gluScaleImage :: GLenum
-> GLint
-> GLint
-> GLenum
-> Ptr a
-> GLint
-> GLint
-> GLenum
-> Ptr b
-> m GLint
gluScaleImage GLenum
v1 GLint
v2 GLint
v3 GLenum
v4 Ptr a
v5 GLint
v6 GLint
v7 GLenum
v8 Ptr b
v9 = IO GLint -> m GLint
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLenum
   -> Ptr a
   -> GLint
   -> GLint
   -> GLenum
   -> Ptr b
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLenum
-> Ptr a
-> GLint
-> GLint
-> GLenum
-> Ptr b
-> IO GLint
forall a b.
FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLenum
   -> Ptr a
   -> GLint
   -> GLint
   -> GLenum
   -> Ptr b
   -> IO GLint)
-> GLenum
-> GLint
-> GLint
-> GLenum
-> Ptr a
-> GLint
-> GLint
-> GLenum
-> Ptr b
-> IO GLint
dyn_gluScaleImage FunPtr
  (GLenum
   -> GLint
   -> GLint
   -> GLenum
   -> Ptr a
   -> GLint
   -> GLint
   -> GLenum
   -> Ptr b
   -> IO GLint)
forall a. FunPtr a
ptr_gluScaleImage GLenum
v1 GLint
v2 GLint
v3 GLenum
v4 Ptr a
v5 GLint
v6 GLint
v7 GLenum
v8 Ptr b
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 :: FunPtr a
ptr_gluScaleImage = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluScaleImage"

-- gluSphere ----------------------------------------------------------------------

gluSphere :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLint -> GLint -> m ()
gluSphere :: Ptr GLUquadric -> GLdouble -> GLint -> GLint -> m ()
gluSphere Ptr GLUquadric
v1 GLdouble
v2 GLint
v3 GLint
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ())
-> Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ()
dyn_gluSphere FunPtr (Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ())
forall a. FunPtr a
ptr_gluSphere Ptr GLUquadric
v1 GLdouble
v2 GLint
v3 GLint
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 :: FunPtr a
ptr_gluSphere = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluSphere"

-- gluTessBeginContour ----------------------------------------------------------------------

gluTessBeginContour :: MonadIO m => Ptr GLUtesselator -> m ()
gluTessBeginContour :: Ptr GLUtesselator -> m ()
gluTessBeginContour Ptr GLUtesselator
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
dyn_gluTessBeginContour FunPtr (Ptr GLUtesselator -> IO ())
forall a. FunPtr a
ptr_gluTessBeginContour Ptr GLUtesselator
v1

foreign import CALLCONV "dynamic" dyn_gluTessBeginContour
  :: FunPtr (Ptr GLUtesselator -> IO ())
  ->         Ptr GLUtesselator -> IO ()

{-# NOINLINE ptr_gluTessBeginContour #-}
ptr_gluTessBeginContour :: FunPtr a
ptr_gluTessBeginContour :: FunPtr a
ptr_gluTessBeginContour = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluTessBeginContour"

-- gluTessBeginPolygon ----------------------------------------------------------------------

gluTessBeginPolygon :: MonadIO m => Ptr GLUtesselator -> Ptr a -> m ()
gluTessBeginPolygon :: Ptr GLUtesselator -> Ptr a -> m ()
gluTessBeginPolygon Ptr GLUtesselator
v1 Ptr a
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> Ptr a -> IO ())
-> Ptr GLUtesselator -> Ptr a -> IO ()
forall a.
FunPtr (Ptr GLUtesselator -> Ptr a -> IO ())
-> Ptr GLUtesselator -> Ptr a -> IO ()
dyn_gluTessBeginPolygon FunPtr (Ptr GLUtesselator -> Ptr a -> IO ())
forall a. FunPtr a
ptr_gluTessBeginPolygon Ptr GLUtesselator
v1 Ptr a
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 :: FunPtr a
ptr_gluTessBeginPolygon = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluTessBeginPolygon"

-- gluTessCallback ----------------------------------------------------------------------

gluTessCallback :: MonadIO m => Ptr GLUtesselator -> GLenum -> FunPtr a -> m ()
gluTessCallback :: Ptr GLUtesselator -> GLenum -> FunPtr a -> m ()
gluTessCallback Ptr GLUtesselator
v1 GLenum
v2 FunPtr a
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ())
-> Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ()
forall a.
FunPtr (Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ())
-> Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ()
dyn_gluTessCallback FunPtr (Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ())
forall a. FunPtr a
ptr_gluTessCallback Ptr GLUtesselator
v1 GLenum
v2 FunPtr a
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 :: FunPtr a
ptr_gluTessCallback = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluTessCallback"

-- gluTessEndContour ----------------------------------------------------------------------

gluTessEndContour :: MonadIO m => Ptr GLUtesselator -> m ()
gluTessEndContour :: Ptr GLUtesselator -> m ()
gluTessEndContour Ptr GLUtesselator
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
dyn_gluTessEndContour FunPtr (Ptr GLUtesselator -> IO ())
forall a. FunPtr a
ptr_gluTessEndContour Ptr GLUtesselator
v1

foreign import CALLCONV "dynamic" dyn_gluTessEndContour
  :: FunPtr (Ptr GLUtesselator -> IO ())
  ->         Ptr GLUtesselator -> IO ()

{-# NOINLINE ptr_gluTessEndContour #-}
ptr_gluTessEndContour :: FunPtr a
ptr_gluTessEndContour :: FunPtr a
ptr_gluTessEndContour = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluTessEndContour"

-- gluTessEndPolygon ----------------------------------------------------------------------

gluTessEndPolygon :: MonadIO m => Ptr GLUtesselator -> m ()
gluTessEndPolygon :: Ptr GLUtesselator -> m ()
gluTessEndPolygon Ptr GLUtesselator
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> IO ()) -> Ptr GLUtesselator -> IO ()
dyn_gluTessEndPolygon FunPtr (Ptr GLUtesselator -> IO ())
forall a. FunPtr a
ptr_gluTessEndPolygon Ptr GLUtesselator
v1

foreign import CALLCONV "dynamic" dyn_gluTessEndPolygon
  :: FunPtr (Ptr GLUtesselator -> IO ())
  ->         Ptr GLUtesselator -> IO ()

{-# NOINLINE ptr_gluTessEndPolygon #-}
ptr_gluTessEndPolygon :: FunPtr a
ptr_gluTessEndPolygon :: FunPtr a
ptr_gluTessEndPolygon = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluTessEndPolygon"

-- gluTessNormal ----------------------------------------------------------------------

gluTessNormal :: MonadIO m => Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> m ()
gluTessNormal :: Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> m ()
gluTessNormal Ptr GLUtesselator
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr
  (Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ())
-> Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ()
dyn_gluTessNormal FunPtr
  (Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ())
forall a. FunPtr a
ptr_gluTessNormal Ptr GLUtesselator
v1 GLdouble
v2 GLdouble
v3 GLdouble
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 :: FunPtr a
ptr_gluTessNormal = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluTessNormal"

-- gluTessProperty ----------------------------------------------------------------------

gluTessProperty :: MonadIO m => Ptr GLUtesselator -> GLenum -> GLdouble -> m ()
gluTessProperty :: Ptr GLUtesselator -> GLenum -> GLdouble -> m ()
gluTessProperty Ptr GLUtesselator
v1 GLenum
v2 GLdouble
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> GLenum -> GLdouble -> IO ())
-> Ptr GLUtesselator -> GLenum -> GLdouble -> IO ()
dyn_gluTessProperty FunPtr (Ptr GLUtesselator -> GLenum -> GLdouble -> IO ())
forall a. FunPtr a
ptr_gluTessProperty Ptr GLUtesselator
v1 GLenum
v2 GLdouble
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 :: FunPtr a
ptr_gluTessProperty = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluTessProperty"

-- gluTessVertex ----------------------------------------------------------------------

gluTessVertex :: MonadIO m => Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> m ()
gluTessVertex :: Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> m ()
gluTessVertex Ptr GLUtesselator
v1 Ptr GLdouble
v2 Ptr a
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ())
-> Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ()
forall a.
FunPtr (Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ())
-> Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ()
dyn_gluTessVertex FunPtr (Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ())
forall a. FunPtr a
ptr_gluTessVertex Ptr GLUtesselator
v1 Ptr GLdouble
v2 Ptr a
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 :: FunPtr a
ptr_gluTessVertex = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluTessVertex"

-- gluUnProject ----------------------------------------------------------------------

gluUnProject :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> m GLint
gluUnProject :: GLdouble
-> GLdouble
-> GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> Ptr GLint
-> Ptr GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> m GLint
gluUnProject GLdouble
v1 GLdouble
v2 GLdouble
v3 Ptr GLdouble
v4 Ptr GLdouble
v5 Ptr GLint
v6 Ptr GLdouble
v7 Ptr GLdouble
v8 Ptr GLdouble
v9 = IO GLint -> m GLint
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
forall a b. (a -> b) -> a -> b
$ 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
dyn_gluUnProject FunPtr
  (GLdouble
   -> GLdouble
   -> GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> Ptr GLint
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> IO GLint)
forall a. FunPtr a
ptr_gluUnProject GLdouble
v1 GLdouble
v2 GLdouble
v3 Ptr GLdouble
v4 Ptr GLdouble
v5 Ptr GLint
v6 Ptr GLdouble
v7 Ptr GLdouble
v8 Ptr GLdouble
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 :: FunPtr a
ptr_gluUnProject = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"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 :: GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> Ptr GLint
-> GLdouble
-> GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> m GLint
gluUnProject4 GLdouble
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 Ptr GLdouble
v5 Ptr GLdouble
v6 Ptr GLint
v7 GLdouble
v8 GLdouble
v9 Ptr GLdouble
v10 Ptr GLdouble
v11 Ptr GLdouble
v12 Ptr GLdouble
v13 = IO GLint -> m GLint
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLint -> m GLint) -> IO GLint -> m GLint
forall a b. (a -> b) -> a -> b
$ FunPtr
  (GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> Ptr GLint
   -> GLdouble
   -> GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> IO GLint)
-> GLdouble
-> GLdouble
-> GLdouble
-> GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> Ptr GLint
-> GLdouble
-> GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> Ptr GLdouble
-> IO GLint
dyn_gluUnProject4 FunPtr
  (GLdouble
   -> GLdouble
   -> GLdouble
   -> GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> Ptr GLint
   -> GLdouble
   -> GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> Ptr GLdouble
   -> IO GLint)
forall a. FunPtr a
ptr_gluUnProject4 GLdouble
v1 GLdouble
v2 GLdouble
v3 GLdouble
v4 Ptr GLdouble
v5 Ptr GLdouble
v6 Ptr GLint
v7 GLdouble
v8 GLdouble
v9 Ptr GLdouble
v10 Ptr GLdouble
v11 Ptr GLdouble
v12 Ptr GLdouble
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 :: FunPtr a
ptr_gluUnProject4 = IO (FunPtr a) -> FunPtr a
forall a. IO a -> a
unsafePerformIO (IO (FunPtr a) -> FunPtr a) -> IO (FunPtr a) -> FunPtr a
forall a b. (a -> b) -> a -> b
$ String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntry String
"gluUnProject4"