sceneview/io.github.sceneview.node/ModelNode

ModelNode

open class ModelNode(val modelInstance: ModelInstance, autoAnimate: Boolean = true, scaleToUnits: Float? = null, centerOrigin: Position? = null) : Node

Create the ModelNode from a loaded model instance.

Use your own single MaterialLoader instance or the SceneView.materialLoader one to load your gltF form different .glTF/.glb resource locations.

Constructors

ModelNode

constructor(modelInstance: ModelInstance, autoAnimate: Boolean = true, scaleToUnits: Float? = null, centerOrigin: Position? = null)

Types

CameraNode

inner class CameraNode : CameraNode, ModelNode.ChildNode

ChildNode

interface ChildNode

EmptyNode

inner class EmptyNode : Node, ModelNode.ChildNode

LightNode

inner class LightNode : LightNode, ModelNode.ChildNode

PlayingAnimation

data class PlayingAnimation(val startTime: Long = System.nanoTime(), var speed: Float = 1.0f, val loop: Boolean = true)

RenderableNode

inner class RenderableNode : RenderableNode, ModelNode.ChildNode

Properties

animationCount

val animationCount: Int

The number of animation definitions in the glTF asset.

animator

var animator: Animator

Retrieves the Animator for this instance.

boundingBox

val boundingBox: Box

Gets the bounding box computed from the supplied min / max values in glTF accessors.

cameraNodes

val cameraNodes: List<ModelNode.CameraNode>

center

val center: Float3

childNodes

var childNodes: Set<Node>

collider

var collider: Collider?

collisionShape

var collisionShape: CollisionShape?

The shape to used to detect collisions for this Node.

collisionSystem

var collisionSystem: CollisionSystem?

editableScaleRange

var editableScaleRange: ClosedFloatingPointRange<Float>

editingTransforms

var editingTransforms: Set<KProperty1<Node, Any>>

emptyNodes

val emptyNodes: List<ModelNode.EmptyNode>

val engine: Engine

val entity: Entity

val extents: Float3

val halfExtent: Float3

isEditable

open var isEditable: Boolean

isHittable

var isHittable: Boolean

isPositionEditable

open var isPositionEditable: Boolean

isRotationEditable

open var isRotationEditable: Boolean

isScaleEditable

open var isScaleEditable: Boolean

isShadowCaster

var isShadowCaster: Boolean

Changes whether or not the renderable casts shadows.

isShadowReceiver

var isShadowReceiver: Boolean

Changes whether or not the renderable can receive shadows.

isSmoothTransformEnabled

var isSmoothTransformEnabled: Boolean

isTouchable

open var isTouchable: Boolean

The node can be selected when a touch event happened.

isVisible

open var isVisible: Boolean

The visible state of this node.

lightNodes

val lightNodes: List<ModelNode.LightNode>

materialInstances

var materialInstances: List<List<MaterialInstance>>

Changes the material instances binding for the given primitives.

materialVariantNames

val materialVariantNames: List<String>

Returns the names of all material variants.

model

val model: FilamentAsset

The source Model (FilamentAsset) from the ModelInstance.

modelInstance

val modelInstance: ModelInstance

The ModelInstance to add to scene. Usually a renderable 3D model.

name

open var name: String?

nodes

val nodes: List<Node>

onAddedToScene

var onAddedToScene: (scene: Scene) -> Unit?

onContextClick

var onContextClick: (e: MotionEvent) -> Boolean?

onDoubleTap

var onDoubleTap: (e: MotionEvent) -> Boolean?

onDoubleTapEvent

var onDoubleTapEvent: (e: MotionEvent) -> Boolean?

onDown

var onDown: (e: MotionEvent) -> Boolean?

onEditingChanged

var onEditingChanged: (editingTransforms: Set<KProperty1<Node, Any>?>) -> Unit?

onFling

var onFling: (e1: MotionEvent?, e2: MotionEvent, velocity: Float2) -> Boolean?

onFrame

var onFrame: (frameTimeNanos: Long) -> Unit?

onLongPress

var onLongPress: (e: MotionEvent) -> Unit?

onMove

var onMove: (detector: MoveGestureDetector, e: MotionEvent, Position) -> Boolean?

onMoveBegin

var onMoveBegin: (detector: MoveGestureDetector, e: MotionEvent) -> Boolean?

onMoveEnd

var onMoveEnd: (detector: MoveGestureDetector, e: MotionEvent) -> Unit?

onRemovedFromScene

var onRemovedFromScene: (scene: Scene) -> Unit?

onRotate

var onRotate: (detector: RotateGestureDetector, e: MotionEvent, rotationDelta: Quaternion) -> Boolean?

onRotateBegin

var onRotateBegin: (detector: RotateGestureDetector, e: MotionEvent) -> Boolean?

onRotateEnd

var onRotateEnd: (detector: RotateGestureDetector, e: MotionEvent) -> Unit?

onScale

var onScale: (detector: ScaleGestureDetector, e: MotionEvent, scaleFactor: Float) -> Boolean?

onScaleBegin

var onScaleBegin: (detector: ScaleGestureDetector, e: MotionEvent) -> Boolean?

onScaleEnd

var onScaleEnd: (detector: ScaleGestureDetector, e: MotionEvent) -> Unit?

onScroll

var onScroll: (e1: MotionEvent?, e2: MotionEvent, distance: Float2) -> Boolean?

onShowPress

var onShowPress: (e: MotionEvent) -> Unit?

onSingleTapConfirmed

var onSingleTapConfirmed: (e: MotionEvent) -> Boolean?

onSingleTapUp

var onSingleTapUp: (e: MotionEvent) -> Boolean?

onSmoothEnd

var onSmoothEnd: (node: Node) -> Unit?

onTouch

var onTouch: (e: MotionEvent, hitResult: HitResult) -> Boolean?

parent

open var parent: Node?

Changes the parent node.

parentEntity

var parentEntity: Entity?

parentInstance

var parentInstance: EntityInstance?

playingAnimations

var playingAnimations: MutableMap<Int, ModelNode.PlayingAnimation>

position

open var position: Position

Position to locate within the coordinate system the parent.

quaternion

open var quaternion: Quaternion

Quaternion rotation.

renderableNodes

val renderableNodes: List<ModelNode.RenderableNode>

rotation

open var rotation: Rotation

Orientation in Euler Angles Degrees per axis from 0.0f to 360.0f.

scale

open var scale: Scale

Scale on each axis.

size

val size: Float3

skinCount

val skinCount: Int

Gets the skin count of this instance.

skinNames

val skinNames: List<String>

Gets the skin name at skin index in this instance.

smoothTransform

var smoothTransform: Transform?

smoothTransformSpeed

var smoothTransformSpeed: Float

The smooth position, rotation and scale speed.

transform

open var transform: Transform

Local transform of the transform component (i.e. relative to the parent).

transformInstance

val transformInstance: Int

transformManager

val transformManager: TransformManager

worldPosition

open var worldPosition: Position

World-space position.

worldQuaternion

open var worldQuaternion: Quaternion

The world-space quaternion.

worldRotation

open var worldRotation: Rotation

World-space rotation.

worldScale

open var worldScale: Scale

World-space scale.

worldToLocal

val worldToLocal: Transform

Transform from the world coordinate system to the coordinate system of this node.

worldTransform

var worldTransform: Transform

World transform of a transform component (i.e. relative to the root).

Functions

addChildNode

fun addChildNode(node: Node): Node

addChildNodes

fun addChildNodes(nodes: Set<Node>): Node

animatePositions

fun animatePositions(vararg positions: Position): ObjectAnimator

animateQuaternions

fun animateQuaternions(vararg quaternions: Quaternion): ObjectAnimator

animateRotations

fun animateRotations(vararg rotations: Rotation): ObjectAnimator

animateScales

fun animateScales(vararg scales: Scale): ObjectAnimator

animateTransforms

fun animateTransforms(vararg transforms: Transform): AnimatorSet

attachSkin

fun attachSkin(target: Node, @IntRange(from = 0) skinIndex: Int = 0)

Attaches the given skin to the given node, which must have an associated mesh with BONE_INDICES and BONE_WEIGHTS attributes.

centerOrigin

fun centerOrigin(origin: Position = Position(x = 0.0f, y = 0.0f, z = 0.0f))

Sets up a root transform on the current model to make it centered.

clearChildNodes

fun clearChildNodes(): Node

destroy

open fun destroy()

Detach and destroy the node and all its children.

detachSkin

fun detachSkin(target: Node, @IntRange(from = 0) skinIndex: Int = 0)

Attaches the given skin to the given node, which must have an associated mesh with BONE_INDICES and BONE_WEIGHTS attributes.

getJointCount

open fun getJointCount(@IntRange(from = 0) skinIndex: Int = 0): Int

Gets the joint count at skin index in this instance.

getLocalPosition

fun getLocalPosition(worldPosition: Position): Float3

Converts a position in the world-space to a local-space of this node.

getLocalQuaternion

fun getLocalQuaternion(worldQuaternion: Quaternion): Quaternion

Converts a quaternion in the world-space to a local-space of this node.

getLocalRotation

fun getLocalRotation(worldRotation: Rotation): Float3

Converts a rotation in the world-space to a local-space of this node.

getLocalScale

fun getLocalScale(worldScale: Scale): Float3

Converts a scale in the world-space to a local-space of this node.

getLocalTransform

fun getLocalTransform(worldTransform: Transform): Mat4

Converts a transform in the world-space to a local-space of this node.

fun getLocalTransform(node: Node): Mat4

Converts a node transform in the world-space to a local-space of this node.

getTransformationMatrix

open override fun getTransformationMatrix(): Matrix

getWorldPosition

fun getWorldPosition(localPosition: Position): Float3

Converts a position in the local-space of this node to world-space.

getWorldQuaternion

fun getWorldQuaternion(quaternion: Quaternion): Quaternion

Converts a quaternion in the local-space of this node to world-space.

getWorldRotation

fun getWorldRotation(rotation: Rotation): Float3

Converts a rotation in the local-space of this node to world-space.

getWorldScale

fun getWorldScale(scale: Scale): Float3

Converts a scale in the local-space of this node to world-space.

getWorldTransform

fun getWorldTransform(localTransform: Transform): Mat4

Converts a transform in the local-space of this node to world-space.

fun getWorldTransform(node: Node): Mat4

Converts a node transform in the local-space of this node to world-space.

lookAt

fun lookAt(targetWorldPosition: Position, upDirection: Direction = Direction(y = 1.0f), smooth: Boolean = isSmoothTransformEnabled, smoothSpeed: Float = smoothTransformSpeed): Node

Rotates the node to face a point in world-space.

fun lookAt(targetNode: Node, upDirection: Direction = Direction(y = 1.0f), smooth: Boolean = isSmoothTransformEnabled, smoothSpeed: Float = smoothTransformSpeed): Node

Rotates the node to face another node.

lookTowards

fun lookTowards(lookDirection: Direction, upDirection: Direction = Direction(y = 1.0f), smooth: Boolean = isSmoothTransformEnabled, smoothSpeed: Float = smoothTransformSpeed): Node

Rotates the node to face a direction in world-space.

onAddedToScene

open fun onAddedToScene(scene: Scene)

onContextClick

open override fun onContextClick(e: MotionEvent): Boolean

onDoubleTap

open override fun onDoubleTap(e: MotionEvent): Boolean

onDoubleTapEvent

open override fun onDoubleTapEvent(e: MotionEvent): Boolean

onDown

open override fun onDown(e: MotionEvent): Boolean

onFling

open override fun onFling(e1: MotionEvent?, e2: MotionEvent, velocityX: Float, velocityY: Float): Boolean

onFrame

open override fun onFrame(frameTimeNanos: Long)

onLongPress

open override fun onLongPress(e: MotionEvent)

onMove

open override fun onMove(detector: MoveGestureDetector, e: MotionEvent): Boolean

Responds to moving events for a gesture in progress

open fun onMove(detector: MoveGestureDetector, e: MotionEvent, worldPosition: Position): Boolean

onMoveBegin

open override fun onMoveBegin(detector: MoveGestureDetector, e: MotionEvent): Boolean

Responds to the beginning of a moving gesture

onMoveEnd

open override fun onMoveEnd(detector: MoveGestureDetector, e: MotionEvent)

Responds to the end of a move gesture

onRemovedFromScene

open fun onRemovedFromScene(scene: Scene)

onRotate

open override fun onRotate(detector: RotateGestureDetector, e: MotionEvent): Boolean

Responds to rotating events for a gesture in progress.

open fun onRotate(detector: RotateGestureDetector, e: MotionEvent, rotationDelta: Quaternion): Boolean

onRotateBegin

open override fun onRotateBegin(detector: RotateGestureDetector, e: MotionEvent): Boolean

Responds to the beginning of a scaling gesture.

onRotateEnd

open override fun onRotateEnd(detector: RotateGestureDetector, e: MotionEvent)

Responds to the end of a scale gesture.

onScale

open override fun onScale(detector: ScaleGestureDetector, e: MotionEvent): Boolean

Responds to scaling events for a gesture in progress.

open fun onScale(detector: ScaleGestureDetector, e: MotionEvent, scaleFactor: Float): Boolean

onScaleBegin

open override fun onScaleBegin(detector: ScaleGestureDetector, e: MotionEvent): Boolean

Responds to the beginning of a scaling gesture. Reported by new pointers going down.

onScaleEnd

open override fun onScaleEnd(detector: ScaleGestureDetector, e: MotionEvent)

Responds to the end of a scale gesture. Reported by existing pointers going up.

onScroll

open override fun onScroll(e1: MotionEvent?, e2: MotionEvent, distanceX: Float, distanceY: Float): Boolean

onShowPress

open override fun onShowPress(e: MotionEvent)

onSingleTapConfirmed

open override fun onSingleTapConfirmed(e: MotionEvent): Boolean

onSingleTapUp

open override fun onSingleTapUp(e: MotionEvent): Boolean

onTouchEvent

open fun onTouchEvent(e: MotionEvent, hitResult: HitResult): Boolean

onTransformChanged

open fun onTransformChanged()

The transformation (position, rotation or scale) of the Node has changed.

onWorldTransformChanged

open fun onWorldTransformChanged()

The transformation (position, rotation or scale) of the Node has changed.

overlapTest

fun overlapTest(): Node?

Tests to see if this node collision shape overlaps the collision shape of any other nodes in the scene using Node.collisionShape.

overlapTestAll

fun overlapTestAll(): List<Node>

Tests to see if a node is overlapping any other nodes within the scene using Node.collisionShape.

playAnimation

fun playAnimation(animationIndex: Int, speed: Float = 1.0f, loop: Boolean = true)

Applies rotation, translation, and scale to entities that have been targeted by the given animation definition. Uses TransformManager.

fun playAnimation(animationName: String, speed: Float = 1.0f, loop: Boolean = true)

removeChildNode

fun removeChildNode(node: Node): Node

removeChildNodes

fun removeChildNodes(nodes: Set<Node>): Node

scaleToUnitCube

fun scaleToUnitCube(units: Float = 1.0f)

Sets up a root transform on the current model to make it fit into a unit cube.

setAnimationSpeed

fun setAnimationSpeed(animationIndex: Int, speed: Float)

Sets the rate at which the animation is played.

fun setAnimationSpeed(animationName: String, speed: Float)

setBlendOrder

fun setBlendOrder(@IntRange(from = 0, to = 65535) blendOrder: Int)

Changes the drawing order for blended primitives.

setCulling

fun setCulling(enabled: Boolean)

Changes whether or not frustum culling is on.

setGlobalBlendOrderEnabled

fun setGlobalBlendOrderEnabled(enabled: Boolean)

Changes whether the blend order is global or local to this Renderable (by default).

setLayerMask

fun setLayerMask(@IntRange(from = 0, to = 255) select: Int, @IntRange(from = 0, to = 255) value: Int)

Changes the visibility bits.

setLayerVisible

fun setLayerVisible(visible: Boolean)

Changes the visibility.

setMaterialInstance

fun setMaterialInstance(materialInstance: MaterialInstance)

Changes the material instance binding for all primitives.

setMorphWeights

fun setMorphWeights(weights: FloatArray, @IntRange(from = 0) offset: Int = weights.size)

Updates the vertex morphing weights on a renderable, all zeroes by default.

setPriority

fun setPriority(@IntRange(from = 0, to = 7) priority: Int)

Changes the coarse-level draw ordering.

setScale

fun setScale(scale: Float)

The node scale.

setScreenSpaceContactShadows

fun setScreenSpaceContactShadows(enabled: Boolean)

Changes whether or not the renderable can use screen-space contact shadows.

stopAnimation

fun stopAnimation(animationIndex: Int)

fun stopAnimation(animationName: String)

transform

open fun transform(transform: Transform, smooth: Boolean = isSmoothTransformEnabled, smoothSpeed: Float = smoothTransformSpeed): Node

fun transform(position: Position = this.position, rotation: Rotation, scale: Scale = this.scale, smooth: Boolean = isSmoothTransformEnabled, smoothSpeed: Float = smoothTransformSpeed): Node

fun transform(position: Position = this.position, quaternion: Quaternion = this.quaternion, scale: Scale = this.scale, smooth: Boolean = isSmoothTransformEnabled, smoothSpeed: Float = smoothTransformSpeed): Node

Change the node transform.

worldTransform

open fun worldTransform(worldTransform: Transform, smooth: Boolean = isSmoothTransformEnabled, smoothSpeed: Float = smoothTransformSpeed): Node

fun worldTransform(position: Position = this.worldPosition, rotation: Rotation, scale: Scale = this.worldScale, smooth: Boolean = isSmoothTransformEnabled, smoothSpeed: Float = smoothTransformSpeed): Node

fun worldTransform(position: Position = this.worldPosition, quaternion: Quaternion = this.worldQuaternion, scale: Scale = this.worldScale, smooth: Boolean = isSmoothTransformEnabled, smoothSpeed: Float = smoothTransformSpeed): Node

Change the node world transform.

ModelNode

See also

Constructors

Types

Properties

Functions