GLURaw-1.5.0.1/0000755000000000000000000000000012521420140011132 5ustar0000000000000000GLURaw-1.5.0.1/README.md0000644000000000000000000000032612521420140012412 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)](https://travis-ci.org/haskell-opengl/GLURaw) GLURaw-1.5.0.1/LICENSE0000644000000000000000000000271512521420140012144 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-1.5.0.1/GLURaw.cabal0000644000000000000000000000431212521420140013217 0ustar0000000000000000name: GLURaw version: 1.5.0.1 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-2015 Sven Panne license: BSD3 license-file: LICENSE author: Sven Panne maintainer: Sven Panne , Jason Dagit category: Graphics build-type: Simple cabal-version: >= 1.10 extra-source-files: 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.Rendering.GLU.Raw Graphics.Rendering.GLU.Raw.Callbacks Graphics.Rendering.GLU.Raw.Functions Graphics.Rendering.GLU.Raw.Tokens Graphics.Rendering.GLU.Raw.Types other-modules: Graphics.Rendering.GLU.Raw.TypesInternal c-sources: cbits/HsGLURaw.c hs-source-dirs: src build-depends: base >= 4 && < 5, transformers >= 0.2 && < 0.5, OpenGLRaw >= 2.4 && < 2.6 default-language: Haskell2010 ghc-options: -Wall other-extensions: CPP 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-1.5.0.1/Setup.hs0000644000000000000000000000005612521420140012567 0ustar0000000000000000import Distribution.Simple main = defaultMain GLURaw-1.5.0.1/cbits/0000755000000000000000000000000012521420140012236 5ustar0000000000000000GLURaw-1.5.0.1/cbits/HsGLURaw.c0000644000000000000000000000432512521420140014002 0ustar0000000000000000/* ----------------------------------------------------------------------------- * * Module : C support for Graphics.Rendering.GLU.Raw.Extensions * Copyright : (c) Sven Panne 2013 * 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-1.5.0.1/src/0000755000000000000000000000000012521420140011721 5ustar0000000000000000GLURaw-1.5.0.1/src/Graphics/0000755000000000000000000000000012521420140013461 5ustar0000000000000000GLURaw-1.5.0.1/src/Graphics/Rendering/0000755000000000000000000000000012521420140015376 5ustar0000000000000000GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/0000755000000000000000000000000012521420140016025 5ustar0000000000000000GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw.hs0000644000000000000000000000150112521420140017107 0ustar0000000000000000-------------------------------------------------------------------------------- -- | -- Module : Graphics.Rendering.GLU.Raw -- Copyright : (c) Sven Panne 2013 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- A 1:1 binding for the OpenGL utility library. -- -------------------------------------------------------------------------------- module Graphics.Rendering.GLU.Raw ( module Graphics.Rendering.GLU.Raw.Functions, module Graphics.Rendering.GLU.Raw.Tokens, module Graphics.Rendering.GLU.Raw.Types, module Graphics.Rendering.GLU.Raw.Callbacks ) where import Graphics.Rendering.GLU.Raw.Functions import Graphics.Rendering.GLU.Raw.Tokens import Graphics.Rendering.GLU.Raw.Types import Graphics.Rendering.GLU.Raw.Callbacks GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/0000755000000000000000000000000012521420140016556 5ustar0000000000000000GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/Tokens.hs0000644000000000000000000002232212521420140020356 0ustar0000000000000000-------------------------------------------------------------------------------- -- | -- Module : Graphics.Rendering.GLU.Raw.Tokens -- Copyright : (c) Sven Panne 2013 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- All tokens from GLU 1.3, see . -- -------------------------------------------------------------------------------- module Graphics.Rendering.GLU.Raw.Tokens where import Graphics.Rendering.OpenGL.Raw.Core31 -------------------------------------------------------------------------------- -- Boolean glu_FALSE :: GLenum glu_FALSE = 0 glu_TRUE :: GLenum glu_TRUE = 1 -- StringName glu_VERSION :: GLenum glu_VERSION = 100800 glu_EXTENSIONS :: GLenum glu_EXTENSIONS = 100801 -- ErrorCode glu_INVALID_ENUM :: GLenum glu_INVALID_ENUM = 100900 glu_INVALID_VALUE :: GLenum glu_INVALID_VALUE = 100901 glu_OUT_OF_MEMORY :: GLenum glu_OUT_OF_MEMORY = 100902 glu_INCOMPATIBLE_GL_VERSION :: GLenum glu_INCOMPATIBLE_GL_VERSION = 100903 glu_INVALID_OPERATION :: GLenum glu_INVALID_OPERATION = 100904 -- NurbsDisplay -- GLU_FILL glu_OUTLINE_POLYGON :: GLenum glu_OUTLINE_POLYGON = 100240 glu_OUTLINE_PATCH :: GLenum glu_OUTLINE_PATCH = 100241 -- NurbsCallback glu_NURBS_ERROR :: GLenum glu_NURBS_ERROR = 100103 glu_ERROR :: GLenum glu_ERROR = 100103 glu_NURBS_BEGIN :: GLenum glu_NURBS_BEGIN = 100164 glu_NURBS_BEGIN_EXT :: GLenum glu_NURBS_BEGIN_EXT = 100164 glu_NURBS_VERTEX :: GLenum glu_NURBS_VERTEX = 100165 glu_NURBS_VERTEX_EXT :: GLenum glu_NURBS_VERTEX_EXT = 100165 glu_NURBS_NORMAL :: GLenum glu_NURBS_NORMAL = 100166 glu_NURBS_NORMAL_EXT :: GLenum glu_NURBS_NORMAL_EXT = 100166 glu_NURBS_COLOR :: GLenum glu_NURBS_COLOR = 100167 glu_NURBS_COLOR_EXT :: GLenum glu_NURBS_COLOR_EXT = 100167 glu_NURBS_TEXTURE_COORD :: GLenum glu_NURBS_TEXTURE_COORD = 100168 glu_NURBS_TEX_COORD_EXT :: GLenum glu_NURBS_TEX_COORD_EXT = 100168 glu_NURBS_END :: GLenum glu_NURBS_END = 100169 glu_NURBS_END_EXT :: GLenum glu_NURBS_END_EXT = 100169 glu_NURBS_BEGIN_DATA :: GLenum glu_NURBS_BEGIN_DATA = 100170 glu_NURBS_BEGIN_DATA_EXT :: GLenum glu_NURBS_BEGIN_DATA_EXT = 100170 glu_NURBS_VERTEX_DATA :: GLenum glu_NURBS_VERTEX_DATA = 100171 glu_NURBS_VERTEX_DATA_EXT :: GLenum glu_NURBS_VERTEX_DATA_EXT = 100171 glu_NURBS_NORMAL_DATA :: GLenum glu_NURBS_NORMAL_DATA = 100172 glu_NURBS_NORMAL_DATA_EXT :: GLenum glu_NURBS_NORMAL_DATA_EXT = 100172 glu_NURBS_COLOR_DATA :: GLenum glu_NURBS_COLOR_DATA = 100173 glu_NURBS_COLOR_DATA_EXT :: GLenum glu_NURBS_COLOR_DATA_EXT = 100173 glu_NURBS_TEXTURE_COORD_DATA :: GLenum glu_NURBS_TEXTURE_COORD_DATA = 100174 glu_NURBS_TEX_COORD_DATA_EXT :: GLenum glu_NURBS_TEX_COORD_DATA_EXT = 100174 glu_NURBS_END_DATA :: GLenum glu_NURBS_END_DATA = 100175 glu_NURBS_END_DATA_EXT :: GLenum glu_NURBS_END_DATA_EXT = 100175 -- NurbsError glu_NURBS_ERROR1 :: GLenum glu_NURBS_ERROR1 = 100251 glu_NURBS_ERROR2 :: GLenum glu_NURBS_ERROR2 = 100252 glu_NURBS_ERROR3 :: GLenum glu_NURBS_ERROR3 = 100253 glu_NURBS_ERROR4 :: GLenum glu_NURBS_ERROR4 = 100254 glu_NURBS_ERROR5 :: GLenum glu_NURBS_ERROR5 = 100255 glu_NURBS_ERROR6 :: GLenum glu_NURBS_ERROR6 = 100256 glu_NURBS_ERROR7 :: GLenum glu_NURBS_ERROR7 = 100257 glu_NURBS_ERROR8 :: GLenum glu_NURBS_ERROR8 = 100258 glu_NURBS_ERROR9 :: GLenum glu_NURBS_ERROR9 = 100259 glu_NURBS_ERROR10 :: GLenum glu_NURBS_ERROR10 = 100260 glu_NURBS_ERROR11 :: GLenum glu_NURBS_ERROR11 = 100261 glu_NURBS_ERROR12 :: GLenum glu_NURBS_ERROR12 = 100262 glu_NURBS_ERROR13 :: GLenum glu_NURBS_ERROR13 = 100263 glu_NURBS_ERROR14 :: GLenum glu_NURBS_ERROR14 = 100264 glu_NURBS_ERROR15 :: GLenum glu_NURBS_ERROR15 = 100265 glu_NURBS_ERROR16 :: GLenum glu_NURBS_ERROR16 = 100266 glu_NURBS_ERROR17 :: GLenum glu_NURBS_ERROR17 = 100267 glu_NURBS_ERROR18 :: GLenum glu_NURBS_ERROR18 = 100268 glu_NURBS_ERROR19 :: GLenum glu_NURBS_ERROR19 = 100269 glu_NURBS_ERROR20 :: GLenum glu_NURBS_ERROR20 = 100270 glu_NURBS_ERROR21 :: GLenum glu_NURBS_ERROR21 = 100271 glu_NURBS_ERROR22 :: GLenum glu_NURBS_ERROR22 = 100272 glu_NURBS_ERROR23 :: GLenum glu_NURBS_ERROR23 = 100273 glu_NURBS_ERROR24 :: GLenum glu_NURBS_ERROR24 = 100274 glu_NURBS_ERROR25 :: GLenum glu_NURBS_ERROR25 = 100275 glu_NURBS_ERROR26 :: GLenum glu_NURBS_ERROR26 = 100276 glu_NURBS_ERROR27 :: GLenum glu_NURBS_ERROR27 = 100277 glu_NURBS_ERROR28 :: GLenum glu_NURBS_ERROR28 = 100278 glu_NURBS_ERROR29 :: GLenum glu_NURBS_ERROR29 = 100279 glu_NURBS_ERROR30 :: GLenum glu_NURBS_ERROR30 = 100280 glu_NURBS_ERROR31 :: GLenum glu_NURBS_ERROR31 = 100281 glu_NURBS_ERROR32 :: GLenum glu_NURBS_ERROR32 = 100282 glu_NURBS_ERROR33 :: GLenum glu_NURBS_ERROR33 = 100283 glu_NURBS_ERROR34 :: GLenum glu_NURBS_ERROR34 = 100284 glu_NURBS_ERROR35 :: GLenum glu_NURBS_ERROR35 = 100285 glu_NURBS_ERROR36 :: GLenum glu_NURBS_ERROR36 = 100286 glu_NURBS_ERROR37 :: GLenum glu_NURBS_ERROR37 = 100287 -- NurbsProperty glu_AUTO_LOAD_MATRIX :: GLenum glu_AUTO_LOAD_MATRIX = 100200 glu_CULLING :: GLenum glu_CULLING = 100201 glu_SAMPLING_TOLERANCE :: GLenum glu_SAMPLING_TOLERANCE = 100203 glu_DISPLAY_MODE :: GLenum glu_DISPLAY_MODE = 100204 glu_PARAMETRIC_TOLERANCE :: GLenum glu_PARAMETRIC_TOLERANCE = 100202 glu_SAMPLING_METHOD :: GLenum glu_SAMPLING_METHOD = 100205 glu_U_STEP :: GLenum glu_U_STEP = 100206 glu_V_STEP :: GLenum glu_V_STEP = 100207 glu_NURBS_MODE :: GLenum glu_NURBS_MODE = 100160 glu_NURBS_MODE_EXT :: GLenum glu_NURBS_MODE_EXT = 100160 glu_NURBS_TESSELLATOR :: GLenum glu_NURBS_TESSELLATOR = 100161 glu_NURBS_TESSELLATOR_EXT :: GLenum glu_NURBS_TESSELLATOR_EXT = 100161 glu_NURBS_RENDERER :: GLenum glu_NURBS_RENDERER = 100162 glu_NURBS_RENDERER_EXT :: GLenum glu_NURBS_RENDERER_EXT = 100162 -- NurbsSampling glu_OBJECT_PARAMETRIC_ERROR :: GLenum glu_OBJECT_PARAMETRIC_ERROR = 100208 glu_OBJECT_PARAMETRIC_ERROR_EXT :: GLenum glu_OBJECT_PARAMETRIC_ERROR_EXT = 100208 glu_OBJECT_PATH_LENGTH :: GLenum glu_OBJECT_PATH_LENGTH = 100209 glu_OBJECT_PATH_LENGTH_EXT :: GLenum glu_OBJECT_PATH_LENGTH_EXT = 100209 glu_PATH_LENGTH :: GLenum glu_PATH_LENGTH = 100215 glu_PARAMETRIC_ERROR :: GLenum glu_PARAMETRIC_ERROR = 100216 glu_DOMAIN_DISTANCE :: GLenum glu_DOMAIN_DISTANCE = 100217 -- NurbsTrim glu_MAP1_TRIM_2 :: GLenum glu_MAP1_TRIM_2 = 100210 glu_MAP1_TRIM_3 :: GLenum glu_MAP1_TRIM_3 = 100211 -- QuadricDrawStyle glu_POINT :: GLenum glu_POINT = 100010 glu_LINE :: GLenum glu_LINE = 100011 glu_FILL :: GLenum glu_FILL = 100012 glu_SILHOUETTE :: GLenum glu_SILHOUETTE = 100013 -- QuadricCallback -- GLU_ERROR -- QuadricNormal glu_SMOOTH :: GLenum glu_SMOOTH = 100000 glu_FLAT :: GLenum glu_FLAT = 100001 glu_NONE :: GLenum glu_NONE = 100002 -- QuadricOrientation glu_OUTSIDE :: GLenum glu_OUTSIDE = 100020 glu_INSIDE :: GLenum glu_INSIDE = 100021 -- TessCallback glu_TESS_BEGIN :: GLenum glu_TESS_BEGIN = 100100 glu_BEGIN :: GLenum glu_BEGIN = 100100 glu_TESS_VERTEX :: GLenum glu_TESS_VERTEX = 100101 glu_VERTEX :: GLenum glu_VERTEX = 100101 glu_TESS_END :: GLenum glu_TESS_END = 100102 glu_END :: GLenum glu_END = 100102 glu_TESS_ERROR :: GLenum glu_TESS_ERROR = 100103 glu_TESS_EDGE_FLAG :: GLenum glu_TESS_EDGE_FLAG = 100104 glu_EDGE_FLAG :: GLenum glu_EDGE_FLAG = 100104 glu_TESS_COMBINE :: GLenum glu_TESS_COMBINE = 100105 glu_TESS_BEGIN_DATA :: GLenum glu_TESS_BEGIN_DATA = 100106 glu_TESS_VERTEX_DATA :: GLenum glu_TESS_VERTEX_DATA = 100107 glu_TESS_END_DATA :: GLenum glu_TESS_END_DATA = 100108 glu_TESS_ERROR_DATA :: GLenum glu_TESS_ERROR_DATA = 100109 glu_TESS_EDGE_FLAG_DATA :: GLenum glu_TESS_EDGE_FLAG_DATA = 100110 glu_TESS_COMBINE_DATA :: GLenum glu_TESS_COMBINE_DATA = 100111 -- TessContour glu_CW :: GLenum glu_CW = 100120 glu_CCW :: GLenum glu_CCW = 100121 glu_INTERIOR :: GLenum glu_INTERIOR = 100122 glu_EXTERIOR :: GLenum glu_EXTERIOR = 100123 glu_UNKNOWN :: GLenum glu_UNKNOWN = 100124 -- TessProperty glu_TESS_WINDING_RULE :: GLenum glu_TESS_WINDING_RULE = 100140 glu_TESS_BOUNDARY_ONLY :: GLenum glu_TESS_BOUNDARY_ONLY = 100141 glu_TESS_TOLERANCE :: GLenum glu_TESS_TOLERANCE = 100142 -- TessError glu_TESS_ERROR1 :: GLenum glu_TESS_ERROR1 = 100151 glu_TESS_ERROR2 :: GLenum glu_TESS_ERROR2 = 100152 glu_TESS_ERROR3 :: GLenum glu_TESS_ERROR3 = 100153 glu_TESS_ERROR4 :: GLenum glu_TESS_ERROR4 = 100154 glu_TESS_ERROR5 :: GLenum glu_TESS_ERROR5 = 100155 glu_TESS_ERROR6 :: GLenum glu_TESS_ERROR6 = 100156 glu_TESS_ERROR7 :: GLenum glu_TESS_ERROR7 = 100157 glu_TESS_ERROR8 :: GLenum glu_TESS_ERROR8 = 100158 glu_TESS_MISSING_BEGIN_POLYGON :: GLenum glu_TESS_MISSING_BEGIN_POLYGON = 100151 glu_TESS_MISSING_BEGIN_CONTOUR :: GLenum glu_TESS_MISSING_BEGIN_CONTOUR = 100152 glu_TESS_MISSING_END_POLYGON :: GLenum glu_TESS_MISSING_END_POLYGON = 100153 glu_TESS_MISSING_END_CONTOUR :: GLenum glu_TESS_MISSING_END_CONTOUR = 100154 glu_TESS_COORD_TOO_LARGE :: GLenum glu_TESS_COORD_TOO_LARGE = 100155 glu_TESS_NEED_COMBINE_CALLBACK :: GLenum glu_TESS_NEED_COMBINE_CALLBACK = 100156 -- TessWinding glu_TESS_WINDING_ODD :: GLenum glu_TESS_WINDING_ODD = 100130 glu_TESS_WINDING_NONZERO :: GLenum glu_TESS_WINDING_NONZERO = 100131 glu_TESS_WINDING_POSITIVE :: GLenum glu_TESS_WINDING_POSITIVE = 100132 glu_TESS_WINDING_NEGATIVE :: GLenum glu_TESS_WINDING_NEGATIVE = 100133 glu_TESS_WINDING_ABS_GEQ_TWO :: GLenum glu_TESS_WINDING_ABS_GEQ_TWO = 100134 GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/Types.hs0000644000000000000000000000113412521420140020215 0ustar0000000000000000-------------------------------------------------------------------------------- -- | -- Module : Graphics.Rendering.GLU.Raw.Types -- Copyright : (c) Sven Panne 2013 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- All (abstract) types from GLU 1.3, see . -- -------------------------------------------------------------------------------- module Graphics.Rendering.GLU.Raw.Types ( GLUnurbs, GLUquadric, GLUtesselator ) where import Graphics.Rendering.GLU.Raw.TypesInternal GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/Callbacks.hs0000644000000000000000000001572512521420140021003 0ustar0000000000000000{-# LANGUAGE CPP #-} -------------------------------------------------------------------------------- -- | -- Module : Graphics.Rendering.GLU.Raw.Callbacks -- Copyright : (c) Sven Panne 2013 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- All callbacks from GLU 1.3, see . -- -------------------------------------------------------------------------------- module Graphics.Rendering.GLU.Raw.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 Foreign.C.Types import Graphics.Rendering.OpenGL.Raw -------------------------------------------------------------------------------- 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-1.5.0.1/src/Graphics/Rendering/GLU/Raw/TypesInternal.hs0000644000000000000000000000117012521420140021712 0ustar0000000000000000{-# OPTIONS_HADDOCK hide #-} -------------------------------------------------------------------------------- -- | -- Module : Graphics.Rendering.GLU.Raw.TypesInternal -- Copyright : (c) Sven Panne 2013 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- All types from GLU 1.3, see . -- -------------------------------------------------------------------------------- module Graphics.Rendering.GLU.Raw.TypesInternal where data GLUnurbs = GLUnurbs data GLUquadric = GLUquadric data GLUtesselator = GLUtesselator GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/Functions.hs0000644000000000000000000011262512521420140021071 0ustar0000000000000000{-# LANGUAGE CPP #-} -------------------------------------------------------------------------------- -- | -- Module : Graphics.Rendering.GLU.Raw.Functions -- Copyright : (c) Sven Panne 2013 -- License : BSD3 -- -- Maintainer : Sven Panne -- Stability : stable -- Portability : portable -- -- All functions from GLU 1.3, see . -- -------------------------------------------------------------------------------- module Graphics.Rendering.GLU.Raw.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 -- Make the foreign imports happy. import Foreign.C.Types import Control.Monad.IO.Class ( MonadIO(..) ) import Foreign.C.String ( withCString, CString ) import Foreign.Marshal.Error ( throwIf ) import Foreign.Ptr ( Ptr, FunPtr, nullFunPtr ) import System.IO.Unsafe ( unsafePerformIO ) import Graphics.Rendering.GLU.Raw.Types import Graphics.Rendering.OpenGL.Raw.Types -------------------------------------------------------------------------------- -- | 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"