Imj.Graphics.Render

Draw and Render

Draw describes the ability to draw colored Chars, Strings, Texts.

Render makes the result of draw*** calls visible on the screen.

Optimized instances of Draw and Render, for games and animations drawing in the terminal, are available in Imj.Graphics.Render.Delta.Env. They minimize stdout usage using double buffering and delta rendering, thereby mitigating the screen tearing effect.

class Draw e where

Minimal complete definition

drawChar', drawChars', drawTxt', drawStr'

Methods

drawChar' :: MonadIO m => e -> Char -> Coords Pos -> LayeredColor -> m ()

Draw a Char.

drawChars' :: MonadIO m => e -> Int -> Char -> Coords Pos -> LayeredColor -> m ()

Draw repeated chars.

drawTxt' :: MonadIO m => e -> Text -> Coords Pos -> LayeredColor -> m ()

Draw Text.

drawStr' :: MonadIO m => e -> String -> Coords Pos -> LayeredColor -> m ()

Draw String.

drawColorStr' :: MonadIO m => e -> ColorString -> Coords Pos -> m ()

Draw a ColorString.

drawAlignedTxt_' :: MonadIO m => e -> Text -> LayeredColor -> Alignment -> m ()

Draw text aligned w.r.t alignment and reference coordinates.

drawAlignedTxt' :: MonadIO m => e -> Text -> LayeredColor -> Alignment -> m Alignment

Draws text aligned w.r.t alignment and reference coordinates.

Returns an Alignment where the reference coordinate of the input Alignment was projected on the next line.

drawAlignedColorStr' :: MonadIO m => e -> Alignment -> ColorString -> m Alignment

Draw a ColorString with an Alignment constraint.

Instances

Draw NaiveDraw

Direct draw to stdout : don't use for production, this is for tests only and creates heavy screen tearing.

Methods

drawChar' :: MonadIO m => NaiveDraw -> Char -> Coords Pos -> LayeredColor -> m ()

drawChars' :: MonadIO m => NaiveDraw -> Int -> Char -> Coords Pos -> LayeredColor -> m ()

drawTxt' :: MonadIO m => NaiveDraw -> Text -> Coords Pos -> LayeredColor -> m ()

drawStr' :: MonadIO m => NaiveDraw -> String -> Coords Pos -> LayeredColor -> m ()

drawColorStr' :: MonadIO m => NaiveDraw -> ColorString -> Coords Pos -> m ()

drawAlignedTxt_' :: MonadIO m => NaiveDraw -> Text -> LayeredColor -> Alignment -> m ()

drawAlignedTxt' :: MonadIO m => NaiveDraw -> Text -> LayeredColor -> Alignment -> m Alignment

drawAlignedColorStr' :: MonadIO m => NaiveDraw -> Alignment -> ColorString -> m Alignment

Draw DeltaEnv

Draws using the delta rendering engine.

Methods

drawChar' :: MonadIO m => DeltaEnv -> Char -> Coords Pos -> LayeredColor -> m ()

drawChars' :: MonadIO m => DeltaEnv -> Int -> Char -> Coords Pos -> LayeredColor -> m ()

drawTxt' :: MonadIO m => DeltaEnv -> Text -> Coords Pos -> LayeredColor -> m ()

drawStr' :: MonadIO m => DeltaEnv -> String -> Coords Pos -> LayeredColor -> m ()

drawColorStr' :: MonadIO m => DeltaEnv -> ColorString -> Coords Pos -> m ()

drawAlignedTxt_' :: MonadIO m => DeltaEnv -> Text -> LayeredColor -> Alignment -> m ()

drawAlignedTxt' :: MonadIO m => DeltaEnv -> Text -> LayeredColor -> Alignment -> m Alignment

drawAlignedColorStr' :: MonadIO m => DeltaEnv -> Alignment -> ColorString -> m Alignment

class Draw e => Render e where

Class describing the ability to render the result of a Draw to the screen.

It is left to the implementation to decide wether to clear the screen or not (after a renderToScreen for example), and with which color.

Minimal complete definition

renderToScreen'

Methods

renderToScreen' :: MonadIO m => e -> m ()

Render to the screen.

Instances

Render NaiveDraw

Direct draw to stdout : don't use for production, this is for tests only and creates heavy screen tearing.

Methods

renderToScreen' :: MonadIO m => NaiveDraw -> m ()

Render DeltaEnv

Renders using the delta rendering engine.

Methods

renderToScreen' :: MonadIO m => DeltaEnv -> m ()

From MonadReader

The functions below use Draw and Render instances in a MonadReader monad.

Hence, if you run in a MonadReader YourEnv monad (where YourEnv is your environment equiped with Draw and Render instances), you can write:

import Control.Monad.IO.Class(MonadIO)
import Control.Monad.Reader.Class(MonadReader)
import Control.Monad.Reader(runReaderT)

import Imj.Graphics.Class.Render
import Imj.Graphics.Render.FromMonadReader(drawStr, renderToScreen)

helloWorld :: (Draw e, Render e, MonadReader e m, MonadIO m) => m ()
helloWorld = drawStr "Hello World" (Coords 10 10) green >> renderToScreen

main = createEnv >>= runReaderT helloWorld

This example follows this pattern.

Draw char(s)

drawChar :: (Draw e, MonadReader e m, MonadIO m) => Char -> Coords Pos -> LayeredColor -> m ()

drawChars :: (Draw e, MonadReader e m, MonadIO m) => Int -> Char -> Coords Pos -> LayeredColor -> m ()

Draws a Char multiple times, starting at the given coordinates and then moving to the right.

Draw text

drawTxt :: (Draw e, MonadReader e m, MonadIO m) => Text -> Coords Pos -> LayeredColor -> m ()

drawStr :: (Draw e, MonadReader e m, MonadIO m) => String -> Coords Pos -> LayeredColor -> m ()

drawColorStr :: (Draw e, MonadReader e m, MonadIO m) => ColorString -> Coords Pos -> m ()

Draw a ColorString.

Draw aligned text

drawAlignedTxt_ :: (Draw e, MonadReader e m, MonadIO m) => Text -> LayeredColor -> Alignment -> m ()

Draws text with Alignment.

drawAlignedTxt :: (Draw e, MonadReader e m, MonadIO m) => Text -> LayeredColor -> Alignment -> m Alignment

Draws text with Alignment.

Returns the Alignment projected on the next line.

drawAlignedColorStr :: (Draw e, MonadReader e m, MonadIO m) => Alignment -> ColorString -> m Alignment

Draw a ColorString with an Alignment constraint.

Render to the physical device

renderToScreen :: (Render e, MonadReader e m, MonadIO m) => m ()

Render the drawing to {the screen, the console, etc...}.

Reexports

data LayeredColor

A background and a foreground Color8.

Constructors

LayeredColor

Fields

• _colorsBackground :: !(Color8 Background)
• _colorsForeground :: !(Color8 Foreground)

Instances

Eq LayeredColor

Methods

(==) :: LayeredColor -> LayeredColor -> Bool

(/=) :: LayeredColor -> LayeredColor -> Bool

Show LayeredColor

Methods

showsPrec :: Int -> LayeredColor -> ShowS

show :: LayeredColor -> String

showList :: [LayeredColor] -> ShowS

DiscreteDistance LayeredColor

First interpolate background color, then foreground color

Methods

distance :: LayeredColor -> LayeredColor -> Int

distanceSuccessive :: Successive LayeredColor -> Int

DiscreteInterpolation LayeredColor

First interpolate background color, then foreground color

Methods

interpolate :: LayeredColor -> LayeredColor -> Int -> LayeredColor

interpolateSuccessive :: Successive LayeredColor -> Int -> LayeredColor

data Coords a

Two-dimensional discrete coordinates. We use phantom types Pos, Vel to distinguish positions from speeds.

Constructors

Coords

Fields

• _coordsY :: !(Coord Row)
• _coordsX :: !(Coord Col)

Instances

Eq (Coords a)

Methods

(==) :: Coords a -> Coords a -> Bool

(/=) :: Coords a -> Coords a -> Bool

Ord (Coords a)

Methods

compare :: Coords a -> Coords a -> Ordering

(<) :: Coords a -> Coords a -> Bool

(<=) :: Coords a -> Coords a -> Bool

(>) :: Coords a -> Coords a -> Bool

(>=) :: Coords a -> Coords a -> Bool

max :: Coords a -> Coords a -> Coords a

min :: Coords a -> Coords a -> Coords a

Show (Coords a)

Methods

showsPrec :: Int -> Coords a -> ShowS

show :: Coords a -> String

showList :: [Coords a] -> ShowS

DiscreteDistance (Coords Pos)

 Using bresenham 2d line algorithm.

Methods

distance :: Coords Pos -> Coords Pos -> Int

distanceSuccessive :: Successive (Coords Pos) -> Int

DiscreteInterpolation (Coords Pos)

 Using bresenham 2d line algorithm.

Methods

interpolate :: Coords Pos -> Coords Pos -> Int -> Coords Pos

interpolateSuccessive :: Successive (Coords Pos) -> Int -> Coords Pos

data Alignment

Constructors

Alignment

Fields

• _alignmentKing :: !AlignmentKind

  The kind of alignment.

• _alignmentRef :: !(Coords Pos)

  The reference coordinates.

data Text :: *

A space efficient, packed, unboxed Unicode text type.

Instances

type Item Text

type Item Text = Char

data Char :: *

The character type Char is an enumeration whose values represent Unicode (or equivalently ISO/IEC 10646) characters (see http://www.unicode.org/ for details). This set extends the ISO 8859-1 (Latin-1) character set (the first 256 characters), which is itself an extension of the ASCII character set (the first 128 characters). A character literal in Haskell has type Char.

To convert a Char to or from the corresponding Int value defined by Unicode, use toEnum and fromEnum from the Enum class respectively (or equivalently ord and chr).

Instances

Bounded Char

Since: 2.1

Methods

minBound :: Char

maxBound :: Char

Enum Char

Since: 2.1

Methods

succ :: Char -> Char

pred :: Char -> Char

toEnum :: Int -> Char

fromEnum :: Char -> Int

enumFrom :: Char -> [Char]

enumFromThen :: Char -> Char -> [Char]

enumFromTo :: Char -> Char -> [Char]

enumFromThenTo :: Char -> Char -> Char -> [Char]

Eq Char

Methods

(==) :: Char -> Char -> Bool

(/=) :: Char -> Char -> Bool

Data Char

Since: 4.0.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Char -> c Char

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Char

toConstr :: Char -> Constr

dataTypeOf :: Char -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Char)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Char)

gmapT :: (forall b. Data b => b -> b) -> Char -> Char

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Char -> r

gmapQ :: (forall d. Data d => d -> u) -> Char -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Char -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Char -> m Char

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Char -> m Char

Ord Char

Methods

compare :: Char -> Char -> Ordering

(<) :: Char -> Char -> Bool

(<=) :: Char -> Char -> Bool

(>) :: Char -> Char -> Bool

(>=) :: Char -> Char -> Bool

max :: Char -> Char -> Char

min :: Char -> Char -> Char

Read Char

Since: 2.1

Methods

readsPrec :: Int -> ReadS Char

readList :: ReadS [Char]

readPrec :: ReadPrec Char

readListPrec :: ReadPrec [Char]

Show Char

Since: 2.1

Methods

showsPrec :: Int -> Char -> ShowS

show :: Char -> String

showList :: [Char] -> ShowS

Prim Char

Methods

sizeOf# :: Char -> Int#

alignment# :: Char -> Int#

indexByteArray# :: ByteArray# -> Int# -> Char

readByteArray# :: MutableByteArray# s -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Char#)

writeByteArray# :: MutableByteArray# s -> Int# -> Char -> State# s -> State# s

setByteArray# :: MutableByteArray# s -> Int# -> Int# -> Char -> State# s -> State# s

indexOffAddr# :: Addr# -> Int# -> Char

readOffAddr# :: Addr# -> Int# -> State# s -> (#TupleRep [RuntimeRep], LiftedRep, State# s, Char#)

writeOffAddr# :: Addr# -> Int# -> Char -> State# s -> State# s

setOffAddr# :: Addr# -> Int# -> Int# -> Char -> State# s -> State# s

Random Char

Methods

randomR :: RandomGen g => (Char, Char) -> g -> (Char, g)

random :: RandomGen g => g -> (Char, g)

randomRs :: RandomGen g => (Char, Char) -> g -> [Char]

randoms :: RandomGen g => g -> [Char]

randomRIO :: (Char, Char) -> IO Char

randomIO :: IO Char

ErrorList Char

Methods

listMsg :: String -> [Char]

Unbox Char

Vector Vector Char

Methods

basicUnsafeFreeze :: PrimMonad m => Mutable Vector (PrimState m) Char -> m (Vector Char)

basicUnsafeThaw :: PrimMonad m => Vector Char -> m (Mutable Vector (PrimState m) Char)

basicLength :: Vector Char -> Int

basicUnsafeSlice :: Int -> Int -> Vector Char -> Vector Char

basicUnsafeIndexM :: Monad m => Vector Char -> Int -> m Char

basicUnsafeCopy :: PrimMonad m => Mutable Vector (PrimState m) Char -> Vector Char -> m ()

elemseq :: Vector Char -> Char -> b -> b

MVector MVector Char

Methods

basicLength :: MVector s Char -> Int

basicUnsafeSlice :: Int -> Int -> MVector s Char -> MVector s Char

basicOverlaps :: MVector s Char -> MVector s Char -> Bool

basicUnsafeNew :: PrimMonad m => Int -> m (MVector (PrimState m) Char)

basicInitialize :: PrimMonad m => MVector (PrimState m) Char -> m ()

basicUnsafeReplicate :: PrimMonad m => Int -> Char -> m (MVector (PrimState m) Char)

basicUnsafeRead :: PrimMonad m => MVector (PrimState m) Char -> Int -> m Char

basicUnsafeWrite :: PrimMonad m => MVector (PrimState m) Char -> Int -> Char -> m ()

basicClear :: PrimMonad m => MVector (PrimState m) Char -> m ()

basicSet :: PrimMonad m => MVector (PrimState m) Char -> Char -> m ()

basicUnsafeCopy :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m ()

basicUnsafeMove :: PrimMonad m => MVector (PrimState m) Char -> MVector (PrimState m) Char -> m ()

basicUnsafeGrow :: PrimMonad m => MVector (PrimState m) Char -> Int -> m (MVector (PrimState m) Char)

Generic1 k (URec k Char)

Associated Types

type Rep1 (URec k Char) (f :: URec k Char -> *) :: k -> *

Methods

from1 :: f a -> Rep1 (URec k Char) f a

to1 :: Rep1 (URec k Char) f a -> f a

IsString (Seq Char)

Methods

fromString :: String -> Seq Char

Functor (URec * Char)

Methods

fmap :: (a -> b) -> URec * Char a -> URec * Char b

(<$) :: a -> URec * Char b -> URec * Char a

Foldable (URec * Char)

Methods

fold :: Monoid m => URec * Char m -> m

foldMap :: Monoid m => (a -> m) -> URec * Char a -> m

foldr :: (a -> b -> b) -> b -> URec * Char a -> b

foldr' :: (a -> b -> b) -> b -> URec * Char a -> b

foldl :: (b -> a -> b) -> b -> URec * Char a -> b

foldl' :: (b -> a -> b) -> b -> URec * Char a -> b

foldr1 :: (a -> a -> a) -> URec * Char a -> a

foldl1 :: (a -> a -> a) -> URec * Char a -> a

toList :: URec * Char a -> [a]

null :: URec * Char a -> Bool

length :: URec * Char a -> Int

elem :: Eq a => a -> URec * Char a -> Bool

maximum :: Ord a => URec * Char a -> a

minimum :: Ord a => URec * Char a -> a

sum :: Num a => URec * Char a -> a

product :: Num a => URec * Char a -> a

Traversable (URec * Char)

Methods

traverse :: Applicative f => (a -> f b) -> URec * Char a -> f (URec * Char b)

sequenceA :: Applicative f => URec * Char (f a) -> f (URec * Char a)

mapM :: Monad m => (a -> m b) -> URec * Char a -> m (URec * Char b)

sequence :: Monad m => URec * Char (m a) -> m (URec * Char a)

Eq (URec k Char p)

Methods

(==) :: URec k Char p -> URec k Char p -> Bool

(/=) :: URec k Char p -> URec k Char p -> Bool

Ord (URec k Char p)

Methods

compare :: URec k Char p -> URec k Char p -> Ordering

(<) :: URec k Char p -> URec k Char p -> Bool

(<=) :: URec k Char p -> URec k Char p -> Bool

(>) :: URec k Char p -> URec k Char p -> Bool

(>=) :: URec k Char p -> URec k Char p -> Bool

max :: URec k Char p -> URec k Char p -> URec k Char p

min :: URec k Char p -> URec k Char p -> URec k Char p

Show (URec k Char p)

Methods

showsPrec :: Int -> URec k Char p -> ShowS

show :: URec k Char p -> String

showList :: [URec k Char p] -> ShowS

Generic (URec k Char p)

Associated Types

type Rep (URec k Char p) :: * -> *

Methods

from :: URec k Char p -> Rep (URec k Char p) x

to :: Rep (URec k Char p) x -> URec k Char p

data Vector Char

data Vector Char = V_Char (Vector Char)

data URec k Char

Used for marking occurrences of Char#

Since: 4.9.0.0

data URec k Char = UChar {

• uChar# :: Char#

}

data MVector s Char

data MVector s Char = MV_Char (MVector s Char)

type Rep1 k (URec k Char)

type Rep1 k (URec k Char) = D1 k (MetaData "URec" "GHC.Generics" "base" False) (C1 k (MetaCons "UChar" PrefixI True) (S1 k (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar k)))

type Rep (URec k Char p)

type Rep (URec k Char p) = D1 * (MetaData "URec" "GHC.Generics" "base" False) (C1 * (MetaCons "UChar" PrefixI True) (S1 * (MetaSel (Just Symbol "uChar#") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (UChar *)))

type String = [Char]

A String is a list of characters. String constants in Haskell are values of type String.

class Monad m => MonadIO (m :: * -> *)

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Minimal complete definition

liftIO

Instances

MonadIO IO

Since: 4.9.0.0

Methods

liftIO :: IO a -> IO a

MonadIO m => MonadIO (ListT m)

Methods

liftIO :: IO a -> ListT m a

MonadIO m => MonadIO (MaybeT m)

Methods

liftIO :: IO a -> MaybeT m a

(Error e, MonadIO m) => MonadIO (ErrorT e m)

Methods

liftIO :: IO a -> ErrorT e m a

MonadIO m => MonadIO (ExceptT e m)

Methods

liftIO :: IO a -> ExceptT e m a

MonadIO m => MonadIO (StateT s m)

Methods

liftIO :: IO a -> StateT s m a

MonadIO m => MonadIO (StateT s m)

Methods

liftIO :: IO a -> StateT s m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Methods

liftIO :: IO a -> WriterT w m a

(Monoid w, MonadIO m) => MonadIO (WriterT w m)

Methods

liftIO :: IO a -> WriterT w m a

MonadIO m => MonadIO (IdentityT * m)

Methods

liftIO :: IO a -> IdentityT * m a

MonadIO m => MonadIO (ReaderT * r m)

Methods

liftIO :: IO a -> ReaderT * r m a

MonadIO m => MonadIO (ContT * r m)

Methods

liftIO :: IO a -> ContT * r m a

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

Methods

liftIO :: IO a -> RWST r w s m a

(Monoid w, MonadIO m) => MonadIO (RWST r w s m)

Methods

liftIO :: IO a -> RWST r w s m a

class Monad m => MonadReader r (m :: * -> *) | m -> r

See examples in Control.Monad.Reader. Note, the partially applied function type (->) r is a simple reader monad. See the instance declaration below.

Minimal complete definition

(ask | reader), local

Instances

MonadReader r m => MonadReader r (MaybeT m)

Methods

ask :: MaybeT m r

local :: (r -> r) -> MaybeT m a -> MaybeT m a

reader :: (r -> a) -> MaybeT m a

MonadReader r m => MonadReader r (ListT m)

Methods

ask :: ListT m r

local :: (r -> r) -> ListT m a -> ListT m a

reader :: (r -> a) -> ListT m a

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)

Methods

ask :: WriterT w m r

local :: (r -> r) -> WriterT w m a -> WriterT w m a

reader :: (r -> a) -> WriterT w m a

(Monoid w, MonadReader r m) => MonadReader r (WriterT w m)

Methods

ask :: WriterT w m r

local :: (r -> r) -> WriterT w m a -> WriterT w m a

reader :: (r -> a) -> WriterT w m a

MonadReader r m => MonadReader r (StateT s m)

Methods

ask :: StateT s m r

local :: (r -> r) -> StateT s m a -> StateT s m a

reader :: (r -> a) -> StateT s m a

MonadReader r m => MonadReader r (StateT s m)

Methods

ask :: StateT s m r

local :: (r -> r) -> StateT s m a -> StateT s m a

reader :: (r -> a) -> StateT s m a

MonadReader r m => MonadReader r (IdentityT * m)

Methods

ask :: IdentityT * m r

local :: (r -> r) -> IdentityT * m a -> IdentityT * m a

reader :: (r -> a) -> IdentityT * m a

MonadReader r m => MonadReader r (ExceptT e m)

Methods

ask :: ExceptT e m r

local :: (r -> r) -> ExceptT e m a -> ExceptT e m a

reader :: (r -> a) -> ExceptT e m a

(Error e, MonadReader r m) => MonadReader r (ErrorT e m)

Methods

ask :: ErrorT e m r

local :: (r -> r) -> ErrorT e m a -> ErrorT e m a

reader :: (r -> a) -> ErrorT e m a

Monad m => MonadReader r (ReaderT * r m)

Methods

ask :: ReaderT * r m r

local :: (r -> r) -> ReaderT * r m a -> ReaderT * r m a

reader :: (r -> a) -> ReaderT * r m a

MonadReader r ((->) LiftedRep LiftedRep r)

Methods

ask :: (LiftedRep -> LiftedRep) r r

local :: (r -> r) -> (LiftedRep -> LiftedRep) r a -> (LiftedRep -> LiftedRep) r a

reader :: (r -> a) -> (LiftedRep -> LiftedRep) r a

MonadReader r' m => MonadReader r' (ContT * r m)

Methods

ask :: ContT * r m r'

local :: (r' -> r') -> ContT * r m a -> ContT * r m a

reader :: (r' -> a) -> ContT * r m a

(Monad m, Monoid w) => MonadReader r (RWST r w s m)

Methods

ask :: RWST r w s m r

local :: (r -> r) -> RWST r w s m a -> RWST r w s m a

reader :: (r -> a) -> RWST r w s m a

(Monad m, Monoid w) => MonadReader r (RWST r w s m)

Methods

ask :: RWST r w s m r

local :: (r -> r) -> RWST r w s m a -> RWST r w s m a

reader :: (r -> a) -> RWST r w s m a