Transfert de votre projet SceneKit vers RealityKit

Bonjour, bienvenue dans cette séance. Je m’appelle Max Cobb et je suis ingénieur logiciel chez Apple. Commençons cette séance en faisant un petit saut dans le passé. Si vous êtes un développeur SceneKit, vous reconnaîtrez peut-être un exemple de jeu très amusant qu’Apple a partagé il y a plusieurs années. Dans ce projet, un panda roux, qui s’appelle aussi Max, évolue dans un environnement volcanique en résolvant des énigmes pour sauver ses amis, tout en affrontant des ennemis. Cet exemple a été construit avec un framework appelé SceneKit, qui permettait aux développeurs de créer des apps 3D natives sans avoir à inclure un moteur de jeu tiers complet dans leurs lots. SceneKit existe depuis de nombreuses années. En réalité depuis OS X Mountain Lion. Cela fait 13 ans. Beaucoup de choses ont changé dans l’écosystème des développeurs Apple depuis. De nouveaux paradigmes de programmation, de nouveaux matériels et de nouvelles plates-formes. Autrement dit, il y a eu un grand changement dans la manière dont les gens construisent et interagissent avec les apps. SceneKit a été conçu avec une architecture qui avait beaucoup de sens à l’époque. Mais à mesure que l’écosystème évoluait, il devenait très difficile de maintenir SceneKit à jour sans introduire de changements disruptifs pour les applications 3D existantes. C’est pourquoi, Apple met un terne officiellement SceneKit sur toutes les plates-formes.

Qu’est-ce que cela signifie pour les projets existants ? Mon app va-t-elle toujours fonctionner ? Dois-je la réécrire ? Que puis-je utiliser à la place ? Voyons en détail ce que cet abandon signifie pour les développeurs SceneKit. Laissez-moi clarifier un point : vous n’avez pas besoin de réécrire vos apps. Il s’agit d’un abandon en douceur, ce qui signifie que les applications existantes utilisant SceneKit continueront de fonctionner. Cependant, si vous prévoyez une nouvelle app ou une mise à jour majeure, SceneKit n’est pas recommandé.

Deuxièmement, SceneKit entre désormais en mode maintenance. Apple ne corrigera que les bugs critiques, donc ne vous attendez pas à de nouvelles fonctionnalités ou optimisations à l’avenir. À ce stade, aucun abandon définitif de SceneKit n’est prévu, et Apple avertira les développeurs si cela devait changer.

Si vous souhaitez utiliser la technologie de pointe d’Apple et la combinaison de matériel et de logiciels leader du marché, la meilleure option reste RealityKit.

RealityKit est un moteur 3D moderne, polyvalent et de haut niveau. À la fois puissant et accessible, il offre un accès aux normes du secteur et permet de créer des rendus magnifiques et réalistes avec de nombreuses fonctionnalités avancées qui peuvent vraiment faire briller votre app. Il s’agit de la technologie qui alimente de nombreuses apps tierces et fonctionnalités système, telles que Quick Look sur Mac, pour prévisualiser des modèles 3D en un clic. Les toutes nouvelles balises App Store sur iOS 26 sont l’un des grands changements pour rendre vos apps encore plus faciles à trouver. Les balises App Store ont des icônes 3D stylisées rendues avec RealityKit. Voici un exemple dans lequel l’App Store affiche une liste de jeux balisés pour leurs excellents graphismes 3D. Autre nouveauté sur iOS : Swift Charts utilise RealityKit pour offrir une troisième dimension aux visualisations de données.

RealityKit n’est pas seulement utilisé sur visionOS, il est la colonne vertébrale de cette plate-forme. Tout sur visionOS exploite RealityKit, y compris les boutons de vos applications et les fenêtres qui les abritent. RealityKit donne à votre app l’impression d’être réellement présente dans votre environnement réel.

RealityKit place également SwiftUI au premier plan, permettant ainsi aux développeurs SwiftUI de se sentir immédiatement à l’aise. Il est pris en charge sur : visionOS, iOS, macOS, iPadOS, et cette année, RealityKit arrive sur une nouvelle plate-forme : tvOS offre une nouvelle destination pour les apps et autres contenus construits avec RealityKit. Cette année encore, ce framework est enrichi de nouvelles fonctionnalités avancées et passionnantes. Pour en savoir plus, regardez « What’s New in RealityKit » de mon collègue Lawrence Wong. Aujourd’hui, je vais vous aider à comprendre comment RealityKit fonctionne par rapport à SceneKit, les différences, les nouvelles possibilités, et comment se lancer lorsqu’on vient de l’univers SceneKit. Je veux aussi moderniser mon jeu, le préparer aux fonctionnalités passionnantes à venir et aux plates-formes que je souhaite créer. Au cours de cette séance, j’expliquerai les principales étapes que j’ai suivies pour porter ce jeu SceneKit vers RealityKit. Le code source complet de ce projet est disponible pour téléchargement. Voici le programme. Je commencerai par expliquer les différences conceptuelles entre ces deux moteurs de rendu et comment interagir avec eux. Ensuite, aucun jeu 3D ne serait complet sans des ressources de qualité. J’explorerai les moyens de convertir des ressources SceneKit existantes au format privilégié par RealityKit. Je vous montrerai les outils permettant de composer des scènes RealityKit et commencerai à faire le parallèle entre les fonctionnalités de SceneKit et RealityKit, en commençant par les animations. Donner à ma scène un look stylé en ajoutant des lumières dynamiques, de l’immersion et de la personnalité, du son personnalisé, et finaliser avec des effets visuels, comme le post-traitement des particules. Tout ce dont j’ai besoin pour porter un jeu comme le mien de SceneKit à RealityKit. Plongeons dans le vif du sujet. En termes de concepts, je vais me concentrer sur quatre domaines clés : architecture, systèmes de coordonnées, ressources et vues. Commençons par l’architecture, SceneKit est basé sur un système de nœuds. Cela signifie que chaque objet dans la scène est un nœud, et ces nœuds ont des comportements prédéfinis sous forme de propriétés.

Chaque nœud possède des propriétés pour les fonctionnalités, notamment la géométrie, les animations, l’audio, la physique et les lumières.

Par exemple, lorsque je crée un nœud vide, il ne possède ni géométrie ni propriétés spéciales, et est positionné à l’origine de son parent.

Si je veux afficher Max dans mon jeu, je peux assigner son modèle à la propriété geometry d’un nœud.

Quand Max se déplace dans la scène, l’app assigne un lecteur d’animation au nœud et le lit.

Les bruits de pas que vous entendez proviennent d’un lecteur audio, également assigné au même nœud.

C’est ainsi que fonctionne une architecture basée sur les nœuds. Tout tourne autour du nœud et de ses propriétés. En revanche, RealityKit utilise un modèle de conception appelé Entity Component System ou ECS. Cela signifie que chaque objet dans la scène est une Entité, et que son comportement est modifié en lui attachant des composants. Dans RealityKit, chaque comportement est un composant.

De sa transformation aux comportements avancés, tels que la physique, les particules et même les portails, la liste des composants ne cesse de s’allonger à mesure que RealityKit évolue. Les nouveaux composants cette année incluent des composants de présentation d’image et de geste. Ce sont les différences architecturales à garder à l’esprit lorsque vous portez des apps SceneKit vers RealityKit. Passons maintenant à un point plus simple. Lorsqu’on adopte un nouveau moteur de rendu, il est essentiel de comprendre le système de coordonnées.

Les systèmes de coordonnées sont faciles à traduire entre SceneKit et RealityKit, car ils sont identiques. Dans les deux systèmes, l’axe X pointe vers la droite, l’axe Y pointe vers le haut, et l’axe Z est dirigé vers la caméra.

Concernant les ressources, SceneKit est flexible dans les formats de modèles qu’il accepte, et le moteur les sérialise en fichiers SCN. C’est pratique, mais ce n’est pas une norme unifiée dans le secteur. La plupart de ces formats sont propriétaires, avec un support de fonctionnalités variable, ce qui apporte une complexité supplémentaire aux pipelines de ressources.

RealityKit, en revanche, est conçu autour d’une norme ouverte du secteur appelé Universal Scene Description ou USD.

Ce format a été introduit par Pixar en 2012 pour résoudre plusieurs difficultés dans le pipeline de création de ressources, dont l’échange de données et la collaboration. C’est la norme privilégiée par Apple sur toutes ses plates-formes. Je vais devoir convertir certains fichiers SCN en USD pour mon jeu. Je vais détailler tout cela dans un instant. Avant cela, la dernière différence fondamentale que je veux souligner concerne les vues. Les vues sont des blocs de construction essentiels qui représentent une partie de l’interface utilisateur d’une app. Dans le cas de SceneKit et RealityKit, il s’agit d’une fenêtre qui rend du contenu 3D.

Avec SceneKit, je peux afficher du contenu via un SCNView, ou un SceneView si j’utilise SwiftUI. Il existe aussi ARSCNView, qui permet de rendre des objets virtuels dans le monde réel avec ARKit. Avec RealityKit, c’est plus simple : le contenu est rendu via un RealityView, conçu dès le départ pour offrir toutes les commodités auxquelles nous sommes habitués avec SwiftUI. Je peux rendre des scènes entièrement virtuelles ou placer des objets dans le monde réel avec cette seule vue. Le même contenu se déploie et s’adapte sur toutes les plates-formes Apple prises en charge, et effectue même automatiquement un rendu stéréoscopique sur visionOS, sans aucun changement de code. Très bien, ce sont les principaux concepts à garder à l’esprit lors de la transition vers RealityKit : architecture, systèmes de coordonnées, support de ressources et vues. Ensuite, chaque grand jeu doit avoir de superbes ressources. Voyons ce que j’ai actuellement dans mon jeu. Dans le catalogue de ressources graphiques, j’ai une collection de modèles 3D. Ces modèles sont au format SCN. C’est parfait pour un projet SceneKit, mais je dois convertir toutes ces ressources en USD pour pouvoir les utiliser dans RealityKit. Je vais vous montrer quelques options. Si vous avez les modèles dans leur format d’origine, c’est la meilleure option. Il y a de fortes chances que votre outil de création de contenu numérique ou DCC offre un bon support pour USD. J’utilise Blender, donc je peux exporter la ressource directement dans ce format.

Mais si vous n’avez pas les fichiers d’origine, il existe quelques autres options pour convertir directement une ressource SCN en USD. Une méthode, probablement la plus simple, est directement dans Xcode. Pour ce faire, sélectionnez une ressource. Je vais choisir enemy1 cette fois-ci. Puis, allez dans File, Export..., et dans les options d’exportation, choisissez un package Universal Scene Description, qui est un type de fichier USD compressé.

Les résultats de cette exportation peuvent varier selon les ressources, mais pour la plupart des modèles de mon jeu, cela fonctionne très bien. Vous pourriez aussi avoir des animations dans des fichiers SCN séparés, ce qui est une pratique courante dans SceneKit. Par exemple, dans mon jeu SceneKit, les animations du personnage principal, marcher, sauter et tourner, sont chacune dans des fichiers séparés, sans géométrie. Mais comment exporter ces animations en USD et les appliquer à la géométrie ? Eh bien, heureusement, Apple a mis à jour un outil CLI fourni avec Xcode 26, appelé outil SCN, pour faciliter ce processus. Je vais vous montrer comment l’utiliser. Je peux exécuter l’outil SCN en saisissant xcrun scntool.

Cela affiche une liste d’options disponibles. Pour convertir, je peux saisir xcrun scntool --convert en spécifiant le fichier max.scn dans ce cas. Et --format usdz comme format de sortie. Cette commande seule convertirait le fichier SCN en USD, de la même manière que je l’ai fait plus tôt dans Xcode. Pour ajouter l’animation, j’utilise --append-animation pour chaque fichier d’animation SCN que je souhaite exporter, max_spin dans ce cas.

Et je sauvegarde sur le bureau.

Voyons le fichier converti.

Parfait, ma géométrie contient maintenant les informations d’animation au format USD. J’ai fait cela pour toutes mes ressources et les ai organisées de manière à correspondre à mon processus préféré. Je suis maintenant prêt à assembler mon jeu. Ce qui m’amène au prochain sujet : la composition de scène. Dans la version SceneKit, l’éditeur SceneKit dans Xcode m’a aidé à assembler tous les éléments. RealityKit propose aussi un outil pour cela : Reality Composer Pro. Reality Composer Pro se situe entre Xcode et mon DCC préféré, comme Blender ou Maya. Je peux l’utiliser pour composer ma scène, ajouter des composants aux entités, créer et modifier des shaders, et préparer la scène pour Xcode. Je peux importer toutes mes nouvelles ressources USD et commencer à reconstruire mon jeu. Reality Composer Pro est fourni avec Xcode. Je vais l’ouvrir maintenant.

Je vais créer mon projet sous le nom PyroPanda.

Reality Composer Pro me donne une scène par défaut, sans contenu. Ensuite, je peux glisser-déposer toutes ces ressources nouvellement converties dans mon projet.

Pour ajouter ces ressources à ma scène, je peux soit faire un clic droit et choisir Add to Scene.

Soit glisser une ressource, comme Max, depuis le navigateur de projet directement dans la fenêtre.

Une fois en place, repositionner les entités est simple. Je peux utiliser ce gadget pour placer Max au point de départ du jeu. Plus ou moins là. Reality Composer Pro est un excellent outil pour composer ma scène de manière visuelle, me permettant de modifier les matériaux, les shaders, les particules, les lumières, et bien plus encore. Souvenez-vous, j’ai dit que Reality Composer Pro se situait entre mon outil de création de contenu numérique et Xcode ? Eh bien, maintenant, je dois intégrer le contenu dans mon app. C’est la prochaine étape. Le projet Reality Composer Pro est un package Swift. Je peux l’ajouter en tant que dépendance locale dans Xcode en accédant à mes dépendances de package de projet ici, en cliquant sur Add Local... et en choisissant mon app comme cible.

Ensuite, dans mon fichier ContentView.swift, je dois importer RealityKit et mon nouveau package, PyroPanda, en haut du fichier.

Dans mon ContentView, j’ajouterai un RealityView.

Puis, je dois charger la scène en tant qu’entité, en précisant qu’elle provient du lot de ce package.

Enfin, j’ajoute la nouvelle entité au contenu de RealityView.

Je vais aussi ajouter un contrôle de caméra juste pour voir le résultat.

J’ai passé du temps plus tôt à assembler la scène avec Reality Composer Pro. Voici le résultat final. J’ai ajouté les modèles restants, attribué les textures et créé les shaders dynamiques pour la lave, les plantes et l’un des ennemis, ajoutant plus de personnalité à l’environnement volcanique. Vous pouvez consulter le code source complet pour voir comment chaque élément de cette scène a été construit. Il y a tellement de choses que vous pouvez faire avec Reality Composer Pro. Pour en savoir plus, je vous recommande de consulter l’une de ces deux séances précédentes de la WWDC. Cela commence à prendre forme. Maintenant, je vais donner vie à Max avec des animations. Lorsque j’ai converti Max plus tôt, j’ai aussi ajouté une animation. Quand un fichier USD contient des animations, RealityKit les expose via un AnimationLibraryComponent. Cela permet d’accéder facilement aux animations et de les jouer sur mes entités. Je référence toutes les animations à partir d’un unique fichier USD appelé « Max ». Dans Reality Composer Pro, je peux voir les références à toutes les animations dans l’inspecteur ici.

Je peux déclencher chaque animation dans mon projet en utilisant le nom spécifié dans ce composant.

Dans la version SceneKit de ce jeu, voici comment je jouais l’animation de rotation. Tout d’abord, j’ai trouvé le Max_rootNode dans ma scène et j’ai chargé séparément l’animation spinAnimation. Ensuite, j’ai parcouru la scène d’animation jusqu’à ce que je trouve le lecteur d’animation SCN et que je lui enregistre une référence. Enfin, j’ai ajouté l’animationPlayer à Max, avec la référence « spin », et j’ai joué l’animation sur le nœud. Dans RealityKit, l’accès à l’animation via AnimationLibraryComponent est beaucoup plus simple. D’abord, je trouve l’entité Max par son nom, simplement « Max » dans ce cas. Ensuite, je récupère l’AnimationLibraryComponent depuis l’ensemble des composants de Max, et je sélectionne l’animation souhaitée par son nom. Enfin, je la joue sur l’entité. Lorsque Max se déplace dans la scène, mon app complète joue différentes animations qui représentent ses mouvements. Consultez le code source de l’app pour voir comment tout cela est lié. L’éclairage est un élément qui ajoute du réalisme et de l’ambiance à n’importe quelle scène. Et lorsqu’il est bien appliqué, la différence peut être radicale. L’éclairage dans mon application peut être entièrement géré via Reality Composer Pro, sans aucun code supplémentaire. Voyons à quoi cela ressemble. Je peux ajouter une lumière en appuyant sur l’icône d’insertion ici, en bas de ma hiérarchie d’entités, et en sélectionnant une lumière directionnelle.

Il s’agit d’une entité vide avec uniquement un composant de lumière directionnelle. Pour ce type de lumière, seule son orientation affecte la manière dont elle illumine les autres entités dans la scène.

Je vais la positionner ici, juste pour plus de clarté visuelle, et la faire pivoter autour de l’axe X comme ceci.

La lumière est bien, mais il manque quelque chose. Il n’y a pas d’ombres ! Dans la liste des composants, je peux aussi ajouter un composant d’ombres directionnelles en cochant cette case.

Depuis le point de départ, je peux maintenant voir comment le terrain et Max projettent des ombres sur le reste de la scène. La marche à suivre pour obtenir le même résultat via du code est très similaire. Pour SceneKit, je crée un SCNLight, je définis son type sur directionnel et j’active castShadow. Ensuite, je crée un nouveau nœud et j’assigne la lumière à la propriété light du nœud.

Pour RealityKit, je crée une entité avec deux composants : un composant de lumière directionnelle et un composant d’ombres directionnelles. Une lumière directionnelle est l’une des options d’éclairage disponibles dans RealityKit. Les autres incluent les lumières ponctuelles, les projecteurs, et les lumières basées sur des images, qui utilisent des textures pour illuminer votre scène. À présent, mon jeu a l’air un peu plus dynamique d’un point de vue visuel, alors j’ajoute quelques éléments sonores pour intensifier un peu plus l’engagement. Intéressons-nous à la musique d’ambiance qui tourne en boucle dans la scène. Dans mon projet SceneKit, je commence par charger le fichier audio d’ambiance en tant que source audio. Je peux ensuite modifier les propriétés de cette source audio pour changer la façon dont elle est jouée. Dans ce cas, je veux qu’elle boucle, et je ne veux pas qu’elle soit positionnelle ou spatiale, c’est-à-dire que le volume de lecture ne doit pas changer en fonction de la distance entre la caméra principale et le nœud source. Enfin, j’ajoute un lecteur audio au nœud du terrain, et je démarre la lecture. Dans RealityKit, je peux accéder aux fichiers audio de la même manière que j’accède aux animations : via des composants. Le composant utilisé ici s’appelle AudioLibraryComponent. Je peux configurer entièrement la lecture audio depuis Reality Composer Pro, plutôt que de tout gérer à l’exécution de mon app. Voyons à quoi ressemble cette configuration. J’ai déjà attaché un AudioLibraryComponent à l’entité terrain, avec une référence au fichier audio d’ambiance. Comme je ne veux pas que la lecture provienne d’une source spécifique, je peux ajouter un composant audio d’ambiance à la même entité.

Ce fichier audio est assez long, et par défaut, RealityKit va précharger toute la piste en mémoire à l’exécution. Au lieu de cela, je peux modifier ce comportement pour diffuser la ressource audio au fur et à mesure de sa lecture.

Et lorsque la piste se termine, je veux que la lecture recommence depuis le début, donc je vais cocher la case Loop.

Tout est maintenant configuré, et l’audio est prêt à être joué dans RealityKit. Pour ce faire, deux méthodes s’offrent à vous. La première via AudioLibraryComponent.

Je commence par récupérer AudioLibraryComponent depuis l’ensemble des composants du terrain, puis je référence l’audio d’ambiance par son nom et je le joue sur la même entité terrain. RealityKit prend en compte les paramètres que j’ai ajoutés avec Reality Composer Pro, donc il bouclera et diffusera automatiquement l’audio en tant que piste d’ambiance. De la même façon, je peux utiliser une astuce avec une action d’entité intégrée appelée PlayAudioAction.

Avec cette approche, PlayAudioAction va chercher dans l’AudioLibraryComponent de l’entité cible et trouver le fichier audio nommé.

Je convertis cette action en animation et je la joue sur la même entité terrain.

Les actions d’entité sont très utiles pour minimiser le code dans mon application.

J’utilise cette action et d’autres pour différents événements dans mon jeu. Par exemple, chaque fois que le personnage principal saute ou attaque.

Pour la dernière étape de cette séance, voyons les effets visuels inclus dans mon jeu. Les effets visuels peuvent transformer une scène 3D d’un rendu précis en une expérience immersive. Commençons par les particules. J’ai de superbes effets de particules qui ont été créés pour le jeu original, dans l’éditeur SceneKit de Xcode. Ces particules sont enregistrées sous forme de fichiers SCN de particules. Il n’existe aucun outil permettant de convertir directement ces fichiers en un format compatible avec RealityKit, mais je peux recréer des effets de particules avec des paramètres similaires via Reality Composer Pro. Passons à Reality Composer Pro et découvrons comment éditer des particules. Je préfère garder mes particules sous forme de fichiers USD séparés, donc je peux ajouter un nouveau fichier en cliquant ici dans Reality Composer Pro. Je vais le nommer volcano_smoke.

Je peux ajouter un composant de générateur de particules directement à l’entité racine de ce fichier.

Ensuite, en appuyant sur le bouton Play au-dessus des composants, les particules par défaut commencent à apparaître.

Je peux choisir parmi quelques préréglages, dont l’un de mes préférés, Impact.

Ce préréglage de particules possède une bonne texture pour la fumée, donc c’est un excellent point de départ pour cet effet. Ces paramètres peuvent sembler familiers si vous venez de SceneKit, avec quelques petites différences.

J’ai comparé les paramètres dans Reality Composer Pro avec ceux des particules de mon jeu original dans SceneKit, et j’ai créé un effet de fumée volcanique RealityKit similaire à la version SceneKit.

Une fois terminé, je vais glisser cet élément dans ma scène principale et voir comment il s’intègre avec les autres modèles.

Parfait, c’est exactement ce que je voulais obtenir. La dernière étape est le post-traitement. C’est ici que vous pouvez ajouter les touches finales avec un dernier passage sur le rendu avant qu’il apparaisse dans votre app.

Dans le jeu original, la caméra avait un fort effet bloom, faisant en sorte que les lumières vives se diffusent dans le reste de la scène, ajoutant une lueur douce et rayonnante qui renforce l’atmosphère surnaturelle du jeu.

Cela a été réalisé en modifiant quelques propriétés sur la caméra active de la scène. Bien que cela soit pratique, les développeurs, et surtout les développeurs de jeux, préfèrent souvent avoir un contrôle précis sur ces effets, à la fois pour des raisons de performance et de préférences artistiques.

Mais qu’en est-il de RealityKit ?

Bien qu’une propriété simple permettant de créer cet effet ne soit volontairement pas disponible dans RealityKit, à partir de cette année, vous pouvez ajouter des effets de post-traitement à des RealityViews sur iOS, iPadOS, macOS et tvOS.

Cela nécessite une certaine configuration, mais cela ne veut pas dire que vous devez forcément écrire tous les shaders Metal à partir de zéro. Apple propose des shaders Metal aux performances très optimisées que vous pouvez utiliser pour démarrer. Je vais créer un effet bloom en utilisant l’API de post-traitement, que je peux ajouter à mon jeu. À partir de la texture d’origine de mon jeu, je souhaite extraire les reflets et les écrire dans une texture distincte. Je les floute ensuite pour adoucir les contours, et enfin, je superpose cette texture floutée à l’originale pour créer l’effet bloom.

Pour faire ça dans mon app, je dois d’abord définir un type BloomPostProcess conforme à PostProcessEffect.

Dans la méthode postProcess, je crée une texture temporaire Metal pour y écrire certaines données bloom. Ensuite, j’utilise un shader de performance pour extraire uniquement les parties les plus lumineuses de l’image, là où l’effet bloom doit apparaître. Je floute cette zone à l’aide d’un flou gaussien. Et enfin, je superpose cette image floutée sur la texture originale. Le code complet de ces étapes est disponible dans le téléchargement fourni.

Pour appliquer cet effet à mon RealityView, je crée une instance de ma classe BloomPostProcess et je l’applique aux effets de rendu.

Cela ajoute une belle touche finale à mon jeu. L’environnement devient plus éclatant et offre une expérience de jeu vraiment incroyable. Mon app est désormais bien aboutie grâce à RealityKit. Elle fonctionne exactement de la même façon sur iOS, iPadOS, macOS et tvOS. Avec une seule base de code et une scène RealityKit, je peux lancer mon app sur toutes ces plates-formes immédiatement. Voici ce jeu exécuté sur la dernière plate-forme RealityKit : tvOS, avec prise en charge des manettes.

Je peux désormais jouer à mon jeu RealityKit sur Apple TV, chez moi.

Et sur visionOS, je peux faire quelque chose d’encore plus spécial. En plaçant ma scène dans une vue d’immersion progressive, je peux ajouter un portail vers le monde de PyroPanda, rendu en 3D complète juste devant moi.

Ce type d’expérience est uniquement possible avec RealityKit et visionOS.

Voyons ce que nous avons abordé aujourd’hui. SceneKit est désormais obsolète. Mais même si c’est important, cela ne veut pas dire que vous devez vous inquiéter pour vos applications existantes basées sur SceneKit. La meilleure voie à suivre, c’est RealityKit, qui ouvre des possibilités uniques pour vos apps et jeux. J’ai détaillé les principales différences conceptuelles et les outils disponibles pour les développeurs RealityKit, ainsi que les étapes majeures de la migration d’un jeu de SceneKit vers RealityKit.

Je vous encourage à consulter ces séances pour vous aider à créer des apps et jeux incroyables avec RealityKit, ainsi que d’autres séances des années précédentes et la documentation RealityKit. Le téléchargement de cet exemple d’app contient encore plus de détails sur des sujets que je n’ai pas eu le temps d’aborder aujourd’hui, comme le mouvement de la caméra, le déplacement des personnages et les manettes de jeu. La technologie évolue sans cesse. Apple souhaite que l’abandon de SceneKit se passe le plus facilement possible pour les développeurs comme vous. Nous sommes très enthousiastes pour l’avenir de RealityKit, et impatients de voir ce que les développeurs SceneKit vont en faire. Merci d’avoir regardé, et profitez bien du reste de la conférence.