Camera

A node representing an orthographic camera.

Press play to preview the animation

                                    
                                        import
                                        
                                        ...
                                        
                                        export
                                        
                                        default
                                        
                                        makeScene2D
                                        (
                                        function
                                        *
                                        
                                        (
                                        view
                                        )
                                        
                                        {
                                        
                                        const
                                         camera 
                                        =
                                        
                                        createRef
                                        <
                                        Camera
                                        >
                                        (
                                        )
                                        ;
                                        
                                        const
                                         rect 
                                        =
                                        
                                        createRef
                                        <
                                        Rect
                                        >
                                        (
                                        )
                                        ;
                                        
                                        const
                                         circle 
                                        =
                                        
                                        createRef
                                        <
                                        Circle
                                        >
                                        (
                                        )
                                        ;
                                        
                                          view
                                        .
                                        add
                                        (
                                        
                                        <
                                        >
                                        
                                        <
                                        Camera
                                        
                                        ref
                                        =
                                        {
                                        camera
                                        }
                                        >
                                        
                                        <
                                        Rect
                                        
                                        ref
                                        =
                                        {
                                        rect
                                        }
                                        
                                        fill
                                        =
                                        {
                                        'lightseagreen'
                                        }
                                        
                                        size
                                        =
                                        {
                                        100
                                        }
                                        
                                        position
                                        =
                                        {
                                        [
                                        100
                                        ,
                                        
                                        -
                                        50
                                        ]
                                        }
                                        
                                        />
                                        
                                        <
                                        Circle
                                        
                                        ref
                                        =
                                        {
                                        circle
                                        }
                                        
                                        fill
                                        =
                                        {
                                        'hotpink'
                                        }
                                        
                                        size
                                        =
                                        {
                                        120
                                        }
                                        
                                        position
                                        =
                                        {
                                        [
                                        -
                                        100
                                        ,
                                        
                                        50
                                        ]
                                        }
                                        
                                        />
                                        
                                        Camera
                                        >
                                        
                                        >
                                        ,
                                        
                                        )
                                        ;
                                        
                                        yield
                                        *
                                        
                                        all
                                        (
                                        
                                        camera
                                        (
                                        )
                                        .
                                        centerOn
                                        (
                                        rect
                                        (
                                        )
                                        ,
                                        
                                        3
                                        )
                                        ,
                                        
                                        camera
                                        (
                                        )
                                        .
                                        rotation
                                        (
                                        180
                                        ,
                                        
                                        3
                                        )
                                        ,
                                        
                                        camera
                                        (
                                        )
                                        .
                                        zoom
                                        (
                                        1.8
                                        ,
                                        
                                        3
                                        )
                                        ,
                                        
                                        )
                                        ;
                                        
                                        yield
                                        *
                                        
                                        camera
                                        (
                                        )
                                        .
                                        centerOn
                                        (
                                        circle
                                        (
                                        )
                                        ,
                                        
                                        2
                                        )
                                        ;
                                        
                                        yield
                                        *
                                        
                                        camera
                                        (
                                        )
                                        .
                                        reset
                                        (
                                        1
                                        )
                                        ;
                                        
                                        }
                                        )
                                        ;

Constructors

`constructor`

                            
                                public 
                                override
                                new
                                Camera
                                
                                      {...}
                                      : 
                                      CameraProps
                                    
                                : 
                                Camera

Parameters

{...} : CameraProps

Overwrites


                          Node.constructor

Properties

`absolutePosition`

                            
                              
                                readonly 
                                public 
                                absolutePosition
                                : 
                                SimpleVector2Signal
                                
                                  
                                    
                                      Camera

A helper signal for operating on the position in world space.

Retrieving the position using this signal returns the position in worldspace. Similarly, setting the position using this signal transforms thenew value to local space.

If the new value is a function, the position of this node will becontinuously updated to always match the position returned by the function.This can be useful to "pin" the node in a specific place or to make itfollow another node's position.

Unlike position , this signal is not compound - it doesn't containseparate signals for the x and y components.

Inherited from


                          Node.absolutePosition

`absoluteRotation`

                            
                                readonly 
                                public 
                                absoluteRotation
                                : 
                                SimpleSignal
                                
                                      number
                                    
                                      Camera

A helper signal for operating on the rotation in world space.

Retrieving the rotation using this signal returns the rotation in worldspace. Similarly, setting the rotation using this signal transforms thenew value to local space.

If the new value is a function, the rotation of this node will becontinuously updated to always match the rotation returned by the function.

Inherited from


                          Node.absoluteRotation

`absoluteScale`

                            
                              
                                readonly 
                                public 
                                absoluteScale
                                : 
                                SimpleVector2Signal
                                
                                  
                                    
                                      Camera

A helper signal for operating on the scale in world space.

Retrieving the scale using this signal returns the scale in world space.Similarly, setting the scale using this signal transforms the new value tolocal space.

If the new value is a function, the scale of this node will be continuouslyupdated to always match the position returned by the function.

Unlike scale , this signal is not compound - it doesn't containseparate signals for the x and y components.

Inherited from


                          Node.absoluteScale

`cache`

                            
                                readonly 
                                public 
                                cache
                                : 
                                SimpleSignal
                                
                                      boolean
                                    
                                      Camera

Inherited from


                          Node.cache

`cachePadding`

                            
                              
                                readonly 
                                public 
                                cachePadding
                                : 
                                SpacingSignal
                                
                                  
                                    
                                      Camera

Controls the padding of the cached canvas used by this node.

By default, the size of the cache is determined based on the bounding boxof the node and its children. That includes effects such as stroke orshadow. This property can be used to expand the cache area further.Usually used to account for custom effects created by shaders .

Inherited from


                          Node.cachePadding

`children`

                            
                              
                                readonly 
                                public 
                                children
                                : 
                                Signal
                                
                                  
                                    
                                      ComponentChildren
                                    
                                    
                                      Node
                                      []
                                    
                                    
                                      Camera
                                    
                                    
                                      SignalContext
                                      
                                        
                                          
                                            ComponentChildren
                                          
                                          
                                            Node
                                            []
                                          
                                          
                                            Camera

Inherited from


                          Node.children

`composite`

                            
                                readonly 
                                public 
                                composite
                                : 
                                SimpleSignal
                                
                                      boolean
                                    
                                      Camera

Inherited from


                          Node.composite

`compositeOperation`

                            
                                readonly 
                                public 
                                compositeOperation
                                : 
                                SimpleSignal
                                
                                      GlobalCompositeOperation
                                    
                                      Camera

Inherited from


                          Node.compositeOperation

`creationStack`

                            
                                readonly 
                                public 
                                creationStack
                                ?: 
                                string

Inherited from


                          Node.creationStack

`filters`

                            
                              
                                readonly 
                                public 
                                filters
                                : 
                                FiltersSignal
                                
                                  
                                    
                                      Camera

Inherited from


                          Node.filters

`isClass`

Inherited from


                          Node.isClass

`key`

Inherited from


                          Node.key

`opacity`

                            
                                readonly 
                                public 
                                opacity
                                : 
                                SimpleSignal
                                
                                      number
                                    
                                      Camera

Represents the opacity of this node in the range 0-1.

The value is clamped to the range 0-1.

Inherited from


                          Node.opacity

`parent`

                            
                                readonly 
                                public 
                                parent
                                : 
                                SimpleSignal
                                
                                            null
                                          
                                            Node
                                          
                                      void
                                    
                                 = 
                                ...

Inherited from


                          Node.parent

`position`

                            
                              
                                readonly 
                                public 
                                position
                                : 
                                Vector2Signal
                                
                                  
                                    
                                      Camera
                                    
                                    
                                      Vector2SignalContext
                                      
                                        
                                          
                                            Camera

Represents the position of this node in local space of its parent.

Examples

Inherited from


                          Node.position

`properties`

                            
                                readonly 
                                public 
                                properties
                                : 
                                Record
                                
                                      string
                                    
                                      PropertyMetadata
                                      
                                            any
                                          
                                 = 
                                ...

Inherited from


                          Node.properties

`rotation`

                            
                                readonly 
                                public 
                                rotation
                                : 
                                SimpleSignal
                                
                                      number
                                    
                                      Camera

Represents the rotation (in degrees) of this node relative to its parent.

Inherited from


                          Node.rotation

`scale`

                            
                              
                                readonly 
                                public 
                                scale
                                : 
                                Vector2Signal
                                
                                  
                                    
                                      Camera
                                    
                                    
                                      Vector2SignalContext
                                      
                                        
                                          
                                            Camera

Represents the scale of this node in local space of its parent.

Examples

Inherited from


                          Node.scale

`scene`

                            
                              
                                readonly 
                                public 
                                scene
                                : 
                                SimpleSignal
                                
                                  
                                    
                                      Node
                                    
                                    
                                      Camera

The scene node that the camera is rendering.

`shaders`

                            
                                readonly 
                                public 
                                shaders
                                : 
                                Signal
                                
                                      PossibleShaderConfig
                                    
                                      ShaderConfig
                                      []
                                    
                                      Camera
                                    
                                      SignalContext
                                      
                                            PossibleShaderConfig
                                          
                                            ShaderConfig
                                            []
                                          
                                            Camera

Experimental

This is an experimental feature . The behavior and API may change drastically between minor releases.

Inherited from


                          Node.shaders

`shadowBlur`

                            
                                readonly 
                                public 
                                shadowBlur
                                : 
                                SimpleSignal
                                
                                      number
                                    
                                      Camera

Inherited from


                          Node.shadowBlur

`shadowColor`

                            
                              
                                readonly 
                                public 
                                shadowColor
                                : 
                                ColorSignal
                                
                                  
                                    
                                      Camera

Inherited from


                          Node.shadowColor

`shadowOffset`

                            
                              
                                readonly 
                                public 
                                shadowOffset
                                : 
                                Vector2Signal
                                
                                  
                                    
                                      Camera
                                    
                                    
                                      Vector2SignalContext
                                      
                                        
                                          
                                            Camera

Inherited from


                          Node.shadowOffset

`skew`

                            
                              
                                readonly 
                                public 
                                skew
                                : 
                                Vector2Signal
                                
                                  
                                    
                                      Camera
                                    
                                    
                                      Vector2SignalContext
                                      
                                        
                                          
                                            Camera

Represents the skew of this node in local space of its parent.

Examples

Inherited from


                          Node.skew

`zIndex`

                            
                                readonly 
                                public 
                                zIndex
                                : 
                                SimpleSignal
                                
                                      number
                                    
                                      Camera

Inherited from


                          Node.zIndex

`zoom`

                            
                                readonly 
                                public 
                                zoom
                                : 
                                SimpleSignal
                                
                                      number
                                    
                                      Camera

The zoom level of the camera.

Default Value: 1

Accessors

`x`

                            
                                public 
                                get 
                                x
                                (): 
                                SimpleSignal
                                
                                      number
                                    
                                      this

Inherited from


                          Node.x

`y`

                            
                                public 
                                get 
                                y
                                (): 
                                SimpleSignal
                                
                                      number
                                    
                                      this

Inherited from


                          Node.y

Methods

`[iterator]`

                            
                                public 
                                [iterator]
                                (): 
                                Generator
                                
                                            key
                                            : 
                                            string
                                          
                                            meta
                                            : 
                                            PropertyMetadata
                                            
                                                  any
                                                
                                            signal
                                            : 
                                            SimpleSignal
                                            
                                                  any
                                                
                                                  void
                                                
                                      void
                                    
                                      unknown

Inherited from


                          Node.[iterator]

`absoluteOpacity`

                            
                                public 
                                absoluteOpacity
                                (): 
                                number

Inherited from


                          Node.absoluteOpacity

`add`

                            
                              
                                public 
                                add
                                
                                  
                                    
                                      node
                                      : 
                                      ComponentChildren
                                    
                                  
                                
                                : 
                                Camera

Add the given node(s) as the children of this node.

The nodes will be appended at the end of the children list.

Examples

Parameters

node : ComponentChildren
A node or an array of nodes to append.

Inherited from


                          Node.add

`applyState`

                            
                                public 
                                applyState
                                
                                      state
                                      : 
                                      NodeState
                                    
                                : 
                                void
                              
                                public 
                                applyState
                                
                                      state
                                      : 
                                      NodeState
                                    
                                      duration
                                      : 
                                      number
                                    
                                      timing
                                      ?: 
                                      TimingFunction
                                    
                                : 
                                ThreadGenerator

Apply the given state to the node, setting all matching signal values tothe provided values.

Parameters

state : NodeState
The state to apply to the node.

Inherited from


                          Node.applyState

`cacheBBox`

Get a bounding box for the contents rendered by this node as wellas its children.

Inherited from


                          Node.cacheBBox

`centerOn`

                            
                                public 
                                centerOn
                                
                                      position
                                      : 
                                      PossibleVector2
                                      
                                            number
                                          
                                      duration
                                      : 
                                      number
                                    
                                      timingFunction
                                      ?: 
                                      TimingFunction
                                    
                                      interpolationFunction
                                      ?: 
                                      InterpolationFunction
                                      
                                            Vector2
                                          
                                            any
                                            []
                                          
                                : 
                                ThreadGenerator
                              
                                public 
                                centerOn
                                
                                      node
                                      : 
                                      Node
                                    
                                      duration
                                      : 
                                      number
                                    
                                      timingFunction
                                      ?: 
                                      TimingFunction
                                    
                                      interpolationFunction
                                      ?: 
                                      InterpolationFunction
                                      
                                            Vector2
                                          
                                            any
                                            []
                                          
                                : 
                                ThreadGenerator

Centers the camera on the specified position without changing the zoomlevel.

Parameters

position : PossibleVector2 number
The position to center the camera on.
duration : number
The duration of the tween.
timingFunction ?: TimingFunction
The timing function to use for the tween.
interpolationFunction ?: InterpolationFunction Vector2 any []
The interpolation function to use for thetween.

`childAs`

Get the nth children cast to the specified type.

Type Parameters

T extends Node T = Node

Parameters

index : number
The index of the child to retrieve.

Inherited from


                          Node.childAs

`childrenAs`

Get the children array cast to the specified type.

Type Parameters

T extends Node T = Node

Inherited from


                          Node.childrenAs

`clone`

                            
                                public 
                                clone
                                
                                      customProps
                                      : 
                                      NodeState
                                       = 
                                      {}
                                    
                                : 
                                Camera

Create a copy of this node.

Parameters

customProps : NodeState = {}
Properties to override.

Inherited from


                          Node.clone

`compositeToLocal`

                            
                              
                                public 
                                compositeToLocal
                                (): 
                                DOMMatrix

Inherited from


                          Node.compositeToLocal

`compositeToWorld`

                            
                              
                                public 
                                compositeToWorld
                                (): 
                                DOMMatrix

A matrix mapping composite space to world space.

Certain effects such as blur and shadows ignore the current transformation.This matrix can be used to transform their parameters so that the effectappears relative to the closest composite root.

Inherited from


                          Node.compositeToWorld

`dispose`

Prepare this node to be disposed of.

This method is called automatically when a scene is refreshed. It willbe called even if the node is not currently attached to the tree.

The goal of this method is to clean any external references to allow thenode to be garbage collected.

Inherited from


                          Node.dispose

`drawOverlay`

                            
                                public 
                                drawOverlay
                                
                                      context
                                      : 
                                      CanvasRenderingContext2D
                                    
                                      matrix
                                      : 
                                      DOMMatrix
                                    
                                : 
                                void

Draw an overlay for this node.

The overlay for the currently inspected node is displayed on top of thecanvas.

The provided context is in screen space. The local-to-screen matrix can beused to transform all shapes that need to be displayed.This approach allows to keep the line widths and gizmo sizes consistent,no matter how zoomed-in the view is.

Parameters

context : CanvasRenderingContext2D
The context to draw with.
matrix : DOMMatrix
A local-to-screen matrix.

Inherited from


                          Node.drawOverlay

`findAll`

Find all descendants of this node that match the given predicate.

Type Parameters

T extends Node T

Parameters

predicate : node : any => node is T
A function that returns true if the node matches.

Inherited from


                          Node.findAll

`findAncestor`

                            
                                public 
                                findAncestor
                                
                                      T
                                       extends 
                                      Node
                                      
                                            T
                                          
                                      predicate
                                      : 
                                      
                                            node
                                            : 
                                            Node
                                          
                                       => 
                                      node 
                                      is 
                                      T
                                    
                                : 
                                
                                      null
                                    
                                      T
                                    
                                public 
                                findAncestor
                                
                                      T
                                       extends 
                                      Node
                                      
                                            T
                                          
                                       = 
                                      Node
                                    
                                      predicate
                                      : 
                                      
                                            node
                                            : 
                                            Node
                                          
                                       => 
                                      boolean
                                    
                                : 
                                
                                      null
                                    
                                      T

Find the closest ancestor of this node that matches the given predicate.

Type Parameters

T extends Node T

Parameters

predicate : node : Node => node is T
A function that returns true if the node matches.

Inherited from


                          Node.findAncestor

`findFirst`

Find the first descendant of this node that matches the given predicate.

Type Parameters

T extends Node T

Parameters

predicate : node : Node => node is T
A function that returns true if the node matches.

Inherited from


                          Node.findFirst

`findLast`

Find the last descendant of this node that matches the given predicate.

Type Parameters

T extends Node T

Parameters

predicate : node : Node => node is T
A function that returns true if the node matches.

Inherited from


                          Node.findLast

`followCurve`

                            
                                public 
                                followCurve
                                
                                      curve
                                      : 
                                      Curve
                                    
                                      duration
                                      : 
                                      number
                                    
                                      timing
                                      : 
                                      TimingFunction
                                       = 
                                      easeInOutCubic
                                    
                                : 
                                ThreadGenerator

Makes the camera follow a path specified by the provided curve.

This will not change the orientation of the camera. To make the cameraorient itself along the curve, use followCurveWithRotation or followCurveWithRotationReverse .

If you want to follow the curve in reverse, use followCurveReverse .

Parameters

curve : Curve
The curve to follow.
duration : number
The duration of the tween.
timing : TimingFunction = easeInOutCubic
The timing function to use for the tween.

`followCurveReverse`

                            
                                public 
                                followCurveReverse
                                
                                      curve
                                      : 
                                      Curve
                                    
                                      duration
                                      : 
                                      number
                                    
                                      timing
                                      : 
                                      TimingFunction
                                       = 
                                      easeInOutCubic
                                    
                                : 
                                Generator
                                
                                            void
                                          
                                            ThreadGenerator
                                          
                                            Promise
                                            
                                                  any
                                                
                                            Promisable
                                            
                                                  any
                                                
                                      void
                                    
                                      any

Makes the camera follow a path specified by the provided curve in reverse.

This will not change the orientation of the camera. To make the cameraorient itself along the curve, use followCurveWithRotation or followCurveWithRotationReverse .

If you want to follow the curve forward, use followCurve .

Parameters

curve : Curve
The curve to follow.
duration : number
The duration of the tween.
timing : TimingFunction = easeInOutCubic
The timing function to use for the tween.

`followCurveWithRotation`

                            
                                public 
                                followCurveWithRotation
                                
                                      curve
                                      : 
                                      Curve
                                    
                                      duration
                                      : 
                                      number
                                    
                                      timing
                                      : 
                                      TimingFunction
                                       = 
                                      easeInOutCubic
                                    
                                : 
                                Generator
                                
                                            void
                                          
                                            ThreadGenerator
                                          
                                            Promise
                                            
                                                  any
                                                
                                            Promisable
                                            
                                                  any
                                                
                                      void
                                    
                                      any

Makes the camera follow a path specified by the provided curve whilepointing the camera the direction of the tangent.

To make the camera follow the curve without changing its orientation, use followCurve or followCurveReverse .

If you want to follow the curve in reverse, use followCurveWithRotationReverse .

Parameters

curve : Curve
The curve to follow.
duration : number
The duration of the tween.
timing : TimingFunction = easeInOutCubic
The timing function to use for the tween.

`followCurveWithRotationReverse`

                            
                                public 
                                followCurveWithRotationReverse
                                
                                      curve
                                      : 
                                      Curve
                                    
                                      duration
                                      : 
                                      number
                                    
                                      timing
                                      : 
                                      TimingFunction
                                       = 
                                      easeInOutCubic
                                    
                                : 
                                Generator
                                
                                            void
                                          
                                            ThreadGenerator
                                          
                                            Promise
                                            
                                                  any
                                                
                                            Promisable
                                            
                                                  any
                                                
                                      void
                                    
                                      any

Makes the camera follow a path specified by the provided curve in reversewhile pointing the camera the direction of the tangent.

To make the camera follow the curve without changing its orientation, use followCurve or followCurveReverse .

If you want to follow the curve forward, use followCurveWithRotation .

Parameters

curve : Curve
The curve to follow.
duration : number
The duration of the tween.
timing : TimingFunction = easeInOutCubic
The timing function to use for the tween.

`getState`

Return a snapshot of the node's current signal values.

This method will calculate the values of any reactive properties of thenode at the time the method is called.

Inherited from


                          Node.getState

`hit`

Try to find a node intersecting the given position.

Parameters

position : Vector2
The searched position.

Overwrites


                          Node.hit

`insert`

                            
                                public 
                                insert
                                
                                      node
                                      : 
                                      ComponentChildren
                                    
                                      index
                                      : 
                                      number
                                       = 
                                      0
                                    
                                : 
                                Camera

Insert the given node(s) at the specified index in the children list.

Examples

Parameters

node : ComponentChildren
A node or an array of nodes to insert.
index : number = 0
An index at which to insert the node(s).

Inherited from


                          Node.insert

`instantiate`

                            
                                public 
                                instantiate
                                
                                      props
                                      : 
                                      NodeProps
                                       = 
                                      {}
                                    
                                : 
                                Camera

Create an instance of this node's class.

Parameters

props : NodeProps = {}
Properties to pass to the constructor.

Inherited from


                          Node.instantiate

`localToParent`

                            
                              
                                public 
                                localToParent
                                (): 
                                DOMMatrix

Get the local-to-parent matrix for this node.

This matrix transforms vectors from local space of this node to local spaceof this node's parent.

Inherited from


                          Node.localToParent

`localToWorld`

                            
                              
                                public 
                                localToWorld
                                (): 
                                DOMMatrix

Get the local-to-world matrix for this node.

This matrix transforms vectors from local space of this node to worldspace.

Examples

Inherited from


                          Node.localToWorld

`move`

Rearrange this node in relation to its siblings.

Children are rendered starting from the beginning of the children list.We can change the rendering order by rearranging said list.

A positive by arguments move the node up (it will be rendered on top ofthe elements it has passed). Negative values move it down.

Parameters

by : number = 1
Number of places by which the node should be moved.

Inherited from


                          Node.move

`moveAbove`

                            
                                public 
                                moveAbove
                                
                                      node
                                      : 
                                      Node
                                    
                                      directlyAbove
                                      : 
                                      boolean
                                       = 
                                      false
                                    
                                : 
                                Camera

Move the node above the provided node in the parent's layout.

The node will be moved above the provided node and from then on will berendered on top of it. By default, if the node is already positionedhigher than the sibling node, it will not get moved.

Parameters

node : Node
The sibling node below which to move.
directlyAbove : boolean = false
Whether the node should be positioned directly above thesibling. When true, will move the node even if it isalready positioned above the sibling.

Inherited from


                          Node.moveAbove

`moveBelow`

                            
                                public 
                                moveBelow
                                
                                      node
                                      : 
                                      Node
                                    
                                      directlyBelow
                                      : 
                                      boolean
                                       = 
                                      false
                                    
                                : 
                                Camera

Move the node below the provided node in the parent's layout.

The node will be moved below the provided node and from then on will berendered below it. By default, if the node is already positioned lower thanthe sibling node, it will not get moved.

Parameters

node : Node
The sibling node below which to move.
directlyBelow : boolean = false
Whether the node should be positioned directly belowthe sibling. When true, will move the node even ifit is already positioned below the sibling.

Inherited from


                          Node.moveBelow

`moveDown`

Move the node down in relation to its siblings.

The node will exchange places with the sibling right below it (if any) andfrom then on will be rendered under it.

Inherited from


                          Node.moveDown

`moveTo`

Move the node to the provided position relative to its siblings.

If the node is getting moved to a lower position, it will be placed belowthe sibling that's currently at the provided index (if any).If the node is getting moved to a higher position, it will be placed abovethe sibling that's currently at the provided index (if any).

Parameters

index : number
The index to move the node to.

Inherited from


                          Node.moveTo

`moveToBottom`

                            
                                public 
                                moveToBottom
                                (): 
                                Camera

Move the node to the bottom in relation to its siblings.

The node will be placed at the beginning of the children list and from thenon will be rendered below all of its siblings.

Inherited from


                          Node.moveToBottom

`moveToTop`

Move the node to the top in relation to its siblings.

The node will be placed at the end of the children list and from then onwill be rendered on top of all of its siblings.

Inherited from


                          Node.moveToTop

`moveUp`

Move the node up in relation to its siblings.

The node will exchange places with the sibling right above it (if any) andfrom then on will be rendered on top of it.

Inherited from


                          Node.moveUp

`parentAs`

Get the parent cast to the specified type.

Type Parameters

T extends Node T = Node

Inherited from


                          Node.parentAs

`parentToWorld`

                            
                              
                                public 
                                parentToWorld
                                (): 
                                DOMMatrix

Get the parent-to-world matrix for this node.

This matrix transforms vectors from local space of this node's parent toworld space.

Inherited from


                          Node.parentToWorld

`peekChildren`

                            
                                public 
                                peekChildren
                                (): 
                                readonly 
                                Node
                                []

Get the current children of this node.

Unlike children , this method does not have any side effects.It does not register the children signal as a dependency, and it does notspawn any children. It can be used to safely retrieve the current state ofthe scene graph for debugging purposes.

Inherited from


                          Node.peekChildren

`reactiveClone`

                            
                                public 
                                reactiveClone
                                
                                      customProps
                                      : 
                                      NodeState
                                       = 
                                      {}
                                    
                                : 
                                Camera

Create a reactive copy of this node.

A reactive copy has all its properties dynamically updated to match thesource node.

Parameters

customProps : NodeState = {}
Properties to override.

Inherited from


                          Node.reactiveClone

`remove`

Remove this node from the tree.

Inherited from


                          Node.remove

`removeChildren`

                            
                                public 
                                removeChildren
                                (): 
                                Camera

Remove all children of this node.

Inherited from


                          Node.removeChildren

`render`

                            
                                public 
                                render
                                
                                      context
                                      : 
                                      CanvasRenderingContext2D
                                    
                                : 
                                void

Render this node onto the given canvas.

Parameters

context : CanvasRenderingContext2D
The context to draw with.

Inherited from


                          Node.render

`reparent`

Change the parent of this node while keeping the absolute transform.

After performing this operation, the node will stay in the same placevisually, but its parent will be changed.

Parameters

newParent : Node
The new parent of this node.

Inherited from


                          Node.reparent

`reset`

                            
                                public 
                                reset
                                
                                      duration
                                      : 
                                      number
                                    
                                      timingFunction
                                      : 
                                      TimingFunction
                                       = 
                                      easeInOutCubic
                                    
                                : 
                                ThreadGenerator

Resets the camera's position, rotation and zoom level to their originalvalues.

Parameters

duration : number
The duration of the tween.
timingFunction : TimingFunction = easeInOutCubic
The timing function to use for the tween.

`restore`

                            
                                public 
                                restore
                                (): 
                                void
                              
                                public 
                                restore
                                
                                      duration
                                      : 
                                      number
                                    
                                      timing
                                      ?: 
                                      TimingFunction
                                    
                                : 
                                ThreadGenerator

Restore the node to its last saved state.

This method can be used together with the save method to restore anode to a previously saved state. Restoring a node to a previous stateremoves that state from the state stack.

Examples

Inherited from


                          Node.restore

`save`

Push a snapshot of the node's current state onto the node's state stack.

This method can be used together with the restore method to save anode's current state and later restore it. It is possible to store morethan one state by calling save method multiple times.

Inherited from


                          Node.save

`snapshotClone`

                            
                                public 
                                snapshotClone
                                
                                      customProps
                                      : 
                                      NodeState
                                       = 
                                      {}
                                    
                                : 
                                Camera

Create a copy of this node.

Unlike clone , a snapshot clone calculates any reactive propertiesat the moment of cloning and passes the raw values to the copy.

Parameters

customProps : NodeState = {}
Properties to override.

Inherited from


                          Node.snapshotClone

`toPromise`

Wait for any asynchronous resources that this node or its children have.

Certain resources like images are always loaded asynchronously.Awaiting this method makes sure that all such resources are done loadingbefore continuing the animation.

Inherited from


                          Node.toPromise

`view`

Inherited from


                          Node.view

`worldToLocal`

                            
                              
                                public 
                                worldToLocal
                                (): 
                                DOMMatrix

Get the world-to-local matrix for this node.

This matrix transforms vectors from world space to local space of thisnode.

Examples

Inherited from


                          Node.worldToLocal

`worldToParent`

                            
                              
                                public 
                                worldToParent
                                (): 
                                DOMMatrix

Get the world-to-parent matrix for this node.

This matrix transforms vectors from world space to local space of thisnode's parent.

Inherited from


                          Node.worldToParent

`Stage`

Parameters

{...} : RectProps cameraRef ?: Reference Camera scene ?: Node

Constructors
- constructor
Properties
Accessors
- x
- y
Methods

Constructors ​

constructor ​

Parameters

Properties ​

absolutePosition ​

absoluteRotation ​

absoluteScale ​

cache ​

cachePadding ​

children ​

composite ​

compositeOperation ​

creationStack ​

filters ​

isClass ​

key ​

opacity ​

parent ​

position ​

properties ​

rotation ​

scale ​

scene ​

shaders ​

shadowBlur ​

shadowColor ​

shadowOffset ​

skew ​

zIndex ​

zoom ​

Accessors ​

x ​

y ​

Methods ​

[iterator] ​

absoluteOpacity ​

add ​

Parameters

applyState ​

Parameters

cacheBBox ​

centerOn ​

Parameters

childAs ​

Type Parameters

Parameters

childrenAs ​

Type Parameters

clone ​

Parameters

compositeToLocal ​

compositeToWorld ​

dispose ​

drawOverlay ​

Parameters

findAll ​

Type Parameters

Parameters

findAncestor ​

Type Parameters

Parameters

findFirst ​

Type Parameters

Parameters

findLast ​

Type Parameters

Parameters

followCurve ​

Parameters

followCurveReverse ​

Parameters

followCurveWithRotation ​

Parameters

followCurveWithRotationReverse ​

Parameters

getState ​

hit ​

Parameters

insert ​

Parameters

Constructors

`constructor`

Properties

`absolutePosition`

`absoluteRotation`

`absoluteScale`

`cache`

`cachePadding`

`children`

`composite`

`compositeOperation`

`creationStack`

`filters`

`isClass`

`key`

`opacity`

`parent`

`position`

`properties`

`rotation`

`scale`

`scene`

`shaders`

`shadowBlur`

`shadowColor`

`shadowOffset`

`skew`

`zIndex`

`zoom`

Accessors

`x`

`y`

Methods

`[iterator]`

`absoluteOpacity`

`add`

`applyState`

`cacheBBox`

`centerOn`

`childAs`

`childrenAs`

`clone`

`compositeToLocal`

`compositeToWorld`

`dispose`

`drawOverlay`

`findAll`

`findAncestor`

`findFirst`

`findLast`

`followCurve`

`followCurveReverse`

`followCurveWithRotation`

`followCurveWithRotationReverse`

`getState`

`hit`

`insert`

`instantiate`

`localToParent`

`localToWorld`

`move`

`moveAbove`

`moveBelow`

`moveDown`

`moveTo`

`moveToBottom`

`moveToTop`

`moveUp`

`parentAs`

`parentToWorld`

`peekChildren`

`reactiveClone`

`remove`

`removeChildren`

`render`

`reparent`

`reset`

`restore`

`save`

`snapshotClone`