{-# LANGUAGE CPP #-}
{-# OPTIONS_HADDOCK hide #-}
--------------------------------------------------------------------------------
-- |
-- Module      :  Graphics.UI.GLUT.Raw.Functions
-- Copyright   :  (c) Sven Panne 2018
-- License     :  BSD3
--
-- Maintainer  :  Sven Panne <svenpanne@gmail.com>
-- Stability   :  stable
-- Portability :  portable
--
-- All raw functions from GLUT and freeglut.
--
--------------------------------------------------------------------------------

module Graphics.UI.GLUT.Raw.Functions (
   isKnown,

   glutAddMenuEntry,
   glutAddSubMenu,
   glutAppStatusFunc,
   glutAttachMenu,
   glutBitmapCharacter,
   glutBitmapHeight,
   glutBitmapLength,
   glutBitmapString,
   glutBitmapWidth,
   glutButtonBoxFunc,
   glutChangeToMenuEntry,
   glutChangeToSubMenu,
   glutCloseFunc,
   glutCopyColormap,
   glutCreateMenu,
   glutCreateSubWindow,
   glutCreateWindow,
   glutDestroyMenu,
   glutDestroyWindow,
   glutDetachMenu,
   glutDeviceGet,
   glutDialsFunc,
   glutDisplayFunc,
   glutEnterGameMode,
   glutEntryFunc,
   glutEstablishOverlay,
   glutExit,
   glutExtensionSupported,
   glutForceJoystickFunc,
   glutFullScreen,
   glutFullScreenToggle,
   glutGameModeGet,
   glutGameModeString,
   glutGet,
   glutGetColor,
   glutGetMenu,
   glutGetMenuData,
   glutGetModeValues,
   glutGetModifiers,
   glutGetProcAddress,
   glutGetWindow,
   glutGetWindowData,
   glutHideOverlay,
   glutHideWindow,
   glutIconifyWindow,
   glutIdleFunc,
   glutIgnoreKeyRepeat,
   glutInit,
   glutInitContextFlags,
   glutInitContextFunc,
   glutInitContextProfile,
   glutInitContextVersion,
   glutInitDisplayMode,
   glutInitDisplayString,
   glutInitWindowPosition,
   glutInitWindowSize,
   glutJoystickFunc,
   glutKeyboardFunc,
   glutKeyboardUpFunc,
   glutLayerGet,
   glutLeaveFullScreen,
   glutLeaveGameMode,
   glutLeaveMainLoop,
   glutMainLoop,
   glutMainLoopEvent,
   glutMenuDestroyFunc,
   glutMenuStateFunc,
   glutMenuStatusFunc,
   glutMotionFunc,
   glutMouseFunc,
   glutMouseWheelFunc,
   glutMultiButtonFunc,
   glutMultiEntryFunc,
   glutMultiMotionFunc,
   glutMultiPassiveFunc,
   glutOverlayDisplayFunc,
   glutPassiveMotionFunc,
   glutPopWindow,
   glutPositionFunc,
   glutPositionWindow,
   glutPostOverlayRedisplay,
   glutPostRedisplay,
   glutPostWindowOverlayRedisplay,
   glutPostWindowRedisplay,
   glutPushWindow,
   glutRemoveMenuItem,
   glutRemoveOverlay,
   glutReportErrors,
   glutReshapeFunc,
   glutReshapeWindow,
   glutSetColor,
   glutSetCursor,
   glutSetIconTitle,
   glutSetKeyRepeat,
   glutSetMenu,
   glutSetMenuData,
   glutSetMenuFont,
   glutSetOption,
   glutSetVertexAttribCoord3,
   glutSetVertexAttribNormal,
   glutSetVertexAttribTexCoord2,
   glutSetWindow,
   glutSetWindowData,
   glutSetWindowTitle,
   glutSetupVideoResizing,
   glutShowOverlay,
   glutShowWindow,
   glutSolidCone,
   glutSolidCube,
   glutSolidCylinder,
   glutSolidDodecahedron,
   glutSolidIcosahedron,
   glutSolidOctahedron,
   glutSolidRhombicDodecahedron,
   glutSolidSierpinskiSponge,
   glutSolidSphere,
   glutSolidTeacup,
   glutSolidTeapot,
   glutSolidTeaspoon,
   glutSolidTetrahedron,
   glutSolidTorus,
   glutSpaceballButtonFunc,
   glutSpaceballMotionFunc,
   glutSpaceballRotateFunc,
   glutSpecialFunc,
   glutSpecialUpFunc,
   glutStopVideoResizing,
   glutStrokeCharacter,
   glutStrokeHeight,
   glutStrokeLength,
   glutStrokeString,
   glutStrokeWidth,
   glutSwapBuffers,
   glutTabletButtonFunc,
   glutTabletMotionFunc,
   glutTimerFunc,
   glutUseLayer,
   glutVideoPan,
   glutVideoResize,
   glutVideoResizeGet,
   glutVisibilityFunc,
   glutWMCloseFunc,
   glutWarpPointer,
   glutWindowStatusFunc,
   glutWireCone,
   glutWireCube,
   glutWireCylinder,
   glutWireDodecahedron,
   glutWireIcosahedron,
   glutWireOctahedron,
   glutWireRhombicDodecahedron,
   glutWireSierpinskiSponge,
   glutWireSphere,
   glutWireTeacup,
   glutWireTeapot,
   glutWireTeaspoon,
   glutWireTetrahedron,
   glutWireTorus
) 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 Graphics.Rendering.OpenGL ( GLdouble, GLenum, GLfloat, GLint )
import System.IO.Unsafe ( unsafePerformIO )

import Graphics.UI.GLUT.Raw.Callbacks

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

-- | Retrieve a GLUT API entry by name. Throws a userError when no entry with
-- the given name was found.
getAPIEntry :: String -> IO (FunPtr a)
getAPIEntry :: String -> IO (FunPtr a)
getAPIEntry String
extensionEntry =
  String -> IO (FunPtr a) -> IO (FunPtr a)
forall a. String -> IO (FunPtr a) -> IO (FunPtr a)
throwIfNullFunPtr (String
"unknown GLUT entry " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
extensionEntry) (IO (FunPtr a) -> IO (FunPtr a)) -> IO (FunPtr a) -> IO (FunPtr a)
forall a b. (a -> b) -> a -> b
$
    String -> IO (FunPtr a)
forall a. String -> IO (FunPtr a)
getAPIEntryInternal String
extensionEntry

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

getAPIEntryInternal :: String -> IO (FunPtr a)
getAPIEntryInternal :: String -> IO (FunPtr a)
getAPIEntryInternal String
extensionEntry =
   String -> (CString -> IO (FunPtr a)) -> IO (FunPtr a)
forall a. String -> (CString -> IO a) -> IO a
withCString String
extensionEntry CString -> IO (FunPtr a)
forall a. CString -> IO (FunPtr a)
hs_GLUT_getProcAddress

isKnown :: MonadIO m => String -> m Bool
isKnown :: String -> m Bool
isKnown = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> (String -> IO Bool) -> String -> m Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (FunPtr Any -> Bool) -> IO (FunPtr Any) -> IO Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (FunPtr Any -> FunPtr Any -> Bool
forall a. Eq a => a -> a -> Bool
/= FunPtr Any
forall a. FunPtr a
nullFunPtr) (IO (FunPtr Any) -> IO Bool)
-> (String -> IO (FunPtr Any)) -> String -> IO Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO (FunPtr Any)
forall a. String -> IO (FunPtr a)
getAPIEntryInternal

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

-- glutAddMenuEntry ------------------------------------------------------------

glutAddMenuEntry :: MonadIO m => Ptr CChar -> CInt -> m ()
glutAddMenuEntry :: CString -> CInt -> m ()
glutAddMenuEntry CString
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CString -> CInt -> IO ()) -> CString -> CInt -> IO ()
dyn_glutAddMenuEntry FunPtr (CString -> CInt -> IO ())
forall a. FunPtr a
ptr_glutAddMenuEntry CString
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutAddMenuEntry
  :: FunPtr (Ptr CChar -> CInt -> IO ())
  ->         Ptr CChar -> CInt -> IO ()

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

-- glutAddSubMenu --------------------------------------------------------------

glutAddSubMenu :: MonadIO m => Ptr CChar -> CInt -> m ()
glutAddSubMenu :: CString -> CInt -> m ()
glutAddSubMenu CString
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CString -> CInt -> IO ()) -> CString -> CInt -> IO ()
dyn_glutAddSubMenu FunPtr (CString -> CInt -> IO ())
forall a. FunPtr a
ptr_glutAddSubMenu CString
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutAddSubMenu
  :: FunPtr (Ptr CChar -> CInt -> IO ())
  ->         Ptr CChar -> CInt -> IO ()

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

-- glutAppStatusFunc -----------------------------------------------------------

glutAppStatusFunc :: MonadIO m => FunPtr AppStatusFunc -> m ()
glutAppStatusFunc :: FunPtr (CInt -> IO ()) -> m ()
glutAppStatusFunc FunPtr (CInt -> IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (CInt -> IO ()) -> IO ())
-> FunPtr (CInt -> IO ()) -> IO ()
dyn_glutAppStatusFunc FunPtr (FunPtr (CInt -> IO ()) -> IO ())
forall a. FunPtr a
ptr_glutAppStatusFunc FunPtr (CInt -> IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutAppStatusFunc
  :: FunPtr (FunPtr AppStatusFunc -> IO ())
  ->         FunPtr AppStatusFunc -> IO ()

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

-- glutAttachMenu --------------------------------------------------------------

glutAttachMenu :: MonadIO m => CInt -> m ()
glutAttachMenu :: CInt -> m ()
glutAttachMenu CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutAttachMenu FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutAttachMenu CInt
v1

foreign import CALLCONV "dynamic" dyn_glutAttachMenu
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutBitmapCharacter ---------------------------------------------------------

glutBitmapCharacter :: MonadIO m => Ptr a -> CInt -> m ()
glutBitmapCharacter :: Ptr a -> CInt -> m ()
glutBitmapCharacter Ptr a
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> CInt -> IO ()) -> Ptr a -> CInt -> IO ()
forall a. FunPtr (Ptr a -> CInt -> IO ()) -> Ptr a -> CInt -> IO ()
dyn_glutBitmapCharacter FunPtr (Ptr a -> CInt -> IO ())
forall a. FunPtr a
ptr_glutBitmapCharacter Ptr a
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutBitmapCharacter
  :: FunPtr (Ptr a -> CInt -> IO ())
  ->         Ptr a -> CInt -> IO ()

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

-- glutBitmapHeight ------------------------------------------------------------

glutBitmapHeight :: MonadIO m => Ptr a -> m CInt
glutBitmapHeight :: Ptr a -> m CInt
glutBitmapHeight Ptr a
v1 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> IO CInt) -> Ptr a -> IO CInt
forall a. FunPtr (Ptr a -> IO CInt) -> Ptr a -> IO CInt
dyn_glutBitmapHeight FunPtr (Ptr a -> IO CInt)
forall a. FunPtr a
ptr_glutBitmapHeight Ptr a
v1

foreign import CALLCONV "dynamic" dyn_glutBitmapHeight
  :: FunPtr (Ptr a -> IO CInt)
  ->         Ptr a -> IO CInt

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

-- glutBitmapLength ------------------------------------------------------------

glutBitmapLength :: MonadIO m => Ptr a -> Ptr CUChar -> m CInt
glutBitmapLength :: Ptr a -> Ptr CUChar -> m CInt
glutBitmapLength Ptr a
v1 Ptr CUChar
v2 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
-> Ptr a -> Ptr CUChar -> IO CInt
forall a.
FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
-> Ptr a -> Ptr CUChar -> IO CInt
dyn_glutBitmapLength FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
forall a. FunPtr a
ptr_glutBitmapLength Ptr a
v1 Ptr CUChar
v2

foreign import CALLCONV "dynamic" dyn_glutBitmapLength
  :: FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
  ->         Ptr a -> Ptr CUChar -> IO CInt

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

-- glutBitmapString ------------------------------------------------------------

glutBitmapString :: MonadIO m => Ptr a -> Ptr CUChar -> m ()
glutBitmapString :: Ptr a -> Ptr CUChar -> m ()
glutBitmapString Ptr a
v1 Ptr CUChar
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> Ptr CUChar -> IO ())
-> Ptr a -> Ptr CUChar -> IO ()
forall a.
FunPtr (Ptr a -> Ptr CUChar -> IO ())
-> Ptr a -> Ptr CUChar -> IO ()
dyn_glutBitmapString FunPtr (Ptr a -> Ptr CUChar -> IO ())
forall a. FunPtr a
ptr_glutBitmapString Ptr a
v1 Ptr CUChar
v2

foreign import CALLCONV "dynamic" dyn_glutBitmapString
  :: FunPtr (Ptr a -> Ptr CUChar -> IO ())
  ->         Ptr a -> Ptr CUChar -> IO ()

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

-- glutBitmapWidth -------------------------------------------------------------

glutBitmapWidth :: MonadIO m => Ptr a -> CInt -> m CInt
glutBitmapWidth :: Ptr a -> CInt -> m CInt
glutBitmapWidth Ptr a
v1 CInt
v2 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> CInt -> IO CInt) -> Ptr a -> CInt -> IO CInt
forall a.
FunPtr (Ptr a -> CInt -> IO CInt) -> Ptr a -> CInt -> IO CInt
dyn_glutBitmapWidth FunPtr (Ptr a -> CInt -> IO CInt)
forall a. FunPtr a
ptr_glutBitmapWidth Ptr a
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutBitmapWidth
  :: FunPtr (Ptr a -> CInt -> IO CInt)
  ->         Ptr a -> CInt -> IO CInt

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

-- glutButtonBoxFunc -----------------------------------------------------------

glutButtonBoxFunc :: MonadIO m => FunPtr ButtonBoxFunc -> m ()
glutButtonBoxFunc :: FunPtr ButtonBoxFunc -> m ()
glutButtonBoxFunc FunPtr ButtonBoxFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr ButtonBoxFunc -> IO ())
-> FunPtr ButtonBoxFunc -> IO ()
dyn_glutButtonBoxFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
forall a. FunPtr a
ptr_glutButtonBoxFunc FunPtr ButtonBoxFunc
v1

foreign import CALLCONV "dynamic" dyn_glutButtonBoxFunc
  :: FunPtr (FunPtr ButtonBoxFunc -> IO ())
  ->         FunPtr ButtonBoxFunc -> IO ()

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

-- glutChangeToMenuEntry -------------------------------------------------------

glutChangeToMenuEntry :: MonadIO m => CInt -> Ptr CChar -> CInt -> m ()
glutChangeToMenuEntry :: CInt -> CString -> CInt -> m ()
glutChangeToMenuEntry CInt
v1 CString
v2 CInt
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> CString -> CInt -> IO ())
-> CInt -> CString -> CInt -> IO ()
dyn_glutChangeToMenuEntry FunPtr (CInt -> CString -> CInt -> IO ())
forall a. FunPtr a
ptr_glutChangeToMenuEntry CInt
v1 CString
v2 CInt
v3

foreign import CALLCONV "dynamic" dyn_glutChangeToMenuEntry
  :: FunPtr (CInt -> Ptr CChar -> CInt -> IO ())
  ->         CInt -> Ptr CChar -> CInt -> IO ()

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

-- glutChangeToSubMenu ---------------------------------------------------------

glutChangeToSubMenu :: MonadIO m => CInt -> Ptr CChar -> CInt -> m ()
glutChangeToSubMenu :: CInt -> CString -> CInt -> m ()
glutChangeToSubMenu CInt
v1 CString
v2 CInt
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> CString -> CInt -> IO ())
-> CInt -> CString -> CInt -> IO ()
dyn_glutChangeToSubMenu FunPtr (CInt -> CString -> CInt -> IO ())
forall a. FunPtr a
ptr_glutChangeToSubMenu CInt
v1 CString
v2 CInt
v3

foreign import CALLCONV "dynamic" dyn_glutChangeToSubMenu
  :: FunPtr (CInt -> Ptr CChar -> CInt -> IO ())
  ->         CInt -> Ptr CChar -> CInt -> IO ()

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

-- glutCloseFunc ---------------------------------------------------------------

glutCloseFunc :: MonadIO m => FunPtr CloseFunc -> m ()
glutCloseFunc :: FunPtr (IO ()) -> m ()
glutCloseFunc FunPtr (IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
dyn_glutCloseFunc FunPtr (FunPtr (IO ()) -> IO ())
forall a. FunPtr a
ptr_glutCloseFunc FunPtr (IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutCloseFunc
  :: FunPtr (FunPtr CloseFunc -> IO ())
  ->         FunPtr CloseFunc -> IO ()

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

-- glutCopyColormap ------------------------------------------------------------

glutCopyColormap :: MonadIO m => CInt -> m ()
glutCopyColormap :: CInt -> m ()
glutCopyColormap CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutCopyColormap FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutCopyColormap CInt
v1

foreign import CALLCONV "dynamic" dyn_glutCopyColormap
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutCreateMenu --------------------------------------------------------------

glutCreateMenu :: MonadIO m => FunPtr MenuFunc -> m CInt
glutCreateMenu :: FunPtr (CInt -> IO ()) -> m CInt
glutCreateMenu FunPtr (CInt -> IO ())
v1 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (CInt -> IO ()) -> IO CInt)
-> FunPtr (CInt -> IO ()) -> IO CInt
dyn_glutCreateMenu FunPtr (FunPtr (CInt -> IO ()) -> IO CInt)
forall a. FunPtr a
ptr_glutCreateMenu FunPtr (CInt -> IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutCreateMenu
  :: FunPtr (FunPtr MenuFunc -> IO CInt)
  ->         FunPtr MenuFunc -> IO CInt

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

-- glutCreateSubWindow ---------------------------------------------------------

glutCreateSubWindow :: MonadIO m => CInt -> CInt -> CInt -> CInt -> CInt -> m CInt
glutCreateSubWindow :: CInt -> CInt -> CInt -> CInt -> CInt -> m CInt
glutCreateSubWindow CInt
v1 CInt
v2 CInt
v3 CInt
v4 CInt
v5 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt)
-> CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt
dyn_glutCreateSubWindow FunPtr (CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt)
forall a. FunPtr a
ptr_glutCreateSubWindow CInt
v1 CInt
v2 CInt
v3 CInt
v4 CInt
v5

foreign import CALLCONV "dynamic" dyn_glutCreateSubWindow
  :: FunPtr (CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt)
  ->         CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt

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

-- glutCreateWindow ------------------------------------------------------------

glutCreateWindow :: MonadIO m => Ptr CChar -> m CInt
glutCreateWindow :: CString -> m CInt
glutCreateWindow CString
v1 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (CString -> IO CInt) -> CString -> IO CInt
dyn_glutCreateWindow FunPtr (CString -> IO CInt)
forall a. FunPtr a
ptr_glutCreateWindow CString
v1

foreign import CALLCONV "dynamic" dyn_glutCreateWindow
  :: FunPtr (Ptr CChar -> IO CInt)
  ->         Ptr CChar -> IO CInt

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

-- glutDestroyMenu -------------------------------------------------------------

glutDestroyMenu :: MonadIO m => CInt -> m ()
glutDestroyMenu :: CInt -> m ()
glutDestroyMenu CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutDestroyMenu FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutDestroyMenu CInt
v1

foreign import CALLCONV "dynamic" dyn_glutDestroyMenu
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutDestroyWindow -----------------------------------------------------------

glutDestroyWindow :: MonadIO m => CInt -> m ()
glutDestroyWindow :: CInt -> m ()
glutDestroyWindow CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutDestroyWindow FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutDestroyWindow CInt
v1

foreign import CALLCONV "dynamic" dyn_glutDestroyWindow
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutDetachMenu --------------------------------------------------------------

glutDetachMenu :: MonadIO m => CInt -> m ()
glutDetachMenu :: CInt -> m ()
glutDetachMenu CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutDetachMenu FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutDetachMenu CInt
v1

foreign import CALLCONV "dynamic" dyn_glutDetachMenu
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutDeviceGet ---------------------------------------------------------------

glutDeviceGet :: MonadIO m => GLenum -> m CInt
glutDeviceGet :: GLenum -> m CInt
glutDeviceGet GLenum
v1 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (GLenum -> IO CInt) -> GLenum -> IO CInt
dyn_glutDeviceGet FunPtr (GLenum -> IO CInt)
forall a. FunPtr a
ptr_glutDeviceGet GLenum
v1

foreign import CALLCONV "dynamic" dyn_glutDeviceGet
  :: FunPtr (GLenum -> IO CInt)
  ->         GLenum -> IO CInt

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

-- glutDialsFunc ---------------------------------------------------------------

glutDialsFunc :: MonadIO m => FunPtr DialsFunc -> m ()
glutDialsFunc :: FunPtr ButtonBoxFunc -> m ()
glutDialsFunc FunPtr ButtonBoxFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr ButtonBoxFunc -> IO ())
-> FunPtr ButtonBoxFunc -> IO ()
dyn_glutDialsFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
forall a. FunPtr a
ptr_glutDialsFunc FunPtr ButtonBoxFunc
v1

foreign import CALLCONV "dynamic" dyn_glutDialsFunc
  :: FunPtr (FunPtr DialsFunc -> IO ())
  ->         FunPtr DialsFunc -> IO ()

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

-- glutDisplayFunc -------------------------------------------------------------

glutDisplayFunc :: MonadIO m => FunPtr DisplayFunc -> m ()
glutDisplayFunc :: FunPtr (IO ()) -> m ()
glutDisplayFunc FunPtr (IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
dyn_glutDisplayFunc FunPtr (FunPtr (IO ()) -> IO ())
forall a. FunPtr a
ptr_glutDisplayFunc FunPtr (IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutDisplayFunc
  :: FunPtr (FunPtr DisplayFunc -> IO ())
  ->         FunPtr DisplayFunc -> IO ()

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

-- glutEnterGameMode -----------------------------------------------------------

glutEnterGameMode :: MonadIO m => m CInt
glutEnterGameMode :: m CInt
glutEnterGameMode = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (IO CInt) -> IO CInt
dyn_glutEnterGameMode FunPtr (IO CInt)
forall a. FunPtr a
ptr_glutEnterGameMode

foreign import CALLCONV "dynamic" dyn_glutEnterGameMode
  :: FunPtr (IO CInt)
  ->         IO CInt

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

-- glutEntryFunc ---------------------------------------------------------------

glutEntryFunc :: MonadIO m => FunPtr EntryFunc -> m ()
glutEntryFunc :: FunPtr (CInt -> IO ()) -> m ()
glutEntryFunc FunPtr (CInt -> IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (CInt -> IO ()) -> IO ())
-> FunPtr (CInt -> IO ()) -> IO ()
dyn_glutEntryFunc FunPtr (FunPtr (CInt -> IO ()) -> IO ())
forall a. FunPtr a
ptr_glutEntryFunc FunPtr (CInt -> IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutEntryFunc
  :: FunPtr (FunPtr EntryFunc -> IO ())
  ->         FunPtr EntryFunc -> IO ()

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

-- glutEstablishOverlay --------------------------------------------------------

glutEstablishOverlay :: MonadIO m => m ()
glutEstablishOverlay :: m ()
glutEstablishOverlay = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutEstablishOverlay FunPtr (IO ())
forall a. FunPtr a
ptr_glutEstablishOverlay

foreign import CALLCONV "dynamic" dyn_glutEstablishOverlay
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutExit --------------------------------------------------------------------

glutExit :: MonadIO m => m ()
glutExit :: m ()
glutExit = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutExit FunPtr (IO ())
forall a. FunPtr a
ptr_glutExit

foreign import CALLCONV "dynamic" dyn_glutExit
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutExtensionSupported ------------------------------------------------------

glutExtensionSupported :: MonadIO m => Ptr CChar -> m CInt
glutExtensionSupported :: CString -> m CInt
glutExtensionSupported CString
v1 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (CString -> IO CInt) -> CString -> IO CInt
dyn_glutExtensionSupported FunPtr (CString -> IO CInt)
forall a. FunPtr a
ptr_glutExtensionSupported CString
v1

foreign import CALLCONV "dynamic" dyn_glutExtensionSupported
  :: FunPtr (Ptr CChar -> IO CInt)
  ->         Ptr CChar -> IO CInt

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

-- glutForceJoystickFunc -------------------------------------------------------

glutForceJoystickFunc :: MonadIO m => m ()
glutForceJoystickFunc :: m ()
glutForceJoystickFunc = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutForceJoystickFunc FunPtr (IO ())
forall a. FunPtr a
ptr_glutForceJoystickFunc

foreign import CALLCONV "dynamic" dyn_glutForceJoystickFunc
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutFullScreen --------------------------------------------------------------

glutFullScreen :: MonadIO m => m ()
glutFullScreen :: m ()
glutFullScreen = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutFullScreen FunPtr (IO ())
forall a. FunPtr a
ptr_glutFullScreen

foreign import CALLCONV "dynamic" dyn_glutFullScreen
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutFullScreenToggle --------------------------------------------------------

glutFullScreenToggle :: MonadIO m => m ()
glutFullScreenToggle :: m ()
glutFullScreenToggle = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutFullScreenToggle FunPtr (IO ())
forall a. FunPtr a
ptr_glutFullScreenToggle

foreign import CALLCONV "dynamic" dyn_glutFullScreenToggle
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutGameModeGet -------------------------------------------------------------

glutGameModeGet :: MonadIO m => GLenum -> m CInt
glutGameModeGet :: GLenum -> m CInt
glutGameModeGet GLenum
v1 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (GLenum -> IO CInt) -> GLenum -> IO CInt
dyn_glutGameModeGet FunPtr (GLenum -> IO CInt)
forall a. FunPtr a
ptr_glutGameModeGet GLenum
v1

foreign import CALLCONV "dynamic" dyn_glutGameModeGet
  :: FunPtr (GLenum -> IO CInt)
  ->         GLenum -> IO CInt

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

-- glutGameModeString ----------------------------------------------------------

glutGameModeString :: MonadIO m => Ptr CChar -> m ()
glutGameModeString :: CString -> m ()
glutGameModeString CString
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CString -> IO ()) -> CString -> IO ()
dyn_glutGameModeString FunPtr (CString -> IO ())
forall a. FunPtr a
ptr_glutGameModeString CString
v1

foreign import CALLCONV "dynamic" dyn_glutGameModeString
  :: FunPtr (Ptr CChar -> IO ())
  ->         Ptr CChar -> IO ()

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

-- glutGet ---------------------------------------------------------------------

glutGet :: MonadIO m => GLenum -> m CInt
glutGet :: GLenum -> m CInt
glutGet GLenum
v1 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (GLenum -> IO CInt) -> GLenum -> IO CInt
dyn_glutGet FunPtr (GLenum -> IO CInt)
forall a. FunPtr a
ptr_glutGet GLenum
v1

foreign import CALLCONV "dynamic" dyn_glutGet
  :: FunPtr (GLenum -> IO CInt)
  ->         GLenum -> IO CInt

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

-- glutGetColor ----------------------------------------------------------------

glutGetColor :: MonadIO m => CInt -> CInt -> m GLfloat
glutGetColor :: CInt -> CInt -> m GLfloat
glutGetColor CInt
v1 CInt
v2 = IO GLfloat -> m GLfloat
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLfloat -> m GLfloat) -> IO GLfloat -> m GLfloat
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> CInt -> IO GLfloat) -> CInt -> CInt -> IO GLfloat
dyn_glutGetColor FunPtr (CInt -> CInt -> IO GLfloat)
forall a. FunPtr a
ptr_glutGetColor CInt
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutGetColor
  :: FunPtr (CInt -> CInt -> IO GLfloat)
  ->         CInt -> CInt -> IO GLfloat

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

-- glutGetMenu -----------------------------------------------------------------

glutGetMenu :: MonadIO m => m CInt
glutGetMenu :: m CInt
glutGetMenu = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (IO CInt) -> IO CInt
dyn_glutGetMenu FunPtr (IO CInt)
forall a. FunPtr a
ptr_glutGetMenu

foreign import CALLCONV "dynamic" dyn_glutGetMenu
  :: FunPtr (IO CInt)
  ->         IO CInt

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

-- glutGetMenuData -------------------------------------------------------------

glutGetMenuData :: MonadIO m => m (Ptr a)
glutGetMenuData :: m (Ptr a)
glutGetMenuData = IO (Ptr a) -> m (Ptr a)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr a) -> m (Ptr a)) -> IO (Ptr a) -> m (Ptr a)
forall a b. (a -> b) -> a -> b
$ FunPtr (IO (Ptr a)) -> IO (Ptr a)
forall a. FunPtr (IO (Ptr a)) -> IO (Ptr a)
dyn_glutGetMenuData FunPtr (IO (Ptr a))
forall a. FunPtr a
ptr_glutGetMenuData

foreign import CALLCONV "dynamic" dyn_glutGetMenuData
  :: FunPtr (IO (Ptr a))
  ->         IO (Ptr a)

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

-- glutGetModeValues -----------------------------------------------------------

glutGetModeValues :: MonadIO m => GLenum -> Ptr CInt -> m (Ptr CInt)
glutGetModeValues :: GLenum -> Ptr CInt -> m (Ptr CInt)
glutGetModeValues GLenum
v1 Ptr CInt
v2 = IO (Ptr CInt) -> m (Ptr CInt)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr CInt) -> m (Ptr CInt)) -> IO (Ptr CInt) -> m (Ptr CInt)
forall a b. (a -> b) -> a -> b
$ FunPtr (GLenum -> Ptr CInt -> IO (Ptr CInt))
-> GLenum -> Ptr CInt -> IO (Ptr CInt)
dyn_glutGetModeValues FunPtr (GLenum -> Ptr CInt -> IO (Ptr CInt))
forall a. FunPtr a
ptr_glutGetModeValues GLenum
v1 Ptr CInt
v2

foreign import CALLCONV "dynamic" dyn_glutGetModeValues
  :: FunPtr (GLenum -> Ptr CInt -> IO (Ptr CInt))
  ->         GLenum -> Ptr CInt -> IO (Ptr CInt)

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

-- glutGetModifiers ------------------------------------------------------------

glutGetModifiers :: MonadIO m => m CInt
glutGetModifiers :: m CInt
glutGetModifiers = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (IO CInt) -> IO CInt
dyn_glutGetModifiers FunPtr (IO CInt)
forall a. FunPtr a
ptr_glutGetModifiers

foreign import CALLCONV "dynamic" dyn_glutGetModifiers
  :: FunPtr (IO CInt)
  ->         IO CInt

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

-- glutGetProcAddress ----------------------------------------------------------

glutGetProcAddress :: MonadIO m => Ptr CChar -> m (FunPtr a)
glutGetProcAddress :: CString -> m (FunPtr a)
glutGetProcAddress CString
v1 = IO (FunPtr a) -> m (FunPtr a)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (FunPtr a) -> m (FunPtr a)) -> IO (FunPtr a) -> m (FunPtr a)
forall a b. (a -> b) -> a -> b
$ FunPtr (CString -> IO (FunPtr a)) -> CString -> IO (FunPtr a)
forall a.
FunPtr (CString -> IO (FunPtr a)) -> CString -> IO (FunPtr a)
dyn_glutGetProcAddress FunPtr (CString -> IO (FunPtr a))
forall a. FunPtr a
ptr_glutGetProcAddress CString
v1

foreign import CALLCONV "dynamic" dyn_glutGetProcAddress
  :: FunPtr (Ptr CChar -> IO (FunPtr a))
  ->         Ptr CChar -> IO (FunPtr a)

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

-- glutGetWindow ---------------------------------------------------------------

glutGetWindow :: MonadIO m => m CInt
glutGetWindow :: m CInt
glutGetWindow = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (IO CInt) -> IO CInt
dyn_glutGetWindow FunPtr (IO CInt)
forall a. FunPtr a
ptr_glutGetWindow

foreign import CALLCONV "dynamic" dyn_glutGetWindow
  :: FunPtr (IO CInt)
  ->         IO CInt

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

-- glutGetWindowData -----------------------------------------------------------

glutGetWindowData :: MonadIO m => m (Ptr a)
glutGetWindowData :: m (Ptr a)
glutGetWindowData = IO (Ptr a) -> m (Ptr a)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Ptr a) -> m (Ptr a)) -> IO (Ptr a) -> m (Ptr a)
forall a b. (a -> b) -> a -> b
$ FunPtr (IO (Ptr a)) -> IO (Ptr a)
forall a. FunPtr (IO (Ptr a)) -> IO (Ptr a)
dyn_glutGetWindowData FunPtr (IO (Ptr a))
forall a. FunPtr a
ptr_glutGetWindowData

foreign import CALLCONV "dynamic" dyn_glutGetWindowData
  :: FunPtr (IO (Ptr a))
  ->         IO (Ptr a)

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

-- glutHideOverlay -------------------------------------------------------------

glutHideOverlay :: MonadIO m => m ()
glutHideOverlay :: m ()
glutHideOverlay = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutHideOverlay FunPtr (IO ())
forall a. FunPtr a
ptr_glutHideOverlay

foreign import CALLCONV "dynamic" dyn_glutHideOverlay
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutHideWindow --------------------------------------------------------------

glutHideWindow :: MonadIO m => m ()
glutHideWindow :: m ()
glutHideWindow = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutHideWindow FunPtr (IO ())
forall a. FunPtr a
ptr_glutHideWindow

foreign import CALLCONV "dynamic" dyn_glutHideWindow
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutIconifyWindow -----------------------------------------------------------

glutIconifyWindow :: MonadIO m => m ()
glutIconifyWindow :: m ()
glutIconifyWindow = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutIconifyWindow FunPtr (IO ())
forall a. FunPtr a
ptr_glutIconifyWindow

foreign import CALLCONV "dynamic" dyn_glutIconifyWindow
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutIdleFunc ----------------------------------------------------------------

glutIdleFunc :: MonadIO m => FunPtr IdleFunc -> m ()
glutIdleFunc :: FunPtr (IO ()) -> m ()
glutIdleFunc FunPtr (IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
dyn_glutIdleFunc FunPtr (FunPtr (IO ()) -> IO ())
forall a. FunPtr a
ptr_glutIdleFunc FunPtr (IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutIdleFunc
  :: FunPtr (FunPtr IdleFunc -> IO ())
  ->         FunPtr IdleFunc -> IO ()

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

-- glutIgnoreKeyRepeat ---------------------------------------------------------

glutIgnoreKeyRepeat :: MonadIO m => CInt -> m ()
glutIgnoreKeyRepeat :: CInt -> m ()
glutIgnoreKeyRepeat CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutIgnoreKeyRepeat FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutIgnoreKeyRepeat CInt
v1

foreign import CALLCONV "dynamic" dyn_glutIgnoreKeyRepeat
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutInit --------------------------------------------------------------------

glutInit :: MonadIO m => Ptr CInt -> Ptr (Ptr CChar) -> m ()
glutInit :: Ptr CInt -> Ptr CString -> m ()
glutInit Ptr CInt
v1 Ptr CString
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr CInt -> Ptr CString -> IO ())
-> Ptr CInt -> Ptr CString -> IO ()
dyn_glutInit FunPtr (Ptr CInt -> Ptr CString -> IO ())
forall a. FunPtr a
ptr_glutInit Ptr CInt
v1 Ptr CString
v2

foreign import CALLCONV "dynamic" dyn_glutInit
  :: FunPtr (Ptr CInt -> Ptr (Ptr CChar) -> IO ())
  ->         Ptr CInt -> Ptr (Ptr CChar) -> IO ()

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

-- glutInitContextFlags --------------------------------------------------------

glutInitContextFlags :: MonadIO m => CInt -> m ()
glutInitContextFlags :: CInt -> m ()
glutInitContextFlags CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutInitContextFlags FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutInitContextFlags CInt
v1

foreign import CALLCONV "dynamic" dyn_glutInitContextFlags
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutInitContextFunc ---------------------------------------------------------

glutInitContextFunc :: MonadIO m => FunPtr InitContextFunc -> m ()
glutInitContextFunc :: FunPtr (IO ()) -> m ()
glutInitContextFunc FunPtr (IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
dyn_glutInitContextFunc FunPtr (FunPtr (IO ()) -> IO ())
forall a. FunPtr a
ptr_glutInitContextFunc FunPtr (IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutInitContextFunc
  :: FunPtr (FunPtr InitContextFunc -> IO ())
  ->         FunPtr InitContextFunc -> IO ()

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

-- glutInitContextProfile ------------------------------------------------------

glutInitContextProfile :: MonadIO m => CInt -> m ()
glutInitContextProfile :: CInt -> m ()
glutInitContextProfile CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutInitContextProfile FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutInitContextProfile CInt
v1

foreign import CALLCONV "dynamic" dyn_glutInitContextProfile
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutInitContextVersion ------------------------------------------------------

glutInitContextVersion :: MonadIO m => CInt -> CInt -> m ()
glutInitContextVersion :: CInt -> CInt -> m ()
glutInitContextVersion CInt
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr ButtonBoxFunc -> ButtonBoxFunc
dyn_glutInitContextVersion FunPtr ButtonBoxFunc
forall a. FunPtr a
ptr_glutInitContextVersion CInt
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutInitContextVersion
  :: FunPtr (CInt -> CInt -> IO ())
  ->         CInt -> CInt -> IO ()

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

-- glutInitDisplayMode ---------------------------------------------------------

glutInitDisplayMode :: MonadIO m => CUInt -> m ()
glutInitDisplayMode :: CUInt -> m ()
glutInitDisplayMode CUInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CUInt -> IO ()) -> CUInt -> IO ()
dyn_glutInitDisplayMode FunPtr (CUInt -> IO ())
forall a. FunPtr a
ptr_glutInitDisplayMode CUInt
v1

foreign import CALLCONV "dynamic" dyn_glutInitDisplayMode
  :: FunPtr (CUInt -> IO ())
  ->         CUInt -> IO ()

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

-- glutInitDisplayString -------------------------------------------------------

glutInitDisplayString :: MonadIO m => Ptr CChar -> m ()
glutInitDisplayString :: CString -> m ()
glutInitDisplayString CString
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CString -> IO ()) -> CString -> IO ()
dyn_glutInitDisplayString FunPtr (CString -> IO ())
forall a. FunPtr a
ptr_glutInitDisplayString CString
v1

foreign import CALLCONV "dynamic" dyn_glutInitDisplayString
  :: FunPtr (Ptr CChar -> IO ())
  ->         Ptr CChar -> IO ()

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

-- glutInitWindowPosition ------------------------------------------------------

glutInitWindowPosition :: MonadIO m => CInt -> CInt -> m ()
glutInitWindowPosition :: CInt -> CInt -> m ()
glutInitWindowPosition CInt
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr ButtonBoxFunc -> ButtonBoxFunc
dyn_glutInitWindowPosition FunPtr ButtonBoxFunc
forall a. FunPtr a
ptr_glutInitWindowPosition CInt
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutInitWindowPosition
  :: FunPtr (CInt -> CInt -> IO ())
  ->         CInt -> CInt -> IO ()

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

-- glutInitWindowSize ----------------------------------------------------------

glutInitWindowSize :: MonadIO m => CInt -> CInt -> m ()
glutInitWindowSize :: CInt -> CInt -> m ()
glutInitWindowSize CInt
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr ButtonBoxFunc -> ButtonBoxFunc
dyn_glutInitWindowSize FunPtr ButtonBoxFunc
forall a. FunPtr a
ptr_glutInitWindowSize CInt
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutInitWindowSize
  :: FunPtr (CInt -> CInt -> IO ())
  ->         CInt -> CInt -> IO ()

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

-- glutJoystickFunc ------------------------------------------------------------

glutJoystickFunc :: MonadIO m => FunPtr JoystickFunc -> CInt -> m ()
glutJoystickFunc :: FunPtr JoystickFunc -> CInt -> m ()
glutJoystickFunc FunPtr JoystickFunc
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr JoystickFunc -> CInt -> IO ())
-> FunPtr JoystickFunc -> CInt -> IO ()
dyn_glutJoystickFunc FunPtr (FunPtr JoystickFunc -> CInt -> IO ())
forall a. FunPtr a
ptr_glutJoystickFunc FunPtr JoystickFunc
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutJoystickFunc
  :: FunPtr (FunPtr JoystickFunc -> CInt -> IO ())
  ->         FunPtr JoystickFunc -> CInt -> IO ()

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

-- glutKeyboardFunc ------------------------------------------------------------

glutKeyboardFunc :: MonadIO m => FunPtr KeyboardFunc -> m ()
glutKeyboardFunc :: FunPtr KeyboardFunc -> m ()
glutKeyboardFunc FunPtr KeyboardFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr KeyboardFunc -> IO ())
-> FunPtr KeyboardFunc -> IO ()
dyn_glutKeyboardFunc FunPtr (FunPtr KeyboardFunc -> IO ())
forall a. FunPtr a
ptr_glutKeyboardFunc FunPtr KeyboardFunc
v1

foreign import CALLCONV "dynamic" dyn_glutKeyboardFunc
  :: FunPtr (FunPtr KeyboardFunc -> IO ())
  ->         FunPtr KeyboardFunc -> IO ()

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

-- glutKeyboardUpFunc ----------------------------------------------------------

glutKeyboardUpFunc :: MonadIO m => FunPtr KeyboardUpFunc -> m ()
glutKeyboardUpFunc :: FunPtr KeyboardFunc -> m ()
glutKeyboardUpFunc FunPtr KeyboardFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr KeyboardFunc -> IO ())
-> FunPtr KeyboardFunc -> IO ()
dyn_glutKeyboardUpFunc FunPtr (FunPtr KeyboardFunc -> IO ())
forall a. FunPtr a
ptr_glutKeyboardUpFunc FunPtr KeyboardFunc
v1

foreign import CALLCONV "dynamic" dyn_glutKeyboardUpFunc
  :: FunPtr (FunPtr KeyboardUpFunc -> IO ())
  ->         FunPtr KeyboardUpFunc -> IO ()

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

-- glutLayerGet ----------------------------------------------------------------

glutLayerGet :: MonadIO m => GLenum -> m CInt
glutLayerGet :: GLenum -> m CInt
glutLayerGet GLenum
v1 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (GLenum -> IO CInt) -> GLenum -> IO CInt
dyn_glutLayerGet FunPtr (GLenum -> IO CInt)
forall a. FunPtr a
ptr_glutLayerGet GLenum
v1

foreign import CALLCONV "dynamic" dyn_glutLayerGet
  :: FunPtr (GLenum -> IO CInt)
  ->         GLenum -> IO CInt

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

-- glutLeaveFullScreen ---------------------------------------------------------

glutLeaveFullScreen :: MonadIO m => m ()
glutLeaveFullScreen :: m ()
glutLeaveFullScreen = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutLeaveFullScreen FunPtr (IO ())
forall a. FunPtr a
ptr_glutLeaveFullScreen

foreign import CALLCONV "dynamic" dyn_glutLeaveFullScreen
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutLeaveGameMode -----------------------------------------------------------

glutLeaveGameMode :: MonadIO m => m ()
glutLeaveGameMode :: m ()
glutLeaveGameMode = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutLeaveGameMode FunPtr (IO ())
forall a. FunPtr a
ptr_glutLeaveGameMode

foreign import CALLCONV "dynamic" dyn_glutLeaveGameMode
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutLeaveMainLoop -----------------------------------------------------------

glutLeaveMainLoop :: MonadIO m => m ()
glutLeaveMainLoop :: m ()
glutLeaveMainLoop = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutLeaveMainLoop FunPtr (IO ())
forall a. FunPtr a
ptr_glutLeaveMainLoop

foreign import CALLCONV "dynamic" dyn_glutLeaveMainLoop
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutMainLoop ----------------------------------------------------------------

glutMainLoop :: MonadIO m => m ()
glutMainLoop :: m ()
glutMainLoop = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutMainLoop FunPtr (IO ())
forall a. FunPtr a
ptr_glutMainLoop

foreign import CALLCONV "dynamic" dyn_glutMainLoop
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutMainLoopEvent -----------------------------------------------------------

glutMainLoopEvent :: MonadIO m => m ()
glutMainLoopEvent :: m ()
glutMainLoopEvent = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutMainLoopEvent FunPtr (IO ())
forall a. FunPtr a
ptr_glutMainLoopEvent

foreign import CALLCONV "dynamic" dyn_glutMainLoopEvent
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutMenuDestroyFunc ---------------------------------------------------------

glutMenuDestroyFunc :: MonadIO m => FunPtr MenuDestroyFunc -> m ()
glutMenuDestroyFunc :: FunPtr (IO ()) -> m ()
glutMenuDestroyFunc FunPtr (IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
dyn_glutMenuDestroyFunc FunPtr (FunPtr (IO ()) -> IO ())
forall a. FunPtr a
ptr_glutMenuDestroyFunc FunPtr (IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutMenuDestroyFunc
  :: FunPtr (FunPtr MenuDestroyFunc -> IO ())
  ->         FunPtr MenuDestroyFunc -> IO ()

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

-- glutMenuStateFunc -----------------------------------------------------------

glutMenuStateFunc :: MonadIO m => FunPtr MenuStateFunc -> m ()
glutMenuStateFunc :: FunPtr (CInt -> IO ()) -> m ()
glutMenuStateFunc FunPtr (CInt -> IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (CInt -> IO ()) -> IO ())
-> FunPtr (CInt -> IO ()) -> IO ()
dyn_glutMenuStateFunc FunPtr (FunPtr (CInt -> IO ()) -> IO ())
forall a. FunPtr a
ptr_glutMenuStateFunc FunPtr (CInt -> IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutMenuStateFunc
  :: FunPtr (FunPtr MenuStateFunc -> IO ())
  ->         FunPtr MenuStateFunc -> IO ()

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

-- glutMenuStatusFunc ----------------------------------------------------------

glutMenuStatusFunc :: MonadIO m => FunPtr MenuStatusFunc -> m ()
glutMenuStatusFunc :: FunPtr MenuStatusFunc -> m ()
glutMenuStatusFunc FunPtr MenuStatusFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr MenuStatusFunc -> IO ())
-> FunPtr MenuStatusFunc -> IO ()
dyn_glutMenuStatusFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
forall a. FunPtr a
ptr_glutMenuStatusFunc FunPtr MenuStatusFunc
v1

foreign import CALLCONV "dynamic" dyn_glutMenuStatusFunc
  :: FunPtr (FunPtr MenuStatusFunc -> IO ())
  ->         FunPtr MenuStatusFunc -> IO ()

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

-- glutMotionFunc --------------------------------------------------------------

glutMotionFunc :: MonadIO m => FunPtr MotionFunc -> m ()
glutMotionFunc :: FunPtr ButtonBoxFunc -> m ()
glutMotionFunc FunPtr ButtonBoxFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr ButtonBoxFunc -> IO ())
-> FunPtr ButtonBoxFunc -> IO ()
dyn_glutMotionFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
forall a. FunPtr a
ptr_glutMotionFunc FunPtr ButtonBoxFunc
v1

foreign import CALLCONV "dynamic" dyn_glutMotionFunc
  :: FunPtr (FunPtr MotionFunc -> IO ())
  ->         FunPtr MotionFunc -> IO ()

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

-- glutMouseFunc ---------------------------------------------------------------

glutMouseFunc :: MonadIO m => FunPtr MouseFunc -> m ()
glutMouseFunc :: FunPtr MouseFunc -> m ()
glutMouseFunc FunPtr MouseFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr MouseFunc -> IO ()) -> FunPtr MouseFunc -> IO ()
dyn_glutMouseFunc FunPtr (FunPtr MouseFunc -> IO ())
forall a. FunPtr a
ptr_glutMouseFunc FunPtr MouseFunc
v1

foreign import CALLCONV "dynamic" dyn_glutMouseFunc
  :: FunPtr (FunPtr MouseFunc -> IO ())
  ->         FunPtr MouseFunc -> IO ()

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

-- glutMouseWheelFunc ----------------------------------------------------------

glutMouseWheelFunc :: MonadIO m => FunPtr MouseWheelFunc -> m ()
glutMouseWheelFunc :: FunPtr MouseFunc -> m ()
glutMouseWheelFunc FunPtr MouseFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr MouseFunc -> IO ()) -> FunPtr MouseFunc -> IO ()
dyn_glutMouseWheelFunc FunPtr (FunPtr MouseFunc -> IO ())
forall a. FunPtr a
ptr_glutMouseWheelFunc FunPtr MouseFunc
v1

foreign import CALLCONV "dynamic" dyn_glutMouseWheelFunc
  :: FunPtr (FunPtr MouseWheelFunc -> IO ())
  ->         FunPtr MouseWheelFunc -> IO ()

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

-- glutMultiButtonFunc ---------------------------------------------------------

glutMultiButtonFunc :: MonadIO m => FunPtr MultiButtonFunc -> m ()
glutMultiButtonFunc :: FunPtr MultiButtonFunc -> m ()
glutMultiButtonFunc FunPtr MultiButtonFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr MultiButtonFunc -> IO ())
-> FunPtr MultiButtonFunc -> IO ()
dyn_glutMultiButtonFunc FunPtr (FunPtr MultiButtonFunc -> IO ())
forall a. FunPtr a
ptr_glutMultiButtonFunc FunPtr MultiButtonFunc
v1

foreign import CALLCONV "dynamic" dyn_glutMultiButtonFunc
  :: FunPtr (FunPtr MultiButtonFunc -> IO ())
  ->         FunPtr MultiButtonFunc -> IO ()

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

-- glutMultiEntryFunc ----------------------------------------------------------

glutMultiEntryFunc :: MonadIO m => FunPtr MultiEntryFunc -> m ()
glutMultiEntryFunc :: FunPtr ButtonBoxFunc -> m ()
glutMultiEntryFunc FunPtr ButtonBoxFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr ButtonBoxFunc -> IO ())
-> FunPtr ButtonBoxFunc -> IO ()
dyn_glutMultiEntryFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
forall a. FunPtr a
ptr_glutMultiEntryFunc FunPtr ButtonBoxFunc
v1

foreign import CALLCONV "dynamic" dyn_glutMultiEntryFunc
  :: FunPtr (FunPtr MultiEntryFunc -> IO ())
  ->         FunPtr MultiEntryFunc -> IO ()

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

-- glutMultiMotionFunc ---------------------------------------------------------

glutMultiMotionFunc :: MonadIO m => FunPtr MultiMotionFunc -> m ()
glutMultiMotionFunc :: FunPtr MenuStatusFunc -> m ()
glutMultiMotionFunc FunPtr MenuStatusFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr MenuStatusFunc -> IO ())
-> FunPtr MenuStatusFunc -> IO ()
dyn_glutMultiMotionFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
forall a. FunPtr a
ptr_glutMultiMotionFunc FunPtr MenuStatusFunc
v1

foreign import CALLCONV "dynamic" dyn_glutMultiMotionFunc
  :: FunPtr (FunPtr MultiMotionFunc -> IO ())
  ->         FunPtr MultiMotionFunc -> IO ()

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

-- glutMultiPassiveFunc --------------------------------------------------------

glutMultiPassiveFunc :: MonadIO m => FunPtr MultiPassiveFunc -> m ()
glutMultiPassiveFunc :: FunPtr MenuStatusFunc -> m ()
glutMultiPassiveFunc FunPtr MenuStatusFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr MenuStatusFunc -> IO ())
-> FunPtr MenuStatusFunc -> IO ()
dyn_glutMultiPassiveFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
forall a. FunPtr a
ptr_glutMultiPassiveFunc FunPtr MenuStatusFunc
v1

foreign import CALLCONV "dynamic" dyn_glutMultiPassiveFunc
  :: FunPtr (FunPtr MultiPassiveFunc -> IO ())
  ->         FunPtr MultiPassiveFunc -> IO ()

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

-- glutOverlayDisplayFunc ------------------------------------------------------

glutOverlayDisplayFunc :: MonadIO m => FunPtr OverlayDisplayFunc -> m ()
glutOverlayDisplayFunc :: FunPtr (IO ()) -> m ()
glutOverlayDisplayFunc FunPtr (IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
dyn_glutOverlayDisplayFunc FunPtr (FunPtr (IO ()) -> IO ())
forall a. FunPtr a
ptr_glutOverlayDisplayFunc FunPtr (IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutOverlayDisplayFunc
  :: FunPtr (FunPtr OverlayDisplayFunc -> IO ())
  ->         FunPtr OverlayDisplayFunc -> IO ()

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

-- glutPassiveMotionFunc -------------------------------------------------------

glutPassiveMotionFunc :: MonadIO m => FunPtr PassiveMotionFunc -> m ()
glutPassiveMotionFunc :: FunPtr ButtonBoxFunc -> m ()
glutPassiveMotionFunc FunPtr ButtonBoxFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr ButtonBoxFunc -> IO ())
-> FunPtr ButtonBoxFunc -> IO ()
dyn_glutPassiveMotionFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
forall a. FunPtr a
ptr_glutPassiveMotionFunc FunPtr ButtonBoxFunc
v1

foreign import CALLCONV "dynamic" dyn_glutPassiveMotionFunc
  :: FunPtr (FunPtr PassiveMotionFunc -> IO ())
  ->         FunPtr PassiveMotionFunc -> IO ()

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

-- glutPopWindow ---------------------------------------------------------------

glutPopWindow :: MonadIO m => m ()
glutPopWindow :: m ()
glutPopWindow = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutPopWindow FunPtr (IO ())
forall a. FunPtr a
ptr_glutPopWindow

foreign import CALLCONV "dynamic" dyn_glutPopWindow
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutPositionFunc ------------------------------------------------------------

glutPositionFunc :: MonadIO m => FunPtr PositionFunc -> m ()
glutPositionFunc :: FunPtr ButtonBoxFunc -> m ()
glutPositionFunc FunPtr ButtonBoxFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr ButtonBoxFunc -> IO ())
-> FunPtr ButtonBoxFunc -> IO ()
dyn_glutPositionFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
forall a. FunPtr a
ptr_glutPositionFunc FunPtr ButtonBoxFunc
v1

foreign import CALLCONV "dynamic" dyn_glutPositionFunc
  :: FunPtr (FunPtr PositionFunc -> IO ())
  ->         FunPtr PositionFunc -> IO ()

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

-- glutPositionWindow ----------------------------------------------------------

glutPositionWindow :: MonadIO m => CInt -> CInt -> m ()
glutPositionWindow :: CInt -> CInt -> m ()
glutPositionWindow CInt
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr ButtonBoxFunc -> ButtonBoxFunc
dyn_glutPositionWindow FunPtr ButtonBoxFunc
forall a. FunPtr a
ptr_glutPositionWindow CInt
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutPositionWindow
  :: FunPtr (CInt -> CInt -> IO ())
  ->         CInt -> CInt -> IO ()

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

-- glutPostOverlayRedisplay ----------------------------------------------------

glutPostOverlayRedisplay :: MonadIO m => m ()
glutPostOverlayRedisplay :: m ()
glutPostOverlayRedisplay = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutPostOverlayRedisplay FunPtr (IO ())
forall a. FunPtr a
ptr_glutPostOverlayRedisplay

foreign import CALLCONV "dynamic" dyn_glutPostOverlayRedisplay
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutPostRedisplay -----------------------------------------------------------

glutPostRedisplay :: MonadIO m => m ()
glutPostRedisplay :: m ()
glutPostRedisplay = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutPostRedisplay FunPtr (IO ())
forall a. FunPtr a
ptr_glutPostRedisplay

foreign import CALLCONV "dynamic" dyn_glutPostRedisplay
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutPostWindowOverlayRedisplay ----------------------------------------------

glutPostWindowOverlayRedisplay :: MonadIO m => CInt -> m ()
glutPostWindowOverlayRedisplay :: CInt -> m ()
glutPostWindowOverlayRedisplay CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutPostWindowOverlayRedisplay FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutPostWindowOverlayRedisplay CInt
v1

foreign import CALLCONV "dynamic" dyn_glutPostWindowOverlayRedisplay
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutPostWindowRedisplay -----------------------------------------------------

glutPostWindowRedisplay :: MonadIO m => CInt -> m ()
glutPostWindowRedisplay :: CInt -> m ()
glutPostWindowRedisplay CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutPostWindowRedisplay FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutPostWindowRedisplay CInt
v1

foreign import CALLCONV "dynamic" dyn_glutPostWindowRedisplay
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutPushWindow --------------------------------------------------------------

glutPushWindow :: MonadIO m => m ()
glutPushWindow :: m ()
glutPushWindow = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutPushWindow FunPtr (IO ())
forall a. FunPtr a
ptr_glutPushWindow

foreign import CALLCONV "dynamic" dyn_glutPushWindow
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutRemoveMenuItem ----------------------------------------------------------

glutRemoveMenuItem :: MonadIO m => CInt -> m ()
glutRemoveMenuItem :: CInt -> m ()
glutRemoveMenuItem CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutRemoveMenuItem FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutRemoveMenuItem CInt
v1

foreign import CALLCONV "dynamic" dyn_glutRemoveMenuItem
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutRemoveOverlay -----------------------------------------------------------

glutRemoveOverlay :: MonadIO m => m ()
glutRemoveOverlay :: m ()
glutRemoveOverlay = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutRemoveOverlay FunPtr (IO ())
forall a. FunPtr a
ptr_glutRemoveOverlay

foreign import CALLCONV "dynamic" dyn_glutRemoveOverlay
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutReportErrors ------------------------------------------------------------

glutReportErrors :: MonadIO m => m ()
glutReportErrors :: m ()
glutReportErrors = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutReportErrors FunPtr (IO ())
forall a. FunPtr a
ptr_glutReportErrors

foreign import CALLCONV "dynamic" dyn_glutReportErrors
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutReshapeFunc -------------------------------------------------------------

glutReshapeFunc :: MonadIO m => FunPtr ReshapeFunc -> m ()
glutReshapeFunc :: FunPtr ButtonBoxFunc -> m ()
glutReshapeFunc FunPtr ButtonBoxFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr ButtonBoxFunc -> IO ())
-> FunPtr ButtonBoxFunc -> IO ()
dyn_glutReshapeFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
forall a. FunPtr a
ptr_glutReshapeFunc FunPtr ButtonBoxFunc
v1

foreign import CALLCONV "dynamic" dyn_glutReshapeFunc
  :: FunPtr (FunPtr ReshapeFunc -> IO ())
  ->         FunPtr ReshapeFunc -> IO ()

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

-- glutReshapeWindow -----------------------------------------------------------

glutReshapeWindow :: MonadIO m => CInt -> CInt -> m ()
glutReshapeWindow :: CInt -> CInt -> m ()
glutReshapeWindow CInt
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr ButtonBoxFunc -> ButtonBoxFunc
dyn_glutReshapeWindow FunPtr ButtonBoxFunc
forall a. FunPtr a
ptr_glutReshapeWindow CInt
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutReshapeWindow
  :: FunPtr (CInt -> CInt -> IO ())
  ->         CInt -> CInt -> IO ()

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

-- glutSetColor ----------------------------------------------------------------

glutSetColor :: MonadIO m => CInt -> GLfloat -> GLfloat -> GLfloat -> m ()
glutSetColor :: CInt -> GLfloat -> GLfloat -> GLfloat -> m ()
glutSetColor CInt
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> GLfloat -> GLfloat -> GLfloat -> IO ())
-> CInt -> GLfloat -> GLfloat -> GLfloat -> IO ()
dyn_glutSetColor FunPtr (CInt -> GLfloat -> GLfloat -> GLfloat -> IO ())
forall a. FunPtr a
ptr_glutSetColor CInt
v1 GLfloat
v2 GLfloat
v3 GLfloat
v4

foreign import CALLCONV "dynamic" dyn_glutSetColor
  :: FunPtr (CInt -> GLfloat -> GLfloat -> GLfloat -> IO ())
  ->         CInt -> GLfloat -> GLfloat -> GLfloat -> IO ()

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

-- glutSetCursor ---------------------------------------------------------------

glutSetCursor :: MonadIO m => CInt -> m ()
glutSetCursor :: CInt -> m ()
glutSetCursor CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutSetCursor FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutSetCursor CInt
v1

foreign import CALLCONV "dynamic" dyn_glutSetCursor
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutSetIconTitle ------------------------------------------------------------

glutSetIconTitle :: MonadIO m => Ptr CChar -> m ()
glutSetIconTitle :: CString -> m ()
glutSetIconTitle CString
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CString -> IO ()) -> CString -> IO ()
dyn_glutSetIconTitle FunPtr (CString -> IO ())
forall a. FunPtr a
ptr_glutSetIconTitle CString
v1

foreign import CALLCONV "dynamic" dyn_glutSetIconTitle
  :: FunPtr (Ptr CChar -> IO ())
  ->         Ptr CChar -> IO ()

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

-- glutSetKeyRepeat ------------------------------------------------------------

glutSetKeyRepeat :: MonadIO m => CInt -> m ()
glutSetKeyRepeat :: CInt -> m ()
glutSetKeyRepeat CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutSetKeyRepeat FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutSetKeyRepeat CInt
v1

foreign import CALLCONV "dynamic" dyn_glutSetKeyRepeat
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutSetMenu -----------------------------------------------------------------

glutSetMenu :: MonadIO m => CInt -> m ()
glutSetMenu :: CInt -> m ()
glutSetMenu CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutSetMenu FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutSetMenu CInt
v1

foreign import CALLCONV "dynamic" dyn_glutSetMenu
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutSetMenuData -------------------------------------------------------------

glutSetMenuData :: MonadIO m => Ptr a -> m ()
glutSetMenuData :: Ptr a -> m ()
glutSetMenuData Ptr a
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> IO ()) -> Ptr a -> IO ()
forall a. FunPtr (Ptr a -> IO ()) -> Ptr a -> IO ()
dyn_glutSetMenuData FunPtr (Ptr a -> IO ())
forall a. FunPtr a
ptr_glutSetMenuData Ptr a
v1

foreign import CALLCONV "dynamic" dyn_glutSetMenuData
  :: FunPtr (Ptr a -> IO ())
  ->         Ptr a -> IO ()

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

-- glutSetMenuFont -------------------------------------------------------------

glutSetMenuFont :: MonadIO m => CInt -> Ptr a -> m ()
glutSetMenuFont :: CInt -> Ptr a -> m ()
glutSetMenuFont CInt
v1 Ptr a
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> Ptr a -> IO ()) -> CInt -> Ptr a -> IO ()
forall a. FunPtr (CInt -> Ptr a -> IO ()) -> CInt -> Ptr a -> IO ()
dyn_glutSetMenuFont FunPtr (CInt -> Ptr a -> IO ())
forall a. FunPtr a
ptr_glutSetMenuFont CInt
v1 Ptr a
v2

foreign import CALLCONV "dynamic" dyn_glutSetMenuFont
  :: FunPtr (CInt -> Ptr a -> IO ())
  ->         CInt -> Ptr a -> IO ()

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

-- glutSetOption ---------------------------------------------------------------

glutSetOption :: MonadIO m => GLenum -> CInt -> m ()
glutSetOption :: GLenum -> CInt -> m ()
glutSetOption GLenum
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLenum -> CInt -> IO ()) -> GLenum -> CInt -> IO ()
dyn_glutSetOption FunPtr (GLenum -> CInt -> IO ())
forall a. FunPtr a
ptr_glutSetOption GLenum
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutSetOption
  :: FunPtr (GLenum -> CInt -> IO ())
  ->         GLenum -> CInt -> IO ()

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

-- glutSetVertexAttribCoord3 ---------------------------------------------------

glutSetVertexAttribCoord3 :: MonadIO m => GLint -> m ()
glutSetVertexAttribCoord3 :: GLint -> m ()
glutSetVertexAttribCoord3 GLint
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLint -> IO ()) -> GLint -> IO ()
dyn_glutSetVertexAttribCoord3 FunPtr (GLint -> IO ())
forall a. FunPtr a
ptr_glutSetVertexAttribCoord3 GLint
v1

foreign import CALLCONV "dynamic" dyn_glutSetVertexAttribCoord3
  :: FunPtr (GLint -> IO ())
  ->         GLint -> IO ()

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

-- glutSetVertexAttribNormal ---------------------------------------------------

glutSetVertexAttribNormal :: MonadIO m => GLint -> m ()
glutSetVertexAttribNormal :: GLint -> m ()
glutSetVertexAttribNormal GLint
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLint -> IO ()) -> GLint -> IO ()
dyn_glutSetVertexAttribNormal FunPtr (GLint -> IO ())
forall a. FunPtr a
ptr_glutSetVertexAttribNormal GLint
v1

foreign import CALLCONV "dynamic" dyn_glutSetVertexAttribNormal
  :: FunPtr (GLint -> IO ())
  ->         GLint -> IO ()

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

-- glutSetVertexAttribTexCoord2 ------------------------------------------------

glutSetVertexAttribTexCoord2 :: MonadIO m => GLint -> m ()
glutSetVertexAttribTexCoord2 :: GLint -> m ()
glutSetVertexAttribTexCoord2 GLint
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLint -> IO ()) -> GLint -> IO ()
dyn_glutSetVertexAttribTexCoord2 FunPtr (GLint -> IO ())
forall a. FunPtr a
ptr_glutSetVertexAttribTexCoord2 GLint
v1

foreign import CALLCONV "dynamic" dyn_glutSetVertexAttribTexCoord2
  :: FunPtr (GLint -> IO ())
  ->         GLint -> IO ()

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

-- glutSetWindow ---------------------------------------------------------------

glutSetWindow :: MonadIO m => CInt -> m ()
glutSetWindow :: CInt -> m ()
glutSetWindow CInt
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutSetWindow FunPtr (CInt -> IO ())
forall a. FunPtr a
ptr_glutSetWindow CInt
v1

foreign import CALLCONV "dynamic" dyn_glutSetWindow
  :: FunPtr (CInt -> IO ())
  ->         CInt -> IO ()

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

-- glutSetWindowData -----------------------------------------------------------

glutSetWindowData :: MonadIO m => Ptr a -> m ()
glutSetWindowData :: Ptr a -> m ()
glutSetWindowData Ptr a
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> IO ()) -> Ptr a -> IO ()
forall a. FunPtr (Ptr a -> IO ()) -> Ptr a -> IO ()
dyn_glutSetWindowData FunPtr (Ptr a -> IO ())
forall a. FunPtr a
ptr_glutSetWindowData Ptr a
v1

foreign import CALLCONV "dynamic" dyn_glutSetWindowData
  :: FunPtr (Ptr a -> IO ())
  ->         Ptr a -> IO ()

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

-- glutSetWindowTitle ----------------------------------------------------------

glutSetWindowTitle :: MonadIO m => Ptr CChar -> m ()
glutSetWindowTitle :: CString -> m ()
glutSetWindowTitle CString
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CString -> IO ()) -> CString -> IO ()
dyn_glutSetWindowTitle FunPtr (CString -> IO ())
forall a. FunPtr a
ptr_glutSetWindowTitle CString
v1

foreign import CALLCONV "dynamic" dyn_glutSetWindowTitle
  :: FunPtr (Ptr CChar -> IO ())
  ->         Ptr CChar -> IO ()

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

-- glutSetupVideoResizing ------------------------------------------------------

glutSetupVideoResizing :: MonadIO m => m ()
glutSetupVideoResizing :: m ()
glutSetupVideoResizing = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutSetupVideoResizing FunPtr (IO ())
forall a. FunPtr a
ptr_glutSetupVideoResizing

foreign import CALLCONV "dynamic" dyn_glutSetupVideoResizing
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutShowOverlay -------------------------------------------------------------

glutShowOverlay :: MonadIO m => m ()
glutShowOverlay :: m ()
glutShowOverlay = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutShowOverlay FunPtr (IO ())
forall a. FunPtr a
ptr_glutShowOverlay

foreign import CALLCONV "dynamic" dyn_glutShowOverlay
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutShowWindow --------------------------------------------------------------

glutShowWindow :: MonadIO m => m ()
glutShowWindow :: m ()
glutShowWindow = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutShowWindow FunPtr (IO ())
forall a. FunPtr a
ptr_glutShowWindow

foreign import CALLCONV "dynamic" dyn_glutShowWindow
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutSolidCone ---------------------------------------------------------------

glutSolidCone :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutSolidCone :: GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutSolidCone GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
-> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
dyn_glutSolidCone FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
forall a. FunPtr a
ptr_glutSolidCone GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4

foreign import CALLCONV "dynamic" dyn_glutSolidCone
  :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
  ->         GLdouble -> GLdouble -> GLint -> GLint -> IO ()

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

-- glutSolidCube ---------------------------------------------------------------

glutSolidCube :: MonadIO m => GLdouble -> m ()
glutSolidCube :: GLdouble -> m ()
glutSolidCube GLdouble
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> IO ()) -> GLdouble -> IO ()
dyn_glutSolidCube FunPtr (GLdouble -> IO ())
forall a. FunPtr a
ptr_glutSolidCube GLdouble
v1

foreign import CALLCONV "dynamic" dyn_glutSolidCube
  :: FunPtr (GLdouble -> IO ())
  ->         GLdouble -> IO ()

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

-- glutSolidCylinder -----------------------------------------------------------

glutSolidCylinder :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutSolidCylinder :: GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutSolidCylinder GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
-> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
dyn_glutSolidCylinder FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
forall a. FunPtr a
ptr_glutSolidCylinder GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4

foreign import CALLCONV "dynamic" dyn_glutSolidCylinder
  :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
  ->         GLdouble -> GLdouble -> GLint -> GLint -> IO ()

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

-- glutSolidDodecahedron -------------------------------------------------------

glutSolidDodecahedron :: MonadIO m => m ()
glutSolidDodecahedron :: m ()
glutSolidDodecahedron = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutSolidDodecahedron FunPtr (IO ())
forall a. FunPtr a
ptr_glutSolidDodecahedron

foreign import CALLCONV "dynamic" dyn_glutSolidDodecahedron
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutSolidIcosahedron --------------------------------------------------------

glutSolidIcosahedron :: MonadIO m => m ()
glutSolidIcosahedron :: m ()
glutSolidIcosahedron = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutSolidIcosahedron FunPtr (IO ())
forall a. FunPtr a
ptr_glutSolidIcosahedron

foreign import CALLCONV "dynamic" dyn_glutSolidIcosahedron
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutSolidOctahedron ---------------------------------------------------------

glutSolidOctahedron :: MonadIO m => m ()
glutSolidOctahedron :: m ()
glutSolidOctahedron = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutSolidOctahedron FunPtr (IO ())
forall a. FunPtr a
ptr_glutSolidOctahedron

foreign import CALLCONV "dynamic" dyn_glutSolidOctahedron
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutSolidRhombicDodecahedron ------------------------------------------------

glutSolidRhombicDodecahedron :: MonadIO m => m ()
glutSolidRhombicDodecahedron :: m ()
glutSolidRhombicDodecahedron = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutSolidRhombicDodecahedron FunPtr (IO ())
forall a. FunPtr a
ptr_glutSolidRhombicDodecahedron

foreign import CALLCONV "dynamic" dyn_glutSolidRhombicDodecahedron
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutSolidSierpinskiSponge ---------------------------------------------------

glutSolidSierpinskiSponge :: MonadIO m => CInt -> Ptr GLdouble -> GLdouble -> m ()
glutSolidSierpinskiSponge :: CInt -> Ptr GLdouble -> GLdouble -> m ()
glutSolidSierpinskiSponge CInt
v1 Ptr GLdouble
v2 GLdouble
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
-> CInt -> Ptr GLdouble -> GLdouble -> IO ()
dyn_glutSolidSierpinskiSponge FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
forall a. FunPtr a
ptr_glutSolidSierpinskiSponge CInt
v1 Ptr GLdouble
v2 GLdouble
v3

foreign import CALLCONV "dynamic" dyn_glutSolidSierpinskiSponge
  :: FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
  ->         CInt -> Ptr GLdouble -> GLdouble -> IO ()

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

-- glutSolidSphere -------------------------------------------------------------

glutSolidSphere :: MonadIO m => GLdouble -> GLint -> GLint -> m ()
glutSolidSphere :: GLdouble -> GLint -> GLint -> m ()
glutSolidSphere GLdouble
v1 GLint
v2 GLint
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> GLint -> GLint -> IO ())
-> GLdouble -> GLint -> GLint -> IO ()
dyn_glutSolidSphere FunPtr (GLdouble -> GLint -> GLint -> IO ())
forall a. FunPtr a
ptr_glutSolidSphere GLdouble
v1 GLint
v2 GLint
v3

foreign import CALLCONV "dynamic" dyn_glutSolidSphere
  :: FunPtr (GLdouble -> GLint -> GLint -> IO ())
  ->         GLdouble -> GLint -> GLint -> IO ()

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

-- glutSolidTeacup -------------------------------------------------------------

glutSolidTeacup :: MonadIO m => GLdouble -> m ()
glutSolidTeacup :: GLdouble -> m ()
glutSolidTeacup GLdouble
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> IO ()) -> GLdouble -> IO ()
dyn_glutSolidTeacup FunPtr (GLdouble -> IO ())
forall a. FunPtr a
ptr_glutSolidTeacup GLdouble
v1

foreign import CALLCONV "dynamic" dyn_glutSolidTeacup
  :: FunPtr (GLdouble -> IO ())
  ->         GLdouble -> IO ()

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

-- glutSolidTeapot -------------------------------------------------------------

glutSolidTeapot :: MonadIO m => GLdouble -> m ()
glutSolidTeapot :: GLdouble -> m ()
glutSolidTeapot GLdouble
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> IO ()) -> GLdouble -> IO ()
dyn_glutSolidTeapot FunPtr (GLdouble -> IO ())
forall a. FunPtr a
ptr_glutSolidTeapot GLdouble
v1

foreign import CALLCONV "dynamic" dyn_glutSolidTeapot
  :: FunPtr (GLdouble -> IO ())
  ->         GLdouble -> IO ()

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

-- glutSolidTeaspoon -----------------------------------------------------------

glutSolidTeaspoon :: MonadIO m => GLdouble -> m ()
glutSolidTeaspoon :: GLdouble -> m ()
glutSolidTeaspoon GLdouble
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> IO ()) -> GLdouble -> IO ()
dyn_glutSolidTeaspoon FunPtr (GLdouble -> IO ())
forall a. FunPtr a
ptr_glutSolidTeaspoon GLdouble
v1

foreign import CALLCONV "dynamic" dyn_glutSolidTeaspoon
  :: FunPtr (GLdouble -> IO ())
  ->         GLdouble -> IO ()

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

-- glutSolidTetrahedron --------------------------------------------------------

glutSolidTetrahedron :: MonadIO m => m ()
glutSolidTetrahedron :: m ()
glutSolidTetrahedron = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutSolidTetrahedron FunPtr (IO ())
forall a. FunPtr a
ptr_glutSolidTetrahedron

foreign import CALLCONV "dynamic" dyn_glutSolidTetrahedron
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutSolidTorus --------------------------------------------------------------

glutSolidTorus :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutSolidTorus :: GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutSolidTorus GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
-> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
dyn_glutSolidTorus FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
forall a. FunPtr a
ptr_glutSolidTorus GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4

foreign import CALLCONV "dynamic" dyn_glutSolidTorus
  :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
  ->         GLdouble -> GLdouble -> GLint -> GLint -> IO ()

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

-- glutSpaceballButtonFunc -----------------------------------------------------

glutSpaceballButtonFunc :: MonadIO m => FunPtr SpaceballButtonFunc -> m ()
glutSpaceballButtonFunc :: FunPtr ButtonBoxFunc -> m ()
glutSpaceballButtonFunc FunPtr ButtonBoxFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr ButtonBoxFunc -> IO ())
-> FunPtr ButtonBoxFunc -> IO ()
dyn_glutSpaceballButtonFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
forall a. FunPtr a
ptr_glutSpaceballButtonFunc FunPtr ButtonBoxFunc
v1

foreign import CALLCONV "dynamic" dyn_glutSpaceballButtonFunc
  :: FunPtr (FunPtr SpaceballButtonFunc -> IO ())
  ->         FunPtr SpaceballButtonFunc -> IO ()

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

-- glutSpaceballMotionFunc -----------------------------------------------------

glutSpaceballMotionFunc :: MonadIO m => FunPtr SpaceballMotionFunc -> m ()
glutSpaceballMotionFunc :: FunPtr MenuStatusFunc -> m ()
glutSpaceballMotionFunc FunPtr MenuStatusFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr MenuStatusFunc -> IO ())
-> FunPtr MenuStatusFunc -> IO ()
dyn_glutSpaceballMotionFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
forall a. FunPtr a
ptr_glutSpaceballMotionFunc FunPtr MenuStatusFunc
v1

foreign import CALLCONV "dynamic" dyn_glutSpaceballMotionFunc
  :: FunPtr (FunPtr SpaceballMotionFunc -> IO ())
  ->         FunPtr SpaceballMotionFunc -> IO ()

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

-- glutSpaceballRotateFunc -----------------------------------------------------

glutSpaceballRotateFunc :: MonadIO m => FunPtr SpaceballRotateFunc -> m ()
glutSpaceballRotateFunc :: FunPtr MenuStatusFunc -> m ()
glutSpaceballRotateFunc FunPtr MenuStatusFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr MenuStatusFunc -> IO ())
-> FunPtr MenuStatusFunc -> IO ()
dyn_glutSpaceballRotateFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
forall a. FunPtr a
ptr_glutSpaceballRotateFunc FunPtr MenuStatusFunc
v1

foreign import CALLCONV "dynamic" dyn_glutSpaceballRotateFunc
  :: FunPtr (FunPtr SpaceballRotateFunc -> IO ())
  ->         FunPtr SpaceballRotateFunc -> IO ()

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

-- glutSpecialFunc -------------------------------------------------------------

glutSpecialFunc :: MonadIO m => FunPtr SpecialFunc -> m ()
glutSpecialFunc :: FunPtr MenuStatusFunc -> m ()
glutSpecialFunc FunPtr MenuStatusFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr MenuStatusFunc -> IO ())
-> FunPtr MenuStatusFunc -> IO ()
dyn_glutSpecialFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
forall a. FunPtr a
ptr_glutSpecialFunc FunPtr MenuStatusFunc
v1

foreign import CALLCONV "dynamic" dyn_glutSpecialFunc
  :: FunPtr (FunPtr SpecialFunc -> IO ())
  ->         FunPtr SpecialFunc -> IO ()

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

-- glutSpecialUpFunc -----------------------------------------------------------

glutSpecialUpFunc :: MonadIO m => FunPtr SpecialUpFunc -> m ()
glutSpecialUpFunc :: FunPtr MenuStatusFunc -> m ()
glutSpecialUpFunc FunPtr MenuStatusFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr MenuStatusFunc -> IO ())
-> FunPtr MenuStatusFunc -> IO ()
dyn_glutSpecialUpFunc FunPtr (FunPtr MenuStatusFunc -> IO ())
forall a. FunPtr a
ptr_glutSpecialUpFunc FunPtr MenuStatusFunc
v1

foreign import CALLCONV "dynamic" dyn_glutSpecialUpFunc
  :: FunPtr (FunPtr SpecialUpFunc -> IO ())
  ->         FunPtr SpecialUpFunc -> IO ()

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

-- glutStopVideoResizing -------------------------------------------------------

glutStopVideoResizing :: MonadIO m => m ()
glutStopVideoResizing :: m ()
glutStopVideoResizing = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutStopVideoResizing FunPtr (IO ())
forall a. FunPtr a
ptr_glutStopVideoResizing

foreign import CALLCONV "dynamic" dyn_glutStopVideoResizing
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutStrokeCharacter ---------------------------------------------------------

glutStrokeCharacter :: MonadIO m => Ptr a -> CInt -> m ()
glutStrokeCharacter :: Ptr a -> CInt -> m ()
glutStrokeCharacter Ptr a
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> CInt -> IO ()) -> Ptr a -> CInt -> IO ()
forall a. FunPtr (Ptr a -> CInt -> IO ()) -> Ptr a -> CInt -> IO ()
dyn_glutStrokeCharacter FunPtr (Ptr a -> CInt -> IO ())
forall a. FunPtr a
ptr_glutStrokeCharacter Ptr a
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutStrokeCharacter
  :: FunPtr (Ptr a -> CInt -> IO ())
  ->         Ptr a -> CInt -> IO ()

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

-- glutStrokeHeight ------------------------------------------------------------

glutStrokeHeight :: MonadIO m => Ptr a -> m GLfloat
glutStrokeHeight :: Ptr a -> m GLfloat
glutStrokeHeight Ptr a
v1 = IO GLfloat -> m GLfloat
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO GLfloat -> m GLfloat) -> IO GLfloat -> m GLfloat
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> IO GLfloat) -> Ptr a -> IO GLfloat
forall a. FunPtr (Ptr a -> IO GLfloat) -> Ptr a -> IO GLfloat
dyn_glutStrokeHeight FunPtr (Ptr a -> IO GLfloat)
forall a. FunPtr a
ptr_glutStrokeHeight Ptr a
v1

foreign import CALLCONV "dynamic" dyn_glutStrokeHeight
  :: FunPtr (Ptr a -> IO GLfloat)
  ->         Ptr a -> IO GLfloat

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

-- glutStrokeLength ------------------------------------------------------------

glutStrokeLength :: MonadIO m => Ptr a -> Ptr CUChar -> m CInt
glutStrokeLength :: Ptr a -> Ptr CUChar -> m CInt
glutStrokeLength Ptr a
v1 Ptr CUChar
v2 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
-> Ptr a -> Ptr CUChar -> IO CInt
forall a.
FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
-> Ptr a -> Ptr CUChar -> IO CInt
dyn_glutStrokeLength FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
forall a. FunPtr a
ptr_glutStrokeLength Ptr a
v1 Ptr CUChar
v2

foreign import CALLCONV "dynamic" dyn_glutStrokeLength
  :: FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
  ->         Ptr a -> Ptr CUChar -> IO CInt

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

-- glutStrokeString ------------------------------------------------------------

glutStrokeString :: MonadIO m => Ptr a -> Ptr CUChar -> m ()
glutStrokeString :: Ptr a -> Ptr CUChar -> m ()
glutStrokeString Ptr a
v1 Ptr CUChar
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> Ptr CUChar -> IO ())
-> Ptr a -> Ptr CUChar -> IO ()
forall a.
FunPtr (Ptr a -> Ptr CUChar -> IO ())
-> Ptr a -> Ptr CUChar -> IO ()
dyn_glutStrokeString FunPtr (Ptr a -> Ptr CUChar -> IO ())
forall a. FunPtr a
ptr_glutStrokeString Ptr a
v1 Ptr CUChar
v2

foreign import CALLCONV "dynamic" dyn_glutStrokeString
  :: FunPtr (Ptr a -> Ptr CUChar -> IO ())
  ->         Ptr a -> Ptr CUChar -> IO ()

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

-- glutStrokeWidth -------------------------------------------------------------

glutStrokeWidth :: MonadIO m => Ptr a -> CInt -> m CInt
glutStrokeWidth :: Ptr a -> CInt -> m CInt
glutStrokeWidth Ptr a
v1 CInt
v2 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (Ptr a -> CInt -> IO CInt) -> Ptr a -> CInt -> IO CInt
forall a.
FunPtr (Ptr a -> CInt -> IO CInt) -> Ptr a -> CInt -> IO CInt
dyn_glutStrokeWidth FunPtr (Ptr a -> CInt -> IO CInt)
forall a. FunPtr a
ptr_glutStrokeWidth Ptr a
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutStrokeWidth
  :: FunPtr (Ptr a -> CInt -> IO CInt)
  ->         Ptr a -> CInt -> IO CInt

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

-- glutSwapBuffers -------------------------------------------------------------

glutSwapBuffers :: MonadIO m => m ()
glutSwapBuffers :: m ()
glutSwapBuffers = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutSwapBuffers FunPtr (IO ())
forall a. FunPtr a
ptr_glutSwapBuffers

foreign import CALLCONV "dynamic" dyn_glutSwapBuffers
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutTabletButtonFunc --------------------------------------------------------

glutTabletButtonFunc :: MonadIO m => FunPtr TabletButtonFunc -> m ()
glutTabletButtonFunc :: FunPtr MouseFunc -> m ()
glutTabletButtonFunc FunPtr MouseFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr MouseFunc -> IO ()) -> FunPtr MouseFunc -> IO ()
dyn_glutTabletButtonFunc FunPtr (FunPtr MouseFunc -> IO ())
forall a. FunPtr a
ptr_glutTabletButtonFunc FunPtr MouseFunc
v1

foreign import CALLCONV "dynamic" dyn_glutTabletButtonFunc
  :: FunPtr (FunPtr TabletButtonFunc -> IO ())
  ->         FunPtr TabletButtonFunc -> IO ()

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

-- glutTabletMotionFunc --------------------------------------------------------

glutTabletMotionFunc :: MonadIO m => FunPtr TabletMotionFunc -> m ()
glutTabletMotionFunc :: FunPtr ButtonBoxFunc -> m ()
glutTabletMotionFunc FunPtr ButtonBoxFunc
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr ButtonBoxFunc -> IO ())
-> FunPtr ButtonBoxFunc -> IO ()
dyn_glutTabletMotionFunc FunPtr (FunPtr ButtonBoxFunc -> IO ())
forall a. FunPtr a
ptr_glutTabletMotionFunc FunPtr ButtonBoxFunc
v1

foreign import CALLCONV "dynamic" dyn_glutTabletMotionFunc
  :: FunPtr (FunPtr TabletMotionFunc -> IO ())
  ->         FunPtr TabletMotionFunc -> IO ()

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

-- glutTimerFunc ---------------------------------------------------------------

glutTimerFunc :: MonadIO m => CUInt -> FunPtr TimerFunc -> CInt -> m ()
glutTimerFunc :: CUInt -> FunPtr (CInt -> IO ()) -> CInt -> m ()
glutTimerFunc CUInt
v1 FunPtr (CInt -> IO ())
v2 CInt
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CUInt -> FunPtr (CInt -> IO ()) -> CInt -> IO ())
-> CUInt -> FunPtr (CInt -> IO ()) -> CInt -> IO ()
dyn_glutTimerFunc FunPtr (CUInt -> FunPtr (CInt -> IO ()) -> CInt -> IO ())
forall a. FunPtr a
ptr_glutTimerFunc CUInt
v1 FunPtr (CInt -> IO ())
v2 CInt
v3

foreign import CALLCONV "dynamic" dyn_glutTimerFunc
  :: FunPtr (CUInt -> FunPtr TimerFunc -> CInt -> IO ())
  ->         CUInt -> FunPtr TimerFunc -> CInt -> IO ()

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

-- glutUseLayer ----------------------------------------------------------------

glutUseLayer :: MonadIO m => GLenum -> m ()
glutUseLayer :: GLenum -> m ()
glutUseLayer GLenum
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLenum -> IO ()) -> GLenum -> IO ()
dyn_glutUseLayer FunPtr (GLenum -> IO ())
forall a. FunPtr a
ptr_glutUseLayer GLenum
v1

foreign import CALLCONV "dynamic" dyn_glutUseLayer
  :: FunPtr (GLenum -> IO ())
  ->         GLenum -> IO ()

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

-- glutVideoPan ----------------------------------------------------------------

glutVideoPan :: MonadIO m => CInt -> CInt -> CInt -> CInt -> m ()
glutVideoPan :: CInt -> CInt -> CInt -> CInt -> m ()
glutVideoPan CInt
v1 CInt
v2 CInt
v3 CInt
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr MouseFunc -> MouseFunc
dyn_glutVideoPan FunPtr MouseFunc
forall a. FunPtr a
ptr_glutVideoPan CInt
v1 CInt
v2 CInt
v3 CInt
v4

foreign import CALLCONV "dynamic" dyn_glutVideoPan
  :: FunPtr (CInt -> CInt -> CInt -> CInt -> IO ())
  ->         CInt -> CInt -> CInt -> CInt -> IO ()

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

-- glutVideoResize -------------------------------------------------------------

glutVideoResize :: MonadIO m => CInt -> CInt -> CInt -> CInt -> m ()
glutVideoResize :: CInt -> CInt -> CInt -> CInt -> m ()
glutVideoResize CInt
v1 CInt
v2 CInt
v3 CInt
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr MouseFunc -> MouseFunc
dyn_glutVideoResize FunPtr MouseFunc
forall a. FunPtr a
ptr_glutVideoResize CInt
v1 CInt
v2 CInt
v3 CInt
v4

foreign import CALLCONV "dynamic" dyn_glutVideoResize
  :: FunPtr (CInt -> CInt -> CInt -> CInt -> IO ())
  ->         CInt -> CInt -> CInt -> CInt -> IO ()

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

-- glutVideoResizeGet ----------------------------------------------------------

glutVideoResizeGet :: MonadIO m => GLenum -> m CInt
glutVideoResizeGet :: GLenum -> m CInt
glutVideoResizeGet GLenum
v1 = IO CInt -> m CInt
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO CInt -> m CInt) -> IO CInt -> m CInt
forall a b. (a -> b) -> a -> b
$ FunPtr (GLenum -> IO CInt) -> GLenum -> IO CInt
dyn_glutVideoResizeGet FunPtr (GLenum -> IO CInt)
forall a. FunPtr a
ptr_glutVideoResizeGet GLenum
v1

foreign import CALLCONV "dynamic" dyn_glutVideoResizeGet
  :: FunPtr (GLenum -> IO CInt)
  ->         GLenum -> IO CInt

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

-- glutVisibilityFunc ----------------------------------------------------------

glutVisibilityFunc :: MonadIO m => FunPtr VisibilityFunc -> m ()
glutVisibilityFunc :: FunPtr (CInt -> IO ()) -> m ()
glutVisibilityFunc FunPtr (CInt -> IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (CInt -> IO ()) -> IO ())
-> FunPtr (CInt -> IO ()) -> IO ()
dyn_glutVisibilityFunc FunPtr (FunPtr (CInt -> IO ()) -> IO ())
forall a. FunPtr a
ptr_glutVisibilityFunc FunPtr (CInt -> IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutVisibilityFunc
  :: FunPtr (FunPtr VisibilityFunc -> IO ())
  ->         FunPtr VisibilityFunc -> IO ()

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

-- glutWMCloseFunc -------------------------------------------------------------

glutWMCloseFunc :: MonadIO m => FunPtr WMCloseFunc -> m ()
glutWMCloseFunc :: FunPtr (IO ()) -> m ()
glutWMCloseFunc FunPtr (IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (IO ()) -> IO ()) -> FunPtr (IO ()) -> IO ()
dyn_glutWMCloseFunc FunPtr (FunPtr (IO ()) -> IO ())
forall a. FunPtr a
ptr_glutWMCloseFunc FunPtr (IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutWMCloseFunc
  :: FunPtr (FunPtr WMCloseFunc -> IO ())
  ->         FunPtr WMCloseFunc -> IO ()

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

-- glutWarpPointer -------------------------------------------------------------

glutWarpPointer :: MonadIO m => CInt -> CInt -> m ()
glutWarpPointer :: CInt -> CInt -> m ()
glutWarpPointer CInt
v1 CInt
v2 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr ButtonBoxFunc -> ButtonBoxFunc
dyn_glutWarpPointer FunPtr ButtonBoxFunc
forall a. FunPtr a
ptr_glutWarpPointer CInt
v1 CInt
v2

foreign import CALLCONV "dynamic" dyn_glutWarpPointer
  :: FunPtr (CInt -> CInt -> IO ())
  ->         CInt -> CInt -> IO ()

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

-- glutWindowStatusFunc --------------------------------------------------------

glutWindowStatusFunc :: MonadIO m => FunPtr WindowStatusFunc -> m ()
glutWindowStatusFunc :: FunPtr (CInt -> IO ()) -> m ()
glutWindowStatusFunc FunPtr (CInt -> IO ())
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (FunPtr (CInt -> IO ()) -> IO ())
-> FunPtr (CInt -> IO ()) -> IO ()
dyn_glutWindowStatusFunc FunPtr (FunPtr (CInt -> IO ()) -> IO ())
forall a. FunPtr a
ptr_glutWindowStatusFunc FunPtr (CInt -> IO ())
v1

foreign import CALLCONV "dynamic" dyn_glutWindowStatusFunc
  :: FunPtr (FunPtr WindowStatusFunc -> IO ())
  ->         FunPtr WindowStatusFunc -> IO ()

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

-- glutWireCone ----------------------------------------------------------------

glutWireCone :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutWireCone :: GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutWireCone GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
-> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
dyn_glutWireCone FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
forall a. FunPtr a
ptr_glutWireCone GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4

foreign import CALLCONV "dynamic" dyn_glutWireCone
  :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
  ->         GLdouble -> GLdouble -> GLint -> GLint -> IO ()

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

-- glutWireCube ----------------------------------------------------------------

glutWireCube :: MonadIO m => GLdouble -> m ()
glutWireCube :: GLdouble -> m ()
glutWireCube GLdouble
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> IO ()) -> GLdouble -> IO ()
dyn_glutWireCube FunPtr (GLdouble -> IO ())
forall a. FunPtr a
ptr_glutWireCube GLdouble
v1

foreign import CALLCONV "dynamic" dyn_glutWireCube
  :: FunPtr (GLdouble -> IO ())
  ->         GLdouble -> IO ()

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

-- glutWireCylinder ------------------------------------------------------------

glutWireCylinder :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutWireCylinder :: GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutWireCylinder GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
-> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
dyn_glutWireCylinder FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
forall a. FunPtr a
ptr_glutWireCylinder GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4

foreign import CALLCONV "dynamic" dyn_glutWireCylinder
  :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
  ->         GLdouble -> GLdouble -> GLint -> GLint -> IO ()

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

-- glutWireDodecahedron --------------------------------------------------------

glutWireDodecahedron :: MonadIO m => m ()
glutWireDodecahedron :: m ()
glutWireDodecahedron = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutWireDodecahedron FunPtr (IO ())
forall a. FunPtr a
ptr_glutWireDodecahedron

foreign import CALLCONV "dynamic" dyn_glutWireDodecahedron
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutWireIcosahedron ---------------------------------------------------------

glutWireIcosahedron :: MonadIO m => m ()
glutWireIcosahedron :: m ()
glutWireIcosahedron = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutWireIcosahedron FunPtr (IO ())
forall a. FunPtr a
ptr_glutWireIcosahedron

foreign import CALLCONV "dynamic" dyn_glutWireIcosahedron
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutWireOctahedron ----------------------------------------------------------

glutWireOctahedron :: MonadIO m => m ()
glutWireOctahedron :: m ()
glutWireOctahedron = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutWireOctahedron FunPtr (IO ())
forall a. FunPtr a
ptr_glutWireOctahedron

foreign import CALLCONV "dynamic" dyn_glutWireOctahedron
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutWireRhombicDodecahedron -------------------------------------------------

glutWireRhombicDodecahedron :: MonadIO m => m ()
glutWireRhombicDodecahedron :: m ()
glutWireRhombicDodecahedron = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutWireRhombicDodecahedron FunPtr (IO ())
forall a. FunPtr a
ptr_glutWireRhombicDodecahedron

foreign import CALLCONV "dynamic" dyn_glutWireRhombicDodecahedron
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutWireSierpinskiSponge ----------------------------------------------------

glutWireSierpinskiSponge :: MonadIO m => CInt -> Ptr GLdouble -> GLdouble -> m ()
glutWireSierpinskiSponge :: CInt -> Ptr GLdouble -> GLdouble -> m ()
glutWireSierpinskiSponge CInt
v1 Ptr GLdouble
v2 GLdouble
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
-> CInt -> Ptr GLdouble -> GLdouble -> IO ()
dyn_glutWireSierpinskiSponge FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
forall a. FunPtr a
ptr_glutWireSierpinskiSponge CInt
v1 Ptr GLdouble
v2 GLdouble
v3

foreign import CALLCONV "dynamic" dyn_glutWireSierpinskiSponge
  :: FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
  ->         CInt -> Ptr GLdouble -> GLdouble -> IO ()

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

-- glutWireSphere --------------------------------------------------------------

glutWireSphere :: MonadIO m => GLdouble -> GLint -> GLint -> m ()
glutWireSphere :: GLdouble -> GLint -> GLint -> m ()
glutWireSphere GLdouble
v1 GLint
v2 GLint
v3 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> GLint -> GLint -> IO ())
-> GLdouble -> GLint -> GLint -> IO ()
dyn_glutWireSphere FunPtr (GLdouble -> GLint -> GLint -> IO ())
forall a. FunPtr a
ptr_glutWireSphere GLdouble
v1 GLint
v2 GLint
v3

foreign import CALLCONV "dynamic" dyn_glutWireSphere
  :: FunPtr (GLdouble -> GLint -> GLint -> IO ())
  ->         GLdouble -> GLint -> GLint -> IO ()

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

-- glutWireTeacup --------------------------------------------------------------

glutWireTeacup :: MonadIO m => GLdouble -> m ()
glutWireTeacup :: GLdouble -> m ()
glutWireTeacup GLdouble
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> IO ()) -> GLdouble -> IO ()
dyn_glutWireTeacup FunPtr (GLdouble -> IO ())
forall a. FunPtr a
ptr_glutWireTeacup GLdouble
v1

foreign import CALLCONV "dynamic" dyn_glutWireTeacup
  :: FunPtr (GLdouble -> IO ())
  ->         GLdouble -> IO ()

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

-- glutWireTeapot --------------------------------------------------------------

glutWireTeapot :: MonadIO m => GLdouble -> m ()
glutWireTeapot :: GLdouble -> m ()
glutWireTeapot GLdouble
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> IO ()) -> GLdouble -> IO ()
dyn_glutWireTeapot FunPtr (GLdouble -> IO ())
forall a. FunPtr a
ptr_glutWireTeapot GLdouble
v1

foreign import CALLCONV "dynamic" dyn_glutWireTeapot
  :: FunPtr (GLdouble -> IO ())
  ->         GLdouble -> IO ()

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

-- glutWireTeaspoon ------------------------------------------------------------

glutWireTeaspoon :: MonadIO m => GLdouble -> m ()
glutWireTeaspoon :: GLdouble -> m ()
glutWireTeaspoon GLdouble
v1 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> IO ()) -> GLdouble -> IO ()
dyn_glutWireTeaspoon FunPtr (GLdouble -> IO ())
forall a. FunPtr a
ptr_glutWireTeaspoon GLdouble
v1

foreign import CALLCONV "dynamic" dyn_glutWireTeaspoon
  :: FunPtr (GLdouble -> IO ())
  ->         GLdouble -> IO ()

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

-- glutWireTetrahedron ---------------------------------------------------------

glutWireTetrahedron :: MonadIO m => m ()
glutWireTetrahedron :: m ()
glutWireTetrahedron = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (IO ()) -> IO ()
dyn_glutWireTetrahedron FunPtr (IO ())
forall a. FunPtr a
ptr_glutWireTetrahedron

foreign import CALLCONV "dynamic" dyn_glutWireTetrahedron
  :: FunPtr (IO ())
  ->         IO ()

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

-- glutWireTorus ---------------------------------------------------------------

glutWireTorus :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutWireTorus :: GLdouble -> GLdouble -> GLint -> GLint -> m ()
glutWireTorus GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4 = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
-> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
dyn_glutWireTorus FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
forall a. FunPtr a
ptr_glutWireTorus GLdouble
v1 GLdouble
v2 GLint
v3 GLint
v4

foreign import CALLCONV "dynamic" dyn_glutWireTorus
  :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
  ->         GLdouble -> GLdouble -> GLint -> GLint -> IO ()

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