Struct Scene 

pub struct Scene {

    pub names: SecondaryMap<NodeHandle, Cow<'static, str>>,
    pub meshes: SparseSecondaryMap<NodeHandle, Mesh>,
    pub cameras: SparseSecondaryMap<NodeHandle, Camera>,
    pub lights: SparseSecondaryMap<NodeHandle, Light>,
    pub skins: SparseSecondaryMap<NodeHandle, SkinBinding>,
    pub morph_weights: SparseSecondaryMap<NodeHandle, Vec<f32>>,
    pub animation_mixers: SparseSecondaryMap<NodeHandle, AnimationMixer>,
    pub rest_transforms: SparseSecondaryMap<NodeHandle, Transform>,
    pub split_primitive_tags: SparseSecondaryMap<NodeHandle, SplitPrimitiveTag>,
    pub skeleton_pool: SlotMap<SkeletonKey, Skeleton>,
    pub environment: Environment,
    pub tone_mapping: ToneMappingSettings,
    pub bloom: BloomSettings,
    pub ssao: SsaoSettings,
    pub screen_space: ScreenSpaceSettings,
    pub background: BackgroundSettings,
    pub active_camera: Option<NodeHandle>,
    /* private fields */
}

The scene graph container.

Scene is the pure data layer that stores scene graph hierarchy and component data. Uses SlotMap + SecondaryMap for high-performance component-based storage.

Storage Layout

• nodes: Core node data (hierarchy and transforms) using SlotMap
• Dense components (names, meshes): Use SecondaryMap
• Sparse components (cameras, lights, skins): Use SparseSecondaryMap

Example

let mut scene = Scene::new();

// Create nodes
let root = scene.create_node_with_name("Root");
let child = scene.create_node_with_name("Child");
scene.attach(child, root);

// Add mesh component
scene.set_mesh(child, Mesh::new(geometry, material));

Fields

names: SecondaryMap<NodeHandle, Cow<'static, str>>

Node names - almost all nodes have a name

meshes: SparseSecondaryMap<NodeHandle, Mesh>

Mesh components stored directly on nodes

cameras: SparseSecondaryMap<NodeHandle, Camera>

Camera components stored directly on nodes

lights: SparseSecondaryMap<NodeHandle, Light>

Light components stored directly on nodes

skins: SparseSecondaryMap<NodeHandle, SkinBinding>

Skeletal skin bindings

morph_weights: SparseSecondaryMap<NodeHandle, Vec<f32>>

Morph target weights

animation_mixers: SparseSecondaryMap<NodeHandle, AnimationMixer>

Animation mixer components (sparse, only character roots have animations)

rest_transforms: SparseSecondaryMap<NodeHandle, Transform>

Rest pose transforms recorded before animation takes over. Used to restore nodes when animations stop or blend with weight < 1.0.

split_primitive_tags: SparseSecondaryMap<NodeHandle, SplitPrimitiveTag>

Split primitive tags

skeleton_pool: SlotMap<SkeletonKey, Skeleton>

Skeleton is a shared resource - multiple characters may reference the same skeleton definition

environment: Environment

Scene environment settings (skybox, IBL)

tone_mapping: ToneMappingSettings

Tone mapping settings (exposure, mode)

bloom: BloomSettings

Bloom post-processing settings

ssao: SsaoSettings

SSAO (Screen Space Ambient Occlusion) settings

screen_space: ScreenSpaceSettings

Screen space effects settings (SSS, SSR)

background: BackgroundSettings

Background rendering settings (mode + skybox uniform buffer)

active_camera: Option<NodeHandle>

Currently active camera for rendering

Implementations

impl Scene

pub fn new() -> Scene

pub fn id(&self) -> u32

Returns the unique scene identifier.

pub fn root_nodes(&self) -> &[NodeHandle]

Returns a read-only slice of root-level node handles.

pub fn push_root_node(&mut self, handle: NodeHandle)

Registers a node as a root-level node (no parent).

pub fn nodes(&self) -> &SlotMap<NodeHandle, Node>

Returns a read-only reference to the node storage.

pub fn create_node(&mut self) -> NodeHandle

Creates a new node and returns its handle.

pub fn create_node_with_name(&mut self, name: &str) -> NodeHandle

Creates a new node with a name.

pub fn add_node(&mut self, node: Node) -> NodeHandle

Adds a node to the scene (defaults to root level).

pub fn add_to_parent( &mut self, child: Node, parent_handle: NodeHandle, ) -> NodeHandle

Adds a node as a child of the specified parent.

pub fn remove_node(&mut self, handle: NodeHandle)

Removes a node and all its descendants recursively.

pub fn attach(&mut self, child_handle: NodeHandle, parent_handle: NodeHandle)

Attaches a node as a child of another (establishes parent-child relationship).

pub fn get_node(&self, handle: NodeHandle) -> Option<&Node>

Returns a read-only reference to a node.

pub fn get_node_mut(&mut self, handle: NodeHandle) -> Option<&mut Node>

Returns a mutable reference to a node.

pub fn set_name(&mut self, handle: NodeHandle, name: &str)

Sets the name for a node.

pub fn get_name(&self, handle: NodeHandle) -> Option<&str>

Returns the name of a node.

pub fn set_mesh(&mut self, handle: NodeHandle, mesh: Mesh)

Sets the mesh component for a node.

pub fn get_mesh(&self, handle: NodeHandle) -> Option<&Mesh>

Gets a reference to the node’s Mesh component

pub fn get_mesh_mut(&mut self, handle: NodeHandle) -> Option<&mut Mesh>

Gets a mutable reference to the node’s Mesh component

pub fn set_camera(&mut self, handle: NodeHandle, camera: Camera)

Sets the Camera component for a node

pub fn get_camera(&self, handle: NodeHandle) -> Option<&Camera>

Gets a reference to the node’s Camera component

pub fn get_camera_mut(&mut self, handle: NodeHandle) -> Option<&mut Camera>

Gets a mutable reference to the node’s Camera component

pub fn set_light(&mut self, handle: NodeHandle, light: Light)

Sets the Light component for a node

pub fn get_light(&self, handle: NodeHandle) -> Option<&Light>

Gets a reference to the node’s Light component

pub fn get_light_mut(&mut self, handle: NodeHandle) -> Option<&mut Light>

Gets a mutable reference to the node’s Light component

pub fn get_light_bundle( &mut self, handle: NodeHandle, ) -> Option<(&mut Light, &mut Node)>

Gets both the Light component and Transform for a node (for light processing)

pub fn bind_skeleton( &mut self, handle: NodeHandle, skeleton_key: SkeletonKey, bind_mode: BindMode, )

Binds a skeleton to a node

pub fn get_skin(&self, handle: NodeHandle) -> Option<&SkinBinding>

Gets the node’s skin binding

pub fn set_morph_weights(&mut self, handle: NodeHandle, weights: Vec<f32>)

Sets morph weights

pub fn get_morph_weights(&self, handle: NodeHandle) -> Option<&Vec<f32>>

Gets morph weights

pub fn get_morph_weights_mut( &mut self, handle: NodeHandle, ) -> Option<&mut Vec<f32>>

Gets a mutable reference to morph weights

pub fn set_morph_weights_from_pod( &mut self, handle: NodeHandle, data: &MorphWeightData, )

Sets morph weights for a node (from POD data)

pub fn iter_active_lights(&self) -> impl Iterator<Item = (&Light, &Affine3A)>

pub fn query_main_camera_bundle( &mut self, ) -> Option<(&mut Transform, &mut Camera)>

Gets the (Transform, Camera) bundle for the main camera

pub fn query_camera_bundle( &mut self, node_handle: NodeHandle, ) -> Option<(&mut Transform, &mut Camera)>

pub fn query_light_bundle( &mut self, node_handle: NodeHandle, ) -> Option<(&mut Transform, &Light)>

Queries the Transform and Light for a specified node

pub fn query_mesh_bundle( &mut self, node_handle: NodeHandle, ) -> Option<(&mut Transform, &Mesh)>

Queries the Transform and Mesh for a specified node

pub fn update_matrix_world(&mut self)

Updates world matrices for the entire scene

pub fn update_subtree(&mut self, root_handle: NodeHandle)

Updates world matrices for a specified subtree

pub fn add_mesh(&mut self, mesh: Mesh) -> NodeHandle

pub fn add_mesh_to_parent( &mut self, mesh: Mesh, parent: NodeHandle, ) -> NodeHandle

pub fn add_skeleton(&mut self, skeleton: Skeleton) -> SkeletonKey

pub fn add_camera(&mut self, camera: Camera) -> NodeHandle

pub fn add_camera_to_parent( &mut self, camera: Camera, parent: NodeHandle, ) -> NodeHandle

pub fn add_light(&mut self, light: Light) -> NodeHandle

pub fn add_light_to_parent( &mut self, light: Light, parent: NodeHandle, ) -> NodeHandle

pub fn mark_as_split_primitive(&mut self, handle: NodeHandle)

pub fn shader_defines(&self) -> &ShaderDefines

Computes the scene’s shader macro definitions

Uses internal caching mechanism, only recalculates when Environment version changes.

pub fn add_logic<L>(&mut self, logic: L)

where L: SceneLogic,

pub fn on_update<F>(&mut self, f: F)

where F: FnMut(&mut Scene, &Input, f32) + Send + Sync + 'static,

Shortcut method: Add closure logic (for quick prototyping)

pub fn update(&mut self, input: &Input, dt: f32)

Updates scene state (called every frame)

pub fn sync_gpu_buffers(&mut self)

Syncs GPU Buffer data

pub fn light_storage(&self) -> &CpuBuffer<Vec<GpuLightStorage>>

pub fn environment_uniforms(&self) -> &CpuBuffer<EnvironmentUniforms>

pub fn update_skeletons(&mut self)

pub fn sync_morph_weights(&mut self)

pub fn main_camera_node_mut(&mut self) -> Option<&mut Node>

pub fn main_camera_node(&self) -> Option<&Node>

pub fn set_background_color(&mut self, r: f32, g: f32, b: f32)

Sets the background to a solid color.

pub fn node(&mut self, handle: &NodeHandle) -> SceneNode<'_>

Returns a chainable wrapper for the given node.

Silently no-ops if the handle is stale, avoiding unwrap().

Example

scene.node(&handle)
    .set_position(0.0, 3.0, 0.0)
    .set_scale(2.0)
    .look_at(Vec3::ZERO);

pub fn build_node(&mut self, name: &str) -> NodeBuilder<'_>

Starts building a node

pub fn find_node_by_name(&self, name: &str) -> Option<NodeHandle>

Finds a node by name

pub fn get_global_transform(&self, handle: NodeHandle) -> Affine3A

Gets the global transform matrix of a node

pub fn play_animation(&mut self, node_handle: NodeHandle, clip_name: &str)

Plays a specific animation clip on the node (if an AnimationMixer is present)

pub fn play_if_any_animation(&mut self, node_handle: NodeHandle)

Plays any animation on the node (used for simple cases where clip name is not important)

pub fn get_bbox_of_node( &self, node_handle: NodeHandle, query: &impl GeometryQuery, ) -> Option<BoundingBox>

Recursively computes the world-space bounding box enclosing a node and all its descendants.

query implements crate::GeometryQuery to map geometry handles to local-space bounding boxes.

Trait Implementations

impl AnimationTarget for Scene

fn node_children(&self, handle: NodeHandle) -> Option<Vec<NodeHandle>>

Get the children of a node.

fn node_name(&self, handle: NodeHandle) -> Option<String>

Get a node’s name.

fn node_transform(&self, handle: NodeHandle) -> Option<Transform>

Get a node’s transform.

fn set_node_position(&mut self, handle: NodeHandle, position: Vec3)

Get a mutable reference and apply a transform mutation.

fn set_node_rotation(&mut self, handle: NodeHandle, rotation: Quat)

Set a node’s rotation.

fn set_node_scale(&mut self, handle: NodeHandle, scale: Vec3)

Set a node’s scale.

fn mark_node_dirty(&mut self, handle: NodeHandle)

Mark a node’s transform as dirty (needs hierarchy update).

fn has_rest_transform(&self, handle: NodeHandle) -> bool

Check if a rest transform exists for a node.

fn rest_transform(&self, handle: NodeHandle) -> Option<Transform>

Get the rest transform for a node.

fn store_rest_transform(&mut self, handle: NodeHandle, transform: Transform)

Store a rest transform for a node.

fn morph_weights_mut(&mut self, handle: NodeHandle) -> &mut Vec<f32>

Get or create a mutable morph weights vector for a node.

impl Bindings for Scene

fn define_bindings<'a>(&'a self, _builder: &mut ResourceBuilder<'a>)

impl Default for Scene

fn default() -> Scene

Returns the “default value” for a type.

impl SceneExt for Scene

fn instantiate(&mut self, prefab: &Prefab) -> NodeHandle

Instantiates a Prefab into the scene, returning the root node handle.

fn spawn( &mut self, geometry: impl ResolveGeometry, material: impl ResolveMaterial, assets: &AssetServer, ) -> NodeHandle

Spawns a mesh node from any geometry/material combination.

fn spawn_box( &mut self, w: f32, h: f32, d: f32, material: impl ResolveMaterial, assets: &AssetServer, ) -> NodeHandle

Spawns a box mesh node.

fn spawn_sphere( &mut self, radius: f32, material: impl ResolveMaterial, assets: &AssetServer, ) -> NodeHandle

Spawns a sphere mesh node.

fn spawn_plane( &mut self, width: f32, height: f32, material: impl ResolveMaterial, assets: &AssetServer, ) -> NodeHandle

Spawns a plane mesh node.