sceneview/io.github.sceneview.node/ViewNode2

ViewNode2

class ViewNode2(val engine: Engine, val windowManager: ViewNode2.WindowManager, materialLoader: MaterialLoader, view: View, unlit: Boolean = false, invertFrontFaceWinding: Boolean = false, val imageReaderMaxImages: Int = 7) : PlaneNode

A Node that can display an Android View

This node contains a View for the rendering engine to render.

Manages a FrameLayout that is attached directly to a WindowManager that other views can be added and removed from.

To render a View, the View must be attached to a WindowManager so that it can be properly drawn. This class encapsulates a FrameLayout that is attached to a WindowManager that other views can be added to as children. This allows us to safely and correctly draw the View associated with a Entity and a MaterialInstance while keeping them isolated from the rest of the activities View hierarchy.

Additionally, this manages the lifecycle of the window to help ensure that the window is added/removed from the WindowManager at the appropriate times.

Parameters

view

The 2D Android View that is rendered by this ViewNode2

unlit

True to disable all lights influences on the rendered view

invertFrontFaceWinding

Inverts the winding order of front faces. Inverting the winding order of front faces is useful when rendering mirrored reflections (water, mirror surfaces, front camera in AR, etc.). True to invert front faces, false otherwise

Constructors

ViewNode2

constructor(engine: Engine, windowManager: ViewNode2.WindowManager, materialLoader: MaterialLoader, @LayoutRes viewLayoutRes: Int, unlit: Boolean = false, invertFrontFaceWinding: Boolean = false)

constructor(engine: Engine, windowManager: ViewNode2.WindowManager, materialLoader: MaterialLoader, unlit: Boolean = false, invertFrontFaceWinding: Boolean = false, content: @Composable () -> Unit)

Set the Jetpack Compose UI content for this view. Initial composition will occur when the view becomes attached to a window or when createComposition is called, whichever comes first.

constructor(engine: Engine, windowManager: ViewNode2.WindowManager, materialLoader: MaterialLoader, view: View, unlit: Boolean = false, invertFrontFaceWinding: Boolean = false, imageReaderMaxImages: Int = 7)

Types

Layout

@RequiresApi(value = 28)

inner class Layout @JvmOverloads constructor(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0, defStyleRes: Int = 0) : FrameLayout

Used to render an Android view to a native open GL texture that can then be rendered by Filament.

WindowManager

class WindowManager(context: Context)

Properties

axisAlignedBoundingBox

open var axisAlignedBoundingBox: Box

Changes the bounding box used for frustum culling.

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>>

enabledAttributes

open val enabledAttributes: List<MutableSet<VertexBuffer.VertexAttribute>>

Retrieves the set of enabled attribute slots in the given primitive's VertexBuffer.

engine

val engine: Engine

entity

val entity: Entity

geometry

open override val geometry: Plane

imageReaderMaxImages

val imageReaderMaxImages: Int = 7

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

open var isShadowCaster: Boolean

Changes whether or not the renderable casts shadows.

isShadowReceiver

open 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.

layout

val layout: ViewNode2.Layout

materialInstance

open var materialInstance: MaterialInstance

Changes the material instance binding for the first primitive.

materialInstances

open var materialInstances: List<MaterialInstance>

Changes the material instance binding for the given primitive.

morphTargetCount

open val morphTargetCount: Int

Gets the morph target count on a renderable.

name

open var name: String?

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?

position

open var position: Position

Position to locate within the coordinate system the parent.

primitiveCount

@get:IntRange(from = 0)

open val primitiveCount: Int

Gets the immutable number of primitives in the given renderable.

pxPerUnits

var pxPerUnits: Float

quaternion

open var quaternion: Quaternion

Quaternion rotation.

renderableInstance

open val renderableInstance: RenderableInstance

renderableManager

open val renderableManager: RenderableManager

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.

smoothTransform

var smoothTransform: Transform?

smoothTransformSpeed

var smoothTransformSpeed: Float

The smooth position, rotation and scale speed.

stream

val stream: Stream

surface

var surface: Surface?

texture

val texture: Texture

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

viewSize

var viewSize: Float3

windowManager

val windowManager: ViewNode2.WindowManager

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

clearChildNodes

fun clearChildNodes(): Node

destroy

open override fun destroy()

Detach and destroy the node and all its children.

getLightChannel

open fun getLightChannel(@IntRange(from = 0, to = 7) channel: Int): Boolean

Returns whether a light channel is enabled on a specified renderable

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.

getMaterialInstanceAt

open fun getMaterialInstanceAt(@IntRange(from = 0) primitiveIndex: Int): MaterialInstance

Creates a MaterialInstance Java wrapper object for a particular material instance.

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 override 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 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 override 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 override 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.

removeChildNode

fun removeChildNode(node: Node): Node

removeChildNodes

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

set

open operator fun List<MaterialInstance>.set(@IntRange(from = 0) primitiveIndex: Int, materialInstance: MaterialInstance)

setBlendOrder

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

Changes the drawing order for blended primitives.

setBlendOrderAt

open fun setBlendOrderAt(@IntRange(from = 0) primitiveIndex: Int, @IntRange(from = 0, to = 65535) blendOrder: Int)

Changes the drawing order for blended primitives. The drawing order is either global or local (default) to this Renderable.

setBonesAsMatrices

open fun setBonesAsMatrices(matrices: Buffer, @IntRange(from = 0, to = 255) boneCount: Int, @IntRange(from = 0) offset: Int)

Sets the transforms associated with each bone of a Renderable.

setBonesAsQuaternions

open fun setBonesAsQuaternions(quaternions: Buffer, @IntRange(from = 0, to = 255) boneCount: Int, @IntRange(from = 0) offset: Int)

Sets the transforms associated with each bone of a Renderable

setCulling

open fun setCulling(enabled: Boolean)

Changes whether or not frustum culling is on.

setGeometry

open fun setGeometry(geometry: Geometry)

Changes the geometry for the given renderable instance.

setGeometryAt

open fun setGeometryAt(@IntRange(from = 0) primitiveIndex: Int, type: RenderableManager.PrimitiveType, vertices: VertexBuffer, indices: IndexBuffer, @IntRange(from = 0) offset: Int = 0, @IntRange(from = 0) count: Int = indices.indexCount)

Changes the geometry for the given primitive.

setGlobalBlendOrderEnabled

open fun setGlobalBlendOrderEnabled(enabled: Boolean)

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

setGlobalBlendOrderEnabledAt

open fun setGlobalBlendOrderEnabledAt(@IntRange(from = 0) primitiveIndex: Int, enabled: Boolean)

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

setLayerMask

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

Changes the visibility bits.

setLayerVisible

open fun setLayerVisible(visible: Boolean)

Changes the visibility.

setLightChannel

open fun setLightChannel(@IntRange(from = 0, to = 7) channel: Int, enable: Boolean)

Enables or disables a light channel.

setMaterialInstanceAt

open fun setMaterialInstanceAt(@IntRange(from = 0) primitiveIndex: Int, materialInstance: MaterialInstance)

Changes the material instance binding for the given primitive.

setMaterialInstances

open fun setMaterialInstances(materialInstance: MaterialInstance)

Changes the material instance binding for all primitives.

setMorphTargetBufferAt

open fun setMorphTargetBufferAt(@IntRange(from = 0) level: Int, @IntRange(from = 0) primitiveIndex: Int, morphTargetBuffer: MorphTargetBuffer)

Utility method to change morph target buffer for the given primitive.

open fun setMorphTargetBufferAt(@IntRange(from = 0) level: Int, @IntRange(from = 0) primitiveIndex: Int, morphTargetBuffer: MorphTargetBuffer, @IntRange(from = 0) offset: Int, @IntRange(from = 0) count: Int)

Changes the morph target buffer for the given primitive.

setMorphWeights

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

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

setPriority

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

Changes the coarse-level draw ordering.

setScale

fun setScale(scale: Float)

The node scale.

setScreenSpaceContactShadows

open fun setScreenSpaceContactShadows(enabled: Boolean)

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

setSkinningBuffer

open fun setSkinningBuffer(skinningBuffer: SkinningBuffer, count: Int, offset: Int)

Associates a SkinningBuffer to a renderable instance.

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.

updateCollisionShape

fun updateCollisionShape()

updateGeometry

fun updateGeometry(vertices: List<Geometry.Vertex> = geometry.vertices, indices: List<List<Int>> = geometry.primitivesIndices)

fun updateGeometry(size: Size = geometry.size, center: Position = geometry.center, normal: Direction = geometry.normal, uvScale: UvScale = geometry.uvScale)

updateGeometrySize

fun updateGeometrySize()

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.