arsceneview/io.github.sceneview.ar.node/TrackableNode

TrackableNode

open class TrackableNode<T : Trackable>(engine: Engine, val visibleTrackingStates: Set<TrackingState> = setOf(TrackingState.TRACKING), var onTrackingStateChanged: (TrackingState) -> Unit? = null, var onUpdated: (T) -> Unit? = null) : PoseNode

AR Trackable positioned node.

A Trackable is something that ARCore can track and that Anchors can be attached to

Inheritors

AugmentedFaceNode

AugmentedImageNode

StreetscapeGeometryNode

Constructors

constructor(engine: Engine, visibleTrackingStates: Set<TrackingState> = setOf(TrackingState.TRACKING), onTrackingStateChanged: (TrackingState) -> Unit? = null, onUpdated: (T) -> Unit? = null)

Properties

val anchors: Collection<Anchor>

Gets the Anchors attached to this node trackable.

cameraTrackingState

open var cameraTrackingState: TrackingState

Is the AR camera tracking.

var childNodes: Set<Node>

var collider: Collider?

var collisionShape: CollisionShape?

collisionSystem

var collisionSystem: CollisionSystem?

editableScaleRange

var editableScaleRange: ClosedFloatingPointRange<Float>

editingTransforms

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

val engine: Engine

val entity: Entity

var frame: Frame?

open var isEditable: Boolean

var Node.~~isFocusable~~: Boolean

var isHittable: Boolean

isPositionEditable

open var isPositionEditable: Boolean

isRotationEditable

open override var isRotationEditable: Boolean

isScaleEditable

open var isScaleEditable: Boolean

isSmoothTransformEnabled

var isSmoothTransformEnabled: Boolean

open var isTouchable: Boolean

open override var isVisible: Boolean

var Node.~~localPosition~~: Float3

var Node.~~localRotation~~: Float3

var Node.~~localScale~~: Float3

var moveHitTest: PoseNode.(Frame, MotionEvent) -> HitResult?

open var name: String?

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

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

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

onDoubleTapEvent

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

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

onEditingChanged

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

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

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

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

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

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

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

var onPoseChanged: (Pose) -> Unit?

onRemovedFromScene

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

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

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

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

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

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

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

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

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

onSingleTapConfirmed

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

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

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

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

onTrackingStateChanged

var onTrackingStateChanged: (TrackingState) -> Unit?

var onUpdated: (T) -> Unit?

open var parent: Node?

var parentEntity: Entity?

var parentInstance: EntityInstance?

var pose: Pose

The position of the intersection between a ray and detected real-world geometry.

open var position: Position

open var quaternion: Quaternion

open var rotation: Rotation

open var scale: Scale

var session: Session?

smoothTransform

var smoothTransform: Transform?

smoothTransformSpeed

var smoothTransformSpeed: Float

var trackable: T?

The node world positioned trackable

var trackingState: TrackingState

The TrackingState of this Node.

open var transform: Transform

transformInstance

val transformInstance: Int

transformManager

val transformManager: TransformManager

visibleCameraTrackingStates

var visibleCameraTrackingStates: Set<TrackingState>

Set the node to be visible only on those camera tracking states

visibleTrackingStates

val visibleTrackingStates: Set<TrackingState>

Set the node to be visible only on those tracking states

open var worldPosition: Position

worldQuaternion

open var worldQuaternion: Quaternion

open var worldRotation: Rotation

open var worldScale: Scale

val worldToLocal: Transform

var worldTransform: Transform

Functions

fun addChildNode(node: Node): Node

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

addLifecycleListener

fun Node.~~addLifecycleListener~~(listener: Any?): Nothing?

addTransformChangedListener

fun Node.~~addTransformChangedListener~~(listener: Any?): Nothing?

animatePositions

fun animatePositions(vararg positions: Position): ObjectAnimator

animateQuaternions

fun animateQuaternions(vararg quaternions: Quaternion): ObjectAnimator

animateRotations

fun animateRotations(vararg rotations: Rotation): ObjectAnimator

fun animateScales(vararg scales: Scale): ObjectAnimator

animateTransforms

fun animateTransforms(vararg transforms: Transform): AnimatorSet

clearChildNodes

fun clearChildNodes(): Node

open override fun createAnchor(): Anchor?

Creates an anchor that is attached to this trackable, using the given initial pose in the world coordinate space.

createAnchorNode

open override fun createAnchorNode(): AnchorNode?

Creates an AnchorNode that is attached to this trackable, using the given initial pose in the world coordinate space.

open fun destroy()

getLocalPosition

fun getLocalPosition(worldPosition: Position): Float3

getLocalQuaternion

fun getLocalQuaternion(worldQuaternion: Quaternion): Quaternion

getLocalRotation

fun getLocalRotation(worldRotation: Rotation): Float3

fun getLocalScale(worldScale: Scale): Float3

getLocalTransform

fun getLocalTransform(worldTransform: Transform): Mat4

fun getLocalTransform(node: Node): Mat4

getTransformationMatrix

open override fun getTransformationMatrix(): Matrix

getWorldPosition

fun getWorldPosition(localPosition: Position): Float3

getWorldQuaternion

fun getWorldQuaternion(quaternion: Quaternion): Quaternion

getWorldRotation

fun getWorldRotation(rotation: Rotation): Float3

fun getWorldScale(scale: Scale): Float3

getWorldTransform

fun getWorldTransform(localTransform: Transform): Mat4

fun getWorldTransform(node: Node): Mat4

fun lookAt(targetWorldPosition: Position, upDirection: Direction, smooth: Boolean, smoothSpeed: Float): Node

fun lookAt(targetNode: Node, upDirection: Direction, smooth: Boolean, smoothSpeed: Float): Node

fun lookTowards(lookDirection: Direction, upDirection: Direction, smooth: Boolean, smoothSpeed: Float): Node

open fun onAddedToScene(scene: Scene)

onCameraTrackingChanged

open fun onCameraTrackingChanged(trackingState: TrackingState)

open override fun onContextClick(e: MotionEvent): Boolean

open override fun onDoubleTap(e: MotionEvent): Boolean

onDoubleTapEvent

open override fun onDoubleTapEvent(e: MotionEvent): Boolean

open override fun onDown(e: MotionEvent): Boolean

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

open fun onFrame(frameTimeNanos: Long)

open override fun onLongPress(e: MotionEvent)

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

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

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

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

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

open fun onPoseChanged(pose: Pose)

onRemovedFromScene

open fun onRemovedFromScene(scene: Scene)

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

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

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

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

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

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

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

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

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

open override fun onShowPress(e: MotionEvent)

onSingleTapConfirmed

open override fun onSingleTapConfirmed(e: MotionEvent): Boolean

open override fun onSingleTapUp(e: MotionEvent): Boolean

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

onTransformChanged

open fun onTransformChanged()

fun Node.~~onUpdated~~(node: Node, frameTime: Long): Nothing?

onWorldTransformChanged

open fun onWorldTransformChanged()

fun overlapTest(): Node?

fun overlapTestAll(): List<Node>

removeChildNode

fun removeChildNode(node: Node): Node

removeChildNodes

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

fun setScale(scale: Float)

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

fun transform(position: Position, rotation: Rotation, scale: Scale, smooth: Boolean, smoothSpeed: Float): Node

fun transform(position: Position, quaternion: Quaternion, scale: Scale, smooth: Boolean, smoothSpeed: Float): Node

open fun update(trackable: T?)

open override fun update(session: Session, frame: Frame)

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

fun worldTransform(position: Position, rotation: Rotation, scale: Scale, smooth: Boolean, smoothSpeed: Float): Node

fun worldTransform(position: Position, quaternion: Quaternion, scale: Scale, smooth: Boolean, smoothSpeed: Float): Node