Interface INode<SC>

A visual Node in the Renderer scene graph.

Remarks

A Node is a basic building block of the Renderer scene graph. It can be a container for other Nodes, or it can be a leaf Node that renders a solid color, gradient, image, or specific texture, using a specific shader.

For text rendering Nodes, see ITextNode.

INode vs CoreNode

CoreNode is the name of the class for a Renderer Node and is only directly used internally by the Renderer. INode describes the public API of a Renderer Node including the ability to be tied to a specific Shader.

Users of the Renderer API, should generally interact with INode objects instead of CoreNode objects.

interface INode<SC> {
    absX: number;
    absY: number;
    alpha: number;
    autosize: boolean;
    calcZIndex: number;
    children: CoreNode[];
    childUpdateType: UpdateType;
    clipping: boolean;
    clippingRect: RectWithValid;
    color: number;
    colorBl: number;
    colorBottom: number;
    colorBr: number;
    colorLeft: number;
    colorRight: number;
    colorTl: number;
    colorTop: number;
    colorTr: number;
    data: undefined | CustomDataMap;
    framebufferDimensions: Dimensions;
    globalTransform?: Matrix3d;
    hasRTTupdates: boolean;
    height: number;
    id: number;
    imageType:
        | null
        | "svg"
        | "regular"
        | "compressed";
    isRenderable: boolean;
    localTransform?: Matrix3d;
    mount: number;
    mountX: number;
    mountY: number;
    parent: null | INode<BaseShaderController>;
    parentHasRenderTexture: boolean;
    parentRenderTexture: null | CoreNode;
    pivot: number;
    pivotX: number;
    pivotY: number;
    preloadBound?: Bound;
    premultipliedColorBl: number;
    premultipliedColorBr: number;
    premultipliedColorTl: number;
    premultipliedColorTr: number;
    preventCleanup: boolean;
    props: CoreNodeProps;
    renderBound?: Bound;
    renderCoords?: RenderCoords;
    renderState: CoreNodeRenderState;
    rotation: number;
    rtt: boolean;
    rttParent: null | CoreNode;
    scale: number;
    scaleRotateTransform?: Matrix3d;
    scaleX: number;
    scaleY: number;
    shader: SC;
    src: null | string;
    srcHeight: undefined | number;
    srcWidth: undefined | number;
    srcX: undefined | number;
    srcY: undefined | number;
    stage: Stage;
    strictBound?: Bound;
    strictBounds: boolean;
    texture: null | Texture;
    textureOptions: TextureOptions;
    updateType: UpdateType;
    width: number;
    worldAlpha: number;
    x: number;
    y: number;
    zIndex: number;
    zIndexLocked: number;
    animate(props: Partial<INodeAnimateProps<SC>>, settings: Partial<AnimationSettings>): IAnimationController;
    autosizeNode(dimensions: Dimensions): void;
    calculateClippingRect(parentClippingRect: RectWithValid): void;
    calculateRenderCoords(): void;
    calculateZIndex(): void;
    checkBasicRenderability(): boolean;
    checkRenderBounds(): CoreNodeRenderState;
    createRenderBounds(): void;
    destroy(): void;
    emit(event: string, data?: any): void;
    flush(): void;
    hasColorProperties(): boolean;
    hasDimensions(): boolean;
    hasShader(): boolean;
    isOutOfBounds(): boolean;
    loadTexture(): void;
    off(event: string, listener?: ((target: any, data: any) => void)): void;
    on(event: string, listener: ((target: any, data: any) => void)): void;
    once(event: string, listener: ((target: any, data: any) => void)): void;
    removeAllListeners(): void;
    renderQuads(renderer: CoreRenderer): void;
    setRenderable(isRenderable: boolean): void;
    setUpdateType(type: UpdateType): void;
    sortChildren(): void;
    unloadTexture(): void;
    update(delta: number, parentClippingRect: RectWithValid): void;
    updateBoundingRect(): void;
    updateIsRenderable(): void;
    updateLocalTransform(): void;
    updateRenderState(renderState: CoreNodeRenderState): void;
    updateScaleRotateTransform(): void;
    updateTextureOwnership(isRenderable: boolean): void;
}

Type Parameters

Hierarchy

  • Omit<CoreNode, "shader" | "animate" | "parent">
    • INode

Properties

absX absY alpha autosize calcZIndex children childUpdateType clipping clippingRect color colorBl colorBottom colorBr colorLeft colorRight colorTl colorTop colorTr data framebufferDimensions globalTransform? hasRTTupdates height id imageType isRenderable localTransform? mount mountX mountY parent parentHasRenderTexture parentRenderTexture pivot pivotX pivotY preloadBound? premultipliedColorBl premultipliedColorBr premultipliedColorTl premultipliedColorTr preventCleanup props renderBound? renderCoords? renderState rotation rtt rttParent scale scaleRotateTransform? scaleX scaleY shader src srcHeight srcWidth srcX srcY stage strictBound? strictBounds texture textureOptions updateType width worldAlpha x y zIndex zIndexLocked

Methods

animate autosizeNode calculateClippingRect calculateRenderCoords calculateZIndex checkBasicRenderability checkRenderBounds createRenderBounds destroy emit flush hasColorProperties hasDimensions hasShader isOutOfBounds loadTexture off on once removeAllListeners renderQuads setRenderable setUpdateType sortChildren unloadTexture update updateBoundingRect updateIsRenderable updateLocalTransform updateRenderState updateScaleRotateTransform updateTextureOwnership

Properties

absX

absX: number

absY

absY: number

alpha

alpha: number

autosize

autosize: boolean

calcZIndex

calcZIndex: number = 0

Readonlychildren

children: CoreNode[] = []

childUpdateType

childUpdateType: UpdateType = UpdateType.None

clipping

clipping: boolean

clippingRect

clippingRect: RectWithValid = ...

color

color: number

colorBl

colorBl: number

colorBottom

colorBottom: number

colorBr

colorBr: number

colorLeft

colorLeft: number

colorRight

colorRight: number

colorTl

colorTl: number

colorTop

colorTop: number

colorTr

colorTr: number

data

data: undefined | CustomDataMap

framebufferDimensions

framebufferDimensions: Dimensions

OptionalglobalTransform

globalTransform?: Matrix3d

hasRTTupdates

hasRTTupdates: boolean = false

height

height: number

id

id: number

imageType

imageType:
    | null
    | "svg"
    | "regular"
    | "compressed"

isRenderable

isRenderable: boolean = false

OptionallocalTransform

localTransform?: Matrix3d

mount

mount: number

mountX

mountX: number

mountY

mountY: number

parent

parent: null | INode<BaseShaderController>

parentHasRenderTexture

parentHasRenderTexture: boolean = false

parentRenderTexture

parentRenderTexture: null | CoreNode

pivot

pivot: number

pivotX

pivotX: number

pivotY

pivotY: number

OptionalpreloadBound

preloadBound?: Bound

premultipliedColorBl

premultipliedColorBl: number = 0

premultipliedColorBr

premultipliedColorBr: number = 0

premultipliedColorTl

premultipliedColorTl: number = 0

premultipliedColorTr

premultipliedColorTr: number = 0

preventCleanup

preventCleanup: boolean

Readonlyprops

props: CoreNodeProps

OptionalrenderBound

renderBound?: Bound

OptionalrenderCoords

renderCoords?: RenderCoords

renderState

renderState: CoreNodeRenderState = CoreNodeRenderState.Init

rotation

rotation: number

rtt

rtt: boolean

rttParent

rttParent: null | CoreNode = null

scale

scale: number

OptionalscaleRotateTransform

scaleRotateTransform?: Matrix3d

scaleX

scaleX: number

scaleY

scaleY: number

shader

shader: SC

src

src: null | string

srcHeight

srcHeight: undefined | number

srcWidth

srcWidth: undefined | number

srcX

srcX: undefined | number

srcY

srcY: undefined | number

Readonlystage

stage: Stage

OptionalstrictBound

strictBound?: Bound

strictBounds

strictBounds: boolean

texture

texture: null | Texture

textureOptions

textureOptions: TextureOptions

updateType

updateType: UpdateType = UpdateType.All

width

width: number

worldAlpha

worldAlpha: number = 1

x

x: number

y

y: number

zIndex

zIndex: number

zIndexLocked

zIndexLocked: number

Methods

animate

autosizeNode

calculateClippingRect

  • calculateClippingRect(parentClippingRect): void

  • This function calculates the clipping rectangle for a node.

    The function then checks if the node is rotated. If the node requires clipping and is not rotated, a new clipping rectangle is created based on the node's global transform and dimensions. If a parent clipping rectangle exists, it is intersected with the node's clipping rectangle (if it exists), or replaces the node's clipping rectangle.

    Finally, the node's parentClippingRect and clippingRect properties are updated.

    Parameters

    • parentClippingRect: RectWithValid

    Returns void

calculateRenderCoords

calculateZIndex

checkBasicRenderability

  • checkBasicRenderability(): boolean

  • Checks if the node is renderable based on world alpha, dimensions and out of bounds status.

    Returns boolean

checkRenderBounds

createRenderBounds

destroy

  • destroy(): void

  • Destroy the node and cleanup all resources

    Returns void

emit

flush

hasColorProperties

  • hasColorProperties(): boolean

  • Checks if the node has any color properties set.

    Returns boolean

hasDimensions

  • hasDimensions(): boolean

  • Checks if the node has dimensions (width/height)

    Returns boolean

hasShader

isOutOfBounds

  • isOutOfBounds(): boolean

  • Checks if the node is out of the viewport bounds.

    Returns boolean

loadTexture

off

  • off(event, listener?): void

  • Parameters

    • event: string
    • Optionallistener: ((target: any, data: any) => void)
        • (target, data): void

        • Parameters

          • target: any
          • data: any

          Returns void

    Returns void

on

  • on(event, listener): void

  • Parameters

    • event: string
    • listener: ((target: any, data: any) => void)
        • (target, data): void

        • Parameters

          • target: any
          • data: any

          Returns void

    Returns void

once

  • once(event, listener): void

  • Parameters

    • event: string
    • listener: ((target: any, data: any) => void)
        • (target, data): void

        • Parameters

          • target: any
          • data: any

          Returns void

    Returns void

removeAllListeners

renderQuads

  • renderQuads(renderer): void

  • Parameters

    • renderer: CoreRenderer

    Returns void

setRenderable

  • setRenderable(isRenderable): void

  • Sets the renderable state and triggers changes if necessary.

    Parameters

    • isRenderable: boolean

      The new renderable state

    Returns void

setUpdateType

  • setUpdateType(type): void

  • Change types types is used to determine the scope of the changes being applied

    Parameters

    • type: UpdateType

    Returns void

    Remarks

    See UpdateType for more information on each type

sortChildren

unloadTexture

update

  • update(delta, parentClippingRect): void

  • @todo: test for correct calculation flag

    Parameters

    • delta: number
    • parentClippingRect: RectWithValid

    Returns void

updateBoundingRect

updateIsRenderable

  • updateIsRenderable(): void

  • Updates the isRenderable property based on various conditions.

    Returns void

updateLocalTransform

updateRenderState

updateScaleRotateTransform

  • updateScaleRotateTransform(): void

  • Returns void

updateTextureOwnership

  • updateTextureOwnership(isRenderable): void

  • Changes the renderable state of the node.

    Parameters

    • isRenderable: boolean

    Returns void

Settings

Member Visibility

On This Page

INode vs CoreNode
Properties
Methods