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

ARCameraNode

open class ARCameraNode(engine: Engine) : CameraNode

Represents a virtual camera, which determines the perspective through which the scene is viewed.

If the camera is part of an ARSceneView, then the camera automatically tracks the camera pose from ARCore.

The following methods will throw [ ] when called:

parent - CameraNode's parent cannot be changed, it is always the scene.
position - CameraNode's position cannot be changed, it is controlled by the ARCore camera pose.
rotation - CameraNode's rotation cannot be changed, it is controlled by the ARCore camera pose.

All other functionality in Node is supported. You can access the position and rotation of the camera, assign a collision shape to the camera, or add children to the camera. Disabling the camera turns off rendering.

Inheritors

DefaultARCameraNode

Constructors

constructor(engine: Engine)

Properties

open val aperture: Float

open val camera: FilamentCamera

var childNodes: Set<Node>

var collider: Collider?

var collisionShape: CollisionShape?

collisionSystem

var collisionSystem: CollisionSystem?

open val cullingFar: Float

cullingProjectionTransform

open val cullingProjectionTransform: Transform

editableScaleRange

var editableScaleRange: ClosedFloatingPointRange<Float>

editingTransforms

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

val engine: Engine

val entity: Entity

open override var far: Float

open override var focalLength: Double

open var focusDistance: Float

forwardDirection

open val forwardDirection: Direction

var frame: Frame?

open override var isEditable: Boolean

var Node.~~isFocusable~~: Boolean

var isHittable: Boolean

isPositionEditable

open var isPositionEditable: Boolean

isRotationEditable

open var isRotationEditable: Boolean

isScaleEditable

open var isScaleEditable: Boolean

isSmoothTransformEnabled

var isSmoothTransformEnabled: Boolean

open override var isTouchable: Boolean

open var isVisible: Boolean

open val leftDirection: Direction

var Node.~~localPosition~~: Float3

var Node.~~localRotation~~: Float3

var Node.~~localScale~~: Float3

open var modelTransform: Transform

open var name: String?

open override var near: Float

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?

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?

open var parent: Node?

var parentEntity: Entity?

var parentInstance: EntityInstance?

open var pose: Pose?

The virtual camera pose in world space for rendering AR content onto the latest frame.

open var position: Position

projectionTransform

open var projectionTransform: Transform

open var quaternion: Quaternion

open var rotation: Rotation

open var scale: Scale

open val scaling: Float4

open val sensitivity: Float

var session: Session?

open val shutterSpeed: Float

smoothTransform

var smoothTransform: Transform?

smoothTransformSpeed

var smoothTransformSpeed: Float

open var trackingState: TrackingState

The TrackingState of this Node.

open var transform: Transform

transformInstance

val transformInstance: Int

transformManager

val transformManager: TransformManager

open val upDirection: Direction

var view: View?

val viewport: Viewport?

open val viewTransform: Transform

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 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 ~~hitTest~~(motionEvent: MotionEvent): List<HitResult>

fun ~~hitTest~~(ray: Ray): List<HitResult>

fun ~~hitTest~~(xPx: Float, yPx: Float): List<HitResult>

fun ~~hitTestView~~(xViewPercent: Float, yViewPercent: Float): List<HitResult>

open fun lookAt(eye: Position, center: Position, up: Direction)

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

motionEventToRay

fun ~~motionEventToRay~~(motionEvent: MotionEvent): Ray

open fun onAddedToScene(scene: Scene)

onCameraUpdated

open fun onCameraUpdated(camera: Camera)

Updates the current projection and pose of the camera in world space.

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, worldPosition: Position): Boolean

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

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

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

onTrackingStateChanged

open fun onTrackingStateChanged(trackingState: TrackingState)

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

screenPointToRay

fun ~~screenPointToRay~~(x: Float, y: Float): Ray

setCustomProjection

open fun setCustomProjection(inProjection: Transform, near: Double, far: Double, inProjectionForCulling: Transform)

open fun setExposure(exposure: Float)

open fun setExposure(aperture: Float, shutterSpeed: Float, sensitivity: Float)

setLensProjection

open fun setLensProjection(focalLength: Double, aspect: Double, near: Double, far: Double)

open fun setProjection(fovInDegrees: Double, aspect: Double, near: Double, far: Double, direction: Camera.Fov)

open fun setProjection(projection: Camera.Projection, left: Double, right: Double, bottom: Double, top: Double, near: Double, far: Double)

fun setProjection(fovInDegrees: Double, near: Float, far: Float, direction: Camera.Fov, aspect: Double)

fun setScale(scale: Float)

open fun setScaling(scaling: Float2)

open fun setShift(xShift: Double, yShift: Double)

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(session: Session, frame: Frame)

updateProjection

open fun updateProjection(focalLength: Double, near: Float, far: Float, aspect: Double)

open fun viewToRay(viewPosition: Float2): Ray

open fun viewToWorld(viewPosition: Float2, z: Float): Position

worldToScreenPoint

fun ~~worldToScreenPoint~~(point: Vector3): Vector3

open fun worldToView(worldPosition: Position): Float2

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