Quoi de neuf dans RealityKit

Bonjour, je m’appelle Laurence, ingénieur logiciel de l’équipe RealityKit. Bienvenue dans ma session « Nouveautés de RealityKit ». Dans cette session, je vais présenter des nouvelles fonctionnalités RealityKit qui seront disponibles cette année.

Nous avons lancé RealityKit en 2019 afin de vous permettre d’intégrer du contenu 3D dans vos apps, pour un rendu réaliste et une expérience immersive enrichie. Depuis, nous avons reçu beaucoup de feedback, ce qui nous a aidés chaque année à améliorer ce framework. RealityKit offre de nombreuses fonctionnalités permettant à votre contenu 3D de s’intégrer de manière transparente à l’environnement réel, pour créer des apps et des jeux immersifs sur visionOS. En plus de visionOS, RealityKit apporte également de nombreuses fonctionnalités clés dans iOS, iPadOS et macOS. Les capacités multiplateformes de RealityKit permettent d’écrire votre app une seule fois et de la déployer sur de nombreuses plates-formes, en modifiant le code juste un minimum. Cette année, je suis ravi d’annoncer que RealityKit est désormais pris en charge sur la dernière version de tvOS. Vous pouvez désormais transférer vos apps et expériences existantes sur Apple TV ou en créer pour le grand écran. RealityKit est pris en charge sur toutes les générations d’Apple TV 4K. La mise à jour RealityKit de cette année apporte de nombreuses nouvelles fonctionnalités qui facilitent plus que jamais la création d’expériences 3D mêlant le monde virtuel et le monde réel. Durant cette session, je vais présenter certaines de ces fonctionnalités, telles que ManipulationComponent, EnvironmentBlendingComponent, MeshInstancesComponent et bien d’autres. J’utiliserai certaines de ces fonctionnalités pour créer un jeu de puzzle spatial. Le jeu commence par un coffre verrouillé ancré à une surface devant vous. Autour de ce coffre, vous trouverez plusieurs objets avec lesquels vous pouvez interagir. La clé qui permet d’ouvrir le coffre est fixée en dessous de l’un de ces objets. Vous devez saisir et inspecter les objets pour trouver lequel a la clé. Une fois que vous avez la clé, vous pouvez ouvrir le coffre et découvrir votre récompense :

un petit feu d’artifice !

Tout d’abord, je vais utiliser la nouvelle prise en charge native d’ARKit dans RealityKit pour ancrer des modèles dans l’espace devant le joueur et gérer les changements de cycle de vie des ancrages. Ensuite, je vais montrer comment utiliser le nouveau ManipulationComponent pour ajouter des interactions aux entités 3D d’une scène. Je vais utiliser un PhysicsBodyComponent pour qu’elles tombent de manière réaliste lorsqu’elles sont relâchées. Ensuite, j’utiliserai les nouvelles API SceneUnderstanding pour que les entités du jeu entrent en collision avec notre maillage de compréhension de la scène.

Après, j’utiliserai EnvironmentBlendingComponent pour permettre à l’app de mieux se mêler au monde réel.

Puis, je vais montrer comment utiliser le nouveau MeshInstancesComponent pour dessiner efficacement plusieurs instances d’un modèle 3D à utiliser pour décorer ma scène. Après, nous verrons des nouvelles mises à jour intéressantes sur les médias immersifs. J’aborderai également d’autres annonces, telles que les accessoires spatiaux, les mises à jour des entités, et bien plus. Je commence par ancrer des modèles 3D dans l’environnement réel avec une nouvelle API qui permet d’accéder directement aux données ARKit via RealityKit. J’utiliserai une AnchorEntity RealityKit pour positionner mon jeu sur une table. Les entités d’ancrage permettent de fixer du contenu virtuel à des surfaces du monde réel. Cette année, nous améliorons les AnchorEntities en exposant directement les données d’ancrage ARKit. Je vais vous montrer comment ça fonctionne. Pour accéder directement aux données ARKit via RealityKit, vous devez d’abord créer une SpatialTrackingSession. La configuration de la session indiquera à RealityKit d’envoyer les nouveaux AnchorStateEvents à votre app quand l’état des AnchorEntities change. Vous pouvez ensuite configurer une AnchorEntity pour filtrer les propriétés de l’ancrage que vous recherchez. Dans mon app, je souhaite rechercher une table avec des dimensions spécifiques. Quand RealityKit a trouvé l’ancrage qui correspond le mieux aux propriétés définies dans AnchorEntity, il déclenche un AnchorStateEvent. Cette instance AnchorStateEvent contient des données ARKit comme la transformation et l’étendue de l’ancrage, que j’utilise pour positionner mon jeu. Voyons cela dans le code. Je vais d’abord créer une SpatialTrackingSession pour suivre les RealityKit AnchorEntities dans l’environnement. Pour mon jeu, je dois suivre un plan afin de faire apparaître le coffre au trésor. Je vais donc configurer une SpatialTrackingSession avec le suivi de plan activé.

Je peux alors démarrer la session de suivi en exécutant la configuration que je viens de créer. Ensuite, je peux générer une entité AnchorEntity pour positionner facilement mon jeu sur la table. Je vais classer l’AnchorEntity comme une table qui doit être une surface horizontale avec une limite minimale de 15 cm carrés. Cette AnchorEntity commencera dans un état non ancré, mais sera ancrée lorsqu’un plan de table correspondant à la classification et aux limites fournies sera détecté. Pour recevoir des mises à jour lorsque l’état de l’ancrage change, j’utilise la nouvelle API AnchorStateEvents.

L’API AnchorStateEvents permet de s’abonner à des événements pour savoir quand des entités sont ancrées, si elles sont sur le point d’être désancrées ou si elles n’ont pas pu être ancrées. J’utilise l’événement DidAnchor dans mon app pour positionner les entités de mon jeu dans les limites de la surface de la table.

Dans mon code, j’ai ajouté un abonnement à l’événement DidAnchor pour savoir quand l’entité d’ancrage a été correctement ancrée à l’environnement. La structure de l’événement me fournit mon entité d’ancrage, qui a été mise à jour pour contenir le nouvel ARKitAnchorComponent. Ce composant contient des données ARKit comme les étendues et les transformations à utiliser pour positionner mes entités de jeu sur la surface ancrée. J’accède à ces données en utilisant la propriété d’ancrage de l’ARKitAnchorComponent.

Pour utiliser la propriété d’ancrage, je dois la convertir en type d’ancrage ARKit. Je vais essayer de la convertir en PlaneAnchor, car mon AnchorEntity est configurée pour rechercher des plans.

J’ai désormais accès aux données brutes pour les extensions et transformations ARKit pour l’ancrage. J’utiliserai les transformations ARKit, notamment originFromAnchorTransform et anchorFromExtentTransform, pour positionner mon jeu et m’assurer qu’il est centré sur la surface ancrée. Maintenant, lorsque j’ouvre l’espace immersif, les objets du jeu apparaissent dès qu’une surface appropriée est trouvée.

Ensuite, je vais ajouter des interactions à ma scène avec le nouveau ManipulationComponent dans RealityKit. ManipulationComponent simplifie le processus de saisie et de rotation des entités 3D dans votre scène. Il prend même en charge des gestes avancés, comme passer d’une main à l’autre.

Je vais utiliser ManipulationComponent pour permettre au joueur de saisir et de faire pivoter les objets du jeu afin de trouver la clé qui se trouve en dessous. Je vais vous montrer comment ajouter cette fonctionnalité au jeu, mais si vous souhaitez en savoir plus sur ManipulationComponent et ses possibilités, regardez la session « Better together: SwiftUI and RealityKit ». Pour saisir les entités et interagir avec elles, il vous suffit d’appeler la fonction configureEntity de ManipulationComponent. Cette fonction ajoutera automatiquement les composants InputTarget, Collision, HoverEffect et Manipulation nécessaires à l’entité. Et voilà ! Vous pouvez maintenant saisir et faire pivoter les entités avec vos mains. Cependant, vous remarquerez que les objets reviennent en douceur à leur emplacement d’origine lorsque vous les relâchez.

Je vais revenir à mon code et définir la propriété releaseBehavior sur ManipulationComponent pour qu’ils restent en place.

Je vais ensuite assigner cette instance manipulationComponent à mon entité. Cela empêchera l’objet de revenir automatiquement à sa position de départ lorsque je le relâche. Il restera immobile. Ensuite, je vais devoir le faire tomber au sol. Pour cela, je vais ajouter un PhysicsBodyComponent à mon entité. Je fais attention à activer la gravité sur PhysicsBodyComponent uniquement lorsque l’objet n’est pas pincé ni saisi. La nouvelle API ManipulationEvents facilite cette opération.

Les ManipulationEvents sont des événements de RealityKit qui décrivent les différents états d’interaction par lesquels passent les entités lorsque l’on interagit avec elles.

Par exemple, l’événement WillRelease sera déclenché lorsqu’une entité sera relâchée par le joueur. De même, il existe d’autres événements tels que WillBegin, WillEnd, DidUpdateTransform et DidHandOff. Consultez la documentation sur developer.apple.com pour plus de détails.

J’utiliserai les événements WillBegin et WillEnd pour m’assurer que les entités de mon jeu ne réagissent à la gravité que lorsque l’on n’interagit pas avec elles.

Je vais ajouter un abonnement à l’événement WillBegin afin de changer le mode physicsBodyComponent en kinematic pour empêcher le système physique d’interférer pendant que l’objet est déplacé. Ainsi, la gravité n’affectera pas l’entité.

Ensuite, j’ajoute un abonnement à l’événement WillEnd pour rétablir le mode dynamic du physicsBodyComponent, car il n’y a plus d’interaction avec l’entité. Cela permettra à l’entité de réagir aux autres objets physiques de la scène. Elle réagira aussi à la gravité. Maintenant que les objets du jeu réagissent aux éléments physiques, je veux qu’ils entrent en collision avec l’environnement du joueur. Pour cela, j’utilise la nouvelle API Scene Understanding qui ajoute le maillage de ma pièce à la simulation physique de l’app. Grâce à l’API SpatialTrackingSession, RealityKit est capable de générer un maillage de votre environnement. Ce maillage, appelé « maillage de compréhension de la scène », permet d’ajouter des collisions et des effets physiques aux objets réels de votre pièce.

Vous pouvez utiliser le maillage de compréhension de la scène de votre environnement réel en définissant les SceneUnderstandingFlags dans la configuration SpatialTrackingSession.

visionOS prend actuellement en charge les indicateurs de collision et physiques. J’utiliserai ces deux indicateurs pour que mes objets de jeu entrent en collision avec le maillage de compréhension de la scène. Je vais définir ces indicateurs dans la configuration SpatialTrackingSession avant de l’exécuter.

Pour cela, je dois mettre à jour la SpatialTrackingSession que j’ai configurée précédemment. Il suffit d’ajouter les indicateurs de collision et de compréhension de la scène physique à la configuration SpatialTrackingSession avant de démarrer la session. Désormais, le maillage de compréhension de la scène participera à la simulation physique du jeu et les objets du jeu entreront en collision avec l’environnement lorsque je les déposerai sur la table ou le sol. Maintenant que mon jeu peut interagir avec l’environnement, je souhaite qu’il réagisse aussi visuellement à celui-ci. Pour cela, je peux utiliser EnvironmentBlendingComponent. EnvironmentBlendingComponent est un nouveau composant conçu pour les apps spatiales immersives dans la mise à jour RealityKit de cette année.

Il permet de masquer des entités derrière des objets statiques du monde réel. Les entités dotées de ce composant sont masquées de manière réaliste, partiellement ou totalement, selon la partie de l’entité recouverte par un objet statique du monde réel. Les objets dynamiques en mouvement, comme les personnes et les animaux, n’occultent pas les objets dotés de ce composant.

Si je souhaite ajouter cette fonctionnalité, il suffit d’ajouter EnvironmentBlendingComponent et de définir son mode de fusion préféré pour qu’il soit occulté par l’environnement. À présent, si une entité dotée du composant EnvironmentBlendingComponent est positionnée derrière un objet réel, elle sera masquée par celui-ci. Les entités qui utilisent EnvironmentBlendingComponent sont considérées comme faisant partie de leur environnement d’arrière-plan et sont toujours dessinées derrière les autres objets virtuels de votre scène. Maintenant qu’EnvironmentBlendingComponent fonctionne, je peux ajouter quelques décorations à la zone de jeu environnante à l’aide du nouveau MeshInstancesComponent. L’année dernière, les API LowLevelMesh et LowLevelTexture ont été ajoutées à RealityKit afin d’offrir un contrôle accru sur vos données de rendu. Dans la mise à jour RealityKit de cette année, cet accès de bas niveau est étendu à un autre aspect du rendu : l’instanciation. Dans mon app, je souhaite décorer l’espace environnant et définir une zone jouable.

Je pourrais générer plusieurs entités en double pour décorer l’espace. Cependant, pour cela, je devrais cloner mon entité plusieurs fois, ce qui créerait de nombreuses copies de mon ModelComponent. Cela peut entraîner une forte consommation de la mémoire et des ressources. Il est plus efficace et pratique d’utiliser le nouveau composant MeshInstancesComponent.

MeshInstancesComponent permet de dessiner plusieurs fois un maillage avec une seule entité. Il suffit de fournir une liste de transformations pour dessiner le maillage. Sur iOS, iPadOS, macOS et tvOS, vous pouvez utiliser un LowLevelBuffer pour transmettre les données de rendu à CustomMaterial afin que chaque instance de maillage soit unique. En plus d’être pratique, MeshInstancesComponent peut également améliorer les performances en réduisant la quantité de données à envoyer au GPU. Au lieu d’envoyer plusieurs copies du modèle et des matériaux au GPU lors du dessin de maillages en double, MeshInstancesComponent n’envoie ces données qu’une seule fois.

Notez que les modèles dessinés avec un seul MeshInstancesComponent sont toujours considérés comme faisant partie d’une seule entité. Si vous utilisez ce composant pour couvrir une grande surface, il peut être judicieux de le diviser en plusieurs entités plus petites afin de permettre le culling. Voici comment utiliser MeshInstancesComponent dans le code. D’abord, j’ai besoin d’un maillage à instancier. Pour l’obtenir, je charge une entité à partir du bundle de contenu de l’app. Maintenant, je peux initialiser MeshInstancesComponent et l’objet LowLevelInstanceData. L’objet LowLevelInstanceData contient les données de chaque instance de maillage individuelle. Lorsque je crée un objet LowLevelInstanceData, je dois indiquer le nombre d’instances dont j’ai besoin pour mon app. Je vais utiliser 20 ici pour afficher une approximation de la zone de jeu sans la surcharger. Ensuite, je peux assigner l’objet LowLevelInstanceData au MeshInstancesComponent indexé par l’index de la partie du maillage que je souhaite instancier. Ici, je sais que le maillage que j’instancie est simple et ne comporte qu’une seule partie de maillage, je vais donc assigner LowLevelDataObject à partIndex : 0.

Je peux maintenant remplir l’objet LowLevelInstanceData avec les transformations pour chaque instance de maillage.

Pour avoir des décorations variées, je vais randomiser l’échelle, l’angle et la position de chacune de ces instances. Avec ces valeurs, je peux créer une matrice de transformation et l’attribuer à une instance.

Je peux maintenant ajouter meshInstancesComponent à mon entité qui sera donc chaque fois dessinée à l’aide des données MeshInstancesComponent.

Et maintenant... le jeu est terminé !

Vous pouvez lancer le jeu et l’ancrer à la surface devant vous. Vous pouvez saisir des objets et les faire pivoter dans la zone de jeu pour trouver la clé qui ouvre le coffre. Je vais récapituler les nouvelles API utilisées pour créer cette app. J’ai utilisé les nouvelles API AnchorStateEvent pour ancrer le contenu. J’ai ensuite utilisé ManipulationComponent pour permettre l’interaction avec les objets. J’ai utilisé les indicateurs de compréhension de la scène pour que les entités du jeu entrent en collision avec le maillage de compréhension de la scène. Enfin, j’ai utilisé EnvironmentBlendingComponent et MeshInstancesComponent pour que le jeu se mêle au monde réel. Je vais maintenant vous présenter d’autres fonctionnalités intéressantes ajoutées à RealityKit cette année, comme de nouveaux médias immersifs. Cette année, nous introduisons un tout nouveau composant appelé ImagePresentationComponent, pour présenter des images dans RealityKit. Il prend en charge trois types d’images : les images et photos 2D classiques, les photos spatiales, qui sont des photos stéréoscopiques prises avec l’iPhone ou Vision Pro, et les scènes spatiales, un nouveau type d’image 3D créée à partir d’une image ou d’une photo 2D existante.

Les scènes spatiales sont des images 3D avec une profondeur réelle, créée à partir d’une image 2D. Elles ressemblent à une version diorama d’une photo, avec une parallaxe de mouvement qui accentue la profondeur de la scène spatiale lorsque l’on bouge la tête en regardant la scène. Les scènes spatiales sont un excellent moyen de donner vie à vos photos 2D, à la fois dans l’app Photos sur visionOS et dans la vôtre, grâce à RealityKit. Je vais vous montrer le code permettant d’ajouter les trois types d’images à votre app. Je vais d’abord montrer comment présenter une image ou une photo 2D avec RealityKit.

Je vais rechercher l’URL d’une photo 2D, puis l’utiliser pour créer un composant de présentation d’image. L’initialiseur du composant est asynchrone, car le chargement de l’image en mémoire peut prendre un certain temps. Une fois le composant initialisé, je peux l’attribuer à une entité afin de l’afficher dans ma scène RealityKit.

Pour présenter des photos spatiales, il y a une étape de plus. Vous devrez attribuer un mode d’affichage souhaité au composant avant de le définir sur l’entité. Vous pouvez spécifier le mode d’affichage souhaité en vérifiant d’abord si votre image le prend en charge. Si vous ne spécifiez pas de mode d’affichage souhaité ou si votre image ne le prend pas en charge, ImagePresentationComponent présentera votre image en 2D ou en vision monoscopique, même s’il s’agit d’une photo spatiale. Pour activer la présentation immersive des photos spatiales, utilisez un mode d’affichage souhaité spatialStereoImmersive. Lorsqu’un composant de présentation d’images est créé à partir d’une photo spatiale, les deux modes stéréo spatiaux sont disponibles. Les images 2D et les photos spatiales sont chargées à partir d’un fichier sur un disque. L’affichage de cette image comme scène spatiale requiert des étapes supplémentaires, car nous devons générer la scène spatiale avant de pouvoir la présenter. Je vais montrer comment générer et présenter une scène spatiale dans le code.

Vous pouvez générer une scène spatiale à partir d’une image 2D ou d’une photo spatiale. Si vous générez une scène spatiale à partir d’une photo spatiale, seul l’un des canaux de la photo spatiale sera utilisé comme image 2D pour la conversion. Pour créer une scène spatiale, vous n’initialisez pas ImagePresentationComponent directement à partir de l’URL de l’image. Vous pouvez à la place créer une Spatial3DImage à partir de l’URL, puis utiliser l’image 3D spatiale pour initialiser ImagePresentationComponent. Cependant, le composant n’est pas encore prêt à être présenté sous forme de scène spatiale. Vous devez d’abord générer la scène.

Pour cela, nous appelons la méthode generate de l’image 3D spatiale. Cela génère la scène spatiale en quelques secondes. Une fois la génération effectuée, les availableViewingModes pour ImagePresentationComponent seront mis à jour pour inclure les modes spatial3D et spatial3DImmersive. Vous pouvez ensuite définir l’un d’eux comme mode d’affichage souhaité pour choisir entre une présentation dans une fenêtre ou immersive de la scène spatiale. Vous n’avez pas besoin de générer la scène spatiale à l’avance. Vous pouvez attendre que la personne qui utilise votre app appuie sur un bouton, comme dans l’app Photos. Le fait de définir le mode d’affichage souhaité du composant sur .spatial3D avant d’appeler generate indique au composant que vous souhaitez afficher la scène spatiale dès qu’elle est prête. Le composant affichera une animation de progression durant le processus de génération, puis affichera la scène spatiale dès que la génération est terminée. Voici un exemple de ce que cela donne sur Vision Pro. Le composant de présentation d’image affiche la même animation de génération que l’app Photos sur visionOS, et le résultat final est magnifique en 3D.

Voici un résumé rapide des différentes façons d’utiliser ImagePresentationComponent pour présenter une image 2D, une photo spatiale ou une scène spatiale. Pour en savoir plus sur ce composant, consultez les exemples de code « Presenting images in RealityKit » sur developer.apple.com.

Une autre mise à jour immersive lancée cette année concerne VideoPlayerComponent, qui a été mis à jour pour prendre en charge la lecture de nombreux formats vidéo immersifs. Il prend désormais en charge la lecture vidéo spatiale avec un style spatial complet, en mode portail et immersif.

Les vidéos Apple Projected Media Profile comme les vidéos à 180 et 360 degrés et à grand champ de vision sont aussi prises en charge. Il est aussi possible de configurer les réglages de confort sur les vidéos Apple Projected Media Profile, et RealityKit ajustera automatiquement la lecture en conséquence.

Ces formats vidéo, en plus d’Apple Immersive Video, peuvent être configurés pour être lus dans divers modes de visualisation. Pour en savoir plus sur ces mises à jour, regardez la session « Support immersive video playback in visionOS apps ».

Je vais maintenant aborder d’autres mises à jour de cette année. Je vais tout d’abord vous présenter le suivi des accessoires spatiaux. Ensuite, je passerai en revue les dernières mises à jour concernant l’intégration de SwiftUI et RealityKit. Après cela, je parlerai des nouvelles mises à jour des entités. Je présenterai la prise en charge des textures AVIF par RealityKit. Puis, je passerai à la nouvelle fonctionnalité d’effets de survol GroupID. Pour finir, j’évoquerai l’ajout d’effets de post-traitement à RealityViews. C’est parti. RealityKit prend désormais en charge le suivi des accessoires spatiaux qui permettent d’interagir avec vos apps dans Shared Space et Full Space. Vous pouvez suivre les accessoires spatiaux avec six degrés de liberté. Le retour haptique est aussi pris en charge pour de meilleures interactions dans vos apps et vos jeux. Pour en savoir plus sur l’ajout de la saisie par accessoires spatiaux dans vos apps, regardez la session « Explore spatial accessory input on visionOS ». Cette année, RealityKit introduit de tout nouveaux composants pour assurer une meilleure intégration de SwiftUI. ViewAttachmentComponent facilite considérablement l’ajout de vues SwiftUI directement à vos entités. De plus, PresentationComponent permet d’ajouter des fenêtres modales, comme des fenêtres contextuelles, à des entités, et le nouveau GestureComponent simplifie le processus d’ajout de gestes SwiftUI aux entités. Regardez la session « Better together: SwiftUI and RealityKit » pour en savoir plus sur les nouveautés concernant l’intégration de SwiftUI et RealityKit cette année.

Une nouvelle méthode d’attachement d’entité permet d’attacher une entité à l’épingle d’une autre entité. Cette API simplifie considérablement l’attachement de maillages aux articulations d’un squelette animé. Attacher des maillages de cette manière évite d’avoir à les aligner manuellement et vous dispense de mises à jour hiérarchiques coûteuses. De plus, un nouvel initialiseur Entity vous permet de charger des entités à partir d’objets Data en mémoire. Grâce à ce nouvel initialiseur, vous pouvez charger des scènes RealityKit ou des fichiers USD complets depuis une source en ligne ou les diffuser en streaming sur le réseau. Le nouvel initialiseur prend en charge les mêmes formats de fichiers que les initialiseurs d’entités existants.

De plus, RealityKit ajoute la prise en charge des textures encodées AVIF, dont la qualité est similaire au format JPEG avec une prise en charge des couleurs 10 bits, tout en étant nettement moins volumineuses. Vous pouvez utiliser l’app Preview sur votre Mac ou usdcrush dans le Terminal pour exporter des fichiers USD avec cette compression activée. De plus, HoverEffectComponent bénéficie d’une nouvelle fonctionnalité : GroupID. Les GroupID permettent de créer des associations entre les effets de survol. Tous les effets de survol qui partagent un GroupID partageront aussi leurs activations. En attribuant un GroupID aux effets de survol, vous contrôlez entièrement la manière dont un effet de survol est activé, indépendamment de sa hiérarchie relative. Normalement, les effets de survol sont appliqués de manière hiérarchique, comme dans l’exemple de gauche, où les entités enfants héritent des effets de leurs entités parents. Cependant, si une entité possède un GroupID comme les entités A et B dans l’exemple de droite, ses effets ne se propageront pas à ses enfants.

Autre nouveauté intéressante cette année, la prise en charge des effets de post-traitement dans RealityView. Vous pouvez utiliser l’API customPostProcessing pour ajouter des effets personnalisés, tels que le bloom, à vos apps à l’aide de Metal Performance Shaders, CIFilters ou vos shaders. Cette API est prise en charge sur iOS, iPadOS, macOS et tvOS.

La mise à jour RealityKit de cette année vise à faciliter plus que jamais la création d’expériences 3D avec RealityKit. J’ai expliqué comment créer un jeu de puzzle spatial qui utilise certaines nouvelles API RealityKit pour ancrer le jeu dans votre environnement et permettre des interactions intuitives avec les éléments du jeu. J’ai aussi parlé des mises à jour des médias immersifs qui permettent à vos apps d’afficher du contenu spatial directement dans RealityKit.

J’ai ensuite abordé d’autres mises à jour, comme le suivi des accessoires spatiaux, les mises à jour des entités et GroupID pour les effets de survol. Grâce à ces nouvelles fonctionnalités, il est très facile de créer des apps 3D avec RealityKit, et j’ai hâte de découvrir les expériences que vous allez imaginer. Merci de votre attention !