Struct InputTransformModeComponent 

pub struct InputTransformModeComponent {
    pub forward_axis: ForwardAxis,
    pub roll_axis: RollAxis,
    pub rotation_enabled: bool,
    pub translation_basis_source: Option<ComponentRef>,
    pub fps_rotation: bool,
}

Input mode component that controls which axis is treated as “forward” for WASD.

Intended topology: InputComponent -> (InputTransformModeComponent?) InputComponent -> TransformComponent

Fields

forward_axis: ForwardAxis

roll_axis: RollAxis

rotation_enabled: bool

translation_basis_source: Option<ComponentRef>

fps_rotation: bool

If true, rotations are applied in world axes (FPS-style). If false, rotations are applied in local space (current behavior).

Implementations

impl InputTransformModeComponent

pub fn forward_y() -> Self

pub fn forward_z() -> Self

Examples found in repository

examples/example_util/mod.rs (line 40)

pub fn spawn_mms_demo_rig(
    universe: &mut engine::Universe,
    cam_pos: [f32; 3],
) -> engine::ecs::ComponentId {
    use engine::ecs::component::{
        BackgroundColorComponent, Camera3DComponent, InputComponent, InputTransformModeComponent,
        TransformComponent,
    };

    // Dark blue clear colour.
    let bg_color = universe
        .world
        .add_component(BackgroundColorComponent::new());
    let bg_color_c = universe
        .world
        .add_component(ColorComponent::rgba(0.02, 0.03, 0.10, 1.0));
    let _ = universe.world.add_child(bg_color, bg_color_c);
    universe.add(bg_color);

    // Camera rig: Input → Transform → Camera3D.
    let input = universe
        .world
        .add_component(InputComponent::new().with_speed(3.0));
    let input_mode = universe
        .world
        .add_component(InputTransformModeComponent::forward_z().with_roll_axis_y());
    let _ = universe.attach(input, input_mode);

    let cam_transform = universe
        .world
        .add_component(TransformComponent::new().with_position(cam_pos[0], cam_pos[1], cam_pos[2]));
    let _ = universe.attach(input, cam_transform);

    let camera = universe.world.add_component(Camera3DComponent::new());
    let _ = universe.attach(cam_transform, camera);

    universe.add(input);

    spawn_desktop_camera_controls_hint(universe, cam_transform);

    cam_transform
}

examples/audio-clip-instance-demo.rs (line 30)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    println!("[audio-clip-instance-demo] start");

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Minimal camera so the window opens.
    let input = universe
        .world
        .add_component(engine::ecs::component::InputComponent::new().with_speed(2.0));
    let rig = universe.world.add_component(
        engine::ecs::component::TransformComponent::new().with_position(0.0, 0.0, 3.0),
    );
    let input_mode = universe.world.add_component(
        engine::ecs::component::InputTransformModeComponent::forward_z().with_roll_axis_y(),
    );
    let cam = universe
        .world
        .add_component(engine::ecs::component::Camera3DComponent::new().with_fov(60.0));
    let _ = universe.attach(input, input_mode);
    let _ = universe.attach(input, rig);
    let _ = universe.attach(rig, cam);
    universe.add(input);

    let clear = universe
        .world
        .add_component(engine::ecs::component::BackgroundColorComponent::new());
    let clear_c = universe
        .world
        .add_component(engine::ecs::component::ColorComponent::rgba(
            0.06, 0.07, 0.10, 1.0,
        ));
    let _ = universe.world.add_child(clear, clear_c);
    universe.add(clear);

    let source = include_str!("audio-clip-instance-demo.mms");
    let output = scripting::MeowMeowRunner::eval_with_world_at_path(
        source,
        Some("examples/audio-clip-instance-demo.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[audio-clip-instance-demo] mms ok: {} intent(s)",
        output.intents.len()
    );

    for intent in output.intents {
        universe
            .command_queue
            .push_intent_now(engine::ecs::ComponentId::default(), intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/audio-music-demo.rs (line 28)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    println!("[audio-music-demo] start");

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Minimal camera so the window opens.
    let input = universe
        .world
        .add_component(engine::ecs::component::InputComponent::new().with_speed(2.0));
    let rig = universe.world.add_component(
        engine::ecs::component::TransformComponent::new().with_position(0.0, 0.0, 3.0),
    );
    let input_mode = universe.world.add_component(
        engine::ecs::component::InputTransformModeComponent::forward_z().with_roll_axis_y(),
    );
    let cam = universe
        .world
        .add_component(engine::ecs::component::Camera3DComponent::new().with_fov(60.0));
    let _ = universe.attach(input, input_mode);
    let _ = universe.attach(input, rig);
    let _ = universe.attach(rig, cam);
    universe.add(input);

    // Dim clear color so console output stays readable in case of errors.
    let clear = universe
        .world
        .add_component(engine::ecs::component::BackgroundColorComponent::new());
    let clear_c = universe
        .world
        .add_component(engine::ecs::component::ColorComponent::rgba(
            0.06, 0.07, 0.10, 1.0,
        ));
    let _ = universe.world.add_child(clear, clear_c);
    universe.add(clear);

    let source = include_str!("audio-music-demo.mms");
    let output = scripting::MeowMeowRunner::eval_with_world_at_path(
        source,
        Some("examples/audio-music-demo.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[audio-music-demo] mms ok: {} intent(s)",
        output.intents.len()
    );

    for intent in output.intents {
        universe
            .command_queue
            .push_intent_now(engine::ecs::ComponentId::default(), intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/opacity-example.rs (line 403)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Dark brown / pink background.
    let bg = universe
        .world
        .add_component(BackgroundColorComponent::new());
    let bg_c = universe
        .world
        .add_component(ColorComponent::rgba(0.22, 0.08, 0.10, 1.0));
    let _ = universe.world.add_child(bg, bg_c);
    universe.add(bg);

    // Ambient so unlit areas aren't black.
    let ambient = universe
        .world
        .add_component(AmbientLightComponent::rgb(0.35, 0.35, 0.40));
    universe.add(ambient);

    // A bright overhead light.
    let light_t = universe.world.add_component(
        TransformComponent::new()
            .with_position(0.0, 18.0, 10.0)
            .with_scale(0.2, 0.2, 0.2),
    );
    let light = universe.world.add_component(
        PointLightComponent::new()
            .with_color(1.0, 1.0, 1.0)
            .with_intensity(1.6)
            .with_distance(80.0),
    );
    let _ = universe.attach(light_t, light);
    universe.add(light_t);

    // --- Camera rig ---
    // I { T { C3D { with_fps_rotation with_roll_axis_y } } }
    let input = universe
        .world
        .add_component(InputComponent::new().with_speed(3.0));
    let input_mode = universe.world.add_component(
        InputTransformModeComponent::forward_z()
            .with_roll_axis_y()
            .with_fps_rotation(),
    );
    let _ = universe.attach(input, input_mode);

    let rig_transform = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 6.0, 20.0));
    let _ = universe.attach(input, rig_transform);

    let camera = universe.world.add_component(Camera3DComponent::new());
    let _ = universe.attach(rig_transform, camera);

    // Topology: I { T { C3D } } — add a small camera-attached controls hint.
    example_util::spawn_desktop_camera_controls_hint(&mut universe, rig_transform);

    universe.add(input);

    // --- Ground ---
    let ground = universe.world.add_component(
        TransformComponent::new()
            .with_position(0.0, -0.6, 0.0)
            .with_scale(60.0, 1.0, 60.0),
    );
    let ground_r = universe.world.add_component(RenderableComponent::cube());
    let ground_c = universe
        .world
        .add_component(ColorComponent::rgba(0.95, 0.95, 0.95, 1.0));
    let _ = universe.attach(ground, ground_r);
    let _ = universe.attach(ground_r, ground_c);
    universe.add(ground);

    // --- Opaque yellow cubes behind (contrast reference) ---
    for i in 0..6 {
        let x = -10.0 + i as f32 * 4.0;
        spawn_cube(
            &mut universe,
            ground,
            (x, 1.2, -18.0),
            (2.0, 2.0, 2.0),
            Some((1.0, 0.92, 0.15, 1.0)),
            None,
        );
    }

    // --- Demo spots ---
    // Left of the left big spot: a single-layer transparent XY plane (16x16).
    spawn_demo_xy_plane(&mut universe, (-14.0, 0.0, 0.0), 0.50, 16, 16, 0.0);

    // Big spots: 8x8x8
    // Left: single-layer transparent (instanced)
    spawn_demo_spot(&mut universe, (-4.0, 0.0, 0.0), 0.50, false, 8);

    // Right: multi-layer transparent (sorted)
    spawn_demo_spot(&mut universe, (4.0, 0.0, 0.0), 0.50, true, 8);

    // Small spots: opaque 1x4 strip + transparent 1x4 strip (along Z).
    spawn_demo_strip_pair(&mut universe, (-4.0, 0.0, 10.0), false);
    spawn_demo_strip_pair(&mut universe, (4.0, 0.0, 10.0), true);

    // Process init-time registrations.
    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/pointer-events.rs (line 392)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    use engine::ecs::component::{
        AmbientLightComponent, BackgroundColorComponent, Camera3DComponent, ColorComponent,
        DirectionalLightComponent, InputComponent, InputTransformModeComponent, PointerComponent,
        TransformComponent,
    };

    // Background.
    let bg = universe
        .world
        .add_component(BackgroundColorComponent::new());
    let bg_c = universe
        .world
        .add_component(ColorComponent::rgba(0.12, 0.12, 0.16, 1.0));
    let _ = universe.world.add_child(bg, bg_c);
    universe.add(bg);

    // Lighting.
    let ambient = universe
        .world
        .add_component(AmbientLightComponent::rgb(0.30, 0.30, 0.32));
    universe.add(ambient);

    let sun_t = universe
        .world
        .add_component(TransformComponent::new().with_position(2.0, 4.0, 3.0));
    let sun = universe
        .world
        .add_component(DirectionalLightComponent::new());
    let _ = universe.attach(sun_t, sun);
    universe.add(sun_t);

    // Camera + pointer rig.
    let input = universe
        .world
        .add_component(InputComponent::new().with_speed(3.0));
    let input_mode = universe.world.add_component(
        InputTransformModeComponent::forward_z()
            .with_fps_rotation()
            .with_roll_axis_y(),
    );
    let _ = universe.attach(input, input_mode);

    let cam_t = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 0.5, 4.5));
    let cam = universe
        .world
        .add_component(Camera3DComponent::new().with_fov(70.0));
    let pointer = universe.world.add_component(PointerComponent::new());

    let _ = universe.attach(input, cam_t);
    let _ = universe.attach(cam_t, cam);
    let _ = universe.attach(cam, pointer);

    example_util::spawn_desktop_camera_controls_hint(&mut universe, cam_t);
    universe.add(input);

    // Scene root for all interactive objects.
    let scene = universe.world.add_component(TransformComponent::new());
    universe.add(scene);

    // --- LEFT: click-only cubes ---
    let click_group = universe
        .world
        .add_component(TransformComponent::new().with_position(-2.2, 0.0, 0.0));
    let _ = universe.attach(scene, click_group);

    for (i, dy) in [-0.55_f32, 0.0, 0.55].iter().enumerate() {
        spawn_click_cube(&mut universe, click_group, [0.0, *dy, 0.0]);
        let _ = i;
    }
    spawn_label(
        &mut universe,
        click_group,
        [-0.25, -1.05, 0.0],
        "click\ncycles color",
    );

    // --- MID: drag-only cube ---
    let drag_cube_root = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 0.0, 0.0));
    let _ = universe.attach(scene, drag_cube_root);

    spawn_drag_cube(
        &mut universe,
        drag_cube_root,
        [0.0, 0.0, 0.0],
        [0.35, 0.85, 0.55, 1.0],
    );
    spawn_label(
        &mut universe,
        drag_cube_root,
        [-0.25, -0.80, 0.0],
        "drag\nto move",
    );

    // --- RIGHT: drag + click cube ---
    let both_root = universe
        .world
        .add_component(TransformComponent::new().with_position(2.2, 0.0, 0.0));
    let _ = universe.attach(scene, both_root);

    spawn_both_cube(&mut universe, both_root, [0.0, 0.0, 0.0]);
    spawn_label(
        &mut universe,
        both_root,
        [-0.30, -0.80, 0.0],
        "drag to move\nclick for color",
    );

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/text-animation.rs (line 25)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Input-driven camera rig.
    // Topology: I { T { C3D } }
    let input = universe
        .world
        .add_component(engine::ecs::component::InputComponent::new().with_speed(1.5));
    let camera3d = universe
        .world
        .add_component(engine::ecs::component::Camera3DComponent::new());
    let rig_transform = universe.world.add_component(
        engine::ecs::component::TransformComponent::new().with_position(0.0, 0.0, 2.5),
    );
    let input_mode = universe.world.add_component(
        engine::ecs::component::InputTransformModeComponent::forward_z().with_roll_axis_y(),
    );
    let _ = universe.attach(input, input_mode);
    let _ = universe.attach(input, rig_transform);
    let _ = universe.attach(rig_transform, camera3d);

    // Small on-screen help.
    example_util::spawn_desktop_camera_controls_hint(&mut universe, rig_transform);
    universe.add(input);

    // Light so we can see non-emissive materials.
    let light_transform = universe.world.add_component(
        engine::ecs::component::TransformComponent::new().with_position(0.0, 0.0, 2.0),
    );
    let light = universe.world.add_component(
        engine::ecs::component::PointLightComponent::new()
            .with_distance(25.0)
            .with_color(1.0, 1.0, 1.0),
    );
    let _ = universe.attach(light_transform, light);
    universe.add(light_transform);

    use engine::ecs::component::{
        ColorComponent, TextComponent, TextShadowComponent, TextureComponent,
        TextureFilteringComponent, TransformComponent, TransparentCutoutComponent,
    };

    // Styled text root.
    let text_root = universe.world.add_component(
        TransformComponent::new()
            .with_position(0.0, 0.0, 0.0)
            .with_scale(0.25, 0.25, 1.0),
    );

    // Color must be an ancestor of the glyph renderables.
    let color_id = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(text_root, color_id);

    // This is the component we animate via SetText.
    let text_id = universe.world.add_component(TextComponent::new(">w<"));
    let _ = universe.attach(color_id, text_id);

    // Route into cutout pass for cleaner edges.
    let cutout = universe
        .world
        .add_component(TransparentCutoutComponent::new());
    let _ = universe.attach(text_id, cutout);

    // Font atlas.
    let tex = universe.world.add_component(TextureComponent::with_uri(
        "assets/textures/font_system.dds",
    ));
    let _ = universe.attach(text_id, tex);

    let shadow = universe.world.add_component(
        TextShadowComponent::new()
            .with_scale(1.35)
            .with_offset([0.06, -0.06, 0.0015]),
    );
    let filtering = universe
        .world
        .add_component(TextureFilteringComponent::nearest_magnification());

    let _ = universe.attach(text_id, shadow);
    let _ = universe.attach(text_id, filtering);

    universe.add(text_root);

    let clock_component = universe
        .world
        .add_component(engine::ecs::component::ClockComponent::new().with_bpm(140.0));
    let _ = universe.add(clock_component);

    // Looping animation: 4 beats long, 4 keyframes.
    let anim = universe
        .world
        .add_component(engine::ecs::component::AnimationComponent::new());

    let faces = [">w<", "^w^", "-_-", "o_o"];
    for (i, &face) in faces.iter().enumerate() {
        let kf = universe
            .world
            .add_component(engine::ecs::component::KeyframeComponent::new(i as f64));

        // Each keyframe emits a SetText intent.
        let action = universe
            .world
            .add_component(engine::ecs::component::ActionComponent::new(
                engine::ecs::IntentValue::SetText {
                    component_ids: vec![text_id],
                    text: face.to_string(),
                },
            ));

        let _ = universe.attach(anim, kf);
        let _ = universe.attach(kf, action);
    }

    universe.add(anim);

    // Process init-time registrations (Text expands into glyph subtrees here).
    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

Additional examples can be found in:

• examples/button-press.rs
• examples/vtuber-example.rs
• examples/openxr.rs
• examples/transparent-cutout-example.rs
• examples/text-example.rs
• examples/gestures-and-gizmos.rs
• examples/background-example.rs
• examples/mesh-factory-example.rs
• examples/simple-demo.rs
• examples/background-occlusion-example.rs
• examples/raycast-topology-animation.rs
• examples/animation-for-topology.rs
• examples/vr-input.rs
• examples/font-example.rs
• examples/vtuber-joints-example.rs
• examples/animation-example.rs
• examples/folder-text.rs
• examples/collision-perimeter.rs
• examples/audio-graph-example.rs
• examples/gravity-fields.rs

pub fn with_rotation_disabled(self) -> Self

pub fn with_translation_basis_source(self, source: ComponentRef) -> Self

pub fn with_fps_rotation(self) -> Self

Examples found in repository

examples/opacity-example.rs (line 405)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Dark brown / pink background.
    let bg = universe
        .world
        .add_component(BackgroundColorComponent::new());
    let bg_c = universe
        .world
        .add_component(ColorComponent::rgba(0.22, 0.08, 0.10, 1.0));
    let _ = universe.world.add_child(bg, bg_c);
    universe.add(bg);

    // Ambient so unlit areas aren't black.
    let ambient = universe
        .world
        .add_component(AmbientLightComponent::rgb(0.35, 0.35, 0.40));
    universe.add(ambient);

    // A bright overhead light.
    let light_t = universe.world.add_component(
        TransformComponent::new()
            .with_position(0.0, 18.0, 10.0)
            .with_scale(0.2, 0.2, 0.2),
    );
    let light = universe.world.add_component(
        PointLightComponent::new()
            .with_color(1.0, 1.0, 1.0)
            .with_intensity(1.6)
            .with_distance(80.0),
    );
    let _ = universe.attach(light_t, light);
    universe.add(light_t);

    // --- Camera rig ---
    // I { T { C3D { with_fps_rotation with_roll_axis_y } } }
    let input = universe
        .world
        .add_component(InputComponent::new().with_speed(3.0));
    let input_mode = universe.world.add_component(
        InputTransformModeComponent::forward_z()
            .with_roll_axis_y()
            .with_fps_rotation(),
    );
    let _ = universe.attach(input, input_mode);

    let rig_transform = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 6.0, 20.0));
    let _ = universe.attach(input, rig_transform);

    let camera = universe.world.add_component(Camera3DComponent::new());
    let _ = universe.attach(rig_transform, camera);

    // Topology: I { T { C3D } } — add a small camera-attached controls hint.
    example_util::spawn_desktop_camera_controls_hint(&mut universe, rig_transform);

    universe.add(input);

    // --- Ground ---
    let ground = universe.world.add_component(
        TransformComponent::new()
            .with_position(0.0, -0.6, 0.0)
            .with_scale(60.0, 1.0, 60.0),
    );
    let ground_r = universe.world.add_component(RenderableComponent::cube());
    let ground_c = universe
        .world
        .add_component(ColorComponent::rgba(0.95, 0.95, 0.95, 1.0));
    let _ = universe.attach(ground, ground_r);
    let _ = universe.attach(ground_r, ground_c);
    universe.add(ground);

    // --- Opaque yellow cubes behind (contrast reference) ---
    for i in 0..6 {
        let x = -10.0 + i as f32 * 4.0;
        spawn_cube(
            &mut universe,
            ground,
            (x, 1.2, -18.0),
            (2.0, 2.0, 2.0),
            Some((1.0, 0.92, 0.15, 1.0)),
            None,
        );
    }

    // --- Demo spots ---
    // Left of the left big spot: a single-layer transparent XY plane (16x16).
    spawn_demo_xy_plane(&mut universe, (-14.0, 0.0, 0.0), 0.50, 16, 16, 0.0);

    // Big spots: 8x8x8
    // Left: single-layer transparent (instanced)
    spawn_demo_spot(&mut universe, (-4.0, 0.0, 0.0), 0.50, false, 8);

    // Right: multi-layer transparent (sorted)
    spawn_demo_spot(&mut universe, (4.0, 0.0, 0.0), 0.50, true, 8);

    // Small spots: opaque 1x4 strip + transparent 1x4 strip (along Z).
    spawn_demo_strip_pair(&mut universe, (-4.0, 0.0, 10.0), false);
    spawn_demo_strip_pair(&mut universe, (4.0, 0.0, 10.0), true);

    // Process init-time registrations.
    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/pointer-events.rs (line 393)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    use engine::ecs::component::{
        AmbientLightComponent, BackgroundColorComponent, Camera3DComponent, ColorComponent,
        DirectionalLightComponent, InputComponent, InputTransformModeComponent, PointerComponent,
        TransformComponent,
    };

    // Background.
    let bg = universe
        .world
        .add_component(BackgroundColorComponent::new());
    let bg_c = universe
        .world
        .add_component(ColorComponent::rgba(0.12, 0.12, 0.16, 1.0));
    let _ = universe.world.add_child(bg, bg_c);
    universe.add(bg);

    // Lighting.
    let ambient = universe
        .world
        .add_component(AmbientLightComponent::rgb(0.30, 0.30, 0.32));
    universe.add(ambient);

    let sun_t = universe
        .world
        .add_component(TransformComponent::new().with_position(2.0, 4.0, 3.0));
    let sun = universe
        .world
        .add_component(DirectionalLightComponent::new());
    let _ = universe.attach(sun_t, sun);
    universe.add(sun_t);

    // Camera + pointer rig.
    let input = universe
        .world
        .add_component(InputComponent::new().with_speed(3.0));
    let input_mode = universe.world.add_component(
        InputTransformModeComponent::forward_z()
            .with_fps_rotation()
            .with_roll_axis_y(),
    );
    let _ = universe.attach(input, input_mode);

    let cam_t = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 0.5, 4.5));
    let cam = universe
        .world
        .add_component(Camera3DComponent::new().with_fov(70.0));
    let pointer = universe.world.add_component(PointerComponent::new());

    let _ = universe.attach(input, cam_t);
    let _ = universe.attach(cam_t, cam);
    let _ = universe.attach(cam, pointer);

    example_util::spawn_desktop_camera_controls_hint(&mut universe, cam_t);
    universe.add(input);

    // Scene root for all interactive objects.
    let scene = universe.world.add_component(TransformComponent::new());
    universe.add(scene);

    // --- LEFT: click-only cubes ---
    let click_group = universe
        .world
        .add_component(TransformComponent::new().with_position(-2.2, 0.0, 0.0));
    let _ = universe.attach(scene, click_group);

    for (i, dy) in [-0.55_f32, 0.0, 0.55].iter().enumerate() {
        spawn_click_cube(&mut universe, click_group, [0.0, *dy, 0.0]);
        let _ = i;
    }
    spawn_label(
        &mut universe,
        click_group,
        [-0.25, -1.05, 0.0],
        "click\ncycles color",
    );

    // --- MID: drag-only cube ---
    let drag_cube_root = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 0.0, 0.0));
    let _ = universe.attach(scene, drag_cube_root);

    spawn_drag_cube(
        &mut universe,
        drag_cube_root,
        [0.0, 0.0, 0.0],
        [0.35, 0.85, 0.55, 1.0],
    );
    spawn_label(
        &mut universe,
        drag_cube_root,
        [-0.25, -0.80, 0.0],
        "drag\nto move",
    );

    // --- RIGHT: drag + click cube ---
    let both_root = universe
        .world
        .add_component(TransformComponent::new().with_position(2.2, 0.0, 0.0));
    let _ = universe.attach(scene, both_root);

    spawn_both_cube(&mut universe, both_root, [0.0, 0.0, 0.0]);
    spawn_label(
        &mut universe,
        both_root,
        [-0.30, -0.80, 0.0],
        "drag to move\nclick for color",
    );

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/button-press.rs (line 483)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Minimal lit scene + pointer raycaster.
    use engine::ecs::component::{
        AmbientLightComponent, BackgroundColorComponent, Camera3DComponent,
        DirectionalLightComponent, InputComponent, InputTransformModeComponent, PointerComponent,
        TransformComponent,
    };

    let bg = universe
        .world
        .add_component(BackgroundColorComponent::new());
    let bg_c = universe
        .world
        .add_component(engine::ecs::component::ColorComponent::rgba(
            0.92, 0.92, 0.96, 1.0,
        ));
    let _ = universe.world.add_child(bg, bg_c);
    universe.add(bg);

    let ambient = universe
        .world
        .add_component(AmbientLightComponent::rgb(0.35, 0.35, 0.35));
    universe.add(ambient);

    let sun_t = universe
        .world
        .add_component(TransformComponent::new().with_position(1.0, 1.0, 1.0));
    let sun = universe
        .world
        .add_component(DirectionalLightComponent::new());
    let _ = universe.attach(sun_t, sun);
    universe.add(sun_t);

    let input = universe
        .world
        .add_component(InputComponent::new().with_speed(2.5));
    let input_mode = universe.world.add_component(
        InputTransformModeComponent::forward_z()
            .with_fps_rotation()
            .with_roll_axis_y(),
    );
    let _ = universe.attach(input, input_mode);

    let rig_t = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 0.0, 2.5));
    let _ = universe.attach(input, rig_t);

    let cam = universe
        .world
        .add_component(Camera3DComponent::new().with_far(600.0).with_fov(70.0));
    let _ = universe.attach(rig_t, cam);

    let pointer = universe.world.add_component(PointerComponent::new());
    let _ = universe.attach(cam, pointer);

    example_util::spawn_desktop_camera_controls_hint(&mut universe, rig_t);
    universe.add(input);

    // The button.
    let button_root = spawn_button(
        &mut universe,
        [0.0, 0.0, 0.0],
        [1.20, 0.45],
        ButtonBorder::new(0.025, 0.025, 0.025, 0.025),
        "click me",
        0.18,
        [0.15, 0.15, 0.20, 1.0],
        [0.85, 0.85, 0.92, 1.0],
    );

    // A small 3-cube stack to the left of the button for gizmo testing:
    //   [cyan]
    // [yellow][light brown]
    //
    // These live under an EditorComponent subtree so clicking attaches the editor gizmo.
    {
        use engine::ecs::component::{EditorComponent, TransformComponent};

        let editor_root = universe.world.add_component(EditorComponent::new());

        // Position the stack in world space (left of the button).
        let stack_root = universe
            .world
            .add_component(TransformComponent::new().with_position(-1.55, 0.0, 0.0));
        let _ = universe.attach(editor_root, stack_root);

        let cube = 0.22_f32;
        let gap = 0.04_f32;
        let step = cube + gap;
        let y_bottom = -0.5 * step;
        let y_top = 0.5 * step;
        let x_left = -0.5 * step;
        let x_right = 0.5 * step;

        let yellow = [1.0, 0.92, 0.22, 1.0];
        let light_brown = [0.80, 0.66, 0.46, 1.0];
        let cyan = [0.20, 0.95, 1.0, 1.0];

        let _bottom_left = spawn_raycastable_colored_cube(
            &mut universe,
            stack_root,
            [x_left, y_bottom, 0.0],
            [cube, cube, 0.06],
            yellow,
        );
        let _bottom_right = spawn_raycastable_colored_cube(
            &mut universe,
            stack_root,
            [x_right, y_bottom, 0.0],
            [cube, cube, 0.06],
            light_brown,
        );
        let _top = spawn_raycastable_colored_cube(
            &mut universe,
            stack_root,
            [0.0, y_top, 0.0],
            [cube, cube, 0.06],
            cyan,
        );

        universe.add(editor_root);
    }

    universe.add_signal_handler(
        engine::ecs::SignalKind::DragStart,
        button_root,
        button_press_handler,
    );
    universe.add_signal_handler(
        engine::ecs::SignalKind::DragEnd,
        button_root,
        button_press_handler,
    );

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/vtuber-example.rs (line 41)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Light pink background.
    let background = universe
        .world
        .add_component(BackgroundColorComponent::new());
    let background_c = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 0.82, 0.90, 1.0));
    let _ = universe.world.add_child(background, background_c);
    universe.add(background);

    // Small ambient so shadowed areas aren't pure black.
    let ambient = universe
        .world
        .add_component(AmbientLightComponent::rgb(0.10, 0.10, 0.12));
    universe.add(ambient);

    // --- Camera rig (WASD + mouse) ---
    // InputComponent is the root, and it owns a Transform (the camera rig).
    let input = universe
        .world
        .add_component(InputComponent::new().with_speed(1.5));
    let input_mode = universe.world.add_component(
        InputTransformModeComponent::forward_z()
            .with_fps_rotation()
            .with_roll_axis_y(),
    );
    let _ = universe.attach(input, input_mode);

    // Start slightly pulled back looking towards the origin.
    let rig_transform = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 0.0, 6.0));
    let _ = universe.attach(input, rig_transform);

    let camera3d = universe.world.add_component(Camera3DComponent::new());
    let _ = universe.attach(rig_transform, camera3d);

    // Topology: I { T { C3D } } — add a small camera-attached controls hint.
    example_util::spawn_desktop_camera_controls_hint(&mut universe, rig_transform);

    universe.add(input);

    // --- lighting ---
    // Directional key light (slightly down + forward Z).
    let sun = universe.world.add_component(
        DirectionalLightComponent::new()
            .with_intensity(1.2)
            .with_color(1.0, 0.98, 0.94),
    );
    let sun_dir = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, -0.35, 1.0));
    let _ = universe.attach(sun_dir, sun);
    universe.add(sun_dir);

    let light_transform = universe.world.add_component(
        TransformComponent::new()
            .with_position(1.0, 6.0, 3.0)
            .with_scale(0.1, 0.1, 0.1),
    );
    let light = universe.world.add_component(
        engine::ecs::component::PointLightComponent::new()
            .with_distance(120.0)
            .with_color(1.0, 1.0, 1.0),
    );
    let _ = universe.attach(light_transform, light);
    universe.add(light_transform);

    // --- VTuber model ---
    let model_root = universe.world.add_component(TransformComponent::new());
    let model = universe
        .world
        .add_component(GLTFComponent::new("assets/models/pc-rei.hoodie.glb"));
    // emissive for pc-rei
    let emissive = universe
        .world
        .add_component(engine::ecs::component::EmissiveComponent::on());

    let _ = universe.attach(model, emissive);

    let xr_input = universe.world.add_component(InputXRComponent::on());
    let xr_gamepad = universe
        .world
        .add_component(engine::ecs::component::InputXRGamepadComponent::new().speed(1.5));
    let xr_head = universe.world.add_component(TransformComponent::new());
    let xr_camera = universe.world.add_component(CameraXRComponent::on());
    let _ = universe.attach(xr_input, xr_head);
    let _ = universe.attach(xr_input, xr_gamepad);
    let _ = universe.attach(xr_head, xr_camera);
    let _ = universe.attach(xr_head, model_root);

    let _ = universe.attach(model_root, model);
    universe.add(xr_input);
    universe.add(model_root);

    // --- Background clouds (occluded + lit) ---
    let bg_root = universe.world.add_component(
        engine::ecs::component::BackgroundComponent::new().with_occlusion_and_lighting(),
    );
    universe.add(bg_root);
    let mut cloud_params = example_util::CloudRingParams::default();
    cloud_params.cloud_count = 8; // +3 clusters
    cloud_params.angle_jitter = 0.35;
    cloud_params.high_y_probability = 0.5;
    cloud_params.high_y_multiplier = 1.5;
    cloud_params.seed = 0x57_55_B0_01u32;
    example_util::spawn_cloud_ring(&mut universe, bg_root, cloud_params);

    // --- Simple environment ---
    let spawn_cube = |universe: &mut engine::Universe,
                      position: (f32, f32, f32),
                      scale: (f32, f32, f32),
                      color: (f32, f32, f32, f32)| {
        let transform = universe.world.add_component(
            TransformComponent::new()
                .with_position(position.0, position.1, position.2)
                .with_scale(scale.0, scale.1, scale.2),
        );
        let renderable = universe.world.add_component(RenderableComponent::cube());
        let color = universe
            .world
            .add_component(ColorComponent::rgba(color.0, color.1, color.2, color.3));

        let _ = universe.attach(transform, renderable);
        let _ = universe.attach(renderable, color);

        universe.add(transform);
    };

    // floor
    spawn_cube(
        &mut universe,
        (0.0, -0.05, 0.0),
        (10.0, 0.1, 10.0),
        (0.92, 0.92, 0.92, 1.0),
    );

    // back wall
    spawn_cube(
        &mut universe,
        (0.0, 1.5, -5.0),
        (10.0, 3.0, 1.0),
        (0.95, 0.94, 0.96, 1.0),
    );

    // desk
    spawn_cube(
        &mut universe,
        (0.0, 0.35, 1.0),
        (1.0, 0.75, 0.5),
        (0.75, 0.70, 0.65, 1.0),
    );

    let xr_root = universe
        .world
        .add_component(engine::ecs::component::XrComponent::on());
    universe.add(xr_root);

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/gestures-and-gizmos.rs (line 99)

fn build_gestures_and_gizmos_scene(universe: &mut engine::Universe) -> Scene {
    use engine::ecs::component::{
        BackgroundColorComponent, BackgroundComponent, Camera3DComponent, ColorComponent,
        DirectionalLightComponent, InputComponent, InputTransformModeComponent, PointerComponent,
        RaycastableComponent, RenderableComponent, TransformComponent, TransformGizmoComponent,
    };
    use engine::graphics::BuiltinMeshType;
    use engine::graphics::primitives::{MaterialHandle, Renderable};

    let tri_mesh = universe.render_assets.get_mesh(BuiltinMeshType::Triangle2D);
    let cube_mesh = universe.render_assets.get_mesh(BuiltinMeshType::Cube);
    let tetra_mesh = universe
        .render_assets
        .get_mesh(BuiltinMeshType::Tetrahedron);

    // BackgroundColor { C.rgba }
    let bg_color = universe
        .world
        .add_component(BackgroundColorComponent::new());
    let bg_color_c = universe
        .world
        .add_component(ColorComponent::rgba(0.90, 0.90, 0.90, 1.0));
    let _ = universe.world.add_child(bg_color, bg_color_c);
    universe.add(bg_color);

    // ambient light
    let ambient = universe
        .world
        .add_component(AmbientLightComponent::rgb(0.25, 0.25, 0.25));
    universe.add(ambient);

    // ground plane
    let ground_tx = universe.world.add_component(
        TransformComponent::new()
            .with_position(0.0, -2.5, 0.0)
            .with_scale(20.0, 1.0, 20.0),
    );
    let ground_r = universe
        .world
        .add_component(RenderableComponent::new(Renderable::new(
            universe.render_assets.get_mesh(BuiltinMeshType::Cube),
            MaterialHandle::TOON_MESH,
        )));
    let ground_c = universe
        .world
        .add_component(ColorComponent::rgba(0.75, 0.75, 0.75, 1.0));
    let _ = universe.attach(ground_tx, ground_r);
    let _ = universe.attach(ground_r, ground_c);
    let _ = universe.add(ground_tx);

    // Background {
    //     with_occlusion_and_lighting()
    //     // using the example utils to add clouds to the background
    // }
    let bg_root = universe
        .world
        .add_component(BackgroundComponent::new().with_occlusion_and_lighting());
    universe.add(bg_root);

    // DirectionalLight {
    //     T { translate [1, 1, 1] }
    // }
    // Directional lights encode their direction in the node's world position.
    let sun_t = universe
        .world
        .add_component(TransformComponent::new().with_position(1.0, 1.0, 1.0));
    let sun = universe
        .world
        .add_component(DirectionalLightComponent::new());
    let _ = universe.attach(sun_t, sun);
    universe.add(sun_t);

    // i = input
    // t = transform
    // c3d = camera3d
    //
    // I {
    //     T {
    //         C3D { with_fps_rotation().with_roll_axis_y() }
    //     }
    // }
    let input = universe
        .world
        .add_component(InputComponent::new().with_speed(2.5));
    let input_mode = universe.world.add_component(
        InputTransformModeComponent::forward_z()
            .with_fps_rotation()
            .with_roll_axis_y(),
    );

    let _ = universe.attach(input, input_mode);

    // Forward is -Z, so put the camera at +Z looking toward the origin.
    let rig_t = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 0.0, 3.5));
    let _ = universe.attach(input, rig_t);

    let cam = universe
        .world
        .add_component(Camera3DComponent::new().with_far(600.0).with_fov(70.0));
    let _ = universe.attach(rig_t, cam);

    // Opt-in: treat this camera rig as a pointer source.
    let pointer = universe.world.add_component(PointerComponent::new());
    let _ = universe.attach(cam, pointer);

    // Topology: I { T { C3D } } — add a small camera-attached controls hint.
    example_util::spawn_desktop_camera_controls_hint(universe, rig_t);

    fn spawn_shape_with_gizmo(
        universe: &mut engine::Universe,
        mesh: engine::graphics::primitives::CpuMeshHandle,
        pos: [f32; 3],
        scale: [f32; 3],
        rot_euler: [f32; 3],
        color: [f32; 4],
    ) {
        let t = universe.world.add_component(
            TransformComponent::new()
                .with_position(pos[0], pos[1], pos[2])
                .with_scale(scale[0], scale[1], scale[2])
                .with_rotation_euler(rot_euler[0], rot_euler[1], rot_euler[2]),
        );
        let r = universe
            .world
            .add_component(RenderableComponent::new(Renderable::new(
                mesh,
                MaterialHandle::TOON_MESH,
            )));
        let c = universe
            .world
            .add_component(ColorComponent::rgba(color[0], color[1], color[2], color[3]));
        let rc = universe
            .world
            .add_component(RaycastableComponent::enabled());
        let g = universe.world.add_component(TransformGizmoComponent::new());

        let _ = universe.attach(t, r);
        let _ = universe.attach(r, c);
        let _ = universe.attach(r, rc);
        let _ = universe.attach(t, g);

        universe.add(t);
    }

    fn spawn_shape_raycastable_no_gizmo(
        universe: &mut engine::Universe,
        mesh: engine::graphics::primitives::CpuMeshHandle,
        pos: [f32; 3],
        scale: [f32; 3],
        rot_euler: [f32; 3],
        color: [f32; 4],
    ) {
        let t = universe.world.add_component(
            TransformComponent::new()
                .with_position(pos[0], pos[1], pos[2])
                .with_scale(scale[0], scale[1], scale[2])
                .with_rotation_euler(rot_euler[0], rot_euler[1], rot_euler[2]),
        );
        let r = universe
            .world
            .add_component(RenderableComponent::new(Renderable::new(
                mesh,
                MaterialHandle::TOON_MESH,
            )));
        let c = universe
            .world
            .add_component(ColorComponent::rgba(color[0], color[1], color[2], color[3]));
        let rc = universe
            .world
            .add_component(RaycastableComponent::enabled());

        let _ = universe.attach(t, r);
        let _ = universe.attach(r, c);
        let _ = universe.attach(r, rc);

        universe.add(t);
    }

    spawn_shape_with_gizmo(
        universe,
        tri_mesh,
        [-1.2, 0.0, 0.0],
        [0.65, 0.65, 0.65],
        [0.0, 0.0, 0.0],
        [0.2, 0.9, 0.25, 1.0],
    );
    spawn_shape_with_gizmo(
        universe,
        cube_mesh,
        [0.0, 0.0, 0.0],
        [0.55, 0.55, 0.55],
        [0.0, 0.0, 0.0],
        [0.95, 0.25, 0.2, 1.0],
    );
    spawn_shape_with_gizmo(
        universe,
        tetra_mesh,
        [1.2, 0.0, 0.0],
        [0.7, 0.7, 0.7],
        [0.0, 0.0, 0.0],
        [0.2, 0.55, 1.0, 1.0],
    );

    // Standalone tetrahedron: no gizmo, but explicitly raycastable.
    // This helps isolate tetra picking vs gizmo-handle interception.
    spawn_shape_raycastable_no_gizmo(
        universe,
        tetra_mesh,
        [2.6, -0.6, 0.0],
        [0.95, 0.95, 0.95],
        [0.0, 0.0, 0.0],
        [0.85, 0.85, 1.0, 1.0],
    );

    universe.add(input);

    Scene { bg_root }
}

examples/raycast-topology-animation.rs (line 148)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Background.
    let bg_color = universe
        .world
        .add_component(engine::ecs::component::BackgroundColorComponent::new());
    let bg_color_c = universe
        .world
        .add_component(engine::ecs::component::ColorComponent::rgba(
            0.1, 0.1, 0.1, 1.0,
        ));
    let _ = universe.world.add_child(bg_color, bg_color_c);
    universe.add(bg_color);

    // Camera rig so we can see the scene.
    let input = universe
        .world
        .add_component(engine::ecs::component::InputComponent::new().with_speed(2.0));

    let rig_transform = universe.world.add_component(
        engine::ecs::component::TransformComponent::new()
            .with_position(0.0, 2.0, 8.0)
            .with_rotation_euler(-0.25, 0.0, 0.0),
    );

    let camera3d = universe
        .world
        .add_component(engine::ecs::component::Camera3DComponent::new());

    let input_mode = universe.world.add_component(
        engine::ecs::component::InputTransformModeComponent::forward_z()
            .with_roll_axis_y()
            .with_fps_rotation(),
    );

    let _ = universe.attach(input, input_mode);
    let _ = universe.attach(input, rig_transform);
    let _ = universe.attach(rig_transform, camera3d);

    // Topology: I { T { C3D } } — add a small camera-attached controls hint.
    example_util::spawn_desktop_camera_controls_hint(&mut universe, rig_transform);
    universe.add(input);

    // Two rotating anchor transforms that the raycaster will be reparented under.
    // Each ring has its own anchor at a different height.
    let anchor_a = universe.world.add_component(
        engine::ecs::component::TransformComponent::new().with_position(0.0, 1.0, 0.0),
    );
    let anchor_b = universe.world.add_component(
        engine::ecs::component::TransformComponent::new().with_position(0.0, 2.2, 0.0),
    );

    // Visual markers for A/B.
    fn marker(universe: &mut engine::Universe, parent: engine::ecs::ComponentId, rgba: [f32; 4]) {
        let r = universe
            .world
            .add_component(engine::ecs::component::RenderableComponent::cube());
        let rc = universe
            .world
            .add_component(engine::ecs::component::RaycastableComponent::disabled());
        let c = universe
            .world
            .add_component(engine::ecs::component::ColorComponent::rgba(
                rgba[0], rgba[1], rgba[2], rgba[3],
            ));
        let e = universe
            .world
            .add_component(engine::ecs::component::EmissiveComponent::on());
        let t = universe.world.add_component(
            engine::ecs::component::TransformComponent::new().with_scale(0.15, 0.15, 0.15),
        );
        let _ = universe.attach(parent, t);
        let _ = universe.attach(t, r);
        let _ = universe.attach(r, rc);
        let _ = universe.attach(r, c);
        let _ = universe.attach(r, e);
    }

    marker(&mut universe, anchor_a, [0.9, 0.2, 0.2, 1.0]);
    marker(&mut universe, anchor_b, [0.2, 0.2, 0.9, 1.0]);

    universe.add(anchor_a);
    universe.add(anchor_b);

    // A ring of cubes around the origin to see which one gets hit.
    fn ring_cube(
        universe: &mut engine::Universe,
        ring_root: engine::ecs::ComponentId,
        x: f32,
        y: f32,
        z: f32,
        rgba: [f32; 4],
    ) {
        let t = universe.world.add_component(
            engine::ecs::component::TransformComponent::new()
                .with_position(x, y, z)
                .with_scale(0.35, 0.35, 0.35),
        );
        let r = universe
            .world
            .add_component(engine::ecs::component::RenderableComponent::cube());
        let rc = universe
            .world
            .add_component(engine::ecs::component::RaycastableComponent::enabled());
        let c = universe
            .world
            .add_component(engine::ecs::component::ColorComponent::rgba(
                rgba[0], rgba[1], rgba[2], rgba[3],
            ));
        let _ = universe.attach(ring_root, t);
        let _ = universe.attach(t, r);
        let _ = universe.attach(r, rc);
        let _ = universe.attach(r, c);
    }

    // Two rings: one per anchor height.
    let n = 28;
    let (radius_a, y_a) = (4.0, 1.0);
    let (radius_b, y_b) = (2.6, 2.2);

    let ring_a_root = universe
        .world
        .add_component(engine::ecs::component::TransformComponent::new());
    let ring_b_root = universe
        .world
        .add_component(engine::ecs::component::TransformComponent::new());

    for i in 0..n {
        let a = (i as f32) * (std::f32::consts::TAU / (n as f32));
        let (x, z) = (radius_a * a.cos(), radius_a * a.sin());
        let color = if i % 2 == 0 {
            [0.55, 0.20, 0.20, 1.0]
        } else {
            [0.20, 0.55, 0.20, 1.0]
        };
        ring_cube(&mut universe, ring_a_root, x, y_a, z, color);
    }

    for i in 0..n {
        let a = (i as f32) * (std::f32::consts::TAU / (n as f32));
        let (x, z) = (radius_b * a.cos(), radius_b * a.sin());
        let color = if i % 2 == 0 {
            [0.20, 0.25, 0.60, 1.0]
        } else {
            [0.20, 0.55, 0.55, 1.0]
        };
        ring_cube(&mut universe, ring_b_root, x, y_b, z, color);
    }

    // Init rings and attach scoped interaction handlers.
    universe.add(ring_a_root);
    universe.add(ring_b_root);
    universe.add_signal_handler(
        engine::ecs::SignalKind::RayIntersected,
        ring_a_root,
        ring_a_handler,
    );
    universe.add_signal_handler(
        engine::ecs::SignalKind::RayIntersected,
        ring_b_root,
        ring_b_handler,
    );

    // The raycaster component we will move between parents.
    // Source is inferred from topology:
    // - Under transforms A/B (no camera child) => parent-forward (-Z)
    // - Under camera rig transform (has camera child) => cursor-through-camera
    let raycaster = universe.world.add_component(
        engine::ecs::component::RayCastComponent::event_driven().with_max_distance(25.0),
    );

    // Global animation: move the raycaster between anchors.
    // Loop length is 8 beats (we include a noop keyframe at beat 7.0 to force loop_len=8).
    let anim_global = universe
        .world
        .add_component(engine::ecs::component::AnimationComponent::new());
    {
        // beat 0: attach to A.
        let kf0 = universe
            .world
            .add_component(engine::ecs::component::KeyframeComponent::new(0.0));
        let act0 = universe
            .world
            .add_component(engine::ecs::component::ActionComponent::new(
                engine::ecs::IntentValue::Attach {
                    parents: vec![anchor_a],
                    child: raycaster,
                },
            ));
        let _ = universe.attach(kf0, act0);
        let _ = universe.attach(anim_global, kf0);

        // beat 4: attach to B.
        let kf4 = universe
            .world
            .add_component(engine::ecs::component::KeyframeComponent::new(4.0));
        let act4 = universe
            .world
            .add_component(engine::ecs::component::ActionComponent::new(
                engine::ecs::IntentValue::Attach {
                    parents: vec![anchor_b],
                    child: raycaster,
                },
            ));
        let _ = universe.attach(kf4, act4);
        let _ = universe.attach(anim_global, kf4);

        // beat 7: noop to make loop_len=8.
        let kf7 = universe
            .world
            .add_component(engine::ecs::component::KeyframeComponent::new(7.0));
        let noop = universe
            .world
            .add_component(engine::ecs::component::ActionComponent::new(
                engine::ecs::IntentValue::Noop,
            ));
        let _ = universe.attach(kf7, noop);
        let _ = universe.attach(anim_global, kf7);
    }
    universe.add(anim_global);

    // Ring A animation: rotate anchor A around Y (1 rev / 8 beats).
    // Also triggers Action::raycast(raycaster) on downbeats in the first half: beats 0,1,2,3.
    let anim_a = universe
        .world
        .add_component(engine::ecs::component::AnimationComponent::new());

    // Ring B animation: rotate anchor B differently (yaw + pitch).
    // Also triggers Action::raycast(raycaster) on offbeats in the second half: beats 4.5,5.5,6.5,7.5.
    let anim_b = universe
        .world
        .add_component(engine::ecs::component::AnimationComponent::new());

    let loop_beats = 8.0;
    let steps = 64;

    for step in 0..=steps {
        let t = (step as f32) / (steps as f32);
        let beat = (t as f64) * (loop_beats as f64);

        // Keyframe beats are per-animation local beats.
        let kf_a = universe
            .world
            .add_component(engine::ecs::component::KeyframeComponent::new(beat));
        let kf_b = universe
            .world
            .add_component(engine::ecs::component::KeyframeComponent::new(beat));

        // Anchor A rotation: smooth yaw.
        let yaw_a = t * std::f32::consts::TAU;
        let a_set = engine::ecs::component::ActionComponent::new(
            engine::ecs::IntentValue::UpdateTransform {
                component_ids: vec![anchor_a],
                translation: [0.0, 1.0, 0.0],
                rotation_quat_xyzw: quat_from_yaw(yaw_a),
                scale: [1.0, 1.0, 1.0],
            },
        );
        let a_set_id = universe.world.add_component(a_set);
        let _ = universe.attach(kf_a, a_set_id);

        // Anchor B rotation: yaw + pitch (different pattern).
        let yaw_b = -t * std::f32::consts::TAU * 1.5;
        let pitch_b = (t * std::f32::consts::TAU).sin() * 0.35;
        let rot_b = quat_mul(quat_from_yaw(yaw_b), quat_from_pitch(pitch_b));
        let b_set = engine::ecs::component::ActionComponent::new(
            engine::ecs::IntentValue::UpdateTransform {
                component_ids: vec![anchor_b],
                translation: [0.0, 2.2, 0.0],
                rotation_quat_xyzw: rot_b,
                scale: [1.0, 1.0, 1.0],
            },
        );
        let b_set_id = universe.world.add_component(b_set);
        let _ = universe.attach(kf_b, b_set_id);

        // Per-ring raycast patterns.
        // A: downbeats in first half (0..4): step % 8 == 0 -> beats 0,1,2,3,4.
        if beat < 4.0 && step % 8 == 0 {
            let act = universe
                .world
                .add_component(engine::ecs::component::ActionComponent::new(
                    engine::ecs::IntentValue::RequestRaycast {
                        component_ids: vec![raycaster],
                    },
                ));
            let _ = universe.attach(kf_a, act);
        }

        // B: offbeats in second half (4..8): step % 8 == 4 -> beats 0.5,1.5,...,7.5.
        if beat >= 4.0 && step % 8 == 4 {
            let act = universe
                .world
                .add_component(engine::ecs::component::ActionComponent::new(
                    engine::ecs::IntentValue::RequestRaycast {
                        component_ids: vec![raycaster],
                    },
                ));
            let _ = universe.attach(kf_b, act);
        }

        let _ = universe.attach(anim_a, kf_a);
        let _ = universe.attach(anim_b, kf_b);
    }

    universe.add(anim_a);
    universe.add(anim_b);

    // Process init-time registrations.
    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

Additional examples can be found in:

• examples/vr-input.rs
• examples/vtuber-joints-example.rs
• examples/collision-perimeter.rs
• examples/gravity-fields.rs

pub fn with_roll_axis_y(self) -> Self

Examples found in repository

examples/example_util/mod.rs (line 40)

pub fn spawn_mms_demo_rig(
    universe: &mut engine::Universe,
    cam_pos: [f32; 3],
) -> engine::ecs::ComponentId {
    use engine::ecs::component::{
        BackgroundColorComponent, Camera3DComponent, InputComponent, InputTransformModeComponent,
        TransformComponent,
    };

    // Dark blue clear colour.
    let bg_color = universe
        .world
        .add_component(BackgroundColorComponent::new());
    let bg_color_c = universe
        .world
        .add_component(ColorComponent::rgba(0.02, 0.03, 0.10, 1.0));
    let _ = universe.world.add_child(bg_color, bg_color_c);
    universe.add(bg_color);

    // Camera rig: Input → Transform → Camera3D.
    let input = universe
        .world
        .add_component(InputComponent::new().with_speed(3.0));
    let input_mode = universe
        .world
        .add_component(InputTransformModeComponent::forward_z().with_roll_axis_y());
    let _ = universe.attach(input, input_mode);

    let cam_transform = universe
        .world
        .add_component(TransformComponent::new().with_position(cam_pos[0], cam_pos[1], cam_pos[2]));
    let _ = universe.attach(input, cam_transform);

    let camera = universe.world.add_component(Camera3DComponent::new());
    let _ = universe.attach(cam_transform, camera);

    universe.add(input);

    spawn_desktop_camera_controls_hint(universe, cam_transform);

    cam_transform
}

examples/audio-clip-instance-demo.rs (line 30)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    println!("[audio-clip-instance-demo] start");

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Minimal camera so the window opens.
    let input = universe
        .world
        .add_component(engine::ecs::component::InputComponent::new().with_speed(2.0));
    let rig = universe.world.add_component(
        engine::ecs::component::TransformComponent::new().with_position(0.0, 0.0, 3.0),
    );
    let input_mode = universe.world.add_component(
        engine::ecs::component::InputTransformModeComponent::forward_z().with_roll_axis_y(),
    );
    let cam = universe
        .world
        .add_component(engine::ecs::component::Camera3DComponent::new().with_fov(60.0));
    let _ = universe.attach(input, input_mode);
    let _ = universe.attach(input, rig);
    let _ = universe.attach(rig, cam);
    universe.add(input);

    let clear = universe
        .world
        .add_component(engine::ecs::component::BackgroundColorComponent::new());
    let clear_c = universe
        .world
        .add_component(engine::ecs::component::ColorComponent::rgba(
            0.06, 0.07, 0.10, 1.0,
        ));
    let _ = universe.world.add_child(clear, clear_c);
    universe.add(clear);

    let source = include_str!("audio-clip-instance-demo.mms");
    let output = scripting::MeowMeowRunner::eval_with_world_at_path(
        source,
        Some("examples/audio-clip-instance-demo.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[audio-clip-instance-demo] mms ok: {} intent(s)",
        output.intents.len()
    );

    for intent in output.intents {
        universe
            .command_queue
            .push_intent_now(engine::ecs::ComponentId::default(), intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/audio-music-demo.rs (line 28)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    println!("[audio-music-demo] start");

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Minimal camera so the window opens.
    let input = universe
        .world
        .add_component(engine::ecs::component::InputComponent::new().with_speed(2.0));
    let rig = universe.world.add_component(
        engine::ecs::component::TransformComponent::new().with_position(0.0, 0.0, 3.0),
    );
    let input_mode = universe.world.add_component(
        engine::ecs::component::InputTransformModeComponent::forward_z().with_roll_axis_y(),
    );
    let cam = universe
        .world
        .add_component(engine::ecs::component::Camera3DComponent::new().with_fov(60.0));
    let _ = universe.attach(input, input_mode);
    let _ = universe.attach(input, rig);
    let _ = universe.attach(rig, cam);
    universe.add(input);

    // Dim clear color so console output stays readable in case of errors.
    let clear = universe
        .world
        .add_component(engine::ecs::component::BackgroundColorComponent::new());
    let clear_c = universe
        .world
        .add_component(engine::ecs::component::ColorComponent::rgba(
            0.06, 0.07, 0.10, 1.0,
        ));
    let _ = universe.world.add_child(clear, clear_c);
    universe.add(clear);

    let source = include_str!("audio-music-demo.mms");
    let output = scripting::MeowMeowRunner::eval_with_world_at_path(
        source,
        Some("examples/audio-music-demo.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[audio-music-demo] mms ok: {} intent(s)",
        output.intents.len()
    );

    for intent in output.intents {
        universe
            .command_queue
            .push_intent_now(engine::ecs::ComponentId::default(), intent);
    }

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/opacity-example.rs (line 404)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Dark brown / pink background.
    let bg = universe
        .world
        .add_component(BackgroundColorComponent::new());
    let bg_c = universe
        .world
        .add_component(ColorComponent::rgba(0.22, 0.08, 0.10, 1.0));
    let _ = universe.world.add_child(bg, bg_c);
    universe.add(bg);

    // Ambient so unlit areas aren't black.
    let ambient = universe
        .world
        .add_component(AmbientLightComponent::rgb(0.35, 0.35, 0.40));
    universe.add(ambient);

    // A bright overhead light.
    let light_t = universe.world.add_component(
        TransformComponent::new()
            .with_position(0.0, 18.0, 10.0)
            .with_scale(0.2, 0.2, 0.2),
    );
    let light = universe.world.add_component(
        PointLightComponent::new()
            .with_color(1.0, 1.0, 1.0)
            .with_intensity(1.6)
            .with_distance(80.0),
    );
    let _ = universe.attach(light_t, light);
    universe.add(light_t);

    // --- Camera rig ---
    // I { T { C3D { with_fps_rotation with_roll_axis_y } } }
    let input = universe
        .world
        .add_component(InputComponent::new().with_speed(3.0));
    let input_mode = universe.world.add_component(
        InputTransformModeComponent::forward_z()
            .with_roll_axis_y()
            .with_fps_rotation(),
    );
    let _ = universe.attach(input, input_mode);

    let rig_transform = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 6.0, 20.0));
    let _ = universe.attach(input, rig_transform);

    let camera = universe.world.add_component(Camera3DComponent::new());
    let _ = universe.attach(rig_transform, camera);

    // Topology: I { T { C3D } } — add a small camera-attached controls hint.
    example_util::spawn_desktop_camera_controls_hint(&mut universe, rig_transform);

    universe.add(input);

    // --- Ground ---
    let ground = universe.world.add_component(
        TransformComponent::new()
            .with_position(0.0, -0.6, 0.0)
            .with_scale(60.0, 1.0, 60.0),
    );
    let ground_r = universe.world.add_component(RenderableComponent::cube());
    let ground_c = universe
        .world
        .add_component(ColorComponent::rgba(0.95, 0.95, 0.95, 1.0));
    let _ = universe.attach(ground, ground_r);
    let _ = universe.attach(ground_r, ground_c);
    universe.add(ground);

    // --- Opaque yellow cubes behind (contrast reference) ---
    for i in 0..6 {
        let x = -10.0 + i as f32 * 4.0;
        spawn_cube(
            &mut universe,
            ground,
            (x, 1.2, -18.0),
            (2.0, 2.0, 2.0),
            Some((1.0, 0.92, 0.15, 1.0)),
            None,
        );
    }

    // --- Demo spots ---
    // Left of the left big spot: a single-layer transparent XY plane (16x16).
    spawn_demo_xy_plane(&mut universe, (-14.0, 0.0, 0.0), 0.50, 16, 16, 0.0);

    // Big spots: 8x8x8
    // Left: single-layer transparent (instanced)
    spawn_demo_spot(&mut universe, (-4.0, 0.0, 0.0), 0.50, false, 8);

    // Right: multi-layer transparent (sorted)
    spawn_demo_spot(&mut universe, (4.0, 0.0, 0.0), 0.50, true, 8);

    // Small spots: opaque 1x4 strip + transparent 1x4 strip (along Z).
    spawn_demo_strip_pair(&mut universe, (-4.0, 0.0, 10.0), false);
    spawn_demo_strip_pair(&mut universe, (4.0, 0.0, 10.0), true);

    // Process init-time registrations.
    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/pointer-events.rs (line 394)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    use engine::ecs::component::{
        AmbientLightComponent, BackgroundColorComponent, Camera3DComponent, ColorComponent,
        DirectionalLightComponent, InputComponent, InputTransformModeComponent, PointerComponent,
        TransformComponent,
    };

    // Background.
    let bg = universe
        .world
        .add_component(BackgroundColorComponent::new());
    let bg_c = universe
        .world
        .add_component(ColorComponent::rgba(0.12, 0.12, 0.16, 1.0));
    let _ = universe.world.add_child(bg, bg_c);
    universe.add(bg);

    // Lighting.
    let ambient = universe
        .world
        .add_component(AmbientLightComponent::rgb(0.30, 0.30, 0.32));
    universe.add(ambient);

    let sun_t = universe
        .world
        .add_component(TransformComponent::new().with_position(2.0, 4.0, 3.0));
    let sun = universe
        .world
        .add_component(DirectionalLightComponent::new());
    let _ = universe.attach(sun_t, sun);
    universe.add(sun_t);

    // Camera + pointer rig.
    let input = universe
        .world
        .add_component(InputComponent::new().with_speed(3.0));
    let input_mode = universe.world.add_component(
        InputTransformModeComponent::forward_z()
            .with_fps_rotation()
            .with_roll_axis_y(),
    );
    let _ = universe.attach(input, input_mode);

    let cam_t = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 0.5, 4.5));
    let cam = universe
        .world
        .add_component(Camera3DComponent::new().with_fov(70.0));
    let pointer = universe.world.add_component(PointerComponent::new());

    let _ = universe.attach(input, cam_t);
    let _ = universe.attach(cam_t, cam);
    let _ = universe.attach(cam, pointer);

    example_util::spawn_desktop_camera_controls_hint(&mut universe, cam_t);
    universe.add(input);

    // Scene root for all interactive objects.
    let scene = universe.world.add_component(TransformComponent::new());
    universe.add(scene);

    // --- LEFT: click-only cubes ---
    let click_group = universe
        .world
        .add_component(TransformComponent::new().with_position(-2.2, 0.0, 0.0));
    let _ = universe.attach(scene, click_group);

    for (i, dy) in [-0.55_f32, 0.0, 0.55].iter().enumerate() {
        spawn_click_cube(&mut universe, click_group, [0.0, *dy, 0.0]);
        let _ = i;
    }
    spawn_label(
        &mut universe,
        click_group,
        [-0.25, -1.05, 0.0],
        "click\ncycles color",
    );

    // --- MID: drag-only cube ---
    let drag_cube_root = universe
        .world
        .add_component(TransformComponent::new().with_position(0.0, 0.0, 0.0));
    let _ = universe.attach(scene, drag_cube_root);

    spawn_drag_cube(
        &mut universe,
        drag_cube_root,
        [0.0, 0.0, 0.0],
        [0.35, 0.85, 0.55, 1.0],
    );
    spawn_label(
        &mut universe,
        drag_cube_root,
        [-0.25, -0.80, 0.0],
        "drag\nto move",
    );

    // --- RIGHT: drag + click cube ---
    let both_root = universe
        .world
        .add_component(TransformComponent::new().with_position(2.2, 0.0, 0.0));
    let _ = universe.attach(scene, both_root);

    spawn_both_cube(&mut universe, both_root, [0.0, 0.0, 0.0]);
    spawn_label(
        &mut universe,
        both_root,
        [-0.30, -0.80, 0.0],
        "drag to move\nclick for color",
    );

    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    universe.enable_repl();
    engine::Windowing::run_app(universe).expect("Windowing failed");
}

examples/text-animation.rs (line 25)

fn main() {
    mittens_engine::example_support::ensure_model_assets();
    utils::logger::init();

    let world = engine::ecs::World::default();
    let mut universe = engine::Universe::new(world);

    // Input-driven camera rig.
    // Topology: I { T { C3D } }
    let input = universe
        .world
        .add_component(engine::ecs::component::InputComponent::new().with_speed(1.5));
    let camera3d = universe
        .world
        .add_component(engine::ecs::component::Camera3DComponent::new());
    let rig_transform = universe.world.add_component(
        engine::ecs::component::TransformComponent::new().with_position(0.0, 0.0, 2.5),
    );
    let input_mode = universe.world.add_component(
        engine::ecs::component::InputTransformModeComponent::forward_z().with_roll_axis_y(),
    );
    let _ = universe.attach(input, input_mode);
    let _ = universe.attach(input, rig_transform);
    let _ = universe.attach(rig_transform, camera3d);

    // Small on-screen help.
    example_util::spawn_desktop_camera_controls_hint(&mut universe, rig_transform);
    universe.add(input);

    // Light so we can see non-emissive materials.
    let light_transform = universe.world.add_component(
        engine::ecs::component::TransformComponent::new().with_position(0.0, 0.0, 2.0),
    );
    let light = universe.world.add_component(
        engine::ecs::component::PointLightComponent::new()
            .with_distance(25.0)
            .with_color(1.0, 1.0, 1.0),
    );
    let _ = universe.attach(light_transform, light);
    universe.add(light_transform);

    use engine::ecs::component::{
        ColorComponent, TextComponent, TextShadowComponent, TextureComponent,
        TextureFilteringComponent, TransformComponent, TransparentCutoutComponent,
    };

    // Styled text root.
    let text_root = universe.world.add_component(
        TransformComponent::new()
            .with_position(0.0, 0.0, 0.0)
            .with_scale(0.25, 0.25, 1.0),
    );

    // Color must be an ancestor of the glyph renderables.
    let color_id = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(text_root, color_id);

    // This is the component we animate via SetText.
    let text_id = universe.world.add_component(TextComponent::new(">w<"));
    let _ = universe.attach(color_id, text_id);

    // Route into cutout pass for cleaner edges.
    let cutout = universe
        .world
        .add_component(TransparentCutoutComponent::new());
    let _ = universe.attach(text_id, cutout);

    // Font atlas.
    let tex = universe.world.add_component(TextureComponent::with_uri(
        "assets/textures/font_system.dds",
    ));
    let _ = universe.attach(text_id, tex);

    let shadow = universe.world.add_component(
        TextShadowComponent::new()
            .with_scale(1.35)
            .with_offset([0.06, -0.06, 0.0015]),
    );
    let filtering = universe
        .world
        .add_component(TextureFilteringComponent::nearest_magnification());

    let _ = universe.attach(text_id, shadow);
    let _ = universe.attach(text_id, filtering);

    universe.add(text_root);

    let clock_component = universe
        .world
        .add_component(engine::ecs::component::ClockComponent::new().with_bpm(140.0));
    let _ = universe.add(clock_component);

    // Looping animation: 4 beats long, 4 keyframes.
    let anim = universe
        .world
        .add_component(engine::ecs::component::AnimationComponent::new());

    let faces = [">w<", "^w^", "-_-", "o_o"];
    for (i, &face) in faces.iter().enumerate() {
        let kf = universe
            .world
            .add_component(engine::ecs::component::KeyframeComponent::new(i as f64));

        // Each keyframe emits a SetText intent.
        let action = universe
            .world
            .add_component(engine::ecs::component::ActionComponent::new(
                engine::ecs::IntentValue::SetText {
                    component_ids: vec![text_id],
                    text: face.to_string(),
                },
            ));

        let _ = universe.attach(anim, kf);
        let _ = universe.attach(kf, action);
    }

    universe.add(anim);

    // Process init-time registrations (Text expands into glyph subtrees here).
    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    engine::Windowing::run_app(universe).expect("Windowing failed");
}

Additional examples can be found in:

• examples/button-press.rs
• examples/vtuber-example.rs
• examples/openxr.rs
• examples/transparent-cutout-example.rs
• examples/text-example.rs
• examples/gestures-and-gizmos.rs
• examples/background-example.rs
• examples/mesh-factory-example.rs
• examples/simple-demo.rs
• examples/background-occlusion-example.rs
• examples/raycast-topology-animation.rs
• examples/animation-for-topology.rs
• examples/vr-input.rs
• examples/font-example.rs
• examples/vtuber-joints-example.rs
• examples/animation-example.rs
• examples/folder-text.rs
• examples/collision-perimeter.rs
• examples/audio-graph-example.rs
• examples/gravity-fields.rs

pub fn with_roll_axis_z(self) -> Self

Trait Implementations

impl Clone for InputTransformModeComponent

fn clone(&self) -> InputTransformModeComponent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for InputTransformModeComponent

fn name(&self) -> &'static str

Short debug/type name for this component kind (e.g. “transform”, “camera”).

fn as_any(&self) -> &dyn Any

fn as_any_mut(&mut self) -> &mut dyn Any

fn to_mms_ast(&self, _world: &World) -> ComponentExpression

Encode this component as an MMS Component Expression AST node.

fn set_id(&mut self, _component: ComponentId)

fn init(&mut self, _emit: &mut dyn SignalEmitter, _component: ComponentId)

Called when component is added to the World

fn cleanup(&mut self, _emit: &mut dyn SignalEmitter, _component: ComponentId)

Called when component is removed from the World.

fn encode(&self) -> HashMap<String, Value>

Encode component data to a HashMap for serialization.

fn decode(&mut self, _data: &HashMap<String, Value>) -> Result<(), String>

Decode component data from a HashMap after deserialization.

impl Debug for InputTransformModeComponent

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

Formats the value using the given formatter.

impl Default for InputTransformModeComponent

fn default() -> Self

Returns the “default value” for a type.