Graphics.GPipe.Context.GLFW

Non interactive applications only need to pass configuration defined here into GPipe's runContextT and newWindow.

Interactive applications will need Graphics.GPipe.Context.GLFW.Input.

GPipe context handler for GLFW

data Handle

Opaque handle representing the initialized GLFW library.

To get started quickly try defaultHandleConfig and defaultWindowConfig.

     import Graphics.GPipe
     import qualified Graphics.GPipe.Context.GLFW as GLFW

     runContextT GLFW.defaultHandleConfig $ do
         win <- newWindow (WindowFormatColorDepth RGB8 Depth16) (GLFW.defaultWindowConfig "OpenGL Graphics")
         -- Do GPipe things here

Instances

ContextHandler Handle

Associated Types

data ContextHandlerParameters Handle :: *

type ContextWindow Handle :: *

type WindowParameters Handle :: *

Methods

contextHandlerCreate :: ContextHandlerParameters Handle -> IO Handle

contextHandlerDelete :: Handle -> IO ()

createContext :: Handle -> Maybe (WindowBits, WindowParameters Handle) -> IO (ContextWindow Handle)

contextDoAsync :: Handle -> Maybe (ContextWindow Handle) -> IO () -> IO ()

contextSwap :: Handle -> ContextWindow Handle -> IO ()

contextFrameBufferSize :: Handle -> ContextWindow Handle -> IO (Int, Int)

contextDelete :: Handle -> ContextWindow Handle -> IO ()

type WindowParameters Handle

type WindowParameters Handle = WindowConfig

type ContextWindow Handle

type ContextWindow Handle = GLFWWindow

data ContextHandlerParameters Handle

data ContextHandlerParameters Handle = HandleConfig {

• configErrorCallback :: Error -> String -> IO ()
• configEventPolicy :: Maybe EventPolicy

}

data GLFWWindow

Opaque handle representing a, possibly closed, internal Context. You'll typically deal with GPipe's Window instead of this one.

Configuration

Default configs

defaultHandleConfig :: ContextHandlerParameters Handle

Default GLFW handle configuration.

• Print any errors that GLFW emits.
• Automatically process GLFW events after every buffer swap.

defaultWindowConfig :: String -> WindowConfig

Default window configuration for a small window on any monitor with the given title.

Custom configs

data family ContextHandlerParameters ctx :: *

Implementation specific context handler parameters, eg error handling and event processing policies

Instances

data ContextHandlerParameters Handle

data ContextHandlerParameters Handle = HandleConfig {

• configErrorCallback :: Error -> String -> IO ()
• configEventPolicy :: Maybe EventPolicy

}

Configuration for the GLFW handle.

HandleConfig

Constructor

configErrorCallback :: Error -> String -> IO ()

Specify a callback to handle errors emitted by GLFW.

configEventPolicy :: Maybe EventPolicy

Specify the EventPolicy to use for automatic GLFW event processing. If Nothing then automatic event processing is disabled and you'll need to call mainloop or mainstep somewhere.

data WindowConfig

Configuration for a new GLFW window and associated OpenGL context.

Constructors

WindowConfig

Fields

• configWidth :: Int
• configHeight :: Int
• configTitle :: String
• configMonitor :: Maybe Monitor
• configHints :: [WindowHint]
• configSwapInterval :: Maybe Int

Instances

Show WindowConfig

Methods

showsPrec :: Int -> WindowConfig -> ShowS

show :: WindowConfig -> String

showList :: [WindowConfig] -> ShowS

data EventPolicy

Type to describe the waiting or polling style of event processing supported by GLFW.

• Recommended reading: Event Processing section of the GLFW Input Guide at http://www.glfw.org/docs/latest/input_guide.html#events.

Constructors

Poll

Wait

Instances

Show EventPolicy

Methods

showsPrec :: Int -> EventPolicy -> ShowS

show :: EventPolicy -> String

showList :: [EventPolicy] -> ShowS

Exceptions

data InitException

IO exception thrown when GLFW library initialization fails.

Constructors

InitException

Instances

Show InitException

Methods

showsPrec :: Int -> InitException -> ShowS

show :: InitException -> String

showList :: [InitException] -> ShowS

Exception InitException

Methods

toException :: InitException -> SomeException

fromException :: SomeException -> Maybe InitException

displayException :: InitException -> String

data CreateWindowException

IO Exception thrown when GLFW window creation fails.

Constructors

CreateWindowException String

CreateSharedWindowException String

Instances

Show CreateWindowException

Methods

showsPrec :: Int -> CreateWindowException -> ShowS

show :: CreateWindowException -> String

showList :: [CreateWindowException] -> ShowS

Exception CreateWindowException

Methods

toException :: CreateWindowException -> SomeException

fromException :: SomeException -> Maybe CreateWindowException

displayException :: CreateWindowException -> String

data UnsafeWindowHintsException

IO Exception thrown when attempting to create a new window using GLFW hints which GPipe manages.

Constructors

UnsafeWindowHintsException [WindowHint]

Instances

Show UnsafeWindowHintsException

Methods

showsPrec :: Int -> UnsafeWindowHintsException -> ShowS

show :: UnsafeWindowHintsException -> String

showList :: [UnsafeWindowHintsException] -> ShowS

Exception UnsafeWindowHintsException

Methods

toException :: UnsafeWindowHintsException -> SomeException

fromException :: SomeException -> Maybe UnsafeWindowHintsException

displayException :: UnsafeWindowHintsException -> String

Mainthread hooks

mainloop

Arguments

:: MonadIO m

=> Window os c ds

-> EventPolicy

A Poll loop runs continuously while a Wait loop sleeps until events or user input occur.

-> ContextT Handle os m (Maybe ())

Process GLFW and GPipe events according to the given EventPolicy in a loop.

Use case: Call mainloop in multithreaded applications which do GPipe rendering off of the main thread, but which do not otherwise need additional control over the main thread. For less complex applications use automatic event processing configured via HandleConfig.

• Must be called on the main thread.
• The loop will run until windowShouldClose is true for the all Windows created by the same ContextHandler, or all the Windows have been deleted.
• To indicate a window should close use setWindowShouldClose in Graphics.GPipe.Context.GLFW.Wrapped.

mainstep

Arguments

:: MonadIO m

=> Window os c ds

-> EventPolicy

Poll will process events and return immediately while Wait will sleep until events are received.

-> ContextT Handle os m (Maybe ())

Process GLFW and GPipe events according to the given EventPolicy.

Use case: Call mainstep as part of a custom engine loop in multithreaded applications which do GPipe rendering off of the main thread. Use mainloop for less complex applications.

• Must be called on the main thread.
• Can be called with any window you've created and not yet deleted.
• If GPipe can't find the window you passed in, returns Nothing.

Reexports

module Graphics.GPipe.Context.GLFW.Input

module Graphics.GPipe.Context.GLFW.Window

module Graphics.GPipe.Context.GLFW.Misc