View in English

  • Apple Developer
    • Get Started

    Explore Get Started

    • Overview
    • Learn
    • Apple Developer Program

    Stay Updated

    • Latest News
    • Hello Developer
    • Platforms

    Explore Platforms

    • Apple Platforms
    • iOS
    • iPadOS
    • macOS
    • tvOS
    • visionOS
    • watchOS
    • App Store

    Featured

    • Design
    • Distribution
    • Games
    • Accessories
    • Web
    • Home
    • CarPlay
    • Technologies

    Explore Technologies

    • Overview
    • Xcode
    • Swift
    • SwiftUI

    Featured

    • Accessibility
    • App Intents
    • Apple Intelligence
    • Games
    • Machine Learning & AI
    • Security
    • Xcode Cloud
    • Community

    Explore Community

    • Overview
    • Meet with Apple events
    • Community-driven events
    • Developer Forums
    • Open Source

    Featured

    • WWDC
    • Swift Student Challenge
    • Developer Stories
    • App Store Awards
    • Apple Design Awards
    • Apple Developer Centers
    • Documentation

    Explore Documentation

    • Documentation Library
    • Technology Overviews
    • Sample Code
    • Human Interface Guidelines
    • Videos

    Release Notes

    • Featured Updates
    • iOS
    • iPadOS
    • macOS
    • watchOS
    • visionOS
    • tvOS
    • Xcode
    • Downloads

    Explore Downloads

    • All Downloads
    • Operating Systems
    • Applications
    • Design Resources

    Featured

    • Xcode
    • TestFlight
    • Fonts
    • SF Symbols
    • Icon Composer
    • Support

    Explore Support

    • Overview
    • Help Guides
    • Developer Forums
    • Feedback Assistant
    • Contact Us

    Featured

    • Account Help
    • App Review Guidelines
    • App Store Connect Help
    • Upcoming Requirements
    • Agreements and Guidelines
    • System Status
  • Quick Links

    • Events
    • News
    • Forums
    • Sample Code
    • Videos
 

Vidéos

Ouvrir le menu Fermer le menu
  • Collections
  • Toutes les vidéos
  • À propos

Plus de vidéos

  • À propos
  • Résumé
  • Code
  • Quoi de neuf dans RealityKit

    Laissez libre cours à votre créativité avec les nouvelles fonctionnalités de RealityKit qui peuvent vous aider à créer du contenu 3D riche pour iOS, iPadOS, macOS, tvOS et visionOS. Découvrez comment accéder aux données ARKit directement via RealityKit. Découvrez comment interagir plus naturellement avec vos contenus 3D grâce à la fonctionnalité de manipulation d'objets. Découvrez de nouvelles API pour la compréhension de scène, la fusion d'environnement, l'instanciation et bien plus encore, le tout à l'aide d'un échantillon interactif.

    Chapitres

    • 0:00 - Introduction
    • 3:19 - Mises à jour de l’ancrage
    • 6:52 - ManipulationComponent
    • 10:01 - Compréhension de la scène
    • 11:18 - EnvironmentBlendingComponent
    • 12:26 - MeshInstancesComponent
    • 16:28 - Médias immersifs
    • 21:43 - Accessoires et autres

    Ressources

    • Integrating virtual objects with your environment
    • Presenting images in RealityKit
    • Playing immersive media with RealityKit
      • Vidéo HD
      • Vidéo SD

    Vidéos connexes

    WWDC25

    • Explorer les entrées d’accessoires spatiaux sur visionOS
    • Mieux ensemble : SwiftUI et RealityKit
    • Prise en charge de la lecture vidéo immersive dans les apps visionOS
  • Rechercher dans cette vidéo…
    • 4:33 - Set up SpatialTrackingSession

      // Set up SpatialTrackingSession
      @State var spatialTrackingSession = SpatialTrackingSession()
      
      RealityView { content in
                   
          let configuration = SpatialTrackingSession.Configuration(
              tracking: [.plane]
          )
      		// Run the configuration
          if let unavailableCapabilities = await spatialTrackingSession.run(configuration) {
              // Handle errors
          }
      }
    • 4:34 - Set up PlaneAnchor

      // Set up PlaneAnchor
      RealityView { content in
      
      		// Set up the SpatialTrackingSession
      
          // Add a PlaneAnchor
          let planeAnchor = AnchorEntity(.plane(.horizontal,
                                                classification: .table,
                                                minimumBounds: [0.15, 0.15]))
          content.add(planeAnchor)
      }
    • 5:48 - Handle DidAnchor event

      // Handle DidAnchor event
      
      		didAnchor = content.subscribe(to: AnchorStateEvents.DidAnchor.self) { event in
      
      		guard let anchorComponent =
                 event.entity.components[ARKitAnchorComponent.self] else { return }
      
      
      		guard let planeAnchor = anchorComponent.anchor as? PlaneAnchor else { return }
      
      		let worldSpaceFromExtent =
          planeAnchor.originFromAnchorTransform *
          planeAnchor.geometry.extent.anchorFromExtentTransform
      
          gameRoot.transform = Transform(matrix: worldSpaceFromExtent)
      
          // Add game objects to gameRoot 
      }
    • 7:38 - Set up ManipulationComponent

      // Set up ManipulationComponent
      extension Entity {
          static func loadModelAndSetUp(modelName: String,
                                        in bundle: Bundle) async throws -> Entity {
      
              let entity = // Load model and assign PhysicsBodyComponent
              let shapes = // Generate convex shape that fits the entity model
      
              // Initialize manipulation
              ManipulationComponent.configureEntity(entity, collisionShapes: [shapes])
              var manipulationComponent = ManipulationComponent()
              manipulationComponent.releaseBehavior = .stay
              entity.components.set(manipulationComponent)
      
              // Continue entity set up
          }
      }
    • 9:28 - Subscribe to willBegin ManipulationEvent

      // Subscribe to ManipulationEvents
      
      // Update the PhysicsBodyComponent to support movement
      willBegin = content.subscribe(to: ManipulationEvents.WillBegin.self) { event in
          if var physicsBody = event.entity.components[PhysicsBodyComponent.self] {
              physicsBody.mode = .kinematic
              event.entity.components.set(physicsBody)
          }
      }
    • 9:29 - Subscribe to willEnd ManipulationEvent

      // Subscribe to ManipulationEvents
                      
      // Update the PhysicsBodyComponent to be a dynamic object
      willEnd = content.subscribe(to: ManipulationEvents.WillEnd.self) { event in
          if var physicsBody = event.entity.components[PhysicsBodyComponent.self] {
              physicsBody.mode = .dynamic
              event.entity.components.set(physicsBody)
          }
      }
    • 10:52 - Set up Scene understanding mesh collision and physics​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​

      // Set up Scene understanding mesh collision/physics
      
      let configuration = SpatialTrackingSession.Configuration(
          tracking: [.plane],
          sceneUnderstanding: [.collision, .physics]
      )
    • 11:56 - Set up EnvironmentBlendingComponent

      // Set up EnvironmentBlendingComponent
      
      entity.components.set(
          EnvironmentBlendingComponent(preferredBlendingMode: .occluded(by: .surroundings))​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​
      )
    • 14:20 - Set up MeshInstancesComponent

      // Set up MeshInstancesComponent entity
      
      let entity = try await ModelEntity(named:"PebbleStriped.usdz")
      var meshInstancesComponent = MeshInstancesComponent()
      let instances = try LowLevelInstanceData(instanceCount: 20)
      meshInstancesComponent[partIndex: 0] = instances
          
      instances.withMutableTransforms { transforms in
          for i in 0..<20 { 
              let scale: Float = .random(in:0.018...0.025)
              let angle: Float = .random(in:0..<2) * .pi
              let position = randomPoint(in: inArea, with: scene)
              let transform = Transform(scale: .init(repeating: scale),
                                        rotation: .init(angle: angle,axis: [0, 1, 0]),
                                        translation: position)
              transforms[i] = transform.matrix
          }
      }
              
      entity.components.set(meshInstancesComponent)
    • 17:36 - Load and display a 2D photo

      // Load and display a 2D photo
          
      guard let url = Bundle.main.url(forResource: "my2DPhoto", withExtension: "heic") else {a​​​​​​​​​​​​​​​​​​​​​​​​​​
          return
      }
      
      let component = try await ImagePresentationComponent(contentsOf: url)
      
      let entity = Entity()
      entity.components.set(component)
    • 17:57 - Load and display a spatial photo with windowed presentation

      // Load and display a spatial photo with windowed presentation
          
      guard let url = Bundle.main.url(forResource: "mySpatialPhoto", withExtension: "heic") else {
          return
      }
      
      var component = try await ImagePresentationComponent(contentsOf: url)
      
      // Discover if the component supports windowed spatial photo presentation.
      if component.availableViewingModes.contains(.spatialStereo) {
          component.desiredViewingMode = .spatialStereo
      }
      
      entity.components.set(component)
    • 18:22 - Load and display a spatial photo with immserive presentation

      // Load and display a spatial photo with immersive presentation
          
      guard let url = Bundle.main.url(forResource: "mySpatialPhoto", withExtension: "heic") else {
          return
      }
      
      var component = try await ImagePresentationComponent(contentsOf: url)
      
      // Discover if the component supports immersive spatial photo presentation.
      if component.availableViewingModes.contains(.spatialStereoImmersive) {
          component.desiredViewingMode = .spatialStereoImmersive
      }
      
      entity.components.set(component)
    • 18:56 - Load a spatial photo and use it to generate and present a spatial scene

      // Load a spatial photo and use it to generate and present a spatial scene
          
      guard let url = Bundle.main.url(forResource: "mySpatialPhoto", withExtension: "heic") else {
          return
      }
      
      let spatial3DImage = try await ImagePresentationComponent.Spatial3DImage(contentsOf: url)
      var component = ImagePresentationComponent(spatial3DImage: spatial3DImage)
      
      try await spatial3DImage.generate()
      
      // Discover if the component supports windowed spatial scene presentation.
      if component.availableViewingModes.contains(.spatial3D) {
          component.desiredViewingMode = .spatial3D
      }
      
      entity.components.set(component)
    • 20:06 - Generating a spatial scene as needed

      // Load a spatial photo and use it to generate and present a spatial scene
          
      guard let url = Bundle.main.url(forResource: "mySpatialPhoto", withExtension: "heic") else {
          return
      }
      
      let spatial3DImage = try await ImagePresentationComponent.Spatial3DImage(contentsOf: url)
      var component = ImagePresentationComponent(spatial3DImage: spatial3DImage)
      
      component.desiredViewingMode = .spatial3D // (or .spatial3DImmersive)
      
      entity.components.set(component)
      
      try await spatial3DImage.generate()
    • 23:35 - Load entity from Data object​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​​

      // Load entity from Data object
          
      if let (data, response) = try? await URLSession.shared.data(from: url) {
          if let entity = try? await Entity(from: data) {
              content.add(entity)
          }
      }
    • 0:00 - Introduction
    • Le framework RealityKit, lancé en 2019, permet aux développeurs de créer des apps et des jeux 3D immersifs sur différentes plateformes Apple, notamment visionOS, iOS, iPadOS, macOS et désormais tvOS. Suite aux retours, notre dernière version apporte plusieurs nouveautés intéressantes : un accès direct aux données ARKit, un « ManipulationComponent » permettant d’interagir avec les objets 3D, un « EnvironmentBlendingComponent » pour une meilleure fusion avec le monde réel, et un « MeshInstancesComponent » qui optimise l’affichage de multiples modèles 3D. Ces fonctionnalités sont mises en valeur dans un jeu de puzzle en réalité augmentée où les joueurs manipulent des objets pour ouvrir un coffre mystérieux. Vous verrez ainsi comment RealityKit permet de créer une expérience fluide entre le monde virtuel et réel.

    • 3:19 - Mises à jour de l’ancrage
    • Grâce à cette nouvelle API, vous pouvez accéder directement aux données ARKit via RealityKit, ce qui améliore la puissance des « AnchorEntities ». Grâce à la création d’une « SpatialTrackingSession » avec le suivi de plan activé, vous pouvez configurer des « AnchorEntities » pour filtrer des surfaces spécifiques du monde réel, telles que des tables avec des dimensions minimales. Lorsque le système détecte une surface correspondante, il déclenche un « AnchorStateEvent » pour fournir des données ARKit telles que la transformation et l’étendue. Ces données peuvent ensuite être utilisées pour positionner avec précision les entités sur la surface ancrée, en veillant à ce qu’elles soient centrées et alignées par rapport au spectateur.

    • 6:52 - ManipulationComponent
    • Dans l’espace immersif, les objets du jeu apparaissent sur les surfaces appropriées. Le « ManipulationComponent » de RealityKit permet aux utilisateurs de saisir, de faire pivoter et d’échanger ces entités 3D entre leurs mains. L’appel de la fonction « configureEntity » ajoute automatiquement les composants nécessaires. Pour éviter que les objets ne soient réinitialisés après leur libération, définissez la propriété « releaseBehavior » sur « stay ». Un « PhysicsBodyComponent » ajouté permet aux objets de tomber au sol. L’API « ManipulationEvents » est utilisée pour activer et désactiver la gravité ; la gravité est activée lorsque quelqu’un relâche un objet (évènement « WillEnd ») et désactivée lorsqu’il est ramassé (évènement « WillBegin »), ce qui permet des interactions réalistes tout en gardant le contrôle pendant la manipulation.

    • 10:01 - Compréhension de la scène
    • Dans visionOS, grâce à l’API Scene Understanding de RealityKit, vous pouvez intégrer l’environnement réel dans la simulation physique d’un jeu. L’API « SpatialTrackingSession » vous permet de générer un maillage de l’environnement. Pour que les objets du jeu puissent entrer en collision avec ce maillage du monde réel, les indicateurs « SceneUnderstandingFlags » pour la collision et la physique doivent être définis dans la configuration « SpatialTrackingSession » avant de démarrer la session. Cette mise à jour permet aux objets du jeu d’interagir de manière réaliste avec l’environnement physique, par exemple en les laissant tomber sur des tables ou sur le sol.

    • 11:18 - EnvironmentBlendingComponent
    • Avec la dernière mise à jour de RealityKit, vous pouvez utiliser « EnvironmentBlendingComponent » dans vos apps d’espace immersif pour occulter des entités virtuelles avec l’environnement réel. Lorsque vous ajoutez ce composant et définissez le mode de fusion, les entités peuvent être occultées de manière réaliste par des objets statiques du monde réel et créer ainsi une expérience plus fluide. Toutefois, vous devez savoir que ces entités sont toujours dessinées derrière les autres objets virtuels de la scène et ne seront pas occultées par des objets dynamiques en mouvement, tels que des personnes ou des animaux domestiques.

    • 12:26 - MeshInstancesComponent
    • La dernière mise à jour de RealityKit intègre également le « MeshInstancesComponent », qui améliore l’efficacité du rendu en vous permettant de dessiner plusieurs fois un même maillage dans une entité. Ce nouveau composant remplace le clonage d’entités, ce qui réduit considérablement l’empreinte mémoire et le temps de traitement. « MeshInstancesComponent » vous permet de fournir une liste de transformations pour chaque instance de maillage, ce qui permet d’obtenir des apparences uniques grâce à « CustomMaterials » sur les plateformes prises en charge. Cette méthode améliore les performances en optimisant le transfert de données GPU. Lorsque vous utilisez ce composant pour de grandes zones, divisez-le en entités plus petites afin d’assurer une élimination appropriée. Vous trouverez une démonstration de la manière d’initialiser et de remplir le « MeshInstancesComponent » avec des transformations aléatoires, afin de créer une zone jouable avec des décorations. Ces différentes API, comprenant AnchorStateEvent, ManipulationComponent, les indicateurs sceneUnderstanding et EnvironmentBlendingComponent, travaillent ensemble pour offrir des expériences en réalité augmentée à la fois immersives et naturelles.

    • 16:28 - Médias immersifs
    • RealityKit s’enrichit cette année de nouvelles fonctionnalités majeures qui optimisent le traitement des contenus immersifs. Grâce à un nouveau composant, « ImagePresentationComponent », vous pouvez afficher trois types d’images : les images 2D traditionnelles, les photos spatiales et les scènes spatiales. Les vues spatiales apportent vraiment quelque chose de spécial. En fait, ce sont des rendus en 3D créés à partir de simples photos en 2D. Ils ont un effet de diorama avec un effet de profondeur quand on bouge, ce qui donne vraiment vie aux images fixes. Pour créer ces vues spatiales, il vous suffit de prendre une photo ou une image 2D, de la convertir avec la classe « Spatial3DImage » et de définir le mode d’affichage souhaité. Le « VideoPlayerComponent » a également été mis à jour afin de prendre en charge divers formats vidéo immersifs, notamment les vidéos spatiales, les vidéos Apple Projected Media Profile telles que les vidéos 180° et 360°, ainsi que les vidéos Apple Immersive Video. Vous pouvez lire ces vidéos dans différents modes d’affichage et configurer les paramètres de confort pour les vidéos Apple Projected Media Profile.

    • 21:43 - Accessoires et autres
    • La mise à jour RealityKit de cette année améliore considérablement le développement d’apps 3D. Les principales mises à jour sont les suivantes. Accessoires spatiaux : RealityKit prend désormais en charge le suivi des accessoires spatiaux dans six degrés de liberté avec fonctionnalités haptiques, pour des interactions plus immersives dans le Shared et le Full Space. Intégration SwiftUI : de nouveaux composants, tels que « ViewAttachmentComponent », « PresentationComponent » et « GestureComponent » simplifient l’ajout de vues SwiftUI, de présentations modales et de gestes aux entités. Mises à jour des entités : une nouvelle méthode d’attachement d’entités simplifie l’attachement de maillages à des squelettes animés, et un initialiseur permet de charger des entités à partir d’objets de données en mémoire, prenant en charge les scènes en ligne et le streaming USD. Prise en charge des textures et des effets de survol : RealityKit prend désormais en charge les textures encodées AVIF pour réduire la taille des fichiers sans compromettre la qualité. Le « HoverEffectComponent » a été mis à jour avec des « GroupID », ce qui permet un meilleur contrôle de l’activation des effets de survol. Effets de post-traitement : « RealityViews » prend désormais en charge les effets de post-traitement. Cette fonction vous permet donc d’ajouter des effets personnalisés, tels que le bloom à l’aide de Metal Performance Shaders, « CIFilter » ou des shaders personnalisés, sur iOS, iPadOS, macOS et tvOS.

Developer Footer

  • Vidéos
  • WWDC25
  • Quoi de neuf dans RealityKit
  • Open Menu Close Menu
    • iOS
    • iPadOS
    • macOS
    • tvOS
    • visionOS
    • watchOS
    • App Store
    Open Menu Close Menu
    • Swift
    • SwiftUI
    • Swift Playground
    • TestFlight
    • Xcode
    • Xcode Cloud
    • Icon Composer
    • SF Symbols
    Open Menu Close Menu
    • Accessibility
    • Accessories
    • Apple Intelligence
    • Audio & Video
    • Augmented Reality
    • Business
    • Design
    • Distribution
    • Education
    • Games
    • Health & Fitness
    • In-App Purchase
    • Localization
    • Maps & Location
    • Machine Learning & AI
    • Security
    • Safari & Web
    Open Menu Close Menu
    • Documentation
    • Downloads
    • Sample Code
    • Videos
    Open Menu Close Menu
    • Help Guides & Articles
    • Contact Us
    • Forums
    • Feedback & Bug Reporting
    • System Status
    Open Menu Close Menu
    • Apple Developer
    • App Store Connect
    • Certificates, IDs, & Profiles
    • Feedback Assistant
    Open Menu Close Menu
    • Apple Developer Program
    • Apple Developer Enterprise Program
    • App Store Small Business Program
    • MFi Program
    • Mini Apps Partner Program
    • News Partner Program
    • Video Partner Program
    • Security Bounty Program
    • Security Research Device Program
    Open Menu Close Menu
    • Meet with Apple
    • Apple Developer Centers
    • App Store Awards
    • Apple Design Awards
    • Apple Developer Academies
    • WWDC
    Read the latest news.
    Get the Apple Developer app.
    Copyright © 2026 Apple Inc. All rights reserved.
    Terms of Use Privacy Policy Agreements and Guidelines