androidx.xr.arcore

Kotlin |Java

Interfaces

`Trackable`	An object that ARCore for Jetpack XR can track and that an `Anchor` can be attached to.
`Trackable.State`	The subset of data that is common to the state of all `Trackable` instances.

Classes

`Anchor`	An anchor describes a fixed location and orientation in the real world.
`Anchor.State`	The representation of the current state of an `Anchor`.
`AnchorCreateIllegalState`	Result of an unsuccessful `Anchor.create` call.
`AnchorCreateNotAuthorized`	Result of an unsuccessful `Anchor.create` call.
`AnchorCreateResourcesExhausted`	Result of an unsuccessful `Anchor.create` or `Anchor.load` call.
`AnchorCreateResult`	Result of a `Anchor.create` or `Anchor.load` call.
`AnchorCreateSuccess`	Result of a successful `Anchor.create` or `Anchor.load` call.
`AnchorCreateTrackingUnavailable`	Result of an unsuccessful `Anchor.create` call.
`AnchorCreateUnsupportedLocation`	Result of an unsuccessful `Anchor.create` call.
`AnchorLoadInvalidUuid`	Result of an unsuccessful `Anchor.load` call.
`ArDevice`	Contains the information of the device that locates it with respect to the real world.
`ArDevice.State`	Contains the current state of the AR Device tracking.
`AugmentedObject`	A representation of a physical object in real space.
`AugmentedObject.State`	The representation of the current state of an `AugmentedObject`.
`CreateGeospatialPoseFromPoseNotTracking`	Result of an unsuccessful `Geospatial.createGeospatialPoseFromPose` call.
`CreateGeospatialPoseFromPoseResult`	Result of a `Geospatial.createGeospatialPoseFromPose` or Geospatial.createGeospatialPoseFromDevicePose call.
`CreateGeospatialPoseFromPoseSuccess`	Result of a successful `Geospatial.createGeospatialPoseFromPose` call.
`CreatePoseFromGeospatialPoseNotTracking`	Result of an unsuccessful `Geospatial.createPoseFromGeospatialPose` call.
`CreatePoseFromGeospatialPoseResult`	Result of a call to `Geospatial.createPoseFromGeospatialPose`.
`CreatePoseFromGeospatialPoseSuccess`	Result of a successful `Geospatial.createPoseFromGeospatialPose` call.
`DepthMap`	Contains the depth map information corresponding to a specific `RenderViewpoint`
`DepthMap.State`	Contains the current state of depth tracking
`Eye`	A representation of a user's eye.
`Eye.State`	The representation of the current state of an `Eye`.
`Face`	Contains the tracking information of a detected human face.
`Face.State`	The representation of the current state of `Face`.
`FaceBlendShapeType`	Represents the type of face blend shape.
`FaceConfidenceRegion`	Represents the regions of face tracking confidence.
`Geospatial`	Provides localization ability in Earth-relative coordinates.
`Geospatial.State`	Describes the state of Geospatial.
`Hand`	Contains the tracking information of one of the user's hands.
`Hand.State`	The representation of the current state of `Hand`.
`HitResult`	Defines an intersection between a ray and estimated real-world geometry.
`PerceptionState`	Represents the state of ARCore for Jetpack XR at an specific point in time.
`Plane`	Describes the system's current best knowledge of a real-world planar surface.
`Plane.Label`	A semantic description of a `Plane`.
`Plane.State`	The representation of the current state of a `Plane`.
`Plane.Type`	A simple summary of the normal vector of a `Plane`.
`RenderViewpoint`	Represents a single viewpoint used for rendering, such as a left eye, right eye, or a mono view.
`RenderViewpoint.State`	Class that contains the current state of the render viewpoint.

Enums

`Hand.HandSide`	The handedness of the user's hand.
`HandJointType`	Represents the type of hand joint.

Top-level functions summary

List<HitResult>

hitTest(session: Session, ray: Ray)

Performs a hit-test using the given ray.

Top-level functions

hitTest

Artifact: androidx.xr.arcore:arcore

View Source

Added in 1.0.0-alpha09

fun hitTest(session: Session, ray: Ray): List<HitResult>

Performs a hit-test using the given ray.

A hit-test is a method of calculating the intersection of a ray with objects tracked by the session. Conducting a hit-test results in a list of hit objects, in other words, a hit-test does not stop at the first object hit.

import androidx.xr.arcore.Anchor
import androidx.xr.arcore.ArDevice
import androidx.xr.arcore.Plane
import androidx.xr.arcore.hitTest
import androidx.xr.runtime.math.Pose
import androidx.xr.runtime.math.Ray
import androidx.xr.scenecore.scene

val arDevice = ArDevice.getInstance(session)

// Assume hitOrigin and hitDirection are in Activity Space.
// We need to transform the ray into Perception Space for hitTest.

// Transform the origin point from Activity Space to Perception Space.
val perceptionOrigin =
    session.scene.activitySpace
        .transformPoseTo(Pose(hitOrigin), session.scene.perceptionSpace)
        .translation

// Transform the direction vector from Activity Space to Perception Space.
val perceptionDirection =
    session.scene.activitySpace
        .transformPoseTo(Pose(hitDirection), session.scene.perceptionSpace)
        .translation
        .toNormalized() // Ensure the direction is normalized after transformation.

val ray = Ray(perceptionOrigin, perceptionDirection)

hitTest(session, ray)
    // Use a valid plane label as a test to filter out any unreliable hits.
    .firstOrNull { (it.trackable as? Plane?)?.state?.value?.label != Plane.Label.UNKNOWN }
    ?.let { hitResult ->
        // Do something with the hit result, like create an anchor representing where the ray
        // intersected the plane. The hitResult.hitPose is in Perception Space.
        val anchorResult = Anchor.create(session, hitResult.hitPose)

        // Anchor creation can fail, so it is important to properly handle the return value of
        // and `Anchor.create()` call. See `Anchor.create()` for more information.
        yourAnchorResultHandler(anchorResult)

        // If rendering is needed, transform hitResult.hitPose from Perception Space
        // to the desired Scene Space (e.g., Activity Space).
        val activitySpaceHitPose =
            session.scene.perceptionSpace.transformPoseTo(
                hitResult.hitPose,
                session.scene.activitySpace,
            )
        renderSomething(activitySpaceHitPose)
    }

Returns
`List<HitResult>`	A list of `HitResult` objects, sorted by distance from the origin of the ray. The nearest hit is at the beginning of the list.

Throws
`kotlin.IllegalStateException`	if `Session.config` is set to `Config.PlaneTrackingMode.DISABLED`.