ARKit ile Artırılmış Gerçeklik: Sıfırdan İleri Seviye

1// AR Session: AR deneyimini yöneten ana objedir
2let arSession = ARSession()
3 
4// AR Configuration: Hangi özelliklerin kullanılacağını belirler
5let config = ARWorldTrackingConfiguration()
6 
7// AR Anchor: Sanal içeriğin gerçek dünyadaki konumu
8let anchor = ARAnchor(name: "myObject", transform: matrix)
9 
10// AR Frame: Kamera görüntüsü + tracking bilgisi
11let frame = arSession.currentFrame

1import ARKit
2import UIKit
3 
4class ARViewController: UIViewController {
5    
6    @IBOutlet var arView: ARSCNView!
7    
8    override func viewDidLoad() {
9        super.viewDidLoad()
10        
11        arView.delegate = self
12        arView.session.delegate = self
13        
14        // Debug options
15        arView.debugOptions = [
16            .showFeaturePoints,
17            .showWorldOrigin,
18            .showBoundingBoxes
19        ]
20        
21        arView.autoenablesDefaultLighting = true
22    }
23    
24    override func viewWillAppear(_ animated: Bool) {
25        super.viewWillAppear(animated)
26        
27        let config = ARWorldTrackingConfiguration()
28        config.planeDetection = [.horizontal, .vertical]
29        config.environmentTexturing = .automatic
30        
31        // LiDAR varsa
32        if ARWorldTrackingConfiguration.supportsSceneReconstruction(.mesh) {
33            config.sceneReconstruction = .mesh
34        }
35        
36        arView.session.run(config)
37    }
38}

1// World Tracking - En kapsamlı, 6DoF
2let worldConfig = ARWorldTrackingConfiguration()
3 
4// Image Tracking - Sadece resim takibi
5let imageConfig = ARImageTrackingConfiguration()
6imageConfig.trackingImages = referenceImages
7imageConfig.maximumNumberOfTrackedImages = 4
8 
9// Face Tracking - TrueDepth kamera gerekli
10let faceConfig = ARFaceTrackingConfiguration()
11faceConfig.maximumNumberOfTrackedFaces = 1
12 
13// Body Tracking - A12+ chip gerekli
14let bodyConfig = ARBodyTrackingConfiguration()

1extension ARViewController: ARSCNViewDelegate {
2    
3    func renderer(_ renderer: SCNSceneRenderer, didAdd node: SCNNode, for anchor: ARAnchor) {
4        guard let planeAnchor = anchor as? ARPlaneAnchor else { return }
5        
6        let planeNode = createPlaneNode(for: planeAnchor)
7        node.addChildNode(planeNode)
8        
9        // Haptic feedback
10        DispatchQueue.main.async {
11            let generator = UIImpactFeedbackGenerator(style: .light)
12            generator.impactOccurred()
13        }
14    }
15    
16    private func createPlaneNode(for planeAnchor: ARPlaneAnchor) -> SCNNode {
17        let extent = planeAnchor.planeExtent
18        
19        let plane = SCNPlane(
20            width: CGFloat(extent.width),
21            height: CGFloat(extent.height)
22        )
23        
24        let material = SCNMaterial()
25        material.diffuse.contents = UIColor.systemBlue.withAlphaComponent(0.3)
26        plane.materials = [material]
27        
28        let planeNode = SCNNode(geometry: plane)
29        planeNode.eulerAngles.x = -.pi / 2
30        
31        return planeNode
32    }
33}

1override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
2    guard let touch = touches.first else { return }
3    let location = touch.location(in: arView)
4    
5    if let query = arView.raycastQuery(
6        from: location,
7        allowing: .estimatedPlane,
8        alignment: .horizontal
9    ) {
10        let results = arView.session.raycast(query)
11        
12        if let firstResult = results.first {
13            placeObject(at: firstResult)
14        }
15    }
16}
17 
18private func placeObject(at raycastResult: ARRaycastResult) {
19    guard let modelScene = SCNScene(named: "art.scnassets/chair.scn"),
20          let modelNode = modelScene.rootNode.childNode(
21              withName: "chair",
22              recursively: true
23          )?.clone() else {
24        return
25    }
26    
27    let transform = raycastResult.worldTransform
28    modelNode.position = SCNVector3(
29        transform.columns.3.x,
30        transform.columns.3.y,
31        transform.columns.3.z
32    )
33    
34    modelNode.scale = SCNVector3(0.01, 0.01, 0.01)
35    
36    let anchor = ARAnchor(name: "furniture", transform: transform)
37    arView.session.add(anchor: anchor)
38    
39    arView.scene.rootNode.addChildNode(modelNode)
40}

1class ImageTrackingViewController: UIViewController {
2    
3    override func viewWillAppear(_ animated: Bool) {
4        super.viewWillAppear(animated)
5        
6        guard let referenceImages = ARReferenceImage.referenceImages(
7            inGroupNamed: "AR Resources",
8            bundle: nil
9        ) else {
10            fatalError("Reference images bulunamadı!")
11        }
12        
13        let config = ARImageTrackingConfiguration()
14        config.trackingImages = referenceImages
15        config.maximumNumberOfTrackedImages = 4
16        
17        arView.session.run(config)
18    }
19}
20 
21extension ImageTrackingViewController: ARSCNViewDelegate {
22    
23    func renderer(_ renderer: SCNSceneRenderer, nodeFor anchor: ARAnchor) -> SCNNode? {
24        guard let imageAnchor = anchor as? ARImageAnchor else { return nil }
25        
26        let referenceImage = imageAnchor.referenceImage
27        let imageName = referenceImage.name ?? "unknown"
28        
29        print("Tespit edildi: \(imageName)")
30        
31        // Resmin üzerine içerik ekle
32        let plane = SCNPlane(
33            width: referenceImage.physicalSize.width,
34            height: referenceImage.physicalSize.height
35        )
36        
37        plane.firstMaterial?.diffuse.contents = UIColor.green.withAlphaComponent(0.5)
38        
39        let planeNode = SCNNode(geometry: plane)
40        planeNode.eulerAngles.x = -.pi / 2
41        
42        return planeNode
43    }
44}

1class FaceTrackingViewController: UIViewController {
2    
3    override func viewWillAppear(_ animated: Bool) {
4        super.viewWillAppear(animated)
5        
6        guard ARFaceTrackingConfiguration.isSupported else {
7            showAlert("Face tracking bu cihazda desteklenmiyor")
8            return
9        }
10        
11        let config = ARFaceTrackingConfiguration()
12        config.maximumNumberOfTrackedFaces = 1
13        
14        arView.session.run(config)
15    }
16}
17 
18extension FaceTrackingViewController: ARSCNViewDelegate {
19    
20    func renderer(_ renderer: SCNSceneRenderer, didUpdate node: SCNNode, for anchor: ARAnchor) {
21        guard let faceAnchor = anchor as? ARFaceAnchor else { return }
22        
23        let blendShapes = faceAnchor.blendShapes
24        
25        // Göz kırpma tespiti
26        if let eyeBlinkLeft = blendShapes[.eyeBlinkLeft]?.floatValue,
27           let eyeBlinkRight = blendShapes[.eyeBlinkRight]?.floatValue {
28            if eyeBlinkLeft > 0.5 && eyeBlinkRight > 0.5 {
29                // İki göz de kapalı!
30            }
31        }
32        
33        // Gülümseme tespiti
34        if let smileLeft = blendShapes[.mouthSmileLeft]?.floatValue,
35           let smileRight = blendShapes[.mouthSmileRight]?.floatValue {
36            let smileIntensity = (smileLeft + smileRight) / 2
37            // Gülümseme efekti uygula
38        }
39    }
40}

1class LiDARViewController: UIViewController {
2    
3    override func viewWillAppear(_ animated: Bool) {
4        super.viewWillAppear(animated)
5        
6        let config = ARWorldTrackingConfiguration()
7        
8        if ARWorldTrackingConfiguration.supportsSceneReconstruction(.mesh) {
9            config.sceneReconstruction = .mesh
10            arView.debugOptions.insert(.showSceneUnderstanding)
11        }
12        
13        // Person occlusion
14        if ARWorldTrackingConfiguration.supportsFrameSemantics(.personSegmentationWithDepth) {
15            config.frameSemantics.insert(.personSegmentationWithDepth)
16        }
17        
18        arView.session.run(config)
19    }
20}

1import RealityKit
2import ARKit
3 
4class RealityKitViewController: UIViewController {
5    
6    @IBOutlet var arView: ARView!
7    
8    override func viewDidLoad() {
9        super.viewDidLoad()
10        
11        let config = ARWorldTrackingConfiguration()
12        config.planeDetection = [.horizontal]
13        arView.session.run(config)
14        
15        // Coaching overlay
16        let coachingOverlay = ARCoachingOverlayView()
17        coachingOverlay.session = arView.session
18        coachingOverlay.goal = .horizontalPlane
19        arView.addSubview(coachingOverlay)
20        
21        let tapGesture = UITapGestureRecognizer(
22            target: self,
23            action: #selector(handleTap)
24        )
25        arView.addGestureRecognizer(tapGesture)
26    }
27    
28    @objc func handleTap(_ gesture: UITapGestureRecognizer) {
29        let location = gesture.location(in: arView)
30        
31        if let result = arView.raycast(
32            from: location,
33            allowing: .estimatedPlane,
34            alignment: .horizontal
35        ).first {
36            let anchor = AnchorEntity(world: result.worldTransform)
37            
38            Task {
39                do {
40                    let model = try await ModelEntity.loadModel(named: "toy_robot")
41                    model.generateCollisionShapes(recursive: true)
42                    
43                    anchor.addChild(model)
44                    arView.scene.addAnchor(anchor)
45                    
46                    // Gesture'ları ekle
47                    arView.installGestures([.translation, .rotation, .scale], for: model)
48                } catch {
49                    print("Model yüklenemedi: \(error)")
50                }
51            }
52        }
53    }
54}

1// Thermal state kontrol
2if ProcessInfo.processInfo.thermalState == .serious {
3    arView.renderOptions = [.disableMotionBlur, .disableDepthOfField]
4    arView.contentScaleFactor = 1.0
5}
6 
7// Plane detection'ı kapat
8func stopPlaneDetection() {
9    guard let config = arView.session.configuration as? ARWorldTrackingConfiguration else { return }
10    config.planeDetection = []
11    arView.session.run(config)
12}
13 
14// LOD (Level of Detail)
15let distance = simd_distance(cameraPosition, objectPosition)
16if distance > 5.0 {
17    node.geometry = lowPolyModel
18} else {
19    node.geometry = highPolyModel
20}

1import SwiftUI
2import RealityKit
3 
4struct ARFurnitureView: View {
5    @StateObject private var viewModel = ARFurnitureViewModel()
6    
7    var body: some View {
8        ZStack {
9            ARViewContainer(viewModel: viewModel)
10                .edgesIgnoringSafeArea(.all)
11            
12            VStack {
13                Spacer()
14                
15                ScrollView(.horizontal) {
16                    HStack(spacing: 16) {
17                        ForEach(viewModel.furnitureItems) { item in
18                            FurnitureButton(item: item) {
19                                viewModel.selectFurniture(item)
20                            }
21                        }
22                    }
23                    .padding()
24                }
25                .background(.ultraThinMaterial)
26            }
27        }
28    }
29}
30 
31@MainActor
32class ARFurnitureViewModel: ObservableObject {
33    @Published var selectedFurniture: FurnitureItem?
34    
35    let furnitureItems = [
36        FurnitureItem(id: "chair", name: "Sandalye", modelName: "chair.usdz", price: 299),
37        FurnitureItem(id: "table", name: "Masa", modelName: "table.usdz", price: 599),
38        FurnitureItem(id: "sofa", name: "Kanepe", modelName: "sofa.usdz", price: 1299),
39    ]
40    
41    func selectFurniture(_ item: FurnitureItem) {
42        selectedFurniture = item
43        UIImpactFeedbackGenerator(style: .medium).impactOccurred()
44    }
45}