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

CloudAnchorNode

open class CloudAnchorNode(engine: Engine, anchor: Anchor, cloudAnchorId: String? = null, var onTrackingStateChanged: (TrackingState) -> Unit? = null, var onUpdated: (Anchor?) -> Unit? = null, var onHosted: (cloudAnchorId: String?, state: Anchor.CloudAnchorState) -> Unit? = null) : AnchorNode

Constructors

CloudAnchorNode

constructor(engine: Engine, anchor: Anchor, cloudAnchorId: String? = null, onTrackingStateChanged: (TrackingState) -> Unit? = null, onUpdated: (Anchor?) -> Unit? = null, onHosted: (cloudAnchorId: String?, state: Anchor.CloudAnchorState) -> Unit? = null)

Types

object Companion

Properties

var anchor: Anchor

The node world positioned anchor

cameraTrackingState

open var cameraTrackingState: TrackingState

Is the AR camera tracking.

var childNodes: Set<Node>

var cloudAnchorId: String?

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?

var hostState: Anchor.CloudAnchorState

The current cloud anchor state of the anchor.

var hostTask: HostCloudAnchorFuture?

open var isEditable: Boolean

var Node.~~isFocusable~~: Boolean

var isHittable: Boolean

isPositionEditable

open override 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?

onAnchorChanged

var onAnchorChanged: (Anchor) -> 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 onHosted: (cloudAnchorId: String?, state: Anchor.CloudAnchorState) -> 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: (Anchor) -> 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

open var trackingState: TrackingState

The anchor TrackingState of this Node.

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

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

fun cancelHost()

clearChildNodes

fun clearChildNodes(): Node

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.

open override fun destroy()

open fun detachAnchor()

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 host(session: Session, ttlDays: Int = 1, onCompleted: (cloudAnchorId: String?, state: Anchor.CloudAnchorState) -> Unit? = null)

Hosts a Cloud Anchor based on the Anchor

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 fun onHosted(cloudAnchorId: String?, state: Anchor.CloudAnchorState)

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