Construindo experiências de realidade aumentadas com kit de realidade em Ios

Alternativamente, você pode adicionar manualmente RealityKit a um projeto existente, importando o framework:

import RealityKit
import ARKit

Certifique-se de que o NSCameraUsageDescrição está definido no seu – uma string amigável explicando por que o aplicativo precisa de acesso à câmera.

Para mais informações, consultar a documentação do Apple RealityKit e ARKit ].

Compreender o Sistema Entidade-Componente

RealityKit usa uma arquitetura Entity-Component, que é fundamental para construir cenas. Um é um recipiente que contém componentes. Componentes definem o comportamento, aparência, física e outras propriedades da entidade. Por exemplo, um define uma malha 3D, uma ] manipula posição/rotação/escala, e uma permite simulação física.

Esta abordagem modular torna mais fácil compor objetos complexos. Você cria entidades, anexa componentes e organiza-os em uma hierarquia. A raiz da cena é uma (tipicamente uma ], que liga conteúdo virtual a uma localização real do mundo detectada pelo ARKit.

Criar um Âncora e Adicionar Conteúdo

A âncora mais comum é uma âncora plana, que liga conteúdo a superfícies horizontais ou verticais. Aqui está como colocar um modelo 3D em qualquer plano reconhecido:

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

Você também pode criar âncoras em posições específicas do mundo usando ou anexar conteúdo para imagens ou faces detectadas usando ou .

Construindo uma cena AR básica com RealityKit

Além de simples colocação de modelo, você precisa gerenciar o ciclo de vida da visualização AR. Em um aplicativo UIKit, adicione um ao seu controlador de visualização:

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, incorpore uma que faça a ponte na hierarquia SwiftUI.

Interação do usuário: Gestos e testes de sucesso

Para tornar o seu aplicativo AR interativo, você precisa lidar com toques, arrastamentos e rotações de usuários. RealityKit fornece teste de hit para identificar qual entidade o usuário tocou.

Toque no local ou no Interact

Adicione um ao . No manipulador de gestos, chame para recuperar a entidade sob o 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)
}

Raycasting contra as superfícies do mundo real é mais confiável do que o hit-testing de entidade quando você quer colocar conteúdo em um avião. Use para isso.

Arrastar e girar com gestos

Para ativar o arrastar, anexe um e atualize a posição da entidade ao longo do plano. Para rotação, use um :

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 uma implementação robusta, considere usar do pacote RealityKit , ou a propriedade de gesto no iOS 16+.

Características avançadas: Animações, Física e Colaboração

Animações

RealityKit suporta animações esqueléticas (a partir de arquivos USDZ) e animações baseadas em propriedades. Para desencadear uma animação integrada em um modelo com recursos de animação:

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

Você também pode animar as transformações, opacidade ou parâmetros personalizados usando o método visto anteriormente. Para sequências complexas, use ou .

Simulação Física

Anexar um para permitir a gravidade, colisões e forças:

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)

A caixa cairá sobre o avião e responderá às colisões. Os objetos estáticos (como paredes) devem ter .

Sessões AR colaborativas

Com as sessões colaborativas do ARKit, vários dispositivos podem compartilhar o mesmo mundo de AR. Habilite a colaboração definindo as opções de colaboração da sessão:

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

Envie para outros pares através de uma estrutura de rede (por exemplo, Conectividade Multipare). A cena RealityKit de cada dispositivo permanece sincronizada. Isto é ideal para jogos multiplayer ou avaliações de design compartilhado.

Otimização do desempenho para experiências AR suaves

Aplicações AR exigem altas taxas de quadros (60 fps) para evitar o enjoo do movimento. Siga estas práticas:

• Use modelos de baixo-poli e optimize os arquivos USDZ. Mantenha as contagens de vértices baixas e use texturas compactas (KTX ou PNG).
• Limite o número de entidades ] na cena. Use para depurar conta.
• Minimizar chamadas de empate usando o instancing – compartilhar o mesmo modelo entre várias entidades.
• Ajustar a qualidade de renderização com nos dispositivos mais antigos.
• Use ] carregamento do modelo para evitar o bloqueio do thread principal. Carregue modelos em uma fila de fundo e apresente-os quando estiver pronto.
• Gerir o ciclo de vida da sessão AR: chamar quando a aplicação for para o fundo e repetir a configuração em primeiro plano.

Para obter orientações pormenorizadas, ver da Apple Criando uma experiência de AR imersiva e Testing and Troubleshooting Your AR Experience].

Design de interfaces AR intuitivas

A experiência do usuário em RA difere das aplicações tradicionais. Siga estes princípios:

• Reaplicação de detecção de superfície: Visualize os planos detectados com uma grade ou contorno para que os usuários saibam onde colocar objetos.
• Os gestinos devem se sentir naturais: Use manipulação direta (tap, drag, belisca) em vez de controles abstratos.
• Forneça dicas visuais: Realce entidades interativas ou mostre uma mira quando o usuário aponta para um plano válido.
• Iluminação manual : RealityKit pode estimar automaticamente a luz do mundo real e aplicá-la a objetos virtuais. Use para ajustar a intensidade.
• Teste em vários ambientes: Iluminação diferente, texturas e tamanhos de sala afetam o rastreamento de AR. Otimize para condições médias.

Depuração e Teste de Aplicações AR

Testes de dispositivos reais não são negociáveis. Use o ARKit Debugging Features:

• Habilite para mostrar pontos de recursos, origem mundial e estruturas de fio de física.
• Utilizar para ver quando as superfícies são detectadas.
• Adicione um para monitorar o estado de rastreamento e erros.
• Teste em várias gerações de dispositivos (por exemplo, iPhone 8 vs. iPhone 14 Pro) para medir o desempenho.

Para testes de interface automatizados, você pode simular dados de AR, mas testes manuais continuam sendo essenciais para a precisão.

Conclusão

RealityKit abstrai grande parte da complexidade do desenvolvimento de AR, mas construir uma experiência polida requer atenção à arquitetura de entidade, interação do usuário, desempenho e design. Ao combinar as técnicas cobertas – desde a configuração de cena e manipulação de gestos até a física e colaboração – você pode criar aplicativos de AR que atraem usuários e aproveitar todo o potencial do hardware iOS. Mantenha-se atualizado com as estruturas de AR em evolução da Apple e teste sempre em dispositivos reais para garantir uma experiência imersiva e sem falhas.