Novidades do RealityKit

Olá! Meu nome é Laurence. Sou software engineer da equipe RealityKit. Esta é a sessão “Novidades do RealityKit”. Nesta sessão, vou abordar alguns dos novos recursos do RealityKit que estão sendo lançados este ano.

Lançamos o RealityKit em 2019 para permitir a integração de conteúdo 3D nos seus apps, proporcionando renderização realista e aprimorando as experiências imersivas. Desde então, recebemos muitos comentários de vocês, o que nos ajudou a tornar este framework melhor ano após ano. O RealityKit oferece muitos recursos para que seu conteúdo 3D se misture perfeitamente com o ambiente do mundo real, permitindo que você crie apps e jogos imersivos no visionOS. Além do visionOS, o RealityKit também traz muitos recursos importantes do RealityKit para iOS, iPadOS e macOS. Com os recursos multiplataforma do RealityKit, você pode escrever seu app uma vez e levá-lo para muitas plataformas diferentes com o mínimo de alterações de código. Este ano, tenho o orgulho de anunciar que o RealityKit agora é compatível com o último tvOS! Agora você pode trazer seus apps e experiências para a Apple TV ou fazer novas criações para a tela grande. O RealityKit é compatível com todas as gerações da Apple TV 4K. A atualização do RealityKit deste ano traz uma gama de novas funcionalidades que tornam ainda mais fácil criar experiências 3D que aliam o mundo virtual ao real. Nesta sessão, vou apresentar alguns desses recursos, como o ManipulationComponent, EnvironmentBlendingComponent, MeshInstancesComponent e outros. Vou usar alguns deles para construir um quebra-cabeça espacial. O jogo começa com um baú trancado que está ancorado a uma superfície à sua frente. Ao redor desse baú haverá vários objetos com os quais você poderá interagir. Um desses objetos terá a chave que abre o baú presa ao fundo dele. Ao pegar e inspecionar os objetos, você pode encontrar qual deles tem a chave. Assim que tiver a chave, pode destrancar o baú e ver o seu prêmio:

uma pequena queima de fogos!

Primeiro, vou usar o novo suporte nativo do ARKit no RealityKit para ancorar os modelos ao espaço à frente do jogador e lidar com as mudanças no ciclo de vida da âncora. Depois, mostrarei como usar o novo ManipulationComponent para adicionar interatividade a entidades 3D em uma cena. Também usarei um PhysicsBodyComponent para que eles caiam realisticamente quando lançados. Então, usarei as novas APIs SceneUnderstanding para permitir que as entidades do jogo colidam com a malha de compreensão de cena.

Depois disso, vou usar o EnvironmentBlendingComponent para permitir que o app se misture melhor com o mundo real.

Em seguida, vou mostrar como usar o novo MeshInstancesComponent para desenhar várias instâncias de um modelo 3D para decorar minha cena. Depois, vou falar de algumas atualizações de mídia imersiva bem legais. Também vou apresentar outras novidades, como acessórios espaciais, atualizações para entidades e muito mais. Vou começar ancorando modelos 3D ao ambiente do mundo real usando uma nova API que dá acesso a dados do ARKit diretamente por meio do RealityKit. Usarei um RealityKit AnchorEntity para posicionar o jogo em uma mesa. As entidades âncora são usadas para anexar conteúdo virtual a superfícies do mundo real. Este ano, tornamos o AnchorEntities mais poderoso ao expor os dados de ancoragem do ARKit diretamente. Vou mostrar como se faz. Para ter acesso a dados do ARKit diretamente do RealityKit, é necessário primeiro criar um SpatialTrackingSession. A configuração da sessão dirá ao RealityKit para enviar os novos AnchorStateEvents ao seu app à medida que os estados de AnchorEntities forem alterados. Então, você pode configurar uma AnchorEntity para filtrar as propriedades da âncora que você está procurando. No meu app, quero procurar uma tabela com dimensões específicas. Quando o RealityKit encontrar a melhor âncora para as propriedades que defini na AnchorEntity, ele vai disparar um AnchorStateEvent. Essa instância de AnchorStateEvent contém dados do ARKit, como a transformação e extensões da âncora, que posso usar para posicionar o jogo. Vamos analisar isso no código. Vou começar criando uma SpatialTrackingSession que permitirá que as AnchorEntities do RealityKit sejam rastreadas para o ambiente. No meu jogo, preciso rastrear um avião para gerar o baú do tesouro, então vou definir uma SpatialTrackingSession com o rastreamento de avião ativado.

Agora posso iniciar a sessão de rastreamento executando a configuração que acabei de criar. Depois, posso gerar uma AnchorEntity para ajudar a posicionar o jogo na mesa. Vou classificar a AnchorEntity como uma tabela que deve ter uma superfície horizontal com limites mínimos de 15 cm² associados a ela. Essa AnchorEntity começará em um estado desancorado, mas ficará ancorada quando for detectado um plano de tabela que corresponda à classificação e aos limites fornecidos. Para receber atualizações quando o estado da âncora for alterado, terei de usar a nova API AnchorStateEvents.

A API AnchorStateEvents permite assinar eventos para quando as entidades forem ancoradas, se estiverem prestes a ser desancoradas ou se falharem em ancorar. Usarei o evento DidAnchor no meu app para posicionar as entidades do jogo dentro dos limites da superfície da tabela.

No meu código, vou adicionar uma assinatura ao evento DidAnchor para saber quando a entidade âncora foi ancorada ao ambiente. A estrutura do evento fornece minha entidade âncora, que foi atualizada para conter o novo ARKitAnchorComponent. Esse componente contém dados do ARKit, como extensões e transformações, que posso usar para posicionar as entidades do jogo na superfície ancorada. Posso acessar esses dados utilizando a propriedade âncora do ARKitAnchorComponent.

Para usar essa propriedade, terei de convertê-la no tipo de âncora do ARKit. Nesse caso, tentarei lançá-la para um PlaneAnchor, já que a AnchorEntity está configurada para procurar aviões.

Agora tenho acesso às extensões e transformações brutas do ARKit para a âncora. Usarei as transformações do ARKit, especificamente originFromAnchorTransform e anchorFromExtentTransform, para posicionar o jogo e garantir que ele esteja centrado na superfície ancorada. Agora, ao abrir o espaço imersivo, os objetos do jogo serão gerados assim que uma superfície adequada for encontrada.

A seguir, vou adicionar interatividades à cena usando o novo ManipulationComponent no RealityKit. O ManipulationComponent simplifica o processo de pegar e girar as entidades 3D em sua cena. Ele comporta até movimentos avançados, como trocar de mãos!

Vou usar o ManipulationComponent para permitir que o jogador pegue e gire os objetos do jogo para encontrar a chave embaixo deles. Vou mostrar como adicionar essa funcionalidade ao jogo, mas se você quiser mais informações sobre o ManipulationComponent e o que você pode fazer com ele, confira a sessão “Melhor juntos: SwiftUI e RealityKit”. Para permitir que você pegue as entidades e interaja com elas, basta chamar a função ManipulationComponent configureEntity. Essa função adicionará automaticamente os componentes InputTarget, Collision, HoverEffect e Manipulation necessários à entidade. E aí está! Agora você pode pegar e girar as entidades com as mãos. No entanto, você vai notar que os objetos voltarão suavemente para o lugar de origem quando forem soltos.

Voltarei ao meu código e definirei a propriedade "releaseBehavior" no ManipulationComponent para permanecer.

Em seguida, atribuirei essa instância ManipulationComponent à minha entidade. Isso impedirá que o objeto volte automaticamente à posição inicial quando eu soltá-lo. Em vez disso, ele continuará parado. Depois, tenho derrubá-los no chão. Para isso, adiciono um PhysicsBodyComponent à entidade. Eu gostaria de ter o cuidado de só ativar a gravidade no PhysicsBodyComponent quando o objeto não estiver sendo agarrado e pego. Com a nova API ManipulationEvents, é fácil fazer isso.

ManipulationEvents são eventos emitidos pelo RealityKit que descrevem vários estados de interatividade pelos quais as entidades passam.

Por exemplo, o evento WillRelease será acionado quando uma entidade for liberada pelo jogador. Da mesma forma, existem outros eventos, como WillBegin, WillEnd, DidUpdateTransform e DidHandOff. Leia a documentação em developer.apple.com para obter mais detalhes.

Vou usar os eventos WillBegin e WillEnd para garantir que as entidades do jogo só reajam à gravidade quando não houver interatividade com elas.

Primeiro, adiciono uma assinatura ao evento WillBegin para alterar o modo physicsBodyComponent para cinemático, para evitar que o sistema físico interfira, enquanto o objeto está sendo movido. Isso também evita que a gravidade afete a entidade.

Depois, adiciono uma assinatura ao evento WillEnd para voltar o modo physicsBodyComponent para dinâmico, já que não há mais interatividade com a entidade. Isso permite que a entidade reaja a outros objetos físicos na cena. Ela também reagirá à gravidade! Agora que os objetos do jogo reagem à física, preciso que eles colidam com o ambiente do jogador. Posso fazer isso usando a nova API de compreensão de cena, que adiciona a malha da minha sala à simulação de física do app. Com a API SpatialTrackingSession, o RealityKit é capaz de gerar uma malha do ambiente. Essa malha, conhecida como malha de compreensão de cena, pode ser usada para adicionar colisão e física aos objetos do mundo real na sua sala.

Você pode utilizar a malha de compreensão de cena de seu ambiente do mundo real definindo o SceneUnderstandingFlags na configuração SpatialTrackingSession.

O visionOS atualmente comporta as bandeiras de colisão e física. Vou usar ambas para permitir que os objetos do jogo colidam com a malha de compreensão de cena. Vou definir esses sinalizadores na configuração SpatialTrackingSession antes de executar.

Para isso, preciso atualizar o SpatialTrackingSession que configurei antes. Basta adicionar os sinalizadores de compreensão de colisão e cena física à configuração SpatialTrackingSession antes de iniciar a sessão. Agora, a malha de compreensão de cena participará da simulação de física do jogo, e os objetos do jogo colidirão com o ambiente quando eu os derrubar na mesa ou no chão. Agora que meu jogo pode interagir com o ambiente, quero que ele responda visualmente ao ambiente também. Para isso, posso usar o EnvironmentBlendingComponent. O EnvironmentBlendingComponent é um novo componente projetado para apps espaciais imersivos na atualização do RealityKit deste ano.

Esse componente permite que as entidades sejam encobertas por objetos estáticos do mundo real. As entidades com esse componente são realisticamente ocultadas no todo ou em parte, dependendo de quanto da entidade é encoberto por um objeto estático do mundo real. Objetos dinâmicos em movimento, como pessoas e animais de estimação, não ocultarão objetos com esse componente.

Se eu quiser adicionar essa funcionalidade, basta adicionar o EnvironmentBlendingComponent e definir o modo de mesclagem preferido para ser encoberto pelo ambiente. Agora, se uma entidade com o EnvironmentBlendingComponent estiver posicionada atrás de um objeto do mundo real, você notará que a entidade será encoberta por ele. As entidades que usam o EnvironmentBlendingComponent serão tratadas como parte do ambiente em segundo plano e serão desenhadas atrás de outros objetos virtuais em sua cena. Agora que o EnvironmentBlendingComponent está funcionando, posso adicionar decorações à área do jogo usando o novo MeshInstancesComponent. Ano passado, as APIs LowLevelMesh e LowLevelTexture foram adicionadas ao RealityKit para oferecer muito mais controle dos dados de renderização. Na atualização do RealityKit deste ano, esse acesso de baixo nível está sendo expandido para outro aspecto da renderização: o instanciamento. No meu app, quero decorar o espaço ao redor e também definir uma área de jogo.

Eu poderia gerar um monte de entidades duplicadas para decorar o espaço. Só que, para isso, eu teria de clonar a entidade muitas vezes, o que criaria muitas cópias do ModelComponent. Isso poderia resultar em muito espaço de memória e processamento. Uma forma mais eficiente e também conveniente de fazer isso é usar o novo MeshInstancesComponent.

O MeshInstancesComponent permite desenhar uma malha várias vezes com uma única entidade. Basta fornecer uma lista de transformações para desenhar a malha. No iOS, iPadOS, macOS e tvOS, pode-se usar um LowLevelBuffer para passar dados de renderização para o CustomMaterial de modo que cada instância de malha pareça única. Além de conveniente, o MeshInstancesComponent também pode melhorar o desempenho, reduzindo a quantidade de dados que precisam ser enviados para a GPU. Em vez de enviar várias cópias do modelo e materiais para a GPU ao desenhar malhas duplicadas, o MeshInstancesComponent só enviará esses dados uma vez.

É importante observar que os modelos desenhados com um único MeshInstancesComponent ainda são considerados parte de uma única entidade. Se você usar esse componente para cobrir uma área grande, talvez faça sentido dividi-lo em várias entidades menores para permitir o culling. Veja como usar o MeshInstancesComponent no código. Primeiro, preciso de uma malha para a instância. Vou obtê-la carregando uma entidade do pacote de conteúdo do app. Agora, posso inicializar o MeshInstancesComponent e o objeto LowLevelInstanceData. O objeto LowLevelInstanceData é o que contém os dados para cada uma das instâncias de malha. Ao criar um objeto LowLevelInstanceData, preciso fornecer o número de instâncias necessárias para o meu app. Vou usar 20 aqui para mostrar uma aproximação da área de jogo sem muita aglomeração. Então, posso atribuir o objeto LowLevelInstanceData ao MeshInstancesComponent subscrito pelo índice da parte de malha que quero instanciar. No meu caso, sei que a malha que estou instanciando é simples e só tem uma parte de malha, então vou atribuir o LowLevelDataObject a partIndex: 0.

Agora posso preencher o objeto LowLevelInstanceData com as transformações para cada instância de malha.

Para ter decorações variadas, vou randomizar a escala, o ângulo e a posição para cada uma dessas instâncias. Com esses valores, posso criar uma matriz de transformação e atribuí-la a uma instância.

Agora posso adicionar o MeshInstancesComponent à entidade e, sempre que a entidade for desenhada, ela usará os dados do MeshInstancesComponent.

Com isso... o jogo está completo!

Você pode iniciar o jogo e fixá-lo à superfície à sua frente. Você pode pegar e girar os objetos na área de jogo para encontrar a chave que destranca o baú! Vamos recapitular as novas APIs que usei para criar este app. Usei as novas APIs AnchorStateEvent para ancorar o conteúdo. Depois, usei o ManipulationComponent para permitir interatividade com os objetos. Usei as sinalizações de compreensão de cena para permitir que as entidades do jogo colidissem com a malha de compreensão de cena. Por fim, usei o EnvironmentBlendingComponent e o MeshInstancesComponent para ajudar o jogo a se mesclar com o mundo real. A seguir, vamos ver outros recursos interessantes adicionados ao RealityKit este ano, como suporte para novas mídias imersivas. Este ano, introduzimos um novo componente chamado ImagePresentationComponent, usado para apresentar imagens no RealityKit. Ele comporta três tipos de imagens: imagens e fotos 2D tradicionais, fotos espaciais, que são fotos estereoscópicas do iPhone ou Vision Pro, e cenas espaciais, um novo tipo de imagem 3D criada de uma imagem ou foto 2D existente.

Cenas espaciais são imagens 3D com profundidade real, geradas de uma imagem 2D. São como uma versão em diorama de uma foto, com paralaxe de movimento para acentuar a profundidade da cena espacial à medida que o espectador move a cabeça em relação à cena. As cenas espaciais são uma ótima maneira de dar vida às fotos 2D existentes, seja no app Fotos no visionOS ou no seu próprio app, com o RealityKit. Vamos ver o código para adicionar os três tipos de imagens ao seu app. Vou começar mostrando como apresentar uma imagem ou foto 2D com o RealityKit.

Primeiro, vou encontrar um URL para uma foto 2D e usá-lo para criar um novo componente de apresentação de imagem. O inicializador para o componente é assíncrono, pois pode levar um tempinho para carregar a imagem na memória. Depois que o componente é inicializado, posso atribuí-lo a uma entidade para exibi-lo na minha cena do RealityKit.

Para a apresentação de fotos espaciais, há mais uma etapa envolvida. Você precisará atribuir um modo de visualização desejado para o componente antes de configurá-lo na entidade. E pode especificar o modo de visualização desejado, verificando primeiro se a imagem o comporta. Se você não especificar um modo de visualização ou se a imagem não der suporte, o ImagePresentationComponent apresentará a imagem em um modo de visualização 2D ou monoscópica, mesmo que seja uma foto espacial. Para optar pela apresentação de fotos espaciais imersivas, use o modo de visualização desejado do spatialStereoImmersive. Sempre que você criar um componente de apresentação de imagem de uma foto espacial, os modos estéreo e espacial estarão disponíveis. As imagens 2D e as fotos espaciais são carregadas de um arquivo no disco. Exibir essa imagem como uma cena espacial requer algumas etapas adicionais, pois precisamos gerar a cena espacial antes de apresentá-la. Vou mostrar como gerar e apresentar uma cena espacial em código.

Você pode gerar uma cena espacial usando uma imagem 2D ou uma foto espacial. Se gerar uma cena espacial de uma foto espacial, apenas um dos canais na foto espacial será usado como imagem 2D para conversão. Para criar uma cena espacial, você não inicializa o ImagePresentationComponent diretamente do URL da imagem. Em vez disso, você pode criar um Spatial3DImage do URL e usar a imagem espacial 3D para inicializar o ImagePresentationComponent. Porém, o componente ainda não está pronto para se apresentar como uma cena espacial. Você precisa gerar a cena primeiro.

Fazemos isso chamando o método de geração da imagem espacial 3D. Isso vai gerar a cena espacial em poucos segundos. Depois, os modos availableViewingModes do ImagePresentationComponent serão atualizados para incluir os modos spatial3D e spatial3DImmersive. Então você pode definir um deles como o modo de visualização desejado e optar pela apresentação em janela ou imersiva da cena espacial. Não é necessário gerar a cena espacial com antecedência. Convém esperar até que a pessoa que está usando o app aperte um botão, como no app Fotos. Definir o modo de visualização do componente como .spatial3D antes de chamar generate informa ao componente que você deseja mostrar a cena espacial assim que estiver pronta. Isso solicita que o componente mostre uma animação de progresso durante o processo de geração e exiba a cena espacial assim que a geração for concluída. Veja um exemplo no Vision Pro. O componente de apresentação de imagem mostra a mesma animação de geração do app Fotos no visionOS, e o resultado fica ótimo em 3D.

Este é um resumo rápido das diferentes maneiras de usar ImagePresentationComponent para apresentar uma imagem 2D, uma foto espacial ou uma cena espacial. Para obter mais informações sobre esse componente, consulte o código de exemplo “Apresentar imagens no RealityKit”, em developer.apple.com.

Outra atualização de mídia imersiva este ano é que VideoPlayerComponent foi atualizado para comportar a reprodução de vários formatos de vídeo imersivos. Agora ele é compatível com a reprodução de vídeo espacial todo em estilo espacial, nos modos portal e imersivo.

Vídeos Apple Projected Media Profile, como 180°, 360° e ultra-angular, também são compatíveis. Pode-se também definir ajustes de conforto para vídeos Apple Projected Media Profile. O RealityKit ajustará automaticamente a reprodução. Esses formatos de vídeo, além do Apple Immersive Video, podem ser configurados para vários modos de visualização. Para aprofundar-se nessas atualizações, confira a sessão “Compatibilidade com a reprodução de vídeo imersiva em apps para visionOS”.

A seguir, algumas de nossas outras atualizações este ano. Primeiro, os acessórios espaciais rastreados. Depois, as últimas atualizações com integração para SwiftUI e RealityKit. Depois disso, novas atualizações de entidade. Vou dar uma visão geral do suporte de textura AVIF do RealityKit. Depois, o novo recurso groupID de efeito de foco. Por fim, a adição de efeitos de pós-processamento ao RealityViews. Vamos começar. O RealityKit está adicionando suporte para rastreamento de acessórios espaciais para que você interaja com os apps em espaço compartilhado e espaço total. Você pode rastrear acessórios espaciais em seis graus de liberdade, e eles também são compatíveis com a resposta tátil para aprimorar a interatividade nos apps e jogos. Para saber mais sobre a entrada de acessórios espaciais nos apps, confira a sessão “Explorar a inserção de acessórios espaciais no visionOS”. Este ano, o RealityKit também está introduzindo alguns componentes para permitir maior integração com o SwiftUI. O ViewAttachmentComponent torna muito simples adicionar exibições do SwiftUI diretamente às entidades. Além disso, o PresentationComponent permite adicionar apresentações modais, como popovers, às entidades. E o novo GestureComponent simplifica o processo de adição de movimentos do SwiftUI às entidades. Confira a sessão “Melhor juntos: SwiftUI e RealityKit” para saber mais novidades sobre a integração do SwiftUI e do RealityKit deste ano.

Há também um novo método attach que permite anexar uma entidade ao pin de outra entidade. Essa API torna muito simples a fixação de malhas às articulações de um esqueleto animado. Anexar malhas dessa maneira evitará o alinhamento manual das malhas, bem como atualizações de transformação hierárquica caras. Além disso, há um novo inicializador de entidade que permite carregar entidades de objetos de dados na memória. Com esse inicializador novo, você pode carregar cenas inteiras ou USDs do RealityKit de uma fonte online ou transmiti-los pela rede. O inicializador novo comporta os mesmos formatos de arquivo que os inicializadores de entidade atuais.

Além disso, o RealityKit está adicionando suporte a texturas codificadas em AVIF, que oferecem qualidade semelhante ao jpeg, com suporte para cores de 10 bits e tamanho bem menor. Você pode usar o app Pré-visualização no Mac ou usdcrush no Terminal para exportar USDs com essa compactação ativada. Além disso, o HoverEffectComponent está recebendo um novo recurso: GroupIDs. GroupIDs são uma maneira de criar associações entre efeitos de foco. Os efeitos de foco que compartilharem um GroupID compartilharão ativações. Atribuir efeitos de foco a um GroupID permitirá controle total sobre o modo como um efeito de foco é ativado, seja qual for a hierarquia relativa entre eles. Em geral, os efeitos de foco são aplicados hierarquicamente, como no exemplo à esquerda, em que as entidades filhas herdam os efeitos das entidades pai. No entanto, se uma entidade tiver um GroupID como Entidade A e Entidade B no exemplo à direita, ela não propagará os efeitos para as filhas.

Outro adendo legal este ano é o suporte para efeitos de pós-processamento no RealityView. Você pode usar a API customPostProcessing para adicionar efeitos personalizados, como bloom, aos seus apps utilizando Metal Performance Shaders, CIFilters ou os seus próprios shaders. Essa API é compatível com iOS, iPadOS, macOS e tvOS.

A atualização deste ano do RealityKit visa tornar a criação de experiências 3D com o RealityKit ainda mais fácil. Essa foi uma visão geral de como criar um quebra-cabeça espacial usando algumas das novas APIs do RealityKit para ancorar o jogo ao ambiente e permitir formas intuitivas de interagir com as peças do jogo. Falei também sobre as novas atualizações de mídia imersiva que permitem que os apps exibam conteúdo espacial diretamente no RealityKit.

Depois, abordei outras atualizações, como rastreamento de acessórios espaciais, atualizações de entidades e groupIDs para efeito de foco. Com esses novos recursos, ficou mais fácil desenvolver apps 3D com o RealityKit. Mal posso esperar para ver as experiências que você vai criar. Agradeço sua participação.