Construyendo Experiencias de Realidad Aumentada con Realitykit en Ios

Alternativamente, puede agregar manualmente RealityKit a un proyecto existente importando el marco:

import RealityKit
import ARKit

Asegúrese de que NSCameraUsageDescription] se establece en su : una cadena fácil de usar que explica por qué la aplicación necesita acceso a la cámara.

Para más detalles, consulte la documentación de AppleRealityKit y ARKit documentation.

Comprender el sistema de Entidades Componentes

RealityKit utiliza una arquitectura Entity‐Component], que es fundamental para construir escenas. Un es un contenedor que posee componentes. Los componentes definen el comportamiento, la apariencia, la física y otras propiedades de la entidad. Por ejemplo, un define una malla 3D, una posición [FLT/5]

Este enfoque modular hace que sea fácil componer objetos complejos. Crea entidades, fija componentes y los arregla en una jerarquía. La raíz de la escena es un (típicamente un ), que vincula el contenido virtual con una ubicación real detectada por ARKit.

Crear un ancla y agregar contenido

El anclaje más común es un anclaje plano, que fija el contenido a superficies horizontales o verticales. Aquí es cómo colocar un modelo 3D en cualquier plano reconocido:

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

También puede crear anclas en posiciones específicas del mundo usando o adjuntar contenido a imágenes o rostros detectados usando o ].

Construyendo un escenario AR básico con la realidadKit

Más allá de la colocación de modelos simples, usted necesita administrar el ciclo de vida de la vista AR. En una aplicación UIKit, añadir un a su controlador de visión:

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

Para SwiftUI, incrustar un que puente en la jerarquía SwiftUI.

Interacción del usuario: Gestos y Hit‐Testing

Para que su aplicación AR sea interactiva, necesita manejar los grifos, arrastres y rotaciones de los usuarios. RealityKit proporciona un test de éxito para identificar qué entidad tocó el usuario.

Toque a la Place o Interacto

Añada un al . En el gestor, llame para recuperar la entidad bajo el dedo:

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

Raycast contra las superficies del mundo real es más confiable que la entidad que se da a prueba cuando desea colocar contenido en un plano. Use para esto.

Arrastre y gire con Gestures

Para permitir la arrastre, agréguese un y actualice la posición de la entidad a lo largo del plano. Para la rotación, utilice 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)
}

Para una aplicación robusta, considere utilizar del paquete de RealityKit], o la propiedad de gesto en iOS 16+.

Características avanzadas: Animaciones, Física y Colaboración

Animaciones

RealityKit admite animaciones esqueléticas (de archivos USDZ) y animaciones basadas en la propiedad. Para activar una animación integrada en un modelo con recursos de animación:

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

También puede animar transformaciones, opacidad o parámetros personalizados utilizando el método visto anteriormente. Para secuencias complejas, use o .

Simulación Física

Adjuntar un para permitir la gravedad, las colisiones y las fuerzas:

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 caja caerá sobre el plano y responderá a las colisiones. Los objetos esticos (como las paredes) deberían tener .

Reuniones de AR colaborativas

Con las sesiones de colaboración de ARKit, varios dispositivos pueden compartir el mismo mundo AR. Permitir la colaboración mediante la configuración de las opciones de colaboración de la sesión:

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

Enviar a otros pares a través de un marco de red (por ejemplo, Multipeer Connectivity). La escena RealityKit de cada dispositivo sigue sincronizada. Esto es ideal para juegos multijugador o para comentarios de diseño compartidos.

Optimización de rendimiento para experiencias de AR de Smooth

Las aplicaciones AR exigen altas tasas de marcos (60 fps) para evitar la enfermedad de movimiento.

• Utilice modelos de baja potencia] y optimizados archivos USDZ. Mantenga el vértice cuenta con texturas bajas y usen texturas comprimidas (KTX o PNG).
• ]Escribe el número de entidades en la escena. Usa para depurar los recuentos.
• Minimizar las llamadas de sorteo mediante la instancing – compartir el mismo modelo en múltiples entidades.
• Ajuste la calidad de renderización con en dispositivos antiguos.
• Use de carga de modelo] para evitar el bloqueo de los hilos principales. Carga modelos en una cola de fondo y presentarlos cuando esté listo.
• Maneje el ciclo de vida de la sesión AR: llame cuando la aplicación vaya al fondo, y vuelva a ejecutar la configuración en primer plano.

Para obtener una orientación detallada, consulte la Creando una experiencia de AR inmersiva] y ]Testing and Troubleshooting Your AR Experience.

Diseño de interfaces de AR intuitivas

La experiencia de usuario en AR difiere de las aplicaciones tradicionales.

• Reseña de detección de superficies: Visualizar planos detectados con una red o contorno para que los usuarios sepan dónde colocar objetos.
• Las imágenes deben sentirse naturales: Usar la manipulación directa (tap, drag, pinch) en lugar de controles abstractos.
• Proveer pistas visuales: Destacar las entidades interactivas o mostrar un crosshair cuando el usuario señala en un plano válido.
• Iluminación de mandíbulas: RealityKit puede estimar automáticamente la luz del mundo real y aplicarla a objetos virtuales. Use para ajustar la intensidad.
• Prueba en varios entornos: Las diferentes iluminación, texturas y tamaños de la habitación afectan el seguimiento de AR. Optimize para condiciones promedio.

Depuración y prueba de aplicaciones AR

Las pruebas de dispositivos reales no son negociables. Use Xcode's ARKit Debugging Features:

• Permitir mostrar puntos de características, origen mundial y cables de física.
• Use registros para ver cuándo se detectan superficies.
• Agregue un para monitorear estado de seguimiento y errores.
• Prueba en varias generaciones de dispositivos (por ejemplo, iPhone 8 vs. iPhone 14 Pro) para medir el rendimiento.

Para la prueba automatizada de la interfaz de usuario, puede burlar los datos de AR, pero la prueba manual sigue siendo esencial para la precisión.

Conclusión

RealityKit abstrae gran parte de la complejidad del desarrollo de AR, pero la construcción de una experiencia pulida requiere atención a la arquitectura de entidad, interacción de usuario, rendimiento y diseño. Combinando las técnicas cubiertas – desde la configuración de escena y el manejo de gestos a la física y la colaboración – puedes crear aplicaciones AR que involucren a los usuarios y apalancan el potencial completo de hardware iOS.