core/com.lehaine.littlekt.graph.node/CanvasLayer

CanvasLayer

A Node that uses a separate OrthographicCamera for rendering instead of the inherited camera from the SceneGraph. This is useful to render a list of nodes with a camera a certain way and another list of nodes another way.

For example: When rendering certain nodes at a low resolution using a Viewport to render UI at a higher resolution.

Author

Colton Daily

Constructors

CanvasLayer

fun CanvasLayer()

Functions

addChild

fun addChild(child: Node): Node

Sets the parent of the child to this Node.

addChildAt

fun addChildAt(child: Node, index: Int): Node

Sets the parent of the child to this Node sets it at the specified index.

addChildren

fun addChildren(vararg children: Node): Node

Sets the parent of the children to this Node.

callInput

open fun callInput(event: InputEvent<*>)

callUnhandledInput

open fun callUnhandledInput(event: InputEvent<*>)

canvasToScreenCoordinates

fun canvasToScreenCoordinates(vector2: MutableVec2f): MutableVec2f

fun canvasToScreenCoordinates(vector3: MutableVec3f): MutableVec3f

Convert canvas coordinates to screen coordinates.

compareTo

open operator override fun compareTo(other: Node): Int

Compares Node by depth and position at each depth.

destroy

fun destroy()

Remove the Node from the SceneGraph and destroys all children.

destroyAllChildren

fun destroyAllChildren(): Node

Removes & destroys all children nodes.

enabled

fun enabled(value: Boolean): Node

Enables/disables the Node. When disabled colliders are removed from the Physics system and will not be called.

equals

open operator override fun equals(other: Any?): Boolean

hashCode

open override fun hashCode(): Int

isEmpty

fun isEmpty(): Boolean

Determines if this Node has zero children nodes.

isNotEmpty

fun isNotEmpty(): Boolean

Determines if this Node contains any children.

minusAssign

operator fun minusAssign(child: Node)

moveChild

fun moveChild(child: Node, index: Int): Node

Moves a child node to the specified index.

onDescendantAdded

open fun onDescendantAdded(child: Node)

onDescendantRemoved

open fun onDescendantRemoved(child: Node)

onDestroy

open override fun onDestroy()

Called when destroy is invoked and all of its children have been destroyed.

parent

open fun parent(parent: Node?): Node

Sets the parent Node of this Node.

plusAssign

operator fun plusAssign(child: Node)

propagateFixedUpdate

fun propagateFixedUpdate()

propagateHit

open override fun propagateHit(hx: Float, hy: Float): Control?

propagateInput

open override fun propagateInput(event: InputEvent<*>): Boolean

propagateInternalDebugRender

open override fun propagateInternalDebugRender(batch: Batch, camera: Camera, camera3d: Camera, shapeRenderer: ShapeRenderer, renderCallback: (Node, Batch, Camera, Camera, ShapeRenderer) -> Unit?)

propagateInternalRender

open override fun propagateInternalRender(batch: Batch, camera: Camera, camera3d: Camera, shapeRenderer: ShapeRenderer, renderCallback: (Node, Batch, Camera, Camera, ShapeRenderer) -> Unit?)

propagatePostUpdate

fun propagatePostUpdate()

propagatePreUpdate

fun propagatePreUpdate()

propagateResize

fun propagateResize(width: Int, height: Int, center: Boolean)

propagateUnhandledInput

open override fun propagateUnhandledInput(event: InputEvent<*>): Boolean

propagateUpdate

fun propagateUpdate()

removeChild

fun removeChild(child: Node): Node

Removes the node if this node is its parent.

removeChildAt

fun removeChildAt(idx: Int): Node

Removes the child at the specified index.

render

open fun render(batch: Batch, shapeRenderer: ShapeRenderer, renderCallback: (Node, Batch, Camera, Camera, ShapeRenderer) -> Unit?)

screenToCanvasCoordinates

fun screenToCanvasCoordinates(vector2: MutableVec2f): MutableVec2f

fun screenToCanvasCoordinates(vector3: MutableVec3f): MutableVec3f

Convert screen coordinates to local canvas coordinates.

sendChildAtToBottom

fun sendChildAtToBottom(idx: Int): Node

Sends the child node at the specified index to the bottom of this list which will be rendered on top.

sendChildAtToTop

fun sendChildAtToTop(idx: Int): Node

Sends the child node at the specified index to the top of this list which will be rendered behind.

sendChildToBottom

fun sendChildToBottom(child: Node): Node

Sends the child node to the bottom of this list which will be rendered on top.

sendChildToTop

fun sendChildToTop(child: Node): Node

Sends the child node to the top of this list which will be rendered behind.

swapChildren

fun swapChildren(child: Node, child2: Node): Node

Swaps the two children positions within the parents list

swapChildrenAt

fun swapChildrenAt(idx: Int, idx2: Int): Node

Swaps children positions at the specified indices.

toString

open override fun toString(): String

treeString

fun treeString(): String

treeStringWithProperties

fun treeStringWithProperties(): String

Properties

canvas

var canvas: CanvasLayer? = null

The CanvasLayer that this Node belongs to. The closest parent CanvasLayer will be selected. If none are found, the scene root viewport will be used.

canvasCamera

val canvasCamera: OrthographicCamera

canvasCamera3d

val canvasCamera3d: PerspectiveCamera

childCount

val childCount: Int

The current child count for this Node. Alias for NodeList.size.

children

val children: NodeList

The children of this Node. Alias for nodes.

context

val context: Context

contextOrNull

val contextOrNull: Context?

val dt: Duration

enabled

var enabled: Boolean

Enables/disables the node.

fixedProgressionRatio

val fixedProgressionRatio: Float

Attempts to grab the SceneGraph.fixedProgressionRatio. Defaults to 1 if not.

height

var height: Int

Height of the viewport

val id: Int

Unique identifier for this node.

index

val index: Int

The index of this Node as a child in it's parent.

insideTree

val insideTree: Boolean

Check if this Node is in a SceneGraph

isDestroyed

val isDestroyed: Boolean

If destroy was called, this will be true until the next time node's are processed.

membersAndPropertiesString

open val membersAndPropertiesString: String

name

var name: String

Node name. useful for doing scene-wide searches for an node

nodes

val nodes: NodeList

The list of Nodes in this scene.

onAddedToScene

val onAddedToScene: Signal

List of 'addedToScene' callbacks called when onAddedToScene is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onChildEnteredTree

val onChildEnteredTree: SingleSignal<Node>

onChildExitedTree

val onChildExitedTree: SingleSignal<Node>

onDestroy

val onDestroy: Signal

List of 'destroy' callbacks called when destroy is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onDisabled

val onDisabled: Signal

List of 'onDisabled' callbacks called when onDisabled is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onEnabled

val onEnabled: Signal

List of 'onEnabled' callbacks called when onEnabled is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onFixedUpdate

val onFixedUpdate: Signal

List of 'fixed-update' callbacks called when fixedUpdate is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onInput

val onInput: SingleSignal<InputEvent<*>>

List of 'input' callbacks called when input is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onPostUpdate

val onPostUpdate: SingleSignal<Duration>

List of 'post-update' callbacks called when postUpdate is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onPreUpdate

val onPreUpdate: SingleSignal<Duration>

List of 'pre-update' callbacks called when preUpdate is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onReady

val onReady: Signal

List of 'ready' callbacks called when ready is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onRemovedFromScene

val onRemovedFromScene: Signal

List of 'removedFromScene' callbacks called when onRemovedFromScene is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onRemovingFromScene

val onRemovingFromScene: Signal

onResize

val onResize: DoubleSignal<Int, Int>

List of 'resize' callbacks called when resize is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onSizeChanged

val onSizeChanged: Signal

Signal that is emitted when the viewport dimensions are changed by the CanvasLayer.

onUnhandledInput

val onUnhandledInput: SingleSignal<InputEvent<*>>

List of 'unhandledInput' callbacks called when unhandledInput is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

onUpdate

val onUpdate: SingleSignal<Duration>

List of 'update' callbacks called when update is called. Add any additional callbacks directly to this list. The main use is to add callbacks directly to nodes inline when building a SceneGraph vs having to extend a class directly.

parent

var parent: Node?

The parent Node, if any.

ppu

val ppu: Float

Pixels per unit. Mainly used when rendering a Node. This is based off of the SceneGraph.ppu.

ppuInv

val ppuInv: Float

The inverse of ppu. This is based off the SceneGraph.ppuInv.

scene

var scene: SceneGraph<*>?

The scene this node belongs to.

updateInterval

var updateInterval: Int = 1

Specifies how often this node's update method should be called. 1 means every frame, 2 is every other, etc

viewport

var viewport: Viewport

Viewport instance that can be used for rendering children nodes in inherited classes. This is not used directly in the base CanvasLayer class.

virtualHeight

var virtualHeight: Float

The viewport virtual/world height

virtualWidth

var virtualWidth: Float

The viewport virtual/world width

width

var width: Int

Width of the viewport

var x: Int

Viewport x-coord

var y: Int

Viewport y-coord

Inheritors

FrameBufferNode

ViewportCanvasLayer

Extensions

button

inline fun Node.button(callback: Button.() -> Unit = {}): Button

Adds a Button to the current Node as a child and then triggers the callback

camera2d

inline fun Node.camera2d(callback: Camera2D.() -> Unit = {}): Camera2D

Adds a Camera2D to the current Node as a child and then triggers the callback

camera3d

inline fun Node.camera3d(callback: Camera3D.() -> Unit = {}): Camera3D

Adds a Camera3D to the current Node as a child and then triggers the callback

canvasLayer

inline fun Node.canvasLayer(callback: CanvasLayer.() -> Unit = {}): CanvasLayer

Adds a CanvasLayer to the current Node as a child and then triggers the callback

centerContainer

inline fun Node.centerContainer(callback: CenterContainer.() -> Unit = {}): CenterContainer

Adds a CenterContainer to the current Node as a child and then triggers the callback

column

inline fun Node.column(callback: VBoxContainer.() -> Unit = {}): VBoxContainer

Adds a VBoxContainer to the current Node as a child and then triggers the callback

container

inline fun Node.container(callback: Container.() -> Unit = {}): Container

Adds a Container to the current Node as a child and then triggers the callback

control

inline fun Node.control(callback: Control.() -> Unit = {}): Control

Adds a Control to the current Node as a child and then triggers the callback

directionalLight

inline fun Node.directionalLight(callback: DirectionalLight.() -> Unit = {}): DirectionalLight

Adds a DirectionalLight to the current Node as a child and then triggers the callback

findFirstNodeOfType

inline fun <T : Node> Node.findFirstNodeOfType(): T?

frameBuffer

inline fun Node.frameBuffer(callback: FrameBufferNode.() -> Unit = {}): FrameBufferNode

frameBufferContainer

inline fun Node.frameBufferContainer(callback: FrameBufferContainer.() -> Unit = {}): FrameBufferContainer

Adds a FrameBufferContainer to the current Node as a child and then triggers the callback

hBoxContainer

inline fun Node.hBoxContainer(callback: HBoxContainer.() -> Unit = {}): HBoxContainer

Adds a HBoxContainer to the current Node as a child and then triggers the callback

hScrollBar

inline fun Node.hScrollBar(callback: HScrollBar.() -> Unit = {}): HScrollBar

Adds a HScrollBar to the current Node as a child and then triggers the callback

label

inline fun Node.label(callback: Label.() -> Unit = {}): Label

Adds a Label to the current Node as a child and then triggers the callback

lineEdit

inline fun Node.lineEdit(callback: LineEdit.() -> Unit = {}): LineEdit

Adds a LineEdit to the current Node as a child and then triggers the callback

meshNode

inline fun Node.meshNode(callback: MeshNode.() -> Unit = {}): MeshNode

Adds a MeshNode to the current Node as a child and then triggers the callback

ninePatchRect

inline fun Node.ninePatchRect(callback: NinePatchRect.() -> Unit = {}): NinePatchRect

Adds a NinePatchRect to the current Node as a child and then triggers the callback

node

inline fun Node.node(callback: Node.() -> Unit = {}): Node

Adds a Node to the current Node as a child and then triggers the callback

inline fun <T : Node> Node.node(node: T, callback: T.() -> Unit = {}): T

Adds the specified Node to the current Node as a child and then triggers the callback. This can be used for classes that extend node that perhaps they don't have a DSL method to initialize it.

node2d

inline fun Node.node2d(callback: Node2D.() -> Unit = {}): Node2D

Adds a Node2D to the current Node as a child and then triggers the callback

node3d

inline fun Node.node3d(callback: Node3D.() -> Unit = {}): Node3D

Adds a Node3D to the current Node as a child and then triggers the callback

paddedContainer

inline fun Node.paddedContainer(callback: PaddedContainer.() -> Unit = {}): PaddedContainer

Adds a PaddedContainer to the current Node as a child and then triggers the callback

panel

inline fun Node.panel(callback: Panel.() -> Unit = {}): Panel

Adds a Panel to the current Node as a child and then triggers the callback

panelContainer

inline fun Node.panelContainer(callback: PanelContainer.() -> Unit = {}): PanelContainer

Adds a PanelContainer to the current Node as a child and then triggers the callback

progressBar

inline fun Node.progressBar(callback: ProgressBar.() -> Unit = {}): ProgressBar

Adds a ProgressBar to the current Node as a child and then triggers the callback

row

inline fun Node.row(callback: HBoxContainer.() -> Unit = {}): HBoxContainer

Adds a HBoxContainer to the current Node as a child and then triggers the callback

scrollContainer

inline fun Node.scrollContainer(callback: ScrollContainer.() -> Unit = {}): ScrollContainer

Adds a ScrollContainer to the current Node as a child and then triggers the callback

textureProgress

inline fun Node.textureProgress(callback: TextureProgress.() -> Unit = {}): TextureProgress

Adds a TextureProgress to the current Node as a child and then triggers the callback

textureRect

inline fun Node.textureRect(callback: TextureRect.() -> Unit = {}): TextureRect

Adds a TextureRect to the current Node as a child and then triggers the callback

vBoxContainer

inline fun Node.vBoxContainer(callback: VBoxContainer.() -> Unit = {}): VBoxContainer

Adds a VBoxContainer to the current Node as a child and then triggers the callback

viewport

inline fun Node.viewport(callback: ViewportCanvasLayer.() -> Unit = {}): ViewportCanvasLayer

Adds a ViewportCanvasLayer to the current Node as a child and then triggers the callback

vScrollBar

inline fun Node.vScrollBar(callback: VScrollBar.() -> Unit = {}): VScrollBar

Adds a VScrollBar to the current Node as a child and then triggers the callback