A Scene represents a sequence of animations and variables that change over time.

The ZIndex property specifies the stack order of sprites and animations. Elements with a higher ZIndex will be drawn on top of elements with a lower index.

Render a Scene to an Animation.

Render a Scene to an Animation.

Play an animation once and then remove it. This advances the clock by the duration of the animation.

Example:

do play drawBox
   play drawCircle

Execute actions in a scene without advancing the clock. Note that scenes do not end before all forked actions have completed.

Example:

do fork $ play drawBox
   play drawCircle

Query the current clock timestamp.

Example:

do now <- play drawCircle *> queryNow
   play $ staticFrame 1 $ scale 2 $ withStrokeWidth 0.05 $
     mkText $ "Now=" <> T.pack (show now)

Advance the clock by a given number of seconds.

Example:

do fork $ play drawBox
   wait 1
   play drawCircle

Wait until the clock is equal to the given timestamp.

Wait until all forked and sequential animations have finished.

Example:

do waitOn $ fork $ play drawBox
   play drawCircle

Change the ZIndex of a scene.

Query the duration of a scene.

Time dependent variable.

Create a new variable with a default value. Variables always have a defined value even if they are read at a timestamp that is earlier than when the variable was created. For example:

do v <- fork (wait 10 >> newVar 0) -- Create a variable at timestamp '10'.
   readVar v                       -- Read the variable at timestamp '0'.
                                   -- The value of the variable will be '0'.

Read the value of a variable at the current timestamp.

Write the value of a variable at the current timestamp.

Example:

do v <- newVar 0
   newSprite $ mkCircle <$> unVar v
   writeVar v 1; wait 1
   writeVar v 2; wait 1
   writeVar v 3; wait 1

Modify the value of a variable at the current timestamp and all future timestamps.

Modify a variable between now and now+duration. Note: The modification function is invoked for past timestamps (with a time value of 0) and for timestamps after now+duration (with a time value of 1). See tweenVarUnclamped.

Modify a variable between now and now+duration. Note: The modification function is invoked for past timestamps (with a negative time value) and for timestamps after now+duration (with a time value greater than 1).

Create and render a variable. The rendering will be born at the current timestamp and will persist until the end of the scene.

Example:

do var <- simpleVar mkCircle 0
   tweenVar var 2 $ \val -> fromToS val (screenHeight/2)

Helper function for filtering variables.

Sprites are animations with a given time of birth as well as a time of death. They can be controlled using variables, tweening, and effects.

Sprite frame generator. Generates frames over time in a stateful environment.

Dereference a variable as a Sprite frame.

Example:

do v <- newVar 0
   newSprite $ mkCircle <$> unVar v
   tweenVar v 1 $ \val -> fromToS val 3
   tweenVar v 1 $ \val -> fromToS val 0

Dereference seconds since sprite birth.

Dereference duration of the current sprite.

Create new sprite defined by a frame generator. Unless otherwise specified using destroySprite, the sprite will die at the end of the scene.

Example:

do newSprite $ mkCircle <$> spriteT -- Circle sprite where radius=time.
   wait 2

Create new sprite defined by a frame generator. The sprite will die at the end of the scene.

Create a new sprite from an animation. This advances the clock by the duration of the animation. Unless otherwise specified using destroySprite, the sprite will die at the end of the scene.

Note: If the scene doesn't end immediately after the duration of the animation, the animation will be stretched to match the lifetime of the sprite. See newSpriteA' and play.

Example:

do fork $ newSpriteA drawCircle
   play drawBox
   play $ reverseA drawBox

Create a new sprite from an animation and specify the synchronization policy. This advances the clock by the duration of the animation.

Example:

do fork $ newSpriteA' SyncFreeze drawCircle
   play drawBox
   play $ reverseA drawBox

Create a sprite from a static SVG image.

Example:

do newSpriteSVG $ mkBackground "lightblue"
   play drawCircle

Create a permanent sprite from a static SVG image. Same as newSpriteSVG but the sprite isn't returned and thus cannot be destroyed.

Destroy a sprite, preventing it from being rendered in the future of the scene. If destroySprite is invoked multiple times, the earliest time-of-death is used.

Example:

do s <- newSpriteSVG $ withFillOpacity 1 $ mkCircle 1
   fork $ wait 1 >> destroySprite s
   play drawBox

Change the rendering of a sprite using data from a variable. If data from several variables is needed, use a frame generator instead.

Example:

do s <- fork $ newSpriteA drawBox
   v <- newVar 0
   applyVar v s rotate
   tweenVar v 2 $ \val -> fromToS val 90

Low-level frame modifier.

Map the SVG output of a sprite.

Example:

do s <- fork $ newSpriteA drawCircle
   wait 1
   spriteMap s flipYAxis

Modify the output of a sprite between now and now+duration.

Example:

do s <- fork $ newSpriteA drawCircle
   spriteTween s 1 $ \val -> translate (screenWidth*0.3*val) 0

Create a new variable and apply it to a sprite.

Example:

do s <- fork $ newSpriteA drawBox
   v <- spriteVar s 0 rotate
   tweenVar v 2 $ \val -> fromToS val 90

Apply an effect to a sprite.

Example:

do s <- fork $ newSpriteA drawCircle
   spriteE s $ overBeginning 1 fadeInE
   spriteE s $ overEnding 0.5 fadeOutE

Set new ZIndex of a sprite.

Example:

do s1 <- newSpriteSVG $ withFillOpacity 1 $ withFillColor "blue" $ mkCircle 3
   newSpriteSVG $ withFillOpacity 1 $ withFillColor "red" $ mkRect 8 3
   wait 1
   spriteZ s1 1
   wait 1

Destroy all local sprites at the end of a scene.

Example:

do -- the rect lives through the entire 3s animation
   newSpriteSVG_ $ translate (-3) 0 $ mkRect 4 4
   wait 1
   spriteScope $ do
     -- the circle only lives for 1 second.
     local <- newSpriteSVG $ translate 3 0 $ mkCircle 2
     spriteE local $ overBeginning 0.3 fadeInE
     spriteE local $ overEnding 0.3 fadeOutE
     wait 1
   wait 1

Objects are SVG nodes (represented as Haskell values) with identity, location, and several other properties that can change over time.

Container for object properties.

Create new object.

Create new object.

Modify object properties.

Modify object properties using a stateful API.

Query object property.

Modify object properties over a set duration.

Modify object properties over a set duration using a stateful API.

Modify object value over a set duration. This is a convenience function for modifying oValue.

Modify object value over a set duration using a stateful API. This is a convenience function for modifying oValue.

Objects can be any Haskell structure as long as it can be rendered to SVG.

Object position. Default: <0,0>

Rendered SVG node of an object. Does not include context or object properties. Read-only.

Custom render context. Is applied to the object for every frame that it is shown.

Object margins (top, right, bottom, left) in local units.

Object's top margin.

Object's right margin.

Object's bottom margin.

Object's left margin.

Object bounding-box (minimal X-coordinate, minimal Y-coordinate, width, height). Uses boundingBox and has the same limitations.

Object's minimal X-coordinate..

Object's minimal Y-coordinate..

Object's width without margin.

Object's height without margin.

Object opacity. Default: 1

Toggle for whether or not the object should be rendered. Default: False

Object's z-index.

Easing function used when modifying object properties. Default: curveS 2

Object's scale. Default: 1

Origin point for scaling. Default: <0,0>

Derived location of the top-most point of an object + margin.

Derived location of the bottom-most point of an object + margin.

Derived location of the left-most point of an object + margin.

Derived location of the right-most point of an object + margin.

Derived location of an object's center point.

Lens for the source value contained in an object.

Instantly show object.

Instantly hide object.

Fade in object over a set duration.

Fade out object over a set duration.

Scale in object over a set duration.

Scale out object over a set duration.

Morph source object into target object over a set duration.

Basic object mapping to <circle/> in SVG.

Circle radius in local units.

Basic object mapping to <rect/> in SVG.

Rectangle width in local units.

Rectangle height in local units.

Object representing an interpolation between SVG nodes.

Control variable for the interpolation. A value of 0 gives the source SVG and 1 gives the target svg.

Source shape.

Target shape.

Cameras can take control of objects and manipulate them with convenient pan and zoom operations.

Connect an object to a camera such that camera settings (position, zoom, and rotation) is applied to the object.

Example

do cam <- newObject Camera
   circ <- newObject $ Circle 2
   oModifyS circ $
     oContext .= withFillOpacity 1 . withFillColor "blue"
   oShow circ
   cameraAttach cam circ
   cameraZoom cam 1 2
   cameraZoom cam 1 1

Example

do cam <- newObject Camera
   circ <- newObject $ Circle 2; oShow circ
   oModify circ $ oTranslate .~ (-3,0)
   box <- newObject $ Rectangle 4 4; oShow box
   oModify box $ oTranslate .~ (3,0)
   cameraAttach cam circ
   cameraAttach cam box
   cameraFocus cam (-3,0)
   cameraZoom cam 2 2      -- Zoom in
   cameraZoom cam 2 1      -- Zoom out
   cameraFocus cam (3,0)
   cameraZoom cam 2 2      -- Zoom in
   cameraZoom cam 2 1      -- Zoom out

Instantaneously set camera zoom level.

Change camera zoom level over a set duration.

Instantaneously set camera location.

Change camera location over a set duration.

Lift an ST action into the Scene monad.

Apply a transformation with a given overlap. This makes sure to keep timestamps intact such that events can still be timed by transcripts.

Evaluate the value of a scene.