Debian Codegraph @

src/Graphics/UI/GLUT/Raw/Functions.hs

raw
1 {-# LANGUAGE CPP #-}
2 {-# OPTIONS_HADDOCK hide #-}
3 --------------------------------------------------------------------------------
4 -- |
5 -- Module : Graphics.UI.GLUT.Raw.Functions
6 -- Copyright : (c) Sven Panne 2018
7 -- License : BSD3
8 --
9 -- Maintainer : Sven Panne <[email protected]>
10 -- Stability : stable
11 -- Portability : portable
12 --
13 -- All raw functions from GLUT and freeglut.
14 --
15 --------------------------------------------------------------------------------
16
17 module Graphics.UI.GLUT.Raw.Functions (
18 isKnown,
19
20 glutAddMenuEntry,
21 glutAddSubMenu,
22 glutAppStatusFunc,
23 glutAttachMenu,
24 glutBitmapCharacter,
25 glutBitmapHeight,
26 glutBitmapLength,
27 glutBitmapString,
28 glutBitmapWidth,
29 glutButtonBoxFunc,
30 glutChangeToMenuEntry,
31 glutChangeToSubMenu,
32 glutCloseFunc,
33 glutCopyColormap,
34 glutCreateMenu,
35 glutCreateSubWindow,
36 glutCreateWindow,
37 glutDestroyMenu,
38 glutDestroyWindow,
39 glutDetachMenu,
40 glutDeviceGet,
41 glutDialsFunc,
42 glutDisplayFunc,
43 glutEnterGameMode,
44 glutEntryFunc,
45 glutEstablishOverlay,
46 glutExit,
47 glutExtensionSupported,
48 glutForceJoystickFunc,
49 glutFullScreen,
50 glutFullScreenToggle,
51 glutGameModeGet,
52 glutGameModeString,
53 glutGet,
54 glutGetColor,
55 glutGetMenu,
56 glutGetMenuData,
57 glutGetModeValues,
58 glutGetModifiers,
59 glutGetProcAddress,
60 glutGetWindow,
61 glutGetWindowData,
62 glutHideOverlay,
63 glutHideWindow,
64 glutIconifyWindow,
65 glutIdleFunc,
66 glutIgnoreKeyRepeat,
67 glutInit,
68 glutInitContextFlags,
69 glutInitContextFunc,
70 glutInitContextProfile,
71 glutInitContextVersion,
72 glutInitDisplayMode,
73 glutInitDisplayString,
74 glutInitWindowPosition,
75 glutInitWindowSize,
76 glutJoystickFunc,
77 glutKeyboardFunc,
78 glutKeyboardUpFunc,
79 glutLayerGet,
80 glutLeaveFullScreen,
81 glutLeaveGameMode,
82 glutLeaveMainLoop,
83 glutMainLoop,
84 glutMainLoopEvent,
85 glutMenuDestroyFunc,
86 glutMenuStateFunc,
87 glutMenuStatusFunc,
88 glutMotionFunc,
89 glutMouseFunc,
90 glutMouseWheelFunc,
91 glutMultiButtonFunc,
92 glutMultiEntryFunc,
93 glutMultiMotionFunc,
94 glutMultiPassiveFunc,
95 glutOverlayDisplayFunc,
96 glutPassiveMotionFunc,
97 glutPopWindow,
98 glutPositionFunc,
99 glutPositionWindow,
100 glutPostOverlayRedisplay,
101 glutPostRedisplay,
102 glutPostWindowOverlayRedisplay,
103 glutPostWindowRedisplay,
104 glutPushWindow,
105 glutRemoveMenuItem,
106 glutRemoveOverlay,
107 glutReportErrors,
108 glutReshapeFunc,
109 glutReshapeWindow,
110 glutSetColor,
111 glutSetCursor,
112 glutSetIconTitle,
113 glutSetKeyRepeat,
114 glutSetMenu,
115 glutSetMenuData,
116 glutSetMenuFont,
117 glutSetOption,
118 glutSetVertexAttribCoord3,
119 glutSetVertexAttribNormal,
120 glutSetVertexAttribTexCoord2,
121 glutSetWindow,
122 glutSetWindowData,
123 glutSetWindowTitle,
124 glutSetupVideoResizing,
125 glutShowOverlay,
126 glutShowWindow,
127 glutSolidCone,
128 glutSolidCube,
129 glutSolidCylinder,
130 glutSolidDodecahedron,
131 glutSolidIcosahedron,
132 glutSolidOctahedron,
133 glutSolidRhombicDodecahedron,
134 glutSolidSierpinskiSponge,
135 glutSolidSphere,
136 glutSolidTeacup,
137 glutSolidTeapot,
138 glutSolidTeaspoon,
139 glutSolidTetrahedron,
140 glutSolidTorus,
141 glutSpaceballButtonFunc,
142 glutSpaceballMotionFunc,
143 glutSpaceballRotateFunc,
144 glutSpecialFunc,
145 glutSpecialUpFunc,
146 glutStopVideoResizing,
147 glutStrokeCharacter,
148 glutStrokeHeight,
149 glutStrokeLength,
150 glutStrokeString,
151 glutStrokeWidth,
152 glutSwapBuffers,
153 glutTabletButtonFunc,
154 glutTabletMotionFunc,
155 glutTimerFunc,
156 glutUseLayer,
157 glutVideoPan,
158 glutVideoResize,
159 glutVideoResizeGet,
160 glutVisibilityFunc,
161 glutWMCloseFunc,
162 glutWarpPointer,
163 glutWindowStatusFunc,
164 glutWireCone,
165 glutWireCube,
166 glutWireCylinder,
167 glutWireDodecahedron,
168 glutWireIcosahedron,
169 glutWireOctahedron,
170 glutWireRhombicDodecahedron,
171 glutWireSierpinskiSponge,
172 glutWireSphere,
173 glutWireTeacup,
174 glutWireTeapot,
175 glutWireTeaspoon,
176 glutWireTetrahedron,
177 glutWireTorus
178 ) where
179
180 -- Make the foreign imports happy.
181 import Foreign.C.Types
182
183 import Control.Monad.IO.Class ( MonadIO(..) )
184 import Foreign.C.String ( withCString, CString )
185 import Foreign.Marshal.Error ( throwIf )
186 import Foreign.Ptr ( Ptr, FunPtr, nullFunPtr )
187 import Graphics.Rendering.OpenGL ( GLdouble, GLenum, GLfloat, GLint )
188 import System.IO.Unsafe ( unsafePerformIO )
189
190 import Graphics.UI.GLUT.Raw.Callbacks
191
192 --------------------------------------------------------------------------------
193
194 -- | Retrieve a GLUT API entry by name. Throws a userError when no entry with
195 -- the given name was found.
196 getAPIEntry :: String -> IO (FunPtr a)
197 getAPIEntry extensionEntry =
198 throwIfNullFunPtr ("unknown GLUT entry " ++ extensionEntry) $
199 getAPIEntryInternal extensionEntry
200
201 throwIfNullFunPtr :: String -> IO (FunPtr a) -> IO (FunPtr a)
202 throwIfNullFunPtr = throwIf (== nullFunPtr) . const
203
204 getAPIEntryInternal :: String -> IO (FunPtr a)
205 getAPIEntryInternal extensionEntry =
206 withCString extensionEntry hs_GLUT_getProcAddress
207
208 isKnown :: MonadIO m => String -> m Bool
209 isKnown = liftIO . fmap (/= nullFunPtr) . getAPIEntryInternal
210
211 foreign import ccall unsafe "hs_GLUT_getProcAddress"
212 hs_GLUT_getProcAddress :: CString -> IO (FunPtr a)
213
214 -- glutAddMenuEntry ------------------------------------------------------------
215
216 glutAddMenuEntry :: MonadIO m => Ptr CChar -> CInt -> m ()
217 glutAddMenuEntry v1 v2 = liftIO $ dyn_glutAddMenuEntry ptr_glutAddMenuEntry v1 v2
218
219 foreign import CALLCONV "dynamic" dyn_glutAddMenuEntry
220 :: FunPtr (Ptr CChar -> CInt -> IO ())
221 -> Ptr CChar -> CInt -> IO ()
222
223 {-# NOINLINE ptr_glutAddMenuEntry #-}
224 ptr_glutAddMenuEntry :: FunPtr a
225 ptr_glutAddMenuEntry = unsafePerformIO $ getAPIEntry "glutAddMenuEntry"
226
227 -- glutAddSubMenu --------------------------------------------------------------
228
229 glutAddSubMenu :: MonadIO m => Ptr CChar -> CInt -> m ()
230 glutAddSubMenu v1 v2 = liftIO $ dyn_glutAddSubMenu ptr_glutAddSubMenu v1 v2
231
232 foreign import CALLCONV "dynamic" dyn_glutAddSubMenu
233 :: FunPtr (Ptr CChar -> CInt -> IO ())
234 -> Ptr CChar -> CInt -> IO ()
235
236 {-# NOINLINE ptr_glutAddSubMenu #-}
237 ptr_glutAddSubMenu :: FunPtr a
238 ptr_glutAddSubMenu = unsafePerformIO $ getAPIEntry "glutAddSubMenu"
239
240 -- glutAppStatusFunc -----------------------------------------------------------
241
242 glutAppStatusFunc :: MonadIO m => FunPtr AppStatusFunc -> m ()
243 glutAppStatusFunc v1 = liftIO $ dyn_glutAppStatusFunc ptr_glutAppStatusFunc v1
244
245 foreign import CALLCONV "dynamic" dyn_glutAppStatusFunc
246 :: FunPtr (FunPtr AppStatusFunc -> IO ())
247 -> FunPtr AppStatusFunc -> IO ()
248
249 {-# NOINLINE ptr_glutAppStatusFunc #-}
250 ptr_glutAppStatusFunc :: FunPtr a
251 ptr_glutAppStatusFunc = unsafePerformIO $ getAPIEntry "glutAppStatusFunc"
252
253 -- glutAttachMenu --------------------------------------------------------------
254
255 glutAttachMenu :: MonadIO m => CInt -> m ()
256 glutAttachMenu v1 = liftIO $ dyn_glutAttachMenu ptr_glutAttachMenu v1
257
258 foreign import CALLCONV "dynamic" dyn_glutAttachMenu
259 :: FunPtr (CInt -> IO ())
260 -> CInt -> IO ()
261
262 {-# NOINLINE ptr_glutAttachMenu #-}
263 ptr_glutAttachMenu :: FunPtr a
264 ptr_glutAttachMenu = unsafePerformIO $ getAPIEntry "glutAttachMenu"
265
266 -- glutBitmapCharacter ---------------------------------------------------------
267
268 glutBitmapCharacter :: MonadIO m => Ptr a -> CInt -> m ()
269 glutBitmapCharacter v1 v2 = liftIO $ dyn_glutBitmapCharacter ptr_glutBitmapCharacter v1 v2
270
271 foreign import CALLCONV "dynamic" dyn_glutBitmapCharacter
272 :: FunPtr (Ptr a -> CInt -> IO ())
273 -> Ptr a -> CInt -> IO ()
274
275 {-# NOINLINE ptr_glutBitmapCharacter #-}
276 ptr_glutBitmapCharacter :: FunPtr a
277 ptr_glutBitmapCharacter = unsafePerformIO $ getAPIEntry "glutBitmapCharacter"
278
279 -- glutBitmapHeight ------------------------------------------------------------
280
281 glutBitmapHeight :: MonadIO m => Ptr a -> m CInt
282 glutBitmapHeight v1 = liftIO $ dyn_glutBitmapHeight ptr_glutBitmapHeight v1
283
284 foreign import CALLCONV "dynamic" dyn_glutBitmapHeight
285 :: FunPtr (Ptr a -> IO CInt)
286 -> Ptr a -> IO CInt
287
288 {-# NOINLINE ptr_glutBitmapHeight #-}
289 ptr_glutBitmapHeight :: FunPtr a
290 ptr_glutBitmapHeight = unsafePerformIO $ getAPIEntry "glutBitmapHeight"
291
292 -- glutBitmapLength ------------------------------------------------------------
293
294 glutBitmapLength :: MonadIO m => Ptr a -> Ptr CUChar -> m CInt
295 glutBitmapLength v1 v2 = liftIO $ dyn_glutBitmapLength ptr_glutBitmapLength v1 v2
296
297 foreign import CALLCONV "dynamic" dyn_glutBitmapLength
298 :: FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
299 -> Ptr a -> Ptr CUChar -> IO CInt
300
301 {-# NOINLINE ptr_glutBitmapLength #-}
302 ptr_glutBitmapLength :: FunPtr a
303 ptr_glutBitmapLength = unsafePerformIO $ getAPIEntry "glutBitmapLength"
304
305 -- glutBitmapString ------------------------------------------------------------
306
307 glutBitmapString :: MonadIO m => Ptr a -> Ptr CUChar -> m ()
308 glutBitmapString v1 v2 = liftIO $ dyn_glutBitmapString ptr_glutBitmapString v1 v2
309
310 foreign import CALLCONV "dynamic" dyn_glutBitmapString
311 :: FunPtr (Ptr a -> Ptr CUChar -> IO ())
312 -> Ptr a -> Ptr CUChar -> IO ()
313
314 {-# NOINLINE ptr_glutBitmapString #-}
315 ptr_glutBitmapString :: FunPtr a
316 ptr_glutBitmapString = unsafePerformIO $ getAPIEntry "glutBitmapString"
317
318 -- glutBitmapWidth -------------------------------------------------------------
319
320 glutBitmapWidth :: MonadIO m => Ptr a -> CInt -> m CInt
321 glutBitmapWidth v1 v2 = liftIO $ dyn_glutBitmapWidth ptr_glutBitmapWidth v1 v2
322
323 foreign import CALLCONV "dynamic" dyn_glutBitmapWidth
324 :: FunPtr (Ptr a -> CInt -> IO CInt)
325 -> Ptr a -> CInt -> IO CInt
326
327 {-# NOINLINE ptr_glutBitmapWidth #-}
328 ptr_glutBitmapWidth :: FunPtr a
329 ptr_glutBitmapWidth = unsafePerformIO $ getAPIEntry "glutBitmapWidth"
330
331 -- glutButtonBoxFunc -----------------------------------------------------------
332
333 glutButtonBoxFunc :: MonadIO m => FunPtr ButtonBoxFunc -> m ()
334 glutButtonBoxFunc v1 = liftIO $ dyn_glutButtonBoxFunc ptr_glutButtonBoxFunc v1
335
336 foreign import CALLCONV "dynamic" dyn_glutButtonBoxFunc
337 :: FunPtr (FunPtr ButtonBoxFunc -> IO ())
338 -> FunPtr ButtonBoxFunc -> IO ()
339
340 {-# NOINLINE ptr_glutButtonBoxFunc #-}
341 ptr_glutButtonBoxFunc :: FunPtr a
342 ptr_glutButtonBoxFunc = unsafePerformIO $ getAPIEntry "glutButtonBoxFunc"
343
344 -- glutChangeToMenuEntry -------------------------------------------------------
345
346 glutChangeToMenuEntry :: MonadIO m => CInt -> Ptr CChar -> CInt -> m ()
347 glutChangeToMenuEntry v1 v2 v3 = liftIO $ dyn_glutChangeToMenuEntry ptr_glutChangeToMenuEntry v1 v2 v3
348
349 foreign import CALLCONV "dynamic" dyn_glutChangeToMenuEntry
350 :: FunPtr (CInt -> Ptr CChar -> CInt -> IO ())
351 -> CInt -> Ptr CChar -> CInt -> IO ()
352
353 {-# NOINLINE ptr_glutChangeToMenuEntry #-}
354 ptr_glutChangeToMenuEntry :: FunPtr a
355 ptr_glutChangeToMenuEntry = unsafePerformIO $ getAPIEntry "glutChangeToMenuEntry"
356
357 -- glutChangeToSubMenu ---------------------------------------------------------
358
359 glutChangeToSubMenu :: MonadIO m => CInt -> Ptr CChar -> CInt -> m ()
360 glutChangeToSubMenu v1 v2 v3 = liftIO $ dyn_glutChangeToSubMenu ptr_glutChangeToSubMenu v1 v2 v3
361
362 foreign import CALLCONV "dynamic" dyn_glutChangeToSubMenu
363 :: FunPtr (CInt -> Ptr CChar -> CInt -> IO ())
364 -> CInt -> Ptr CChar -> CInt -> IO ()
365
366 {-# NOINLINE ptr_glutChangeToSubMenu #-}
367 ptr_glutChangeToSubMenu :: FunPtr a
368 ptr_glutChangeToSubMenu = unsafePerformIO $ getAPIEntry "glutChangeToSubMenu"
369
370 -- glutCloseFunc ---------------------------------------------------------------
371
372 glutCloseFunc :: MonadIO m => FunPtr CloseFunc -> m ()
373 glutCloseFunc v1 = liftIO $ dyn_glutCloseFunc ptr_glutCloseFunc v1
374
375 foreign import CALLCONV "dynamic" dyn_glutCloseFunc
376 :: FunPtr (FunPtr CloseFunc -> IO ())
377 -> FunPtr CloseFunc -> IO ()
378
379 {-# NOINLINE ptr_glutCloseFunc #-}
380 ptr_glutCloseFunc :: FunPtr a
381 ptr_glutCloseFunc = unsafePerformIO $ getAPIEntry "glutCloseFunc"
382
383 -- glutCopyColormap ------------------------------------------------------------
384
385 glutCopyColormap :: MonadIO m => CInt -> m ()
386 glutCopyColormap v1 = liftIO $ dyn_glutCopyColormap ptr_glutCopyColormap v1
387
388 foreign import CALLCONV "dynamic" dyn_glutCopyColormap
389 :: FunPtr (CInt -> IO ())
390 -> CInt -> IO ()
391
392 {-# NOINLINE ptr_glutCopyColormap #-}
393 ptr_glutCopyColormap :: FunPtr a
394 ptr_glutCopyColormap = unsafePerformIO $ getAPIEntry "glutCopyColormap"
395
396 -- glutCreateMenu --------------------------------------------------------------
397
398 glutCreateMenu :: MonadIO m => FunPtr MenuFunc -> m CInt
399 glutCreateMenu v1 = liftIO $ dyn_glutCreateMenu ptr_glutCreateMenu v1
400
401 foreign import CALLCONV "dynamic" dyn_glutCreateMenu
402 :: FunPtr (FunPtr MenuFunc -> IO CInt)
403 -> FunPtr MenuFunc -> IO CInt
404
405 {-# NOINLINE ptr_glutCreateMenu #-}
406 ptr_glutCreateMenu :: FunPtr a
407 ptr_glutCreateMenu = unsafePerformIO $ getAPIEntry "glutCreateMenu"
408
409 -- glutCreateSubWindow ---------------------------------------------------------
410
411 glutCreateSubWindow :: MonadIO m => CInt -> CInt -> CInt -> CInt -> CInt -> m CInt
412 glutCreateSubWindow v1 v2 v3 v4 v5 = liftIO $ dyn_glutCreateSubWindow ptr_glutCreateSubWindow v1 v2 v3 v4 v5
413
414 foreign import CALLCONV "dynamic" dyn_glutCreateSubWindow
415 :: FunPtr (CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt)
416 -> CInt -> CInt -> CInt -> CInt -> CInt -> IO CInt
417
418 {-# NOINLINE ptr_glutCreateSubWindow #-}
419 ptr_glutCreateSubWindow :: FunPtr a
420 ptr_glutCreateSubWindow = unsafePerformIO $ getAPIEntry "glutCreateSubWindow"
421
422 -- glutCreateWindow ------------------------------------------------------------
423
424 glutCreateWindow :: MonadIO m => Ptr CChar -> m CInt
425 glutCreateWindow v1 = liftIO $ dyn_glutCreateWindow ptr_glutCreateWindow v1
426
427 foreign import CALLCONV "dynamic" dyn_glutCreateWindow
428 :: FunPtr (Ptr CChar -> IO CInt)
429 -> Ptr CChar -> IO CInt
430
431 {-# NOINLINE ptr_glutCreateWindow #-}
432 ptr_glutCreateWindow :: FunPtr a
433 ptr_glutCreateWindow = unsafePerformIO $ getAPIEntry "glutCreateWindow"
434
435 -- glutDestroyMenu -------------------------------------------------------------
436
437 glutDestroyMenu :: MonadIO m => CInt -> m ()
438 glutDestroyMenu v1 = liftIO $ dyn_glutDestroyMenu ptr_glutDestroyMenu v1
439
440 foreign import CALLCONV "dynamic" dyn_glutDestroyMenu
441 :: FunPtr (CInt -> IO ())
442 -> CInt -> IO ()
443
444 {-# NOINLINE ptr_glutDestroyMenu #-}
445 ptr_glutDestroyMenu :: FunPtr a
446 ptr_glutDestroyMenu = unsafePerformIO $ getAPIEntry "glutDestroyMenu"
447
448 -- glutDestroyWindow -----------------------------------------------------------
449
450 glutDestroyWindow :: MonadIO m => CInt -> m ()
451 glutDestroyWindow v1 = liftIO $ dyn_glutDestroyWindow ptr_glutDestroyWindow v1
452
453 foreign import CALLCONV "dynamic" dyn_glutDestroyWindow
454 :: FunPtr (CInt -> IO ())
455 -> CInt -> IO ()
456
457 {-# NOINLINE ptr_glutDestroyWindow #-}
458 ptr_glutDestroyWindow :: FunPtr a
459 ptr_glutDestroyWindow = unsafePerformIO $ getAPIEntry "glutDestroyWindow"
460
461 -- glutDetachMenu --------------------------------------------------------------
462
463 glutDetachMenu :: MonadIO m => CInt -> m ()
464 glutDetachMenu v1 = liftIO $ dyn_glutDetachMenu ptr_glutDetachMenu v1
465
466 foreign import CALLCONV "dynamic" dyn_glutDetachMenu
467 :: FunPtr (CInt -> IO ())
468 -> CInt -> IO ()
469
470 {-# NOINLINE ptr_glutDetachMenu #-}
471 ptr_glutDetachMenu :: FunPtr a
472 ptr_glutDetachMenu = unsafePerformIO $ getAPIEntry "glutDetachMenu"
473
474 -- glutDeviceGet ---------------------------------------------------------------
475
476 glutDeviceGet :: MonadIO m => GLenum -> m CInt
477 glutDeviceGet v1 = liftIO $ dyn_glutDeviceGet ptr_glutDeviceGet v1
478
479 foreign import CALLCONV "dynamic" dyn_glutDeviceGet
480 :: FunPtr (GLenum -> IO CInt)
481 -> GLenum -> IO CInt
482
483 {-# NOINLINE ptr_glutDeviceGet #-}
484 ptr_glutDeviceGet :: FunPtr a
485 ptr_glutDeviceGet = unsafePerformIO $ getAPIEntry "glutDeviceGet"
486
487 -- glutDialsFunc ---------------------------------------------------------------
488
489 glutDialsFunc :: MonadIO m => FunPtr DialsFunc -> m ()
490 glutDialsFunc v1 = liftIO $ dyn_glutDialsFunc ptr_glutDialsFunc v1
491
492 foreign import CALLCONV "dynamic" dyn_glutDialsFunc
493 :: FunPtr (FunPtr DialsFunc -> IO ())
494 -> FunPtr DialsFunc -> IO ()
495
496 {-# NOINLINE ptr_glutDialsFunc #-}
497 ptr_glutDialsFunc :: FunPtr a
498 ptr_glutDialsFunc = unsafePerformIO $ getAPIEntry "glutDialsFunc"
499
500 -- glutDisplayFunc -------------------------------------------------------------
501
502 glutDisplayFunc :: MonadIO m => FunPtr DisplayFunc -> m ()
503 glutDisplayFunc v1 = liftIO $ dyn_glutDisplayFunc ptr_glutDisplayFunc v1
504
505 foreign import CALLCONV "dynamic" dyn_glutDisplayFunc
506 :: FunPtr (FunPtr DisplayFunc -> IO ())
507 -> FunPtr DisplayFunc -> IO ()
508
509 {-# NOINLINE ptr_glutDisplayFunc #-}
510 ptr_glutDisplayFunc :: FunPtr a
511 ptr_glutDisplayFunc = unsafePerformIO $ getAPIEntry "glutDisplayFunc"
512
513 -- glutEnterGameMode -----------------------------------------------------------
514
515 glutEnterGameMode :: MonadIO m => m CInt
516 glutEnterGameMode = liftIO $ dyn_glutEnterGameMode ptr_glutEnterGameMode
517
518 foreign import CALLCONV "dynamic" dyn_glutEnterGameMode
519 :: FunPtr (IO CInt)
520 -> IO CInt
521
522 {-# NOINLINE ptr_glutEnterGameMode #-}
523 ptr_glutEnterGameMode :: FunPtr a
524 ptr_glutEnterGameMode = unsafePerformIO $ getAPIEntry "glutEnterGameMode"
525
526 -- glutEntryFunc ---------------------------------------------------------------
527
528 glutEntryFunc :: MonadIO m => FunPtr EntryFunc -> m ()
529 glutEntryFunc v1 = liftIO $ dyn_glutEntryFunc ptr_glutEntryFunc v1
530
531 foreign import CALLCONV "dynamic" dyn_glutEntryFunc
532 :: FunPtr (FunPtr EntryFunc -> IO ())
533 -> FunPtr EntryFunc -> IO ()
534
535 {-# NOINLINE ptr_glutEntryFunc #-}
536 ptr_glutEntryFunc :: FunPtr a
537 ptr_glutEntryFunc = unsafePerformIO $ getAPIEntry "glutEntryFunc"
538
539 -- glutEstablishOverlay --------------------------------------------------------
540
541 glutEstablishOverlay :: MonadIO m => m ()
542 glutEstablishOverlay = liftIO $ dyn_glutEstablishOverlay ptr_glutEstablishOverlay
543
544 foreign import CALLCONV "dynamic" dyn_glutEstablishOverlay
545 :: FunPtr (IO ())
546 -> IO ()
547
548 {-# NOINLINE ptr_glutEstablishOverlay #-}
549 ptr_glutEstablishOverlay :: FunPtr a
550 ptr_glutEstablishOverlay = unsafePerformIO $ getAPIEntry "glutEstablishOverlay"
551
552 -- glutExit --------------------------------------------------------------------
553
554 glutExit :: MonadIO m => m ()
555 glutExit = liftIO $ dyn_glutExit ptr_glutExit
556
557 foreign import CALLCONV "dynamic" dyn_glutExit
558 :: FunPtr (IO ())
559 -> IO ()
560
561 {-# NOINLINE ptr_glutExit #-}
562 ptr_glutExit :: FunPtr a
563 ptr_glutExit = unsafePerformIO $ getAPIEntry "glutExit"
564
565 -- glutExtensionSupported ------------------------------------------------------
566
567 glutExtensionSupported :: MonadIO m => Ptr CChar -> m CInt
568 glutExtensionSupported v1 = liftIO $ dyn_glutExtensionSupported ptr_glutExtensionSupported v1
569
570 foreign import CALLCONV "dynamic" dyn_glutExtensionSupported
571 :: FunPtr (Ptr CChar -> IO CInt)
572 -> Ptr CChar -> IO CInt
573
574 {-# NOINLINE ptr_glutExtensionSupported #-}
575 ptr_glutExtensionSupported :: FunPtr a
576 ptr_glutExtensionSupported = unsafePerformIO $ getAPIEntry "glutExtensionSupported"
577
578 -- glutForceJoystickFunc -------------------------------------------------------
579
580 glutForceJoystickFunc :: MonadIO m => m ()
581 glutForceJoystickFunc = liftIO $ dyn_glutForceJoystickFunc ptr_glutForceJoystickFunc
582
583 foreign import CALLCONV "dynamic" dyn_glutForceJoystickFunc
584 :: FunPtr (IO ())
585 -> IO ()
586
587 {-# NOINLINE ptr_glutForceJoystickFunc #-}
588 ptr_glutForceJoystickFunc :: FunPtr a
589 ptr_glutForceJoystickFunc = unsafePerformIO $ getAPIEntry "glutForceJoystickFunc"
590
591 -- glutFullScreen --------------------------------------------------------------
592
593 glutFullScreen :: MonadIO m => m ()
594 glutFullScreen = liftIO $ dyn_glutFullScreen ptr_glutFullScreen
595
596 foreign import CALLCONV "dynamic" dyn_glutFullScreen
597 :: FunPtr (IO ())
598 -> IO ()
599
600 {-# NOINLINE ptr_glutFullScreen #-}
601 ptr_glutFullScreen :: FunPtr a
602 ptr_glutFullScreen = unsafePerformIO $ getAPIEntry "glutFullScreen"
603
604 -- glutFullScreenToggle --------------------------------------------------------
605
606 glutFullScreenToggle :: MonadIO m => m ()
607 glutFullScreenToggle = liftIO $ dyn_glutFullScreenToggle ptr_glutFullScreenToggle
608
609 foreign import CALLCONV "dynamic" dyn_glutFullScreenToggle
610 :: FunPtr (IO ())
611 -> IO ()
612
613 {-# NOINLINE ptr_glutFullScreenToggle #-}
614 ptr_glutFullScreenToggle :: FunPtr a
615 ptr_glutFullScreenToggle = unsafePerformIO $ getAPIEntry "glutFullScreenToggle"
616
617 -- glutGameModeGet -------------------------------------------------------------
618
619 glutGameModeGet :: MonadIO m => GLenum -> m CInt
620 glutGameModeGet v1 = liftIO $ dyn_glutGameModeGet ptr_glutGameModeGet v1
621
622 foreign import CALLCONV "dynamic" dyn_glutGameModeGet
623 :: FunPtr (GLenum -> IO CInt)
624 -> GLenum -> IO CInt
625
626 {-# NOINLINE ptr_glutGameModeGet #-}
627 ptr_glutGameModeGet :: FunPtr a
628 ptr_glutGameModeGet = unsafePerformIO $ getAPIEntry "glutGameModeGet"
629
630 -- glutGameModeString ----------------------------------------------------------
631
632 glutGameModeString :: MonadIO m => Ptr CChar -> m ()
633 glutGameModeString v1 = liftIO $ dyn_glutGameModeString ptr_glutGameModeString v1
634
635 foreign import CALLCONV "dynamic" dyn_glutGameModeString
636 :: FunPtr (Ptr CChar -> IO ())
637 -> Ptr CChar -> IO ()
638
639 {-# NOINLINE ptr_glutGameModeString #-}
640 ptr_glutGameModeString :: FunPtr a
641 ptr_glutGameModeString = unsafePerformIO $ getAPIEntry "glutGameModeString"
642
643 -- glutGet ---------------------------------------------------------------------
644
645 glutGet :: MonadIO m => GLenum -> m CInt
646 glutGet v1 = liftIO $ dyn_glutGet ptr_glutGet v1
647
648 foreign import CALLCONV "dynamic" dyn_glutGet
649 :: FunPtr (GLenum -> IO CInt)
650 -> GLenum -> IO CInt
651
652 {-# NOINLINE ptr_glutGet #-}
653 ptr_glutGet :: FunPtr a
654 ptr_glutGet = unsafePerformIO $ getAPIEntry "glutGet"
655
656 -- glutGetColor ----------------------------------------------------------------
657
658 glutGetColor :: MonadIO m => CInt -> CInt -> m GLfloat
659 glutGetColor v1 v2 = liftIO $ dyn_glutGetColor ptr_glutGetColor v1 v2
660
661 foreign import CALLCONV "dynamic" dyn_glutGetColor
662 :: FunPtr (CInt -> CInt -> IO GLfloat)
663 -> CInt -> CInt -> IO GLfloat
664
665 {-# NOINLINE ptr_glutGetColor #-}
666 ptr_glutGetColor :: FunPtr a
667 ptr_glutGetColor = unsafePerformIO $ getAPIEntry "glutGetColor"
668
669 -- glutGetMenu -----------------------------------------------------------------
670
671 glutGetMenu :: MonadIO m => m CInt
672 glutGetMenu = liftIO $ dyn_glutGetMenu ptr_glutGetMenu
673
674 foreign import CALLCONV "dynamic" dyn_glutGetMenu
675 :: FunPtr (IO CInt)
676 -> IO CInt
677
678 {-# NOINLINE ptr_glutGetMenu #-}
679 ptr_glutGetMenu :: FunPtr a
680 ptr_glutGetMenu = unsafePerformIO $ getAPIEntry "glutGetMenu"
681
682 -- glutGetMenuData -------------------------------------------------------------
683
684 glutGetMenuData :: MonadIO m => m (Ptr a)
685 glutGetMenuData = liftIO $ dyn_glutGetMenuData ptr_glutGetMenuData
686
687 foreign import CALLCONV "dynamic" dyn_glutGetMenuData
688 :: FunPtr (IO (Ptr a))
689 -> IO (Ptr a)
690
691 {-# NOINLINE ptr_glutGetMenuData #-}
692 ptr_glutGetMenuData :: FunPtr a
693 ptr_glutGetMenuData = unsafePerformIO $ getAPIEntry "glutGetMenuData"
694
695 -- glutGetModeValues -----------------------------------------------------------
696
697 glutGetModeValues :: MonadIO m => GLenum -> Ptr CInt -> m (Ptr CInt)
698 glutGetModeValues v1 v2 = liftIO $ dyn_glutGetModeValues ptr_glutGetModeValues v1 v2
699
700 foreign import CALLCONV "dynamic" dyn_glutGetModeValues
701 :: FunPtr (GLenum -> Ptr CInt -> IO (Ptr CInt))
702 -> GLenum -> Ptr CInt -> IO (Ptr CInt)
703
704 {-# NOINLINE ptr_glutGetModeValues #-}
705 ptr_glutGetModeValues :: FunPtr a
706 ptr_glutGetModeValues = unsafePerformIO $ getAPIEntry "glutGetModeValues"
707
708 -- glutGetModifiers ------------------------------------------------------------
709
710 glutGetModifiers :: MonadIO m => m CInt
711 glutGetModifiers = liftIO $ dyn_glutGetModifiers ptr_glutGetModifiers
712
713 foreign import CALLCONV "dynamic" dyn_glutGetModifiers
714 :: FunPtr (IO CInt)
715 -> IO CInt
716
717 {-# NOINLINE ptr_glutGetModifiers #-}
718 ptr_glutGetModifiers :: FunPtr a
719 ptr_glutGetModifiers = unsafePerformIO $ getAPIEntry "glutGetModifiers"
720
721 -- glutGetProcAddress ----------------------------------------------------------
722
723 glutGetProcAddress :: MonadIO m => Ptr CChar -> m (FunPtr a)
724 glutGetProcAddress v1 = liftIO $ dyn_glutGetProcAddress ptr_glutGetProcAddress v1
725
726 foreign import CALLCONV "dynamic" dyn_glutGetProcAddress
727 :: FunPtr (Ptr CChar -> IO (FunPtr a))
728 -> Ptr CChar -> IO (FunPtr a)
729
730 {-# NOINLINE ptr_glutGetProcAddress #-}
731 ptr_glutGetProcAddress :: FunPtr a
732 ptr_glutGetProcAddress = unsafePerformIO $ getAPIEntry "glutGetProcAddress"
733
734 -- glutGetWindow ---------------------------------------------------------------
735
736 glutGetWindow :: MonadIO m => m CInt
737 glutGetWindow = liftIO $ dyn_glutGetWindow ptr_glutGetWindow
738
739 foreign import CALLCONV "dynamic" dyn_glutGetWindow
740 :: FunPtr (IO CInt)
741 -> IO CInt
742
743 {-# NOINLINE ptr_glutGetWindow #-}
744 ptr_glutGetWindow :: FunPtr a
745 ptr_glutGetWindow = unsafePerformIO $ getAPIEntry "glutGetWindow"
746
747 -- glutGetWindowData -----------------------------------------------------------
748
749 glutGetWindowData :: MonadIO m => m (Ptr a)
750 glutGetWindowData = liftIO $ dyn_glutGetWindowData ptr_glutGetWindowData
751
752 foreign import CALLCONV "dynamic" dyn_glutGetWindowData
753 :: FunPtr (IO (Ptr a))
754 -> IO (Ptr a)
755
756 {-# NOINLINE ptr_glutGetWindowData #-}
757 ptr_glutGetWindowData :: FunPtr a
758 ptr_glutGetWindowData = unsafePerformIO $ getAPIEntry "glutGetWindowData"
759
760 -- glutHideOverlay -------------------------------------------------------------
761
762 glutHideOverlay :: MonadIO m => m ()
763 glutHideOverlay = liftIO $ dyn_glutHideOverlay ptr_glutHideOverlay
764
765 foreign import CALLCONV "dynamic" dyn_glutHideOverlay
766 :: FunPtr (IO ())
767 -> IO ()
768
769 {-# NOINLINE ptr_glutHideOverlay #-}
770 ptr_glutHideOverlay :: FunPtr a
771 ptr_glutHideOverlay = unsafePerformIO $ getAPIEntry "glutHideOverlay"
772
773 -- glutHideWindow --------------------------------------------------------------
774
775 glutHideWindow :: MonadIO m => m ()
776 glutHideWindow = liftIO $ dyn_glutHideWindow ptr_glutHideWindow
777
778 foreign import CALLCONV "dynamic" dyn_glutHideWindow
779 :: FunPtr (IO ())
780 -> IO ()
781
782 {-# NOINLINE ptr_glutHideWindow #-}
783 ptr_glutHideWindow :: FunPtr a
784 ptr_glutHideWindow = unsafePerformIO $ getAPIEntry "glutHideWindow"
785
786 -- glutIconifyWindow -----------------------------------------------------------
787
788 glutIconifyWindow :: MonadIO m => m ()
789 glutIconifyWindow = liftIO $ dyn_glutIconifyWindow ptr_glutIconifyWindow
790
791 foreign import CALLCONV "dynamic" dyn_glutIconifyWindow
792 :: FunPtr (IO ())
793 -> IO ()
794
795 {-# NOINLINE ptr_glutIconifyWindow #-}
796 ptr_glutIconifyWindow :: FunPtr a
797 ptr_glutIconifyWindow = unsafePerformIO $ getAPIEntry "glutIconifyWindow"
798
799 -- glutIdleFunc ----------------------------------------------------------------
800
801 glutIdleFunc :: MonadIO m => FunPtr IdleFunc -> m ()
802 glutIdleFunc v1 = liftIO $ dyn_glutIdleFunc ptr_glutIdleFunc v1
803
804 foreign import CALLCONV "dynamic" dyn_glutIdleFunc
805 :: FunPtr (FunPtr IdleFunc -> IO ())
806 -> FunPtr IdleFunc -> IO ()
807
808 {-# NOINLINE ptr_glutIdleFunc #-}
809 ptr_glutIdleFunc :: FunPtr a
810 ptr_glutIdleFunc = unsafePerformIO $ getAPIEntry "glutIdleFunc"
811
812 -- glutIgnoreKeyRepeat ---------------------------------------------------------
813
814 glutIgnoreKeyRepeat :: MonadIO m => CInt -> m ()
815 glutIgnoreKeyRepeat v1 = liftIO $ dyn_glutIgnoreKeyRepeat ptr_glutIgnoreKeyRepeat v1
816
817 foreign import CALLCONV "dynamic" dyn_glutIgnoreKeyRepeat
818 :: FunPtr (CInt -> IO ())
819 -> CInt -> IO ()
820
821 {-# NOINLINE ptr_glutIgnoreKeyRepeat #-}
822 ptr_glutIgnoreKeyRepeat :: FunPtr a
823 ptr_glutIgnoreKeyRepeat = unsafePerformIO $ getAPIEntry "glutIgnoreKeyRepeat"
824
825 -- glutInit --------------------------------------------------------------------
826
827 glutInit :: MonadIO m => Ptr CInt -> Ptr (Ptr CChar) -> m ()
828 glutInit v1 v2 = liftIO $ dyn_glutInit ptr_glutInit v1 v2
829
830 foreign import CALLCONV "dynamic" dyn_glutInit
831 :: FunPtr (Ptr CInt -> Ptr (Ptr CChar) -> IO ())
832 -> Ptr CInt -> Ptr (Ptr CChar) -> IO ()
833
834 {-# NOINLINE ptr_glutInit #-}
835 ptr_glutInit :: FunPtr a
836 ptr_glutInit = unsafePerformIO $ getAPIEntry "glutInit"
837
838 -- glutInitContextFlags --------------------------------------------------------
839
840 glutInitContextFlags :: MonadIO m => CInt -> m ()
841 glutInitContextFlags v1 = liftIO $ dyn_glutInitContextFlags ptr_glutInitContextFlags v1
842
843 foreign import CALLCONV "dynamic" dyn_glutInitContextFlags
844 :: FunPtr (CInt -> IO ())
845 -> CInt -> IO ()
846
847 {-# NOINLINE ptr_glutInitContextFlags #-}
848 ptr_glutInitContextFlags :: FunPtr a
849 ptr_glutInitContextFlags = unsafePerformIO $ getAPIEntry "glutInitContextFlags"
850
851 -- glutInitContextFunc ---------------------------------------------------------
852
853 glutInitContextFunc :: MonadIO m => FunPtr InitContextFunc -> m ()
854 glutInitContextFunc v1 = liftIO $ dyn_glutInitContextFunc ptr_glutInitContextFunc v1
855
856 foreign import CALLCONV "dynamic" dyn_glutInitContextFunc
857 :: FunPtr (FunPtr InitContextFunc -> IO ())
858 -> FunPtr InitContextFunc -> IO ()
859
860 {-# NOINLINE ptr_glutInitContextFunc #-}
861 ptr_glutInitContextFunc :: FunPtr a
862 ptr_glutInitContextFunc = unsafePerformIO $ getAPIEntry "glutInitContextFunc"
863
864 -- glutInitContextProfile ------------------------------------------------------
865
866 glutInitContextProfile :: MonadIO m => CInt -> m ()
867 glutInitContextProfile v1 = liftIO $ dyn_glutInitContextProfile ptr_glutInitContextProfile v1
868
869 foreign import CALLCONV "dynamic" dyn_glutInitContextProfile
870 :: FunPtr (CInt -> IO ())
871 -> CInt -> IO ()
872
873 {-# NOINLINE ptr_glutInitContextProfile #-}
874 ptr_glutInitContextProfile :: FunPtr a
875 ptr_glutInitContextProfile = unsafePerformIO $ getAPIEntry "glutInitContextProfile"
876
877 -- glutInitContextVersion ------------------------------------------------------
878
879 glutInitContextVersion :: MonadIO m => CInt -> CInt -> m ()
880 glutInitContextVersion v1 v2 = liftIO $ dyn_glutInitContextVersion ptr_glutInitContextVersion v1 v2
881
882 foreign import CALLCONV "dynamic" dyn_glutInitContextVersion
883 :: FunPtr (CInt -> CInt -> IO ())
884 -> CInt -> CInt -> IO ()
885
886 {-# NOINLINE ptr_glutInitContextVersion #-}
887 ptr_glutInitContextVersion :: FunPtr a
888 ptr_glutInitContextVersion = unsafePerformIO $ getAPIEntry "glutInitContextVersion"
889
890 -- glutInitDisplayMode ---------------------------------------------------------
891
892 glutInitDisplayMode :: MonadIO m => CUInt -> m ()
893 glutInitDisplayMode v1 = liftIO $ dyn_glutInitDisplayMode ptr_glutInitDisplayMode v1
894
895 foreign import CALLCONV "dynamic" dyn_glutInitDisplayMode
896 :: FunPtr (CUInt -> IO ())
897 -> CUInt -> IO ()
898
899 {-# NOINLINE ptr_glutInitDisplayMode #-}
900 ptr_glutInitDisplayMode :: FunPtr a
901 ptr_glutInitDisplayMode = unsafePerformIO $ getAPIEntry "glutInitDisplayMode"
902
903 -- glutInitDisplayString -------------------------------------------------------
904
905 glutInitDisplayString :: MonadIO m => Ptr CChar -> m ()
906 glutInitDisplayString v1 = liftIO $ dyn_glutInitDisplayString ptr_glutInitDisplayString v1
907
908 foreign import CALLCONV "dynamic" dyn_glutInitDisplayString
909 :: FunPtr (Ptr CChar -> IO ())
910 -> Ptr CChar -> IO ()
911
912 {-# NOINLINE ptr_glutInitDisplayString #-}
913 ptr_glutInitDisplayString :: FunPtr a
914 ptr_glutInitDisplayString = unsafePerformIO $ getAPIEntry "glutInitDisplayString"
915
916 -- glutInitWindowPosition ------------------------------------------------------
917
918 glutInitWindowPosition :: MonadIO m => CInt -> CInt -> m ()
919 glutInitWindowPosition v1 v2 = liftIO $ dyn_glutInitWindowPosition ptr_glutInitWindowPosition v1 v2
920
921 foreign import CALLCONV "dynamic" dyn_glutInitWindowPosition
922 :: FunPtr (CInt -> CInt -> IO ())
923 -> CInt -> CInt -> IO ()
924
925 {-# NOINLINE ptr_glutInitWindowPosition #-}
926 ptr_glutInitWindowPosition :: FunPtr a
927 ptr_glutInitWindowPosition = unsafePerformIO $ getAPIEntry "glutInitWindowPosition"
928
929 -- glutInitWindowSize ----------------------------------------------------------
930
931 glutInitWindowSize :: MonadIO m => CInt -> CInt -> m ()
932 glutInitWindowSize v1 v2 = liftIO $ dyn_glutInitWindowSize ptr_glutInitWindowSize v1 v2
933
934 foreign import CALLCONV "dynamic" dyn_glutInitWindowSize
935 :: FunPtr (CInt -> CInt -> IO ())
936 -> CInt -> CInt -> IO ()
937
938 {-# NOINLINE ptr_glutInitWindowSize #-}
939 ptr_glutInitWindowSize :: FunPtr a
940 ptr_glutInitWindowSize = unsafePerformIO $ getAPIEntry "glutInitWindowSize"
941
942 -- glutJoystickFunc ------------------------------------------------------------
943
944 glutJoystickFunc :: MonadIO m => FunPtr JoystickFunc -> CInt -> m ()
945 glutJoystickFunc v1 v2 = liftIO $ dyn_glutJoystickFunc ptr_glutJoystickFunc v1 v2
946
947 foreign import CALLCONV "dynamic" dyn_glutJoystickFunc
948 :: FunPtr (FunPtr JoystickFunc -> CInt -> IO ())
949 -> FunPtr JoystickFunc -> CInt -> IO ()
950
951 {-# NOINLINE ptr_glutJoystickFunc #-}
952 ptr_glutJoystickFunc :: FunPtr a
953 ptr_glutJoystickFunc = unsafePerformIO $ getAPIEntry "glutJoystickFunc"
954
955 -- glutKeyboardFunc ------------------------------------------------------------
956
957 glutKeyboardFunc :: MonadIO m => FunPtr KeyboardFunc -> m ()
958 glutKeyboardFunc v1 = liftIO $ dyn_glutKeyboardFunc ptr_glutKeyboardFunc v1
959
960 foreign import CALLCONV "dynamic" dyn_glutKeyboardFunc
961 :: FunPtr (FunPtr KeyboardFunc -> IO ())
962 -> FunPtr KeyboardFunc -> IO ()
963
964 {-# NOINLINE ptr_glutKeyboardFunc #-}
965 ptr_glutKeyboardFunc :: FunPtr a
966 ptr_glutKeyboardFunc = unsafePerformIO $ getAPIEntry "glutKeyboardFunc"
967
968 -- glutKeyboardUpFunc ----------------------------------------------------------
969
970 glutKeyboardUpFunc :: MonadIO m => FunPtr KeyboardUpFunc -> m ()
971 glutKeyboardUpFunc v1 = liftIO $ dyn_glutKeyboardUpFunc ptr_glutKeyboardUpFunc v1
972
973 foreign import CALLCONV "dynamic" dyn_glutKeyboardUpFunc
974 :: FunPtr (FunPtr KeyboardUpFunc -> IO ())
975 -> FunPtr KeyboardUpFunc -> IO ()
976
977 {-# NOINLINE ptr_glutKeyboardUpFunc #-}
978 ptr_glutKeyboardUpFunc :: FunPtr a
979 ptr_glutKeyboardUpFunc = unsafePerformIO $ getAPIEntry "glutKeyboardUpFunc"
980
981 -- glutLayerGet ----------------------------------------------------------------
982
983 glutLayerGet :: MonadIO m => GLenum -> m CInt
984 glutLayerGet v1 = liftIO $ dyn_glutLayerGet ptr_glutLayerGet v1
985
986 foreign import CALLCONV "dynamic" dyn_glutLayerGet
987 :: FunPtr (GLenum -> IO CInt)
988 -> GLenum -> IO CInt
989
990 {-# NOINLINE ptr_glutLayerGet #-}
991 ptr_glutLayerGet :: FunPtr a
992 ptr_glutLayerGet = unsafePerformIO $ getAPIEntry "glutLayerGet"
993
994 -- glutLeaveFullScreen ---------------------------------------------------------
995
996 glutLeaveFullScreen :: MonadIO m => m ()
997 glutLeaveFullScreen = liftIO $ dyn_glutLeaveFullScreen ptr_glutLeaveFullScreen
998
999 foreign import CALLCONV "dynamic" dyn_glutLeaveFullScreen
1000 :: FunPtr (IO ())
1001 -> IO ()
1002
1003 {-# NOINLINE ptr_glutLeaveFullScreen #-}
1004 ptr_glutLeaveFullScreen :: FunPtr a
1005 ptr_glutLeaveFullScreen = unsafePerformIO $ getAPIEntry "glutLeaveFullScreen"
1006
1007 -- glutLeaveGameMode -----------------------------------------------------------
1008
1009 glutLeaveGameMode :: MonadIO m => m ()
1010 glutLeaveGameMode = liftIO $ dyn_glutLeaveGameMode ptr_glutLeaveGameMode
1011
1012 foreign import CALLCONV "dynamic" dyn_glutLeaveGameMode
1013 :: FunPtr (IO ())
1014 -> IO ()
1015
1016 {-# NOINLINE ptr_glutLeaveGameMode #-}
1017 ptr_glutLeaveGameMode :: FunPtr a
1018 ptr_glutLeaveGameMode = unsafePerformIO $ getAPIEntry "glutLeaveGameMode"
1019
1020 -- glutLeaveMainLoop -----------------------------------------------------------
1021
1022 glutLeaveMainLoop :: MonadIO m => m ()
1023 glutLeaveMainLoop = liftIO $ dyn_glutLeaveMainLoop ptr_glutLeaveMainLoop
1024
1025 foreign import CALLCONV "dynamic" dyn_glutLeaveMainLoop
1026 :: FunPtr (IO ())
1027 -> IO ()
1028
1029 {-# NOINLINE ptr_glutLeaveMainLoop #-}
1030 ptr_glutLeaveMainLoop :: FunPtr a
1031 ptr_glutLeaveMainLoop = unsafePerformIO $ getAPIEntry "glutLeaveMainLoop"
1032
1033 -- glutMainLoop ----------------------------------------------------------------
1034
1035 glutMainLoop :: MonadIO m => m ()
1036 glutMainLoop = liftIO $ dyn_glutMainLoop ptr_glutMainLoop
1037
1038 foreign import CALLCONV "dynamic" dyn_glutMainLoop
1039 :: FunPtr (IO ())
1040 -> IO ()
1041
1042 {-# NOINLINE ptr_glutMainLoop #-}
1043 ptr_glutMainLoop :: FunPtr a
1044 ptr_glutMainLoop = unsafePerformIO $ getAPIEntry "glutMainLoop"
1045
1046 -- glutMainLoopEvent -----------------------------------------------------------
1047
1048 glutMainLoopEvent :: MonadIO m => m ()
1049 glutMainLoopEvent = liftIO $ dyn_glutMainLoopEvent ptr_glutMainLoopEvent
1050
1051 foreign import CALLCONV "dynamic" dyn_glutMainLoopEvent
1052 :: FunPtr (IO ())
1053 -> IO ()
1054
1055 {-# NOINLINE ptr_glutMainLoopEvent #-}
1056 ptr_glutMainLoopEvent :: FunPtr a
1057 ptr_glutMainLoopEvent = unsafePerformIO $ getAPIEntry "glutMainLoopEvent"
1058
1059 -- glutMenuDestroyFunc ---------------------------------------------------------
1060
1061 glutMenuDestroyFunc :: MonadIO m => FunPtr MenuDestroyFunc -> m ()
1062 glutMenuDestroyFunc v1 = liftIO $ dyn_glutMenuDestroyFunc ptr_glutMenuDestroyFunc v1
1063
1064 foreign import CALLCONV "dynamic" dyn_glutMenuDestroyFunc
1065 :: FunPtr (FunPtr MenuDestroyFunc -> IO ())
1066 -> FunPtr MenuDestroyFunc -> IO ()
1067
1068 {-# NOINLINE ptr_glutMenuDestroyFunc #-}
1069 ptr_glutMenuDestroyFunc :: FunPtr a
1070 ptr_glutMenuDestroyFunc = unsafePerformIO $ getAPIEntry "glutMenuDestroyFunc"
1071
1072 -- glutMenuStateFunc -----------------------------------------------------------
1073
1074 glutMenuStateFunc :: MonadIO m => FunPtr MenuStateFunc -> m ()
1075 glutMenuStateFunc v1 = liftIO $ dyn_glutMenuStateFunc ptr_glutMenuStateFunc v1
1076
1077 foreign import CALLCONV "dynamic" dyn_glutMenuStateFunc
1078 :: FunPtr (FunPtr MenuStateFunc -> IO ())
1079 -> FunPtr MenuStateFunc -> IO ()
1080
1081 {-# NOINLINE ptr_glutMenuStateFunc #-}
1082 ptr_glutMenuStateFunc :: FunPtr a
1083 ptr_glutMenuStateFunc = unsafePerformIO $ getAPIEntry "glutMenuStateFunc"
1084
1085 -- glutMenuStatusFunc ----------------------------------------------------------
1086
1087 glutMenuStatusFunc :: MonadIO m => FunPtr MenuStatusFunc -> m ()
1088 glutMenuStatusFunc v1 = liftIO $ dyn_glutMenuStatusFunc ptr_glutMenuStatusFunc v1
1089
1090 foreign import CALLCONV "dynamic" dyn_glutMenuStatusFunc
1091 :: FunPtr (FunPtr MenuStatusFunc -> IO ())
1092 -> FunPtr MenuStatusFunc -> IO ()
1093
1094 {-# NOINLINE ptr_glutMenuStatusFunc #-}
1095 ptr_glutMenuStatusFunc :: FunPtr a
1096 ptr_glutMenuStatusFunc = unsafePerformIO $ getAPIEntry "glutMenuStatusFunc"
1097
1098 -- glutMotionFunc --------------------------------------------------------------
1099
1100 glutMotionFunc :: MonadIO m => FunPtr MotionFunc -> m ()
1101 glutMotionFunc v1 = liftIO $ dyn_glutMotionFunc ptr_glutMotionFunc v1
1102
1103 foreign import CALLCONV "dynamic" dyn_glutMotionFunc
1104 :: FunPtr (FunPtr MotionFunc -> IO ())
1105 -> FunPtr MotionFunc -> IO ()
1106
1107 {-# NOINLINE ptr_glutMotionFunc #-}
1108 ptr_glutMotionFunc :: FunPtr a
1109 ptr_glutMotionFunc = unsafePerformIO $ getAPIEntry "glutMotionFunc"
1110
1111 -- glutMouseFunc ---------------------------------------------------------------
1112
1113 glutMouseFunc :: MonadIO m => FunPtr MouseFunc -> m ()
1114 glutMouseFunc v1 = liftIO $ dyn_glutMouseFunc ptr_glutMouseFunc v1
1115
1116 foreign import CALLCONV "dynamic" dyn_glutMouseFunc
1117 :: FunPtr (FunPtr MouseFunc -> IO ())
1118 -> FunPtr MouseFunc -> IO ()
1119
1120 {-# NOINLINE ptr_glutMouseFunc #-}
1121 ptr_glutMouseFunc :: FunPtr a
1122 ptr_glutMouseFunc = unsafePerformIO $ getAPIEntry "glutMouseFunc"
1123
1124 -- glutMouseWheelFunc ----------------------------------------------------------
1125
1126 glutMouseWheelFunc :: MonadIO m => FunPtr MouseWheelFunc -> m ()
1127 glutMouseWheelFunc v1 = liftIO $ dyn_glutMouseWheelFunc ptr_glutMouseWheelFunc v1
1128
1129 foreign import CALLCONV "dynamic" dyn_glutMouseWheelFunc
1130 :: FunPtr (FunPtr MouseWheelFunc -> IO ())
1131 -> FunPtr MouseWheelFunc -> IO ()
1132
1133 {-# NOINLINE ptr_glutMouseWheelFunc #-}
1134 ptr_glutMouseWheelFunc :: FunPtr a
1135 ptr_glutMouseWheelFunc = unsafePerformIO $ getAPIEntry "glutMouseWheelFunc"
1136
1137 -- glutMultiButtonFunc ---------------------------------------------------------
1138
1139 glutMultiButtonFunc :: MonadIO m => FunPtr MultiButtonFunc -> m ()
1140 glutMultiButtonFunc v1 = liftIO $ dyn_glutMultiButtonFunc ptr_glutMultiButtonFunc v1
1141
1142 foreign import CALLCONV "dynamic" dyn_glutMultiButtonFunc
1143 :: FunPtr (FunPtr MultiButtonFunc -> IO ())
1144 -> FunPtr MultiButtonFunc -> IO ()
1145
1146 {-# NOINLINE ptr_glutMultiButtonFunc #-}
1147 ptr_glutMultiButtonFunc :: FunPtr a
1148 ptr_glutMultiButtonFunc = unsafePerformIO $ getAPIEntry "glutMultiButtonFunc"
1149
1150 -- glutMultiEntryFunc ----------------------------------------------------------
1151
1152 glutMultiEntryFunc :: MonadIO m => FunPtr MultiEntryFunc -> m ()
1153 glutMultiEntryFunc v1 = liftIO $ dyn_glutMultiEntryFunc ptr_glutMultiEntryFunc v1
1154
1155 foreign import CALLCONV "dynamic" dyn_glutMultiEntryFunc
1156 :: FunPtr (FunPtr MultiEntryFunc -> IO ())
1157 -> FunPtr MultiEntryFunc -> IO ()
1158
1159 {-# NOINLINE ptr_glutMultiEntryFunc #-}
1160 ptr_glutMultiEntryFunc :: FunPtr a
1161 ptr_glutMultiEntryFunc = unsafePerformIO $ getAPIEntry "glutMultiEntryFunc"
1162
1163 -- glutMultiMotionFunc ---------------------------------------------------------
1164
1165 glutMultiMotionFunc :: MonadIO m => FunPtr MultiMotionFunc -> m ()
1166 glutMultiMotionFunc v1 = liftIO $ dyn_glutMultiMotionFunc ptr_glutMultiMotionFunc v1
1167
1168 foreign import CALLCONV "dynamic" dyn_glutMultiMotionFunc
1169 :: FunPtr (FunPtr MultiMotionFunc -> IO ())
1170 -> FunPtr MultiMotionFunc -> IO ()
1171
1172 {-# NOINLINE ptr_glutMultiMotionFunc #-}
1173 ptr_glutMultiMotionFunc :: FunPtr a
1174 ptr_glutMultiMotionFunc = unsafePerformIO $ getAPIEntry "glutMultiMotionFunc"
1175
1176 -- glutMultiPassiveFunc --------------------------------------------------------
1177
1178 glutMultiPassiveFunc :: MonadIO m => FunPtr MultiPassiveFunc -> m ()
1179 glutMultiPassiveFunc v1 = liftIO $ dyn_glutMultiPassiveFunc ptr_glutMultiPassiveFunc v1
1180
1181 foreign import CALLCONV "dynamic" dyn_glutMultiPassiveFunc
1182 :: FunPtr (FunPtr MultiPassiveFunc -> IO ())
1183 -> FunPtr MultiPassiveFunc -> IO ()
1184
1185 {-# NOINLINE ptr_glutMultiPassiveFunc #-}
1186 ptr_glutMultiPassiveFunc :: FunPtr a
1187 ptr_glutMultiPassiveFunc = unsafePerformIO $ getAPIEntry "glutMultiPassiveFunc"
1188
1189 -- glutOverlayDisplayFunc ------------------------------------------------------
1190
1191 glutOverlayDisplayFunc :: MonadIO m => FunPtr OverlayDisplayFunc -> m ()
1192 glutOverlayDisplayFunc v1 = liftIO $ dyn_glutOverlayDisplayFunc ptr_glutOverlayDisplayFunc v1
1193
1194 foreign import CALLCONV "dynamic" dyn_glutOverlayDisplayFunc
1195 :: FunPtr (FunPtr OverlayDisplayFunc -> IO ())
1196 -> FunPtr OverlayDisplayFunc -> IO ()
1197
1198 {-# NOINLINE ptr_glutOverlayDisplayFunc #-}
1199 ptr_glutOverlayDisplayFunc :: FunPtr a
1200 ptr_glutOverlayDisplayFunc = unsafePerformIO $ getAPIEntry "glutOverlayDisplayFunc"
1201
1202 -- glutPassiveMotionFunc -------------------------------------------------------
1203
1204 glutPassiveMotionFunc :: MonadIO m => FunPtr PassiveMotionFunc -> m ()
1205 glutPassiveMotionFunc v1 = liftIO $ dyn_glutPassiveMotionFunc ptr_glutPassiveMotionFunc v1
1206
1207 foreign import CALLCONV "dynamic" dyn_glutPassiveMotionFunc
1208 :: FunPtr (FunPtr PassiveMotionFunc -> IO ())
1209 -> FunPtr PassiveMotionFunc -> IO ()
1210
1211 {-# NOINLINE ptr_glutPassiveMotionFunc #-}
1212 ptr_glutPassiveMotionFunc :: FunPtr a
1213 ptr_glutPassiveMotionFunc = unsafePerformIO $ getAPIEntry "glutPassiveMotionFunc"
1214
1215 -- glutPopWindow ---------------------------------------------------------------
1216
1217 glutPopWindow :: MonadIO m => m ()
1218 glutPopWindow = liftIO $ dyn_glutPopWindow ptr_glutPopWindow
1219
1220 foreign import CALLCONV "dynamic" dyn_glutPopWindow
1221 :: FunPtr (IO ())
1222 -> IO ()
1223
1224 {-# NOINLINE ptr_glutPopWindow #-}
1225 ptr_glutPopWindow :: FunPtr a
1226 ptr_glutPopWindow = unsafePerformIO $ getAPIEntry "glutPopWindow"
1227
1228 -- glutPositionFunc ------------------------------------------------------------
1229
1230 glutPositionFunc :: MonadIO m => FunPtr PositionFunc -> m ()
1231 glutPositionFunc v1 = liftIO $ dyn_glutPositionFunc ptr_glutPositionFunc v1
1232
1233 foreign import CALLCONV "dynamic" dyn_glutPositionFunc
1234 :: FunPtr (FunPtr PositionFunc -> IO ())
1235 -> FunPtr PositionFunc -> IO ()
1236
1237 {-# NOINLINE ptr_glutPositionFunc #-}
1238 ptr_glutPositionFunc :: FunPtr a
1239 ptr_glutPositionFunc = unsafePerformIO $ getAPIEntry "glutPositionFunc"
1240
1241 -- glutPositionWindow ----------------------------------------------------------
1242
1243 glutPositionWindow :: MonadIO m => CInt -> CInt -> m ()
1244 glutPositionWindow v1 v2 = liftIO $ dyn_glutPositionWindow ptr_glutPositionWindow v1 v2
1245
1246 foreign import CALLCONV "dynamic" dyn_glutPositionWindow
1247 :: FunPtr (CInt -> CInt -> IO ())
1248 -> CInt -> CInt -> IO ()
1249
1250 {-# NOINLINE ptr_glutPositionWindow #-}
1251 ptr_glutPositionWindow :: FunPtr a
1252 ptr_glutPositionWindow = unsafePerformIO $ getAPIEntry "glutPositionWindow"
1253
1254 -- glutPostOverlayRedisplay ----------------------------------------------------
1255
1256 glutPostOverlayRedisplay :: MonadIO m => m ()
1257 glutPostOverlayRedisplay = liftIO $ dyn_glutPostOverlayRedisplay ptr_glutPostOverlayRedisplay
1258
1259 foreign import CALLCONV "dynamic" dyn_glutPostOverlayRedisplay
1260 :: FunPtr (IO ())
1261 -> IO ()
1262
1263 {-# NOINLINE ptr_glutPostOverlayRedisplay #-}
1264 ptr_glutPostOverlayRedisplay :: FunPtr a
1265 ptr_glutPostOverlayRedisplay = unsafePerformIO $ getAPIEntry "glutPostOverlayRedisplay"
1266
1267 -- glutPostRedisplay -----------------------------------------------------------
1268
1269 glutPostRedisplay :: MonadIO m => m ()
1270 glutPostRedisplay = liftIO $ dyn_glutPostRedisplay ptr_glutPostRedisplay
1271
1272 foreign import CALLCONV "dynamic" dyn_glutPostRedisplay
1273 :: FunPtr (IO ())
1274 -> IO ()
1275
1276 {-# NOINLINE ptr_glutPostRedisplay #-}
1277 ptr_glutPostRedisplay :: FunPtr a
1278 ptr_glutPostRedisplay = unsafePerformIO $ getAPIEntry "glutPostRedisplay"
1279
1280 -- glutPostWindowOverlayRedisplay ----------------------------------------------
1281
1282 glutPostWindowOverlayRedisplay :: MonadIO m => CInt -> m ()
1283 glutPostWindowOverlayRedisplay v1 = liftIO $ dyn_glutPostWindowOverlayRedisplay ptr_glutPostWindowOverlayRedisplay v1
1284
1285 foreign import CALLCONV "dynamic" dyn_glutPostWindowOverlayRedisplay
1286 :: FunPtr (CInt -> IO ())
1287 -> CInt -> IO ()
1288
1289 {-# NOINLINE ptr_glutPostWindowOverlayRedisplay #-}
1290 ptr_glutPostWindowOverlayRedisplay :: FunPtr a
1291 ptr_glutPostWindowOverlayRedisplay = unsafePerformIO $ getAPIEntry "glutPostWindowOverlayRedisplay"
1292
1293 -- glutPostWindowRedisplay -----------------------------------------------------
1294
1295 glutPostWindowRedisplay :: MonadIO m => CInt -> m ()
1296 glutPostWindowRedisplay v1 = liftIO $ dyn_glutPostWindowRedisplay ptr_glutPostWindowRedisplay v1
1297
1298 foreign import CALLCONV "dynamic" dyn_glutPostWindowRedisplay
1299 :: FunPtr (CInt -> IO ())
1300 -> CInt -> IO ()
1301
1302 {-# NOINLINE ptr_glutPostWindowRedisplay #-}
1303 ptr_glutPostWindowRedisplay :: FunPtr a
1304 ptr_glutPostWindowRedisplay = unsafePerformIO $ getAPIEntry "glutPostWindowRedisplay"
1305
1306 -- glutPushWindow --------------------------------------------------------------
1307
1308 glutPushWindow :: MonadIO m => m ()
1309 glutPushWindow = liftIO $ dyn_glutPushWindow ptr_glutPushWindow
1310
1311 foreign import CALLCONV "dynamic" dyn_glutPushWindow
1312 :: FunPtr (IO ())
1313 -> IO ()
1314
1315 {-# NOINLINE ptr_glutPushWindow #-}
1316 ptr_glutPushWindow :: FunPtr a
1317 ptr_glutPushWindow = unsafePerformIO $ getAPIEntry "glutPushWindow"
1318
1319 -- glutRemoveMenuItem ----------------------------------------------------------
1320
1321 glutRemoveMenuItem :: MonadIO m => CInt -> m ()
1322 glutRemoveMenuItem v1 = liftIO $ dyn_glutRemoveMenuItem ptr_glutRemoveMenuItem v1
1323
1324 foreign import CALLCONV "dynamic" dyn_glutRemoveMenuItem
1325 :: FunPtr (CInt -> IO ())
1326 -> CInt -> IO ()
1327
1328 {-# NOINLINE ptr_glutRemoveMenuItem #-}
1329 ptr_glutRemoveMenuItem :: FunPtr a
1330 ptr_glutRemoveMenuItem = unsafePerformIO $ getAPIEntry "glutRemoveMenuItem"
1331
1332 -- glutRemoveOverlay -----------------------------------------------------------
1333
1334 glutRemoveOverlay :: MonadIO m => m ()
1335 glutRemoveOverlay = liftIO $ dyn_glutRemoveOverlay ptr_glutRemoveOverlay
1336
1337 foreign import CALLCONV "dynamic" dyn_glutRemoveOverlay
1338 :: FunPtr (IO ())
1339 -> IO ()
1340
1341 {-# NOINLINE ptr_glutRemoveOverlay #-}
1342 ptr_glutRemoveOverlay :: FunPtr a
1343 ptr_glutRemoveOverlay = unsafePerformIO $ getAPIEntry "glutRemoveOverlay"
1344
1345 -- glutReportErrors ------------------------------------------------------------
1346
1347 glutReportErrors :: MonadIO m => m ()
1348 glutReportErrors = liftIO $ dyn_glutReportErrors ptr_glutReportErrors
1349
1350 foreign import CALLCONV "dynamic" dyn_glutReportErrors
1351 :: FunPtr (IO ())
1352 -> IO ()
1353
1354 {-# NOINLINE ptr_glutReportErrors #-}
1355 ptr_glutReportErrors :: FunPtr a
1356 ptr_glutReportErrors = unsafePerformIO $ getAPIEntry "glutReportErrors"
1357
1358 -- glutReshapeFunc -------------------------------------------------------------
1359
1360 glutReshapeFunc :: MonadIO m => FunPtr ReshapeFunc -> m ()
1361 glutReshapeFunc v1 = liftIO $ dyn_glutReshapeFunc ptr_glutReshapeFunc v1
1362
1363 foreign import CALLCONV "dynamic" dyn_glutReshapeFunc
1364 :: FunPtr (FunPtr ReshapeFunc -> IO ())
1365 -> FunPtr ReshapeFunc -> IO ()
1366
1367 {-# NOINLINE ptr_glutReshapeFunc #-}
1368 ptr_glutReshapeFunc :: FunPtr a
1369 ptr_glutReshapeFunc = unsafePerformIO $ getAPIEntry "glutReshapeFunc"
1370
1371 -- glutReshapeWindow -----------------------------------------------------------
1372
1373 glutReshapeWindow :: MonadIO m => CInt -> CInt -> m ()
1374 glutReshapeWindow v1 v2 = liftIO $ dyn_glutReshapeWindow ptr_glutReshapeWindow v1 v2
1375
1376 foreign import CALLCONV "dynamic" dyn_glutReshapeWindow
1377 :: FunPtr (CInt -> CInt -> IO ())
1378 -> CInt -> CInt -> IO ()
1379
1380 {-# NOINLINE ptr_glutReshapeWindow #-}
1381 ptr_glutReshapeWindow :: FunPtr a
1382 ptr_glutReshapeWindow = unsafePerformIO $ getAPIEntry "glutReshapeWindow"
1383
1384 -- glutSetColor ----------------------------------------------------------------
1385
1386 glutSetColor :: MonadIO m => CInt -> GLfloat -> GLfloat -> GLfloat -> m ()
1387 glutSetColor v1 v2 v3 v4 = liftIO $ dyn_glutSetColor ptr_glutSetColor v1 v2 v3 v4
1388
1389 foreign import CALLCONV "dynamic" dyn_glutSetColor
1390 :: FunPtr (CInt -> GLfloat -> GLfloat -> GLfloat -> IO ())
1391 -> CInt -> GLfloat -> GLfloat -> GLfloat -> IO ()
1392
1393 {-# NOINLINE ptr_glutSetColor #-}
1394 ptr_glutSetColor :: FunPtr a
1395 ptr_glutSetColor = unsafePerformIO $ getAPIEntry "glutSetColor"
1396
1397 -- glutSetCursor ---------------------------------------------------------------
1398
1399 glutSetCursor :: MonadIO m => CInt -> m ()
1400 glutSetCursor v1 = liftIO $ dyn_glutSetCursor ptr_glutSetCursor v1
1401
1402 foreign import CALLCONV "dynamic" dyn_glutSetCursor
1403 :: FunPtr (CInt -> IO ())
1404 -> CInt -> IO ()
1405
1406 {-# NOINLINE ptr_glutSetCursor #-}
1407 ptr_glutSetCursor :: FunPtr a
1408 ptr_glutSetCursor = unsafePerformIO $ getAPIEntry "glutSetCursor"
1409
1410 -- glutSetIconTitle ------------------------------------------------------------
1411
1412 glutSetIconTitle :: MonadIO m => Ptr CChar -> m ()
1413 glutSetIconTitle v1 = liftIO $ dyn_glutSetIconTitle ptr_glutSetIconTitle v1
1414
1415 foreign import CALLCONV "dynamic" dyn_glutSetIconTitle
1416 :: FunPtr (Ptr CChar -> IO ())
1417 -> Ptr CChar -> IO ()
1418
1419 {-# NOINLINE ptr_glutSetIconTitle #-}
1420 ptr_glutSetIconTitle :: FunPtr a
1421 ptr_glutSetIconTitle = unsafePerformIO $ getAPIEntry "glutSetIconTitle"
1422
1423 -- glutSetKeyRepeat ------------------------------------------------------------
1424
1425 glutSetKeyRepeat :: MonadIO m => CInt -> m ()
1426 glutSetKeyRepeat v1 = liftIO $ dyn_glutSetKeyRepeat ptr_glutSetKeyRepeat v1
1427
1428 foreign import CALLCONV "dynamic" dyn_glutSetKeyRepeat
1429 :: FunPtr (CInt -> IO ())
1430 -> CInt -> IO ()
1431
1432 {-# NOINLINE ptr_glutSetKeyRepeat #-}
1433 ptr_glutSetKeyRepeat :: FunPtr a
1434 ptr_glutSetKeyRepeat = unsafePerformIO $ getAPIEntry "glutSetKeyRepeat"
1435
1436 -- glutSetMenu -----------------------------------------------------------------
1437
1438 glutSetMenu :: MonadIO m => CInt -> m ()
1439 glutSetMenu v1 = liftIO $ dyn_glutSetMenu ptr_glutSetMenu v1
1440
1441 foreign import CALLCONV "dynamic" dyn_glutSetMenu
1442 :: FunPtr (CInt -> IO ())
1443 -> CInt -> IO ()
1444
1445 {-# NOINLINE ptr_glutSetMenu #-}
1446 ptr_glutSetMenu :: FunPtr a
1447 ptr_glutSetMenu = unsafePerformIO $ getAPIEntry "glutSetMenu"
1448
1449 -- glutSetMenuData -------------------------------------------------------------
1450
1451 glutSetMenuData :: MonadIO m => Ptr a -> m ()
1452 glutSetMenuData v1 = liftIO $ dyn_glutSetMenuData ptr_glutSetMenuData v1
1453
1454 foreign import CALLCONV "dynamic" dyn_glutSetMenuData
1455 :: FunPtr (Ptr a -> IO ())
1456 -> Ptr a -> IO ()
1457
1458 {-# NOINLINE ptr_glutSetMenuData #-}
1459 ptr_glutSetMenuData :: FunPtr a
1460 ptr_glutSetMenuData = unsafePerformIO $ getAPIEntry "glutSetMenuData"
1461
1462 -- glutSetMenuFont -------------------------------------------------------------
1463
1464 glutSetMenuFont :: MonadIO m => CInt -> Ptr a -> m ()
1465 glutSetMenuFont v1 v2 = liftIO $ dyn_glutSetMenuFont ptr_glutSetMenuFont v1 v2
1466
1467 foreign import CALLCONV "dynamic" dyn_glutSetMenuFont
1468 :: FunPtr (CInt -> Ptr a -> IO ())
1469 -> CInt -> Ptr a -> IO ()
1470
1471 {-# NOINLINE ptr_glutSetMenuFont #-}
1472 ptr_glutSetMenuFont :: FunPtr a
1473 ptr_glutSetMenuFont = unsafePerformIO $ getAPIEntry "glutSetMenuFont"
1474
1475 -- glutSetOption ---------------------------------------------------------------
1476
1477 glutSetOption :: MonadIO m => GLenum -> CInt -> m ()
1478 glutSetOption v1 v2 = liftIO $ dyn_glutSetOption ptr_glutSetOption v1 v2
1479
1480 foreign import CALLCONV "dynamic" dyn_glutSetOption
1481 :: FunPtr (GLenum -> CInt -> IO ())
1482 -> GLenum -> CInt -> IO ()
1483
1484 {-# NOINLINE ptr_glutSetOption #-}
1485 ptr_glutSetOption :: FunPtr a
1486 ptr_glutSetOption = unsafePerformIO $ getAPIEntry "glutSetOption"
1487
1488 -- glutSetVertexAttribCoord3 ---------------------------------------------------
1489
1490 glutSetVertexAttribCoord3 :: MonadIO m => GLint -> m ()
1491 glutSetVertexAttribCoord3 v1 = liftIO $ dyn_glutSetVertexAttribCoord3 ptr_glutSetVertexAttribCoord3 v1
1492
1493 foreign import CALLCONV "dynamic" dyn_glutSetVertexAttribCoord3
1494 :: FunPtr (GLint -> IO ())
1495 -> GLint -> IO ()
1496
1497 {-# NOINLINE ptr_glutSetVertexAttribCoord3 #-}
1498 ptr_glutSetVertexAttribCoord3 :: FunPtr a
1499 ptr_glutSetVertexAttribCoord3 = unsafePerformIO $ getAPIEntry "glutSetVertexAttribCoord3"
1500
1501 -- glutSetVertexAttribNormal ---------------------------------------------------
1502
1503 glutSetVertexAttribNormal :: MonadIO m => GLint -> m ()
1504 glutSetVertexAttribNormal v1 = liftIO $ dyn_glutSetVertexAttribNormal ptr_glutSetVertexAttribNormal v1
1505
1506 foreign import CALLCONV "dynamic" dyn_glutSetVertexAttribNormal
1507 :: FunPtr (GLint -> IO ())
1508 -> GLint -> IO ()
1509
1510 {-# NOINLINE ptr_glutSetVertexAttribNormal #-}
1511 ptr_glutSetVertexAttribNormal :: FunPtr a
1512 ptr_glutSetVertexAttribNormal = unsafePerformIO $ getAPIEntry "glutSetVertexAttribNormal"
1513
1514 -- glutSetVertexAttribTexCoord2 ------------------------------------------------
1515
1516 glutSetVertexAttribTexCoord2 :: MonadIO m => GLint -> m ()
1517 glutSetVertexAttribTexCoord2 v1 = liftIO $ dyn_glutSetVertexAttribTexCoord2 ptr_glutSetVertexAttribTexCoord2 v1
1518
1519 foreign import CALLCONV "dynamic" dyn_glutSetVertexAttribTexCoord2
1520 :: FunPtr (GLint -> IO ())
1521 -> GLint -> IO ()
1522
1523 {-# NOINLINE ptr_glutSetVertexAttribTexCoord2 #-}
1524 ptr_glutSetVertexAttribTexCoord2 :: FunPtr a
1525 ptr_glutSetVertexAttribTexCoord2 = unsafePerformIO $ getAPIEntry "glutSetVertexAttribTexCoord2"
1526
1527 -- glutSetWindow ---------------------------------------------------------------
1528
1529 glutSetWindow :: MonadIO m => CInt -> m ()
1530 glutSetWindow v1 = liftIO $ dyn_glutSetWindow ptr_glutSetWindow v1
1531
1532 foreign import CALLCONV "dynamic" dyn_glutSetWindow
1533 :: FunPtr (CInt -> IO ())
1534 -> CInt -> IO ()
1535
1536 {-# NOINLINE ptr_glutSetWindow #-}
1537 ptr_glutSetWindow :: FunPtr a
1538 ptr_glutSetWindow = unsafePerformIO $ getAPIEntry "glutSetWindow"
1539
1540 -- glutSetWindowData -----------------------------------------------------------
1541
1542 glutSetWindowData :: MonadIO m => Ptr a -> m ()
1543 glutSetWindowData v1 = liftIO $ dyn_glutSetWindowData ptr_glutSetWindowData v1
1544
1545 foreign import CALLCONV "dynamic" dyn_glutSetWindowData
1546 :: FunPtr (Ptr a -> IO ())
1547 -> Ptr a -> IO ()
1548
1549 {-# NOINLINE ptr_glutSetWindowData #-}
1550 ptr_glutSetWindowData :: FunPtr a
1551 ptr_glutSetWindowData = unsafePerformIO $ getAPIEntry "glutSetWindowData"
1552
1553 -- glutSetWindowTitle ----------------------------------------------------------
1554
1555 glutSetWindowTitle :: MonadIO m => Ptr CChar -> m ()
1556 glutSetWindowTitle v1 = liftIO $ dyn_glutSetWindowTitle ptr_glutSetWindowTitle v1
1557
1558 foreign import CALLCONV "dynamic" dyn_glutSetWindowTitle
1559 :: FunPtr (Ptr CChar -> IO ())
1560 -> Ptr CChar -> IO ()
1561
1562 {-# NOINLINE ptr_glutSetWindowTitle #-}
1563 ptr_glutSetWindowTitle :: FunPtr a
1564 ptr_glutSetWindowTitle = unsafePerformIO $ getAPIEntry "glutSetWindowTitle"
1565
1566 -- glutSetupVideoResizing ------------------------------------------------------
1567
1568 glutSetupVideoResizing :: MonadIO m => m ()
1569 glutSetupVideoResizing = liftIO $ dyn_glutSetupVideoResizing ptr_glutSetupVideoResizing
1570
1571 foreign import CALLCONV "dynamic" dyn_glutSetupVideoResizing
1572 :: FunPtr (IO ())
1573 -> IO ()
1574
1575 {-# NOINLINE ptr_glutSetupVideoResizing #-}
1576 ptr_glutSetupVideoResizing :: FunPtr a
1577 ptr_glutSetupVideoResizing = unsafePerformIO $ getAPIEntry "glutSetupVideoResizing"
1578
1579 -- glutShowOverlay -------------------------------------------------------------
1580
1581 glutShowOverlay :: MonadIO m => m ()
1582 glutShowOverlay = liftIO $ dyn_glutShowOverlay ptr_glutShowOverlay
1583
1584 foreign import CALLCONV "dynamic" dyn_glutShowOverlay
1585 :: FunPtr (IO ())
1586 -> IO ()
1587
1588 {-# NOINLINE ptr_glutShowOverlay #-}
1589 ptr_glutShowOverlay :: FunPtr a
1590 ptr_glutShowOverlay = unsafePerformIO $ getAPIEntry "glutShowOverlay"
1591
1592 -- glutShowWindow --------------------------------------------------------------
1593
1594 glutShowWindow :: MonadIO m => m ()
1595 glutShowWindow = liftIO $ dyn_glutShowWindow ptr_glutShowWindow
1596
1597 foreign import CALLCONV "dynamic" dyn_glutShowWindow
1598 :: FunPtr (IO ())
1599 -> IO ()
1600
1601 {-# NOINLINE ptr_glutShowWindow #-}
1602 ptr_glutShowWindow :: FunPtr a
1603 ptr_glutShowWindow = unsafePerformIO $ getAPIEntry "glutShowWindow"
1604
1605 -- glutSolidCone ---------------------------------------------------------------
1606
1607 glutSolidCone :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
1608 glutSolidCone v1 v2 v3 v4 = liftIO $ dyn_glutSolidCone ptr_glutSolidCone v1 v2 v3 v4
1609
1610 foreign import CALLCONV "dynamic" dyn_glutSolidCone
1611 :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
1612 -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
1613
1614 {-# NOINLINE ptr_glutSolidCone #-}
1615 ptr_glutSolidCone :: FunPtr a
1616 ptr_glutSolidCone = unsafePerformIO $ getAPIEntry "glutSolidCone"
1617
1618 -- glutSolidCube ---------------------------------------------------------------
1619
1620 glutSolidCube :: MonadIO m => GLdouble -> m ()
1621 glutSolidCube v1 = liftIO $ dyn_glutSolidCube ptr_glutSolidCube v1
1622
1623 foreign import CALLCONV "dynamic" dyn_glutSolidCube
1624 :: FunPtr (GLdouble -> IO ())
1625 -> GLdouble -> IO ()
1626
1627 {-# NOINLINE ptr_glutSolidCube #-}
1628 ptr_glutSolidCube :: FunPtr a
1629 ptr_glutSolidCube = unsafePerformIO $ getAPIEntry "glutSolidCube"
1630
1631 -- glutSolidCylinder -----------------------------------------------------------
1632
1633 glutSolidCylinder :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
1634 glutSolidCylinder v1 v2 v3 v4 = liftIO $ dyn_glutSolidCylinder ptr_glutSolidCylinder v1 v2 v3 v4
1635
1636 foreign import CALLCONV "dynamic" dyn_glutSolidCylinder
1637 :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
1638 -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
1639
1640 {-# NOINLINE ptr_glutSolidCylinder #-}
1641 ptr_glutSolidCylinder :: FunPtr a
1642 ptr_glutSolidCylinder = unsafePerformIO $ getAPIEntry "glutSolidCylinder"
1643
1644 -- glutSolidDodecahedron -------------------------------------------------------
1645
1646 glutSolidDodecahedron :: MonadIO m => m ()
1647 glutSolidDodecahedron = liftIO $ dyn_glutSolidDodecahedron ptr_glutSolidDodecahedron
1648
1649 foreign import CALLCONV "dynamic" dyn_glutSolidDodecahedron
1650 :: FunPtr (IO ())
1651 -> IO ()
1652
1653 {-# NOINLINE ptr_glutSolidDodecahedron #-}
1654 ptr_glutSolidDodecahedron :: FunPtr a
1655 ptr_glutSolidDodecahedron = unsafePerformIO $ getAPIEntry "glutSolidDodecahedron"
1656
1657 -- glutSolidIcosahedron --------------------------------------------------------
1658
1659 glutSolidIcosahedron :: MonadIO m => m ()
1660 glutSolidIcosahedron = liftIO $ dyn_glutSolidIcosahedron ptr_glutSolidIcosahedron
1661
1662 foreign import CALLCONV "dynamic" dyn_glutSolidIcosahedron
1663 :: FunPtr (IO ())
1664 -> IO ()
1665
1666 {-# NOINLINE ptr_glutSolidIcosahedron #-}
1667 ptr_glutSolidIcosahedron :: FunPtr a
1668 ptr_glutSolidIcosahedron = unsafePerformIO $ getAPIEntry "glutSolidIcosahedron"
1669
1670 -- glutSolidOctahedron ---------------------------------------------------------
1671
1672 glutSolidOctahedron :: MonadIO m => m ()
1673 glutSolidOctahedron = liftIO $ dyn_glutSolidOctahedron ptr_glutSolidOctahedron
1674
1675 foreign import CALLCONV "dynamic" dyn_glutSolidOctahedron
1676 :: FunPtr (IO ())
1677 -> IO ()
1678
1679 {-# NOINLINE ptr_glutSolidOctahedron #-}
1680 ptr_glutSolidOctahedron :: FunPtr a
1681 ptr_glutSolidOctahedron = unsafePerformIO $ getAPIEntry "glutSolidOctahedron"
1682
1683 -- glutSolidRhombicDodecahedron ------------------------------------------------
1684
1685 glutSolidRhombicDodecahedron :: MonadIO m => m ()
1686 glutSolidRhombicDodecahedron = liftIO $ dyn_glutSolidRhombicDodecahedron ptr_glutSolidRhombicDodecahedron
1687
1688 foreign import CALLCONV "dynamic" dyn_glutSolidRhombicDodecahedron
1689 :: FunPtr (IO ())
1690 -> IO ()
1691
1692 {-# NOINLINE ptr_glutSolidRhombicDodecahedron #-}
1693 ptr_glutSolidRhombicDodecahedron :: FunPtr a
1694 ptr_glutSolidRhombicDodecahedron = unsafePerformIO $ getAPIEntry "glutSolidRhombicDodecahedron"
1695
1696 -- glutSolidSierpinskiSponge ---------------------------------------------------
1697
1698 glutSolidSierpinskiSponge :: MonadIO m => CInt -> Ptr GLdouble -> GLdouble -> m ()
1699 glutSolidSierpinskiSponge v1 v2 v3 = liftIO $ dyn_glutSolidSierpinskiSponge ptr_glutSolidSierpinskiSponge v1 v2 v3
1700
1701 foreign import CALLCONV "dynamic" dyn_glutSolidSierpinskiSponge
1702 :: FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
1703 -> CInt -> Ptr GLdouble -> GLdouble -> IO ()
1704
1705 {-# NOINLINE ptr_glutSolidSierpinskiSponge #-}
1706 ptr_glutSolidSierpinskiSponge :: FunPtr a
1707 ptr_glutSolidSierpinskiSponge = unsafePerformIO $ getAPIEntry "glutSolidSierpinskiSponge"
1708
1709 -- glutSolidSphere -------------------------------------------------------------
1710
1711 glutSolidSphere :: MonadIO m => GLdouble -> GLint -> GLint -> m ()
1712 glutSolidSphere v1 v2 v3 = liftIO $ dyn_glutSolidSphere ptr_glutSolidSphere v1 v2 v3
1713
1714 foreign import CALLCONV "dynamic" dyn_glutSolidSphere
1715 :: FunPtr (GLdouble -> GLint -> GLint -> IO ())
1716 -> GLdouble -> GLint -> GLint -> IO ()
1717
1718 {-# NOINLINE ptr_glutSolidSphere #-}
1719 ptr_glutSolidSphere :: FunPtr a
1720 ptr_glutSolidSphere = unsafePerformIO $ getAPIEntry "glutSolidSphere"
1721
1722 -- glutSolidTeacup -------------------------------------------------------------
1723
1724 glutSolidTeacup :: MonadIO m => GLdouble -> m ()
1725 glutSolidTeacup v1 = liftIO $ dyn_glutSolidTeacup ptr_glutSolidTeacup v1
1726
1727 foreign import CALLCONV "dynamic" dyn_glutSolidTeacup
1728 :: FunPtr (GLdouble -> IO ())
1729 -> GLdouble -> IO ()
1730
1731 {-# NOINLINE ptr_glutSolidTeacup #-}
1732 ptr_glutSolidTeacup :: FunPtr a
1733 ptr_glutSolidTeacup = unsafePerformIO $ getAPIEntry "glutSolidTeacup"
1734
1735 -- glutSolidTeapot -------------------------------------------------------------
1736
1737 glutSolidTeapot :: MonadIO m => GLdouble -> m ()
1738 glutSolidTeapot v1 = liftIO $ dyn_glutSolidTeapot ptr_glutSolidTeapot v1
1739
1740 foreign import CALLCONV "dynamic" dyn_glutSolidTeapot
1741 :: FunPtr (GLdouble -> IO ())
1742 -> GLdouble -> IO ()
1743
1744 {-# NOINLINE ptr_glutSolidTeapot #-}
1745 ptr_glutSolidTeapot :: FunPtr a
1746 ptr_glutSolidTeapot = unsafePerformIO $ getAPIEntry "glutSolidTeapot"
1747
1748 -- glutSolidTeaspoon -----------------------------------------------------------
1749
1750 glutSolidTeaspoon :: MonadIO m => GLdouble -> m ()
1751 glutSolidTeaspoon v1 = liftIO $ dyn_glutSolidTeaspoon ptr_glutSolidTeaspoon v1
1752
1753 foreign import CALLCONV "dynamic" dyn_glutSolidTeaspoon
1754 :: FunPtr (GLdouble -> IO ())
1755 -> GLdouble -> IO ()
1756
1757 {-# NOINLINE ptr_glutSolidTeaspoon #-}
1758 ptr_glutSolidTeaspoon :: FunPtr a
1759 ptr_glutSolidTeaspoon = unsafePerformIO $ getAPIEntry "glutSolidTeaspoon"
1760
1761 -- glutSolidTetrahedron --------------------------------------------------------
1762
1763 glutSolidTetrahedron :: MonadIO m => m ()
1764 glutSolidTetrahedron = liftIO $ dyn_glutSolidTetrahedron ptr_glutSolidTetrahedron
1765
1766 foreign import CALLCONV "dynamic" dyn_glutSolidTetrahedron
1767 :: FunPtr (IO ())
1768 -> IO ()
1769
1770 {-# NOINLINE ptr_glutSolidTetrahedron #-}
1771 ptr_glutSolidTetrahedron :: FunPtr a
1772 ptr_glutSolidTetrahedron = unsafePerformIO $ getAPIEntry "glutSolidTetrahedron"
1773
1774 -- glutSolidTorus --------------------------------------------------------------
1775
1776 glutSolidTorus :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
1777 glutSolidTorus v1 v2 v3 v4 = liftIO $ dyn_glutSolidTorus ptr_glutSolidTorus v1 v2 v3 v4
1778
1779 foreign import CALLCONV "dynamic" dyn_glutSolidTorus
1780 :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
1781 -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
1782
1783 {-# NOINLINE ptr_glutSolidTorus #-}
1784 ptr_glutSolidTorus :: FunPtr a
1785 ptr_glutSolidTorus = unsafePerformIO $ getAPIEntry "glutSolidTorus"
1786
1787 -- glutSpaceballButtonFunc -----------------------------------------------------
1788
1789 glutSpaceballButtonFunc :: MonadIO m => FunPtr SpaceballButtonFunc -> m ()
1790 glutSpaceballButtonFunc v1 = liftIO $ dyn_glutSpaceballButtonFunc ptr_glutSpaceballButtonFunc v1
1791
1792 foreign import CALLCONV "dynamic" dyn_glutSpaceballButtonFunc
1793 :: FunPtr (FunPtr SpaceballButtonFunc -> IO ())
1794 -> FunPtr SpaceballButtonFunc -> IO ()
1795
1796 {-# NOINLINE ptr_glutSpaceballButtonFunc #-}
1797 ptr_glutSpaceballButtonFunc :: FunPtr a
1798 ptr_glutSpaceballButtonFunc = unsafePerformIO $ getAPIEntry "glutSpaceballButtonFunc"
1799
1800 -- glutSpaceballMotionFunc -----------------------------------------------------
1801
1802 glutSpaceballMotionFunc :: MonadIO m => FunPtr SpaceballMotionFunc -> m ()
1803 glutSpaceballMotionFunc v1 = liftIO $ dyn_glutSpaceballMotionFunc ptr_glutSpaceballMotionFunc v1
1804
1805 foreign import CALLCONV "dynamic" dyn_glutSpaceballMotionFunc
1806 :: FunPtr (FunPtr SpaceballMotionFunc -> IO ())
1807 -> FunPtr SpaceballMotionFunc -> IO ()
1808
1809 {-# NOINLINE ptr_glutSpaceballMotionFunc #-}
1810 ptr_glutSpaceballMotionFunc :: FunPtr a
1811 ptr_glutSpaceballMotionFunc = unsafePerformIO $ getAPIEntry "glutSpaceballMotionFunc"
1812
1813 -- glutSpaceballRotateFunc -----------------------------------------------------
1814
1815 glutSpaceballRotateFunc :: MonadIO m => FunPtr SpaceballRotateFunc -> m ()
1816 glutSpaceballRotateFunc v1 = liftIO $ dyn_glutSpaceballRotateFunc ptr_glutSpaceballRotateFunc v1
1817
1818 foreign import CALLCONV "dynamic" dyn_glutSpaceballRotateFunc
1819 :: FunPtr (FunPtr SpaceballRotateFunc -> IO ())
1820 -> FunPtr SpaceballRotateFunc -> IO ()
1821
1822 {-# NOINLINE ptr_glutSpaceballRotateFunc #-}
1823 ptr_glutSpaceballRotateFunc :: FunPtr a
1824 ptr_glutSpaceballRotateFunc = unsafePerformIO $ getAPIEntry "glutSpaceballRotateFunc"
1825
1826 -- glutSpecialFunc -------------------------------------------------------------
1827
1828 glutSpecialFunc :: MonadIO m => FunPtr SpecialFunc -> m ()
1829 glutSpecialFunc v1 = liftIO $ dyn_glutSpecialFunc ptr_glutSpecialFunc v1
1830
1831 foreign import CALLCONV "dynamic" dyn_glutSpecialFunc
1832 :: FunPtr (FunPtr SpecialFunc -> IO ())
1833 -> FunPtr SpecialFunc -> IO ()
1834
1835 {-# NOINLINE ptr_glutSpecialFunc #-}
1836 ptr_glutSpecialFunc :: FunPtr a
1837 ptr_glutSpecialFunc = unsafePerformIO $ getAPIEntry "glutSpecialFunc"
1838
1839 -- glutSpecialUpFunc -----------------------------------------------------------
1840
1841 glutSpecialUpFunc :: MonadIO m => FunPtr SpecialUpFunc -> m ()
1842 glutSpecialUpFunc v1 = liftIO $ dyn_glutSpecialUpFunc ptr_glutSpecialUpFunc v1
1843
1844 foreign import CALLCONV "dynamic" dyn_glutSpecialUpFunc
1845 :: FunPtr (FunPtr SpecialUpFunc -> IO ())
1846 -> FunPtr SpecialUpFunc -> IO ()
1847
1848 {-# NOINLINE ptr_glutSpecialUpFunc #-}
1849 ptr_glutSpecialUpFunc :: FunPtr a
1850 ptr_glutSpecialUpFunc = unsafePerformIO $ getAPIEntry "glutSpecialUpFunc"
1851
1852 -- glutStopVideoResizing -------------------------------------------------------
1853
1854 glutStopVideoResizing :: MonadIO m => m ()
1855 glutStopVideoResizing = liftIO $ dyn_glutStopVideoResizing ptr_glutStopVideoResizing
1856
1857 foreign import CALLCONV "dynamic" dyn_glutStopVideoResizing
1858 :: FunPtr (IO ())
1859 -> IO ()
1860
1861 {-# NOINLINE ptr_glutStopVideoResizing #-}
1862 ptr_glutStopVideoResizing :: FunPtr a
1863 ptr_glutStopVideoResizing = unsafePerformIO $ getAPIEntry "glutStopVideoResizing"
1864
1865 -- glutStrokeCharacter ---------------------------------------------------------
1866
1867 glutStrokeCharacter :: MonadIO m => Ptr a -> CInt -> m ()
1868 glutStrokeCharacter v1 v2 = liftIO $ dyn_glutStrokeCharacter ptr_glutStrokeCharacter v1 v2
1869
1870 foreign import CALLCONV "dynamic" dyn_glutStrokeCharacter
1871 :: FunPtr (Ptr a -> CInt -> IO ())
1872 -> Ptr a -> CInt -> IO ()
1873
1874 {-# NOINLINE ptr_glutStrokeCharacter #-}
1875 ptr_glutStrokeCharacter :: FunPtr a
1876 ptr_glutStrokeCharacter = unsafePerformIO $ getAPIEntry "glutStrokeCharacter"
1877
1878 -- glutStrokeHeight ------------------------------------------------------------
1879
1880 glutStrokeHeight :: MonadIO m => Ptr a -> m GLfloat
1881 glutStrokeHeight v1 = liftIO $ dyn_glutStrokeHeight ptr_glutStrokeHeight v1
1882
1883 foreign import CALLCONV "dynamic" dyn_glutStrokeHeight
1884 :: FunPtr (Ptr a -> IO GLfloat)
1885 -> Ptr a -> IO GLfloat
1886
1887 {-# NOINLINE ptr_glutStrokeHeight #-}
1888 ptr_glutStrokeHeight :: FunPtr a
1889 ptr_glutStrokeHeight = unsafePerformIO $ getAPIEntry "glutStrokeHeight"
1890
1891 -- glutStrokeLength ------------------------------------------------------------
1892
1893 glutStrokeLength :: MonadIO m => Ptr a -> Ptr CUChar -> m CInt
1894 glutStrokeLength v1 v2 = liftIO $ dyn_glutStrokeLength ptr_glutStrokeLength v1 v2
1895
1896 foreign import CALLCONV "dynamic" dyn_glutStrokeLength
1897 :: FunPtr (Ptr a -> Ptr CUChar -> IO CInt)
1898 -> Ptr a -> Ptr CUChar -> IO CInt
1899
1900 {-# NOINLINE ptr_glutStrokeLength #-}
1901 ptr_glutStrokeLength :: FunPtr a
1902 ptr_glutStrokeLength = unsafePerformIO $ getAPIEntry "glutStrokeLength"
1903
1904 -- glutStrokeString ------------------------------------------------------------
1905
1906 glutStrokeString :: MonadIO m => Ptr a -> Ptr CUChar -> m ()
1907 glutStrokeString v1 v2 = liftIO $ dyn_glutStrokeString ptr_glutStrokeString v1 v2
1908
1909 foreign import CALLCONV "dynamic" dyn_glutStrokeString
1910 :: FunPtr (Ptr a -> Ptr CUChar -> IO ())
1911 -> Ptr a -> Ptr CUChar -> IO ()
1912
1913 {-# NOINLINE ptr_glutStrokeString #-}
1914 ptr_glutStrokeString :: FunPtr a
1915 ptr_glutStrokeString = unsafePerformIO $ getAPIEntry "glutStrokeString"
1916
1917 -- glutStrokeWidth -------------------------------------------------------------
1918
1919 glutStrokeWidth :: MonadIO m => Ptr a -> CInt -> m CInt
1920 glutStrokeWidth v1 v2 = liftIO $ dyn_glutStrokeWidth ptr_glutStrokeWidth v1 v2
1921
1922 foreign import CALLCONV "dynamic" dyn_glutStrokeWidth
1923 :: FunPtr (Ptr a -> CInt -> IO CInt)
1924 -> Ptr a -> CInt -> IO CInt
1925
1926 {-# NOINLINE ptr_glutStrokeWidth #-}
1927 ptr_glutStrokeWidth :: FunPtr a
1928 ptr_glutStrokeWidth = unsafePerformIO $ getAPIEntry "glutStrokeWidth"
1929
1930 -- glutSwapBuffers -------------------------------------------------------------
1931
1932 glutSwapBuffers :: MonadIO m => m ()
1933 glutSwapBuffers = liftIO $ dyn_glutSwapBuffers ptr_glutSwapBuffers
1934
1935 foreign import CALLCONV "dynamic" dyn_glutSwapBuffers
1936 :: FunPtr (IO ())
1937 -> IO ()
1938
1939 {-# NOINLINE ptr_glutSwapBuffers #-}
1940 ptr_glutSwapBuffers :: FunPtr a
1941 ptr_glutSwapBuffers = unsafePerformIO $ getAPIEntry "glutSwapBuffers"
1942
1943 -- glutTabletButtonFunc --------------------------------------------------------
1944
1945 glutTabletButtonFunc :: MonadIO m => FunPtr TabletButtonFunc -> m ()
1946 glutTabletButtonFunc v1 = liftIO $ dyn_glutTabletButtonFunc ptr_glutTabletButtonFunc v1
1947
1948 foreign import CALLCONV "dynamic" dyn_glutTabletButtonFunc
1949 :: FunPtr (FunPtr TabletButtonFunc -> IO ())
1950 -> FunPtr TabletButtonFunc -> IO ()
1951
1952 {-# NOINLINE ptr_glutTabletButtonFunc #-}
1953 ptr_glutTabletButtonFunc :: FunPtr a
1954 ptr_glutTabletButtonFunc = unsafePerformIO $ getAPIEntry "glutTabletButtonFunc"
1955
1956 -- glutTabletMotionFunc --------------------------------------------------------
1957
1958 glutTabletMotionFunc :: MonadIO m => FunPtr TabletMotionFunc -> m ()
1959 glutTabletMotionFunc v1 = liftIO $ dyn_glutTabletMotionFunc ptr_glutTabletMotionFunc v1
1960
1961 foreign import CALLCONV "dynamic" dyn_glutTabletMotionFunc
1962 :: FunPtr (FunPtr TabletMotionFunc -> IO ())
1963 -> FunPtr TabletMotionFunc -> IO ()
1964
1965 {-# NOINLINE ptr_glutTabletMotionFunc #-}
1966 ptr_glutTabletMotionFunc :: FunPtr a
1967 ptr_glutTabletMotionFunc = unsafePerformIO $ getAPIEntry "glutTabletMotionFunc"
1968
1969 -- glutTimerFunc ---------------------------------------------------------------
1970
1971 glutTimerFunc :: MonadIO m => CUInt -> FunPtr TimerFunc -> CInt -> m ()
1972 glutTimerFunc v1 v2 v3 = liftIO $ dyn_glutTimerFunc ptr_glutTimerFunc v1 v2 v3
1973
1974 foreign import CALLCONV "dynamic" dyn_glutTimerFunc
1975 :: FunPtr (CUInt -> FunPtr TimerFunc -> CInt -> IO ())
1976 -> CUInt -> FunPtr TimerFunc -> CInt -> IO ()
1977
1978 {-# NOINLINE ptr_glutTimerFunc #-}
1979 ptr_glutTimerFunc :: FunPtr a
1980 ptr_glutTimerFunc = unsafePerformIO $ getAPIEntry "glutTimerFunc"
1981
1982 -- glutUseLayer ----------------------------------------------------------------
1983
1984 glutUseLayer :: MonadIO m => GLenum -> m ()
1985 glutUseLayer v1 = liftIO $ dyn_glutUseLayer ptr_glutUseLayer v1
1986
1987 foreign import CALLCONV "dynamic" dyn_glutUseLayer
1988 :: FunPtr (GLenum -> IO ())
1989 -> GLenum -> IO ()
1990
1991 {-# NOINLINE ptr_glutUseLayer #-}
1992 ptr_glutUseLayer :: FunPtr a
1993 ptr_glutUseLayer = unsafePerformIO $ getAPIEntry "glutUseLayer"
1994
1995 -- glutVideoPan ----------------------------------------------------------------
1996
1997 glutVideoPan :: MonadIO m => CInt -> CInt -> CInt -> CInt -> m ()
1998 glutVideoPan v1 v2 v3 v4 = liftIO $ dyn_glutVideoPan ptr_glutVideoPan v1 v2 v3 v4
1999
2000 foreign import CALLCONV "dynamic" dyn_glutVideoPan
2001 :: FunPtr (CInt -> CInt -> CInt -> CInt -> IO ())
2002 -> CInt -> CInt -> CInt -> CInt -> IO ()
2003
2004 {-# NOINLINE ptr_glutVideoPan #-}
2005 ptr_glutVideoPan :: FunPtr a
2006 ptr_glutVideoPan = unsafePerformIO $ getAPIEntry "glutVideoPan"
2007
2008 -- glutVideoResize -------------------------------------------------------------
2009
2010 glutVideoResize :: MonadIO m => CInt -> CInt -> CInt -> CInt -> m ()
2011 glutVideoResize v1 v2 v3 v4 = liftIO $ dyn_glutVideoResize ptr_glutVideoResize v1 v2 v3 v4
2012
2013 foreign import CALLCONV "dynamic" dyn_glutVideoResize
2014 :: FunPtr (CInt -> CInt -> CInt -> CInt -> IO ())
2015 -> CInt -> CInt -> CInt -> CInt -> IO ()
2016
2017 {-# NOINLINE ptr_glutVideoResize #-}
2018 ptr_glutVideoResize :: FunPtr a
2019 ptr_glutVideoResize = unsafePerformIO $ getAPIEntry "glutVideoResize"
2020
2021 -- glutVideoResizeGet ----------------------------------------------------------
2022
2023 glutVideoResizeGet :: MonadIO m => GLenum -> m CInt
2024 glutVideoResizeGet v1 = liftIO $ dyn_glutVideoResizeGet ptr_glutVideoResizeGet v1
2025
2026 foreign import CALLCONV "dynamic" dyn_glutVideoResizeGet
2027 :: FunPtr (GLenum -> IO CInt)
2028 -> GLenum -> IO CInt
2029
2030 {-# NOINLINE ptr_glutVideoResizeGet #-}
2031 ptr_glutVideoResizeGet :: FunPtr a
2032 ptr_glutVideoResizeGet = unsafePerformIO $ getAPIEntry "glutVideoResizeGet"
2033
2034 -- glutVisibilityFunc ----------------------------------------------------------
2035
2036 glutVisibilityFunc :: MonadIO m => FunPtr VisibilityFunc -> m ()
2037 glutVisibilityFunc v1 = liftIO $ dyn_glutVisibilityFunc ptr_glutVisibilityFunc v1
2038
2039 foreign import CALLCONV "dynamic" dyn_glutVisibilityFunc
2040 :: FunPtr (FunPtr VisibilityFunc -> IO ())
2041 -> FunPtr VisibilityFunc -> IO ()
2042
2043 {-# NOINLINE ptr_glutVisibilityFunc #-}
2044 ptr_glutVisibilityFunc :: FunPtr a
2045 ptr_glutVisibilityFunc = unsafePerformIO $ getAPIEntry "glutVisibilityFunc"
2046
2047 -- glutWMCloseFunc -------------------------------------------------------------
2048
2049 glutWMCloseFunc :: MonadIO m => FunPtr WMCloseFunc -> m ()
2050 glutWMCloseFunc v1 = liftIO $ dyn_glutWMCloseFunc ptr_glutWMCloseFunc v1
2051
2052 foreign import CALLCONV "dynamic" dyn_glutWMCloseFunc
2053 :: FunPtr (FunPtr WMCloseFunc -> IO ())
2054 -> FunPtr WMCloseFunc -> IO ()
2055
2056 {-# NOINLINE ptr_glutWMCloseFunc #-}
2057 ptr_glutWMCloseFunc :: FunPtr a
2058 ptr_glutWMCloseFunc = unsafePerformIO $ getAPIEntry "glutWMCloseFunc"
2059
2060 -- glutWarpPointer -------------------------------------------------------------
2061
2062 glutWarpPointer :: MonadIO m => CInt -> CInt -> m ()
2063 glutWarpPointer v1 v2 = liftIO $ dyn_glutWarpPointer ptr_glutWarpPointer v1 v2
2064
2065 foreign import CALLCONV "dynamic" dyn_glutWarpPointer
2066 :: FunPtr (CInt -> CInt -> IO ())
2067 -> CInt -> CInt -> IO ()
2068
2069 {-# NOINLINE ptr_glutWarpPointer #-}
2070 ptr_glutWarpPointer :: FunPtr a
2071 ptr_glutWarpPointer = unsafePerformIO $ getAPIEntry "glutWarpPointer"
2072
2073 -- glutWindowStatusFunc --------------------------------------------------------
2074
2075 glutWindowStatusFunc :: MonadIO m => FunPtr WindowStatusFunc -> m ()
2076 glutWindowStatusFunc v1 = liftIO $ dyn_glutWindowStatusFunc ptr_glutWindowStatusFunc v1
2077
2078 foreign import CALLCONV "dynamic" dyn_glutWindowStatusFunc
2079 :: FunPtr (FunPtr WindowStatusFunc -> IO ())
2080 -> FunPtr WindowStatusFunc -> IO ()
2081
2082 {-# NOINLINE ptr_glutWindowStatusFunc #-}
2083 ptr_glutWindowStatusFunc :: FunPtr a
2084 ptr_glutWindowStatusFunc = unsafePerformIO $ getAPIEntry "glutWindowStatusFunc"
2085
2086 -- glutWireCone ----------------------------------------------------------------
2087
2088 glutWireCone :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
2089 glutWireCone v1 v2 v3 v4 = liftIO $ dyn_glutWireCone ptr_glutWireCone v1 v2 v3 v4
2090
2091 foreign import CALLCONV "dynamic" dyn_glutWireCone
2092 :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
2093 -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
2094
2095 {-# NOINLINE ptr_glutWireCone #-}
2096 ptr_glutWireCone :: FunPtr a
2097 ptr_glutWireCone = unsafePerformIO $ getAPIEntry "glutWireCone"
2098
2099 -- glutWireCube ----------------------------------------------------------------
2100
2101 glutWireCube :: MonadIO m => GLdouble -> m ()
2102 glutWireCube v1 = liftIO $ dyn_glutWireCube ptr_glutWireCube v1
2103
2104 foreign import CALLCONV "dynamic" dyn_glutWireCube
2105 :: FunPtr (GLdouble -> IO ())
2106 -> GLdouble -> IO ()
2107
2108 {-# NOINLINE ptr_glutWireCube #-}
2109 ptr_glutWireCube :: FunPtr a
2110 ptr_glutWireCube = unsafePerformIO $ getAPIEntry "glutWireCube"
2111
2112 -- glutWireCylinder ------------------------------------------------------------
2113
2114 glutWireCylinder :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
2115 glutWireCylinder v1 v2 v3 v4 = liftIO $ dyn_glutWireCylinder ptr_glutWireCylinder v1 v2 v3 v4
2116
2117 foreign import CALLCONV "dynamic" dyn_glutWireCylinder
2118 :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
2119 -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
2120
2121 {-# NOINLINE ptr_glutWireCylinder #-}
2122 ptr_glutWireCylinder :: FunPtr a
2123 ptr_glutWireCylinder = unsafePerformIO $ getAPIEntry "glutWireCylinder"
2124
2125 -- glutWireDodecahedron --------------------------------------------------------
2126
2127 glutWireDodecahedron :: MonadIO m => m ()
2128 glutWireDodecahedron = liftIO $ dyn_glutWireDodecahedron ptr_glutWireDodecahedron
2129
2130 foreign import CALLCONV "dynamic" dyn_glutWireDodecahedron
2131 :: FunPtr (IO ())
2132 -> IO ()
2133
2134 {-# NOINLINE ptr_glutWireDodecahedron #-}
2135 ptr_glutWireDodecahedron :: FunPtr a
2136 ptr_glutWireDodecahedron = unsafePerformIO $ getAPIEntry "glutWireDodecahedron"
2137
2138 -- glutWireIcosahedron ---------------------------------------------------------
2139
2140 glutWireIcosahedron :: MonadIO m => m ()
2141 glutWireIcosahedron = liftIO $ dyn_glutWireIcosahedron ptr_glutWireIcosahedron
2142
2143 foreign import CALLCONV "dynamic" dyn_glutWireIcosahedron
2144 :: FunPtr (IO ())
2145 -> IO ()
2146
2147 {-# NOINLINE ptr_glutWireIcosahedron #-}
2148 ptr_glutWireIcosahedron :: FunPtr a
2149 ptr_glutWireIcosahedron = unsafePerformIO $ getAPIEntry "glutWireIcosahedron"
2150
2151 -- glutWireOctahedron ----------------------------------------------------------
2152
2153 glutWireOctahedron :: MonadIO m => m ()
2154 glutWireOctahedron = liftIO $ dyn_glutWireOctahedron ptr_glutWireOctahedron
2155
2156 foreign import CALLCONV "dynamic" dyn_glutWireOctahedron
2157 :: FunPtr (IO ())
2158 -> IO ()
2159
2160 {-# NOINLINE ptr_glutWireOctahedron #-}
2161 ptr_glutWireOctahedron :: FunPtr a
2162 ptr_glutWireOctahedron = unsafePerformIO $ getAPIEntry "glutWireOctahedron"
2163
2164 -- glutWireRhombicDodecahedron -------------------------------------------------
2165
2166 glutWireRhombicDodecahedron :: MonadIO m => m ()
2167 glutWireRhombicDodecahedron = liftIO $ dyn_glutWireRhombicDodecahedron ptr_glutWireRhombicDodecahedron
2168
2169 foreign import CALLCONV "dynamic" dyn_glutWireRhombicDodecahedron
2170 :: FunPtr (IO ())
2171 -> IO ()
2172
2173 {-# NOINLINE ptr_glutWireRhombicDodecahedron #-}
2174 ptr_glutWireRhombicDodecahedron :: FunPtr a
2175 ptr_glutWireRhombicDodecahedron = unsafePerformIO $ getAPIEntry "glutWireRhombicDodecahedron"
2176
2177 -- glutWireSierpinskiSponge ----------------------------------------------------
2178
2179 glutWireSierpinskiSponge :: MonadIO m => CInt -> Ptr GLdouble -> GLdouble -> m ()
2180 glutWireSierpinskiSponge v1 v2 v3 = liftIO $ dyn_glutWireSierpinskiSponge ptr_glutWireSierpinskiSponge v1 v2 v3
2181
2182 foreign import CALLCONV "dynamic" dyn_glutWireSierpinskiSponge
2183 :: FunPtr (CInt -> Ptr GLdouble -> GLdouble -> IO ())
2184 -> CInt -> Ptr GLdouble -> GLdouble -> IO ()
2185
2186 {-# NOINLINE ptr_glutWireSierpinskiSponge #-}
2187 ptr_glutWireSierpinskiSponge :: FunPtr a
2188 ptr_glutWireSierpinskiSponge = unsafePerformIO $ getAPIEntry "glutWireSierpinskiSponge"
2189
2190 -- glutWireSphere --------------------------------------------------------------
2191
2192 glutWireSphere :: MonadIO m => GLdouble -> GLint -> GLint -> m ()
2193 glutWireSphere v1 v2 v3 = liftIO $ dyn_glutWireSphere ptr_glutWireSphere v1 v2 v3
2194
2195 foreign import CALLCONV "dynamic" dyn_glutWireSphere
2196 :: FunPtr (GLdouble -> GLint -> GLint -> IO ())
2197 -> GLdouble -> GLint -> GLint -> IO ()
2198
2199 {-# NOINLINE ptr_glutWireSphere #-}
2200 ptr_glutWireSphere :: FunPtr a
2201 ptr_glutWireSphere = unsafePerformIO $ getAPIEntry "glutWireSphere"
2202
2203 -- glutWireTeacup --------------------------------------------------------------
2204
2205 glutWireTeacup :: MonadIO m => GLdouble -> m ()
2206 glutWireTeacup v1 = liftIO $ dyn_glutWireTeacup ptr_glutWireTeacup v1
2207
2208 foreign import CALLCONV "dynamic" dyn_glutWireTeacup
2209 :: FunPtr (GLdouble -> IO ())
2210 -> GLdouble -> IO ()
2211
2212 {-# NOINLINE ptr_glutWireTeacup #-}
2213 ptr_glutWireTeacup :: FunPtr a
2214 ptr_glutWireTeacup = unsafePerformIO $ getAPIEntry "glutWireTeacup"
2215
2216 -- glutWireTeapot --------------------------------------------------------------
2217
2218 glutWireTeapot :: MonadIO m => GLdouble -> m ()
2219 glutWireTeapot v1 = liftIO $ dyn_glutWireTeapot ptr_glutWireTeapot v1
2220
2221 foreign import CALLCONV "dynamic" dyn_glutWireTeapot
2222 :: FunPtr (GLdouble -> IO ())
2223 -> GLdouble -> IO ()
2224
2225 {-# NOINLINE ptr_glutWireTeapot #-}
2226 ptr_glutWireTeapot :: FunPtr a
2227 ptr_glutWireTeapot = unsafePerformIO $ getAPIEntry "glutWireTeapot"
2228
2229 -- glutWireTeaspoon ------------------------------------------------------------
2230
2231 glutWireTeaspoon :: MonadIO m => GLdouble -> m ()
2232 glutWireTeaspoon v1 = liftIO $ dyn_glutWireTeaspoon ptr_glutWireTeaspoon v1
2233
2234 foreign import CALLCONV "dynamic" dyn_glutWireTeaspoon
2235 :: FunPtr (GLdouble -> IO ())
2236 -> GLdouble -> IO ()
2237
2238 {-# NOINLINE ptr_glutWireTeaspoon #-}
2239 ptr_glutWireTeaspoon :: FunPtr a
2240 ptr_glutWireTeaspoon = unsafePerformIO $ getAPIEntry "glutWireTeaspoon"
2241
2242 -- glutWireTetrahedron ---------------------------------------------------------
2243
2244 glutWireTetrahedron :: MonadIO m => m ()
2245 glutWireTetrahedron = liftIO $ dyn_glutWireTetrahedron ptr_glutWireTetrahedron
2246
2247 foreign import CALLCONV "dynamic" dyn_glutWireTetrahedron
2248 :: FunPtr (IO ())
2249 -> IO ()
2250
2251 {-# NOINLINE ptr_glutWireTetrahedron #-}
2252 ptr_glutWireTetrahedron :: FunPtr a
2253 ptr_glutWireTetrahedron = unsafePerformIO $ getAPIEntry "glutWireTetrahedron"
2254
2255 -- glutWireTorus ---------------------------------------------------------------
2256
2257 glutWireTorus :: MonadIO m => GLdouble -> GLdouble -> GLint -> GLint -> m ()
2258 glutWireTorus v1 v2 v3 v4 = liftIO $ dyn_glutWireTorus ptr_glutWireTorus v1 v2 v3 v4
2259
2260 foreign import CALLCONV "dynamic" dyn_glutWireTorus
2261 :: FunPtr (GLdouble -> GLdouble -> GLint -> GLint -> IO ())
2262 -> GLdouble -> GLdouble -> GLint -> GLint -> IO ()
2263
2264 {-# NOINLINE ptr_glutWireTorus #-}
2265 ptr_glutWireTorus :: FunPtr a
2266 ptr_glutWireTorus = unsafePerformIO $ getAPIEntry "glutWireTorus"
2267