GLURaw-2.0.0.2/cbits/0000755000000000000000000000000012642417606012254 5ustar0000000000000000GLURaw-2.0.0.2/src/0000755000000000000000000000000012642417606011737 5ustar0000000000000000GLURaw-2.0.0.2/src/Graphics/0000755000000000000000000000000012642417606013477 5ustar0000000000000000GLURaw-2.0.0.2/src/Graphics/GLU/0000755000000000000000000000000012664003355014122 5ustar0000000000000000GLURaw-2.0.0.2/src/Graphics/GLU.hs0000644000000000000000000000126512642417606014466 0ustar0000000000000000-------------------------------------------------------------------------------- -- | -- Module : Graphics.GLU -- Copyright : (c) Sven Panne 2016 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- A 1:1 binding for the OpenGL utility library. -- -------------------------------------------------------------------------------- module Graphics.GLU ( module Graphics.GLU.Functions, module Graphics.GLU.Tokens, module Graphics.GLU.Types, module Graphics.GLU.Callbacks ) where import Graphics.GLU.Functions import Graphics.GLU.Tokens import Graphics.GLU.Types import Graphics.GLU.Callbacks GLURaw-2.0.0.2/src/Graphics/GLU/Callbacks.hs0000644000000000000000000001562012642417606016345 0ustar0000000000000000{-# LANGUAGE CPP #-} -------------------------------------------------------------------------------- -- | -- Module : Graphics.GLU.Callbacks -- Copyright : (c) Sven Panne 2016 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- All callbacks from GLU 1.3, see . -- -------------------------------------------------------------------------------- module Graphics.GLU.Callbacks ( -- * Tessellator Callbacks -- ** Tessellator Callbacks without Polygon Data TessBeginCallback, makeTessBeginCallback, TessEdgeFlagCallback, makeTessEdgeFlagCallback, TessVertexCallback, makeTessVertexCallback, TessEndCallback, makeTessEndCallback, TessErrorCallback, makeTessErrorCallback, TessCombineCallback, makeTessCombineCallback, -- ** Tessellator Callbacks with Polygon Data TessBeginDataCallback, makeTessBeginDataCallback, TessEdgeFlagDataCallback, makeTessEdgeFlagDataCallback, TessVertexDataCallback, makeTessVertexDataCallback, TessEndDataCallback, makeTessEndDataCallback, TessErrorDataCallback, makeTessErrorDataCallback, TessCombineDataCallback, makeTessCombineDataCallback, -- * Quadrics Callbacks QuadricCallback, makeQuadricCallback, -- * NURBS Callbacks -- ** NURBS Callbacks without User Data NURBSBeginCallback, makeNURBSBeginCallback, NURBSVertexCallback, makeNURBSVertexCallback, NURBSNormalCallback, makeNURBSNormalCallback, NURBSColorCallback, makeNURBSColorCallback, NURBSTexCoordCallback, makeNURBSTexCoordCallback, NURBSEndCallback, makeNURBSEndCallback, NURBSErrorCallback, makeNURBSErrorCallback, -- ** NURBS Callbacks with User Data NURBSBeginDataCallback, makeNURBSBeginDataCallback, NURBSVertexDataCallback, makeNURBSVertexDataCallback, NURBSNormalDataCallback, makeNURBSNormalDataCallback, NURBSColorDataCallback, makeNURBSColorDataCallback, NURBSTexCoordDataCallback, makeNURBSTexCoordDataCallback, NURBSEndDataCallback, makeNURBSEndDataCallback ) where import Foreign.Ptr import Graphics.GL -------------------------------------------------------------------------------- type TessBeginCallback = GLenum -> IO () foreign import CALLCONV "wrapper" makeTessBeginCallback :: TessBeginCallback -> IO (FunPtr TessBeginCallback) type TessEdgeFlagCallback = GLboolean -> IO () foreign import CALLCONV "wrapper" makeTessEdgeFlagCallback :: TessEdgeFlagCallback -> IO (FunPtr TessEdgeFlagCallback) type TessVertexCallback v = Ptr v -> IO () foreign import CALLCONV "wrapper" makeTessVertexCallback :: TessVertexCallback v -> IO (FunPtr (TessVertexCallback v)) type TessEndCallback = IO () foreign import CALLCONV "wrapper" makeTessEndCallback :: TessEndCallback -> IO (FunPtr TessEndCallback) type TessErrorCallback = GLenum -> IO () foreign import CALLCONV "wrapper" makeTessErrorCallback :: TessErrorCallback -> IO (FunPtr TessErrorCallback) type TessCombineCallback v = Ptr GLdouble -> Ptr (Ptr v) -> Ptr GLfloat -> Ptr (Ptr v) -> IO () foreign import CALLCONV "wrapper" makeTessCombineCallback :: TessCombineCallback v -> IO (FunPtr (TessCombineCallback v)) type TessBeginDataCallback p = GLenum -> Ptr p -> IO () foreign import CALLCONV "wrapper" makeTessBeginDataCallback :: TessBeginDataCallback p -> IO (FunPtr (TessBeginDataCallback p)) type TessEdgeFlagDataCallback p = GLboolean -> Ptr p -> IO () foreign import CALLCONV "wrapper" makeTessEdgeFlagDataCallback :: TessEdgeFlagDataCallback p -> IO (FunPtr (TessEdgeFlagDataCallback p)) type TessVertexDataCallback v p = Ptr v -> Ptr p -> IO () foreign import CALLCONV "wrapper" makeTessVertexDataCallback :: TessVertexDataCallback v p -> IO (FunPtr (TessVertexDataCallback v p)) type TessEndDataCallback p = Ptr p -> IO () foreign import CALLCONV "wrapper" makeTessEndDataCallback :: TessEndDataCallback p -> IO (FunPtr (TessEndDataCallback p)) type TessErrorDataCallback p = GLenum -> Ptr p -> IO () foreign import CALLCONV "wrapper" makeTessErrorDataCallback :: TessErrorDataCallback p -> IO (FunPtr (TessErrorDataCallback p)) type TessCombineDataCallback v p = Ptr GLdouble -> Ptr (Ptr v) -> Ptr GLfloat -> Ptr (Ptr v) -> Ptr p -> IO () foreign import CALLCONV "wrapper" makeTessCombineDataCallback :: TessCombineDataCallback v p -> IO (FunPtr (TessCombineDataCallback v p)) -------------------------------------------------------------------------------- type QuadricCallback = GLenum -> IO () foreign import CALLCONV "wrapper" makeQuadricCallback :: QuadricCallback -> IO (FunPtr QuadricCallback) -------------------------------------------------------------------------------- type NURBSBeginCallback = GLenum -> IO () foreign import CALLCONV "wrapper" makeNURBSBeginCallback :: NURBSBeginCallback -> IO (FunPtr NURBSBeginCallback) type NURBSVertexCallback = Ptr GLfloat -> IO () foreign import CALLCONV "wrapper" makeNURBSVertexCallback :: NURBSVertexCallback -> IO (FunPtr NURBSVertexCallback) type NURBSNormalCallback = Ptr GLfloat -> IO () foreign import CALLCONV "wrapper" makeNURBSNormalCallback :: NURBSNormalCallback -> IO (FunPtr NURBSNormalCallback) type NURBSColorCallback = Ptr GLfloat -> IO () foreign import CALLCONV "wrapper" makeNURBSColorCallback :: NURBSColorCallback -> IO (FunPtr NURBSColorCallback) type NURBSTexCoordCallback = Ptr GLfloat -> IO () foreign import CALLCONV "wrapper" makeNURBSTexCoordCallback :: NURBSTexCoordCallback -> IO (FunPtr NURBSTexCoordCallback) type NURBSEndCallback = IO () foreign import CALLCONV "wrapper" makeNURBSEndCallback :: NURBSEndCallback -> IO (FunPtr NURBSEndCallback) type NURBSErrorCallback = GLenum -> IO () foreign import CALLCONV "wrapper" makeNURBSErrorCallback :: NURBSErrorCallback -> IO (FunPtr NURBSErrorCallback) type NURBSBeginDataCallback u = GLenum -> Ptr u -> IO () foreign import CALLCONV "wrapper" makeNURBSBeginDataCallback :: NURBSBeginDataCallback u -> IO (FunPtr (NURBSBeginDataCallback u)) type NURBSVertexDataCallback u = Ptr GLfloat -> Ptr u -> IO () foreign import CALLCONV "wrapper" makeNURBSVertexDataCallback :: NURBSVertexDataCallback u -> IO (FunPtr (NURBSVertexDataCallback u)) type NURBSNormalDataCallback u = Ptr GLfloat -> Ptr u -> IO () foreign import CALLCONV "wrapper" makeNURBSNormalDataCallback :: NURBSNormalDataCallback u -> IO (FunPtr (NURBSNormalDataCallback u)) type NURBSColorDataCallback u = Ptr GLfloat -> Ptr u -> IO () foreign import CALLCONV "wrapper" makeNURBSColorDataCallback :: NURBSColorDataCallback u -> IO (FunPtr (NURBSColorDataCallback u)) type NURBSTexCoordDataCallback u = Ptr GLfloat -> Ptr u -> IO () foreign import CALLCONV "wrapper" makeNURBSTexCoordDataCallback :: NURBSTexCoordDataCallback u -> IO (FunPtr (NURBSTexCoordDataCallback u)) type NURBSEndDataCallback u = Ptr u -> IO () foreign import CALLCONV "wrapper" makeNURBSEndDataCallback :: NURBSEndDataCallback u -> IO (FunPtr (NURBSEndDataCallback u)) GLURaw-2.0.0.2/src/Graphics/GLU/Functions.hs0000644000000000000000000011243612642417606016441 0ustar0000000000000000{-# LANGUAGE CPP #-} -------------------------------------------------------------------------------- -- | -- Module : Graphics.GLU.Functions -- Copyright : (c) Sven Panne 2016 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- All functions from GLU 1.3, see . -- -------------------------------------------------------------------------------- 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 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" GLURaw-2.0.0.2/src/Graphics/GLU/Tokens.hs0000644000000000000000000001724212664003355015727 0ustar0000000000000000{-# LANGUAGE CPP, PatternSynonyms, ScopedTypeVariables #-} #if __GLASGOW_HASKELL__ >= 800 {-# OPTIONS_GHC -Wno-missing-pattern-synonym-signatures #-} #endif -------------------------------------------------------------------------------- -- | -- Module : Graphics.GLU.Tokens -- Copyright : (c) Sven Panne 2016 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- All tokens from GLU 1.3, see . -- -------------------------------------------------------------------------------- module Graphics.GLU.Tokens where import Graphics.GL.Core31 -------------------------------------------------------------------------------- -- Boolean pattern GLU_FALSE = 0 :: GLenum pattern GLU_TRUE = 1 :: GLenum -- StringName pattern GLU_VERSION = 100800 :: GLenum pattern GLU_EXTENSIONS = 100801 :: GLenum -- ErrorCode pattern GLU_INVALID_ENUM = 100900 :: GLenum pattern GLU_INVALID_VALUE = 100901 :: GLenum pattern GLU_OUT_OF_MEMORY = 100902 :: GLenum pattern GLU_INCOMPATIBLE_GL_VERSION = 100903 :: GLenum pattern GLU_INVALID_OPERATION = 100904 :: GLenum -- NurbsDisplay -- GLU_FILL pattern GLU_OUTLINE_POLYGON = 100240 :: GLenum pattern GLU_OUTLINE_PATCH = 100241 :: GLenum -- NurbsCallback pattern GLU_NURBS_ERROR = 100103 :: GLenum pattern GLU_ERROR = 100103 :: GLenum pattern GLU_NURBS_BEGIN = 100164 :: GLenum pattern GLU_NURBS_BEGIN_EXT = 100164 :: GLenum pattern GLU_NURBS_VERTEX = 100165 :: GLenum pattern GLU_NURBS_VERTEX_EXT = 100165 :: GLenum pattern GLU_NURBS_NORMAL = 100166 :: GLenum pattern GLU_NURBS_NORMAL_EXT = 100166 :: GLenum pattern GLU_NURBS_COLOR = 100167 :: GLenum pattern GLU_NURBS_COLOR_EXT = 100167 :: GLenum pattern GLU_NURBS_TEXTURE_COORD = 100168 :: GLenum pattern GLU_NURBS_TEX_COORD_EXT = 100168 :: GLenum pattern GLU_NURBS_END = 100169 :: GLenum pattern GLU_NURBS_END_EXT = 100169 :: GLenum pattern GLU_NURBS_BEGIN_DATA = 100170 :: GLenum pattern GLU_NURBS_BEGIN_DATA_EXT = 100170 :: GLenum pattern GLU_NURBS_VERTEX_DATA = 100171 :: GLenum pattern GLU_NURBS_VERTEX_DATA_EXT = 100171 :: GLenum pattern GLU_NURBS_NORMAL_DATA = 100172 :: GLenum pattern GLU_NURBS_NORMAL_DATA_EXT = 100172 :: GLenum pattern GLU_NURBS_COLOR_DATA = 100173 :: GLenum pattern GLU_NURBS_COLOR_DATA_EXT = 100173 :: GLenum pattern GLU_NURBS_TEXTURE_COORD_DATA = 100174 :: GLenum pattern GLU_NURBS_TEX_COORD_DATA_EXT = 100174 :: GLenum pattern GLU_NURBS_END_DATA = 100175 :: GLenum pattern GLU_NURBS_END_DATA_EXT = 100175 :: GLenum -- NurbsError pattern GLU_NURBS_ERROR1 = 100251 :: GLenum pattern GLU_NURBS_ERROR2 = 100252 :: GLenum pattern GLU_NURBS_ERROR3 = 100253 :: GLenum pattern GLU_NURBS_ERROR4 = 100254 :: GLenum pattern GLU_NURBS_ERROR5 = 100255 :: GLenum pattern GLU_NURBS_ERROR6 = 100256 :: GLenum pattern GLU_NURBS_ERROR7 = 100257 :: GLenum pattern GLU_NURBS_ERROR8 = 100258 :: GLenum pattern GLU_NURBS_ERROR9 = 100259 :: GLenum pattern GLU_NURBS_ERROR10 = 100260 :: GLenum pattern GLU_NURBS_ERROR11 = 100261 :: GLenum pattern GLU_NURBS_ERROR12 = 100262 :: GLenum pattern GLU_NURBS_ERROR13 = 100263 :: GLenum pattern GLU_NURBS_ERROR14 = 100264 :: GLenum pattern GLU_NURBS_ERROR15 = 100265 :: GLenum pattern GLU_NURBS_ERROR16 = 100266 :: GLenum pattern GLU_NURBS_ERROR17 = 100267 :: GLenum pattern GLU_NURBS_ERROR18 = 100268 :: GLenum pattern GLU_NURBS_ERROR19 = 100269 :: GLenum pattern GLU_NURBS_ERROR20 = 100270 :: GLenum pattern GLU_NURBS_ERROR21 = 100271 :: GLenum pattern GLU_NURBS_ERROR22 = 100272 :: GLenum pattern GLU_NURBS_ERROR23 = 100273 :: GLenum pattern GLU_NURBS_ERROR24 = 100274 :: GLenum pattern GLU_NURBS_ERROR25 = 100275 :: GLenum pattern GLU_NURBS_ERROR26 = 100276 :: GLenum pattern GLU_NURBS_ERROR27 = 100277 :: GLenum pattern GLU_NURBS_ERROR28 = 100278 :: GLenum pattern GLU_NURBS_ERROR29 = 100279 :: GLenum pattern GLU_NURBS_ERROR30 = 100280 :: GLenum pattern GLU_NURBS_ERROR31 = 100281 :: GLenum pattern GLU_NURBS_ERROR32 = 100282 :: GLenum pattern GLU_NURBS_ERROR33 = 100283 :: GLenum pattern GLU_NURBS_ERROR34 = 100284 :: GLenum pattern GLU_NURBS_ERROR35 = 100285 :: GLenum pattern GLU_NURBS_ERROR36 = 100286 :: GLenum pattern GLU_NURBS_ERROR37 = 100287 :: GLenum -- NurbsProperty pattern GLU_AUTO_LOAD_MATRIX = 100200 :: GLenum pattern GLU_CULLING = 100201 :: GLenum pattern GLU_SAMPLING_TOLERANCE = 100203 :: GLenum pattern GLU_DISPLAY_MODE = 100204 :: GLenum pattern GLU_PARAMETRIC_TOLERANCE = 100202 :: GLenum pattern GLU_SAMPLING_METHOD = 100205 :: GLenum pattern GLU_U_STEP = 100206 :: GLenum pattern GLU_V_STEP = 100207 :: GLenum pattern GLU_NURBS_MODE = 100160 :: GLenum pattern GLU_NURBS_MODE_EXT = 100160 :: GLenum pattern GLU_NURBS_TESSELLATOR = 100161 :: GLenum pattern GLU_NURBS_TESSELLATOR_EXT = 100161 :: GLenum pattern GLU_NURBS_RENDERER = 100162 :: GLenum pattern GLU_NURBS_RENDERER_EXT = 100162 :: GLenum -- NurbsSampling pattern GLU_OBJECT_PARAMETRIC_ERROR = 100208 :: GLenum pattern GLU_OBJECT_PARAMETRIC_ERROR_EXT = 100208 :: GLenum pattern GLU_OBJECT_PATH_LENGTH = 100209 :: GLenum pattern GLU_OBJECT_PATH_LENGTH_EXT = 100209 :: GLenum pattern GLU_PATH_LENGTH = 100215 :: GLenum pattern GLU_PARAMETRIC_ERROR = 100216 :: GLenum pattern GLU_DOMAIN_DISTANCE = 100217 :: GLenum -- NurbsTrim pattern GLU_MAP1_TRIM_2 = 100210 :: GLenum pattern GLU_MAP1_TRIM_3 = 100211 :: GLenum -- QuadricDrawStyle pattern GLU_POINT = 100010 :: GLenum pattern GLU_LINE = 100011 :: GLenum pattern GLU_FILL = 100012 :: GLenum pattern GLU_SILHOUETTE = 100013 :: GLenum -- QuadricCallback -- GLU_ERROR -- QuadricNormal pattern GLU_SMOOTH = 100000 :: GLenum pattern GLU_FLAT = 100001 :: GLenum pattern GLU_NONE = 100002 :: GLenum -- QuadricOrientation pattern GLU_OUTSIDE = 100020 :: GLenum pattern GLU_INSIDE = 100021 :: GLenum -- TessCallback pattern GLU_TESS_BEGIN = 100100 :: GLenum pattern GLU_BEGIN = 100100 :: GLenum pattern GLU_TESS_VERTEX = 100101 :: GLenum pattern GLU_VERTEX = 100101 :: GLenum pattern GLU_TESS_END = 100102 :: GLenum pattern GLU_END = 100102 :: GLenum pattern GLU_TESS_ERROR = 100103 :: GLenum pattern GLU_TESS_EDGE_FLAG = 100104 :: GLenum pattern GLU_EDGE_FLAG = 100104 :: GLenum pattern GLU_TESS_COMBINE = 100105 :: GLenum pattern GLU_TESS_BEGIN_DATA = 100106 :: GLenum pattern GLU_TESS_VERTEX_DATA = 100107 :: GLenum pattern GLU_TESS_END_DATA = 100108 :: GLenum pattern GLU_TESS_ERROR_DATA = 100109 :: GLenum pattern GLU_TESS_EDGE_FLAG_DATA = 100110 :: GLenum pattern GLU_TESS_COMBINE_DATA = 100111 :: GLenum -- TessContour pattern GLU_CW = 100120 :: GLenum pattern GLU_CCW = 100121 :: GLenum pattern GLU_INTERIOR = 100122 :: GLenum pattern GLU_EXTERIOR = 100123 :: GLenum pattern GLU_UNKNOWN = 100124 :: GLenum -- TessProperty pattern GLU_TESS_WINDING_RULE = 100140 :: GLenum pattern GLU_TESS_BOUNDARY_ONLY = 100141 :: GLenum pattern GLU_TESS_TOLERANCE = 100142 :: GLenum -- TessError pattern GLU_TESS_ERROR1 = 100151 :: GLenum pattern GLU_TESS_ERROR2 = 100152 :: GLenum pattern GLU_TESS_ERROR3 = 100153 :: GLenum pattern GLU_TESS_ERROR4 = 100154 :: GLenum pattern GLU_TESS_ERROR5 = 100155 :: GLenum pattern GLU_TESS_ERROR6 = 100156 :: GLenum pattern GLU_TESS_ERROR7 = 100157 :: GLenum pattern GLU_TESS_ERROR8 = 100158 :: GLenum pattern GLU_TESS_MISSING_BEGIN_POLYGON = 100151 :: GLenum pattern GLU_TESS_MISSING_BEGIN_CONTOUR = 100152 :: GLenum pattern GLU_TESS_MISSING_END_POLYGON = 100153 :: GLenum pattern GLU_TESS_MISSING_END_CONTOUR = 100154 :: GLenum pattern GLU_TESS_COORD_TOO_LARGE = 100155 :: GLenum pattern GLU_TESS_NEED_COMBINE_CALLBACK = 100156 :: GLenum -- TessWinding pattern GLU_TESS_WINDING_ODD = 100130 :: GLenum pattern GLU_TESS_WINDING_NONZERO = 100131 :: GLenum pattern GLU_TESS_WINDING_POSITIVE = 100132 :: GLenum pattern GLU_TESS_WINDING_NEGATIVE = 100133 :: GLenum pattern GLU_TESS_WINDING_ABS_GEQ_TWO = 100134 :: GLenum GLURaw-2.0.0.2/src/Graphics/GLU/Types.hs0000644000000000000000000000106212642417606015565 0ustar0000000000000000-------------------------------------------------------------------------------- -- | -- Module : Graphics.GLU.Types -- Copyright : (c) Sven Panne 2016 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- All (abstract) types from GLU 1.3, see . -- -------------------------------------------------------------------------------- module Graphics.GLU.Types ( GLUnurbs, GLUquadric, GLUtesselator ) where import Graphics.GLU.TypesInternal GLURaw-2.0.0.2/src/Graphics/GLU/TypesInternal.hs0000644000000000000000000000113412642417606017262 0ustar0000000000000000{-# OPTIONS_HADDOCK hide #-} -------------------------------------------------------------------------------- -- | -- Module : Graphics.GLU.TypesInternal -- Copyright : (c) Sven Panne 2016 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- All types from GLU 1.3, see . -- -------------------------------------------------------------------------------- module Graphics.GLU.TypesInternal where data GLUnurbs = GLUnurbs data GLUquadric = GLUquadric data GLUtesselator = GLUtesselator GLURaw-2.0.0.2/cbits/HsGLURaw.c0000644000000000000000000000432512642417606014020 0ustar0000000000000000/* ----------------------------------------------------------------------------- * * Module : C support for Graphics.Rendering.GLU.Raw.Extensions * Copyright : (c) Sven Panne 2016 * License : BSD3 * * Maintainer : Sven Panne * Stability : stable * Portability : portable * * -------------------------------------------------------------------------- */ #if defined(USE_GETPROCADDRESS) #define WIN32_LEAN_AND_MEAN #include void* hs_GLU_getProcAddress(const char *name) { static int firstTime = 1; static HMODULE handle = NULL; if (firstTime) { firstTime = 0; handle = LoadLibrary(TEXT("glu32")); } return handle ? GetProcAddress(handle, name) : NULL; } /* -------------------------------------------------------------------------- */ #elif defined(USE_NSADDRESSOFSYMBOL) #include #include #include void* hs_GLU_getProcAddress(const char *name) { NSSymbol symbol; /* Prepend a '_' for the Unix C symbol mangling convention */ char* symbolName = (char*)malloc(strlen(name) + 2); if (!symbolName) { return NULL; } symbolName[0] = '_'; strcpy(symbolName + 1, name); if (!NSIsSymbolNameDefined(symbolName)) { free(symbolName); return NULL; } symbol = NSLookupAndBindSymbol(symbolName); free(symbolName); if (!symbol) { return NULL; } return NSAddressOfSymbol(symbol); } /* -------------------------------------------------------------------------- */ #elif defined(USE_DLSYM) #include #include #ifndef __APPLE__ #include #include #endif void* hs_GLU_getProcAddress(const char *name) { static int firstTime = 1; static void *handle = NULL; if (firstTime) { firstTime = 0; /* Get a handle for our executable. */ handle = dlopen(NULL, RTLD_LAZY); } #ifndef __APPLE__ /* Hack to force linking of GLU on Linux */ FILE *bitbucket = fopen("/dev/null", "w"); fprintf(bitbucket, "%p\n", gluBeginCurve); fclose(bitbucket); #endif return handle ? dlsym(handle, name) : NULL; } /* -------------------------------------------------------------------------- */ #else #error "Don't know how to retrieve GLU entries" #endif GLURaw-2.0.0.2/LICENSE0000644000000000000000000000271512604702075012155 0ustar0000000000000000Copyright (c) 2009, Sven Panne All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. GLURaw-2.0.0.2/Setup.hs0000644000000000000000000000005612604702075012600 0ustar0000000000000000import Distribution.Simple main = defaultMain GLURaw-2.0.0.2/GLURaw.cabal0000644000000000000000000000445212714621770013241 0ustar0000000000000000name: GLURaw version: 2.0.0.2 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 basically a 1:1 mapping of GLU's C API, intended as a basis for a nicer interface. . OpenGL is the industry's most widely used and supported 2D and 3D graphics application programming interface (API), incorporating a broad set of rendering, texture mapping, special effects, and other powerful visualization functions. For more information about OpenGL and its various extensions, please see and . homepage: http://www.haskell.org/haskellwiki/Opengl bug-reports: https://github.com/haskell-opengl/GLURaw/issues copyright: Copyright (C) 2009-2016 Sven Panne license: BSD3 license-file: LICENSE author: Sven Panne maintainer: Sven Panne , Jason Dagit category: Graphics build-type: Simple tested-with: GHC == 7.8.4 GHC == 7.10.3 GHC == 8.0.1 GHC == 8.1 cabal-version: >= 1.10 extra-source-files: CHANGELOG.md README.md flag UseNativeWindowsLibraries description: When compiling under Windows, use the native libraries instead of e.g. the ones coming with Cygwin. library exposed-modules: Graphics.GLU Graphics.GLU.Callbacks Graphics.GLU.Functions Graphics.GLU.Tokens Graphics.GLU.Types other-modules: Graphics.GLU.TypesInternal c-sources: cbits/HsGLURaw.c hs-source-dirs: src build-depends: base >= 4 && < 5, transformers >= 0.2 && < 0.6, OpenGLRaw >= 3.0 && < 3.3 default-language: Haskell2010 ghc-options: -Wall if impl(ghc > 8) ghc-options: -Wcompat other-extensions: CPP PatternSynonyms ScopedTypeVariables if os(windows) && flag(UseNativeWindowsLibraries) if arch(i386) cpp-options: "-DCALLCONV=stdcall" else cpp-options: "-DCALLCONV=ccall" cc-options: "-DUSE_GETPROCADDRESS" extra-libraries: glu32 else cpp-options: "-DCALLCONV=ccall" cc-options: "-DUSE_DLSYM" if os(darwin) frameworks: OpenGL else if os(ios) frameworks: OpenGLES else extra-libraries: GLU source-repository head type: git location: https://github.com/haskell-opengl/GLURaw.git GLURaw-2.0.0.2/CHANGELOG.md0000644000000000000000000000100212714623634012752 0ustar00000000000000002.0.0.2 ------- * Relaxed upper version bound for `OpenGLRaw`. * Silence warnings about pattern synonyms with no type signatures. 2.0.0.1 ------- * Relaxed upper version bound for `OpenGLRaw`. 2.0.0.0 ------- * Use pattern synonyms. * Changed module name prefix from `Graphics.Rendering.GLU.Raw` to `Graphics.GLU`. 1.5.0.3 ------- * Relaxed upper version bound for `transformers`. 1.5.0.2 ------- * Relaxed upper version bound for OpenGLRaw. * Added CHANGELOG.md to distribution. * Minor build/testing tweaks. GLURaw-2.0.0.2/README.md0000644000000000000000000000034412642417606012430 0ustar0000000000000000[![Hackage](https://img.shields.io/hackage/v/GLURaw.svg)](https://hackage.haskell.org/package/GLURaw) [![Build Status](https://travis-ci.org/haskell-opengl/GLURaw.png?branch=master)](https://travis-ci.org/haskell-opengl/GLURaw)