Bâtir des expériences de réalité augmentée avec Realitykit à Ios

Vous pouvez aussi ajouter manuellement RealityKit à un projet existant en important le cadre :

import RealityKit
import ARKit

Assurez-vous que la NSCameraDescription d'utilisation est définie dans votre – une chaîne conviviale expliquant pourquoi l'application a besoin d'un accès par caméra.

Pour plus de détails, voir Apples RealityKit documentation[ et ARKit documentation[.

Comprendre le système des composants de l'entité

RealityKit utilise une architecture Component-Entity, qui est fondamentale pour construire des scènes. Un est un conteneur qui contient des composants. Les composants définissent le comportement, l'apparence, la physique et d'autres propriétés de l'entité. Par exemple, un définit un maillage 3D, un gère la position/rotation/échelle et un permet la simulation physique.

Cette approche modulaire permet de composer facilement des objets complexes. Vous créez des entités, attachez des composants et les arrangez dans une hiérarchie. La racine de la scène est une (généralement une ), qui relie le contenu virtuel à un emplacement réel détecté par ARKit.

Création d'un anchor et ajout de contenu

L'ancre la plus courante est une ancre plane, qui fixe le contenu aux surfaces horizontales ou verticales. Voici comment placer un modèle 3D sur n'importe quel plan reconnu:

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

Vous pouvez également créer des ancres à des positions mondiales spécifiques en utilisant ou en joignant du contenu aux images ou aux visages détectés en utilisant ou .

Construire une scène AR de base avec RealityKit

Au-delà du simple placement de modèle, vous devez gérer le cycle de vie de la vue AR. Dans une application UIKit, ajoutez un à votre contrôleur de vue :

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

Pour SwiftUI, intégrer un qui bridge dans la hiérarchie SwiftUI.

Interaction utilisateur : Gestures et tests de succès

Pour rendre votre application AR interactive, vous devez gérer les touches, les glisser et les rotations de l'utilisateur. RealityKit fournit des tests de succès pour identifier l'entité que l'utilisateur a touchée.

Appuyez sur Place ou Interagissez

Dans le gestionnaire de gestes, appelez pour récupérer l'entité sous le doigt :

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

Le rayonnement contre les surfaces du monde réel est plus fiable que le test de frappe d'entité lorsque vous voulez placer du contenu sur un plan. Utilisez pour cela.

Faites glisser et rotez avec des gestures

Pour activer la traînée, attachez un et mettez à jour la position de l'entité dans le plan. Pour la rotation, utilisez 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)
}

Pour une implémentation robuste, envisagez d'utiliser de RealityKit="s , ou le paquet de la propriété gestuelle dans iOS 16+.

Caractéristiques avancées : Animations, physique et collaboration

Animations

RealityKit prend en charge à la fois les animations squelettiques (à partir de fichiers USDZ) et les animations basées sur la propriété.

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

Vous pouvez également animer des transformations, une opacité ou des paramètres personnalisés en utilisant la méthode vue plus tôt. Pour les séquences complexes, utilisez ou .

Simulation physique

Joindre un pour permettre la gravité, les collisions et les forces:

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)

La boîte tombera sur le plan et réagira aux collisions. Les objets statiques (comme les murs) devraient avoir .

Séances de collaboration en matière d'évaluation des risques

Avec les sessions de collaboration ARKit, plusieurs appareils peuvent partager le même monde AR. Activer la collaboration en définissant les options de collaboration de la session:

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

Envoyer à d'autres pairs via un cadre réseau (p. ex., Multipeer Connectivity). Chaque appareil , la scène RealityKit reste synchronisée. Ceci est idéal pour les jeux multijoueurs ou les revues de conception partagées.

Optimisation des performances pour les expériences d'AR sans heurt

Les applications AR exigent des taux de cadre élevés (60 fps) pour éviter le mal des mouvements. Suivez ces pratiques:

• Utilisez des modèles à faible polarisation et optimisez les fichiers USDZ. Gardez le vertex compte bas et utilisez des textures compressées (KTX ou PNG).
• Limiter le nombre d'entités sur la scène. Utilisez pour le déboguage.
• Minimisez les appels de tirage en utilisant l'instancing – partagez le même modèle entre plusieurs entités.
• Ajustez la qualité de rendu avec sur les appareils plus anciens.
• ] Pour éviter de bloquer le thread principal, utilisez le chargement du modèle. Chargez les modèles dans une file d'attente et présentez-les quand vous êtes prêt.
• Gérer le cycle de vie de la session AR: appeler lorsque l'application va en arrière-plan, et ré-exécuter la configuration au premier plan.

Pour obtenir des conseils détaillés, voir Apples Créer une expérience d'EI immersive et Test et dépannage de votre expérience d'EI.

Conception d'interfaces AR intuitives

L'expérience utilisateur en AR diffère des applications traditionnelles. Suivez ces principes :

• Feedback de détection de surface[: Visualisez les plans détectés avec une grille ou un contour afin que les utilisateurs sachent où placer les objets.
• Les gestuelles doivent se sentir naturelles : Utiliser une manipulation directe (tap, glisser, pincer) plutôt que des contrôles abstraits.
• Fournir des conseils visuels: Mettre en évidence des entités interactives ou montrer un crosshair lorsque l'utilisateur pointe sur un plan valide.
• Luminaire manuel: RealityKit peut automatiquement estimer la lumière du monde réel et l'appliquer aux objets virtuels. Utilisez pour ajuster l'intensité.
• Test dans différents environnements: Différents éclairages, textures et dimensions de la pièce affectent le suivi AR. Optimisez pour des conditions moyennes.

Débogue et test des applications AR

Les tests de vrais appareils ne sont pas négociables. Utilisez Xcodes Caractéristiques de débogage ARKit:

• Activer pour afficher les points de caractéristiques, l'origine mondiale et les trames filaires de physique.
• Utilisez des logs pour voir quand les surfaces sont détectées.
• Ajouter un pour surveiller l'état de suivi et les erreurs.
• Tester sur plusieurs générations d'appareils (par exemple, iPhone 8 vs. iPhone 14 Pro) pour mesurer les performances.

Pour les tests automatisés d'interface utilisateur, vous pouvez vous moquer des données d'AR, mais les tests manuels restent essentiels pour la précision.

Conclusion

RealityKit résume une grande partie de la complexité du développement de l'AR, mais la construction d'une expérience polie nécessite une attention particulière à l'architecture des entités, à l'interaction, aux performances et au design des utilisateurs. En combinant les techniques couvertes – de la configuration de la scène et de la manipulation des gestes à la physique et à la collaboration – vous pouvez créer des applications AR qui mobilisent les utilisateurs et tirent parti de tout le potentiel du matériel iOS.