WWDC Quick Look 💓 By SwiftGGTeam
中文 EN 日本語
Supercharge your spatial workflows with Reality Composer Pro 3

Supercharge your spatial workflows with Reality Composer Pro 3

Reality Composer ProAnimation GraphBehavior TreeScript GraphCompute GraphNavigation Mesh
Watch original video

Highlight

Reality Composer Pro 3 adds five major visual tools: Animation Graph, Behavior Tree, Script Graph, Compute Graph, and Navigation Mesh. Together, they let you complete character animation blending, autonomous behavior definition, interaction logic, particle effects, and scene navigation directly in the editor, so you can build full spatial scenes without writing code.

Core Ideas

In the early days of visionOS development, making an NPC patrol a scene autonomously and respond to interactions was a tedious process. Developers had to write a large amount of Swift code in Xcode: manually controlling animation transitions with RealityKit APIs, implementing pathfinding logic, writing particle system code, and rebuilding and deploying to the device every time a parameter changed. Artists and designers could only describe what they wanted; they could not directly participate in iteration.

Reality Composer Pro 3 moves all of these capabilities into the visual editor. Animation Graph uses node connections instead of code to blend animations; Behavior Tree defines multi-step character behavior; Script Graph handles interaction events; Compute Graph runs particle simulation on the GPU; Navigation Mesh automatically calculates walkable paths. All of this can be previewed in real time on the Mac and tested directly in space through Live Preview after putting on Vision Pro.

This workflow shift lets non-programmers participate in building spatial scenes. Designers can adjust an NPC’s patrol route directly, artists can tune particle effects for data or ambience, and the overall iteration process no longer requires programmer involvement for every change.

Details

Animation Graph: Visual Control for Animation Blending

(02:10)

Animation Graph is a node-based animation editor for controlling a character’s runtime animation. It supports advanced features such as motion retargeting, blend spaces, and inverse kinematics.

The alchemist character needs to switch between idle and walk animations. Building this state machine in Animation Graph involves several steps:

  1. Create a State Machine node and connect it to the Final Pose node
  2. Add two Animation State nodes inside the state machine, named Idle and Walk
  3. Create transitions from Idle to Walk and from Walk to Idle, and add conditions to each transition
  4. Add a Boolean parameter named isWalking in the Inputs Inspector and use it as the transition condition
  5. Connect Animation Clip nodes to both animation states and assign the corresponding animation clips

During testing, you can switch the isWalking parameter directly in the editor, and the character transitions smoothly between the two animations. This visual debugging approach is much more intuitive than setting breakpoints in code and observing animation state.

Behavior Tree: Defining Autonomous Behavior

(06:28)

Behavior Tree is a new behavior editor in Reality Composer Pro 3 for building multi-step autonomous behavior. It consists of two categories of nodes: Composite nodes control flow, while Action nodes perform concrete tasks.

There are three types of Composite nodes:

  • Sequence: Executes child nodes in order and stops when any child fails
  • Selector: Executes child nodes in order and stops when one succeeds
  • Parallel: Executes all child nodes at the same time

Common Action nodes include:

  • Move To: Move to a specified location
  • Rotate To Face: Rotate toward a target direction
  • Wait: Wait for a specified duration
  • Parameter Setter: Modify entity parameters

The alchemist’s patrol route can be built like this: use a Sequence node containing Rotate To Face, Move To, and Wait actions, then add Parameter Setter nodes before and after Move To to control the isWalking parameter and keep animation synchronized with behavior.

Script Graph: Adding Interaction Logic

(11:14)

Script Graph is an event-driven visual scripting system. It responds to scene-level or entity-level events and defines interactions between entities.

To make the alchemist respond to tap interactions, modify the Behavior Tree by adding a Precondition to the cauldron sub-sequence and binding it to the readyToBrew Boolean parameter. This keeps the character waiting by the table until the parameter becomes true.

Then, in Script Graph:

  1. Add an On Tap node to listen for the tap gesture
  2. Add a Set Entity Parameter node
  3. Set the parameter name to readyToBrew and the value to true
  4. Connect the event output of On Tap to Set Entity Parameter

With Reality Composer Pro 3’s Live Preview, you can test this interaction directly on Apple Vision Pro. After tapping the character, it immediately turns toward the cauldron and starts brewing.

(14:52)

The Navigation Mesh component defines the walkable surfaces in a scene. Navigation Controller uses that mesh to calculate a path for a character from one point to another, automatically avoiding obstacles such as trees and puddles.

Navigation Mesh configuration has three parts:

  • Shapes: Defines the bounding boxes used to generate the mesh
  • Off-Mesh Connections: Manually connects disconnected regions, such as climbing a ladder to a roof
  • Generation Parameters: Controls geometric sampling precision; for example, a smaller cell size captures more detail

After setup, Behavior Tree, Animation Graph, or custom Swift systems can all use the Navigation Component to let characters navigate the scene autonomously.

Compute Graph: GPU Particle Simulation

(17:13)

Compute Graph is a Metal-based visual particle editor. It runs particle simulation on the GPU and gives full control over particle generation, evolution, and rendering.

Compute Graph is divided into four stages:

  • Emitter: Controls when particles are produced, whether continuously, in bursts, or one time
  • Initialize: Sets initial particle values such as velocity, lifetime, and size
  • Simulate: Applies forces such as gravity and turbulence each frame to evolve particle state
  • Output: Controls visual appearance such as color and opacity

The cauldron smoke effect is implemented like this:

  1. Use a Continuous Emit node in the Emitter stage for continuous emission
  2. Randomize size and lifetime in the Initialize stage, and use Spawn in Sphere to distribute particles inside a spherical volume
  3. Apply negative gravity in the Simulate stage so the smoke rises
  4. In the Output stage, fade particles in and out over their lifetime and change color based on height

Rendering uses a Shader Graph material and draws circular billboards to create a rounded smoke appearance.

Shader Graph Enhancements

(19:43)

Reality Composer Pro 3’s Shader Graph adds several features:

  • Subsurface Scattering: Improves realism for translucent materials
  • RealityKit PBR Surface 2: Adds surface properties such as sheen and subsurface scattering, improving diffuse and occlusion shading
  • Hair Surface: A shader dedicated to hair and fur
  • Portal Surface and Portal Geometry Modifier: Modify per-pixel transparency on portal surfaces and drive vertex animation

Key Takeaways

Build an Interactive Scene Guide

What to build: When a user taps an exhibit, a virtual guide automatically walks to the exhibit and begins explaining it.

Why it is worth building: Navigation Mesh lets the character avoid obstacles in complex scenes, Behavior Tree manages multi-step patrol routes, and Script Graph responds to user taps.

How to start: Create a Navigation Mesh that covers the whole exhibition hall, define a sequence of Move To nodes in Behavior Tree, and trigger behavior with the On Tap node in Script Graph.

Build a Dynamic Weather System

What to build: Rain and snow change over time, with particle intensity and wind direction adjusted dynamically.

Why it is worth building: Compute Graph can simulate tens of thousands of particles on the GPU, and Script Graph can dynamically adjust emission rate and wind force based on time parameters.

How to start: Create rain and snow particle systems with Compute Graph, expose an emission rate parameter in the Emitter stage, and modify that parameter through Script Graph based on game time.

Develop a Virtual Pet Companion

What to build: A virtual character that follows the user, responds to petting gestures, and expresses emotions.

Why it is worth building: Animation Graph blends multiple emotional animations, Behavior Tree defines transitions among following, waiting, and playing, and Script Graph handles gesture interactions.

How to start: Prepare idle, walk, and happy animation sets, switch them with an Animation Graph state machine, and use a Behavior Tree Selector node to choose whether to follow or wait based on distance.

Prototype an Interactive Game

What to build: A playable mini-game prototype completed in RCP3 without writing code.

Why it is worth building: Script Graph’s event system and built-in game nodes can handle game logic such as collisions, scoring, and state saving.

How to start: Follow the session “Design No-Code Games with Reality Composer Pro 3” and build a complete game loop with Script Graph.

Create an Immersive Performance

What to build: Multiple characters perform complex scripted action sequences, with synchronized lighting and particle effects.

Why it is worth building: Sequencer can coordinate scene events, Animation Graph controls character performances, and Compute Graph provides stage effects.

How to start: Create independent Animation Graphs and Behavior Trees for each character, use Script Graph to trigger the beginning of the performance, and synchronize lighting and particles through Sequencer.

Comments

GitHub Issues · utterances