Graphics.UI.GLWindow

A simple OpenGL window creator that runs on X.Org with libX11. This module allows the creation of different versions of OpenGL contexts by initializing with the required versions.

Note: The Haskell only has bindings up to OpenGL 3.2 This module is intended to be imported qualified, to avoid clashes with Prelude functions, e.g.

 import qualified Graphics.UI.GLWindow as Window                            

As an example, here is a simple module that uses some of these functions to open a OpenGL 3.2 Context:

 module Main where                                                          
                                                                            
 import Graphics.Rendering.OpenGL                                           
 import qualified Graphics.UI.GLWindow as Window                            
                                                                            
 myLoop = do clear [ColorBuffer]                                            
             t <- Window.time                                               
             clearColor $= Color4 (sin (realToFrac t) * 0.5 + 0.5)          
                                  (sin (realToFrac (t+1)) * 0.5 + 0.5)      
                                  (sin (realToFrac (t+2)) * 0.5 +0.5)       
                                  0                                              
                                                                            
 main = do Window.init 3 2 -- initializes a OpenGL 3.2 context              
           Window.loop myLoop -- stops when the ESC key is pressed          
           Window.kill -- removes the window when the loop stops            

Types

type LoopFunc = IO ()

Window initialization

init :: Integer -> Integer -> IO Integer

setFullscreen :: Bool -> IO ()

Window elimination

kill :: IO ()

Window state query

frame :: IO Integer

time :: IO Double

dtime :: IO Double

width :: IO Integer

height :: IO Integer

scrWidth :: IO Integer

scrHeight :: IO Integer

Loop

loop :: LoopFunc -> IO ()