🥽 ARKit

⭐ Difficulty: ⭐⭐⭐⭐ ⏱️ Est. Time: 3-4h 📂 Graphics & Media

Merging reality and digital with augmented reality

iOS 11+visionOS Supported

✨ ARKit is?

ARKit is Apple's augmented reality framework that uses cameras and sensors to place and interact with virtual objects in the real world. It provides powerful AR experiences including plane detection, face tracking, image recognition, and spatial audio.

💡 Key Features: World Tracking · Plane Detection · Face Tracking · Image/Object Recognition · LiDAR · Spatial Audio · Multi-User AR · RealityKit Integration

🎯 1. AR 세션 설정

Start an ARSession and configure the basic setup.

ARViewController.swift — Start AR Session

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()
    }
}

🪑 2. 3D 객체 배치

AR 공간에 3D 모델을 배치.

ARObjectPlacement.swift — Object Placement

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)
    }
}

📐 3. 평면 감지

바닥이나 벽 같은 평면을 자동으로 감지.

ARPlaneDetection.swift — Plane Detection

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) {
        // 평면 확장/업데이트 처리
    }
}

😊 4. 얼굴 추적 (Face Tracking)

Track facial expressions and movement with the TrueDepth camera.

ARFaceTracking.swift — Face Tracking

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)")
        }
    }
}

🖼️ 5. 이미지 추적

Recognize specific images and overlay AR content.

ARImageTracking.swift — Image Tracking

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)
    }
}

📱 SwiftUI Integration

ARDemoView.swift — SwiftUI Wrapper

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()
            }
        }
    }
}

💡 HIG Guidelines

안전: AR 사용 시 주변을 살펴보라는 경고 메시지 표시
초기화: 평면 감지 중임을 사용자에게 명확히 안내
피드백: 객체 배치 가능한 영역을 시각적으로 표시
조명: 충분한 조명이 필요함을 안내
권한: In Info.plist, NSCameraUsageDescription 추가
성능: 복잡한 3D 모델은 최적화하여 사용

🎯 Practical Usage

가구 배치 앱: 실제 공간에 가구를 미리 배치해보기
Education Apps: 3D 모델로 학습 콘텐츠 시각화
쇼핑 앱: 제품을 AR로 미리 체험
Games: 현실 공간을 게임 필드로 활용
내비게이션: AR로 실시간 길 안내

📚 Learn More

⚡️ LiDAR 활용: The LiDAR sensor on iPhone 12 Pro and later enables more accurate depth sensing and faster plane detection. sceneReconstruction = .mesh로 실시간 3D 메시를 생성 is possible.

📎 Apple Official Resources

📘 Documentation 💻 Sample Code 🎬 WWDC Sessions