Struct TransformSystem 

pub struct TransformSystem;

System responsible for syncing TransformComponent changes into VisualWorld. applying side effects to direct children of transforms and calculating world matrices for descendant transform components.

Key points:

• A TransformComponent can parent other transforms to form groups.
• Instances in VisualWorld are created per RenderableComponent under transforms.

Implementations

impl TransformSystem

pub fn new() -> Self

pub fn world_model(world: &World, cid: ComponentId) -> Option<TransformMatrix>

Compute the world-space model matrix for a component by walking up the component tree and multiplying all ancestor TransformComponent model matrices.

Returns None if there are no ancestor transforms.

Examples found in repository

examples/diy-panel.rs (line 104)

fn spawn_container_item_debug_clones(
    universe: &mut engine::Universe,
    container: engine::ecs::ComponentId,
) {
    use engine::ecs::IntentValue;
    use engine::ecs::system::TransformSystem;
    use mittens_engine::scripting::component_registry::{
        ce_ast_to_materialized, spawn_tree, subtree_to_ce_ast,
    };

    let items = collect_container_items(&universe.world, container);
    for (index, item) in items.into_iter().enumerate() {
        let Some(matrix_world) = TransformSystem::world_model(&universe.world, item) else {
            println!("[diy-panel-debug] skip {:?}: no world matrix", item);
            continue;
        };

        let item_label = universe
            .world
            .component_label(item)
            .unwrap_or("")
            .to_string();
        println!(
            "[diy-panel-debug] item={} label={:?} matrix_world={:?}",
            index, item_label, matrix_world,
        );

        // Subtree → MMS AST → MaterializedCE → fresh spawn.
        // Same path attach_clone uses; gives the clone fresh GUIDs and
        // routes everything through the standard component registry.
        let Ok(ce_ast) = subtree_to_ce_ast(&universe.world, item) else {
            println!(
                "[diy-panel-debug] skip {:?}: failed to encode subtree",
                item
            );
            continue;
        };
        let Ok(materialized) = ce_ast_to_materialized(&ce_ast) else {
            println!(
                "[diy-panel-debug] skip {:?}: failed to materialize CE",
                item
            );
            continue;
        };
        let Ok(clone_root) = spawn_tree(
            &materialized,
            None,
            &mut universe.world,
            &mut universe.command_queue,
        ) else {
            println!("[diy-panel-debug] skip {:?}: failed to spawn clone", item);
            continue;
        };

        universe.add(clone_root);

        let (mut clone_translation, clone_rotation, clone_scale) =
            decompose_world_trs(matrix_world);
        clone_translation[0] += DEBUG_CLONE_WORLD_OFFSET[0];
        clone_translation[1] += DEBUG_CLONE_WORLD_OFFSET[1];
        clone_translation[2] += DEBUG_CLONE_WORLD_OFFSET[2];

        universe.command_queue.push_intent_now(
            clone_root,
            IntentValue::UpdateTransform {
                component_ids: vec![clone_root],
                translation: clone_translation,
                rotation_quat_xyzw: clone_rotation,
                scale: clone_scale,
            },
        );

        let label = if item_label.is_empty() {
            format!("item_{index}")
        } else {
            format!("{}_{}", item_label, index)
        };
        println!(
            "[diy-panel-debug] cloned item={} label={:?} clone_root={:?} offset_translation={:?}",
            index, label, clone_root, clone_translation,
        );
    }
}

pub fn world_position(world: &World, cid: ComponentId) -> Option<[f32; 3]>

Compute the world-space position (translation) for a component.

pub fn transform_changed( &mut self, world: &mut World, visuals: &mut VisualWorld, component: ComponentId, transform_stream_system: &mut TransformStreamSystem, camera_system: &mut CameraSystem, light_system: &mut LightSystem, collision_system: &mut CollisionSystem, )

Called by TransformComponent when its values change.

This updates camera translation if the transform has a Camera2D child, and updates VisualWorld instance model matrices for any RenderableComponent descendants.

Trait Implementations

impl Debug for TransformSystem

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for TransformSystem

fn default() -> TransformSystem

Returns the “default value” for a type.

impl System for TransformSystem

fn tick( &mut self, _world: &mut World, _visuals: &mut VisualWorld, _input: &InputState, _dt_sec: f32, )