Hello community, here is the log from the commit of package ghc-GLURaw for openSUSE:Factory checked in at 2015-05-21 08:13:57 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/ghc-GLURaw (Old) and /work/SRC/openSUSE:Factory/.ghc-GLURaw.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "ghc-GLURaw" Changes: -------- --- /work/SRC/openSUSE:Factory/ghc-GLURaw/ghc-GLURaw.changes 2014-11-26 20:54:43.000000000 +0100 +++ /work/SRC/openSUSE:Factory/.ghc-GLURaw.new/ghc-GLURaw.changes 2015-05-21 08:13:59.000000000 +0200 @@ -1,0 +2,12 @@ +Tue May 5 03:39:25 UTC 2015 - [email protected] + +- update to 1.5.0.1 +* no upstream changelog + +------------------------------------------------------------------- +Tue Apr 14 15:13:34 UTC 2015 - [email protected] + +- update to 1.5.0.0 +* no changelog + +------------------------------------------------------------------- Old: ---- GLURaw-1.4.0.1.tar.gz _service New: ---- GLURaw-1.5.0.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ ghc-GLURaw.spec ++++++ --- /var/tmp/diff_new_pack.wAIojN/_old 2015-05-21 08:14:00.000000000 +0200 +++ /var/tmp/diff_new_pack.wAIojN/_new 2015-05-21 08:14:00.000000000 +0200 @@ -1,7 +1,7 @@ # -# spec file for package ghc-GLURaw +# spec file for package ghc # -# Copyright (c) 2014 SUSE LINUX Products GmbH, Nuernberg, Germany. +# Copyright (c) 2015 SUSE LINUX GmbH, Nuernberg, Germany. # # All modifications and additions to the file contributed by third parties # remain the property of their copyright owners, unless otherwise agreed @@ -17,66 +17,62 @@ %global pkg_name GLURaw - -%global common_summary A raw binding for the OpenGL graphics system - -%global common_description GLURaw is a raw Haskell binding for the GLU 1.3 OpenGL utility library. It is basically a 1:1 mapping of the GLU C API, intended as a basis for a nicer interface. - -Name: ghc-GLURaw -Version: 1.4.0.1 +Name: ghc-%{pkg_name} +Version: 1.5.0.1 Release: 0 -Summary: %{common_summary} +Summary: A raw binding for the OpenGL graphics system License: BSD-3-Clause Group: System/Libraries - -BuildRoot: %{_tmppath}/%{name}-%{version}-build -# BEGIN cabal2spec -Url: http://hackage.haskell.org/package/%{pkg_name} -Source0: http://hackage.haskell.org/packages/archive/%{pkg_name}/%{version}/%{pkg_name}-%{version}.tar.gz +Url: https://hackage.haskell.org/package/%{pkg_name} +Source0: https://hackage.haskell.org/package/%{pkg_name}-%{version}/%{pkg_name}-%{version}.tar.gz BuildRequires: ghc-Cabal-devel +# Begin cabal-rpm deps: BuildRequires: ghc-OpenGLRaw-devel BuildRequires: ghc-rpm-macros -%if 0%{?suse_version}<1230 -BuildRequires: Mesa-devel -%else -BuildRequires: glu-devel -%endif -# END cabal2spec +BuildRequires: ghc-transformers-devel +BuildRequires: pkgconfig(glu) +BuildRoot: %{_tmppath}/%{name}-%{version}-build +# End cabal-rpm deps %description -%{common_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 <http://www.opengl.org/> and <http://www.opengl.org/registry/>. %package devel Summary: Haskell %{pkg_name} library development files -Group: Development/Languages/Other -Requires: ghc-compiler -Requires(post): ghc-compiler -Requires(postun): ghc-compiler +Group: Development/Libraries/Other Requires: %{name} = %{version}-%{release} -%if 0%{?suse_version}<1230 -Requires: Mesa-devel -%else -Requires: glu-devel -%endif +Requires: ghc-compiler = %{ghc_version} +# Begin cabal-rpm deps: +Requires: pkgconfig(glu) +Requires(post): ghc-compiler = %{ghc_version} +Requires(postun): ghc-compiler = %{ghc_version} +# End cabal-rpm deps %description devel -%{common_description} -This package contains the development files. +This package provides the Haskell %{pkg_name} library development files. %prep %setup -q -n %{pkg_name}-%{version} %build -%ghc_lib_build +%{ghc_lib_build} %install -%ghc_lib_install +%{ghc_lib_install} %post devel -%ghc_pkg_recache +%{ghc_pkg_recache} %postun devel -%ghc_pkg_recache +%{ghc_pkg_recache} %files -f %{name}.files %defattr(-,root,root,-) @@ -84,5 +80,6 @@ %files devel -f %{name}-devel.files %defattr(-,root,root,-) +%doc README.md %changelog ++++++ GLURaw-1.4.0.1.tar.gz -> GLURaw-1.5.0.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/GLURaw-1.4.0.1/GLURaw.cabal new/GLURaw-1.5.0.1/GLURaw.cabal --- old/GLURaw-1.4.0.1/GLURaw.cabal 2014-05-19 17:18:28.000000000 +0200 +++ new/GLURaw-1.5.0.1/GLURaw.cabal 2015-05-03 15:19:28.000000000 +0200 @@ -1,68 +1,72 @@ name: GLURaw -version: 1.4.0.1 +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 <http://www.opengl.org/> + and <http://www.opengl.org/registry/>. +homepage: http://www.haskell.org/haskellwiki/Opengl +bug-reports: https://github.com/haskell-opengl/GLURaw/issues +copyright: Copyright (C) 2009-2015 Sven Panne license: BSD3 license-file: LICENSE +author: Sven Panne maintainer: Sven Panne <[email protected]>, Jason Dagit <[email protected]> -bug-reports: https://github.com/haskell-opengl/GLURaw/issues -homepage: http://www.haskell.org/haskellwiki/Opengl category: Graphics -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 <http://www.opengl.org/> - and <http://www.opengl.org/registry/>. build-type: Simple -cabal-version: >= 1.6 +cabal-version: >= 1.10 extra-source-files: - README.md - include/HsGLURaw.h + README.md flag UseNativeWindowsLibraries - description: - When compiling under Windows, use the native libraries instead of e.g. the - ones coming with Cygwin. + 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.APIEntry, - Graphics.Rendering.GLU.Raw.TypesInternal - c-sources: - cbits/HsGLURaw.c - hs-Source-Dirs: src - include-dirs: include - build-depends: base >= 3 && < 5, OpenGLRaw >= 1.3.0.0 - ghc-options: -Wall -O2 - 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 + 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_DLSYM" - if os(darwin) - frameworks: OpenGL - else - if os(ios) - frameworks: OpenGLES - else - extra-libraries: GLU + 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 + type: git + location: https://github.com/haskell-opengl/GLURaw.git diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/GLURaw-1.4.0.1/README.md new/GLURaw-1.5.0.1/README.md --- old/GLURaw-1.4.0.1/README.md 2014-05-19 17:18:28.000000000 +0200 +++ new/GLURaw-1.5.0.1/README.md 2015-05-03 15:19:28.000000000 +0200 @@ -1 +1 @@ -[](https://travis-ci.org/haskell-opengl/GLURaw) +[](https://hackage.haskell.org/package/GLURaw) [](https://travis-ci.org/haskell-opengl/GLURaw) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/GLURaw-1.4.0.1/include/HsGLURaw.h new/GLURaw-1.5.0.1/include/HsGLURaw.h --- old/GLURaw-1.4.0.1/include/HsGLURaw.h 2014-05-19 17:18:28.000000000 +0200 +++ new/GLURaw-1.5.0.1/include/HsGLURaw.h 1970-01-01 01:00:00.000000000 +0100 @@ -1,35 +0,0 @@ -/* ----------------------------------------------------------------------------- - * - * Module : GL extension support for Graphics.Rendering.GLU.Raw - * Copyright : (c) Sven Panne 2013 - * License : BSD3 - * - * Maintainer : Sven Panne <[email protected]> - * Stability : stable - * Portability : portable - * - * This header should only define preprocessor macros! - * - * -------------------------------------------------------------------------- */ - -#ifndef HSGLURAW_H -#define HSGLURAW_H - -#define HASH # - -/* NOTE: The macro must immediately start with the foreign declaration, - otherwise the magic mangler (hack_foreign) in the Hugs build system - doesn't recognize it. */ -#define API_ENTRY_INTERNAL(_dyn_entry,_ptr_entry,_str_entry,_entry,_ty,_safety) \ -foreign import CALLCONV _safety "dynamic" _dyn_entry :: Graphics.Rendering.GLU.Raw.APIEntry.Invoker (_ty) ; \ -_entry :: (_ty) ; \ -_entry = _dyn_entry _ptr_entry ; \ -_ptr_entry :: FunPtr a ; \ -_ptr_entry = unsafePerformIO (Graphics.Rendering.GLU.Raw.APIEntry.getAPIEntry _str_entry) ; \ -{-HASH NOINLINE _ptr_entry HASH-} - -#define API_ENTRY(_dyn_entry,_ptr_entry,_str_entry,_entry,_ty) API_ENTRY_INTERNAL(_dyn_entry,_ptr_entry,_str_entry,_entry,_ty,unsafe) - -#define API_ENTRY_SAFE(_dyn_entry,_ptr_entry,_str_entry,_entry,_ty) API_ENTRY_INTERNAL(_dyn_entry,_ptr_entry,_str_entry,_entry,_ty,safe) - -#endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/GLURaw-1.4.0.1/src/Graphics/Rendering/GLU/Raw/APIEntry.hs new/GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/APIEntry.hs --- old/GLURaw-1.4.0.1/src/Graphics/Rendering/GLU/Raw/APIEntry.hs 2014-05-19 17:18:28.000000000 +0200 +++ new/GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/APIEntry.hs 1970-01-01 01:00:00.000000000 +0100 @@ -1,48 +0,0 @@ -{-# LANGUAGE ForeignFunctionInterface, CPP #-} -{-# OPTIONS_HADDOCK hide #-} --------------------------------------------------------------------------------- --- | --- Module : Graphics.Rendering.GLU.Raw.APIEntry --- Copyright : (c) Sven Panne 2013 --- License : BSD3 --- --- Maintainer : Sven Panne <[email protected]> --- Stability : stable --- Portability : portable --- --- This module offers a portable way to retrieve GLUT entries, providing a --- portability layer upon platform-specific mechanisms like @dlsym@, --- @GetProcAddress@ or @NSAddressOfSymbol@. --- --------------------------------------------------------------------------------- - -module Graphics.Rendering.GLU.Raw.APIEntry ( - Invoker, getAPIEntry, - FunPtr, unsafePerformIO -) where - -import Foreign.C.String -import Foreign.Marshal.Error -import Foreign.Ptr -import System.IO.Unsafe - -#ifdef __HUGS__ -{-# CFILES cbits/HsOpenGLRaw.c #-} -#endif - --------------------------------------------------------------------------------- - -type Invoker a = FunPtr a -> a - --- | Retrieve a GLU API entry by name. Throws a userError when no entry with the --- given name was found. -getAPIEntry :: String -> IO (FunPtr a) -getAPIEntry extensionEntry = - throwIfNullFunPtr ("unknown GLU entry " ++ extensionEntry) $ - withCString extensionEntry hs_GLU_getProcAddress - -throwIfNullFunPtr :: String -> IO (FunPtr a) -> IO (FunPtr a) -throwIfNullFunPtr = throwIf (== nullFunPtr) . const - -foreign import ccall unsafe "hs_GLU_getProcAddress" - hs_GLU_getProcAddress :: CString -> IO (FunPtr a) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/GLURaw-1.4.0.1/src/Graphics/Rendering/GLU/Raw/Callbacks.hs new/GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/Callbacks.hs --- old/GLURaw-1.4.0.1/src/Graphics/Rendering/GLU/Raw/Callbacks.hs 2014-05-19 17:18:28.000000000 +0200 +++ new/GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/Callbacks.hs 2015-05-03 15:19:28.000000000 +0200 @@ -1,4 +1,4 @@ -{-# LANGUAGE ForeignFunctionInterface, CPP #-} +{-# LANGUAGE CPP #-} -------------------------------------------------------------------------------- -- | -- Module : Graphics.Rendering.GLU.Raw.Callbacks diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/GLURaw-1.4.0.1/src/Graphics/Rendering/GLU/Raw/Functions.hs new/GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/Functions.hs --- old/GLURaw-1.4.0.1/src/Graphics/Rendering/GLU/Raw/Functions.hs 2014-05-19 17:18:28.000000000 +0200 +++ new/GLURaw-1.5.0.1/src/Graphics/Rendering/GLU/Raw/Functions.hs 2015-05-03 15:19:28.000000000 +0200 @@ -1,4 +1,4 @@ -{-# LANGUAGE ForeignFunctionInterface, CPP #-} +{-# LANGUAGE CPP #-} -------------------------------------------------------------------------------- -- | -- Module : Graphics.Rendering.GLU.Raw.Functions @@ -75,72 +75,796 @@ gluUnProject4, ) where -import Foreign.Ptr +-- Make the foreign imports happy. import Foreign.C.Types -import Graphics.Rendering.GLU.Raw.APIEntry -import Graphics.Rendering.GLU.Raw.Types -import Graphics.Rendering.OpenGL.Raw.Core31 -#include "HsGLURaw.h" +import Control.Monad.IO.Class ( MonadIO(..) ) +import Foreign.C.String ( withCString, CString ) +import Foreign.Marshal.Error ( throwIf ) +import Foreign.Ptr ( Ptr, FunPtr, nullFunPtr ) +import System.IO.Unsafe ( unsafePerformIO ) + +import Graphics.Rendering.GLU.Raw.Types +import Graphics.Rendering.OpenGL.Raw.Types -------------------------------------------------------------------------------- -API_ENTRY_SAFE(dyn_gluBeginCurve,ptr_gluBeginCurve,"gluBeginCurve",gluBeginCurve,Ptr GLUnurbs -> IO ()) -API_ENTRY_SAFE(dyn_gluBeginPolygon,ptr_gluBeginPolygon,"gluBeginPolygon",gluBeginPolygon,Ptr GLUtesselator -> IO ()) -API_ENTRY_SAFE(dyn_gluBeginSurface,ptr_gluBeginSurface,"gluBeginSurface",gluBeginSurface,Ptr GLUnurbs -> IO ()) -API_ENTRY_SAFE(dyn_gluBeginTrim,ptr_gluBeginTrim,"gluBeginTrim",gluBeginTrim,Ptr GLUnurbs -> IO ()) -API_ENTRY(dyn_gluBuild1DMipmapLevels,ptr_gluBuild1DMipmapLevels,"gluBuild1DMipmapLevels",gluBuild1DMipmapLevels,GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint) -API_ENTRY(dyn_gluBuild1DMipmaps,ptr_gluBuild1DMipmaps,"gluBuild1DMipmaps",gluBuild1DMipmaps,GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint) -API_ENTRY(dyn_gluBuild2DMipmapLevels,ptr_gluBuild2DMipmapLevels,"gluBuild2DMipmapLevels",gluBuild2DMipmapLevels,GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint) -API_ENTRY(dyn_gluBuild2DMipmaps,ptr_gluBuild2DMipmaps,"gluBuild2DMipmaps",gluBuild2DMipmaps,GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint) -API_ENTRY(dyn_gluBuild3DMipmapLevels,ptr_gluBuild3DMipmapLevels,"gluBuild3DMipmapLevels",gluBuild3DMipmapLevels,GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint) -API_ENTRY(dyn_gluBuild3DMipmaps,ptr_gluBuild3DMipmaps,"gluBuild3DMipmaps",gluBuild3DMipmaps,GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint) -API_ENTRY(dyn_gluCheckExtension,ptr_gluCheckExtension,"gluCheckExtension",gluCheckExtension,Ptr GLubyte -> Ptr GLubyte -> IO GLboolean) -API_ENTRY_SAFE(dyn_gluCylinder,ptr_gluCylinder,"gluCylinder",gluCylinder,Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()) -API_ENTRY_SAFE(dyn_gluDeleteNurbsRenderer,ptr_gluDeleteNurbsRenderer,"gluDeleteNurbsRenderer",gluDeleteNurbsRenderer,Ptr GLUnurbs -> IO ()) -API_ENTRY(dyn_gluDeleteQuadric,ptr_gluDeleteQuadric,"gluDeleteQuadric",gluDeleteQuadric,Ptr GLUquadric -> IO ()) -API_ENTRY_SAFE(dyn_gluDeleteTess,ptr_gluDeleteTess,"gluDeleteTess",gluDeleteTess,Ptr GLUtesselator -> IO ()) -API_ENTRY_SAFE(dyn_gluDisk,ptr_gluDisk,"gluDisk",gluDisk,Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()) -API_ENTRY_SAFE(dyn_gluEndCurve,ptr_gluEndCurve,"gluEndCurve",gluEndCurve,Ptr GLUnurbs -> IO ()) -API_ENTRY_SAFE(dyn_gluEndPolygon,ptr_gluEndPolygon,"gluEndPolygon",gluEndPolygon,Ptr GLUtesselator -> IO ()) -API_ENTRY_SAFE(dyn_gluEndSurface,ptr_gluEndSurface,"gluEndSurface",gluEndSurface,Ptr GLUnurbs -> IO ()) -API_ENTRY_SAFE(dyn_gluEndTrim,ptr_gluEndTrim,"gluEndTrim",gluEndTrim,Ptr GLUnurbs -> IO ()) -API_ENTRY(dyn_gluErrorString,ptr_gluErrorString,"gluErrorString",gluErrorString,GLenum -> IO (Ptr GLubyte)) -API_ENTRY_SAFE(dyn_gluGetNurbsProperty,ptr_gluGetNurbsProperty,"gluGetNurbsProperty",gluGetNurbsProperty,Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ()) -API_ENTRY(dyn_gluGetString,ptr_gluGetString,"gluGetString",gluGetString,GLenum -> IO (Ptr GLubyte)) -API_ENTRY_SAFE(dyn_gluGetTessProperty,ptr_gluGetTessProperty,"gluGetTessProperty",gluGetTessProperty,Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ()) -API_ENTRY_SAFE(dyn_gluLoadSamplingMatrices,ptr_gluLoadSamplingMatrices,"gluLoadSamplingMatrices",gluLoadSamplingMatrices,Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ()) -API_ENTRY(dyn_gluLookAt,ptr_gluLookAt,"gluLookAt",gluLookAt,GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) -API_ENTRY_SAFE(dyn_gluNewNurbsRenderer,ptr_gluNewNurbsRenderer,"gluNewNurbsRenderer",gluNewNurbsRenderer,IO (Ptr GLUnurbs)) -API_ENTRY(dyn_gluNewQuadric,ptr_gluNewQuadric,"gluNewQuadric",gluNewQuadric,IO (Ptr GLUquadric)) -API_ENTRY(dyn_gluNewTess,ptr_gluNewTess,"gluNewTess",gluNewTess,IO (Ptr GLUtesselator)) -API_ENTRY_SAFE(dyn_gluNextContour,ptr_gluNextContour,"gluNextContour",gluNextContour,Ptr GLUtesselator -> GLenum -> IO ()) -API_ENTRY_SAFE(dyn_gluNurbsCallback,ptr_gluNurbsCallback,"gluNurbsCallback",gluNurbsCallback,Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ()) -API_ENTRY_SAFE(dyn_gluNurbsCallbackData,ptr_gluNurbsCallbackData,"gluNurbsCallbackData",gluNurbsCallbackData,Ptr GLUnurbs -> Ptr a -> IO ()) -API_ENTRY_SAFE(dyn_gluNurbsCallbackDataEXT,ptr_gluNurbsCallbackDataEXT,"gluNurbsCallbackDataEXT",gluNurbsCallbackDataEXT,Ptr GLUnurbs -> Ptr a -> IO ()) -API_ENTRY_SAFE(dyn_gluNurbsCurve,ptr_gluNurbsCurve,"gluNurbsCurve",gluNurbsCurve,Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ()) -API_ENTRY_SAFE(dyn_gluNurbsProperty,ptr_gluNurbsProperty,"gluNurbsProperty",gluNurbsProperty,Ptr GLUnurbs -> GLenum -> GLfloat -> IO ()) -API_ENTRY_SAFE(dyn_gluNurbsSurface,ptr_gluNurbsSurface,"gluNurbsSurface",gluNurbsSurface,Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> IO ()) -API_ENTRY(dyn_gluOrtho2D,ptr_gluOrtho2D,"gluOrtho2D",gluOrtho2D,GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) -API_ENTRY_SAFE(dyn_gluPartialDisk,ptr_gluPartialDisk,"gluPartialDisk",gluPartialDisk,Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> IO ()) -API_ENTRY(dyn_gluPerspective,ptr_gluPerspective,"gluPerspective",gluPerspective,GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) -API_ENTRY(dyn_gluPickMatrix,ptr_gluPickMatrix,"gluPickMatrix",gluPickMatrix,GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO ()) -API_ENTRY(dyn_gluProject,ptr_gluProject,"gluProject",gluProject,GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint) -API_ENTRY_SAFE(dyn_gluPwlCurve,ptr_gluPwlCurve,"gluPwlCurve",gluPwlCurve,Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ()) -API_ENTRY_SAFE(dyn_gluQuadricCallback,ptr_gluQuadricCallback,"gluQuadricCallback",gluQuadricCallback,Ptr GLUquadric -> GLenum -> FunPtr a -> IO ()) -API_ENTRY_SAFE(dyn_gluQuadricDrawStyle,ptr_gluQuadricDrawStyle,"gluQuadricDrawStyle",gluQuadricDrawStyle,Ptr GLUquadric -> GLenum -> IO ()) -API_ENTRY_SAFE(dyn_gluQuadricNormals,ptr_gluQuadricNormals,"gluQuadricNormals",gluQuadricNormals,Ptr GLUquadric -> GLenum -> IO ()) -API_ENTRY_SAFE(dyn_gluQuadricOrientation,ptr_gluQuadricOrientation,"gluQuadricOrientation",gluQuadricOrientation,Ptr GLUquadric -> GLenum -> IO ()) -API_ENTRY_SAFE(dyn_gluQuadricTexture,ptr_gluQuadricTexture,"gluQuadricTexture",gluQuadricTexture,Ptr GLUquadric -> GLboolean -> IO ()) -API_ENTRY(dyn_gluScaleImage,ptr_gluScaleImage,"gluScaleImage",gluScaleImage,GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> IO GLint) -API_ENTRY_SAFE(dyn_gluSphere,ptr_gluSphere,"gluSphere",gluSphere,Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ()) -API_ENTRY_SAFE(dyn_gluTessBeginContour,ptr_gluTessBeginContour,"gluTessBeginContour",gluTessBeginContour,Ptr GLUtesselator -> IO ()) -API_ENTRY_SAFE(dyn_gluTessBeginPolygon,ptr_gluTessBeginPolygon,"gluTessBeginPolygon",gluTessBeginPolygon,Ptr GLUtesselator -> Ptr a -> IO ()) -API_ENTRY_SAFE(dyn_gluTessCallback,ptr_gluTessCallback,"gluTessCallback",gluTessCallback,Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ()) -API_ENTRY_SAFE(dyn_gluTessEndContour,ptr_gluTessEndContour,"gluTessEndContour",gluTessEndContour,Ptr GLUtesselator -> IO ()) -API_ENTRY_SAFE(dyn_gluTessEndPolygon,ptr_gluTessEndPolygon,"gluTessEndPolygon",gluTessEndPolygon,Ptr GLUtesselator -> IO ()) -API_ENTRY(dyn_gluTessNormal,ptr_gluTessNormal,"gluTessNormal",gluTessNormal,Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ()) -API_ENTRY_SAFE(dyn_gluTessProperty,ptr_gluTessProperty,"gluTessProperty",gluTessProperty,Ptr GLUtesselator -> GLenum -> GLdouble -> IO ()) -API_ENTRY_SAFE(dyn_gluTessVertex,ptr_gluTessVertex,"gluTessVertex",gluTessVertex,Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ()) -API_ENTRY(dyn_gluUnProject,ptr_gluUnProject,"gluUnProject",gluUnProject,GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint) -API_ENTRY(dyn_gluUnProject4,ptr_gluUnProject4,"gluUnProject4",gluUnProject4,GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> GLclampd -> GLclampd -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint) +-- | Retrieve a GLU API entry by name. Throws a userError when no entry with the +-- given name was found. +getAPIEntry :: String -> IO (FunPtr a) +getAPIEntry extensionEntry = + throwIfNullFunPtr ("unknown GLU entry " ++ extensionEntry) $ + withCString extensionEntry hs_GLU_getProcAddress + +throwIfNullFunPtr :: String -> IO (FunPtr a) -> IO (FunPtr a) +throwIfNullFunPtr = throwIf (== nullFunPtr) . const + +foreign import ccall unsafe "hs_GLU_getProcAddress" + hs_GLU_getProcAddress :: CString -> IO (FunPtr a) + +-- gluBeginCurve ---------------------------------------------------------------------- + +gluBeginCurve :: MonadIO m => Ptr GLUnurbs -> m () +gluBeginCurve v1 = liftIO $ dyn_gluBeginCurve ptr_gluBeginCurve v1 + +foreign import CALLCONV "dynamic" dyn_gluBeginCurve + :: FunPtr (Ptr GLUnurbs -> IO ()) + -> Ptr GLUnurbs -> IO () + +{-# NOINLINE ptr_gluBeginCurve #-} +ptr_gluBeginCurve :: FunPtr a +ptr_gluBeginCurve = unsafePerformIO $ getAPIEntry "gluBeginCurve" + +-- gluBeginPolygon ---------------------------------------------------------------------- + +gluBeginPolygon :: MonadIO m => Ptr GLUtesselator -> m () +gluBeginPolygon v1 = liftIO $ dyn_gluBeginPolygon ptr_gluBeginPolygon v1 + +foreign import CALLCONV "dynamic" dyn_gluBeginPolygon + :: FunPtr (Ptr GLUtesselator -> IO ()) + -> Ptr GLUtesselator -> IO () + +{-# NOINLINE ptr_gluBeginPolygon #-} +ptr_gluBeginPolygon :: FunPtr a +ptr_gluBeginPolygon = unsafePerformIO $ getAPIEntry "gluBeginPolygon" + +-- gluBeginSurface ---------------------------------------------------------------------- + +gluBeginSurface :: MonadIO m => Ptr GLUnurbs -> m () +gluBeginSurface v1 = liftIO $ dyn_gluBeginSurface ptr_gluBeginSurface v1 + +foreign import CALLCONV "dynamic" dyn_gluBeginSurface + :: FunPtr (Ptr GLUnurbs -> IO ()) + -> Ptr GLUnurbs -> IO () + +{-# NOINLINE ptr_gluBeginSurface #-} +ptr_gluBeginSurface :: FunPtr a +ptr_gluBeginSurface = unsafePerformIO $ getAPIEntry "gluBeginSurface" + +-- gluBeginTrim ---------------------------------------------------------------------- + +gluBeginTrim :: MonadIO m => Ptr GLUnurbs -> m () +gluBeginTrim v1 = liftIO $ dyn_gluBeginTrim ptr_gluBeginTrim v1 + +foreign import CALLCONV "dynamic" dyn_gluBeginTrim + :: FunPtr (Ptr GLUnurbs -> IO ()) + -> Ptr GLUnurbs -> IO () + +{-# NOINLINE ptr_gluBeginTrim #-} +ptr_gluBeginTrim :: FunPtr a +ptr_gluBeginTrim = unsafePerformIO $ getAPIEntry "gluBeginTrim" + +-- gluBuild1DMipmapLevels ---------------------------------------------------------------------- + +gluBuild1DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint +gluBuild1DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9 = liftIO $ dyn_gluBuild1DMipmapLevels ptr_gluBuild1DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9 + +foreign import CALLCONV "dynamic" dyn_gluBuild1DMipmapLevels + :: FunPtr (GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint) + -> GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint + +{-# NOINLINE ptr_gluBuild1DMipmapLevels #-} +ptr_gluBuild1DMipmapLevels :: FunPtr a +ptr_gluBuild1DMipmapLevels = unsafePerformIO $ getAPIEntry "gluBuild1DMipmapLevels" + +-- gluBuild1DMipmaps ---------------------------------------------------------------------- + +gluBuild1DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint +gluBuild1DMipmaps v1 v2 v3 v4 v5 v6 = liftIO $ dyn_gluBuild1DMipmaps ptr_gluBuild1DMipmaps v1 v2 v3 v4 v5 v6 + +foreign import CALLCONV "dynamic" dyn_gluBuild1DMipmaps + :: FunPtr (GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint) + -> GLenum -> GLint -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint + +{-# NOINLINE ptr_gluBuild1DMipmaps #-} +ptr_gluBuild1DMipmaps :: FunPtr a +ptr_gluBuild1DMipmaps = unsafePerformIO $ getAPIEntry "gluBuild1DMipmaps" + +-- gluBuild2DMipmapLevels ---------------------------------------------------------------------- + +gluBuild2DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint +gluBuild2DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 = liftIO $ dyn_gluBuild2DMipmapLevels ptr_gluBuild2DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 + +foreign import CALLCONV "dynamic" dyn_gluBuild2DMipmapLevels + :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint) + -> GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint + +{-# NOINLINE ptr_gluBuild2DMipmapLevels #-} +ptr_gluBuild2DMipmapLevels :: FunPtr a +ptr_gluBuild2DMipmapLevels = unsafePerformIO $ getAPIEntry "gluBuild2DMipmapLevels" + +-- gluBuild2DMipmaps ---------------------------------------------------------------------- + +gluBuild2DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint +gluBuild2DMipmaps v1 v2 v3 v4 v5 v6 v7 = liftIO $ dyn_gluBuild2DMipmaps ptr_gluBuild2DMipmaps v1 v2 v3 v4 v5 v6 v7 + +foreign import CALLCONV "dynamic" dyn_gluBuild2DMipmaps + :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint) + -> GLenum -> GLint -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint + +{-# NOINLINE ptr_gluBuild2DMipmaps #-} +ptr_gluBuild2DMipmaps :: FunPtr a +ptr_gluBuild2DMipmaps = unsafePerformIO $ getAPIEntry "gluBuild2DMipmaps" + +-- gluBuild3DMipmapLevels ---------------------------------------------------------------------- + +gluBuild3DMipmapLevels :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> m GLint +gluBuild3DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11= liftIO $ dyn_gluBuild3DMipmapLevels ptr_gluBuild3DMipmapLevels v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 + +foreign import CALLCONV "dynamic" dyn_gluBuild3DMipmapLevels + :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint) + -> GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> GLint -> GLint -> GLint -> Ptr a -> IO GLint + +{-# NOINLINE ptr_gluBuild3DMipmapLevels #-} +ptr_gluBuild3DMipmapLevels :: FunPtr a +ptr_gluBuild3DMipmapLevels = unsafePerformIO $ getAPIEntry "gluBuild3DMipmapLevels" + +-- gluBuild3DMipmaps ---------------------------------------------------------------------- + +gluBuild3DMipmaps :: MonadIO m => GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> m GLint +gluBuild3DMipmaps v1 v2 v3 v4 v5 v6 v7 v8 = liftIO $ dyn_gluBuild3DMipmaps ptr_gluBuild3DMipmaps v1 v2 v3 v4 v5 v6 v7 v8 + +foreign import CALLCONV "dynamic" dyn_gluBuild3DMipmaps + :: FunPtr (GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint) + -> GLenum -> GLint -> GLsizei -> GLsizei -> GLsizei -> GLenum -> GLenum -> Ptr a -> IO GLint + +{-# NOINLINE ptr_gluBuild3DMipmaps #-} +ptr_gluBuild3DMipmaps :: FunPtr a +ptr_gluBuild3DMipmaps = unsafePerformIO $ getAPIEntry "gluBuild3DMipmaps" + +-- gluCheckExtension ---------------------------------------------------------------------- + +gluCheckExtension :: MonadIO m => Ptr GLubyte -> Ptr GLubyte -> m GLboolean +gluCheckExtension v1 v2 = liftIO $ dyn_gluCheckExtension ptr_gluCheckExtension v1 v2 + +foreign import CALLCONV "dynamic" dyn_gluCheckExtension + :: FunPtr (Ptr GLubyte -> Ptr GLubyte -> IO GLboolean) + -> Ptr GLubyte -> Ptr GLubyte -> IO GLboolean + +{-# NOINLINE ptr_gluCheckExtension #-} +ptr_gluCheckExtension :: FunPtr a +ptr_gluCheckExtension = unsafePerformIO $ getAPIEntry "gluCheckExtension" + +-- gluCylinder ---------------------------------------------------------------------- + +gluCylinder :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> m () +gluCylinder v1 v2 v3 v4 v5 v6 = liftIO $ dyn_gluCylinder ptr_gluCylinder v1 v2 v3 v4 v5 v6 + +foreign import CALLCONV "dynamic" dyn_gluCylinder + :: FunPtr (Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()) + -> Ptr GLUquadric -> GLdouble -> GLdouble -> GLdouble -> GLint -> GLint -> IO () + +{-# NOINLINE ptr_gluCylinder #-} +ptr_gluCylinder :: FunPtr a +ptr_gluCylinder = unsafePerformIO $ getAPIEntry "gluCylinder" + +-- gluDeleteNurbsRenderer ---------------------------------------------------------------------- + +gluDeleteNurbsRenderer :: MonadIO m => Ptr GLUnurbs -> m () +gluDeleteNurbsRenderer v1 = liftIO $ dyn_gluDeleteNurbsRenderer ptr_gluDeleteNurbsRenderer v1 + +foreign import CALLCONV "dynamic" dyn_gluDeleteNurbsRenderer + :: FunPtr (Ptr GLUnurbs -> IO ()) + -> Ptr GLUnurbs -> IO () + +{-# NOINLINE ptr_gluDeleteNurbsRenderer #-} +ptr_gluDeleteNurbsRenderer :: FunPtr a +ptr_gluDeleteNurbsRenderer = unsafePerformIO $ getAPIEntry "gluDeleteNurbsRenderer" + +-- gluDeleteQuadric ---------------------------------------------------------------------- + +gluDeleteQuadric :: MonadIO m => Ptr GLUquadric -> m () +gluDeleteQuadric v1 = liftIO $ dyn_gluDeleteQuadric ptr_gluDeleteQuadric v1 + +foreign import CALLCONV "dynamic" dyn_gluDeleteQuadric + :: FunPtr (Ptr GLUquadric -> IO ()) + -> Ptr GLUquadric -> IO () + +{-# NOINLINE ptr_gluDeleteQuadric #-} +ptr_gluDeleteQuadric :: FunPtr a +ptr_gluDeleteQuadric = unsafePerformIO $ getAPIEntry "gluDeleteQuadric" + +-- gluDeleteTess ---------------------------------------------------------------------- + +gluDeleteTess :: MonadIO m => Ptr GLUtesselator -> m () +gluDeleteTess v1 = liftIO $ dyn_gluDeleteTess ptr_gluDeleteTess v1 + +foreign import CALLCONV "dynamic" dyn_gluDeleteTess + :: FunPtr (Ptr GLUtesselator -> IO ()) + -> Ptr GLUtesselator -> IO () + +{-# NOINLINE ptr_gluDeleteTess #-} +ptr_gluDeleteTess :: FunPtr a +ptr_gluDeleteTess = unsafePerformIO $ getAPIEntry "gluDeleteTess" + +-- gluDisk ---------------------------------------------------------------------- + +gluDisk :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> m () +gluDisk v1 v2 v3 v4 v5 = liftIO $ dyn_gluDisk ptr_gluDisk v1 v2 v3 v4 v5 + +foreign import CALLCONV "dynamic" dyn_gluDisk + :: FunPtr (Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()) + -> Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> IO () + +{-# NOINLINE ptr_gluDisk #-} +ptr_gluDisk :: FunPtr a +ptr_gluDisk = unsafePerformIO $ getAPIEntry "gluDisk" + +-- gluEndCurve ---------------------------------------------------------------------- + +gluEndCurve :: MonadIO m => Ptr GLUnurbs -> m () +gluEndCurve v1 = liftIO $ dyn_gluEndCurve ptr_gluEndCurve v1 + +foreign import CALLCONV "dynamic" dyn_gluEndCurve + :: FunPtr (Ptr GLUnurbs -> IO ()) + -> Ptr GLUnurbs -> IO () + +{-# NOINLINE ptr_gluEndCurve #-} +ptr_gluEndCurve :: FunPtr a +ptr_gluEndCurve = unsafePerformIO $ getAPIEntry "gluEndCurve" + +-- gluEndPolygon ---------------------------------------------------------------------- + +gluEndPolygon :: MonadIO m => Ptr GLUtesselator -> m () +gluEndPolygon v1 = liftIO $ dyn_gluEndPolygon ptr_gluEndPolygon v1 + +foreign import CALLCONV "dynamic" dyn_gluEndPolygon + :: FunPtr (Ptr GLUtesselator -> IO ()) + -> Ptr GLUtesselator -> IO () + +{-# NOINLINE ptr_gluEndPolygon #-} +ptr_gluEndPolygon :: FunPtr a +ptr_gluEndPolygon = unsafePerformIO $ getAPIEntry "gluEndPolygon" + +-- gluEndSurface ---------------------------------------------------------------------- + +gluEndSurface :: MonadIO m => Ptr GLUnurbs -> m () +gluEndSurface v1 = liftIO $ dyn_gluEndSurface ptr_gluEndSurface v1 + +foreign import CALLCONV "dynamic" dyn_gluEndSurface + :: FunPtr (Ptr GLUnurbs -> IO ()) + -> Ptr GLUnurbs -> IO () + +{-# NOINLINE ptr_gluEndSurface #-} +ptr_gluEndSurface :: FunPtr a +ptr_gluEndSurface = unsafePerformIO $ getAPIEntry "gluEndSurface" + +-- gluEndTrim ---------------------------------------------------------------------- + +gluEndTrim :: MonadIO m => Ptr GLUnurbs -> m () +gluEndTrim v1 = liftIO $ dyn_gluEndTrim ptr_gluEndTrim v1 + +foreign import CALLCONV "dynamic" dyn_gluEndTrim + :: FunPtr (Ptr GLUnurbs -> IO ()) + -> Ptr GLUnurbs -> IO () + +{-# NOINLINE ptr_gluEndTrim #-} +ptr_gluEndTrim :: FunPtr a +ptr_gluEndTrim = unsafePerformIO $ getAPIEntry "gluEndTrim" + +-- gluErrorString ---------------------------------------------------------------------- + +gluErrorString :: MonadIO m => GLenum -> m (Ptr GLubyte) +gluErrorString v1 = liftIO $ dyn_gluErrorString ptr_gluErrorString v1 + +foreign import CALLCONV "dynamic" dyn_gluErrorString + :: FunPtr (GLenum -> IO (Ptr GLubyte)) + -> GLenum -> IO (Ptr GLubyte) + +{-# NOINLINE ptr_gluErrorString #-} +ptr_gluErrorString :: FunPtr a +ptr_gluErrorString = unsafePerformIO $ getAPIEntry "gluErrorString" + +-- gluGetNurbsProperty ---------------------------------------------------------------------- + +gluGetNurbsProperty :: MonadIO m => Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> m () +gluGetNurbsProperty v1 v2 v3 = liftIO $ dyn_gluGetNurbsProperty ptr_gluGetNurbsProperty v1 v2 v3 + +foreign import CALLCONV "dynamic" dyn_gluGetNurbsProperty + :: FunPtr (Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO ()) + -> Ptr GLUnurbs -> GLenum -> Ptr GLfloat -> IO () + +{-# NOINLINE ptr_gluGetNurbsProperty #-} +ptr_gluGetNurbsProperty :: FunPtr a +ptr_gluGetNurbsProperty = unsafePerformIO $ getAPIEntry "gluGetNurbsProperty" + +-- gluGetString ---------------------------------------------------------------------- + +gluGetString :: MonadIO m => GLenum -> m (Ptr GLubyte) +gluGetString v1 = liftIO $ dyn_gluGetString ptr_gluGetString v1 + +foreign import CALLCONV "dynamic" dyn_gluGetString + :: FunPtr (GLenum -> IO (Ptr GLubyte)) + -> GLenum -> IO (Ptr GLubyte) + +{-# NOINLINE ptr_gluGetString #-} +ptr_gluGetString :: FunPtr a +ptr_gluGetString = unsafePerformIO $ getAPIEntry "gluGetString" + +-- gluGetTessProperty ---------------------------------------------------------------------- + +gluGetTessProperty :: MonadIO m => Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> m () +gluGetTessProperty v1 v2 v3 = liftIO $ dyn_gluGetTessProperty ptr_gluGetTessProperty v1 v2 v3 + +foreign import CALLCONV "dynamic" dyn_gluGetTessProperty + :: FunPtr (Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO ()) + -> Ptr GLUtesselator -> GLenum -> Ptr GLdouble -> IO () + +{-# NOINLINE ptr_gluGetTessProperty #-} +ptr_gluGetTessProperty :: FunPtr a +ptr_gluGetTessProperty = unsafePerformIO $ getAPIEntry "gluGetTessProperty" + +-- gluLoadSamplingMatrices ---------------------------------------------------------------------- + +gluLoadSamplingMatrices :: MonadIO m => Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> m () +gluLoadSamplingMatrices v1 v2 v3 v4 = liftIO $ dyn_gluLoadSamplingMatrices ptr_gluLoadSamplingMatrices v1 v2 v3 v4 + +foreign import CALLCONV "dynamic" dyn_gluLoadSamplingMatrices + :: FunPtr (Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO ()) + -> Ptr GLUnurbs -> Ptr GLfloat -> Ptr GLfloat -> Ptr GLint -> IO () + +{-# NOINLINE ptr_gluLoadSamplingMatrices #-} +ptr_gluLoadSamplingMatrices :: FunPtr a +ptr_gluLoadSamplingMatrices = unsafePerformIO $ getAPIEntry "gluLoadSamplingMatrices" + +-- gluLookAt ---------------------------------------------------------------------- + +gluLookAt :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> m () +gluLookAt v1 v2 v3 v4 v5 v6 v7 v8 v9 = liftIO $ dyn_gluLookAt ptr_gluLookAt v1 v2 v3 v4 v5 v6 v7 v8 v9 + +foreign import CALLCONV "dynamic" dyn_gluLookAt + :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) + -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO () + +{-# NOINLINE ptr_gluLookAt #-} +ptr_gluLookAt :: FunPtr a +ptr_gluLookAt = unsafePerformIO $ getAPIEntry "gluLookAt" + +-- gluNewNurbsRenderer ---------------------------------------------------------------------- + +gluNewNurbsRenderer :: MonadIO m => m (Ptr GLUnurbs) +gluNewNurbsRenderer = liftIO $ dyn_gluNewNurbsRenderer ptr_gluNewNurbsRenderer + +foreign import CALLCONV "dynamic" dyn_gluNewNurbsRenderer + :: FunPtr (IO (Ptr GLUnurbs)) + -> IO (Ptr GLUnurbs) + +{-# NOINLINE ptr_gluNewNurbsRenderer #-} +ptr_gluNewNurbsRenderer :: FunPtr a +ptr_gluNewNurbsRenderer = unsafePerformIO $ getAPIEntry "gluNewNurbsRenderer" + +-- gluNewQuadric ---------------------------------------------------------------------- + +gluNewQuadric :: MonadIO m => m (Ptr GLUquadric) +gluNewQuadric = liftIO $ dyn_gluNewQuadric ptr_gluNewQuadric + +foreign import CALLCONV "dynamic" dyn_gluNewQuadric + :: FunPtr (IO (Ptr GLUquadric)) + -> IO (Ptr GLUquadric) + +{-# NOINLINE ptr_gluNewQuadric #-} +ptr_gluNewQuadric :: FunPtr a +ptr_gluNewQuadric = unsafePerformIO $ getAPIEntry "gluNewQuadric" + +-- gluNewTess ---------------------------------------------------------------------- + +gluNewTess :: MonadIO m => m (Ptr GLUtesselator) +gluNewTess = liftIO $ dyn_gluNewTess ptr_gluNewTess + +foreign import CALLCONV "dynamic" dyn_gluNewTess + :: FunPtr (IO (Ptr GLUtesselator)) + -> IO (Ptr GLUtesselator) + +{-# NOINLINE ptr_gluNewTess #-} +ptr_gluNewTess :: FunPtr a +ptr_gluNewTess = unsafePerformIO $ getAPIEntry "gluNewTess" + +-- gluNextContour ---------------------------------------------------------------------- + +gluNextContour :: MonadIO m => Ptr GLUtesselator -> GLenum -> m () +gluNextContour v1 v2 = liftIO $ dyn_gluNextContour ptr_gluNextContour v1 v2 + +foreign import CALLCONV "dynamic" dyn_gluNextContour + :: FunPtr (Ptr GLUtesselator -> GLenum -> IO ()) + -> Ptr GLUtesselator -> GLenum -> IO () + +{-# NOINLINE ptr_gluNextContour #-} +ptr_gluNextContour :: FunPtr a +ptr_gluNextContour = unsafePerformIO $ getAPIEntry "gluNextContour" + +-- gluNurbsCallback ---------------------------------------------------------------------- + +gluNurbsCallback :: MonadIO m => Ptr GLUnurbs -> GLenum -> FunPtr a -> m () +gluNurbsCallback v1 v2 v3 = liftIO $ dyn_gluNurbsCallback ptr_gluNurbsCallback v1 v2 v3 + +foreign import CALLCONV "dynamic" dyn_gluNurbsCallback + :: FunPtr (Ptr GLUnurbs -> GLenum -> FunPtr a -> IO ()) + -> Ptr GLUnurbs -> GLenum -> FunPtr a -> IO () + +{-# NOINLINE ptr_gluNurbsCallback #-} +ptr_gluNurbsCallback :: FunPtr a +ptr_gluNurbsCallback = unsafePerformIO $ getAPIEntry "gluNurbsCallback" + +-- gluNurbsCallbackData ---------------------------------------------------------------------- + +gluNurbsCallbackData :: MonadIO m => Ptr GLUnurbs -> Ptr a -> m () +gluNurbsCallbackData v1 v2 = liftIO $ dyn_gluNurbsCallbackData ptr_gluNurbsCallbackData v1 v2 + +foreign import CALLCONV "dynamic" dyn_gluNurbsCallbackData + :: FunPtr (Ptr GLUnurbs -> Ptr a -> IO ()) + -> Ptr GLUnurbs -> Ptr a -> IO () + +{-# NOINLINE ptr_gluNurbsCallbackData #-} +ptr_gluNurbsCallbackData :: FunPtr a +ptr_gluNurbsCallbackData = unsafePerformIO $ getAPIEntry "gluNurbsCallbackData" + +-- gluNurbsCallbackDataEXT ---------------------------------------------------------------------- + +gluNurbsCallbackDataEXT :: MonadIO m => Ptr GLUnurbs -> Ptr a -> m () +gluNurbsCallbackDataEXT v1 v2 = liftIO $ dyn_gluNurbsCallbackDataEXT ptr_gluNurbsCallbackDataEXT v1 v2 + +foreign import CALLCONV "dynamic" dyn_gluNurbsCallbackDataEXT + :: FunPtr (Ptr GLUnurbs -> Ptr a -> IO ()) + -> Ptr GLUnurbs -> Ptr a -> IO () + +{-# NOINLINE ptr_gluNurbsCallbackDataEXT #-} +ptr_gluNurbsCallbackDataEXT :: FunPtr a +ptr_gluNurbsCallbackDataEXT = unsafePerformIO $ getAPIEntry "gluNurbsCallbackDataEXT" + +-- gluNurbsCurve ---------------------------------------------------------------------- + +gluNurbsCurve :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> m () +gluNurbsCurve v1 v2 v3 v4 v5 v6 v7 = liftIO $ dyn_gluNurbsCurve ptr_gluNurbsCurve v1 v2 v3 v4 v5 v6 v7 + +foreign import CALLCONV "dynamic" dyn_gluNurbsCurve + :: FunPtr (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ()) + -> Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO () + +{-# NOINLINE ptr_gluNurbsCurve #-} +ptr_gluNurbsCurve :: FunPtr a +ptr_gluNurbsCurve = unsafePerformIO $ getAPIEntry "gluNurbsCurve" + +-- gluNurbsProperty ---------------------------------------------------------------------- + +gluNurbsProperty :: MonadIO m => Ptr GLUnurbs -> GLenum -> GLfloat -> m () +gluNurbsProperty v1 v2 v3 = liftIO $ dyn_gluNurbsProperty ptr_gluNurbsProperty v1 v2 v3 + +foreign import CALLCONV "dynamic" dyn_gluNurbsProperty + :: FunPtr (Ptr GLUnurbs -> GLenum -> GLfloat -> IO ()) + -> Ptr GLUnurbs -> GLenum -> GLfloat -> IO () + +{-# NOINLINE ptr_gluNurbsProperty #-} +ptr_gluNurbsProperty :: FunPtr a +ptr_gluNurbsProperty = unsafePerformIO $ getAPIEntry "gluNurbsProperty" + +-- gluNurbsSurface ---------------------------------------------------------------------- + +gluNurbsSurface :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> m () +gluNurbsSurface v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 = liftIO $ dyn_gluNurbsSurface ptr_gluNurbsSurface v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 + +foreign import CALLCONV "dynamic" dyn_gluNurbsSurface + :: FunPtr (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> IO ()) + -> Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> Ptr GLfloat -> GLint -> GLint -> Ptr GLfloat -> GLint -> GLint -> GLenum -> IO () + +{-# NOINLINE ptr_gluNurbsSurface #-} +ptr_gluNurbsSurface :: FunPtr a +ptr_gluNurbsSurface = unsafePerformIO $ getAPIEntry "gluNurbsSurface" + +-- gluOrtho2D ---------------------------------------------------------------------- + +gluOrtho2D :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> m () +gluOrtho2D v1 v2 v3 v4 = liftIO $ dyn_gluOrtho2D ptr_gluOrtho2D v1 v2 v3 v4 + +foreign import CALLCONV "dynamic" dyn_gluOrtho2D + :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) + -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO () + +{-# NOINLINE ptr_gluOrtho2D #-} +ptr_gluOrtho2D :: FunPtr a +ptr_gluOrtho2D = unsafePerformIO $ getAPIEntry "gluOrtho2D" + +-- gluPartialDisk ---------------------------------------------------------------------- + +gluPartialDisk :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> m () +gluPartialDisk v1 v2 v3 v4 v5 v6 v7 = liftIO $ dyn_gluPartialDisk ptr_gluPartialDisk v1 v2 v3 v4 v5 v6 v7 + +foreign import CALLCONV "dynamic" dyn_gluPartialDisk + :: FunPtr (Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> IO ()) + -> Ptr GLUquadric -> GLdouble -> GLdouble -> GLint -> GLint -> GLdouble -> GLdouble -> IO () + +{-# NOINLINE ptr_gluPartialDisk #-} +ptr_gluPartialDisk :: FunPtr a +ptr_gluPartialDisk = unsafePerformIO $ getAPIEntry "gluPartialDisk" + +-- gluPerspective ---------------------------------------------------------------------- + +gluPerspective :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> m () +gluPerspective v1 v2 v3 v4 = liftIO $ dyn_gluPerspective ptr_gluPerspective v1 v2 v3 v4 + +foreign import CALLCONV "dynamic" dyn_gluPerspective + :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO ()) + -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> IO () + +{-# NOINLINE ptr_gluPerspective #-} +ptr_gluPerspective :: FunPtr a +ptr_gluPerspective = unsafePerformIO $ getAPIEntry "gluPerspective" + +-- gluPickMatrix ---------------------------------------------------------------------- + +gluPickMatrix :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> m () +gluPickMatrix v1 v2 v3 v4 v5 = liftIO $ dyn_gluPickMatrix ptr_gluPickMatrix v1 v2 v3 v4 v5 + +foreign import CALLCONV "dynamic" dyn_gluPickMatrix + :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO ()) + -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLint -> IO () + +{-# NOINLINE ptr_gluPickMatrix #-} +ptr_gluPickMatrix :: FunPtr a +ptr_gluPickMatrix = unsafePerformIO $ getAPIEntry "gluPickMatrix" + +-- gluProject ---------------------------------------------------------------------- + +gluProject :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> m GLint +gluProject v1 v2 v3 v4 v5 v6 v7 v8 v9 = liftIO $ dyn_gluProject ptr_gluProject v1 v2 v3 v4 v5 v6 v7 v8 v9 + +foreign import CALLCONV "dynamic" dyn_gluProject + :: FunPtr (GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint) + -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint + +{-# NOINLINE ptr_gluProject #-} +ptr_gluProject :: FunPtr a +ptr_gluProject = unsafePerformIO $ getAPIEntry "gluProject" + +-- gluPwlCurve ---------------------------------------------------------------------- + +gluPwlCurve :: MonadIO m => Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> m () +gluPwlCurve v1 v2 v3 v4 v5 = liftIO $ dyn_gluPwlCurve ptr_gluPwlCurve v1 v2 v3 v4 v5 + +foreign import CALLCONV "dynamic" dyn_gluPwlCurve + :: FunPtr (Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO ()) + -> Ptr GLUnurbs -> GLint -> Ptr GLfloat -> GLint -> GLenum -> IO () + +{-# NOINLINE ptr_gluPwlCurve #-} +ptr_gluPwlCurve :: FunPtr a +ptr_gluPwlCurve = unsafePerformIO $ getAPIEntry "gluPwlCurve" + +-- gluQuadricCallback ---------------------------------------------------------------------- + +gluQuadricCallback :: MonadIO m => Ptr GLUquadric -> GLenum -> FunPtr a -> m () +gluQuadricCallback v1 v2 v3 = liftIO $ dyn_gluQuadricCallback ptr_gluQuadricCallback v1 v2 v3 + +foreign import CALLCONV "dynamic" dyn_gluQuadricCallback + :: FunPtr (Ptr GLUquadric -> GLenum -> FunPtr a -> IO ()) + -> Ptr GLUquadric -> GLenum -> FunPtr a -> IO () + +{-# NOINLINE ptr_gluQuadricCallback #-} +ptr_gluQuadricCallback :: FunPtr a +ptr_gluQuadricCallback = unsafePerformIO $ getAPIEntry "gluQuadricCallback" + +-- gluQuadricDrawStyle ---------------------------------------------------------------------- + +gluQuadricDrawStyle :: MonadIO m => Ptr GLUquadric -> GLenum -> m () +gluQuadricDrawStyle v1 v2 = liftIO $ dyn_gluQuadricDrawStyle ptr_gluQuadricDrawStyle v1 v2 + +foreign import CALLCONV "dynamic" dyn_gluQuadricDrawStyle + :: FunPtr (Ptr GLUquadric -> GLenum -> IO ()) + -> Ptr GLUquadric -> GLenum -> IO () + +{-# NOINLINE ptr_gluQuadricDrawStyle #-} +ptr_gluQuadricDrawStyle :: FunPtr a +ptr_gluQuadricDrawStyle = unsafePerformIO $ getAPIEntry "gluQuadricDrawStyle" + +-- gluQuadricNormals ---------------------------------------------------------------------- + +gluQuadricNormals :: MonadIO m => Ptr GLUquadric -> GLenum -> m () +gluQuadricNormals v1 v2 = liftIO $ dyn_gluQuadricNormals ptr_gluQuadricNormals v1 v2 + +foreign import CALLCONV "dynamic" dyn_gluQuadricNormals + :: FunPtr (Ptr GLUquadric -> GLenum -> IO ()) + -> Ptr GLUquadric -> GLenum -> IO () + +{-# NOINLINE ptr_gluQuadricNormals #-} +ptr_gluQuadricNormals :: FunPtr a +ptr_gluQuadricNormals = unsafePerformIO $ getAPIEntry "gluQuadricNormals" + +-- gluQuadricOrientation ---------------------------------------------------------------------- + +gluQuadricOrientation :: MonadIO m => Ptr GLUquadric -> GLenum -> m () +gluQuadricOrientation v1 v2 = liftIO $ dyn_gluQuadricOrientation ptr_gluQuadricOrientation v1 v2 + +foreign import CALLCONV "dynamic" dyn_gluQuadricOrientation + :: FunPtr (Ptr GLUquadric -> GLenum -> IO ()) + -> Ptr GLUquadric -> GLenum -> IO () + +{-# NOINLINE ptr_gluQuadricOrientation #-} +ptr_gluQuadricOrientation :: FunPtr a +ptr_gluQuadricOrientation = unsafePerformIO $ getAPIEntry "gluQuadricOrientation" + +-- gluQuadricTexture ---------------------------------------------------------------------- + +gluQuadricTexture :: MonadIO m => Ptr GLUquadric -> GLboolean -> m () +gluQuadricTexture v1 v2 = liftIO $ dyn_gluQuadricTexture ptr_gluQuadricTexture v1 v2 + +foreign import CALLCONV "dynamic" dyn_gluQuadricTexture + :: FunPtr (Ptr GLUquadric -> GLboolean -> IO ()) + -> Ptr GLUquadric -> GLboolean -> IO () + +{-# NOINLINE ptr_gluQuadricTexture #-} +ptr_gluQuadricTexture :: FunPtr a +ptr_gluQuadricTexture = unsafePerformIO $ getAPIEntry "gluQuadricTexture" + +-- gluScaleImage ---------------------------------------------------------------------- + +gluScaleImage :: MonadIO m => GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> m GLint +gluScaleImage v1 v2 v3 v4 v5 v6 v7 v8 v9 = liftIO $ dyn_gluScaleImage ptr_gluScaleImage v1 v2 v3 v4 v5 v6 v7 v8 v9 + +foreign import CALLCONV "dynamic" dyn_gluScaleImage + :: FunPtr (GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> IO GLint) + -> GLenum -> GLsizei -> GLsizei -> GLenum -> Ptr a -> GLsizei -> GLsizei -> GLenum -> Ptr b -> IO GLint + +{-# NOINLINE ptr_gluScaleImage #-} +ptr_gluScaleImage :: FunPtr a +ptr_gluScaleImage = unsafePerformIO $ getAPIEntry "gluScaleImage" + +-- gluSphere ---------------------------------------------------------------------- + +gluSphere :: MonadIO m => Ptr GLUquadric -> GLdouble -> GLint -> GLint -> m () +gluSphere v1 v2 v3 v4 = liftIO $ dyn_gluSphere ptr_gluSphere v1 v2 v3 v4 + +foreign import CALLCONV "dynamic" dyn_gluSphere + :: FunPtr (Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO ()) + -> Ptr GLUquadric -> GLdouble -> GLint -> GLint -> IO () + +{-# NOINLINE ptr_gluSphere #-} +ptr_gluSphere :: FunPtr a +ptr_gluSphere = unsafePerformIO $ getAPIEntry "gluSphere" + +-- gluTessBeginContour ---------------------------------------------------------------------- + +gluTessBeginContour :: MonadIO m => Ptr GLUtesselator -> m () +gluTessBeginContour v1 = liftIO $ dyn_gluTessBeginContour ptr_gluTessBeginContour v1 + +foreign import CALLCONV "dynamic" dyn_gluTessBeginContour + :: FunPtr (Ptr GLUtesselator -> IO ()) + -> Ptr GLUtesselator -> IO () + +{-# NOINLINE ptr_gluTessBeginContour #-} +ptr_gluTessBeginContour :: FunPtr a +ptr_gluTessBeginContour = unsafePerformIO $ getAPIEntry "gluTessBeginContour" + +-- gluTessBeginPolygon ---------------------------------------------------------------------- + +gluTessBeginPolygon :: MonadIO m => Ptr GLUtesselator -> Ptr a -> m () +gluTessBeginPolygon v1 v2 = liftIO $ dyn_gluTessBeginPolygon ptr_gluTessBeginPolygon v1 v2 + +foreign import CALLCONV "dynamic" dyn_gluTessBeginPolygon + :: FunPtr (Ptr GLUtesselator -> Ptr a -> IO ()) + -> Ptr GLUtesselator -> Ptr a -> IO () + +{-# NOINLINE ptr_gluTessBeginPolygon #-} +ptr_gluTessBeginPolygon :: FunPtr a +ptr_gluTessBeginPolygon = unsafePerformIO $ getAPIEntry "gluTessBeginPolygon" + +-- gluTessCallback ---------------------------------------------------------------------- + +gluTessCallback :: MonadIO m => Ptr GLUtesselator -> GLenum -> FunPtr a -> m () +gluTessCallback v1 v2 v3 = liftIO $ dyn_gluTessCallback ptr_gluTessCallback v1 v2 v3 + +foreign import CALLCONV "dynamic" dyn_gluTessCallback + :: FunPtr (Ptr GLUtesselator -> GLenum -> FunPtr a -> IO ()) + -> Ptr GLUtesselator -> GLenum -> FunPtr a -> IO () + +{-# NOINLINE ptr_gluTessCallback #-} +ptr_gluTessCallback :: FunPtr a +ptr_gluTessCallback = unsafePerformIO $ getAPIEntry "gluTessCallback" + +-- gluTessEndContour ---------------------------------------------------------------------- + +gluTessEndContour :: MonadIO m => Ptr GLUtesselator -> m () +gluTessEndContour v1 = liftIO $ dyn_gluTessEndContour ptr_gluTessEndContour v1 + +foreign import CALLCONV "dynamic" dyn_gluTessEndContour + :: FunPtr (Ptr GLUtesselator -> IO ()) + -> Ptr GLUtesselator -> IO () + +{-# NOINLINE ptr_gluTessEndContour #-} +ptr_gluTessEndContour :: FunPtr a +ptr_gluTessEndContour = unsafePerformIO $ getAPIEntry "gluTessEndContour" + +-- gluTessEndPolygon ---------------------------------------------------------------------- + +gluTessEndPolygon :: MonadIO m => Ptr GLUtesselator -> m () +gluTessEndPolygon v1 = liftIO $ dyn_gluTessEndPolygon ptr_gluTessEndPolygon v1 + +foreign import CALLCONV "dynamic" dyn_gluTessEndPolygon + :: FunPtr (Ptr GLUtesselator -> IO ()) + -> Ptr GLUtesselator -> IO () + +{-# NOINLINE ptr_gluTessEndPolygon #-} +ptr_gluTessEndPolygon :: FunPtr a +ptr_gluTessEndPolygon = unsafePerformIO $ getAPIEntry "gluTessEndPolygon" + +-- gluTessNormal ---------------------------------------------------------------------- + +gluTessNormal :: MonadIO m => Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> m () +gluTessNormal v1 v2 v3 v4 = liftIO $ dyn_gluTessNormal ptr_gluTessNormal v1 v2 v3 v4 + +foreign import CALLCONV "dynamic" dyn_gluTessNormal + :: FunPtr (Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO ()) + -> Ptr GLUtesselator -> GLdouble -> GLdouble -> GLdouble -> IO () + +{-# NOINLINE ptr_gluTessNormal #-} +ptr_gluTessNormal :: FunPtr a +ptr_gluTessNormal = unsafePerformIO $ getAPIEntry "gluTessNormal" + +-- gluTessProperty ---------------------------------------------------------------------- + +gluTessProperty :: MonadIO m => Ptr GLUtesselator -> GLenum -> GLdouble -> m () +gluTessProperty v1 v2 v3 = liftIO $ dyn_gluTessProperty ptr_gluTessProperty v1 v2 v3 + +foreign import CALLCONV "dynamic" dyn_gluTessProperty + :: FunPtr (Ptr GLUtesselator -> GLenum -> GLdouble -> IO ()) + -> Ptr GLUtesselator -> GLenum -> GLdouble -> IO () + +{-# NOINLINE ptr_gluTessProperty #-} +ptr_gluTessProperty :: FunPtr a +ptr_gluTessProperty = unsafePerformIO $ getAPIEntry "gluTessProperty" + +-- gluTessVertex ---------------------------------------------------------------------- + +gluTessVertex :: MonadIO m => Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> m () +gluTessVertex v1 v2 v3 = liftIO $ dyn_gluTessVertex ptr_gluTessVertex v1 v2 v3 + +foreign import CALLCONV "dynamic" dyn_gluTessVertex + :: FunPtr (Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO ()) + -> Ptr GLUtesselator -> Ptr GLdouble -> Ptr a -> IO () + +{-# NOINLINE ptr_gluTessVertex #-} +ptr_gluTessVertex :: FunPtr a +ptr_gluTessVertex = unsafePerformIO $ getAPIEntry "gluTessVertex" + +-- gluUnProject ---------------------------------------------------------------------- + +gluUnProject :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> m GLint +gluUnProject v1 v2 v3 v4 v5 v6 v7 v8 v9 = liftIO $ dyn_gluUnProject ptr_gluUnProject v1 v2 v3 v4 v5 v6 v7 v8 v9 + +foreign import CALLCONV "dynamic" dyn_gluUnProject + :: FunPtr (GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint) + -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint + +{-# NOINLINE ptr_gluUnProject #-} +ptr_gluUnProject :: FunPtr a +ptr_gluUnProject = unsafePerformIO $ getAPIEntry "gluUnProject" + +-- gluUnProject4 ---------------------------------------------------------------------- + +gluUnProject4 :: MonadIO m => GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> GLclampd -> GLclampd -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> m GLint +gluUnProject4 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 = liftIO $ dyn_gluUnProject4 ptr_gluUnProject4 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 + +foreign import CALLCONV "dynamic" dyn_gluUnProject4 + :: FunPtr (GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> GLclampd -> GLclampd -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint) + -> GLdouble -> GLdouble -> GLdouble -> GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLint -> GLclampd -> GLclampd -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> Ptr GLdouble -> IO GLint + +{-# NOINLINE ptr_gluUnProject4 #-} +ptr_gluUnProject4 :: FunPtr a +ptr_gluUnProject4 = unsafePerformIO $ getAPIEntry "gluUnProject4"
