Introducere în construirea de experiențe augmentate de realitate cu RealityKit

Realitatea extinsă (AR) suprapune conţinutul digital în lumea fizică, creând experienţe interactive care îmbină realitatea cu obiectele virtuale. Apple

Pregătirea proiectului și cerințele

Pentru a dezvolta aplicații AR cu RealityKit, aveți nevoie de Xcode 13 sau mai târziu, un dispozitiv iOS fizic cu un cip A9 sau mai nou (iPhone SE, 6s, și mai târziu; iPad-uri 5 gen și mai târziu), și un cont de Apple Developer pentru testare. Simulator iOS nu suportă camere sau senzori de date, astfel încât testarea real-dispozitiv este esențială.

Creați un nou proiect Xcode și selectați App de realitate extinsă[] șablon. Alegeți SwiftUI sau UIKit în funcție de preferințele dumneavoastră

Alternativ, puteți adăuga manual RealityKit la un proiect existent prin importul cadrului:

import RealityKit
import ARKit

Asiguraţi-vă că NSCameraDescriereUtilizare] este stabilită în ]

Pentru mai multe detalii, a se vedea Apple

Înțelegerea sistemului de entitate-component

RealityKit folosește o arhitectură Componentă de entitate, care este fundamentală pentru construirea scenelor. Un container este un recipient care deține componente. Componentele definesc comportamentul, aspectul, fizica și alte proprietăți ale entității. De exemplu, o definește o plasă 3D, o manipulează poziția/rotația/scala și o permite simularea fizicii.

Această abordare modulară face ușor de compus obiecte complexe. Creați entități, atașați componente și aranjați-le într-o ierarhie. Rădăcina scenei este o (de obicei o , care leagă conținutul virtual de o locație din lumea reală detectată de ARKit.

Crearea unui conţinut ancoră şi adăugarea

Cea mai comună ancoră este o ancoră plană, care ataşează conţinutul pe suprafeţe orizontale sau verticale. Aici se pune un model 3D pe orice plan recunoscut:

// Load a USDZ model
guard let model = try? ModelEntity.load(named: "robot") else { return }

// Create an anchor on any horizontal plane
let anchor = AnchorEntity(plane: .horizontal, classification: .any, minimumBounds: [0.2, 0.2])

// Attach the model to the anchor
anchor.addChild(model)

// Add the anchor to the ARView’s scene
arView.scene.addAnchor(anchor)

De asemenea, puteți crea ancore la anumite poziții ale lumii folosind sau atașați conținut la imagini sau fețe detectate care utilizează sau .

Construirea unei scene AR de bază cu RealityKit

Dincolo de plasarea simplă a modelului, trebuie să gestionaţi ciclul de viaţă al vizualizării AR. Într-o aplicaţie UIKit, adăugaţi un la controlerul vizual:

class ViewController: UIViewController {
 @IBOutlet var arView: ARView!

 override func viewDidLoad() {
 super.viewDidLoad()
 arView.session.delegate = self
 // Configure session
 let config = ARWorldTrackingConfiguration()
 config.planeDetection = [.horizontal, .vertical]
 arView.session.run(config)
 loadContent()
 }

 func loadContent() {
 // Create and add anchors
 }
}

Pentru SwiftUI, a introdus un care poduri ] în ierarhia SwiftUI.

Interacţiunea cu utilizatorul: Gesturi şi Testarea Hit

Pentru a face aplicaţia AR interactivă, trebuie să se ocupe de robinete de utilizator, trageri, şi rotaţii. RealityKit oferă hit-testare pentru a identifica ce entitate a atins utilizatorul.

Atingeți la locul sau la interacțiunea

Adăugaţi un la . În handler gest, apel pentru a prelua entitatea sub deget:

arView.addGestureRecognizer(UITapGestureRecognizer(target: self, action: #selector(handleTap(_:))))

@objc func handleTap(_ sender: UITapGestureRecognizer) {
 let location = sender.location(in: arView)
 if let entity = arView.entity(at: location) {
 // Scale the entity
 var transform = entity.transform
 transform.scale *= 1.2
 entity.move(to: transform, relativeTo: entity.parent, duration: 0.3, timingFunction: .easeInOut)
 } else {
 // Place a new object at the tapped location
 placeObject(at: location)
 }
}

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

Raidul împotriva suprafeţelor din lumea reală este mai fiabil decât testarea prin lovire a entităţii atunci când doriţi să plasaţi conţinutul pe un plan. Utilizaţi pentru aceasta.

Trageți și rotiți cu Gesturile

Pentru a activa dragul, atașați o și actualizați poziția entității de-a lungul planului. Pentru rotație, utilizați un :

let panGesture = UIPanGestureRecognizer(target: self, action: #selector(handlePan(_:)))
arView.addGestureRecognizer(panGesture)

@objc func handlePan(_ sender: UIPanGestureRecognizer) {
 let location = sender.location(in: arView)
 guard let entity = arView.entity(at: location) else { return }
 guard let parent = entity.parent as? HasAnchoring else { return }
 // Translate the entity in the anchor’s local plane
 let translation = sender.translation(in: arView)
 // ... (convert to 3D movement)
}

Pentru o implementare robustă, să ia în considerare utilizarea din pachetul RealityKits sau a pachetului de gesturi în iOS 16+.

Caracteristici avansate: Animaţii, Fizică şi Colaborare

Animații

RealityKit sprijină atât animații scheletice (din fișiere USDZ) cât și animații bazate pe proprietate. Pentru a declanșa o animație încorporat pe un model cu resurse de animație:

guard let model = try? ModelEntity.load(named: "dancing_character") else { return }
model.playAnimation(model.availableAnimations[0].repeat(duration: .infinity), transitionDuration: 0.5, startsPaused: false)

Puteți anima și transformările, opacitatea sau parametrii personalizați folosind metoda observată mai devreme. Pentru secvențe complexe, utilizați sau .

Simulare fizică

Ataşarea unei pentru a permite gravitaţia, coliziunile şi forţele:

let box = ModelEntity(mesh: .generateBox(size: 0.1), materials: [SimpleMaterial(color: .red, isMetallic: false)])
box.position = [0, 0.5, 0] // above a plane

let physicsBody = PhysicsBodyComponent(
 massProperties: .default,
 material: .generate(staticFriction: 0.8, dynamicFriction: 0.5, restitution: 0.3),
 mode: .dynamic
)
box.components.set(physicsBody)

let collision = CollisionComponent(shapes: [.generateBox(size: [0.1, 0.1, 0.1])])
box.components.set(collision)

// Add box to anchor
anchor.addChild(box)

Cutia va cădea în plan şi va răspunde la coliziuni. Obiectele statice (ca pereţii) ar trebui să aibă .

Sesiuni AR colaborative

Cu sesiunile de colaborare ARKit . Multiple dispozitive pot partaja aceeași lume AR. Activați colaborarea prin setarea opțiunilor de colaborare sesiune:

config.collaborationEnabled = true
arView.session.run(config)

Trimite altor colegi prin intermediul unui cadru de rețea (de exemplu, Conectivitate Multipeer). Fiecare dispozitiv ți-a făcut o scenă RealityKit rămâne sincronizată. Acest lucru este ideal pentru jocuri multiplayer sau comentarii de design partajate.

Optimizarea performanței pentru experiențe AR netede

Aplicaţiile AR cer rate mari de cadru (60 fps) pentru a evita boala de mişcare. Urmează aceste practici:

  • Folosiţi modele de poli scăzut şi optimizaţi fişierele USDZ. Păstraţi numărătoarele Vertex scăzute şi utilizaţi texturi comprimate (KTX sau PNG).
  • Limiteți numărul de entități din scenă. Utilizați ] pentru a depana numărul de contor.
  • Minimizează apelurile de tragere prin utilizarea instancing
  • Adjust reding quality with [[ ] on old devices.
  • Folosiţi încărcarea modelului pentru a preveni blocarea filetului principal.Încarcă modelele într-o coadă de fundal și prezintă-le când sunt gata.
  • Managerează ciclul de viață al sesiunii AR : apel atunci când aplicația merge în fundal și re-rulează configurația pe prim plan.

Pentru orientări detaliate, a se vedea Apple

Proiectarea interfețelor AR intuitive

Experienţa utilizatorilor în AR diferă de aplicaţiile tradiţionale. Urmează aceste principii:

  • Recepția de detectare a suprafeţei: Vizualizează avioanele detectate cu o grilă sau conturează astfel încât utilizatorii să știe unde să plaseze obiecte.
  • Gesturile ar trebui să se simtă naturale: Folosiți manipularea directă (tap, drag, pinch) mai degrabă decât comenzi abstracte.
  • Aluzii vizuale vizibile: Afișați entitățile interactive sau arătați un fir de păr atunci când utilizatorul indică un plan valid.
  • Iluminarea mânerului: RealitateaKit poate estima automat lumina din lumea reală și o poate aplica obiectelor virtuale. Utilizați ] pentru a ajusta intensitatea.
  • Test în diferite medii: diferite lumini, texturi și dimensiuni ale încăperilor afectează urmărirea AR. Optimizează pentru condiții medii.

Depanarea și testarea aplicațiilor AR

Testarea dispozitivului real nu este negociabilă. Utilizați Xcode

  • Activați ] pentru a arăta puncte de caracteristici, origine mondială, și fire de fizică.
  • Se utilizează loguri pentru a vedea când sunt detectate suprafețele.
  • Se adaugă un pentru a monitoriza starea de urmărire și erorile.
  • Test pe mai multe generații de dispozitive (de exemplu, iPhone 8 vs. iPhone 14 Pro) pentru a măsura performanța.

Pentru testarea automată UI, puteți să vă bateți joc de datele AR, dar testarea manuală rămâne esențială pentru precizie.

Concluzie

RealityKit abstractizează o mare parte din complexitatea dezvoltării AR, dar construirea unei experiențe lustruite necesită atenție la arhitectura entității, interacțiunea cu utilizatorul, performanța și designul. Prin combinarea tehnicilor acoperite