Attempts to hit a Control node. This will check any children Control nodes first and then itself. This will return null if the control is not enabled or if mouseFilter is set to MouseFilter.NONE.

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.

onFocus

open fun onFocus()

Open method to process when a control is gain focus.

onFocusLost

open fun onFocusLost()

Open method to process when a control loses focus.

onThemeChanged

open fun onThemeChanged()

Open method that is to process and recalculate minimum size when a theme is changed.

parent

open override fun parent(parent: Node?): Node

Sets the parent Node of this Node.

plusAssign

operator fun plusAssign(child: Node)

position

fun position(value: Vec2f): CanvasItem

fun position(x: Float, y: Float, invokeCallback: Boolean = true): CanvasItem

Sets the position of the CanvasItem relative to the parent Node. If the CanvasItem has no parent or if the parent node is NOT a CanvasItem, then it is the same a globalPosition

postRender

open fun postRender(batch: Batch, camera: Camera, shapeRenderer: ShapeRenderer)

Invoked after render. Calculations or logic that needs to be done after rendering such as flushing the batch or ending a frame buffer. The Camera can be used for culling and the Batch instance to draw with.

preRender

open fun preRender(batch: Batch, camera: Camera, shapeRenderer: ShapeRenderer)

Invoked before render. Calculations or logic that needs to be done before rendering such as flushing the batch or starting a frame buffer. The Camera can be used for culling and the Batch instance to draw with.

propagateDebugRender

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

Internal debug rendering that needs to be done on the node that shouldn't be overridden. Calls propagateInternalDebugRender method.

propagateFixedUpdate

fun propagateFixedUpdate()

propagateHit

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

propagateInput

open 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?)

propagatePostRender

fun propagatePostRender(batch: Batch, camera: Camera, shapeRenderer: ShapeRenderer)

Internal post rendering that needs to be done on the node that shouldn't be overridden. Calls propagatePostRender method.

propagatePostUpdate

fun propagatePostUpdate()

propagatePreRender

fun propagatePreRender(batch: Batch, camera: Camera, shapeRenderer: ShapeRenderer)

Internal pre rendering that needs to be done on the node that shouldn't be overridden. Calls propagatePreRender method.

propagatePreUpdate

fun propagatePreUpdate()

propagateRender

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

Internal rendering that needs to be done on the node that shouldn't be overridden. Calls propagateInternalRender method.

propagateResize

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

propagateUnhandledInput

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

propagateUpdate

fun propagateUpdate()

queueSort

fun queueSort()

releaseFocus

fun releaseFocus(): Unit?

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 override fun render(batch: Batch, camera: Camera, shapeRenderer: ShapeRenderer)

The main render method. The Camera can be used for culling and the Batch instance to draw with.

rotation

fun rotation(angle: Angle): CanvasItem

Sets the rotation of the CanvasItem relative to the parent Node in radians. If the CanvasItem has no parent or if the parent node is NOT a CanvasItem, then it is the same a globalRotation

scale

fun scale(value: Vec2f): CanvasItem

Sets the scale of the CanvasItem relative to the parent transform's scales. If the CanvasItem has no parent or if the parent node is NOT a CanvasItem, then it is the same a globalScale

fun scale(x: Float, y: Float): CanvasItem

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.

setAnchor

fun setAnchor(side: Control.Side, value: Float, keepMargins: Boolean = true, triggerSizeChanged: Boolean = true)

setRect

fun setRect(tx: Float, ty: Float, tWidth: Float, tHeight: Float)

Set the bounding rectangle of this control.

size

fun size(newWidth: Float, newHeight: Float)

Set the control to a new size.

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.

toGlobal

fun toGlobal(point: Vec2f): Vec2f

fun toGlobal(point: Vec2f, out: MutableVec2f): MutableVec2f

fun toGlobal(x: Float, y: Float): Vec2f

fun toGlobal(x: Float, y: Float, out: MutableVec2f): MutableVec2f

Transforms the provided local position into a position in global coordinate space. The input is expected to be local relative to the Node2D it is called on. e.g. Applying this method to the positions of child nodes will correctly transform their positions into the global coordinate space, but applying it to a node's own position will give an incorrect result, as it will incorporate the node's own transformation into its global position.

toLocal

fun toLocal(point: Vec2f): Vec2f

fun toLocal(point: Vec2f, out: MutableVec2f): MutableVec2f

fun toLocal(x: Float, y: Float): Vec2f

fun toLocal(x: Float, y: Float, out: MutableVec2f): MutableVec2f

Transforms the provided global position into a position in local coordinate space. The output will be local relative to the Node2D it is called on. e.g. It is appropriate for determining the positions of child nodes, but it is not appropriate for determining its own position relative to its parent.

toString

open override fun toString(): String

translate

fun translate(offset: Vec2f)

fun translate(x: Float, y: Float)

Translates the position by the offset vector in local coordinates.

treeString

fun treeString(): String

treeStringWithProperties

fun treeStringWithProperties(): String

uiInput

open fun uiInput(event: InputEvent<*>)

Open method that is to process and accept inputs on UI elements.

updateTransform

open fun updateTransform()

Updates the current CanvasItem transform if it is dirty.

visible

fun visible(value: Boolean): Node

Shows/hides the Node. When disabled propagateInternalRender is no longer called.

Properties

anchorBottom

var anchorBottom: Float

Anchors the bottom edge of the node to the origin, the center or the end of its parent control. It changes how the bottom offset updates when the node moves or changes size.

anchorLeft

var anchorLeft: Float

Anchors the left edge of the node to the origin, the center or the end of its parent control. It changes how the left offset updates when the node moves or changes size.

anchorRight

var anchorRight: Float

Anchors the right edge of the node to the origin, the center or the end of its parent control. It changes how the right offset updates when the node moves or changes size.

anchorTop

var anchorTop: Float

Anchors the top edge of the node to the origin, the center or the end of its parent control. It changes how the top offset updates when the node moves or changes size.

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.

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.

color

var color: Color

colorCache

val colorCache: MutableMap<String, Color>

A map for storing the result of getThemeColor when needed to prevent searching the tree every frame.

colorOverrides

val colorOverrides: OverrideMap<String, Color>

The map of overrides for a theme Color. Local overrides always take precedence when fetching theme items for the control. An override can be removed with remove.

combinedMinHeight

val combinedMinHeight: Float

The combined height of minHeight and internalMinHeight.

combinedMinWidth

val combinedMinWidth: Float

The combined width of minWidth and internalMinWidth.

constantCache

val constantCache: MutableMap<String, Int>

A map for storing the result of getThemeConstant when needed to prevent searching the tree every frame.

constantOverrides

val constantOverrides: OverrideMap<String, Int>

The map of overrides for a theme Int. Local overrides always take precedence when fetching theme items for the control. An override can be removed with remove.

context

val context: Context

contextOrNull

val contextOrNull: Context?

debugColor

var debugColor: Color

drawableCache

val drawableCache: MutableMap<String, Drawable>

A map for storing the result of getThemeDrawable when needed to prevent searching the tree every frame.

drawableOverrides

val drawableOverrides: OverrideMap<String, Drawable>

The map of overrides for a theme Drawable. Local overrides always take precedence when fetching theme items for the control. An override can be removed with remove.

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.

focusMode

var focusMode: Control.FocusMode

focusNeighborBottom

var focusNeighborBottom: Control? = null

focusNeighborLeft

var focusNeighborLeft: Control? = null

focusNeighborRight

var focusNeighborRight: Control? = null

focusNeighborTop

var focusNeighborTop: Control? = null

focusNext

var focusNext: Control? = null

focusPrev

var focusPrev: Control? = null

fontCache

val fontCache: MutableMap<String, BitmapFont>

A map for storing the result of getThemeFont when needed to prevent searching the tree every frame.

fontOverrides

val fontOverrides: OverrideMap<String, BitmapFont>

The map of overrides for a theme BitmapFont. Local overrides always take precedence when fetching theme items for the control. An override can be removed with remove.

globalInverseTransform

val globalInverseTransform: Mat3

globalPosition

var globalPosition: Vec2f

The position of the CanvasItem in global space. If you want to set the x,y properties of this Vec2f then use the globalX and globalY properties of this CanvasItem

globalRotation

var globalRotation: Angle

The rotation of the CanvasItem in global space in radians

globalScale

var globalScale: Vec2f

The global scale of the CanvasItem. If you want to set the x,y properties of this Vec2f then use the globalScaleX and globalScaleY properties of this CanvasItem.

globalScaleX

var globalScaleX: Float

The global x-scale of the CanvasItem.

globalScaleY

var globalScaleY: Float

The global y-scale of the CanvasItem.

globalToLocalTransform

val globalToLocalTransform: Mat3

globalX

var globalX: Float

globalY

var globalY: Float

hasFocus

val hasFocus: Boolean

height

var height: Float

The height of the node's bounding rectangle, in pixels. Container node's update this property automatically.

horizontalGrowDirection

var horizontalGrowDirection: Control.GrowDirection

Controls the direction on the horizontal axis in which the control should grow if its horizontal minimum size is changed to be greater than its current size, as the control always has to be at least the minimum size.

horizontalSizeFlags

var horizontalSizeFlags: Control.SizeFlag

Tells the parent Container nodes how they should resize and place the node on the X axis. Use one of the SizeFlag constants to change the flags.

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.

localToGlobalTransform

val localToGlobalTransform: Mat3

localToGlobalTransformMat4

val localToGlobalTransformMat4: Mat4

marginBottom

var marginBottom: Float

Distance between the node's bottom edge and its parent control, based on anchorBottom.

marginLeft

var marginLeft: Float

Distance between the node's left edge and its parent control, based on anchorLeft.

marginRight

var marginRight: Float

Distance between the node's right edge and its parent control, based on anchorRight.

marginTop

var marginTop: Float

Distance between the node's top edge and its parent control, based on anchorTop.

material

var material: Material? = null

membersAndPropertiesString

open override val membersAndPropertiesString: String

minHeight

var minHeight: Float = 0.0f

The minimum height that this node should use.

minWidth

var minWidth: Float = 0.0f

The minimum width that this node should use.

mouseFilter

var mouseFilter: Control.MouseFilter

Controls when the control will be able to receive mouse button input events through onUiInput and how these events are handled.

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>

onDebugRender

val onDebugRender: TripleSignal<Batch, Camera, ShapeRenderer>

List of 'debugRender' callbacks called when debugRender 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.

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.

onFocus

val onFocus: Signal

A Signal that is emitted when the control gains focus.

onFocusLost

val onFocusLost: Signal

A Signal that is emitted when the control loses focus.

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.

onInvisible

val onInvisible: Signal

List of 'onInvisible' callbacks called when onInvisible 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.

onMinimumSizeChanged

val onMinimumSizeChanged: Signal

A Signal that is emitted when the control's minimum size changes via minWidth or minHeight

onPostRender

val onPostRender: TripleSignal<Batch, Camera, ShapeRenderer>

List of 'postRender' callbacks called after postRender 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.

onPreRender

val onPreRender: TripleSignal<Batch, Camera, ShapeRenderer>

List of 'preRender' callbacks called when onPreRender 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.

onPresortChildren

val onPresortChildren: Signal

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

onRender

val onRender: TripleSignal<Batch, Camera, ShapeRenderer>

List of 'render' callbacks called when propagateInternalRender 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.

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

A Signal that is emitted when the control changes size.

onSizeFlagsChanged

val onSizeFlagsChanged: Signal

A Signal the is emitted when the horizontalSizeFlags or verticalSizeFlags are changed.

onSortChildren

val onSortChildren: Signal

onUiInput

val onUiInput: SingleSignal<InputEvent<*>>

A Signal that is emitted when the control receives an InputEvent.

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.

onVisible

val onVisible: Signal

List of 'onVisible' callbacks called when onVisible 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.

panel

var panel: Drawable

parent

var parent: Node?

The parent Node, if any.

position

var position: Vec2f

The position of the CanvasItem relative to the parent transform. If the CanvasItem has no parent or if the parent node is NOT a CanvasItem, then it is the same a globalPosition. If you want to set the x,y properties of this Vec2f then use the x and y properties of this CanvasItem

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.

rotation

var rotation: Angle

The rotation of the CanvasItem relative to the parent transform's rotation. If the CanvasItem has no parent or if the parent node is NOT a CanvasItem, then it is the same a globalRotation

scale

var scale: Vec2f

The scale of the CanvasItem relative to the parent transform's scales. If the CanvasItem has no parent or if the parent node is NOT a CanvasItem, then it is the same a globalScale. If you want to set the x,y properties of this Vec2f then use the scaleX and scaleY properties of this CanvasItem.

scaleX

var scaleX: Float

The x-scale of the CanvasItem relative to the parent transform's scales.

scaleY

var scaleY: Float

The y-scale of the CanvasItem relative to the parent transform's scales.

scene

var scene: SceneGraph<*>?

The scene this node belongs to.

stretchRatio

var stretchRatio: Float = 1.0f

If the node and at least one of its neighbors uses the SIZE_EXPAND size flag, the parent Container will let it take more or less space depending on this property. If this node has a stretch ratio of 2 and its neighbor a ratio of 1, this node will take two thirds of the available space.

theme

var theme: Theme? = null

The theme of this node and all its Control children use.

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

verticalGrowDirection

var verticalGrowDirection: Control.GrowDirection

Controls the direction on the vertical axis in which the control should grow if its vertical minimum size is changed to be greater than its current size, as the control always has to be at least the minimum size.

verticalSizeFlags

var verticalSizeFlags: Control.SizeFlag

Tells the parent Container nodes how they should resize and place the node on the Y axis. Use one of the SizeFlag constants to change the flags.

visible

var visible: Boolean

Shows/hides the node if it is renderable.

width

var width: Float

The width of the node's bounding rectangle, in pixels. Container node's update this property automatically.

var x: Float

var y: Float

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