Rork Max × visionOS 空間コンピューティングアプリ開発 — Vision Pro 対応アプリを AI で構築する

import RealityKit
import RealityKitContent
 
struct ImmersiveGalleryView: View {
    @State private var artPieces: [ArtPiece] = []
 
    var body: some View {
        RealityView { content in
            // 環境光を設定
            let environment = try? await EnvironmentResource(
                named: "gallery_lighting"
            )
            if let env = environment {
                content.add(env)
            }
 
            // 3Dモデルを円形に配置
            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,  // 目の高さに配置
                        sin(angle) * radius
                    )
                    // 中心を向くように回転
                    model.look(
                        at: SIMD3<Float>(0, 1.5, 0),
                        from: model.position,
                        relativeTo: nil
                    )
                    // タップ可能にするコンポーネント
                    model.components.set(
                        InputTargetComponent()
                    )
                    model.components.set(
                        CollisionComponent(
                            shapes: [.generateBox(
                                size: [0.5, 0.5, 0.5]
                            )]
                        )
                    )
                    content.add(model)
                }
            }
        }
        .gesture(tapGesture)
    }
 
    // 3Dオブジェクトへのタップジェスチャー
    private var tapGesture: some Gesture {
        SpatialTapGesture()
            .targetedToAnyEntity()
            .onEnded { value in
                let entity = value.entity
                // 選択アニメーションを再生
                playSelectionAnimation(on: entity)
            }
    }
 
    private func playSelectionAnimation(on entity: Entity) {
        // スケールアニメーション
        var transform = entity.transform
        transform.scale = SIMD3<Float>(repeating: 1.3)
        entity.move(
            to: transform,
            relativeTo: entity.parent,
            duration: 0.3,
            timingFunction: .easeInOut
        )
        // 0.3秒後に元に戻す
        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
            )
        }
    }
}
// 期待される動作:
// - 没入空間内に3Dモデルが円形に配置される
// - 各モデルは中心を向き、タップ操作で選択アニメーションが再生される

// Reality Composer Pro で作成したシーンを読み込む
let sceneEntity = try await Entity(
    named: "GalleryScene",
    in: realityKitContentBundle
)
// シーン内の特定エンティティを検索
if let pedestal = sceneEntity.findEntity(named: "Pedestal") {
    pedestal.components.set(
        HoverEffectComponent()  // 視線ホバー時のエフェクト
    )
}
// 期待される動作:
// - Reality Composer Pro で設計したシーンがそのまま表示される
// - Pedestal エンティティに視線ホバーエフェクトが適用される

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 {
        // ハンドトラッキングの認可チェック
        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
        }
 
        // ハンドアンカーの更新をリアルタイム監視
        for await update in handTracking.anchorUpdates {
            let hand = update.anchor
 
            guard hand.isTracked else { continue }
 
            // 手首の位置を取得
            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
                    }
                }
            }
 
            // ピンチジェスチャーの検出
            // 親指と人差し指の距離で判定
            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
                    // 2cm以下でピンチと判定
                }
            }
        }
    }
}
// 期待される動作:
// - 左右の手の位置がリアルタイムで更新される
// - 親指と人差し指の距離が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)
            }
        }
        // 回転ジェスチャー
        .gesture(
            RotateGesture3D()
                .targetedToAnyEntity()
                .onChanged { value in
                    let entity = value.entity
                    entity.orientation = simd_quatf(
                        value.rotation
                    )
                }
        )
        // ピンチによるスケール変更
        .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
                    )
                }
        )
    }
}
// 期待される動作:
// - 3Dモデルを両手の回転ジェスチャーで回せる
// - ピンチイン・アウトでモデルのスケールを0.5〜3.0倍に変更できる

func attachSpatialAudio(
    to entity: Entity,
    audioFile: String
) async {
    // 空間オーディオリソースの読み込み
    guard let resource = try? await AudioFileResource(
        named: audioFile,
        configuration: AudioFileResource.Configuration(
            shouldLoop: true,
            shouldRandomizeStartTime: false
        )
    ) else {
        print("Failed to load audio: \(audioFile)")
        return
    }
 
    // 空間オーディオコンポーネントの設定
    let audioSource = Entity()
    audioSource.spatialAudio = SpatialAudioComponent(
        directivity: .beam(focus: 0.5)
        // 指向性: beamは特定方向に音を集中させる
    )
    audioSource.spatialAudio?.gain = -10  // 音量（dB）
 
    entity.addChild(audioSource)
 
    // 再生開始
    audioSource.playAudio(resource)
}
// 期待される動作:
// - エンティティの位置に基づいて空間オーディオが再生される
// - ユーザーが音源に近づくと音量が上がり、遠ざかると下がる
// - 指向性設定により、正面からの音が最も大きく聞こえる

class SceneManager: ObservableObject {
    private var loadedEntities: [String: Entity] = [:]
    private let maxCachedEntities = 20
 
    /// エンティティを遅延読み込み（LRUキャッシュ）
    func loadEntity(named name: String) async -> Entity? {
        // キャッシュから取得
        if let cached = loadedEntities[name] {
            return cached.clone(recursive: true)
        }
 
        // 新規読み込み
        guard let entity = try? await Entity(
            named: name,
            in: realityKitContentBundle
        ) else {
            return nil
        }
 
        // キャッシュが上限を超えたら古いものを除去
        if loadedEntities.count >= maxCachedEntities {
            let oldest = loadedEntities.keys.first!
            loadedEntities.removeValue(forKey: oldest)
        }
        loadedEntities[name] = entity
 
        return entity.clone(recursive: true)
    }
 
    /// シーン遷移時のクリーンアップ
    func clearScene(content: RealityViewContent) {
        content.entities.forEach { entity in
            entity.removeFromParent()
        }
        // 不要なエンティティのキャッシュもクリア
        loadedEntities.removeAll()
    }
}
// 期待される動作:
// - 3Dモデルが LRU キャッシュで管理され、メモリ使用量が一定以下に保たれる
// - シーン遷移時にエンティティとキャッシュが適切にクリーンアップされる