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

TerrainAnchorNode

open class TerrainAnchorNode : AnchorNode

Types

Companion

object Companion

Properties

altitudeAboveTerrain

val altitudeAboveTerrain: Double

anchor

var anchor: Anchor

The node world positioned anchor

cameraTrackingState

open var cameraTrackingState: TrackingState

Is the AR camera tracking.

childNodes

var childNodes: Set<Node>

collider

var collider: Collider?

collisionShape

var collisionShape: CollisionShape?

collisionSystem

var collisionSystem: CollisionSystem?

editableScaleRange

var editableScaleRange: ClosedFloatingPointRange<Float>

editingTransforms

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

engine

val engine: Engine

entity

val entity: Entity

eusQuaternion

val eusQuaternion: Quaternion

frame

var frame: Frame?

isEditable

open var isEditable: Boolean

isFocusable

var Node.~~isFocusable~~: Boolean

isHittable

var isHittable: Boolean

isPositionEditable

open override var isPositionEditable: Boolean

isRotationEditable

open override var isRotationEditable: Boolean

isScaleEditable

open var isScaleEditable: Boolean

isSmoothTransformEnabled

var isSmoothTransformEnabled: Boolean

isTouchable

open var isTouchable: Boolean

isVisible

open override var isVisible: Boolean

latitude

val latitude: Double

localPosition

var Node.~~localPosition~~: Float3

localRotation

var Node.~~localRotation~~: Float3

localScale

var Node.~~localScale~~: Float3

longitude

val longitude: Double

moveHitTest

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

name

open var name: String?

onAddedToScene

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

onAnchorChanged

var onAnchorChanged: (Anchor) -> 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?

onPoseChanged

var onPoseChanged: (Pose) -> 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?

onTrackingStateChanged

var onTrackingStateChanged: (TrackingState) -> Unit?

onUpdated

var onUpdated: (Anchor) -> Unit?

parent

open var parent: Node?

parentEntity

var parentEntity: Entity?

parentInstance

var parentInstance: EntityInstance?

pose

var pose: Pose

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

position

open var position: Position

quaternion

open var quaternion: Quaternion

rotation

open var rotation: Rotation

scale

open var scale: Scale

session

var session: Session?

smoothTransform

var smoothTransform: Transform?

smoothTransformSpeed

var smoothTransformSpeed: Float

trackingState

open var trackingState: TrackingState

The anchor TrackingState of this Node.

transform

open var transform: Transform

transformInstance

val transformInstance: Int

transformManager

val transformManager: TransformManager

updateAnchorPose

var updateAnchorPose: Boolean

Should the anchor automatically update the anchor new pose

visibleCameraTrackingStates

var visibleCameraTrackingStates: Set<TrackingState>

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

visibleTrackingStates

var visibleTrackingStates: Set<TrackingState>

Set the node to be visible only on those tracking states

worldPosition

open var worldPosition: Position

worldQuaternion

open var worldQuaternion: Quaternion

worldRotation

open var worldRotation: Rotation

worldScale

open var worldScale: Scale

worldToLocal

val worldToLocal: Transform

worldTransform

var worldTransform: Transform

Functions

addChildNode

fun addChildNode(node: Node): Node

addChildNodes

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

animateScales

fun animateScales(vararg scales: Scale): ObjectAnimator

animateTransforms

fun animateTransforms(vararg transforms: Transform): AnimatorSet

clearChildNodes

fun clearChildNodes(): Node

createAnchor

open fun createAnchor(): Anchor?

Defines a tracked location in the physical world at the actual pose.

createAnchorNode

open fun createAnchorNode(): AnchorNode?

Defines a tracked AnchorNode in the physical world at the actual pose.

destroy

open override fun destroy()

detachAnchor

open fun detachAnchor()

getLocalPosition

fun getLocalPosition(worldPosition: Position): Float3

getLocalQuaternion

fun getLocalQuaternion(worldQuaternion: Quaternion): Quaternion

getLocalRotation

fun getLocalRotation(worldRotation: Rotation): Float3

getLocalScale

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

getWorldScale

fun getWorldScale(scale: Scale): Float3

getWorldTransform

fun getWorldTransform(localTransform: Transform): Mat4

fun getWorldTransform(node: Node): Mat4

lookAt

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

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

lookTowards

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

onAddedToScene

open fun onAddedToScene(scene: Scene)

onCameraTrackingChanged

open fun onCameraTrackingChanged(trackingState: TrackingState)

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

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

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

onMoveBegin

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

onMoveEnd

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

onPoseChanged

open fun onPoseChanged(pose: Pose)

onRemovedFromScene

open fun onRemovedFromScene(scene: Scene)

onRotate

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

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

onRotateBegin

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

onRotateEnd

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

onScale

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

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

onScaleBegin

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

onScaleEnd

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

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

onUpdated

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

onWorldTransformChanged

open fun onWorldTransformChanged()

overlapTest

fun overlapTest(): Node?

overlapTestAll

fun overlapTestAll(): List<Node>

removeChildNode

fun removeChildNode(node: Node): Node

removeChildNodes

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

setScale

fun setScale(scale: Float)

transform

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

update

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

worldTransform

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