Copyright	[2014] Manuel M T Chakravarty
License	BSD3
Maintainer	Manuel M T Chakravarty <chak@justtesting.org>
Stability	experimental
Safe Haskell	None
Language	Haskell98

Graphics.SpriteKit

Contents

Basic geometry and similar
- Basic temporal definition
- Basic geometry definitions
Marshalling functions (internal)
Color representation
Colour representation
Colours in the sRGBA colour space
Standard colours
Marshalling support (internal)
Bit images and textures
Vector paths
Core Graphics path representation
Marshalling functions (internal)
Nodes and scenes
Actions animating nodes
Physics simulation
User events
Event information
Marshalling functions (internal)
Internal

Description

Cocoa SpriteKit for Haskell

Concepts:

SpriteKit node trees are represented as conventional algebraic datatypes in Haskell.
For rendering, Haskell node trees are converted to native SKNode trees. For animated scenes, where all animation is driven by Haskell, the conversion of updated scenes works by updating the previous SKNode tree.
For interactive scenes and scenes using SceneKit's actions or physics, the Haskell scene code gets called with a Haskell tree representing the current SKNode tree, which, after Haskell side processing, is converted to an SKNode tree again by updating the version that was passed to the Haskell code.

Synopsis

Basic geometry and similar

Basic temporal definition

type TimeInterval = Double

Basic geometry definitions

type GFloat

Arguments

= Double

FIXME: need to be set in dependence on the definition of CGFloat resp CGFLOAT_IS_DOUBLE

Graphics float (which is a Float or Double depending on whether we are on a 32 or 64 bit architecture)

data Point

Point in a two-dimensional coordinate system.

Constructors

Point
Fields pointX :: !GFloat pointY :: !GFloat

Instances

Eq Point
Ord Point
Read Point
Show Point

data Size

Size of a two-dimensional geometry entity.

Constructors

Size
Fields sizeWidth :: !GFloat sizeHeight :: !GFloat

Instances

Eq Size
Ord Size
Read Size
Show Size

data Rect

Location and size of a rectangle.

Constructors

Rect
Fields rectOrigin :: !Point rectSize :: !Size

Instances

Eq Rect
Ord Rect
Read Rect
Show Rect

data Vector

Two-dimensional vector.

Constructors

Vector
Fields vectorDx :: !GFloat vectorDy :: !GFloat

Instances

Eq Vector
Ord Vector
Read Vector
Show Vector

pointZero :: Point

Point at (0, 0).

sizeZero :: Size

rectZero :: Rect

vectorZero :: Vector

Marshalling functions (internal)

pointToCGPoint :: Point -> IO CGPoint

cgPointToPoint :: CGPoint -> IO Point

sizeToCGSize :: Size -> IO CGSize

cgSizeToSize :: CGSize -> IO Size

rectToCGRect :: Rect -> IO CGRect

cgRectToRect :: CGRect -> IO Rect

vectorToCGVector :: Vector -> IO CGVector

cgVectorToVector :: CGVector -> IO Vector

geometry_initialise :: IO ()

Color representation

Colour representation

newtype Color

Representation of color values.

Constructors

Color SKColor

Colours in the sRGBA colour space

colorWithRGBA :: Float -> Float -> Float -> Float -> Color

Create color with the specified red, green, blue, and alpha channel values in the sRGB color space.

rgbaOfColor :: Color -> Maybe (Float, Float, Float, Float)

Extract the red, green, blue, and alpha channel values of a colour in the sRGB colour space.

Returns Nothing if the color is in a different color space.

Standard colours

blackColor :: Color

blueColor :: Color

clearColor :: Color

cyanColor :: Color

darkGrayColor :: Color

grayColor :: Color

greenColor :: Color

lightGrayColor :: Color

magentaColor :: Color

orangeColor :: Color

purpleColor :: Color

redColor :: Color

whiteColor :: Color

yellowColor :: Color

Marshalling support (internal)

newtype SKColor

Constructors

SKColor (ForeignPtr SKColor)

colorToSKColor :: Color -> SKColor

colorToForeignPtr :: Color -> IO (ForeignPtr SKColor)

color_initialise :: IO ()

Bit images and textures

Images

data Image

Instances

IsImage Image

class IsImage img where

Methods

toImage :: img -> Image

Instances

Marshalling functions (internal)

newtype NSUIImage

Constructors

NSUIImage (ForeignPtr NSUIImage)

imageToNSUIImage :: IsImage img => img -> IO NSUIImage

imageToForeignPtr :: IsImage img => img -> IO (ForeignPtr NSUIImage)

image_initialise :: IO ()

SpriteKit texture representation

newtype Texture

A SpriteKit texture object

Constructors

Texture SKTexture

Texture creation

textureWithImageNamed :: FilePath -> Texture

Create a texture from an image in the app bundle (either a file or an image in a texture atlas) or external file.

A placeholder image is used if the specified image cannot be loaded.

In case of a relative name, the look up behaviour varies between a compiled application bundle and running in the interpreter. In case of a compiled application bundle, the standard SpriteKit bundle behaviour applies. In case of executing in the interpreter, we first look for assets relative to the current working directory.

textureWithImage :: Image -> Texture

Create a texture from the given image.

textureWithRectInTexture :: Rect -> Texture -> Texture

Create a texture from a subset of an existing texture.

The original and new texture share the same texture data. In further call to the same function, the rectangle is again specified in terms of the *original* texture.

Texture properties

textureSize :: Texture -> Size

The size of the texture.

textureRect :: Texture -> Rect

The rectangle (in the unit coordinate space) that defines the portion of the texture used to render its image.

The default is (0,0) — (1,1), but it may be different for textures created with textureWithRectInTexture.

Marshalling support

newtype SKTexture

Constructors

SKTexture (ForeignPtr SKTexture)

textureToSKTexture :: Texture -> SKTexture

textureToForeignPtr :: Texture -> IO (ForeignPtr SKTexture)

texture_initialise :: IO ()

Vector paths

Core Graphics path representation

type Path = [PathElement]

Description of a graphics path.

data PathElement

Elementary components of a graphics path.

The constructors AddLineToPoint, AddQuadCurveToPoint, AddCurveToPoint may not start a graphics path.

Constructors

MoveToPoint !Point	Starts a new subpath at the given point.
AddLineToPoint !Point	Adds a line from the current to the given point.
AddQuadCurveToPoint !Point !Point	Adds a quadratic curve with control and destination point.
AddCurveToPoint !Point !Point !Point	Adds a cubic curve with two control and one destination point.
CloseSubpath	Closes and completes the current subpath. FIXME: we might to add field names (esp useful for the quadratic and cubic curves)

Marshalling functions (internal)

newtype CGPath

Constructors

CGPath (ForeignPtr CGPath)

pathToCGPath :: Path -> IO CGPath

cgPathToPath :: CGPath -> IO Path

path_initialise :: IO ()

Nodes and scenes

SpriteKit node representation

data Node u

Tree structure of SpriteKit nodes that are used to assemble scenes, parameterised by the type of user data u.

Constructors

Node
Fields nodeName :: Maybe String Optional node identifier (doesn't have to be unique) nodePosition :: Point The position of the node in its parent's coordinate system. nodeZPosition :: GFloat The height of the node relative to its parent (default: 0.0) nodeXScale :: GFloat Scaling factor multiplying the width of a node and its children (default: 1.0) nodeYScale :: GFloat Scaling factor multiplying the height of a node and its children (default: 1.0) nodeZRotation :: GFloat Euler rotation about the z axis (in radians; default: 0.0) nodeChildren :: [Node u] nodeActionDirectives :: [Directive (Node u)] nodeSpeed :: GFloat Speed modifier for all actions in the entire subtree (default: 1.0) nodePaused :: Bool If `True` all actions in the entire subtree are skipped (default: `False`). nodePhysicsBody :: Maybe PhysicsBody nodeUserData :: u Application specific information (default: uninitialised!) nodeForeign :: Maybe SKNode Internal
Label
Fields nodeName :: Maybe String Optional node identifier (doesn't have to be unique) nodePosition :: Point The position of the node in its parent's coordinate system. nodeZPosition :: GFloat The height of the node relative to its parent (default: 0.0) nodeXScale :: GFloat Scaling factor multiplying the width of a node and its children (default: 1.0) nodeYScale :: GFloat Scaling factor multiplying the height of a node and its children (default: 1.0) nodeZRotation :: GFloat Euler rotation about the z axis (in radians; default: 0.0) nodeChildren :: [Node u] nodeActionDirectives :: [Directive (Node u)] nodeSpeed :: GFloat Speed modifier for all actions in the entire subtree (default: 1.0) nodePaused :: Bool If `True` all actions in the entire subtree are skipped (default: `False`). nodePhysicsBody :: Maybe PhysicsBody nodeUserData :: u Application specific information (default: uninitialised!) nodeForeign :: Maybe SKNode Internal labelText :: String Text displayed by the node. labelFontColor :: Color The colour of the label (default: white). labelFontName :: Maybe String The font used for the label. labelFontSize :: GFloat The size of the font used in the label (default: 32pt).
Shape
Fields nodeName :: Maybe String Optional node identifier (doesn't have to be unique) nodePosition :: Point The position of the node in its parent's coordinate system. nodeZPosition :: GFloat The height of the node relative to its parent (default: 0.0) nodeXScale :: GFloat Scaling factor multiplying the width of a node and its children (default: 1.0) nodeYScale :: GFloat Scaling factor multiplying the height of a node and its children (default: 1.0) nodeZRotation :: GFloat Euler rotation about the z axis (in radians; default: 0.0) nodeChildren :: [Node u] nodeActionDirectives :: [Directive (Node u)] nodeSpeed :: GFloat Speed modifier for all actions in the entire subtree (default: 1.0) nodePaused :: Bool If `True` all actions in the entire subtree are skipped (default: `False`). nodePhysicsBody :: Maybe PhysicsBody nodeUserData :: u Application specific information (default: uninitialised!) nodeForeign :: Maybe SKNode Internal shapePath :: Path Graphics path as a series of shapes or lines. shapeFillColor :: Color The color used to fill the shape (default: clear == not filled). shapeLineWidth :: GFloat The width used to stroke the path (default: 1.0; should be <= 2.0). shapeGlowWidth :: GFloat Glow extending outward from the stroked line (default: 0.0 == no glow). shapeAntialiased :: Bool Smooth stroked path during drawing? (default: True). shapeStrokeColor :: Color Colour used to stroke the shape (default: white; clear == no stroke).
Sprite
Fields nodeName :: Maybe String Optional node identifier (doesn't have to be unique) nodePosition :: Point The position of the node in its parent's coordinate system. nodeZPosition :: GFloat The height of the node relative to its parent (default: 0.0) nodeXScale :: GFloat Scaling factor multiplying the width of a node and its children (default: 1.0) nodeYScale :: GFloat Scaling factor multiplying the height of a node and its children (default: 1.0) nodeZRotation :: GFloat Euler rotation about the z axis (in radians; default: 0.0) nodeChildren :: [Node u] nodeActionDirectives :: [Directive (Node u)] nodeSpeed :: GFloat Speed modifier for all actions in the entire subtree (default: 1.0) nodePaused :: Bool If `True` all actions in the entire subtree are skipped (default: `False`). nodePhysicsBody :: Maybe PhysicsBody nodeUserData :: u Application specific information (default: uninitialised!) nodeForeign :: Maybe SKNode Internal spriteSize :: Size The dimensions of the sprite, in points. spriteAnchorPoint :: Point The point in the sprite that corresponds to the node’s position. ^In unit coordinate space; default: (0.5,0.5); i.e., centered on its position. spriteTexture :: Maybe Texture spriteColorBlendFactor :: GFloat Default = 0 (`spriteColor` is ignored when drawing texture) ^value >0 means texture is blended with `spriteColour` before being drawn spriteColor :: Color The sprite’s color.

data SDirective node children

Specification of changes that should be made to a node's actions (might be a proper node or a scene).

Constructors

RunAction (SAction node children) (Maybe String)	Initiate a new action, possibly named.
RemoveActionForKey String	Remove a named action.
RemoveAllActions	Remove all current actions.

type Directive node = SDirective node node

Directive for a proper node (not including scenes).

type TimedUpdate node = node -> GFloat -> node

Function that computes an updated tree, given the time that elapsed since the start of the current animation.

The result will be ignored if the new node is not derived from the old node — i.e, it must be the same kind of node and it must preserve the nodeForeign field.

Generic SpriteKit node functionality

node :: [Node userData] -> Node userData

Create a node that combines multiple child nodes, but doesn't have a visual representation of its own.

frame :: Node userData -> IO Rect

Determine a rectangle in the parent’s coordinate system that contains the node’s content, ignoring the node’s children.

LIMITATION: The current implementation of this function can be quite costly due to superflous marshalling overhead.

calculateAccumulatedFrame :: Node userData -> IO Rect

Calculate a rectangle in the parent’s coordinate system that contains the content of the node and all of its descendants.

Label nodes

labelNodeWithFontNamed :: String -> Node userData

Creates a label node without any text, but using the specified font.

labelNodeWithText :: String -> Node userData

Creates a label node with the given text (set in 32pt Helvetica Neue Ultralight).

Shape nodes

shapeNodeWithPath :: Path -> Node userData

Creates a shape node from a graphics path relative to the nodes origin.

Sprite nodes

spriteNodeWithColorSize :: Color -> Size -> Node userData

Create a coloured sprite of a given size.

spriteNodeWithImageNamed :: FilePath -> Node userData

Create a texture sprite from an image in the app bundle (either a file or an image in a texture atlas).

A placeholder image is used if the image cannot be loaded.

spriteNodeWithTexture :: Texture -> Node userData

Create a textured sprite from an in-memory texture.

spriteNodeWithTextureSize :: Texture -> Size -> Node userData

Create a textured sprite from an in-memory texture, but also set an explicit size (instead of using the texture's size).

spriteNodeWithTextureColorSize :: Texture -> Color -> Size -> Node userData

Create a textured sprite from an in-memory texture, but also set an explicit size (instead of using the texture's size).

NB: To colourise the texture, you also need to set the colorBlendFactor field of the sprite.

Short forms

spriteWithColorSize :: Color -> Size -> Node userData

Create a coloured sprite of a given size.

spriteWithImageNamed :: FilePath -> Node userData

Create a texture sprite from an image in the app bundle (either a file or an image in a texture atlas).

A placeholder image is used if the image cannot be loaded.

spriteWithTexture :: Texture -> Node userData

Create a textured sprite from an in-memory texture.

spriteWithTextureSize :: Texture -> Size -> Node userData

Create a textured sprite from an in-memory texture, but also set an explicit size (instead of using the texture's size).

spriteWithTextureColorSize :: Texture -> Color -> Size -> Node userData

Create a textured sprite from an in-memory texture, but also set an explicit size (instead of using the texture's size).

NB: To colourise the texture, you also need to set the colorBlendFactor field of the sprite.

Internal marshalling support

newtype SKNode

Constructors

SKNode (ForeignPtr SKNode)

skNodeToNode :: SKNode -> IO (Node userData)

nodeToSKNode :: Node userData -> IO SKNode

mergeSKNode :: Node userData -> Node userData -> IO SKNode

addChildren :: Bool -> SKNode -> [Node userData] -> IO ()

addActionDirectives :: SKNode -> [SDirective node children] -> IO ()

unsafeInterleaveNSArrayTolistOfNode :: NSArray SKNode -> IO [Node userData]

updateChildren :: SKNode -> [Node userData] -> [Node userData] -> IO ()

nodeToForeignPtr :: Node userData -> IO (ForeignPtr SKNode)

node_initialise :: IO ()

Scene representation

data Scene sceneData nodeData

SpriteKit scene description.

Constructors

Scene

Fields

sceneName :: Maybe String: Optional scene node identifier (doesn't have to be unique)
sceneChildren :: [Node nodeData]
sceneActionDirectives :: [SDirective (Scene sceneData nodeData) (Node nodeData)]
sceneSpeed :: GFloat: Speed modifier for all actions in the entire subtree (default: 1.0)
sceneData :: sceneData: Application specific information (default: uninitialised!)
scenePaused :: Bool: If True all actions in the entire subtree are skipped (default: False).
sceneAnchorPoint :: Point: Point in the view’s frame that corresponds to the scene’s origin in unit coordinate space (default: (0, 0) == lower-left corner of the view's frame).
sceneSize :: Size: Dimensions of the scene in points.
sceneScaleMode :: SceneScaleMode: How the scene is defined to the enclosing view (default: SceneScaleModeFill).
sceneBackgroundColor :: Color: Background colour (default: RGBA 0.15, 0.15, 0.15, 1.0).
sceneUpdate :: Maybe (SceneUpdate sceneData nodeData): Called once per frame before any other updates to the scene (default: Nothing)
scenePhysicsWorld :: PhysicsWorld sceneData nodeData: Physics simulation associated with this scene (default: Nothing)
sceneHandleEvent :: Maybe (EventHandler sceneData): Event handler for the scene (default: Nothing).

type EventHandler userData = Event -> userData -> Maybe userData

Event handler that given an input event and node data decides whether to handle the event and how to update the node data.

If the handler chooses not to handle the presented event, it returns Nothing. In this case, the event will be forwarded to the next item in the responder chain.

Scene creation

sceneWithSize :: Size -> Scene sceneData nodeData

A new scene of the given size.

Marshalling functions (internal)

sceneToSKNode :: Scene sceneData nodeData -> IO SKNode

sceneToForeignPtr :: Scene sceneData nodeData -> IO (ForeignPtr SKNode)

scene_initialise :: IO ()

Actions animating nodes

Action directives

runAction :: SAction node children -> SDirective node children

Initiate a new action.

runActionWithKey :: SAction node children -> String -> SDirective node children

Initiate a new action and give it a name.

If an action with the same name is currently underway on a node that receives this action, the old action is removed first.

removeActionForKey :: String -> SDirective node children

Instructs to remove any action with the give name.

removeAllActions :: SDirective node children

Instructs to remove all actions from any node that receives this directive.

Animation actions

data SActionSpecification node children

Specification of an action that can be applied to a SpriteKit node or scene.

The first type parameter is the type of node on which the action operates. The second is the type of node of its children. This distinction is required as actions operating on a scene may include RunActionOnChildWithName actions that will operate on nodes (which are of a different type).

Most actions will be animated over time, given a duration.

Constructors

MoveBy !Vector	Move relative to current position (reversible).
MoveTo !Point	Move to an absolute position (irreversible).
MoveToX !GFloat	Move horizontally to an absolute x-position (irreversible).
MoveToY !GFloat	Move vertically to an absolute y-position (irreversible).
FollowPath Path !Bool !Bool	Follow path, maybe use relative offsets & maybe orient according to path (reversible).
FollowPathSpeed Path !Bool !Bool !GFloat	As above, but specifying speed in points per sec (reversible; OS X 10.10+ & iOS 8+).
RotateByAngle !GFloat	Rotate by a relative value, in radians (reversible).
RotateToAngle !GFloat	Rotate counterclockwise to an absolute angle, in radians (irreversible).
RotateToAngleShortestUnitArc !GFloat !Bool	Rotate to an absolute angle. If second argument '== True', in the direction resulting in the smallest rotation; otherwise, interpolated (irreversible).
SpeedBy !GFloat	Changes how fast the node executes actions by a relative value (reversible).
SpeedTo !GFloat	Changes how fast the node executes actions to an absolute value (irreversible).
ScaleBy !GFloat !GFloat	Relative change of x and y scale values (reversible).
ScaleTo !GFloat !GFloat	Change x and y scale values to an absolute values (irreversible).
ScaleXTo !GFloat	Change x scale value to an absolute value (irreversible).
ScaleYTo !GFloat	Change y scale value to an absolute value (irreversible).
Unhide	Makes a node visible (reversible; instantaneous; OS X 10.10+ & iOS 8+).
Hide	Hides a node (reversible; instantaneous; OS X 10.10+ & iOS 8+).
FadeIn	Changes the alpha value to 1.0 (reversible).
FadeOut	Changes the alpha value to 0.0 (reversible).
FadeAlphaBy !GFloat	Relative change of the alpha value (reversible).
FadeAlphaTo !GFloat	Change the alpha value to an absolute value (irreversible).
ResizeByWidthHeight !GFloat !GFloat	Adjust the size of a sprite (reversible).
ResizeToHeight !GFloat	Change height of a sprite to an absolute value (irreversible).
ResizeToWidth !GFloat	Change width of a sprite to an absolute value (irreversible).
ResizeToWidthHeight !GFloat !GFloat	Change width and height of a sprite to an absolute value (irreversible).
SetTexture Texture !Bool	Change a sprite's texture, maybe resizing the sprite (irreversible; instantaneous; without resizing only OS X 10.10+ & iOS 7.1+).
AnimateWithTextures [Texture] !TimeInterval !Bool !Bool	Animate setting the textures, pausing by the given time interval between textures. If first `Bool` '== True', resize sprite to match each texture. If second `Bool` is `True`, the original texture is restored (reversible).
SetNormalTexture Texture !Bool	Change a sprite's normal texture, maybe resizing (irreversible; instantaneous; OS X 10.11+ & iOS 9+).
AnimateWithNormalTextures [Texture] !TimeInterval !Bool !Bool	Animate normal textures, pausing by the given time interval between textures. If first `Bool` '== True', resize sprite to match each normal texture. If second `Bool` is `True`, the original texture is restored (reversible; OS X 10.11+ & iOS 9+).
ColorizeWithColor Color !GFloat	Animate a sprite's color and blend factor (irreversible).
ColorizeWithColorBlendFactor !GFloat	Animate a sprite's blend factor (irreversible).
ApplyForceImpulse ForceImpulse	Apply the specified force or impulse to the physics body (reverible). FIXME: not yet implemented: change of charge
ChangeMassTo GFloat	Change the mass of the node's physics body to the new value (irreversible).
ChangeMassBy GFloat	Change the mass of the node's physics body by the given value (reversible). FIXME: not yet implemented: physics field strength change and falloff
PlaySoundFileNamed String !Bool	Play a sound, maybe waiting until the sound finishes playing (irreversible). FIXME: not yet implemented: actions acting on sound nodes
RemoveFromParent	Removes the animated node from its parent (irreversible; instantaneous).
RunActionOnChildWithName (Action children) String	Run an action on a named child node (reversible; instantaneous).
Group [SAction node children]	Run all actions in the group in parallel (reversible).
Sequence [SAction node children]	Run all actions in the group in sequence (reversible).
RepeatActionCount (SAction node children) !Int	Repeat an action a fixed number of times (reversible).
RepeatActionForever (SAction node children)	Repeat an action undefinitely (reversible).
WaitForDuration !TimeInterval	Waits for the action's duration +/- half the given range value (irreversible).
CustomAction (TimedUpdate node)	Repeatedly invoke the update function over the action duration (irreversible).

type ActionSpecification node = SActionSpecification node node

Action specifications on proper nodes have the same type for the node to which the action is attached and its children.

data SAction node children

SpriteKit action.

NB: actionTimingFunction not yet supported.

Constructors

Action

Fields

actionSpecification :: SActionSpecification node children: Determines the action to be performed.
actionReversed :: !Bool: Reverses the behaviour of another action (default: False).
actionSpeed :: !GFloat: Speed factor that modifies how fast an action runs (default: 1.0).
actionTimingMode :: ActionTimingMode: Determines the action timing (default: ActionTimingLinear).
actionTimingFunction :: Maybe ActionTimingFunction: Customises the above timing mode (OS X 10.10+ & iOS 8+).
actionDuration :: !TimeInterval: Duration required to complete an action (default: 0.0 == immediate).

type Action node = SAction node node

Action on a proper node (not a scene).

data ActionTimingMode

Determines the temporal progression of an action.

Constructors

ActionTimingLinear
ActionTimingEaseIn
ActionTimingEaseOut
ActionTimingEaseInEaseOut

type ActionTimingFunction = Float -> Float

Projects an input value between 0.0 and 1.0, inclusive, to another value between 0.0 and 1.0 to indicate the temporal progression of an action. The input 0.0 must be mapped to 0.0, and 1.0 to 1.0. Inbetween those bounds, the timing function can adjust the timing of the action.

action :: SActionSpecification node children -> SAction node children

Construct an action.

Convenience functions to construct specifications of the same name

moveBy :: Vector -> SAction node children

moveTo :: Point -> SAction node children

moveToX :: GFloat -> SAction node children

moveToY :: GFloat -> SAction node children

followPath :: Path -> SAction node children

followPathSpeed :: Path -> GFloat -> SAction node children

followPathAsOffsetOrientToPath :: Path -> Bool -> Bool -> SAction node children

followPathAsOffsetOrientToPathSpeed :: Path -> Bool -> Bool -> GFloat -> SAction node children

rotateByAngle :: GFloat -> SAction node children

rotateToAngle :: GFloat -> SAction node children

rotateToAngleShortestUnitArc :: GFloat -> Bool -> SAction node children

speedBy :: GFloat -> SAction node children

speedTo :: GFloat -> SAction node children

scaleBy :: GFloat -> SAction node children

scaleTo :: GFloat -> SAction node children

scaleXByY :: GFloat -> GFloat -> SAction node children

scaleXToX :: GFloat -> GFloat -> SAction node children

scaleXTo :: GFloat -> SAction node children

scaleYTo :: GFloat -> SAction node children

hide :: SAction node children

unhide :: SAction node children

fadeIn :: SAction node children

fadeOut :: SAction node children

fadeAlphaBy :: GFloat -> SAction node children

fadeAlphaTo :: GFloat -> SAction node children

resizeByWidthHeight :: GFloat -> GFloat -> SAction node children

resizeToHeight :: GFloat -> SAction node children

resizeToWidth :: GFloat -> SAction node children

resizeToWidthHeight :: GFloat -> GFloat -> SAction node children

setTexture :: Texture -> SAction node children

setTextureResize :: Texture -> Bool -> SAction node children

setNormalTexture :: Texture -> SAction node children

setNormalTextureResize :: Texture -> Bool -> SAction node children

animateWithTexturesTimePerFrame :: [Texture] -> TimeInterval -> SAction node children

animateWithTextures is a shorthand for convenience.

animateWithTextures :: [Texture] -> TimeInterval -> SAction node children

animateWithTextures is a shorthand for convenience.

animateWithTexturesTimePerFrameResizeRestore :: [Texture] -> TimeInterval -> Bool -> Bool -> SAction node children

animateWithTexturesResizeRestore is a shorthand for convenience.

animateWithTexturesResizeRestore :: [Texture] -> TimeInterval -> Bool -> Bool -> SAction node children

animateWithTexturesResizeRestore is a shorthand for convenience.

animateWithNormalTexturesTimePerFrame :: [Texture] -> TimeInterval -> SAction node children

animateWithNormalTextures is a shorthand for convenience.

animateWithNormalTextures :: [Texture] -> TimeInterval -> SAction node children

animateWithNormalTextures is a shorthand for convenience.

animateWithNormalTexturesTimePerFrameResizeRestore :: [Texture] -> TimeInterval -> Bool -> Bool -> SAction node children

animateWithNormalTexturesResizeRestore is a shorthand for convenience.

animateWithNormalTexturesResizeRestore :: [Texture] -> TimeInterval -> Bool -> Bool -> SAction node children

animateWithNormalTexturesResizeRestore is a shorthand for convenience.

colorizeWithColorColorBlendFactor :: Color -> GFloat -> SAction node children

colorizeWithColor is a shorthand for convenience.

colorizeWithColor :: Color -> GFloat -> SAction node children

colorizeWithColor is a shorthand for convenience.

colorizeWithColorBlendFactor :: GFloat -> SAction node children

applyForce :: Vector -> SAction node children

applyTorque :: GFloat -> SAction node children

applyForceAtPoint :: Vector -> Point -> SAction node children

applyImpulse :: Vector -> SAction node children

applyAngularImpulse :: GFloat -> SAction node children

applyImpulseAtPoint :: Vector -> Point -> SAction node children

changeMassTo :: GFloat -> SAction node children

changeMassBy :: GFloat -> SAction node children

playSoundFileNamedWaitForCompletion :: String -> Bool -> SAction node children

playSoundFileName is a shorthand for convenience.

playSoundFileNamed :: String -> Bool -> SAction node children

playSoundFileName is a shorthand for convenience.

removeFromParent :: SAction node children

runActionOnChildWithName :: Action children -> String -> SAction node children

group :: [SAction node children] -> SAction node children

groupActions is to be symmetric with sequenceActions.

groupActions :: [SAction node children] -> SAction node children

groupActions is to be symmetric with sequenceActions.

sequence :: [SAction node children] -> SAction node children

sequenceActions is for convenience in the face of sequence.

sequenceActions :: [SAction node children] -> SAction node children

sequenceActions is for convenience in the face of sequence.

repeatActionCount :: SAction node children -> Int -> SAction node children

repeatActionForever :: SAction node children -> SAction node children

waitForDuration :: SAction node children

waitForDurationWithRange :: TimeInterval -> SAction node children

customAction :: TimedUpdate node -> SAction node children

Perform the given update function once per frame for the given duration. If the duration is 0, the function is only invoked once.

The node on which the action is run is passed to the update function and gets replaced by the updated node.

FIXME: We need to document the tree merging algorithm.

Marshalling support (internal)

newtype SKAction

Constructors

SKAction (ForeignPtr SKAction)

actionToSKAction :: SAction node children -> IO SKAction

data TimedUpdateBox node

Constructors

TimedUpdateBox (TimedUpdate node)

action_initialise :: IO ()

Physics simulation

Representation of a physics simulation for one scene

data PhysicsWorld sceneData nodeData

SpriteKit physics world.

Constructors

PhysicsWorld
Fields worldGravity :: Vector Gravitational acceleration applied to bodies in the physics world (default: '(0.0,-9.8)') worldSpeed :: GFloat Simulation rate as multiple of scene simulation rate (default: '1.0') worldContactDidBegin :: Maybe (PhysicsContactHandler sceneData nodeData) worldContactDidEnd :: Maybe (PhysicsContactHandler sceneData nodeData)

data PhysicsContact nodeData

Information that chracterises the nature of a given contact between two physics bodies.

Constructors

PhysicsContact

Fields

contactBodyA :: Node nodeData: First body in the contact
contactBodyB :: Node nodeData: Second body in the contact
contactPoint :: Point: Contact point between the two associated physics bodies, in scene coordinates
contactCollisionImpulse :: GFloat: Impulse that specifies how hard these two bodies struck each other in newton-seconds
contactNormal :: Vector: Normal vector specifying the direction of the collision

type PhysicsContactHandler sceneData nodeData

Arguments

= sceneData	Current scene data
-> PhysicsContact nodeData	Contact information
-> (Maybe sceneData, Maybe (Node nodeData), Maybe (Node nodeData))

The function invoked when contact between two physics bodies either begins or ends.

This handler function gets access to the current scene user data as well as the two nodes associated with the contacting physics bodies. It can modify the scene user data and/or these two nodes to affect any changes that need to be made to the scene due to the beginning or ending of the contact. Only modified data needs to be returned.

physicsWorld :: PhysicsWorld sceneData nodeData

Marshalling functions (internal)

newtype SKPhysicsWorld

Constructors

SKPhysicsWorld (ForeignPtr SKPhysicsWorld)

newtype SKPhysicsContact

Constructors

SKPhysicsContact (ForeignPtr SKPhysicsContact)

skPhysicsContactToPhysicsContact :: SKPhysicsContact -> PhysicsContact nodeData

physicsWorld_initialise :: IO ()

Representation of the physics properties of a node

data PhysicsBody

Physics bodies are used to add physics simulation to a node.

Constructors

PhysicsBody

Fields

bodyAffectedByGravity :: Bool: Is body affected by gravity and physics fields? (default: True)
bodyAllowsRotation :: Bool: Is body affected by angular forces and impulses? (default: True)
bodyIsDynamic :: Bool: Is body moved by the physics simulation? (default: true)
bodyMassOrDensity :: MassOrDensity: Body mass, directly or indirectly via its density (default: 'Density 1.0')
bodyFriction :: GFloat: Roughness of the body surface between 0 & 1.0 (default: '0.2')
bodyRestitution :: GFloat: Bounciness of the physics body between 0 & 1.0 (default: '0.2')
bodyLinearDamping :: GFloat: Damping of linear velocity; friction between 0 & 1.0 (default: '0.1')
bodyAngularDamping :: GFloat: Damping of rotational velocity; friction between 0 & 1.0 (default: '0.1')
bodyForeign :: IO SKPhysicsBody: Internal Needs to be IO, so that we don't share SKPhysicsBodys
bodyCategoryBitMask :: Word32: Physics entity categories the body belongs to (default: '0xFFFFFFFF')
bodyCollisionBitMask :: Word32: Category of bodies that this body can collide with (default: '0xFFFFFFFF')
bodyContactTestBitMask :: Word32: Category of bodies causing contact notifications (default: '0xFFFFFFFF')
bodyUsesPreciseCollisionDetection :: Bool: Use more expensive check detecting pass throughs (default: False)
bodyForcesAndImpulses :: [ForceImpulse]: Forces and impulses that will be applied to the body (default: '[]')
bodyVelocity :: Vector: Velocity in meters per second
bodyAngularVelocity :: GFloat: Pseudo vector around a unit z-axis vector (in radians per second)
bodyIsResting :: Bool: Is body at rest on another body
bodyIsPinned :: Bool: Physics body’s node is pinned to its parent node (default: False)

data MassOrDensity

How strongly a body is affected by gravity is determined either by giving its mass or by giving its density, in turn determines its mass in combination with the body's area.

Constructors

Mass GFloat
Density GFloat

Instances

Eq MassOrDensity
Show MassOrDensity

data ForceImpulse

Constructors

ApplyForce Vector (Maybe Point)	Applies a force to a specific point or center of gravity of a body
ApplyTorque GFloat	Applies an angular acceleration to a pysics body
ApplyImpulse Vector (Maybe Point)	Applies an impulse to a specific point or center of gravity of a body
ApplyAngularImpulse GFloat	Applies an impulse that imparts angular momentum

Creation of volume-based physics bodies

bodyWithCircleOfRadius

Arguments

:: GFloat	Radius of the circle volume
-> Maybe Point	Optional center (default: centered on owning node’s origin)
-> PhysicsBody

Creates a circular physics body.

bodyWithRectangleOfSize

Arguments

:: Size	Size of the rectangle volume
-> Maybe Point	Optional center (default: centered on owning node’s origin)
-> PhysicsBody

Creates a rectangular physics body.

bodyOfBodies

Arguments

:: [PhysicsBody]	Component bodies
-> PhysicsBody

Creates a physics body by performing a union of a group of volume-based physics bodies.

NB: The argument list may not contain a body constructed by this very function.

bodyWithPolygonFromPath

Arguments

:: Path	Convex polygonal path with counterclockwise winding & no self intersections
-> PhysicsBody

Creates a polygon-shaped physics body.

The points are specified relative to the owning node’s origin.

bodyWithTextureSize

Arguments

:: Texture	Texture to convert into a physics body
-> Maybe GFloat	Optional alpha threshold (default: 0)
-> Size	Size of the physics body to return
-> PhysicsBody

Creates a physics body from the contents of a texture.

The texels in the texture whose alpha values equal or exceed the given alpha threshold are included in the physics body.

Creation of edge-based physics bodies

bodyWithEdgeLoopFromRect

Arguments

:: Rect	Rectangle that defines the edges
-> PhysicsBody

Creates an edge loop from a rectangle.

The rectangle is specified relative to the owning node’s origin.

bodyWithEdgeFromPointToPoint

Arguments

:: Point	Starting point for the edge
-> Point	Ending point for the edge
-> PhysicsBody

Creates an edge between two points.

The points are specified relative to the owning node’s origin.

bodyWithEdgeLoopFromPath

Arguments

:: Path	Path without self intersections
-> PhysicsBody

bodyWithEdgeChainFromPath

Arguments

:: Path	Path without self intersections
-> PhysicsBody

Physics body queries

bodyDensity :: PhysicsBody -> GFloat

Determine a physics body's density. (Marshalling will by default provide the body mass.)

bodyArea :: PhysicsBody -> GFloat

Determine the area covered by a physics body.

Marshalling functions (internal)

newtype SKPhysicsBody

Constructors

SKPhysicsBody (ForeignPtr SKPhysicsBody)

physicsBodyToSKPhysicsBody :: PhysicsBody -> IO SKPhysicsBody

skPhysicsBodyToPhysicsBody :: SKPhysicsBody -> PhysicsBody

physicsBody_initialise :: IO ()

User events

Event information

data Event

Cocoa events.

NB: Not all event types are supported. Usually, because they would require functionality from other parts of Cocoa, which are not supported here (yet).

Constructors

KeyEvent
Fields eventLocationInNode :: !Point Location within the SpriteKit node receiving the event. , eventModifierFlags :: ?? -- ^Modifier keys that were in effect at the time of the event. eventTimestamp :: !TimeInterval Time when the event occured in seconds since system startup. keyEventType :: KeyEvent The specific type of key event. keyEventCharacters :: String Characters associated with receiving key-up or key-down events. keyEventCharactersIgnoringModifiers :: String Ditto, ignoring the effect of modifier keys, except for Shift. keyEventIsARepeat :: !Bool Whether event is a repeat caused by the user holding a key down. keyEventKeyCode :: !Word16 Hardware-independent, virtual keycode.
MouseEvent
Fields eventLocationInNode :: !Point Location within the SpriteKit node receiving the event. , eventModifierFlags :: ?? -- ^Modifier keys that were in effect at the time of the event. eventTimestamp :: !TimeInterval Time when the event occured in seconds since system startup. mouseEventType :: MouseEvent The specific type of mouse event. mouseEventNumber :: !Int Event identifier (increasing counter of mouse events). mouseEventButtonNumber :: !Int Number of the button used in some mouse events. mouseEventClickCount :: !Int Number of mouse clicks for a mouse event mouseEventPressure :: !Float Value from 0 through 1 indicating pressure for some devices.
EnterExitEvent
Fields eventLocationInNode :: !Point Location within the SpriteKit node receiving the event. , eventModifierFlags :: ?? -- ^Modifier keys that were in effect at the time of the event. eventTimestamp :: !TimeInterval Time when the event occured in seconds since system startup. enterExitEventType :: EnterExitEvent The specific type of a tracking-rectangle or cursor-update event. enterExitEventNumber :: !Int Event identifier (increasing counter of mouse events). , enterExitTrackingNumber :: Int , enterExitUserData :: ??
OtherEvent
Fields eventLocationInNode :: !Point Location within the SpriteKit node receiving the event. , eventModifierFlags :: ?? -- ^Modifier keys that were in effect at the time of the event. eventTimestamp :: !TimeInterval Time when the event occured in seconds since system startup. otherEventType :: OtherEvent The specific type of a tracking-rectangle or cursor-update event. , otherEventSubtype :: Int16 , otherEventData1 :: Int , otherEventData2 :: Int

Instances

Show Event

data KeyEvent

Constructors

KeyDown
KeyUp
FlagsChanged

Instances

Eq KeyEvent
Read KeyEvent
Show KeyEvent

data MouseEvent

Constructors

LeftMouseDown
LeftMouseUp
LeftMouseDragged
RightMouseDown
RightMouseUp
RightMouseDragged
OtherMouseDown
OtherMouseUp
OtherMouseDragged
MouseMoved

Instances

Eq MouseEvent
Read MouseEvent
Show MouseEvent

data EnterExitEvent

Constructors

CursorUpdate

FIXME: not yet supported

Instances

Eq EnterExitEvent
Read EnterExitEvent
Show EnterExitEvent

data OtherEvent

Constructors

Periodic

FIXME: not yet supported

Instances

Eq OtherEvent
Read OtherEvent
Show OtherEvent

Marshalling functions (internal)

keyEvent :: Point -> Double -> CLong -> String -> String -> Bool -> Word16 -> Event

mouseEvent :: Point -> Double -> CLong -> Int -> Int -> Int -> Float -> Event

event_initialise :: IO ()

Internal

spritekit_initialise :: IO ()

IsImage DynamicImage
IsImage Image
IsImage (Image Pixel8)
IsImage (Image Pixel16)
IsImage (Image PixelF)
IsImage (Image PixelYA8)
IsImage (Image PixelYA16)
IsImage (Image PixelRGB8)
IsImage (Image PixelRGB16)
IsImage (Image PixelRGBF)
IsImage (Image PixelYCbCr8)
IsImage (Image PixelCMYK8)
IsImage (Image PixelCMYK16)
IsImage (Image PixelRGBA8)
IsImage (Image PixelRGBA16)