FRP.Rhine.Gloss.IO

Wrapper to write gloss applications in Rhine, using concurrency.

Documentation

data GlossEnv

Concurrent variables needed to communicate with the gloss backend.

Constructors

GlossEnv

Fields

• timeVar :: MVar Float
• eventVar :: MVar Event
• picRef :: IORef Picture
• timeRef :: IORef Float

newtype GlossConcT m a

Effects in the gloss backend

• Wraps the concurrent variables needed for communication with the gloss backend.
• Adds the FreeAsyncT concurrency layer for fairer scheduling

Constructors

GlossConcT

Fields

• unGlossConcT :: ReaderT GlossEnv (FreeAsyncT m) a

Instances

MonadTrans GlossConcT

Defined in FRP.Rhine.Gloss.IO

Methods

lift :: Monad m => m a -> GlossConcT m a

MonadIO m => MonadIO (GlossConcT m)

Defined in FRP.Rhine.Gloss.IO

Methods

liftIO :: IO a -> GlossConcT m a

Monad m => Applicative (GlossConcT m)

Defined in FRP.Rhine.Gloss.IO

Methods

pure :: a -> GlossConcT m a

(<*>) :: GlossConcT m (a -> b) -> GlossConcT m a -> GlossConcT m b

liftA2 :: (a -> b -> c) -> GlossConcT m a -> GlossConcT m b -> GlossConcT m c

(*>) :: GlossConcT m a -> GlossConcT m b -> GlossConcT m b

(<*) :: GlossConcT m a -> GlossConcT m b -> GlossConcT m a

Monad m => Functor (GlossConcT m)

Defined in FRP.Rhine.Gloss.IO

Methods

fmap :: (a -> b) -> GlossConcT m a -> GlossConcT m b

(<$) :: a -> GlossConcT m b -> GlossConcT m a

Monad m => Monad (GlossConcT m)

Defined in FRP.Rhine.Gloss.IO

Methods

(>>=) :: GlossConcT m a -> (a -> GlossConcT m b) -> GlossConcT m b

(>>) :: GlossConcT m a -> GlossConcT m b -> GlossConcT m b

return :: a -> GlossConcT m a

MonadIO m => MonadSchedule (GlossConcT m)

Disregards scheduling capabilities of m, as it uses FreeAsync.

Defined in FRP.Rhine.Gloss.IO

Methods

schedule :: NonEmpty (GlossConcT m a) -> GlossConcT m (NonEmpty a, [GlossConcT m a])

MonadIO m => Clock (GlossConcT m) GlossEventClockIO

Defined in FRP.Rhine.Gloss.IO

Associated Types

type Time GlossEventClockIO

type Tag GlossEventClockIO

Methods

initClock :: GlossEventClockIO -> RunningClockInit (GlossConcT m) (Time GlossEventClockIO) (Tag GlossEventClockIO)

MonadIO m => Clock (GlossConcT m) GlossSimClockIO

Defined in FRP.Rhine.Gloss.IO

Associated Types

type Time GlossSimClockIO

type Tag GlossSimClockIO

Methods

initClock :: GlossSimClockIO -> RunningClockInit (GlossConcT m) (Time GlossSimClockIO) (Tag GlossSimClockIO)

type GlossConc = GlossConcT IO

When gloss is the only effect you are using, use this monad to simplify your type signatures.

runGlossConcT :: MonadIO m => GlossConcT m a -> GlossEnv -> m a

Remove the GlossConcT transformer by explicitly providing an environment.

paintIO :: MonadIO m => Picture -> GlossConcT m ()

Add a picture to the canvas.

clearIO :: MonadIO m => GlossConcT m ()

Clear the canvas.

paintAllIO :: MonadIO m => Picture -> GlossConcT m ()

Clear the canvas and then paint.

data GlossEventClockIO

Concurrently block on gloss events.

Caution: Currently, you should only add one such clock in a Rhine. If you add several GlossEventClockIO, only one will be chosen at random and receive the event. See https://github.com/turion/rhine/issues/330.

Constructors

GlossEventClockIO

Instances

GetClockProxy GlossEventClockIO

Defined in FRP.Rhine.Gloss.IO

Methods

getClockProxy :: ClockProxy GlossEventClockIO

MonadIO m => Clock (GlossConcT m) GlossEventClockIO

Defined in FRP.Rhine.Gloss.IO

Associated Types

type Time GlossEventClockIO

type Tag GlossEventClockIO

Methods

initClock :: GlossEventClockIO -> RunningClockInit (GlossConcT m) (Time GlossEventClockIO) (Tag GlossEventClockIO)

type Tag GlossEventClockIO

Defined in FRP.Rhine.Gloss.IO

type Tag GlossEventClockIO = Event

type Time GlossEventClockIO

Defined in FRP.Rhine.Gloss.IO

type Time GlossEventClockIO = Float

data GlossSimClockIO

Concurrently block on gloss simulation ticks.

Caution: Currently, you should only add one such clock in a Rhine. If you add several GlossSimClockIO, only one will be chosen at random and receive the event. See https://github.com/turion/rhine/issues/330.

Constructors

GlossSimClockIO

Instances

GetClockProxy GlossSimClockIO

Defined in FRP.Rhine.Gloss.IO

Methods

getClockProxy :: ClockProxy GlossSimClockIO

MonadIO m => Clock (GlossConcT m) GlossSimClockIO

Defined in FRP.Rhine.Gloss.IO

Associated Types

type Time GlossSimClockIO

type Tag GlossSimClockIO

Methods

initClock :: GlossSimClockIO -> RunningClockInit (GlossConcT m) (Time GlossSimClockIO) (Tag GlossSimClockIO)

type Tag GlossSimClockIO

Defined in FRP.Rhine.Gloss.IO

type Tag GlossSimClockIO = ()

type Time GlossSimClockIO

Defined in FRP.Rhine.Gloss.IO

type Time GlossSimClockIO = Float

makeGlossEnv :: MonadIO m => m GlossEnv

Create the concurrent variables to communicate with the gloss backend.

You will usually not need this function, have a look at launchInGlossThread and flowGlossIO instead.

launchInGlossThread :: MonadIO m => GlossSettings -> GlossConcT m a -> m a

Apply this to supply the GlossConcT effect. Creates a new thread in which gloss is run, and feeds the clocks GlossEventClockIO and GlossSimClockIO.

Usually, this function is applied to the result of flow, so you can handle all occurring effects as needed. If you only use gloss in your whole signal network, you can use flowGlossIO instead.

launchGlossThread :: MonadIO m => GlossSettings -> m GlossEnv

Helper function for launchInGlossThread.

Creates concurrent variables and launches the gloss backend in a separate thread.

flowGlossIO :: (MonadIO m, Clock (GlossConcT m) cl, GetClockProxy cl, Time cl ~ Time (In cl), Time cl ~ Time (Out cl)) => GlossSettings -> Rhine (GlossConcT m) cl () () -> m ()

Run a Rhine in the GlossConcT monad by launching a separate thread for the gloss backend, and reactimate in the foreground.

runGlossEnvClock :: MonadIO m => GlossEnv -> cl -> RunGlossEnvClock m cl

Apply to a gloss clock to remove a GlossConcT layer. You will have to have initialized a GlossEnv, for example by calling launchGlossThread.

type RunGlossEnvClock m cl = HoistClock (GlossConcT m) m cl

Apply this wrapper to your clock type cl in order to escape the GlossConcT transformer. The resulting clock will be in m, not 'GlossConcT m' anymore. Typically, m will have the MonadIO constraint.

type GlossClockUTC m cl = UTCClock (GlossConcT m) cl

Rescale a gloss clock like GlossSimClockIO or GlossEventClockIO to UTCTime.

This is needed for compatibility with other realtime clocks like Millisecond.

glossClockUTC :: (MonadIO m, Real (Time cl)) => cl -> GlossClockUTC m cl

Rescale a gloss clock like GlossSimClockIO or GlossEventClockIO to UTCTime.

Uses addUTC. For other strategies to rescale a gloss clock to UTCTime, see FRP.Rhine.Clock.Realtime.

type GlossConcTClock m = HoistClock IO (GlossConcT m)

Lift a MonadIO clock to GlossConcT.

You should use this instead of IOClock, otherwise scheduling will probably not work. (This is because GlossConcT uses FreeAsyncT, but liftIO is not asynchronous.)

glossConcTClock :: MonadIO m => cl -> GlossConcTClock m cl

A MonadIO clock lifted to GlossConcT.

type GlossConcClock = GlossConcTClock IO

Lift an IO clock to GlossConc.

See GlossConcTClock.

glossConcClock :: cl -> GlossConcClock cl

An IO clock lifted to GlossConc.