🥽 ARKit

import ARKit
import RealityKit

class ARViewController: UIViewController {
    var arView: ARView!

    override func viewDidLoad() {
        super.viewDidLoad()

        // ARView 생성
        arView = ARView(frame: view.bounds)
        view.addSubview(arView)

        // AR 세션 설정
        setupARSession()
    }

    func setupARSession() {
        // World Tracking Configuration
        let configuration = ARWorldTrackingConfiguration()

        // 평면 감지 (수평, 수직)
        configuration.planeDetection = [.horizontal, .vertical]

        // 환경 텍스처링 (사실적인 반사)
        configuration.environmentTexturing = .automatic

        // LiDAR 활용 (iPhone 12 Pro 이상)
        if ARWorldTrackingConfiguration.supportsSceneReconstruction(.mesh) {
            configuration.sceneReconstruction = .mesh
        }

        // 세션 실행
        arView.session.run(configuration)
    }

    override func viewWillDisappear(_ animated: Bool) {
        super.viewWillDisappear(animated)
        arView.session.pause()
    }
}

import RealityKit

extension ARViewController {
    // 탭 위치에 객체 배치
    func placeObject(at location: CGPoint) {
        // Raycast로 실제 세계 위치 찾기
        guard let raycastResult = arView.raycast(
            from: location,
            allowing: .estimatedPlane,
            alignment: .horizontal
        ).first else { return }

        // 3D 모델 로드
        Task {
            do {
                let entity = try await ModelEntity(named: "chair.usdz")

                // 앵커 생성 및 배치
                let anchor = AnchorEntity(world: raycastResult.worldTransform)
                anchor.addChild(entity)

                // 씬에 추가
                arView.scene.addAnchor(anchor)

                // 충돌 감지 활성화
                entity.generateCollisionShapes(recursive: true)
                arView.installGestures(for: entity)
            } catch {
                print("모델 로드 실패: \(error)")
            }
        }
    }

    // 커스텀 박스 생성
    func createBox(at position: SIMD3<Float>) {
        // 메시 생성
        let mesh = MeshResource.generateBox(size: 0.1)

        // 머티리얼 설정
        var material = SimpleMaterial()
        material.color = .init(tint: .blue, texture: nil)

        // 엔티티 생성
        let entity = ModelEntity(mesh: mesh, materials: [material])

        // 앵커에 추가
        let anchor = AnchorEntity(world: position)
        anchor.addChild(entity)
        arView.scene.addAnchor(anchor)
    }
}

import ARKit

extension ARViewController: ARSessionDelegate {
    func setupPlaneDetection() {
        arView.session.delegate = self
    }

    // 새 앵커 추가됨 (평면 감지)
    func session(_ session: ARSession, didAdd anchors: [ARAnchor]) {
        for anchor in anchors {
            if let planeAnchor = anchor as? ARPlaneAnchor {
                handlePlaneDetection(planeAnchor)
            }
        }
    }

    // 앵커 업데이트 (평면 확장)
    func session(_ session: ARSession, didUpdate anchors: [ARAnchor]) {
        for anchor in anchors {
            if let planeAnchor = anchor as? ARPlaneAnchor {
                updatePlaneVisualization(planeAnchor)
            }
        }
    }

    func handlePlaneDetection(_ planeAnchor: ARPlaneAnchor) {
        // 평면 크기
        let width = planeAnchor.planeExtent.width
        let height = planeAnchor.planeExtent.height

        // 평면 타입
        let alignment = planeAnchor.alignment
        print("평면 감지: \(alignment == .horizontal ? "수평" : "수직") \(width)x\(height)m")

        // 평면 시각화 (선택 사항)
        let planeMesh = MeshResource.generatePlane(width: width, depth: height)
        var material = SimpleMaterial()
        material.color = .init(tint: .white.withAlphaComponent(0.3), texture: nil)

        let planeEntity = ModelEntity(mesh: planeMesh, materials: [material])
        let anchorEntity = AnchorEntity(anchor: planeAnchor)
        anchorEntity.addChild(planeEntity)
        arView.scene.addAnchor(anchorEntity)
    }

    func updatePlaneVisualization(_ planeAnchor: ARPlaneAnchor) {
        // 평면 확장/업데이트 처리
    }
}

import ARKit

class FaceTrackingViewController: UIViewController {
    var arView: ARView!

    override func viewDidLoad() {
        super.viewDidLoad()

        arView = ARView(frame: view.bounds)
        view.addSubview(arView)

        // Face Tracking 설정
        guard ARFaceTrackingConfiguration.isSupported else {
            print("Face Tracking 미지원")
            return
        }

        let configuration = ARFaceTrackingConfiguration()
        configuration.maximumNumberOfTrackedFaces = 1
        arView.session.run(configuration)

        arView.session.delegate = self
    }
}

extension FaceTrackingViewController: ARSessionDelegate {
    func session(_ session: ARSession, didUpdate anchors: [ARAnchor]) {
        for anchor in anchors {
            guard let faceAnchor = anchor as? ARFaceAnchor else { continue }

            // 얼굴 블렌드쉐입 (표정)
            let blendShapes = faceAnchor.blendShapes

            // 눈 깜빡임
            if let eyeBlinkLeft = blendShapes[.eyeBlinkLeft]?.floatValue,
               let eyeBlinkRight = blendShapes[.eyeBlinkRight]?.floatValue {
                print("눈 깜빡임: L=\(eyeBlinkLeft) R=\(eyeBlinkRight)")
            }

            // 미소
            if let smile = blendShapes[.mouthSmileLeft]?.floatValue {
                print("미소: \(smile)")
            }

            // 입 벌림
            if let jawOpen = blendShapes[.jawOpen]?.floatValue {
                print("입 벌림: \(jawOpen)")
            }

            // 얼굴 위치와 회전
            let transform = faceAnchor.transform
            print("얼굴 위치: \(transform.columns.3)")
        }
    }
}

import ARKit

extension ARViewController {
    func setupImageTracking() {
        // AR 참조 이미지 로드
        guard let referenceImages = ARReferenceImage.referenceImages(
            inGroupNamed: "AR Resources",
            bundle: nil
        ) else {
            print("이미지 에셋 없음")
            return
        }

        let configuration = ARWorldTrackingConfiguration()
        configuration.detectionImages = referenceImages
        configuration.maximumNumberOfTrackedImages = 2

        arView.session.run(configuration)
    }

    // 이미지 감지됨
    func session(_ session: ARSession, didAdd anchors: [ARAnchor]) {
        for anchor in anchors {
            guard let imageAnchor = anchor as? ARImageAnchor else { continue }

            // 감지된 이미지 정보
            let referenceImage = imageAnchor.referenceImage
            let imageName = referenceImage.name ?? "알 수 없음"

            print("이미지 감지: \(imageName)")

            // 이미지 위에 3D 콘텐츠 배치
            placeContentOnImage(imageAnchor)
        }
    }

    func placeContentOnImage(_ imageAnchor: ARImageAnchor) {
        // 이미지 크기
        let imageSize = imageAnchor.referenceImage.physicalSize

        // 이미지 위에 평면 생성
        let plane = MeshResource.generatePlane(
            width: Float(imageSize.width),
            depth: Float(imageSize.height)
        )

        var material = SimpleMaterial()
        material.color = .init(tint: .green.withAlphaComponent(0.5), texture: nil)

        let planeEntity = ModelEntity(mesh: plane, materials: [material])

        let anchorEntity = AnchorEntity(anchor: imageAnchor)
        anchorEntity.addChild(planeEntity)
        arView.scene.addAnchor(anchorEntity)
    }
}

import SwiftUI
import ARKit
import RealityKit

struct ARViewContainer: UIViewRepresentable {
    @Binding var placementEnabled: Bool

    func makeUIView(context: Context) -> ARView {
        let arView = ARView(frame: .zero)

        // AR 세션 설정
        let config = ARWorldTrackingConfiguration()
        config.planeDetection = [.horizontal]
        arView.session.run(config)

        // 탭 제스처 추가
        let tapGesture = UITapGestureRecognizer(
            target: context.coordinator,
            action: #selector(Coordinator.handleTap)
        )
        arView.addGestureRecognizer(tapGesture)

        context.coordinator.arView = arView

        return arView
    }

    func updateUIView(_ uiView: ARView, context: Context) {
        context.coordinator.placementEnabled = placementEnabled
    }

    func makeCoordinator() -> Coordinator {
        Coordinator(placementEnabled: $placementEnabled)
    }

    class Coordinator: NSObject {
        var arView: ARView?
        @Binding var placementEnabled: Bool

        init(placementEnabled: Binding<Bool>) {
            _placementEnabled = placementEnabled
        }

        @objc func handleTap(_ sender: UITapGestureRecognizer) {
            guard placementEnabled, let arView else { return }

            let location = sender.location(in: arView)

            // Raycast
            if let result = arView.raycast(from: location, allowing: .estimatedPlane, alignment: .horizontal).first {
                // 박스 생성
                let mesh = MeshResource.generateBox(size: 0.1)
                let material = SimpleMaterial(color: .blue, isMetallic: false)
                let entity = ModelEntity(mesh: mesh, materials: [material])

                let anchor = AnchorEntity(world: result.worldTransform)
                anchor.addChild(entity)
                arView.scene.addAnchor(anchor)
            }
        }
    }
}

struct ARDemoView: View {
    @State private var placementEnabled = false

    var body: some View {
        ZStack {
            ARViewContainer(placementEnabled: $placementEnabled)
                .ignoresSafeArea()

            VStack {
                Spacer()

                Button {
                    placementEnabled.toggle()
                } label: {
                    Label(
                        placementEnabled ? "배치 중지" : "배치 시작",
                        systemImage: placementEnabled ? "stop.circle" : "play.circle"
                    )
                }
                .buttonStyle(.borderedProminent)
                .padding()
            }
        }
    }
}