Rork Max × visionOS Spatial Computing App Development Guide— Build Vision Pro Apps with AI

import RealityKit
import RealityKitContent
 
struct ImmersiveGalleryView: View {
    @State private var artPieces: [ArtPiece] = []
 
    var body: some View {
        RealityView { content in
            // Set up environment lighting
            let environment = try? await EnvironmentResource(
                named: "gallery_lighting"
            )
            if let env = environment {
                content.add(env)
            }
 
            // Arrange 3D models in a circle
            for (index, piece) in artPieces.enumerated() {
                let angle = Float(index) / Float(artPieces.count)
                    * 2 * .pi
                let radius: Float = 3.0
 
                let entity = try? await Entity(
                    named: piece.modelName,
                    in: realityKitContentBundle
                )
                if let model = entity {
                    model.position = SIMD3<Float>(
                        cos(angle) * radius,
                        1.5,  // Position at eye level
                        sin(angle) * radius
                    )
                    // Rotate to face center
                    model.look(
                        at: SIMD3<Float>(0, 1.5, 0),
                        from: model.position,
                        relativeTo: nil
                    )
                    // Enable tap interaction
                    model.components.set(
                        InputTargetComponent()
                    )
                    model.components.set(
                        CollisionComponent(
                            shapes: [.generateBox(
                                size: [0.5, 0.5, 0.5]
                            )]
                        )
                    )
                    content.add(model)
                }
            }
        }
        .gesture(tapGesture)
    }
 
    // Tap gesture for 3D entities
    private var tapGesture: some Gesture {
        SpatialTapGesture()
            .targetedToAnyEntity()
            .onEnded { value in
                let entity = value.entity
                // Play selection animation
                playSelectionAnimation(on: entity)
            }
    }
 
    private func playSelectionAnimation(on entity: Entity) {
        // Scale animation
        var transform = entity.transform
        transform.scale = SIMD3<Float>(repeating: 1.3)
        entity.move(
            to: transform,
            relativeTo: entity.parent,
            duration: 0.3,
            timingFunction: .easeInOut
        )
        // Reset after 0.3 seconds
        Task {
            try? await Task.sleep(for: .seconds(0.3))
            transform.scale = SIMD3<Float>(repeating: 1.0)
            entity.move(
                to: transform,
                relativeTo: entity.parent,
                duration: 0.3,
                timingFunction: .easeInOut
            )
        }
    }
}
// Expected behavior:
// - 3D models are arranged in a circle within the immersive space
// - Each model faces the center and plays a selection animation on tap

// Load a scene created in Reality Composer Pro
let sceneEntity = try await Entity(
    named: "GalleryScene",
    in: realityKitContentBundle
)
// Find a specific entity within the scene
if let pedestal = sceneEntity.findEntity(named: "Pedestal") {
    pedestal.components.set(
        HoverEffectComponent()  // Visual feedback on gaze hover
    )
}
// Expected behavior:
// - The scene designed in Reality Composer Pro loads as-is
// - The Pedestal entity shows a hover effect when the user looks at it

import ARKit
 
class HandTrackingManager: ObservableObject {
    private let session = ARKitSession()
    private let handTracking = HandTrackingProvider()
 
    @Published var leftHandPosition: SIMD3<Float>?
    @Published var rightHandPosition: SIMD3<Float>?
    @Published var isPinching: Bool = false
 
    func startTracking() async {
        // Check hand tracking authorization
        guard HandTrackingProvider.isSupported else {
            print("Hand tracking is not supported")
            return
        }
 
        do {
            try await session.run([handTracking])
        } catch {
            print("Failed to start hand tracking: \(error)")
            return
        }
 
        // Monitor hand anchor updates in real time
        for await update in handTracking.anchorUpdates {
            let hand = update.anchor
 
            guard hand.isTracked else { continue }
 
            // Get wrist position
            if let wrist = hand.skeleton.joint(.wrist) {
                let position = hand.originFromAnchorTransform
                    * wrist.anchorFromJointTransform
 
                let worldPos = SIMD3<Float>(
                    position.columns.3.x,
                    position.columns.3.y,
                    position.columns.3.z
                )
 
                await MainActor.run {
                    switch hand.chirality {
                    case .left:
                        self.leftHandPosition = worldPos
                    case .right:
                        self.rightHandPosition = worldPos
                    }
                }
            }
 
            // Detect pinch gesture
            // Based on distance between thumb tip and index finger tip
            if let thumbTip = hand.skeleton.joint(.thumbTip),
               let indexTip = hand.skeleton.joint(
                   .indexFingerTip
               ) {
                let thumbPos = hand.originFromAnchorTransform
                    * thumbTip.anchorFromJointTransform
                let indexPos = hand.originFromAnchorTransform
                    * indexTip.anchorFromJointTransform
 
                let distance = simd_distance(
                    SIMD3<Float>(
                        thumbPos.columns.3.x,
                        thumbPos.columns.3.y,
                        thumbPos.columns.3.z
                    ),
                    SIMD3<Float>(
                        indexPos.columns.3.x,
                        indexPos.columns.3.y,
                        indexPos.columns.3.z
                    )
                )
 
                await MainActor.run {
                    self.isPinching = distance < 0.02
                    // Pinch detected when distance < 2cm
                }
            }
        }
    }
}
// Expected behavior:
// - Left and right hand positions update in real time
// - isPinching becomes true when thumb and index finger are within 2cm

struct InteractiveModelView: View {
    @State private var rotation: Rotation3D = .identity
    @State private var scale: Double = 1.0
 
    var body: some View {
        RealityView { content in
            if let model = try? await Entity(
                named: "ProductModel",
                in: realityKitContentBundle
            ) {
                model.components.set(InputTargetComponent())
                model.components.set(
                    CollisionComponent(
                        shapes: [.generateConvex(
                            from: model
                        )]
                    )
                )
                content.add(model)
            }
        }
        // Rotation gesture
        .gesture(
            RotateGesture3D()
                .targetedToAnyEntity()
                .onChanged { value in
                    let entity = value.entity
                    entity.orientation = simd_quatf(
                        value.rotation
                    )
                }
        )
        // Pinch-to-scale gesture
        .gesture(
            MagnifyGesture()
                .targetedToAnyEntity()
                .onChanged { value in
                    let entity = value.entity
                    let newScale = Float(
                        max(0.5, min(3.0, value.magnification))
                    )
                    entity.scale = SIMD3<Float>(
                        repeating: newScale
                    )
                }
        )
    }
}
// Expected behavior:
// - 3D model rotates with two-hand rotation gestures
// - Pinch in/out scales the model between 0.5x and 3.0x

func attachSpatialAudio(
    to entity: Entity,
    audioFile: String
) async {
    // Load spatial audio resource
    guard let resource = try? await AudioFileResource(
        named: audioFile,
        configuration: AudioFileResource.Configuration(
            shouldLoop: true,
            shouldRandomizeStartTime: false
        )
    ) else {
        print("Failed to load audio: \(audioFile)")
        return
    }
 
    // Configure spatial audio component
    let audioSource = Entity()
    audioSource.spatialAudio = SpatialAudioComponent(
        directivity: .beam(focus: 0.5)
        // Directivity: beam focuses sound in a specific direction
    )
    audioSource.spatialAudio?.gain = -10  // Volume in dB
 
    entity.addChild(audioSource)
 
    // Start playback
    audioSource.playAudio(resource)
}
// Expected behavior:
// - Spatial audio plays based on the entity's position
// - Volume increases as the user moves closer, decreases when moving away
// - Directivity settings make sound loudest from the front

class SceneManager: ObservableObject {
    private var loadedEntities: [String: Entity] = [:]
    private let maxCachedEntities = 20
 
    /// Lazy-load entities with LRU cache
    func loadEntity(named name: String) async -> Entity? {
        // Return from cache if available
        if let cached = loadedEntities[name] {
            return cached.clone(recursive: true)
        }
 
        // Load fresh
        guard let entity = try? await Entity(
            named: name,
            in: realityKitContentBundle
        ) else {
            return nil
        }
 
        // Evict oldest entry if cache is full
        if loadedEntities.count >= maxCachedEntities {
            let oldest = loadedEntities.keys.first!
            loadedEntities.removeValue(forKey: oldest)
        }
        loadedEntities[name] = entity
 
        return entity.clone(recursive: true)
    }
 
    /// Clean up on scene transitions
    func clearScene(content: RealityViewContent) {
        content.entities.forEach { entity in
            entity.removeFromParent()
        }
        // Clear entity cache as well
        loadedEntities.removeAll()
    }
}
// Expected behavior:
// - 3D models managed via LRU cache, keeping memory usage bounded
// - Entities and cache properly cleaned up on scene transitions