ARView

layerClass

static get layerClass(): Promise<string>

@MainActor @preconcurrency override dynamic class var layerClass: AnyClass { get }

The class used to create the layer for view instances.

didMoveToSuperview

didMoveToSuperview(): Promise<void>

@MainActor @preconcurrency override dynamic func didMoveToSuperview()

Tells the view that its superview changed.

gestureRecognizer

gestureRecognizerShouldReceive(gestureRecognizer: _UIKit_UIGestureRecognizer, touch: _UIKit_UITouch): Promise<boolean>

@MainActor @preconcurrency @objc dynamic func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool

gestureRecognizer

gestureRecognizerShouldRecognizeSimultaneouslyWith(gestureRecognizer: _UIKit_UIGestureRecognizer, otherGestureRecognizer: _UIKit_UIGestureRecognizer): Promise<boolean>

@MainActor @preconcurrency @objc dynamic func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldRecognizeSimultaneouslyWith otherGestureRecognizer: UIGestureRecognizer) -> Bool

layoutSubviews

layoutSubviews(): Promise<void>

@MainActor @preconcurrency override dynamic func layoutSubviews()

Lays out subviews.

touchesBegan

touchesBegan(touches: Array<_UIKit_UITouch>, event?: (_UIKit_UIEvent) | null): Promise<void>

@MainActor @preconcurrency override dynamic func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?)

Tells the view that one or more new touches occurred. See <doc://com.apple.documentation/documentation/uikit/uiresponder/1621142-touchesbegan> for more information. - Parameters: - touches: A set of `UITouch` instances that represent the touches whose values changed. These touches all belong to the specified `event`. For touches in a view, this set contains only one touch by default. To receive multiple touches, set the view’s <doc://com.apple.documentation/documentation/uikit/uiview/1622519-ismultipletouchenabled> property to `true`. - event: The event to which the touches belong.

touchesCancelled

touchesCancelled(touches: Array<_UIKit_UITouch>, event?: (_UIKit_UIEvent) | null): Promise<void>

@MainActor @preconcurrency override dynamic func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?)

Tells the view when a system event (such as a system alert) cancels a touch sequence. See <doc://com.apple.documentation/documentation/uikit/uiresponder/1621116-touchescancelled> for more information. - Parameters: - touches: A set of `UITouch` instances that represent the touches whose values changed. These touches all belong to the specified `event`. For touches in a view, this set contains only one touch by default. To receive multiple touches, set the view’s <doc://com.apple.documentation/documentation/uikit/uiview/1622519-ismultipletouchenabled> property to `true`. - event: The event to which the touches belong.

touchesEnded

touchesEnded(touches: Array<_UIKit_UITouch>, event?: (_UIKit_UIEvent) | null): Promise<void>

@MainActor @preconcurrency override dynamic func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?)

Tells the view when one or more fingers are raised from the view. See ``EntityTranslationGestureRecognizer/touchesEnded(_:with:)`` for more information. - Parameters: - touches: A set of `UITouch` instances that represent the touches whose values changed. These touches all belong to the specified `event`. For touches in a view, this set contains only one touch by default. To receive multiple touches, set the view’s <doc://com.apple.documentation/documentation/uikit/uiview/1622519-ismultipletouchenabled> property to `true`. - event: The event to which the touches belong.

touchesMoved

touchesMoved(touches: Array<_UIKit_UITouch>, event?: (_UIKit_UIEvent) | null): Promise<void>

@MainActor @preconcurrency override dynamic func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?)

Tells the view when one or more touches associated with an event changed. See <doc://com.apple.documentation/documentation/uikit/uiresponder/1621107-touchesmoved> for more information. - Parameters: - touches: A set of `UITouch` instances that represent the touches whose values changed. These touches all belong to the specified `event`. For touches in a view, this set contains only one touch by default. To receive multiple touches, set the view’s <doc://com.apple.documentation/documentation/uikit/uiview/1622519-ismultipletouchenabled> property to `true`. - event: The event to which the touches belong.

contentScaleFactor

get contentScaleFactor(): Promise<number>

@MainActor @preconcurrency override dynamic var contentScaleFactor: CGFloat { get set }

The scale factor of the content in the view.

contentScaleFactor

setContentScaleFactor(value: number): Promise<void>

@MainActor @preconcurrency override dynamic var contentScaleFactor: CGFloat { get set }

The scale factor of the content in the view.

session

get session(): Promise<_ARKit_ARSession>

@MainActor @preconcurrency dynamic var session: ARSession { get set }

The AR session that supports the view’s rendering. RealityKit automatically creates a default session that the view manages. If you have an existing or custom session, setting it as the view's session replaces the default session. If you replace the default session, you need to start it by calling <doc://com.apple.documentation/documentation/arkit/arsession/2875735-run>. See ``automaticallyConfigureSession`` for more details. When ``ARView/automaticallyConfigureSession`` is <doc://com.apple.documentation/documentation/swift/true>, the default value is an <doc://com.apple.documentation/documentation/arkit/arworldtrackingconfiguration>.

session

setSession(value: _ARKit_ARSession): Promise<void>

@MainActor @preconcurrency dynamic var session: ARSession { get set }

The AR session that supports the view’s rendering. RealityKit automatically creates a default session that the view manages. If you have an existing or custom session, setting it as the view's session replaces the default session. If you replace the default session, you need to start it by calling <doc://com.apple.documentation/documentation/arkit/arsession/2875735-run>. See ``automaticallyConfigureSession`` for more details. When ``ARView/automaticallyConfigureSession`` is <doc://com.apple.documentation/documentation/swift/true>, the default value is an <doc://com.apple.documentation/documentation/arkit/arworldtrackingconfiguration>.

init

static initCoder(decoder: _Foundation_NSCoder): Promise<(ARView) | null>

@MainActor @preconcurrency required dynamic init?(coder decoder: NSCoder)

Creates an AR view initialized from data in a given decoder. - Parameters: - decoder: The decoder used to initialize the view.

init

static initFrame(frameRect: { x: number; y: number; width: number; height: number }): Promise<ARView>

@MainActor @preconcurrency override required dynamic init(frame frameRect: CGRect)

Creates an AR view with the specified dimensions. - Parameters: - frameRect: The frame rectangle for the view, measured in points.

cameraMode

get cameraMode(): Promise<ARView_CameraMode>

@MainActor @preconcurrency var cameraMode: ARView.CameraMode { get set }

A setting that chooses between the AR session’s camera and a virtual one.

cameraMode

setCameraMode(value: ARView_CameraMode): Promise<void>

@MainActor @preconcurrency var cameraMode: ARView.CameraMode { get set }

A setting that chooses between the AR session’s camera and a virtual one.

environment

get environment(): Promise<ARView_Environment>

@MainActor @preconcurrency var environment: ARView.Environment { get set }

The view’s background, lighting, and acoustic properties.

environment

setEnvironment(value: ARView_Environment): Promise<void>

@MainActor @preconcurrency var environment: ARView.Environment { get set }

The view’s background, lighting, and acoustic properties.

debugOptions

get debugOptions(): Promise<ARView_DebugOptions>

@MainActor @preconcurrency var debugOptions: ARView.DebugOptions { get set }

The current debugging options.

debugOptions

setDebugOptions(value: ARView_DebugOptions): Promise<void>

@MainActor @preconcurrency var debugOptions: ARView.DebugOptions { get set }

The current debugging options.

audioListener

get audioListener(): Promise<(_RealityFoundation_Entity) | null>

@MainActor @preconcurrency var audioListener: Entity? { get set }

The entity that defines the listener position and orientation for spatial audio. Set the ``ARView/audioListener`` to the entity in the scene from whose point of view RealityKit should render spatial audio. By default, the property is set to `nil`, in which case the active camera acts as the audio listener. This is usually what you want, because the camera typically mirrors the user’s point of view.

audioListener

setAudioListener(value?: (_RealityFoundation_Entity) | null): Promise<void>

@MainActor @preconcurrency var audioListener: Entity? { get set }

The entity that defines the listener position and orientation for spatial audio. Set the ``ARView/audioListener`` to the entity in the scene from whose point of view RealityKit should render spatial audio. By default, the property is set to `nil`, in which case the active camera acts as the audio listener. This is usually what you want, because the camera typically mirrors the user’s point of view.

physicsOrigin

get physicsOrigin(): Promise<(_RealityFoundation_Entity) | null>

@MainActor @preconcurrency var physicsOrigin: Entity? { get set }

The entity that defines the origin of the scene's physics simulation. By default, the scene's origin acts as the origin for physics calculations. Set the ``ARView/physicsOrigin`` to choose a particular entity within the scene to act as the origin instead. Here are the steps to do that: 1. Add a new entity to the scene that tracks the ARKit anchor position. 2. Set `physicsOrigin` to the entity to indicate that this entity's transform determines the origin of the physics simulation. 3. Optionally, parent the Jenga blocks to the anchor entity. This way the Jenga blocks update automatically when the anchor position changes. Example: ```swift // Define your anchor entity and add it to the scene. let myAnchor = AnchorEntity(.image(group: "References", name: "GameImage")) scene.addAnchor(myAnchor) // Set myAnchor as the origin of the physics simulation. arView.physicsOrigin = myAnchor // Add the simulated blocks to the anchor. myAnchor.addChild(block0) myAnchor.addChild(block1) // ... ``` Using this setup, RealityKit simulates all forces, velocities, etc. relative to `myAnchor`. Moving the anchor will not affect the simulation. For more information, see <doc:handling-different-sized-objects-in-physics-simulations>.

physicsOrigin

setPhysicsOrigin(value?: (_RealityFoundation_Entity) | null): Promise<void>

@MainActor @preconcurrency var physicsOrigin: Entity? { get set }

The entity that defines the origin of the scene's physics simulation. By default, the scene's origin acts as the origin for physics calculations. Set the ``ARView/physicsOrigin`` to choose a particular entity within the scene to act as the origin instead. Here are the steps to do that: 1. Add a new entity to the scene that tracks the ARKit anchor position. 2. Set `physicsOrigin` to the entity to indicate that this entity's transform determines the origin of the physics simulation. 3. Optionally, parent the Jenga blocks to the anchor entity. This way the Jenga blocks update automatically when the anchor position changes. Example: ```swift // Define your anchor entity and add it to the scene. let myAnchor = AnchorEntity(.image(group: "References", name: "GameImage")) scene.addAnchor(myAnchor) // Set myAnchor as the origin of the physics simulation. arView.physicsOrigin = myAnchor // Add the simulated blocks to the anchor. myAnchor.addChild(block0) myAnchor.addChild(block1) // ... ``` Using this setup, RealityKit simulates all forces, velocities, etc. relative to `myAnchor`. Moving the anchor will not affect the simulation. For more information, see <doc:handling-different-sized-objects-in-physics-simulations>.

renderOptions

get renderOptions(): Promise<ARView_RenderOptions>

@MainActor @preconcurrency var renderOptions: ARView.RenderOptions { get set }

The render options that configure the view’s AR session. RealityKit applies effects like camera grain, motion blur, and depth of field to the render to make the AR experience more immersive. Each effect causes your virtual content to better blend in with live images from the camera in some way. To disable an effect, you add an option from the ``ARView/RenderOptions-swift.struct`` option set to the view’s ``ARView/renderOptions-swift.property`` property: ```swift arView.renderOptions.insert(.disableMotionBlur) // Turn off motion blur. ``` When you create an AR view, the system automatically adds certain render options to disable effects that might be too demanding for the GPU hardware on which your app is running. But you can modify the ``ARView/renderOptions-swift.property`` set at any time to enable or disable any particular effect, depending on the needs of your app. To decide whether to use an effect, consider both its visual impact on your app, and its computational cost. Check the cost by measuring your app’s CPU and GPU utilization with the effect enabled across all the devices your app supports, as described in <doc:improving-the-performance-of-a-realitykit-app>.

renderOptions

setRenderOptions(value: ARView_RenderOptions): Promise<void>

@MainActor @preconcurrency var renderOptions: ARView.RenderOptions { get set }

The render options that configure the view’s AR session. RealityKit applies effects like camera grain, motion blur, and depth of field to the render to make the AR experience more immersive. Each effect causes your virtual content to better blend in with live images from the camera in some way. To disable an effect, you add an option from the ``ARView/RenderOptions-swift.struct`` option set to the view’s ``ARView/renderOptions-swift.property`` property: ```swift arView.renderOptions.insert(.disableMotionBlur) // Turn off motion blur. ``` When you create an AR view, the system automatically adds certain render options to disable effects that might be too demanding for the GPU hardware on which your app is running. But you can modify the ``ARView/renderOptions-swift.property`` set at any time to enable or disable any particular effect, depending on the needs of your app. To decide whether to use an effect, consider both its visual impact on your app, and its computational cost. Check the cost by measuring your app’s CPU and GPU utilization with the effect enabled across all the devices your app supports, as described in <doc:improving-the-performance-of-a-realitykit-app>.

trackedRaycast

trackedRaycast(point: { x: number; y: number }, target: _ARKit_ARRaycastQuery_Target, alignment: _ARKit_ARRaycastQuery_TargetAlignment, updateHandler: ((arg0: Array<_ARKit_ARRaycastResult>) => void)): Promise<(_ARKit_ARTrackedRaycast) | null>

@MainActor @preconcurrency func trackedRaycast(from point: CGPoint, allowing target: ARRaycastQuery.Target, alignment: ARRaycastQuery.TargetAlignment, updateHandler: @escaping ([ARRaycastResult]) -> Void) -> ARTrackedRaycast?

Performs a tracked ray cast, where a ray is cast into the scene from the center of the camera through a point in the view. - Parameters: - point: A point in the view’s local coordinate system. - target: The type of target where the ray should terminate. - alignment: The alignment of the target. - updateHandler: A closure the method calls to update the list of results, sorted from nearest to farthest from the camera. The closure is called on the ``ARView/session`` instance’s delegate queue. - Returns: A tracked ray-cast instance used to update or stop ray casting. The result is `nil` if the ray cast fails or if the AR ``ARView/session`` configuration isn’t <doc://com.apple.documentation/documentation/arkit/arworldtrackingconfiguration> or one of its subclasses.

cameraTransform

get cameraTransform(): Promise<_RealityFoundation_Transform>

@MainActor @preconcurrency var cameraTransform: Transform { get }

The transform of the currently active camera.

installGestures

installGestures(gestures: ARView_EntityGestures, entity: Implements<_RealityFoundation_HasCollision> | SDKHandle): Promise<Array<SDKHandle>>

@discardableResult @MainActor @preconcurrency func installGestures(_ gestures: ARView.EntityGestures = .all, for entity: any HasCollision) -> [any EntityGestureRecognizer]

Installs standard gestures onto the given entity, configured to be recognized simultaneously. - Parameters: - gestures: The gesture types to install. - entity: The entity with which to associate the gesture recognizers. - Returns: The set of gesture recognizers created to handle the requested gestures.

renderCallbacks

get renderCallbacks(): Promise<ARView_RenderCallbacks>

@MainActor @preconcurrency var renderCallbacks: ARView.RenderCallbacks { get set }

A container that holds the view’s render callbacks. Render callbacks are closures RealityKit calls at predefined times. You can use render callbacks to modify the results of RealityKit’s rendering. If you assign a function or closure to any of the contained callback properties, RealityKit calls that function or closure at a predefined time. Setting the ``ARView/RenderCallbacks-swift.postProcess`` property, for example, causes RealityKit to call the assigned function or closure every frame, after RealityKit renders the scene, but before it displays it.

renderCallbacks

setRenderCallbacks(value: ARView_RenderCallbacks): Promise<void>

@MainActor @preconcurrency var renderCallbacks: ARView.RenderCallbacks { get set }

A container that holds the view’s render callbacks. Render callbacks are closures RealityKit calls at predefined times. You can use render callbacks to modify the results of RealityKit’s rendering. If you assign a function or closure to any of the contained callback properties, RealityKit calls that function or closure at a predefined time. Setting the ``ARView/RenderCallbacks-swift.postProcess`` property, for example, causes RealityKit to call the assigned function or closure every frame, after RealityKit renders the scene, but before it displays it.

makeRaycastQuery

makeRaycastQuery(point: { x: number; y: number }, target: _ARKit_ARRaycastQuery_Target, alignment: _ARKit_ARRaycastQuery_TargetAlignment): Promise<(_ARKit_ARRaycastQuery) | null>

@MainActor @preconcurrency func makeRaycastQuery(from point: CGPoint, allowing target: ARRaycastQuery.Target, alignment: ARRaycastQuery.TargetAlignment) -> ARRaycastQuery?

Creates a ray-cast query originating from a point in the view, centered on the camera’s field of view. - Parameters: - point: A point in the view’s coordinate system. - target: The type of target where the ray should terminate. - alignment: The alignment of the target. - Returns: A query result.

automaticallyConfigureSession

get automaticallyConfigureSession(): Promise<boolean>

@MainActor @preconcurrency var automaticallyConfigureSession: Bool { get set }

An indication of whether to use an automatically configured AR session. When enabled, the ``RealityKit/ARView`` automatically runs an ``RealityKit/ARSession`` with a default configuration. RealityKit updates that configuration based on t camera mode and scene anchors. When disabled, you need to provide a configuration object and run the session manually. The default value is <doc://com.apple.documentation/documentation/swift/true>.

automaticallyConfigureSession

setAutomaticallyConfigureSession(value: boolean): Promise<void>

@MainActor @preconcurrency var automaticallyConfigureSession: Bool { get set }

An indication of whether to use an automatically configured AR session. When enabled, the ``RealityKit/ARView`` automatically runs an ``RealityKit/ARSession`` with a default configuration. RealityKit updates that configuration based on t camera mode and scene anchors. When disabled, you need to provide a configuration object and run the session manually. The default value is <doc://com.apple.documentation/documentation/swift/true>.

ray

ray(screenPoint: { x: number; y: number }): Promise<({ "origin": SDKHandle; "direction": SDKHandle }) | null>

@MainActor @preconcurrency func ray(through screenPoint: CGPoint) -> (origin: SIMD3<Float>, direction: SIMD3<Float>)?

Determines the position and direction of a ray through the given point in the 2D space of the view. - Parameters: - screenPoint: A point in the view’s coordinate system. - Returns: A tuple that represents a ray in AR coordinates that goes from the camera origin through the specified point on the screen.

init

static initFrameCameraModeAutomaticallyConfigureSession(frameRect: { x: number; y: number; width: number; height: number }, cameraMode: ARView_CameraMode, automaticallyConfigureSession: boolean): Promise<ARView>

@MainActor @preconcurrency init(frame frameRect: CGRect, cameraMode: ARView.CameraMode, automaticallyConfigureSession: Bool)

Creates an AR view with the specified dimensions, camera mode, and session configuration state. - Parameters: - frameRect: The frame rectangle for the view, measured in points. - cameraMode: An indication of whether to use the device’s camera or a virtual one. - automaticallyConfigureSession: An indication of whether to use an AR session with configuration that’s updated automatically based on camera mode and scene anchors. Set this value to `false` if you want to run the session manually with your own configuration.

init

static initFrameCameraMode(frameRect: { x: number; y: number; width: number; height: number }, cameraMode: ARView_CameraMode): Promise<ARView>

@MainActor @preconcurrency convenience init(frame frameRect: CGRect, cameraMode: ARView.CameraMode)

Creates an AR view with the specified dimensions and camera mode. - Parameters: - frameRect: The frame rectangle for the view, measured in points. - cameraMode: An indication of whether to use the device’s camera or a virtual one.

scene

get scene(): Promise<_RealityFoundation_Scene>

@MainActor @preconcurrency var scene: Scene { get }

The scene that the view renders and simulates. When you initialize a view, it comes with a single ``Scene`` instance that you access through the view’s ``ARView/scene`` property. Add ``AnchorEntity`` instances to the scene’s ``Scene/anchors`` collection to provide content for the scene.

entity

entity(point: { x: number; y: number }): Promise<(_RealityFoundation_Entity) | null>

@MainActor @preconcurrency func entity(at point: CGPoint) -> Entity?

Finds the entity in the AR scene closest to the specified point. The method ignores entities that lack a ``CollisionComponent``. - Parameters: - point: A point in the view’s coordinate system. - Returns: The entity at `point`, or `nil` if no entity is found.

hitTest

hitTestQueryMask(point: { x: number; y: number }, query?: _RealityFoundation_CollisionCastQueryType, mask?: _RealityFoundation_CollisionGroup): Promise<Array<_RealityFoundation_CollisionCastHit>>

@MainActor @preconcurrency func hitTest(_ point: CGPoint, query: CollisionCastQueryType = .all, mask: CollisionGroup = .all) -> [CollisionCastHit]

Searches for objects corresponding to a point in the view based on a query and a collision mask. The method ignores entities that lack a ``CollisionComponent``. - Parameters: - point: A point in the view’s coordinate system. - query: The query type. - mask: A collision mask that can be used to prevent hits with certain objects. - Returns: An array of hit results.

hitTest

hitTestTypes(point: { x: number; y: number }, types: _ARKit_ARHitTestResult_ResultType): Promise<Array<_ARKit_ARHitTestResult>>

@MainActor @preconcurrency func hitTest(_ point: CGPoint, types: ARHitTestResult.ResultType) -> [ARHitTestResult]

Searches for objects corresponding to a point in the view based on a set of result types. The method ignores entities that lack a ``CollisionComponent``. - Parameters: - point: A point in the view’s coordinate system. - types: The hit test search type to look for. - Returns: An array of hit results.

project

project(point: SDKHandle): Promise<({ x: number; y: number }) | null>

@MainActor @preconcurrency func project(_ point: SIMD3<Float>) -> CGPoint?

Projects a point from the 3D world coordinate system of the scene to the 2D pixel coordinate system of the view. - Parameters: - point: The point in 3D world coordinates. - Returns: A point in the view’s coordinate space.

raycast

raycast(point: { x: number; y: number }, target: _ARKit_ARRaycastQuery_Target, alignment: _ARKit_ARRaycastQuery_TargetAlignment): Promise<Array<_ARKit_ARRaycastResult>>

@MainActor @preconcurrency func raycast(from point: CGPoint, allowing target: ARRaycastQuery.Target, alignment: ARRaycastQuery.TargetAlignment) -> [ARRaycastResult]

Performs a ray cast, where a ray is cast into the scene from the center of the camera through a point in the view, and the results are immediately returned. - Parameters: - point: A point in the view’s local coordinate system. - target: The type of target where the ray should terminate. - alignment: The alignment of the target. - Returns: A list of ray-cast results, sorted from nearest to farthest from the camera. The list is empty if the ray cast fails.

entities

entities(point: { x: number; y: number }): Promise<Array<_RealityFoundation_Entity>>

@MainActor @preconcurrency func entities(at point: CGPoint) -> [Entity]

Finds the collection of entities at the specified point in the scene. The method ignores entities that lack a ``CollisionComponent``. - Parameters: - point: A point in the view’s coordinate system. - Returns: An array of entities at `point`. The array is empty if there are no entities.

snapshot

snapshot(saveToHDR: boolean, completion: ((arg0: (_UIKit_UIImage) | null) => void)): Promise<void>

@MainActor @preconcurrency func snapshot(saveToHDR: Bool, completion: @escaping (ARView.Image?) -> Void)

Takes a screenshot.

unproject

unprojectViewport(point: { x: number; y: number }, viewport: { x: number; y: number; width: number; height: number }): Promise<(SDKHandle) | null>

@MainActor @preconcurrency func unproject(_ point: CGPoint, viewport: CGRect) -> SIMD3<Float>?

Maps a 2D point from the pixel coordinate system of a viewport into a 3D coordinate space. The point lies on this view's near clipping plane. - Parameters: - point: A point in `viewport`. - viewport: A viewport. - Returns: A view-space 3D coordinate.

unproject

unprojectOntoPlaneRelativeToCamera(point: { x: number; y: number }, planeTransform: SDKHandle, relativeToCamera: boolean): Promise<(SDKHandle) | null>

@MainActor @preconcurrency func unproject(_ point: CGPoint, ontoPlane planeTransform: float4x4, relativeToCamera: Bool) -> SIMD3<Float>?

Unproject a 2D point from the view onto a plane in 3D world coordinates. A 2D point in the view’s coordinate space can refer to any point along a line segment in the 3D coordinate space. Unprojecting gets the 3D position of the point along this line segment that intersects the provided plane. - Parameters: - point: A point in the view’s coordinate system. - planeTransform: The transform used to define the coordinate system of the plane. The coordinate system’s positive y-axis is assumed to be the normal of the plane. - relativeToCamera: If the plane transform is relative to camera space or world space. - Returns: 3D position in world coordinates or nil if unprojection is not possible.

unproject

unprojectOntoPlane(point: { x: number; y: number }, planeTransform: SDKHandle): Promise<(SDKHandle) | null>

@MainActor @preconcurrency func unproject(_ point: CGPoint, ontoPlane planeTransform: float4x4) -> SIMD3<Float>?

Maps a 2D point from the view’s coordinate system onto the given plane in 3D space. - Parameters: - point: The point in the view’s coordinate system. - planeTransform: A transform used to define the coordinate system of the plane. The positive y-axis is taken as the normal of the plane. - Returns: The 3D position in world coordinates, or `nil` if the mapping isn’t possible.