GLURaw-1.5.0.1/ 0000755 0000000 0000000 00000000000 12521420140 011132 5 ustar 00 0000000 0000000 GLURaw-1.5.0.1/README.md 0000644 0000000 0000000 00000000326 12521420140 012412 0 ustar 00 0000000 0000000 [](https://hackage.haskell.org/package/GLURaw) [](https://travis-ci.org/haskell-opengl/GLURaw)
GLURaw-1.5.0.1/LICENSE 0000644 0000000 0000000 00000002715 12521420140 012144 0 ustar 00 0000000 0000000 Copyright (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.cabal 0000644 0000000 0000000 00000004312 12521420140 013217 0 ustar 00 0000000 0000000 name: 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.hs 0000644 0000000 0000000 00000000056 12521420140 012567 0 ustar 00 0000000 0000000 import Distribution.Simple
main = defaultMain
GLURaw-1.5.0.1/cbits/ 0000755 0000000 0000000 00000000000 12521420140 012236 5 ustar 00 0000000 0000000 GLURaw-1.5.0.1/cbits/HsGLURaw.c 0000644 0000000 0000000 00000004325 12521420140 014002 0 ustar 00 0000000 0000000 /* -----------------------------------------------------------------------------
*
* 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/ 0000755 0000000 0000000 00000000000 12521420140 011721 5 ustar 00 0000000 0000000 GLURaw-1.5.0.1/src/Graphics/ 0000755 0000000 0000000 00000000000 12521420140 013461 5 ustar 00 0000000 0000000 GLURaw-1.5.0.1/src/Graphics/Rendering/ 0000755 0000000 0000000 00000000000 12521420140 015376 5 ustar 00 0000000 0000000 GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/ 0000755 0000000 0000000 00000000000 12521420140 016025 5 ustar 00 0000000 0000000 GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw.hs 0000644 0000000 0000000 00000001501 12521420140 017107 0 ustar 00 0000000 0000000 --------------------------------------------------------------------------------
-- |
-- 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/ 0000755 0000000 0000000 00000000000 12521420140 016556 5 ustar 00 0000000 0000000 GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/Tokens.hs 0000644 0000000 0000000 00000022322 12521420140 020356 0 ustar 00 0000000 0000000 --------------------------------------------------------------------------------
-- |
-- 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.hs 0000644 0000000 0000000 00000001134 12521420140 020215 0 ustar 00 0000000 0000000 --------------------------------------------------------------------------------
-- |
-- 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.hs 0000644 0000000 0000000 00000015725 12521420140 021003 0 ustar 00 0000000 0000000 {-# 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.hs 0000644 0000000 0000000 00000001170 12521420140 021712 0 ustar 00 0000000 0000000 {-# 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.hs 0000644 0000000 0000000 00000112625 12521420140 021071 0 ustar 00 0000000 0000000 {-# 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"