react-native-nitro-ar 2026.2.1

package/react-native-nitro-ar.podspec

@@ -0,0 +1,40 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "react-native-nitro-ar"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  # Swift module name must match nitrogen's iosModuleName
+  s.module_name  = "NitroAR"
+
+  s.platforms    = { :ios => '16.0', :visionos => 1.0 }
+  s.source       = { :git => "https://github.com/vineyardbovines/react-native-nitro-ar.git", :tag => "#{s.version}" }
+
+  s.source_files = [
+    # Implementation (Swift)
+    "ios/**/*.{swift}",
+    # Autolinking/Registration (Objective-C++)
+    "ios/**/*.{m,mm}",
+    # Implementation (C++ objects)
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.frameworks = [
+    'ARKit',
+    'SceneKit',
+    'UIKit',
+  ]
+
+  load 'nitrogen/generated/ios/NitroAR+autolinking.rb'
+  add_nitrogen_files(s)
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+  install_modules_dependencies(s)
+end

package/src/index.ts

@@ -0,0 +1,60 @@
+import { getHostComponent, NitroModules } from "react-native-nitro-modules";
+import ARViewConfig from "../nitrogen/generated/shared/json/ARViewConfig.json";
+import type { ARBoundingBoxBuilder } from "./specs/ARBoundingBoxBuilder.nitro";
+import type { ARSession } from "./specs/ARSession.nitro";
+import type { ARViewMethods, ARViewProps } from "./specs/ARView.nitro";
+
+export type { ARAnchor } from "./specs/ARAnchor.nitro";
+export type { ARBoundingBoxBuilder } from "./specs/ARBoundingBoxBuilder.nitro";
+export type { ARDepthData } from "./specs/ARDepthData.nitro";
+export type { ARFrame } from "./specs/ARFrame.nitro";
+export type {
+  ARDirectionalLightEstimate,
+  ARLightEstimate,
+} from "./specs/ARLightEstimate.nitro";
+export type { ARMeasurement } from "./specs/ARMeasurement.nitro";
+
+export type {
+  ARPlaneAnchor,
+  ARPlaneGeometry,
+  PlaneAlignment,
+  PlaneClassification,
+} from "./specs/ARPlaneAnchor.nitro";
+export type {
+  ARRaycastResult,
+  RaycastAlignment,
+  RaycastQuery,
+  RaycastTarget,
+} from "./specs/ARRaycastResult.nitro";
+export type {
+  ARMeshAnchor,
+  LiDARCapabilities,
+  MeshClassification,
+  SceneReconstructionMode,
+} from "./specs/ARSceneMesh.nitro";
+// Re-export all types
+export type {
+  ARSession,
+  ARSessionConfiguration,
+  CameraPose,
+  EnvironmentTexturing,
+  PlaneDetectionMode,
+  TrackingState,
+  TrackingStateReason,
+  WorldAlignment,
+} from "./specs/ARSession.nitro";
+export type { ARViewHitResult, ARViewMethods, ARViewProps } from "./specs/ARView.nitro";
+export type { ARVolume } from "./specs/ARVolume.nitro";
+export type { ARWorldMap, WorldMappingStatus } from "./specs/ARWorldMap.nitro";
+
+// ARView Component
+export const ARView = getHostComponent<ARViewProps, ARViewMethods>("ARView", () => ARViewConfig);
+
+// Factory functions
+export function createARSession(): ARSession {
+  return NitroModules.createHybridObject<ARSession>("ARSession");
+}
+
+export function createARBoundingBoxBuilder(): ARBoundingBoxBuilder {
+  return NitroModules.createHybridObject<ARBoundingBoxBuilder>("ARBoundingBoxBuilder");
+}

package/src/specs/ARAnchor.nitro.ts

@@ -0,0 +1,21 @@
+import type { HybridObject } from "react-native-nitro-modules";
+
+export interface ARAnchor extends HybridObject<{ ios: "swift" }> {
+  /** Unique identifier */
+  readonly identifier: string;
+
+  /** Position in world coordinates [x, y, z] */
+  readonly position: number[];
+
+  /** Rotation as quaternion [x, y, z, w] */
+  readonly rotation: number[];
+
+  /** Full 4x4 transform matrix (column-major, 16 values) */
+  readonly transform: number[];
+
+  /** Whether anchor is currently being tracked */
+  readonly isTracked: boolean;
+
+  /** Optional label for user-created anchors */
+  readonly label: string | undefined;
+}

package/src/specs/ARBoundingBoxBuilder.nitro.ts

@@ -0,0 +1,11 @@
+import type { HybridObject } from "react-native-nitro-modules";
+import type { ARAnchor } from "./ARAnchor.nitro";
+import type { ARVolume } from "./ARVolume.nitro";
+
+export interface ARBoundingBoxBuilder extends HybridObject<{ ios: "swift" }> {
+  addBaseAnchor(anchor: ARAnchor): void;
+
+  readonly canBuild: boolean;
+
+  build(): ARVolume;
+}

package/src/specs/ARDepthData.nitro.ts

@@ -0,0 +1,29 @@
+import type { HybridObject } from "react-native-nitro-modules";
+
+export interface ARDepthData extends HybridObject<{ ios: "swift" }> {
+  /** Width of the depth map in pixels */
+  readonly width: number;
+
+  /** Height of the depth map in pixels */
+  readonly height: number;
+
+  /**
+   * Depth values in meters (row-major, width * height floats).
+   * Values are distance from camera plane.
+   */
+  readonly depthMap: number[];
+
+  /**
+   * Confidence values (0-2):
+   * 0 = low confidence
+   * 1 = medium confidence
+   * 2 = high confidence
+   */
+  readonly confidenceMap: number[];
+
+  /** Get depth at normalized screen coordinate (0-1) */
+  getDepthAt(x: number, y: number): number;
+
+  /** Get confidence at normalized screen coordinate (0-1) */
+  getConfidenceAt(x: number, y: number): number;
+}

package/src/specs/ARFrame.nitro.ts

@@ -0,0 +1,41 @@
+import type { HybridObject } from "react-native-nitro-modules";
+import type { ARDepthData } from "./ARDepthData.nitro";
+import type { ARDirectionalLightEstimate, ARLightEstimate } from "./ARLightEstimate.nitro";
+
+export interface ARFrame extends HybridObject<{ ios: "swift" }> {
+  /** Timestamp of this frame in seconds */
+  readonly timestamp: number;
+
+  /** Camera position in world space [x, y, z] */
+  readonly cameraPosition: number[];
+
+  /** Camera rotation as quaternion [x, y, z, w] */
+  readonly cameraRotation: number[];
+
+  /** Camera projection matrix (4x4, column-major, 16 values) */
+  readonly projectionMatrix: number[];
+
+  /** Camera view matrix (4x4, column-major, 16 values) */
+  readonly viewMatrix: number[];
+
+  /** Camera intrinsics [fx, fy, cx, cy] */
+  readonly cameraIntrinsics: number[];
+
+  /** Image resolution [width, height] */
+  readonly imageResolution: number[];
+
+  /** Light estimate if available */
+  readonly lightEstimate: ARLightEstimate | undefined;
+
+  /** Directional light estimate (face tracking only) */
+  readonly directionalLightEstimate: ARDirectionalLightEstimate | undefined;
+
+  /** Scene depth data if available (requires LiDAR) */
+  readonly sceneDepth: ARDepthData | undefined;
+
+  /** Smoothed scene depth if available */
+  readonly smoothedSceneDepth: ARDepthData | undefined;
+
+  /** Captured image as base64 JPEG (quality 0-1) */
+  getCapturedImage(quality: number): string;
+}

package/src/specs/ARLightEstimate.nitro.ts

@@ -0,0 +1,20 @@
+import type { HybridObject } from "react-native-nitro-modules";
+
+export interface ARLightEstimate extends HybridObject<{ ios: "swift" }> {
+  /** Ambient light intensity in lumens (0-2000 typical) */
+  readonly ambientIntensity: number;
+
+  /** Color temperature in Kelvin (6500 = neutral daylight) */
+  readonly ambientColorTemperature: number;
+}
+
+export interface ARDirectionalLightEstimate extends ARLightEstimate {
+  /** Primary light direction as normalized vector [x, y, z] */
+  readonly primaryLightDirection: number[];
+
+  /** Primary light intensity in lumens */
+  readonly primaryLightIntensity: number;
+
+  /** Spherical harmonics coefficients for advanced lighting (27 values: 9 RGB triplets) */
+  readonly sphericalHarmonicsCoefficients: number[];
+}

package/src/specs/ARMeasurement.nitro.ts

@@ -0,0 +1,10 @@
+import type { HybridObject } from "react-native-nitro-modules";
+import type { ARAnchor } from "./ARAnchor.nitro";
+
+export interface ARMeasurement extends HybridObject<{ ios: "swift" }> {
+  readonly start: ARAnchor;
+  readonly end: ARAnchor;
+
+  readonly length: number;
+  readonly isValid: boolean;
+}

package/src/specs/ARPlaneAnchor.nitro.ts

@@ -0,0 +1,46 @@
+import type { HybridObject } from "react-native-nitro-modules";
+
+export type PlaneAlignment = "horizontal" | "vertical";
+export type PlaneClassification =
+  | "none"
+  | "wall"
+  | "floor"
+  | "ceiling"
+  | "table"
+  | "seat"
+  | "window"
+  | "door";
+
+export interface ARPlaneGeometry extends HybridObject<{ ios: "swift" }> {
+  /** Vertices of the plane mesh (flattened [x,y,z, x,y,z, ...]) */
+  readonly vertices: number[];
+
+  /** Texture coordinates (flattened [u,v, u,v, ...]) */
+  readonly textureCoordinates: number[];
+
+  /** Triangle indices */
+  readonly triangleIndices: number[];
+
+  /** Boundary polygon vertices (flattened [x,z, x,z, ...] in local plane space) */
+  readonly boundaryVertices: number[];
+}
+
+export interface ARPlaneAnchor extends HybridObject<{ ios: "swift" }> {
+  readonly identifier: string;
+
+  /** Position [x, y, z] */
+  readonly position: number[];
+  /** Rotation as quaternion [x, y, z, w] */
+  readonly rotation: number[];
+
+  readonly alignment: PlaneAlignment;
+  readonly classification: PlaneClassification;
+
+  /** Plane extent in meters [width, height] */
+  readonly extent: number[];
+
+  /** Center offset from anchor position [x, y, z] */
+  readonly center: number[];
+
+  readonly geometry: ARPlaneGeometry;
+}

package/src/specs/ARRaycastResult.nitro.ts

@@ -0,0 +1,32 @@
+import type { HybridObject } from "react-native-nitro-modules";
+
+export type RaycastTarget =
+  | "existingPlaneGeometry"
+  | "existingPlaneInfinite"
+  | "estimatedPlane"
+  | "any";
+
+export type RaycastAlignment = "horizontal" | "vertical" | "any";
+
+export interface RaycastQuery {
+  /** Screen X coordinate (0-1 normalized or pixel) */
+  x: number;
+  /** Screen Y coordinate (0-1 normalized or pixel) */
+  y: number;
+  /** What surfaces to hit */
+  target: RaycastTarget;
+  /** Plane alignment filter */
+  alignment: RaycastAlignment;
+}
+
+export interface ARRaycastResult extends HybridObject<{ ios: "swift" }> {
+  /** Position [x, y, z] */
+  readonly position: number[];
+  /** Rotation as quaternion [x, y, z, w] */
+  readonly rotation: number[];
+  readonly distance: number;
+  readonly target: RaycastTarget;
+
+  /** Anchor identifier if hit an existing plane */
+  readonly anchorId: string | undefined;
+}

package/src/specs/ARSceneMesh.nitro.ts

@@ -0,0 +1,63 @@
+import type { HybridObject } from "react-native-nitro-modules";
+
+/** Classification of mesh faces */
+export type MeshClassification =
+  | "none"
+  | "wall"
+  | "floor"
+  | "ceiling"
+  | "table"
+  | "seat"
+  | "window"
+  | "door";
+
+/** A single mesh anchor from scene reconstruction */
+export interface ARMeshAnchor extends HybridObject<{ ios: "swift" }> {
+  /** Unique identifier */
+  readonly identifier: string;
+
+  /** Transform matrix (4x4, column-major) */
+  readonly transform: number[];
+
+  /** Number of vertices */
+  readonly vertexCount: number;
+
+  /** Number of faces (triangles) */
+  readonly faceCount: number;
+
+  /**
+   * Vertex positions as flat array [x1,y1,z1, x2,y2,z2, ...]
+   * Positions are in local anchor space
+   */
+  readonly vertices: number[];
+
+  /**
+   * Face indices as flat array [a1,b1,c1, a2,b2,c2, ...]
+   * Each triplet defines a triangle
+   */
+  readonly faces: number[];
+
+  /**
+   * Vertex normals as flat array [nx1,ny1,nz1, ...]
+   */
+  readonly normals: number[];
+
+  /**
+   * Classification for each face (if available)
+   * Only populated when sceneReconstruction includes classification
+   */
+  readonly classifications: MeshClassification[];
+}
+
+/** Scene reconstruction mode */
+export type SceneReconstructionMode = "none" | "mesh" | "meshWithClassification";
+
+/** LiDAR capabilities info */
+export interface LiDARCapabilities {
+  /** Device has LiDAR sensor */
+  readonly isAvailable: boolean;
+  /** Scene reconstruction is supported */
+  readonly supportsSceneReconstruction: boolean;
+  /** Scene depth is supported */
+  readonly supportsSceneDepth: boolean;
+}

package/src/specs/ARSession.nitro.ts

@@ -0,0 +1,112 @@
+import type { HybridObject } from "react-native-nitro-modules";
+import type { ARAnchor } from "./ARAnchor.nitro";
+import type { ARFrame } from "./ARFrame.nitro";
+import type { ARMeasurement } from "./ARMeasurement.nitro";
+import type { ARPlaneAnchor } from "./ARPlaneAnchor.nitro";
+import type { ARRaycastResult, RaycastQuery } from "./ARRaycastResult.nitro";
+import type { ARMeshAnchor, LiDARCapabilities, SceneReconstructionMode } from "./ARSceneMesh.nitro";
+import type { ARWorldMap, WorldMappingStatus } from "./ARWorldMap.nitro";
+
+export interface CameraPose {
+  /** Position [x, y, z] */
+  position: number[];
+  /** Rotation as quaternion [x, y, z, w] */
+  rotation: number[];
+}
+
+export type TrackingState = "notAvailable" | "limited" | "normal";
+
+export type TrackingStateReason =
+  | "none"
+  | "initializing"
+  | "excessiveMotion"
+  | "insufficientFeatures"
+  | "relocalizing";
+
+export type PlaneDetectionMode = "horizontal" | "vertical";
+export type EnvironmentTexturing = "none" | "manual" | "automatic";
+export type WorldAlignment = "gravity" | "gravityAndHeading" | "camera";
+
+export interface ARSessionConfiguration {
+  /** Enable plane detection */
+  planeDetection?: PlaneDetectionMode[];
+  /** Enable light estimation */
+  lightEstimation?: boolean;
+  /** Enable scene depth (requires LiDAR) */
+  sceneDepth?: boolean;
+  /** Enable smoothed scene depth */
+  smoothedSceneDepth?: boolean;
+  /** Enable environment texturing */
+  environmentTexturing?: EnvironmentTexturing;
+  /** Enable world map for relocalization */
+  worldAlignment?: WorldAlignment;
+  /** Initial world map data (base64) for relocalization */
+  initialWorldMap?: string;
+  /** Enable scene reconstruction/mesh (requires LiDAR) */
+  sceneReconstruction?: SceneReconstructionMode;
+  /** Enable people occlusion */
+  peopleOcclusion?: boolean;
+  /** Enable object occlusion (requires LiDAR scene reconstruction) */
+  objectOcclusion?: boolean;
+}
+
+export interface ARSession extends HybridObject<{ ios: "swift" }> {
+  // Lifecycle
+  start(config?: ARSessionConfiguration): void;
+  pause(): void;
+  reset(): void;
+
+  // State
+  readonly trackingState: TrackingState;
+  readonly trackingStateReason: TrackingStateReason;
+  readonly worldMappingStatus: WorldMappingStatus;
+  readonly isRunning: boolean;
+
+  // Camera
+  getCameraPose(): CameraPose;
+  readonly currentFrame: ARFrame | undefined;
+
+  // Raycasting
+  raycast(x: number, y: number): ARRaycastResult | undefined;
+  raycastWithQuery(query: RaycastQuery): ARRaycastResult[];
+
+  // Anchors
+  createAnchor(hit: ARRaycastResult): ARAnchor;
+  /** Create anchor at position [x,y,z] with optional rotation quaternion [x,y,z,w] */
+  createAnchorAtPosition(position: number[], rotation?: number[]): ARAnchor;
+  removeAnchor(anchor: ARAnchor): void;
+  readonly anchors: ARAnchor[];
+
+  // Planes
+  readonly planeAnchors: ARPlaneAnchor[];
+
+  // Measurements
+  createMeasurement(start: ARAnchor, end: ARAnchor): ARMeasurement;
+
+  // World Map Persistence
+  getCurrentWorldMap(): Promise<ARWorldMap>;
+
+  // Callbacks
+  onFrameUpdate(callback: (frame: ARFrame) => void): () => void;
+  onTrackingStateChanged(
+    callback: (state: TrackingState, reason: TrackingStateReason) => void
+  ): () => void;
+  onAnchorsUpdated(
+    callback: (added: ARAnchor[], updated: ARAnchor[], removed: string[]) => void
+  ): () => void;
+  onPlanesUpdated(
+    callback: (added: ARPlaneAnchor[], updated: ARPlaneAnchor[], removed: string[]) => void
+  ): () => void;
+
+  // LiDAR / Scene Mesh
+  /** Check LiDAR capabilities on this device */
+  getLiDARCapabilities(): LiDARCapabilities;
+
+  /** Get current mesh anchors (requires sceneReconstruction enabled) */
+  readonly meshAnchors: ARMeshAnchor[];
+
+  /** Callback when mesh anchors are updated */
+  onMeshUpdated(
+    callback: (added: ARMeshAnchor[], updated: ARMeshAnchor[], removed: string[]) => void
+  ): () => void;
+}

package/src/specs/ARView.nitro.ts

@@ -0,0 +1,84 @@
+import type { HybridView, HybridViewMethods, HybridViewProps } from "react-native-nitro-modules";
+import type { SceneReconstructionMode } from "./ARSceneMesh.nitro";
+
+export interface ARViewHitResult {
+  x: number;
+  y: number;
+  z: number;
+}
+
+export interface ARViewProps extends HybridViewProps {
+  /** Enable debug visualization (feature points, world origin) */
+  showDebugOptions?: boolean;
+  /** Enable plane detection visualization */
+  showPlanes?: boolean;
+  /** Enable feature point visualization */
+  showFeaturePoints?: boolean;
+  /** Enable world origin visualization */
+  showWorldOrigin?: boolean;
+  /** Enable automatic lighting */
+  autoenablesDefaultLighting?: boolean;
+
+  // LiDAR Features
+  /** Enable scene mesh reconstruction (requires LiDAR) */
+  sceneReconstruction?: SceneReconstructionMode;
+  /** Show the scene mesh wireframe for debugging */
+  showSceneMesh?: boolean;
+  /** Enable scene depth (requires LiDAR) */
+  sceneDepth?: boolean;
+  /** Enable object occlusion using scene mesh */
+  objectOcclusion?: boolean;
+  /** Enable people occlusion */
+  peopleOcclusion?: boolean;
+}
+
+export interface ARViewMethods extends HybridViewMethods {
+  // Measurement visualization
+  addMeasurementPoint(id: string, x: number, y: number, z: number, color?: string): void;
+  removeMeasurementPoint(id: string): void;
+  updateMeasurementPoint(id: string, x: number, y: number, z: number): void;
+
+  // Line visualization
+  addLine(
+    id: string,
+    fromX: number,
+    fromY: number,
+    fromZ: number,
+    toX: number,
+    toY: number,
+    toZ: number,
+    color?: string
+  ): void;
+  updateLine(
+    id: string,
+    fromX: number,
+    fromY: number,
+    fromZ: number,
+    toX: number,
+    toY: number,
+    toZ: number
+  ): void;
+  removeLine(id: string): void;
+
+  // Label visualization
+  addDistanceLabel(id: string, x: number, y: number, z: number, distance: number): void;
+  updateDistanceLabel(id: string, x: number, y: number, z: number, distance: number): void;
+  removeDistanceLabel(id: string): void;
+
+  // Clear all visuals
+  clearAllVisuals(): void;
+
+  // Raycast from screen point (normalized 0-1)
+  raycast(x: number, y: number): ARViewHitResult | undefined;
+
+  // Session control (the view manages its own session)
+  startSession(): void;
+  pauseSession(): void;
+  resetSession(): void;
+
+  // LiDAR
+  /** Check if LiDAR is available on this device */
+  isLiDARAvailable(): boolean;
+}
+
+export type ARView = HybridView<ARViewProps, ARViewMethods, { ios: "swift" }>;

package/src/specs/ARVolume.nitro.ts

@@ -0,0 +1,15 @@
+import type { HybridObject } from "react-native-nitro-modules";
+
+export interface ARVolume extends HybridObject<{ ios: "swift" }> {
+  /** Center position [x, y, z] */
+  readonly center: number[];
+
+  readonly width: number;
+  readonly height: number;
+  readonly depth: number;
+
+  /** Rotation as quaternion [x, y, z, w] */
+  readonly rotation: number[];
+
+  readonly isStable: boolean;
+}

package/src/specs/ARWorldMap.nitro.ts

@@ -0,0 +1,20 @@
+import type { HybridObject } from "react-native-nitro-modules";
+
+export type WorldMappingStatus = "notAvailable" | "limited" | "extending" | "mapped";
+
+export interface ARWorldMap extends HybridObject<{ ios: "swift" }> {
+  /** Unique identifier for this world map */
+  readonly identifier: string;
+
+  /** Center of the mapped area in world coordinates [x, y, z] */
+  readonly center: number[];
+
+  /** Approximate extent/radius of the mapped area in meters [x, y, z] */
+  readonly extent: number[];
+
+  /** Number of anchors stored in this world map */
+  readonly anchorCount: number;
+
+  /** Serialized world map data as base64 string */
+  getData(): string;
+}