core/com.lehaine.littlekt.graph/SceneGraph

SceneGraph

open class SceneGraph<InputType>(val context: Context, viewport: Viewport = ScreenViewport( context.graphics.width, context.graphics.height ), batch: Batch? = null, val uiInputSignals: SceneGraph.UiInputSignals<InputType> = UiInputSignals(), val controller: InputMapController<InputType> = createDefaultSceneGraphController( context.input, uiInputSignals ), whitePixel: TextureSlice = Textures.white) : InputMapProcessor<InputType> , Disposable

A class for creating a scene graph of nodes.

Author

Colton Daily

Parameters

context

the current context

viewport

the viewport that the camera of the scene graph will own

batch

an option sprite batch. If omitted, the scene graph will create and manage its own.

uiInputSignals

the input signals mapped to the UI input of type InputType.

controller

the input map controller for the scene graph

whitePixel

a white 1x1 pixel TextureSlice that is used for rendering with ShapeRenderer.

Constructors

SceneGraph

fun <InputType> SceneGraph(context: Context, viewport: Viewport = ScreenViewport( context.graphics.width, context.graphics.height ), batch: Batch? = null, uiInputSignals: SceneGraph.UiInputSignals<InputType> = UiInputSignals(), controller: InputMapController<InputType> = createDefaultSceneGraphController( context.input, uiInputSignals ), whitePixel: TextureSlice = Textures.white)

Types

UiInputSignals

data class UiInputSignals<InputType>(val uiAccept: InputType? = null, val uiSelect: InputType? = null, val uiCancel: InputType? = null, val uiFocusNext: InputType? = null, val uiFocusPrev: InputType? = null, val uiLeft: InputType? = null, val uiRight: InputType? = null, val uiUp: InputType? = null, val uiDown: InputType? = null, val uiHome: InputType? = null, val uiEnd: InputType? = null)

Functions

charTyped

open override fun charTyped(character: Char): Boolean

Invoked when a Key is pressed and a Char is associated with that key.

dispose

open override fun dispose()

Lifecycle method. Do any necessary unloading / disposing here. This is called when this scene is removed from the active slot.

gamepadButtonPressed

open override fun gamepadButtonPressed(button: GameButton, pressure: Float, gamepad: Int): Boolean

Invoked when a GameButton is initially pressed on a GamepadInfo.

gamepadButtonReleased

open override fun gamepadButtonReleased(button: GameButton, gamepad: Int): Boolean

Invoked when a GameButton is released on a GamepadInfo.

gamepadJoystickMoved

open override fun gamepadJoystickMoved(stick: GameStick, xAxis: Float, yAxis: Float, gamepad: Int): Boolean

Invoked when a GameStick is moved on a GamepadInfo.

gamepadTriggerChanged

open override fun gamepadTriggerChanged(button: GameButton, pressure: Float, gamepad: Int): Boolean

Invoked when a GameButton that is considered a trigger is changed / moved.

hasFocus

fun hasFocus(control: Control): Boolean

Checks if the Control has the current keyboard focus.

initialize

open suspend fun initialize()

Initializes the root Node and InputProcessor. This must be called before an update or render calls.

open suspend fun Node.initialize()

Lifecycle method. This is called whenever the SceneGraph is set before initialize is called. Any nodes added to this Node context won't be added until the next frame update.

keyDown

open override fun keyDown(key: Key): Boolean

Invoked when a Key is initially pressed down.

keyRepeat

open override fun keyRepeat(key: Key): Boolean

Invoked when a Key is pressed and held down.

keyUp

open override fun keyUp(key: Key): Boolean

Invoked when a Key is released.

minusAssign

operator fun minusAssign(node: Node)

Removes the node from the root.

mouseMoved

open override fun mouseMoved(screenX: Float, screenY: Float): Boolean

Invoked when the mouse is moved.

onActionChange

open fun onActionChange(inputType: InputType, pressure: Float): Boolean

onActionDown

open override fun onActionDown(inputType: InputType): Boolean

onActionRepeat

open override fun onActionRepeat(inputType: InputType): Boolean

onActionUp

open override fun onActionUp(inputType: InputType): Boolean

onStart

open fun onStart()

Lifecycle method. This is called when this scene becomes the active scene.

plusAssign

operator fun plusAssign(node: Node)

Adds the new to the root.

releaseFocus

fun releaseFocus()

Releases any current keyboard focus.

render

open fun render()

Renders the entire tree.

requestFocus

fun requestFocus(control: Control)

Request a Control to receive keyboard focus.

resize

open fun resize(width: Int, height: Int, centerCamera: Boolean = false)

Resizes the internal graph's OrthographicCamera and CanvasLayer.

sceneToScreenCoordinates

fun sceneToScreenCoordinates(inOut: MutableVec2f): MutableVec2f

screenToSceneCoordinates

fun screenToSceneCoordinates(inOut: MutableVec2f): MutableVec2f

scrolled

open override fun scrolled(amountX: Float, amountY: Float): Boolean

Invoked when the mouse is scrolled.

touchDown

open override fun touchDown(screenX: Float, screenY: Float, pointer: Pointer): Boolean

Invoked when a Pointer is initially touched or clicked. This includes mouse and touch.

touchDragged

open override fun touchDragged(screenX: Float, screenY: Float, pointer: Pointer): Boolean

Invoked when a Pointer is pressed/clicked and dragged. This includes mouse and touch.

touchUp

open override fun touchUp(screenX: Float, screenY: Float, pointer: Pointer): Boolean

Invoked when a Pointer is released. This includes mouse and touch.

uiInput

open fun uiInput(control: Control, event: InputEvent<InputType>)

Open method that is triggered whenever a Control node receives an input event.

update

open fun update(dt: Duration)

Updates all the nodes in the tree.

Properties

batch

val batch: Batch

context

val context: Context

controller

val controller: InputMapController<InputType>

currentMaterial

var currentMaterial: Material? = null

Holds the current Material of the last rendered Node if no changes were made)

defaultMaterial3d

var defaultMaterial3d: ModelMaterial

var dt: Duration

The current delta time.

environment

var environment: Environment

fixedProgressionRatio

val fixedProgressionRatio: Float

The fixed progression lerp ratio for fixed updates. This is used for rendering nodes that use Node.fixedUpdate for movement / physics logic.

fixedTimesPerSecond

var fixedTimesPerSecond: Int = 30

The interval for Node.fixedUpdate to fire. Defaults to 30 times per second.

frame

val frame: Int

The current frame count.

height

val height: Float

The virtual height of hte sceneCanvas.

ppu

open var ppu: Float = 1.0f

Pixel Per Unit. Changing this value affects ppuInv. Defaults to 1.

ppuInv

val ppuInv: Float

The inverse of ppu. Can be used to scale nodes correctly when using a ppu that isn't 1.

requestShowDebugInfo

var requestShowDebugInfo: Boolean = false

When true, nodes will handle rendering debug related info such as node bounds. When false nodes will not be rendered.

root

val root: Node

The root node that should be used to add any children nodes to.

sceneCanvas

val sceneCanvas: ViewportCanvasLayer

The root ViewportCanvasLayer that is used for rendering all the children in the graph. Do not add children directly to this node. Instead, add children to the root node.

shapeRenderer

val shapeRenderer: ShapeRenderer

showDebugInfo

var showDebugInfo: Boolean = false

This is the true current value if debugging is rendering. To change this value see requestShowDebugInfo.

targetFPS

var targetFPS: Int = 60

The target FPS for tmod.

tmod

var tmod: Float = 1.0f

The time modifier based off of targetFPS.

uiInputSignals

val uiInputSignals: SceneGraph.UiInputSignals<InputType>

width

val width: Float

The virtual width of the sceneCanvas.

Extensions

button

inline fun SceneGraph<*>.button(callback: Button.() -> Unit = {}): Button

Adds a Button to the current SceneGraph.root as a child and then triggers the callback

camera2d

inline fun SceneGraph<*>.camera2d(callback: Camera2D.() -> Unit = {}): Camera2D

Adds a Camera2D to the current SceneGraph.root as a child and then triggers the Camera2D

camera3d

inline fun SceneGraph<*>.camera3d(callback: Camera3D.() -> Unit = {}): Camera3D

Adds a Camera3D to the current SceneGraph.root as a child and then triggers the Camera3D

canvasLayer

inline fun SceneGraph<*>.canvasLayer(callback: CanvasLayer.() -> Unit = {}): CanvasLayer

Adds a CanvasLayer to the current SceneGraph.root as a child and then triggers the CanvasLayer

centerContainer

inline fun SceneGraph<*>.centerContainer(callback: CenterContainer.() -> Unit = {}): CenterContainer

Adds a CenterContainer to the current SceneGraph.root as a child and then triggers the callback

column

inline fun SceneGraph<*>.column(callback: VBoxContainer.() -> Unit = {}): VBoxContainer

Adds a VBoxContainer to the current SceneGraph.root as a child and then triggers the callback

container

inline fun SceneGraph<*>.container(callback: Container.() -> Unit = {}): Container

Adds a Container to the current SceneGraph.root as a child and then triggers the callback

control

inline fun SceneGraph<*>.control(callback: Control.() -> Unit = {}): Control

Adds a Control to the current SceneGraph.root as a child and then triggers the callback

directionalLight

inline fun SceneGraph<*>.directionalLight(callback: DirectionalLight.() -> Unit = {}): DirectionalLight

Adds a DirectionalLight to the current SceneGraph.root as a child and then triggers the DirectionalLight

frameBuffer

inline fun SceneGraph<*>.frameBuffer(callback: FrameBufferNode.() -> Unit = {}): FrameBufferNode

frameBufferContainer

inline fun SceneGraph<*>.frameBufferContainer(callback: FrameBufferContainer.() -> Unit = {}): FrameBufferContainer

Adds a FrameBufferContainer to the current SceneGraph.root as a child and then triggers the callback

hBoxContainer

inline fun SceneGraph<*>.hBoxContainer(callback: HBoxContainer.() -> Unit = {}): HBoxContainer

Adds a HBoxContainer to the current SceneGraph.root as a child and then triggers the callback

hScrollBar

inline fun SceneGraph<*>.hScrollBar(callback: HScrollBar.() -> Unit = {}): HScrollBar

Adds a HScrollBar to the current SceneGraph.root as a child and then triggers the callback

label

inline fun SceneGraph<*>.label(callback: Label.() -> Unit = {}): Label

Adds a Label to the current SceneGraph.root as a child and then triggers the callback

lineEdit

inline fun SceneGraph<*>.lineEdit(callback: LineEdit.() -> Unit = {}): LineEdit

Adds a LineEdit to the current SceneGraph.root as a child and then triggers the callback

meshNode

inline fun SceneGraph<*>.meshNode(callback: MeshNode.() -> Unit = {}): MeshNode

Adds a MeshNode to the current SceneGraph.root as a child and then triggers the MeshNode

ninePatchRect

inline fun SceneGraph<*>.ninePatchRect(callback: NinePatchRect.() -> Unit = {}): NinePatchRect

Adds a NinePatchRect to the current SceneGraph.root as a child and then triggers the callback

node

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

Adds a Node to the current SceneGraph.root as a child and then triggers the Node

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

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

node2d

inline fun SceneGraph<*>.node2d(callback: Node2D.() -> Unit = {}): Node2D

Adds a Node2D to the current SceneGraph.root as a child and then triggers the Node2D

node3d

inline fun SceneGraph<*>.node3d(callback: Node3D.() -> Unit = {}): Node3D

Adds a Node3D to the current SceneGraph.root as a child and then triggers the Node3D

paddedContainer

inline fun SceneGraph<*>.paddedContainer(callback: PaddedContainer.() -> Unit = {}): PaddedContainer

Adds a PaddedContainer to the current SceneGraph.root as a child and then triggers the callback

panel

inline fun SceneGraph<*>.panel(callback: Panel.() -> Unit = {}): Panel

Adds a Panel to the SceneGraph.root as a child and then triggers the callback

panelContainer

inline fun SceneGraph<*>.panelContainer(callback: PanelContainer.() -> Unit = {}): PanelContainer

Adds a PanelContainer to the SceneGraph.root as a child and then triggers the callback

progressBar

inline fun SceneGraph<*>.progressBar(callback: ProgressBar.() -> Unit = {}): ProgressBar

Adds a ProgressBar to the current SceneGraph.root as a child and then triggers the callback

row

inline fun SceneGraph<*>.row(callback: HBoxContainer.() -> Unit = {}): HBoxContainer

Adds a HBoxContainer to the current SceneGraph.root as a child and then triggers the callback

scrollContainer

inline fun SceneGraph<*>.scrollContainer(callback: ScrollContainer.() -> Unit = {}): ScrollContainer

Adds a ScrollContainer to the current SceneGraph.root as a child and then triggers the callback

textureProgress

inline fun SceneGraph<*>.textureProgress(callback: TextureProgress.() -> Unit = {}): TextureProgress

Adds a TextureProgress to the current SceneGraph.root as a child and then triggers the callback

textureRect

inline fun SceneGraph<*>.textureRect(callback: TextureRect.() -> Unit = {}): TextureRect

Adds a TextureRect to the SceneGraph.root as a child and then triggers the callback

vBoxContainer

inline fun SceneGraph<*>.vBoxContainer(callback: VBoxContainer.() -> Unit = {}): VBoxContainer

Adds a VBoxContainer to the current SceneGraph.root as a child and then triggers the callback

viewport

inline fun SceneGraph<*>.viewport(callback: ViewportCanvasLayer.() -> Unit = {}): ViewportCanvasLayer

Adds a ViewportCanvasLayer to the current SceneGraph.root as a child and then triggers the ViewportCanvasLayer

vScrollBar

inline fun SceneGraph<*>.vScrollBar(callback: VScrollBar.() -> Unit = {}): VScrollBar

Adds a VScrollBar to the current SceneGraph.root as a child and then triggers the callback