ARKit

ARKit Framework : เครื่องมือในการสร้างแอป AR ด้วยเทคโนโลยีความจริงเสริม

เทคโนโลยีความจริงเสริม (Augmented Reality: AR) เป็นแนวคิดในการผสานโลกจริงเข้ากับวัตถุเสมือนแบบเรียลไทม์ โดยระบบจะใช้ข้อมูลจากกล้อง เซนเซอร์ตรวจจับการเคลื่อนไหว และอัลกอริทึมประมวลผลภาพ เพื่อคำนวณตำแหน่งและทิศทางของอุปกรณ์ จากนั้นจึงวางวัตถุดิจิทัลลงบนสภาพแวดล้อมจริงอย่างสอดคล้องเชิงมิติและแสงเงา เทคโนโลยีนี้ถูกนำไปใช้ในหลายบริบท เช่น การศึกษา การแพทย์ การออกแบบผลิตภัณฑ์ การตลาด และอุตสาหกรรมเกม

ระบบ Augmented Reality (AR) บนแพลตฟอร์มของ Apple ถูกออกแบบให้ทำงานผ่านความร่วมมือของสองเฟรมเวิร์กหลัก ได้แก่ ARKit และ RealityKit ซึ่งมีบทบาทแตกต่างกันแต่เสริมกันอย่างชัดเจน โดยสามารถทำความเข้าใจได้ว่า ARKit ทำหน้าที่ “เข้าใจโลกจริง” ส่วน RealityKit ทำหน้าที่ “สร้างโลกเสมือนให้ปรากฏในโลกจริง”

ARKit เป็นเฟรมเวิร์กที่รับผิดชอบด้านการรับรู้สภาพแวดล้อมและการเคลื่อนไหวของอุปกรณ์ โดยทำหน้าที่จัดการองค์ประกอบพื้นฐานที่ทำให้ระบบ AR ทำงานได้อย่างสมจริง ซึ่งประกอบด้วย

• World Tracking ซึ่งช่วยติดตามตำแหน่งและการเคลื่อนไหวของอุปกรณ์แบบเรียลไทม์ ทำให้วัตถุเสมือนสามารถคงตำแหน่งอยู่ในโลกจริงได้แม้ผู้ใช้จะเดินหรือหมุนอุปกรณ์

• Scene Understanding ที่ช่วยให้ระบบเข้าใจโครงสร้างของพื้นที่รอบตัวผู้ใช้ เช่น การประเมินระยะ ความลึก และรูปทรงของสิ่งแวดล้อม

• Plane Detection ซึ่งใช้ตรวจจับพื้นผิวสำคัญ เช่น พื้น โต๊ะ หรือผนัง เพื่อให้สามารถวางวัตถุเสมือนลงบนตำแหน่งที่สมเหตุสมผลได้

• Lighting Estimation ซึ่งวิเคราะห์สภาพแสงจริงในพื้นที่ เพื่อให้วัตถุเสมือนมีความสว่าง เงา และโทนสีที่สอดคล้องกับสิ่งแวดล้อม ทำให้ภาพรวมดูเป็นธรรมชาติและน่าเชื่อถือมากขึ้น

ในขณะที่ ARKit ทำหน้าที่รับรู้และวิเคราะห์โลกจริง RealityKit จะเข้ามารับช่วงต่อในการสร้างและจัดการวัตถุสามมิติภายในฉาก AR โดย RealityKit เป็น High-level 3D rendering & simulation framework ซึ่งช่วยจัดการการแสดงผลโมเดล 3D ระบบแสงและเงา ฟิสิกส์ของวัตถุ รวมถึงการวางวัตถุลงในตำแหน่งที่ ARKit ตรวจพบ นอกจากนี้ RealityKit ยังรองรับระบบแอนิเมชัน การโต้ตอบกับผู้ใช้ และการจัดการฉากโดยรวม ทำให้นักพัฒนาไม่จำเป็นต้องสร้างเอนจินกราฟิก (Graphic Engine) หรือระบบฟิสิกส์ขึ้นมาเอง

เมื่อทำงานร่วมกัน ARKit จะทำหน้าที่เป็น “ระบบรับรู้โลกจริง” ที่ให้ข้อมูลตำแหน่ง พื้นผิว และแสง ส่วน RealityKit จะเป็น “ระบบสร้างโลกเสมือน” ที่นำข้อมูลเหล่านั้นมาใช้เพื่อแสดงวัตถุสามมิติอย่างสมจริง ผลลัพธ์คือประสบการณ์ AR ที่ผู้ใช้รู้สึกว่าวัตถุเสมือนอยู่ในโลกจริงได้อย่างเป็นธรรมชาติ ทั้งในด้านตำแหน่ง การเคลื่อนไหว และสภาพแสง

โมเดล USDZ สำหรับใช้งานในโปรเจกต์ AR

ไฟล์ USDZ เป็นรูปแบบไฟล์ 3D ที่มีบทบาทสำคัญในการพัฒนาแอป AR บนแพลตฟอร์ม Apple โดยพัฒนาต่อยอดจากโครงสร้าง Universal Scene Description (USD) ซึ่งออกแบบมาเพื่ออธิบายฉากสามมิติได้อย่างครบถ้วน ไม่เพียงเก็บรูปทรงของโมเดล แต่ยังรวมวัสดุ พื้นผิว แสง และแอนิเมชันไว้ในไฟล์เดียว ทำให้สามารถนำไปใช้งานได้ทันทีโดยไม่ต้องจัดการไฟล์ประกอบเพิ่มเติม ข้อดีของ USDZ คือ ถูกออกแบบให้เหมาะกับการแสดงผลแบบเรียลไทม์บนอุปกรณ์ iOS ทำให้โหลดได้รวดเร็ว ใช้ทรัพยากรอย่างมีประสิทธิภาพ และแสดงผลได้ลื่นไหล ซึ่งเป็นคุณสมบัติจำเป็นสำหรับงาน AR ที่ต้องผสานภาพจากโลกจริงกับวัตถุเสมือนพร้อมกัน

นอกจากนี้ USDZ ยังเชื่อมต่อกับเครื่องมือใน ecosystem ของ Apple ได้โดยตรง ไม่ว่าจะเป็น RealityKit สำหรับการพัฒนาแอป Quick Look สำหรับพรีวิวโมเดลแบบโต้ตอบ หรือ Safari ที่สามารถเปิดโมเดลในโหมด AR จากเว็บไซต์ได้ทันที ความสามารถในการใช้งานแบบพร้อมใช้เช่นนี้ ทำให้ USDZ กลายเป็นมาตรฐานหลักสำหรับการสร้างและเผยแพร่เนื้อหา 3D และ AR บนระบบของ Apple ในปัจจุบัน

แหล่งดาวน์โหลดไฟล์ USDZ มีทั้งจากผู้พัฒนาแพลตฟอร์มเองและจากชุมชนผู้สร้างโมเดลสามมิติ ซึ่งช่วยให้นักพัฒนาสามารถนำไปทดลองหรือใช้ในโปรเจกต์ได้ทันทีโดยไม่ต้องเริ่มสร้างโมเดลใหม่ตั้งแต่ต้น

แหล่งแรกที่ควรเริ่มต้น คือ คลังตัวอย่างจาก Apple ซึ่งจัดเตรียมโมเดล USDZ สำหรับสาธิตการใช้งาน AR โดยเฉพาะ โมเดลเหล่านี้มักถูกออกแบบให้มีขนาดเหมาะสม โหลดได้รวดเร็ว และแสดงผลได้ถูกต้องบนอุปกรณ์ iOS จึงเหมาะสำหรับใช้ทดลองในห้องเรียน งานสาธิต หรือโปรเจกต์เริ่มต้น นอกจากนั้น ยังมีเว็บไซต์โมเดลสามมิติทั่วไปที่เปิดให้ดาวน์โหลดทั้งแบบฟรีและเชิงพาณิชย์ เช่น แหล่งชุมชนสำหรับนักออกแบบ 3D ซึ่งมักมีโมเดลจำนวนมากในรูปแบบไฟล์มาตรฐานอย่าง OBJ, FBX หรือ GLTF แม้ไฟล์เหล่านี้จะไม่ใช่ USDZ โดยตรง แต่สามารถนำมาแปลงเป็น USDZ ได้ด้วยเครื่องมือของ Apple หรือซอฟต์แวร์สร้างโมเดล ทำให้ผู้พัฒนาไม่ถูกจำกัดเฉพาะไฟล์ที่สร้างขึ้นสำหรับ iOS เท่านั้น

การสร้างโมเดลด้วยโปรแกรม Reality Composer

การสร้างโมเดลสำหรับใช้งานใน AR ไม่จำเป็นต้องเริ่มจากซอฟต์แวร์สามมิติระดับมืออาชีพเสมอไป ผู้พัฒนาสามารถใช้ iPhone หรือ iPad ร่วมกับแอป Reality Composer เพื่อสร้างฉากและวัตถุสำหรับ AR ได้โดยตรง เครื่องมือนี้ถูกออกแบบให้ใช้งานแบบภาพ (visual workflow) จึงเหมาะทั้งสำหรับผู้เริ่มต้น นักศึกษา และผู้ที่ต้องการสร้างต้นแบบอย่างรวดเร็ว

Reality Composer ช่วยให้ผู้ใช้สามารถนำเข้าโมเดล 3 มิติจากไฟล์ที่มีอยู่แล้ว หรือเลือกใช้วัตถุสำเร็จรูป จากนั้นจัดวางตำแหน่ง ปรับขนาด หมุน และกำหนดพฤติกรรมของวัตถุในฉากได้ผ่านการลากวางบนหน้าจอสัมผัส นอกจากนี้ยังสามารถกำหนด interaction พื้นฐาน เช่น การแตะเพื่อให้วัตถุเคลื่อนที่ หมุน หรือเปลี่ยนสถานะ ซึ่งช่วยให้มือใหม่เข้าใจแนวคิดของ AR scene และ event-driven interaction ได้โดยไม่ต้องเขียนโค้ด

ข้อได้เปรียบสำคัญของการใช้ iPhone หรือ iPad คือ สามารถทดลองฉาก AR ได้ทันทีผ่านกล้องของอุปกรณ์ ผู้ใช้สามารถดูว่าวัตถุมีขนาดเหมาะสมหรือไม่ แสงสอดคล้องกับสภาพแวดล้อมจริงเพียงใด และตำแหน่งของโมเดลสัมพันธ์กับพื้นที่อย่างถูกต้องหรือไม่ การทดสอบแบบเรียลไทม์เช่นนี้ช่วยลดขั้นตอนการลองผิดลองถูกเมื่อพัฒนาแอปจริงใน Xcode โดยเมื่อออกแบบฉากเสร็จแล้ว Reality Composer สามารถบันทึกเป็นไฟล์ที่ใช้งานร่วมกับ Xcode ได้ทันที ไม่ว่าจะเป็นไฟล์สำหรับใช้ใน RealityKit หรือไฟล์ USDZ สำหรับแสดงผลใน Quick Look ทำให้เครื่องมือนี้ทำหน้าที่เป็นสะพานเชื่อมระหว่างการออกแบบฉากสามมิติและการพัฒนาแอป AR อย่างแท้จริง

การพัฒนา AR Application แรกของคุณ

การสาธิตการพัฒนาแอป ARDemo มีจุดมุ่งหมายเพื่อให้ผู้อ่านเข้าใจโครงสร้างพื้นฐานของการสร้างแอป Augmented Reality บน iOS โดยเน้นการแสดงวัตถุสามมิติในสภาพแวดล้อมจริงอย่างเรียบง่าย ก่อนจะต่อยอดไปสู่การพัฒนาแอปที่ซับซ้อนขึ้นในอนาคต

ขั้นตอนเริ่มต้นคือการเตรียมทรัพยากรของโปรเจกต์ โดยเฉพาะไฟล์โมเดลสามมิติในรูปแบบ USDZ ซึ่งเป็นรูปแบบที่สามารถใช้งานร่วมกับ RealityKit และ ARKit ได้โดยตรง โดยคุณสามารถดาวน์โหลดโมเดลที่ต้องการใช้ในโปรเจกต์นี้ได้จาก https://developer.apple.com/augmented-reality/quick-look/

ในการสาธิตนี้จะใช้ 3D Model ชื่อ Biplane

ให้คุณสร้างไฟล์รูปภาพของโมเดลนี้โดยใช้ Screen Capture และตั้งชื่อว่า Biplane.jpg หรือ Biplane.png และในขั้นตอนถัดมาให้เปิด Xcode และสร้างโปรเจคก์ใหม่ชื่อ ARDemo

นำไฟล์ 3D Model ที่ดาวน์โหลดเข้ามาในโปรเจกต์

นำไฟล์รูปภาพของ 3D Model มาเก็บไว้ในส่วนของ Assets ของโปรเจกต์

ก่อนเริ่มพัฒนาแอป ARDemo สิ่งสำคัญคือการวางโครงสร้างโปรเจกต์ให้ชัดเจนตั้งแต่ต้น เพื่อให้ผู้พัฒนาสามารถแยกหน้าที่ของส่วนต่าง ๆ ได้อย่างเป็นระบบ ในตัวอย่างนี้ใช้แนวคิดสถาปัตยกรรมแบบ MVVM ซึ่งช่วยแยก “ข้อมูล”, “ตรรกะการทำงาน” และ “ส่วนแสดงผล” ออกจากกันอย่างชัดเจน ทำให้โค้ดอ่านง่าย ดูแลรักษาได้สะดวก และต่อยอดสู่แอปที่ซับซ้อนขึ้นได้ง่าย เมื่อกำหนดแนวคิดนี้แล้ว จึงเริ่มสร้างไฟล์หลักของระบบ ได้แก่ Model, ViewModel และ View ที่เกี่ยวข้องกับ AR

// ARModel.swift 
import Foundation

struct ARModel: Identifiable {
    let id = UUID()
    let name: String
    let thumbnail: String
}

ไฟล์แรกคือ ARModel.swift ซึ่งทำหน้าที่เป็นชั้นข้อมูลของแอป ใช้เก็บรายละเอียดของโมเดลสามมิติที่ต้องการแสดงใน AR ภายในไฟล์นี้กำหนดโครงสร้างข้อมูลที่มีรหัสประจำตัว ชื่อไฟล์โมเดล และชื่อรูปภาพตัวอย่าง โครงสร้างลักษณะนี้ช่วยให้แอปรู้ว่าโมเดลแต่ละชิ้นต้องโหลดไฟล์ใดและใช้รูปใดแสดงในหน้าอินเทอร์เฟซ แนวคิดสำคัญของไฟล์นี้คือเก็บเฉพาะข้อมูล ไม่ควรมีตรรกะการควบคุม UI หรือการทำงานของ AR เพื่อให้ Model มีความเรียบง่ายและสามารถนำไปใช้ซ้ำได้

// ARViewModel.swift
import Foundation
import SwiftUI
import Combine

class ARViewModel: ObservableObject {

    @Published var models: [ARModel] = [ARModel(name: "toy_biplane_realistic", thumbnail: "biplane")]
    @Published var selectedModel: ARModel?
    @Published var isARPresented: Bool = false

    // MARK: - Intent
    func selectModel(_ model: ARModel) {
        selectedModel = model
    }

    func openAR() {
        guard selectedModel != nil else { return }
        isARPresented = true
    }

    func closeAR() {
        isARPresented = false
    }
}

ถัดมาคือ ARViewModel.swift ซึ่งเป็นหัวใจของการควบคุมสถานะของแอป ไฟล์นี้ทำหน้าที่เป็นตัวกลางระหว่างข้อมูลและหน้าจอ โดยเก็บรายการโมเดล และเก็บสถานะว่ากำลังแสดง AR อยู่หรือไม่

• การ import Combine เป็นการนำเข้าเฟรมเวิร์กที่รองรับแนวคิด reactive programming และอยู่เบื้องหลังการทำงานของ @Published ซึ่งช่วยให้เมื่อข้อมูลเปลี่ยน View จะอัปเดตอัตโนมัติ

• class ARViewModel: ObservableObject จะถูกสังเกตการเปลี่ยนแปลงได้โดย SwiftUI เมื่อใดก็ตามที่ข้อมูลภายในเปลี่ยน SwiftUI จะรีเฟรช View ที่ผูกกับ ViewModel นี้ทันที กลไกนี้ทำให้ไม่ต้องเขียนโค้ดสั่งอัปเดต UI เอง

• @Published var models: [ARModel] = [ARModel(name: "toy_biplane_realistic", thumbnail: "biplane")] เป็นอาร์เรย์ของโมเดลสามมิติที่จะใช้แสดงในแอป

• ตัวแปร @Published var selectedModel: ARModel? ใช้เก็บโมเดลที่ถูกเลือกให้แสดงผล

• ตัวแปร @Published var isARPresented: Bool = false ใช้ควบคุมสถานะการแสดงหน้าจอ AR

• func selectModel(_ model: ARModel) ทำหน้าที่รับโมเดลที่ผู้ใช้เลือก แล้วกำหนดค่าให้ selectedModel การแยกฟังก์ชันนี้ออกมาช่วยให้ View ไม่ต้องแก้ไข state โดยตรง แต่เรียกผ่าน ViewModel ตามหลัก MVVM

• func openAR() ใช้เปิดโหมด AR ซึ่งเป็นการตรวจสอบเงื่อนไขก่อนทำงาน หากยังไม่มีโมเดลที่เลือก ฟังก์ชันจะหยุดทันที วิธีนี้ช่วยป้องกันไม่ให้แอปพยายามเปิด AR โดยไม่มีข้อมูลโมเดล ซึ่งอาจทำให้เกิดข้อผิดพลาดได้ เมื่อผ่านเงื่อนไขแล้วจึงตั้งค่า isARPresented = true เพื่อสั่งให้ View เปิดหน้าจอ AR

• func closeAR() ทำหน้าที่ตรงข้ามกับ openAR คือกำหนดค่า isARPresented เป็น false เพื่อปิดหน้าจอ AR การให้ ViewModel เป็นผู้ควบคุมการเปิด-ปิดนี้ช่วยให้โค้ดมีศูนย์กลางการควบคุมสถานะเดียว ลดความซ้ำซ้อน และทำให้โครงสร้างแอปชัดเจน

โดยสรุป ไฟล์ ARViewModel.swift เป็นตัวกำหนด “สมอง” ของแอป ARDemo ทำหน้าที่เก็บข้อมูลโมเดลที่มีอยู่ และ จัดการว่าโมเดลใดถูกเลือก และควบคุมว่าควรเปิดหรือปิดหน้าจอ AR เมื่อใด กลไกของ ObservableObject และ @Published ทำให้ข้อมูลเหล่านี้เชื่อมกับ UI แบบอัตโนมัติ ซึ่งเป็นหัวใจของการพัฒนาแอป SwiftUI

// SheetView.swift
import SwiftUI

struct SheetView: View {

    @ObservedObject var vm: ARViewModel

    var body: some View {
        ZStack(alignment: .topTrailing) {
            if let model = vm.selectedModel {
                ARViewContainer(modelName: model.name)
                    .ignoresSafeArea()
            }

            Button {
                vm.closeAR()
            } label: {
                Image(systemName: "xmark.circle.fill")
                    .font(.largeTitle)
                    .padding(24)
            }
        }
    }
}

ไฟล์ SheetView.swift ทำหน้าที่เป็นหน้าจอสำหรับแสดงผล AR แบบเต็มจอ โดยเป็น View ที่เชื่อมต่อกับ ViewModel และเรียกใช้ ARViewContainer เพื่อแสดงฉาก AR โดยภายใน view นี้ จะตรวจสอบว่ามีโมเดลที่ถูกเลือกแล้วหรือไม่ หากมีจึงเรียกใช้ ARViewContainer เพื่อแสดงฉาก AR และมีปุ่มสำหรับปิดหน้าจอเพื่อกลับสู่หน้าหลัก การออกแบบลักษณะนี้ช่วยให้การควบคุมการเปิด-ปิด AR อยู่ใน ViewModel อย่างถูกต้อง

@ObservedObject var vm: ARViewModel ใน SheetView จะรับ ViewModel จากภายนอก และต้องการติดตามการเปลี่ยนแปลงของข้อมูลใน ViewModel หากค่าใน ViewModel เปลี่ยน เช่น selectedModel หรือสถานะการเปิด AR เปลี่ยน SwiftUI จะรีเฟรชหน้าจออัตโนมัติ

// ARViewContainer.swift
import SwiftUI
import RealityKit
import ARKit

struct ARViewContainer: UIViewRepresentable {

    let modelName: String

    func makeUIView(context: Context) -> ARView {
        let arView = ARView(frame: .zero)
        let config = ARWorldTrackingConfiguration()
        config.planeDetection = [.horizontal, .vertical]
        config.environmentTexturing = .automatic

        arView.session.run(config)
        return arView
    }

    func updateUIView(_ uiView: ARView, context: Context) {
        uiView.scene.anchors.removeAll()
        let anchor = AnchorEntity(plane: .any)
        guard let model = try? Entity.loadModel(named: modelName)
        else { return }

        anchor.addChild(model)
        uiView.scene.addAnchor(anchor)
    }
}

ไฟล์ ARViewContainer.swift เป็นส่วนสำคัญที่สุดของระบบ AR ในแอป เนื่องจากทำหน้าที่เชื่อม SwiftUI เข้ากับ ARKit และ RealityKit โดยตรง กล่าวคือเป็นตัวที่สร้าง AR session ควบคุมกล้อง วิเคราะห์สภาพแวดล้อม และแสดงโมเดลสามมิติในโลกจริง โครงสร้างของไฟล์นี้ใช้แนวคิด UIViewRepresentable เพื่อให้สามารถนำ ARView ซึ่งเป็น UIKit view มาใช้งานภายใน SwiftUI ได้

• RealityKit ใช้สำหรับจัดการ scene 3D โมเดล วัสดุ และ anchor

• ARKit ใช้สำหรับการติดตามตำแหน่งอุปกรณ์ การวิเคราะห์ภาพจากกล้อง และการตรวจจับพื้นผิวจริง

• ตัวแปร let modelName: String ใช้รับชื่อไฟล์โมเดลจาก View ภายนอก เช่น SheetView แล้วส่งต่อไปใช้โหลดไฟล์ USDZ ในขั้นตอนแสดงผล

• func makeUIView(context: Context) -> ARView เป็นฟังก์ชันที่ถูกเรียกครั้งเดียวเมื่อ view ถูกสร้างขึ้น ภายในประกอบด้วย

  • ARView ที่ถูกสร้างขึ้นมาเพื่อใช้แสดงฉาก AR โดยกำหนด frame เป็นศูนย์เพราะ SwiftUI จะเป็นผู้จัด layout ให้ภายหลัง

  • config ใช้ในการกำหนดประเภทของ AR session โดย ARWorldTrackingConfiguration คือการกำหนดให้ติดตามตำแหน่งอุปกรณ์ในโลกจริง

  • config.planeDetection = [.horizontal, .vertical] คือการเปิดให้ระบบตรวจจับพื้นผิวทั้งแนวนอน เช่น โต๊ะ พื้น และแนวตั้ง เช่น ผนัง เพื่อให้สามารถวางโมเดลในตำแหน่งที่เหมาะสมได้

  • config.environmentTexturing = .automatic คือ การเปิดการประเมินสภาพแสงจริง เพื่อให้วัสดุของโมเดลสามมิติสอดคล้องกับแสงในสภาพแวดล้อม ทำให้ดูสมจริงขึ้น

  • เมื่อกำหนดค่าเสร็จแล้วจึงเรียก arView.session.run(config) เพื่อเริ่ม AR session ทำให้กล้องเริ่มทำงานและระบบเริ่มวิเคราะห์สภาพแวดล้อมจริง ก่อนจะส่ง ARView กลับไปให้ SwiftUI แสดงบนหน้าจอ

• func updateUIView(_ uiView: ARView, context: Context) เป็นฟังก์ชันที่ถูกเรียกเมื่อ SwiftUI ตรวจพบว่าข้อมูลที่ส่งเข้ามาเปลี่ยน เช่น modelName เปลี่ยน หรือ view ถูกรีเฟรช หน้าที่หลักคืออัปเดต scene ของ ARView

  • uiView.scene.anchors.removeAll() ใช้ลบ anchor เดิมทั้งหมดออกจาก scene เพื่อป้องกันไม่ให้โมเดลซ้อนกันหลายตัวเมื่อ view ถูกอัปเดต

  • let anchor = AnchorEntity(plane: .any) สร้าง anchor ใหม่ที่สามารถยึดกับพื้นผิวใดก็ได้ที่ ARKit ตรวจพบ ไม่ว่าจะเป็นพื้น โต๊ะ หรือผนัง

  • guard let model = try? Entity.loadModel(named: modelName) คำสั่งนี้พยายามโหลดโมเดล USDZ จาก bundle ของแอป โดยใช้ชื่อไฟล์ที่ส่งเข้ามา หากโหลดไม่สำเร็จจะออกจากฟังก์ชันทันทีเพื่อป้องกันการเกิดข้อผิดพลาดใน scene

  • เมื่อโหลดโมเดลได้แล้ว จะเพิ่มโมเดลเข้า anchor ด้วยคำสั่ง anchor.addChild(model) และนำ anchor เข้าไปใน scene ด้วยคำสั่ง uiView.scene.addAnchor(anchor) เมื่อถึงขั้นตอนนี้ โมเดลสามมิติจะถูกวางลงในโลกจริงผ่านกล้องของอุปกรณ์ และจะคงตำแหน่งอยู่กับพื้นผิวที่ตรวจพบแม้ผู้ใช้จะเคลื่อนที่

โดยสรุป ARViewContainer ทำหน้าที่เป็นสะพานเชื่อมระหว่าง SwiftUI กับระบบ AR ทั้งหมด ตั้งแต่การสร้าง AR session การตั้งค่าการตรวจจับพื้นผิว การโหลดโมเดล และการวางวัตถุในโลกจริง

การทดสอบผลการทำงาน

เมื่อพัฒนาแอป AR เสร็จแล้ว ขั้นตอนสำคัญถัดไปคือการทดสอบบนอุปกรณ์จริง เนื่องจากแอปที่ใช้ ARKit ไม่สามารถทดสอบความสามารถของกล้องและการตรวจจับสภาพแวดล้อมได้อย่างสมบูรณ์บน Simulator การทดสอบบน iPhone หรือ iPad จริงจึงเป็นขั้นตอนจำเป็นในการตรวจสอบว่าระบบติดตามตำแหน่ง การตรวจจับพื้นผิว และการแสดงโมเดลสามมิติทำงานได้ถูกต้อง

ก่อนจะติดตั้งแอปลงอุปกรณ์ ผู้พัฒนาต้องมี Apple Developer Account เพื่อใช้สำหรับการลงนามแอป (code signing) และอนุญาตให้อุปกรณ์รันแอปที่พัฒนาขึ้นเองได้ ขั้นตอนเริ่มต้นคือเชื่อมต่ออุปกรณ์เข้ากับเครื่อง Mac แล้วเลือก target ของแอปใน Xcode จากนั้นไปที่แท็บ Signing & Capabilities และเปิดตัวเลือก Automatically manage signing เพื่อให้ Xcode สร้าง provisioning profile และ certificate ให้อัตโนมัติ ผู้พัฒนาต้องเลือกทีมพัฒนา (Team) ที่ผูกกับ Apple ID ของตนเอง เมื่อการตั้งค่าสมบูรณ์ แอปจะสามารถ build และติดตั้งลงอุปกรณ์ได้โดยตรง ซึ่งเป็นขั้นตอนพื้นฐานของการทดสอบแอปบน iOS จริง

สำหรับแอป AR ยังมีข้อกำหนดสำคัญอีกประการหนึ่ง คือการขออนุญาตใช้กล้องจากผู้ใช้ เนื่องจาก ARKit ต้องเข้าถึงกล้องเพื่อวิเคราะห์สภาพแวดล้อม หากไม่ได้ระบุสิทธิ์นี้ แอปจะไม่สามารถเปิด AR session ได้และอาจปิดตัวทันทีเมื่อรัน วิธีตั้งค่าคือเพิ่มข้อความอธิบายการใช้งานกล้องในไฟล์ Info.plist โดยกำหนดคีย์ Privacy – Camera Usage Description พร้อมระบุเหตุผลที่แอปต้องใช้กล้อง เช่น เพื่อแสดงเนื้อหาแบบ Augmented Reality ข้อความนี้จะถูกแสดงในหน้าต่างขออนุญาตครั้งแรกที่ผู้ใช้เปิดแอป

เมื่อแอปรันบนอุปกรณ์จริง iOS จะตรวจพบว่ามีการเรียกใช้กล้องและจะแสดงกล่องข้อความถามผู้ใช้ว่าต้องการอนุญาตหรือไม่ หากผู้ใช้อนุญาต ระบบจะเปิด AR session และเริ่มแสดงภาพจากกล้องพร้อมวัตถุสามมิติ แต่หากผู้ใช้ปฏิเสธ แอปจะไม่สามารถเข้าถึงกล้องได้ จึงควรออกแบบข้อความอธิบายให้ชัดเจนและเข้าใจง่าย เพื่อให้ผู้ใช้มั่นใจในความจำเป็นของการใช้งานกล้อง

แนวทางในการจัดกิจกรรมการเรียนรู้

• ดาวน์โหลดเอกสารประกอบการทำกิจกรรมในห้องปฏิบัติการ ที่นี่

• ดาวน์โหลดสไลด์สำหรับใช้ประกอบการสอน ที่นี่

​รายละเอียดเพื่อการอ้างอิง ผู้เขียน ธิติ ธีระเธียร วันที่เผยแพร่ วันที่ 20 กุมภาพันธ์ 2569 วันที่ปรุงปรุงล่าสุด วันที่ 20 กุมภาพันธ์ 2569 เข้าถึงได้จาก https://ajthiti.gitbook.io/develop-in-swift/framework-for-app-development/arkit เงื่อนใขในการใช้งาน This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License.