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

AugmentedFaceNode

open class AugmentedFaceNode(engine: Engine, val augmentedFace: AugmentedFace, meshMaterialInstance: MaterialInstance? = null, builder: RenderableManager.Builder.() -> Unit = {}, onTrackingStateChanged: (TrackingState) -> Unit? = null, onUpdated: (AugmentedFace) -> Unit? = null) : TrackableNode<AugmentedFace>

AR Augmented Face positioned 3D model node

Describes a face detected by ARCore and provides methods to access additional center and face region poses as well as face mesh related data.

Augmented Faces supports front-facing (selfie) camera only, and does not support attaching anchors nor raycast hit testing. Trackable.createAnchor will result in an IllegalStateException.

To use Augmented Faces, enable the feature in the session. This can be done at session creation time, or at any time during session runtime:

Session session = new Session(context, EnumSet.of(Session.Feature.FRONT_CAMERA));
Config config = ...
config.setAugmentedFaceMode(AugmentedFaceMode.MESH3D);
session.configure(config);
}

When Augmented Face mode is enabled, ARCore updates the list of detected faces for each frame. Use Session.getAllTrackables and Trackable.getTrackingState to get a list of faces that have valid meshes that can be rendered.

for (AugmentedFace face : session.getAllTrackables(AugmentedFace.class)) {
  if (face.getTrackingState() == TrackingState.TRACKING) {
    // Render face mesh ...
  }
}
}

Faces provide static mesh data that does not change during the session, as well as pose and mesh data that is updated each frame:

// UVs and indices can be cached as they do not change during the session.
FloatBuffer uvs = face.getMeshTextureCoordinates();
ShortBuffer indices = face.getMeshTriangleIndices();

// Center and region poses, mesh vertices, and normals are updated each frame.
Pose facePose = face.getCenterPose();
FloatBuffer faceVertices = face.getMeshVertices();
FloatBuffer faceNormals = face.getMeshNormals();
}

Constructors

AugmentedFaceNode

constructor(engine: Engine, augmentedFace: AugmentedFace, meshMaterialInstance: MaterialInstance? = null, builder: RenderableManager.Builder.() -> Unit = {}, onTrackingStateChanged: (TrackingState) -> Unit? = null, onUpdated: (AugmentedFace) -> Unit? = null)

Properties

val anchors: Collection<Anchor>

Gets the Anchors attached to this node trackable.

val augmentedFace: AugmentedFace

cameraTrackingState

open var cameraTrackingState: TrackingState

Is the AR camera tracking.

val centerNode: PoseNode

The center of the face, defined to have the origin located behind the nose and between the two cheek bones.

var childNodes: Set<Node>

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?

open var isEditable: Boolean

var Node.~~isFocusable~~: Boolean

var isHittable: Boolean

isPositionEditable

open 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

val meshNode: MeshNode

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

open var name: String?

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?

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

val regionNodes: Map<AugmentedFace.RegionType, PoseNode>

The region nodes at the tip of the nose, the detected face's left side of the forehead, the detected face's right side of the forehead.

open var rotation: Rotation

open var scale: Scale

var session: Session?

smoothTransform

var smoothTransform: Transform?

smoothTransformSpeed

var smoothTransformSpeed: Float

var trackable: AugmentedFace?

The node world positioned trackable

var trackingState: TrackingState

The TrackingState of this Node.

open var transform: Transform

transformInstance

val transformInstance: Int

transformManager

val transformManager: TransformManager

visibleCameraTrackingStates

var visibleCameraTrackingStates: Set<TrackingState>

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

visibleTrackingStates

val 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

clearChildNodes

fun clearChildNodes(): Node

open override fun createAnchor(): Anchor?

Creates an anchor that is attached to this trackable, using the given initial pose in the world coordinate space.

createAnchorNode

open override fun createAnchorNode(): AnchorNode?

Creates an AnchorNode that is attached to this trackable, using the given initial pose in the world coordinate space.

open 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 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 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(trackable: AugmentedFace?)

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