Scene Graph

The core organizing principle. Objects (nodes) are arranged in a parent-child tree. Transformations applied to a parent node (e.g., position, rotation, scale) are inherited by all its children. This allows complex, articulated objects (like a robot arm) to be modeled efficiently: rotating the 'shoulder' joint automatically moves the connected 'elbow' and 'wrist'.

The graph enables efficient visibility determination. By traversing the hierarchy and testing bounding volumes attached to nodes, the engine can quickly cull entire branches of objects that are outside the camera's view frustum, saving significant rendering resources. It also centrally manages render state (e.g., active shader, material) for all objects in the scene.

A scene graph contains heterogeneous node types, each serving a distinct purpose:

• Geometry Nodes: Hold mesh data and materials.
• Light Nodes: Define point, directional, or spot lights.
• Camera Nodes: Define viewports and projection.
• Transform Nodes: Group other nodes for hierarchical movement.
• Group Nodes: Logical collections without inherent transformation. Modern engines often implement this as an Entity Component System (ECS) where nodes are entities decorated with component data.

The engine renders the scene by traversing the graph, typically in a depth-first order. This traversal determines the draw order. Techniques like painter's algorithm (drawing back-to-front for transparency) or z-buffering rely on a systematic walk of the graph. The traversal is also when world-space transformations are calculated by concatenating parent matrices down the tree.

Beyond rendering, the scene graph acts as the spatial backbone for other simulation systems. Physics engines attach collision shapes and rigid bodies to graph nodes. Animation systems drive node transformations. AI navigation systems use the graph for spatial reasoning. In a robotics simulation, a single 'Robot' node hierarchy would be manipulated by rendering, physics, and control systems simultaneously.

To optimize memory, scene graphs support instancing. A single geometry definition (e.g., a tree model) can be referenced by multiple nodes in the graph, each with its own transform. This allows a forest to be rendered with minimal GPU memory overhead. Shared resources like materials, textures, and shaders are also managed through the graph's resource system.

In engines like Unity and Unreal Engine, the scene graph is the primary data structure for the Editor Hierarchy and World Outliner. Every object—a GameObject or Actor—is a node. Transformations are inherited: a 'Character' node's position is relative to its parent 'Room' node, which is relative to the 'Level' root. This enables:

• Efficient culling: The engine can discard entire branches of the graph outside the camera's frustum.
• Simplified animation: Applying a rotation to a 'Turret' node automatically rotates all child 'Barrel' and 'Sight' nodes.
• Modular prefab instantiation: A complex asset (e.g., a vehicle) is a reusable sub-graph.

Physics-based simulators for robotics use scene graphs to model the kinematic tree of a robot and its environment. Each link and joint of a robot arm is a node in a parent-child chain, defining the forward kinematics. The scene graph manages:

• Coordinate frames: The pose of a robot's end-effector is calculated by concatenating transformations up the tree from the base link.
• Sensor attachment: A camera or LiDAR sensor node is a child of a specific link, moving with it.
• Dynamic object spawning: Training environments use the graph to procedurally add and remove obstacles, with physics properties attached as node data.

In WebGL frameworks like Three.js, the scene graph is explicitly constructed using THREE.Object3D as the base node class. Developers build a tree of Mesh, Light, and Camera objects. Key patterns include:

• Grouping: Empty Object3D nodes act as pivot points to transform collections of meshes together.
• Scene graph traversal: The renderer recursively visits each node, applying its local matrix to the global world matrix before rendering.
• Raycasting: Picking a 3D object on screen uses the graph hierarchy to efficiently test for intersections from the camera's perspective.

Computer-Aided Design (CAD) systems and Digital Twin platforms use scene graphs to manage complex assemblies with thousands of parts. A car's digital twin, for instance, is a hierarchy: Car Body > Door Assembly > Window Regulator > Bolt. This supports:

• Selective rendering: Isolating a specific sub-system for inspection by rendering only that branch.
• Bill of Materials (BOM) generation: Traversing the graph enumerates all component nodes.
• Configuration management: Swapping alternative part sub-graphs based on product variant.
• State propagation: Changing a property (e.g., color) on a parent 'Interior' node can apply to all child 'Seat' and 'Dashboard' nodes.

AR/VR runtimes (e.g., ARKit, OpenXR) rely on scene graphs to fuse the virtual and real. The graph's root is often tied to a world tracking origin. Key uses include:

• Anchoring: Virtual objects are attached as child nodes to real-world anchors or feature points, ensuring they persist in the correct physical location.
• Spatial audio: An audio emitter's node position in the graph determines its 3D sound propagation.
• Interaction handling: A controller or hand-tracking node's transform is updated each frame; collision detection with virtual object nodes is computed within the graph's coordinate space.

High-end rendering and animation pipelines use sophisticated scene description formats that are inherently graph-based. Universal Scene Description (USD) by Pixar is a prime example, providing a compositional scene graph where layers of data (animation, shading, geometry) can be overlaid. This enables:

• Non-destructive workflows: A lighting artist can author a 'lights' layer as a separate sub-graph that references the base geometry.
• Collaborative parallel authoring: Different teams can work on different branches of the same scene graph simultaneously.
• Extreme instancing: A single 'Tree' node can be instanced thousands of times with different transformations, minimizing memory usage.

A data-oriented software architectural pattern that separates entities (unique IDs), components (pure data), and systems (logic). It contrasts with the object-oriented hierarchy of a traditional scene graph by prioritizing cache efficiency and scalability for massive numbers of objects, making it common in high-performance game engines and simulations.

A tree data structure used to accelerate spatial queries. Unlike a scene graph which defines logical and renderable hierarchy, a BVH organizes objects based on their spatial bounds (e.g., Axis-Aligned Bounding Boxes).

• Primary Use: Drastically speeds up ray tracing intersection tests and broad-phase collision detection.
• Relationship: A renderer often builds a BVH from the current scene graph's spatial data to optimize rendering and physics.

A template and instantiation mechanism for reusable object configurations. A Prefab defines a hierarchy of components, transforms, and properties that can be instantiated multiple times within a scene graph.

• Function: Encapsulates complex object definitions (e.g., a robotic arm with sensors).
• Workflow: Designers create a Prefab; the engine instantiates it as a subtree in the runtime scene graph, enabling efficient asset management and level design.

The sequence of processing stages that converts a 3D scene description into a final 2D image. The scene graph serves as the primary data source for the render pipeline.

• Stages Include: Culling, sorting, vertex processing, lighting, rasterization, and post-processing.
• Integration: The renderer traverses the scene graph, extracting visible meshes, materials, and transform matrices to feed into the pipeline stages.

The core mathematical structure within a scene graph that defines spatial relationships. Each node has a local transform (position, rotation, scale) relative to its parent.

• Key Mechanism: World-space transforms are computed by concatenating parent transforms down the tree. Moving a parent node automatically affects all its children.
• Foundation: This hierarchy enables efficient manipulation of complex assemblies, like a robot where moving the base repositions the entire arm.

Performance optimization techniques that rely on the scene graph's spatial organization.

• Frustum Culling: Uses the graph's bounding volumes to discard objects outside the camera's view.
• LOD Systems: Store multiple geometry versions of a model within a node. The renderer switches between them based on distance, which is efficiently calculated using the node's world transform from the scene graph.