sceneview/io.github.sceneview.node/CameraNode

CameraNode

open class CameraNode(val engine: Engine, val entity: Entity) : Node, CameraComponent

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

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

Inheritors

DefaultCameraNode

CameraNode

Constructors

CameraNode

constructor(engine: Engine, camera: Camera.() -> Unit = {})

constructor(engine: Engine, entity: Entity)

Properties

aperture

open val aperture: Float

Gets the aperture in f-stops

camera

open val camera: FilamentCamera

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?

cullingFar

open val cullingFar: Float

Gets the distance to the far plane

cullingProjectionTransform

open val cullingProjectionTransform: Mat4

Retrieves the camera's culling matrix. The culling matrix is the same as the projection matrix, except the far plane is finite.

editableScaleRange

var editableScaleRange: ClosedFloatingPointRange<Float>

editingTransforms

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

engine

val engine: Engine

entity

val entity: Entity

far

open override var far: Float

focalLength

open override var focalLength: Double

Gets the focal length in meters

focusDistance

open var focusDistance: Float

The distance from the camera to the focus plane in world units

forwardDirection

open val forwardDirection: Direction

Retrieves the camera forward unit vector in world space, that is a unit vector that points in the direction the camera is looking at.

isEditable

open override var isEditable: Boolean

isHittable

var isHittable: Boolean

isPositionEditable

open var isPositionEditable: Boolean

isRotationEditable

open var isRotationEditable: Boolean

isScaleEditable

open var isScaleEditable: Boolean

isSmoothTransformEnabled

var isSmoothTransformEnabled: Boolean

isTouchable

open override var isTouchable: Boolean

The node can be selected when a touch event happened.

isVisible

open var isVisible: Boolean

The visible state of this node.

leftDirection

open val leftDirection: Direction

Retrieves the camera left unit vector in world space, that is a unit vector that points to the left of the camera.

modelTransform

open var modelTransform: Transform

The camera's model matrix.

name

open var name: String?

near

open override var near: Float

Gets the distance to the near plane

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.

projectionTransform

open var projectionTransform: Mat4

Retrieves the camera's projection matrix. The projection matrix used for rendering always has its far plane set to infinity. This is why it may differ from the matrix set through setProjection() or setLensProjection().

quaternion

open var quaternion: Quaternion

Quaternion rotation.

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.

scaling

open val scaling: Float4

Returns the scaling amount used to scale the projection matrix.

sensitivity

open val sensitivity: Float

Gets the sensitivity in ISO

shutterSpeed

open val shutterSpeed: Float

Gets the shutter speed in seconds

smoothTransform

var smoothTransform: Transform?

smoothTransformSpeed

var smoothTransformSpeed: Float

The smooth position, rotation and scale speed.

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

upDirection

open val upDirection: Direction

Retrieves the camera up unit vector in world space, that is a unit vector that points up with respect to the camera.

view

var view: View?

viewport

val viewport: Viewport?

viewTransform

open val viewTransform: Transform

Retrieves the camera's view matrix. The view matrix is the inverse of the model matrix.

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.

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.

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.

hitTest

fun ~~hitTest~~(motionEvent: MotionEvent): List<HitResult>

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

Tests to see if a ray starting from the screen/camera position is hitting any nodes within the scene and returns a list of HitTestResults containing all of the nodes that were hit, sorted by distance.

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

Tests to see if a ray is hitting any nodes within the scene and returns a list of HitTestResults containing all of the nodes that were hit, sorted by distance.

hitTestView

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

lookAt

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

Sets the camera's model matrix.

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.

motionEventToRay

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

onAddedToScene

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

screenPointToRay

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

Calculates a ray in world space going from the near-plane of the camera and going through a point in screen space.

setCustomProjection

open fun setCustomProjection(inProjection: Transform, near: Double = camera.near.toDouble(), far: Double = camera.cullingFar.toDouble(), inProjectionForCulling: Transform = inProjection)

Sets a custom projection matrix.

setExposure

open fun setExposure(exposure: Float)

Sets this camera's exposure directly. Calling this method will set the aperture to 1.0, the shutter speed to 1.2 and the sensitivity will be computed to match the requested exposure (for a desired exposure of 1.0, the sensitivity will be set to 100 ISO).

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

Sets this camera's exposure (default is f/16, 1/125s, 100 ISO)

setLensProjection

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

Sets the projection matrix from the focal length.

setProjection

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

fun setProjection(fovInDegrees: Double, near: Float = _near, far: Float = _far, direction: Camera.Fov = Camera.Fov.VERTICAL, aspect: Double = getViewPortAspect())

Sets the projection matrix from the field-of-view.

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

Sets the projection matrix from a frustum defined by six planes.

setScale

fun setScale(scale: Float)

The node scale.

setScaling

open fun setScaling(scaling: Float2)

Sets an additional matrix that scales the projection matrix.

setShift

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

Sets an additional matrix that shifts (translates) the projection matrix.

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.

updateProjection

open fun updateProjection(focalLength: Double = _focalLength, near: Float = _near, far: Float = _far, aspect: Double = getViewPortAspect())

Sets the projection matrix from the focal length.

viewToRay

open fun viewToRay(viewPosition: Float2): Ray

Calculates a ray in world space going from the near-plane of the camera and through a point in view space.

viewToWorld

open fun viewToWorld(viewPosition: Float2, z: Float = 1.0f): Float3

Get a world space position from a view space position.

worldToScreenPoint

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

Convert a point from world space into screen space.

worldToView

open fun worldToView(worldPosition: Position): Float2

Get a view space position from a world position.

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.