---
id: wiki-2026-0508-mobile-augmented-reality
title: Mobile Augmented Reality
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Mobile AR, Smartphone AR]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [ar, mobile, computer-vision, 3d]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: Swift / Kotlin / C#
  framework: ARKit 7 / ARCore / Unity AR Foundation
---

# Mobile Augmented Reality

## 매 한 줄
> **"매 스마트폰 매 camera 매 real-time 3D 매 합성 — 매 SLAM 기반 device-pose tracking + plane detection + lighting estimation"**. Apple ARKit (2017), Google ARCore (2018) 매 starting point, 매 2026 매 ARKit 7 + ARCore 1.45 + Unity AR Foundation 6 매 unified API, 매 LiDAR/depth sensor 매 mesh reconstruction 매 standard.

## 매 핵심

### 매 핵심 capabilities
- **6DoF tracking**: 매 device pose (position + rotation) 매 visual-inertial SLAM.
- **Plane detection**: 매 horizontal/vertical plane 매 detect.
- **Hit testing**: 매 screen ray 매 world surface 매 intersection.
- **Lighting estimation**: 매 ambient light + spherical harmonics + shadow.
- **Anchors**: 매 world coordinate 매 stable point 매 attach virtual object.
- **People occlusion**: 매 ML-based segmentation 매 사람 뒤 / 앞 렌더링.
- **Depth API**: 매 LiDAR (iPhone Pro) / ToF (Android) / monocular (ML).
- **Cloud anchors / Persistent anchors**: 매 multi-device + multi-session 공유.

### 매 platforms
- **ARKit 7** (iOS 19): RoomPlan, Object Capture (photogrammetry), Geo Anchors, Vision Pro bridge.
- **ARCore 1.45** (Android): Geospatial API (Streetscape Geometry), Depth API, Cloud Anchors.
- **Unity AR Foundation 6**: cross-platform abstraction over ARKit/ARCore.
- **Unreal AR**: Niagara particles + Lumen — 매 high-fidelity preferred.
- **WebXR Device API**: browser-based AR (Chrome Android, Quest browser).

### 매 응용
1. IKEA Place — furniture preview in room.
2. Snapchat Lenses — face/world filters.
3. Pokémon GO — geo-anchored creatures.
4. Google Maps Live View — walking AR navigation.
5. Industrial maintenance overlays.

## 💻 패턴

### ARKit RealityKit (Swift)
```swift
import ARKit
import RealityKit

class ARController: NSObject, ARSessionDelegate {
  let arView = ARView(frame: .zero)

  func start() {
    let config = ARWorldTrackingConfiguration()
    config.planeDetection = [.horizontal, .vertical]
    config.environmentTexturing = .automatic
    if ARWorldTrackingConfiguration.supportsFrameSemantics(.sceneDepth) {
      config.frameSemantics.insert(.sceneDepth) // LiDAR
    }
    arView.session.run(config)
    arView.session.delegate = self
  }

  func placeBox(at screenPoint: CGPoint) {
    guard let result = arView.raycast(from: screenPoint,
                                      allowing: .estimatedPlane,
                                      alignment: .horizontal).first else { return }
    let anchor = AnchorEntity(world: result.worldTransform)
    let box = ModelEntity(mesh: .generateBox(size: 0.1),
                          materials: [SimpleMaterial(color: .red, isMetallic: false)])
    anchor.addChild(box)
    arView.scene.addAnchor(anchor)
  }
}
```

### ARCore (Kotlin)
```kotlin
class ArSceneView(context: Context) : GLSurfaceView(context) {
    private lateinit var session: Session

    fun init(activity: Activity) {
        session = Session(activity)
        val config = Config(session).apply {
            planeFindingMode = Config.PlaneFindingMode.HORIZONTAL_AND_VERTICAL
            lightEstimationMode = Config.LightEstimationMode.ENVIRONMENTAL_HDR
            depthMode = if (session.isDepthModeSupported(Config.DepthMode.AUTOMATIC))
                Config.DepthMode.AUTOMATIC else Config.DepthMode.DISABLED
        }
        session.configure(config)
    }

    fun onTap(x: Float, y: Float) {
        val frame = session.update()
        for (hit in frame.hitTest(x, y)) {
            val trackable = hit.trackable
            if (trackable is Plane && trackable.isPoseInPolygon(hit.hitPose)) {
                val anchor = hit.createAnchor()
                placeModel(anchor)
                return
            }
        }
    }
}
```

### Unity AR Foundation (C#)
```csharp
using UnityEngine;
using UnityEngine.XR.ARFoundation;
using UnityEngine.XR.ARSubsystems;

public class PlaceObject : MonoBehaviour {
    public ARRaycastManager raycaster;
    public GameObject prefab;
    static List<ARRaycastHit> hits = new();

    void Update() {
        if (Input.touchCount == 0) return;
        var touch = Input.GetTouch(0);
        if (touch.phase != TouchPhase.Began) return;

        if (raycaster.Raycast(touch.position, hits, TrackableType.PlaneWithinPolygon)) {
            var pose = hits[0].pose;
            Instantiate(prefab, pose.position, pose.rotation);
        }
    }
}
```

### People occlusion (ARKit)
```swift
config.frameSemantics.insert(.personSegmentationWithDepth)
arView.environment.background = .cameraFeed()
arView.renderOptions.remove(.disablePersonOcclusion)
```

### Geospatial anchor (ARCore)
```kotlin
val earth = session.earth ?: return
if (earth.trackingState != TrackingState.TRACKING) return

val anchor = earth.createAnchor(
    37.7749, -122.4194, // lat/lng
    altitude,
    0f, 0f, 0f, 1f // quaternion
)
```

### WebXR (browser AR)
```js
const session = await navigator.xr.requestSession('immersive-ar', {
  requiredFeatures: ['hit-test', 'local'],
})
const refSpace = await session.requestReferenceSpace('local')
const viewerSpace = await session.requestReferenceSpace('viewer')
const hitSource = await session.requestHitTestSource({ space: viewerSpace })

session.requestAnimationFrame(function onFrame(t, frame) {
  const hits = frame.getHitTestResults(hitSource)
  if (hits.length > 0) {
    const pose = hits[0].getPose(refSpace)
    placeReticle(pose.transform.matrix)
  }
  session.requestAnimationFrame(onFrame)
})
```

### Mesh reconstruction (LiDAR)
```swift
config.sceneReconstruction = .meshWithClassification
// ARMeshAnchor 매 frame 별 update
func session(_ session: ARSession, didAdd anchors: [ARAnchor]) {
  for case let mesh as ARMeshAnchor in anchors {
    addMeshToScene(mesh)
  }
}
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| iOS-only, 매 native UX | ARKit + RealityKit |
| Android-only | ARCore + Sceneform-EQR / Filament |
| Cross-platform iOS+Android | Unity AR Foundation |
| Web/no-install | WebXR (Chrome Android only currently) |
| High-fidelity / game | Unreal AR |
| Geo-anchored content | ARCore Geospatial / ARKit Location Anchors |
| Indoor mapping | ARKit RoomPlan / ARCore Streetscape |
| Multi-user shared session | Cloud Anchors (ARCore) / SharePlay (ARKit) |

**기본값**: 매 cross-platform 매 Unity AR Foundation, 매 native 매 ARKit/ARCore 직접.

## 🔗 Graph
- 부모: [[Computer Vision|Computer-Vision]]
- 변형: [[ARKit]] · [[ARCore]] · [[WebXR]]
- Adjacent: [[SLAM]] · [[OpenGL ES]] · [[Metal]] · [[Vulkan]] · [[Vision-Pro]]

## 🤖 LLM 활용
**언제**: 매 mobile AR feature 설계, 매 ARKit/ARCore 선택, 매 placement/occlusion/lighting 매 implementation.
**언제 X**: 매 desktop VR/AR (different platforms), 매 marker-based AR only (legacy — Vuforia 같은 different stack).

## ❌ 안티패턴
- **첫 frame 매 immediate placement**: 매 tracking 매 not-converged — 매 plane detection 매 wait.
- **매 anchor 매 world origin attach**: 매 drift 누적 — 매 surface anchor 매 use.
- **무한 occlusion 활성화 매 mid-tier device**: 매 30fps 이하 — 매 capability check.
- **Battery 무시**: 매 AR session 매 30 min 매 device thermal throttle — 매 idle pause.
- **Privacy 무시**: 매 camera + location 매 prompt + purpose string 필수 (App Store/Play reject).

## 🧪 검증 / 중복
- Verified (ARKit 7 docs, ARCore 1.45 docs, Unity AR Foundation 6).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — ARKit/ARCore/Unity/WebXR patterns + capabilities matrix |