react-native-nitro-ar 2026.2.1

package/ios/HybridARDepthData.swift

@@ -0,0 +1,138 @@
+import ARKit
+import NitroModules
+
+@available(iOS 14.0, *)
+final class HybridARDepthData: HybridARDepthDataSpec {
+    private let depthData: ARDepthData
+
+    init(depthData: ARDepthData) {
+        self.depthData = depthData
+    }
+
+    var width: Double {
+        Double(CVPixelBufferGetWidth(depthData.depthMap))
+    }
+
+    var height: Double {
+        Double(CVPixelBufferGetHeight(depthData.depthMap))
+    }
+
+    var depthMap: [Double] {
+        extractFloatBuffer(depthData.depthMap)
+    }
+
+    var confidenceMap: [Double] {
+        guard let confidence = depthData.confidenceMap else {
+            return []
+        }
+        return extractUInt8Buffer(confidence)
+    }
+
+    func getDepthAt(x: Double, y: Double) -> Double {
+        let buffer = depthData.depthMap
+        let w = CVPixelBufferGetWidth(buffer)
+        let h = CVPixelBufferGetHeight(buffer)
+
+        let px = Int(x * Double(w - 1))
+        let py = Int(y * Double(h - 1))
+
+        guard px >= 0, px < w, py >= 0, py < h else {
+            return 0
+        }
+
+        CVPixelBufferLockBaseAddress(buffer, .readOnly)
+        defer { CVPixelBufferUnlockBaseAddress(buffer, .readOnly) }
+
+        guard let baseAddress = CVPixelBufferGetBaseAddress(buffer) else {
+            return 0
+        }
+
+        let bytesPerRow = CVPixelBufferGetBytesPerRow(buffer)
+        let floatBuffer = baseAddress.assumingMemoryBound(to: Float32.self)
+        let index = py * (bytesPerRow / MemoryLayout<Float32>.size) + px
+
+        return Double(floatBuffer[index])
+    }
+
+    func getConfidenceAt(x: Double, y: Double) -> Double {
+        guard let confidence = depthData.confidenceMap else {
+            return 0
+        }
+
+        let w = CVPixelBufferGetWidth(confidence)
+        let h = CVPixelBufferGetHeight(confidence)
+
+        let px = Int(x * Double(w - 1))
+        let py = Int(y * Double(h - 1))
+
+        guard px >= 0, px < w, py >= 0, py < h else {
+            return 0
+        }
+
+        CVPixelBufferLockBaseAddress(confidence, .readOnly)
+        defer { CVPixelBufferUnlockBaseAddress(confidence, .readOnly) }
+
+        guard let baseAddress = CVPixelBufferGetBaseAddress(confidence) else {
+            return 0
+        }
+
+        let bytesPerRow = CVPixelBufferGetBytesPerRow(confidence)
+        let uint8Buffer = baseAddress.assumingMemoryBound(to: UInt8.self)
+        let index = py * bytesPerRow + px
+
+        return Double(uint8Buffer[index])
+    }
+
+    private func extractFloatBuffer(_ buffer: CVPixelBuffer) -> [Double] {
+        CVPixelBufferLockBaseAddress(buffer, .readOnly)
+        defer { CVPixelBufferUnlockBaseAddress(buffer, .readOnly) }
+
+        let w = CVPixelBufferGetWidth(buffer)
+        let h = CVPixelBufferGetHeight(buffer)
+        let bytesPerRow = CVPixelBufferGetBytesPerRow(buffer)
+
+        guard let baseAddress = CVPixelBufferGetBaseAddress(buffer) else {
+            return []
+        }
+
+        var result: [Double] = []
+        result.reserveCapacity(w * h)
+
+        let floatBuffer = baseAddress.assumingMemoryBound(to: Float32.self)
+        let stride = bytesPerRow / MemoryLayout<Float32>.size
+
+        for y in 0..<h {
+            for x in 0..<w {
+                result.append(Double(floatBuffer[y * stride + x]))
+            }
+        }
+
+        return result
+    }
+
+    private func extractUInt8Buffer(_ buffer: CVPixelBuffer) -> [Double] {
+        CVPixelBufferLockBaseAddress(buffer, .readOnly)
+        defer { CVPixelBufferUnlockBaseAddress(buffer, .readOnly) }
+
+        let w = CVPixelBufferGetWidth(buffer)
+        let h = CVPixelBufferGetHeight(buffer)
+        let bytesPerRow = CVPixelBufferGetBytesPerRow(buffer)
+
+        guard let baseAddress = CVPixelBufferGetBaseAddress(buffer) else {
+            return []
+        }
+
+        var result: [Double] = []
+        result.reserveCapacity(w * h)
+
+        let uint8Buffer = baseAddress.assumingMemoryBound(to: UInt8.self)
+
+        for y in 0..<h {
+            for x in 0..<w {
+                result.append(Double(uint8Buffer[y * bytesPerRow + x]))
+            }
+        }
+
+        return result
+    }
+}

package/ios/HybridARFrame.swift

@@ -0,0 +1,121 @@
+import ARKit
+import NitroModules
+import simd
+
+final class HybridARFrame: HybridARFrameSpec {
+    private let frame: ARFrame
+
+    init(frame: ARFrame) {
+        self.frame = frame
+    }
+
+    var timestamp: Double {
+        frame.timestamp
+    }
+
+    var cameraPosition: [Double] {
+        let t = frame.camera.transform
+        return [
+            Double(t.columns.3.x),
+            Double(t.columns.3.y),
+            Double(t.columns.3.z)
+        ]
+    }
+
+    var cameraRotation: [Double] {
+        let q = simd_quatf(frame.camera.transform)
+        return [
+            Double(q.vector.x),
+            Double(q.vector.y),
+            Double(q.vector.z),
+            Double(q.vector.w)
+        ]
+    }
+
+    var projectionMatrix: [Double] {
+        matrixToArray(frame.camera.projectionMatrix)
+    }
+
+    var viewMatrix: [Double] {
+        matrixToArray(frame.camera.viewMatrix(for: .portrait))
+    }
+
+    var cameraIntrinsics: [Double] {
+        let i = frame.camera.intrinsics
+        return [
+            Double(i.columns.0.x), // fx
+            Double(i.columns.1.y), // fy
+            Double(i.columns.2.x), // cx
+            Double(i.columns.2.y)  // cy
+        ]
+    }
+
+    var imageResolution: [Double] {
+        let size = frame.camera.imageResolution
+        return [Double(size.width), Double(size.height)]
+    }
+
+    var lightEstimate: HybridARLightEstimateSpec? {
+        guard let estimate = frame.lightEstimate else {
+            return nil
+        }
+        return HybridARLightEstimate(estimate: estimate)
+    }
+
+    var directionalLightEstimate: HybridARDirectionalLightEstimateSpec? {
+        guard let estimate = frame.lightEstimate as? ARDirectionalLightEstimate else {
+            return nil
+        }
+        return HybridARDirectionalLightEstimate(estimate: estimate)
+    }
+
+    var sceneDepth: HybridARDepthDataSpec? {
+        if #available(iOS 14.0, *) {
+            guard let depth = frame.sceneDepth else {
+                return nil
+            }
+            return HybridARDepthData(depthData: depth)
+        }
+        return nil
+    }
+
+    var smoothedSceneDepth: HybridARDepthDataSpec? {
+        if #available(iOS 14.0, *) {
+            guard let depth = frame.smoothedSceneDepth else {
+                return nil
+            }
+            return HybridARDepthData(depthData: depth)
+        }
+        return nil
+    }
+
+    func getCapturedImage(quality: Double) -> String {
+        let pixelBuffer = frame.capturedImage
+        let ciImage = CIImage(cvPixelBuffer: pixelBuffer)
+        let context = CIContext()
+
+        guard let cgImage = context.createCGImage(ciImage, from: ciImage.extent) else {
+            return ""
+        }
+
+        let uiImage = UIImage(cgImage: cgImage)
+        guard let jpegData = uiImage.jpegData(compressionQuality: CGFloat(quality)) else {
+            return ""
+        }
+
+        return jpegData.base64EncodedString()
+    }
+
+    private func matrixToArray(_ matrix: simd_float4x4) -> [Double] {
+        [
+            Double(matrix.columns.0.x), Double(matrix.columns.0.y),
+            Double(matrix.columns.0.z), Double(matrix.columns.0.w),
+            Double(matrix.columns.1.x), Double(matrix.columns.1.y),
+            Double(matrix.columns.1.z), Double(matrix.columns.1.w),
+            Double(matrix.columns.2.x), Double(matrix.columns.2.y),
+            Double(matrix.columns.2.z), Double(matrix.columns.2.w),
+            Double(matrix.columns.3.x), Double(matrix.columns.3.y),
+            Double(matrix.columns.3.z), Double(matrix.columns.3.w)
+        ]
+    }
+}

package/ios/HybridARLightEstimate.swift

@@ -0,0 +1,58 @@
+import ARKit
+import NitroModules
+
+final class HybridARLightEstimate: HybridARLightEstimateSpec {
+    private let estimate: ARLightEstimate
+
+    init(estimate: ARLightEstimate) {
+        self.estimate = estimate
+    }
+
+    var ambientIntensity: Double {
+        Double(estimate.ambientIntensity)
+    }
+
+    var ambientColorTemperature: Double {
+        Double(estimate.ambientColorTemperature)
+    }
+}
+
+final class HybridARDirectionalLightEstimate: HybridARDirectionalLightEstimateSpec {
+    private let estimate: ARDirectionalLightEstimate
+
+    init(estimate: ARDirectionalLightEstimate) {
+        self.estimate = estimate
+    }
+
+    var ambientIntensity: Double {
+        Double(estimate.ambientIntensity)
+    }
+
+    var ambientColorTemperature: Double {
+        Double(estimate.ambientColorTemperature)
+    }
+
+    var primaryLightDirection: [Double] {
+        let dir = estimate.primaryLightDirection
+        return [Double(dir.x), Double(dir.y), Double(dir.z)]
+    }
+
+    var primaryLightIntensity: Double {
+        Double(estimate.primaryLightIntensity)
+    }
+
+    var sphericalHarmonicsCoefficients: [Double] {
+        let data = estimate.sphericalHarmonicsCoefficients
+        var result: [Double] = []
+        result.reserveCapacity(27)
+
+        data.withUnsafeBytes { buffer in
+            let floats = buffer.bindMemory(to: Float.self)
+            for i in 0..<min(27, floats.count) {
+                result.append(Double(floats[i]))
+            }
+        }
+
+        return result
+    }
+}

package/ios/HybridARMeasurement.swift

@@ -0,0 +1,33 @@
+import NitroModules
+import simd
+
+final class HybridARMeasurement: HybridARMeasurementSpec {
+    let startAnchor: HybridARAnchor
+    let endAnchor: HybridARAnchor
+
+    init(
+        start: HybridARAnchor,
+        end: HybridARAnchor
+    ) {
+        self.startAnchor = start
+        self.endAnchor = end
+    }
+
+    var start: HybridARAnchorSpec {
+        startAnchor
+    }
+
+    var end: HybridARAnchorSpec {
+        endAnchor
+    }
+
+    var length: Double {
+        let a = startAnchor.anchor.transform.columns.3
+        let b = endAnchor.anchor.transform.columns.3
+        return Double(simd_distance(a, b))
+    }
+
+    var isValid: Bool {
+        startAnchor.isTracked && endAnchor.isTracked
+    }
+}

package/ios/HybridARMeshAnchor.swift

@@ -0,0 +1,108 @@
+import ARKit
+import NitroModules
+
+@available(iOS 13.4, *)
+final class HybridARMeshAnchor: HybridARMeshAnchorSpec {
+    let anchor: ARMeshAnchor
+
+    init(anchor: ARMeshAnchor) {
+        self.anchor = anchor
+        super.init()
+    }
+
+    var identifier: String {
+        anchor.identifier.uuidString
+    }
+
+    var transform: [Double] {
+        let t = anchor.transform
+        return [
+            Double(t.columns.0.x), Double(t.columns.0.y), Double(t.columns.0.z), Double(t.columns.0.w),
+            Double(t.columns.1.x), Double(t.columns.1.y), Double(t.columns.1.z), Double(t.columns.1.w),
+            Double(t.columns.2.x), Double(t.columns.2.y), Double(t.columns.2.z), Double(t.columns.2.w),
+            Double(t.columns.3.x), Double(t.columns.3.y), Double(t.columns.3.z), Double(t.columns.3.w)
+        ]
+    }
+
+    var vertexCount: Double {
+        Double(anchor.geometry.vertices.count)
+    }
+
+    var faceCount: Double {
+        Double(anchor.geometry.faces.count)
+    }
+
+    var vertices: [Double] {
+        let geo = anchor.geometry
+        let vertexBuffer = geo.vertices
+        var result: [Double] = []
+        result.reserveCapacity(vertexBuffer.count * 3)
+
+        for i in 0..<vertexBuffer.count {
+            let vertex = vertexBuffer[i]
+            result.append(Double(vertex.x))
+            result.append(Double(vertex.y))
+            result.append(Double(vertex.z))
+        }
+        return result
+    }
+
+    var faces: [Double] {
+        let geo = anchor.geometry
+        let faceBuffer = geo.faces
+        var result: [Double] = []
+        result.reserveCapacity(faceBuffer.count * 3)
+
+        for i in 0..<faceBuffer.count {
+            let indices = faceBuffer.vertexIndicesOf(faceWithIndex: i)
+            result.append(Double(indices[0]))
+            result.append(Double(indices[1]))
+            result.append(Double(indices[2]))
+        }
+        return result
+    }
+
+    var normals: [Double] {
+        let geo = anchor.geometry
+        let normalBuffer = geo.normals
+        var result: [Double] = []
+        result.reserveCapacity(normalBuffer.count * 3)
+
+        for i in 0..<normalBuffer.count {
+            let normal = normalBuffer[i]
+            result.append(Double(normal.x))
+            result.append(Double(normal.y))
+            result.append(Double(normal.z))
+        }
+        return result
+    }
+
+    var classifications: [MeshClassification] {
+        let geo = anchor.geometry
+        guard let classBuffer = geo.classification else {
+            return []
+        }
+
+        var result: [MeshClassification] = []
+        result.reserveCapacity(classBuffer.count)
+
+        for i in 0..<classBuffer.count {
+            let arClass = classBuffer[i]
+            result.append(mapClassification(arClass))
+        }
+        return result
+    }
+
+    private func mapClassification(_ arClass: ARMeshClassification) -> MeshClassification {
+        switch arClass {
+        case .wall: return .wall
+        case .floor: return .floor
+        case .ceiling: return .ceiling
+        case .table: return .table
+        case .seat: return .seat
+        case .window: return .window
+        case .door: return .door
+        default: return .none
+        }
+    }
+}

package/ios/HybridARPlaneAnchor.swift

@@ -0,0 +1,114 @@
+import ARKit
+import NitroModules
+import simd
+
+final class HybridARPlaneGeometry: HybridARPlaneGeometrySpec {
+    private let geometry: ARPlaneGeometry
+
+    init(geometry: ARPlaneGeometry) {
+        self.geometry = geometry
+    }
+
+    var vertices: [Double] {
+        var result: [Double] = []
+        result.reserveCapacity(geometry.vertices.count * 3)
+        for vertex in geometry.vertices {
+            result.append(Double(vertex.x))
+            result.append(Double(vertex.y))
+            result.append(Double(vertex.z))
+        }
+        return result
+    }
+
+    var textureCoordinates: [Double] {
+        var result: [Double] = []
+        result.reserveCapacity(geometry.textureCoordinates.count * 2)
+        for coord in geometry.textureCoordinates {
+            result.append(Double(coord.x))
+            result.append(Double(coord.y))
+        }
+        return result
+    }
+
+    var triangleIndices: [Double] {
+        geometry.triangleIndices.map { Double($0) }
+    }
+
+    var boundaryVertices: [Double] {
+        var result: [Double] = []
+        result.reserveCapacity(geometry.boundaryVertices.count * 2)
+        for vertex in geometry.boundaryVertices {
+            result.append(Double(vertex.x))
+            result.append(Double(vertex.z))
+        }
+        return result
+    }
+}
+
+final class HybridARPlaneAnchor: HybridARPlaneAnchorSpec {
+    private let anchor: ARPlaneAnchor
+
+    init(anchor: ARPlaneAnchor) {
+        self.anchor = anchor
+    }
+
+    var identifier: String {
+        anchor.identifier.uuidString
+    }
+
+    var position: [Double] {
+        let t = anchor.transform
+        return [
+            Double(t.columns.3.x),
+            Double(t.columns.3.y),
+            Double(t.columns.3.z)
+        ]
+    }
+
+    var rotation: [Double] {
+        let q = simd_quatf(anchor.transform)
+        return [
+            Double(q.vector.x),
+            Double(q.vector.y),
+            Double(q.vector.z),
+            Double(q.vector.w)
+        ]
+    }
+
+    var alignment: PlaneAlignment {
+        switch anchor.alignment {
+        case .horizontal: return .horizontal
+        case .vertical: return .vertical
+        @unknown default: return .horizontal
+        }
+    }
+
+    var classification: PlaneClassification {
+        switch anchor.classification {
+        case .wall: return .wall
+        case .floor: return .floor
+        case .ceiling: return .ceiling
+        case .table: return .table
+        case .seat: return .seat
+        case .window: return .window
+        case .door: return .door
+        default: return .none
+        }
+    }
+
+    var extent: [Double] {
+        [Double(anchor.planeExtent.width), Double(anchor.planeExtent.height)]
+    }
+
+    var center: [Double] {
+        [
+            Double(anchor.center.x),
+            Double(anchor.center.y),
+            Double(anchor.center.z)
+        ]
+    }
+
+    var geometry: HybridARPlaneGeometrySpec {
+        HybridARPlaneGeometry(geometry: anchor.geometry)
+    }
+}

package/ios/HybridARRaycastResult.swift

@@ -0,0 +1,53 @@
+import ARKit
+import NitroModules
+import simd
+
+final class HybridARRaycastResult: HybridARRaycastResultSpec {
+    let result: ARRaycastResult
+
+    init(result: ARRaycastResult) {
+        self.result = result
+    }
+
+    var position: [Double] {
+        let t = result.worldTransform
+        return [
+            Double(t.columns.3.x),
+            Double(t.columns.3.y),
+            Double(t.columns.3.z)
+        ]
+    }
+
+    var rotation: [Double] {
+        let q = simd_quatf(result.worldTransform)
+        return [
+            Double(q.vector.x),
+            Double(q.vector.y),
+            Double(q.vector.z),
+            Double(q.vector.w)
+        ]
+    }
+
+    var distance: Double {
+        // Calculate distance from camera (origin) to hit point
+        let pos = result.worldTransform.columns.3
+        return Double(sqrt(pos.x * pos.x + pos.y * pos.y + pos.z * pos.z))
+    }
+
+    var target: RaycastTarget {
+        switch result.target {
+        case .existingPlaneGeometry:
+            return .existingplanegeometry
+        case .existingPlaneInfinite:
+            return .existingplaneinfinite
+        case .estimatedPlane:
+            return .estimatedplane
+        @unknown default:
+            return .any
+        }
+    }
+
+    var anchorId: String? {
+        result.anchor?.identifier.uuidString
+    }
+}