geo-ar/com.getwemap.sdk.geoar.entities/GeoCameraNode

GeoCameraNode

class GeoCameraNode : CameraNode, GeoComponent

Properties

aperture

open val aperture: Float

attitude

open override var attitude: Attitude

camera

open val camera: FilamentCamera

childNodes

var childNodes: Set<Node>

collider

var collider: Collider?

collisionShape

var collisionShape: CollisionShape?

collisionSystem

var collisionSystem: CollisionSystem?

coordinate

open override var coordinate: Coordinate

cullingFar

open val cullingFar: Float

cullingProjectionTransform

open val cullingProjectionTransform: Transform

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

focusDistance

open var focusDistance: Float

forwardDirection

open val forwardDirection: Direction

headingDegrees

open var headingDegrees: Double

headingRadians

open var headingRadians: Double

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

isVisible

open var isVisible: Boolean

leftDirection

open val leftDirection: Direction

modelTransform

open var modelTransform: Transform

name

open var name: String?

near

open override var near: Float

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?

parentEntity

var parentEntity: Entity?

parentInstance

var parentInstance: EntityInstance?

position

open var position: Position

projectionTransform

open override var projectionTransform: Transform

quaternion

open var quaternion: Quaternion

rotation

open var rotation: Rotation

scale

open var scale: Scale

scaling

open val scaling: Float4

sensitivity

open val sensitivity: Float

shutterSpeed

open val shutterSpeed: Float

smoothTransform

var smoothTransform: Transform?

smoothTransformSpeed

var smoothTransformSpeed: Float

transform

open var transform: Transform

transformInstance

val transformInstance: Int

transformManager

val transformManager: TransformManager

upDirection

open val upDirection: Direction

view

var view: View?

viewport

val viewport: Viewport?

viewTransform

open val viewTransform: Transform

worldPosition

open var worldPosition: Position

worldQuaternion

open var worldQuaternion: Quaternion

worldRotation

open var worldRotation: Rotation

worldScale

open var worldScale: Scale

worldSky

open val worldSky: Float3

It corresponds to sky direction

worldToLocal

val worldToLocal: Transform

worldTransform

var worldTransform: Transform

Functions

addChildNode

fun addChildNode(node: Node): Node

addChildNodes

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

animatePositions

fun animatePositions(vararg positions: Float3): ObjectAnimator

animateQuaternions

fun animateQuaternions(vararg quaternions: Quaternion): ObjectAnimator

animateRotations

fun animateRotations(vararg rotations: Float3): ObjectAnimator

animateScales

fun animateScales(vararg scales: Float3): ObjectAnimator

animateTransforms

fun animateTransforms(vararg transforms: Mat4): AnimatorSet

clearChildNodes

fun clearChildNodes(): Node

destroy

open override fun destroy()

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

getViewPortAspect

fun getViewPortAspect(): Double

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

hitTest

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

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

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

hitTestView

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

lookAt

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

lookTowards

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

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

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)

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

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

screenPointToRay

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

setCustomProjection

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

setExposure

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)

setProjection

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)

setScale

fun setScale(scale: Float)

setScaling

open fun setScaling(scaling: Float2)

setShift

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

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

updateOrientation

open fun updateOrientation()

updatePosition

open fun updatePosition()

updateProjection

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

viewToRay

open fun viewToRay(viewPosition: Float2): Ray

viewToWorld

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

worldToScreenPoint

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

worldToView

open fun worldToView(worldPosition: Position): Float2

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