Struct OverlayComponent 

pub struct OverlayComponent { /* private fields */ }

Marks a subtree as belonging to the overlay render phase.

Any renderables under an OverlayComponent ancestor are routed into the overlay pass, which is drawn after all other passes.

Implementations

impl OverlayComponent

pub fn new() -> Self

Examples found in repository

examples/bisket-vr-demo.rs (line 449)

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);

    let output = scripting::MeowMeowRunner::eval_with_world_and_assets_at_path(
        include_str!("bisket-vr-demo.mms"),
        Some("examples/bisket-vr-demo.mms"),
        &mut universe.world,
        &mut universe.systems.rx,
        Some(&mut universe.render_assets),
        &mut universe.command_queue,
    );

    for error in &output.errors {
        eprintln!("[mms] {error}");
    }
    println!(
        "[mms] {} intent(s) from bisket-vr-demo.mms",
        output.intents.len()
    );

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

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

    // Force the glTF subtree to spawn so the armature exists before we query for
    // bone markers (otherwise the bone components aren't in the world yet).
    {
        let systems = &mut universe.systems;
        systems.gltf.tick_with_queue(
            &mut universe.world,
            &mut universe.visuals,
            &mut systems.skinned_mesh,
            &mut universe.command_queue,
            0.0,
        );
    }
    universe.systems.process_commands(
        &mut universe.world,
        &mut universe.visuals,
        &mut universe.render_assets,
        &mut universe.command_queue,
    );

    // Find any global root to start the descendant search from. Scanning all
    // components is fine here — this only runs once at startup.
    let roots: Vec<engine::ecs::ComponentId> = universe
        .world
        .all_components()
        .filter(|&id| universe.world.parent_of(id).is_none())
        .collect();

    // ----------------------------------------------------------------------
    // Dump button — click to print a bone snapshot for offline analysis.
    //
    // Topology: scene_root → OV → button_t → button_r (+ C, EM, Raycastable).
    // OV phase so the cube is visible through the avatar body in first-person VR.
    // Click handler walks the cached bone list, prints world pos + segment
    // lengths to stdout.  Compare with bisket-vr-debug harness output.
    // ----------------------------------------------------------------------
    {
        // Resolve AVC + driven_t for the dump.
        let avc_id_opt = universe.world.all_components().find(|&id| {
            universe
                .world
                .get_component_by_id_as::<AvatarControlComponent>(id)
                .is_some()
        });
        if let Some(avc_id) = avc_id_opt {
            let driven_t = universe.world.parent_of(avc_id).unwrap_or(avc_id);
            let head_ik_offset_yaw = universe
                .world
                .get_component_by_id_as::<AvatarControlComponent>(avc_id)
                .map(|c| {
                    if c.forward_plus_z {
                        0.0
                    } else {
                        std::f32::consts::PI
                    }
                })
                .unwrap_or(std::f32::consts::PI);

            // Find each bone under any root (model_root is unique per avatar here).
            let mut bones: Vec<(String, ComponentId)> = Vec::new();
            for name in DUMP_BONES {
                let sel = format!("[name='{}']", name);
                if let Some(bone) = roots.iter().find_map(|&r| universe.find_component(r, &sel)) {
                    bones.push((name.to_string(), bone));
                } else {
                    eprintln!("[dump] bone not found: {}", name);
                }
            }
            // splice_head = parent of head bone (runtime-inserted by AVC).
            let splice_head = bones
                .iter()
                .find(|(n, _)| n == "J_Bip_C_Head")
                .and_then(|(_, head)| universe.world.parent_of(*head))
                .unwrap_or(avc_id);

            let head_bone = bones
                .iter()
                .find(|(n, _)| n == "J_Bip_C_Head")
                .map(|(_, id)| *id)
                .unwrap_or(splice_head);

            let upper_chest = bones
                .iter()
                .find(|(n, _)| n == "J_Bip_C_UpperChest")
                .map(|(_, id)| *id);

            // Find CameraXR + its transform wrapper to recover authored eye offset.
            let cxr_id = universe.world.all_components().find(|&cid| {
                universe
                    .world
                    .get_component_by_id_as::<mittens_engine::engine::ecs::component::CameraXRComponent>(cid)
                    .is_some()
            });
            let camera_wrapper_t = cxr_id.and_then(|cid| {
                universe.world.parent_of(cid).filter(|&p| {
                    universe
                        .world
                        .get_component_by_id_as::<TransformComponent>(p)
                        .is_some()
                })
            });
            let authored_eye_offset_head_local = camera_wrapper_t
                .and_then(|t| {
                    universe
                        .world
                        .get_component_by_id_as::<TransformComponent>(t)
                })
                .map(|t| t.transform.translation)
                .unwrap_or([0.0, 0.0, 0.0]);

            let _ = DUMP_TARGETS.set(DumpTargets {
                bones,
                driven_t,
                splice_head,
                head_bone,
                upper_chest,
                camera_wrapper_t,
                authored_eye_offset_head_local,
                head_ik_offset_yaw,
            });

            // Spawn the button.  Position chosen so it's reachable in-VR from
            // a standing pose: 0.35 m to the right, hip-height, slightly out.
            let btn_t = universe.world.add_component(
                TransformComponent::new()
                    .with_position(0.35, 1.05, -0.35)
                    .with_scale(0.06, 0.06, 0.06),
            );
            let btn_r = universe.world.add_component(RenderableComponent::cube());
            let btn_c = universe
                .world
                .add_component(ColorComponent::rgba(0.95, 0.20, 0.40, 1.0));
            let btn_em = universe.world.add_component(EmissiveComponent::on());
            let btn_rcast = universe
                .world
                .add_component(RaycastableComponent::enabled());
            let btn_ov = universe.world.add_component(OverlayComponent::new());
            let _ = universe.world.add_child(btn_r, btn_c);
            let _ = universe.world.add_child(btn_r, btn_em);
            let _ = universe.world.add_child(btn_r, btn_rcast);
            let _ = universe.world.add_child(btn_t, btn_r);
            let _ = universe.world.add_child(btn_ov, btn_t);

            // Attach to a stable scene root (the first global root we found).
            let scene_root = roots
                .iter()
                .copied()
                .find(|&r| {
                    universe
                        .world
                        .get_component_by_id_as::<TransformComponent>(r)
                        .is_some()
                        || universe.world.children_of(r).len() > 0
                })
                .unwrap_or_else(|| roots[0]);
            let _ = universe.attach(scene_root, btn_ov);

            // Wire Click handler.  Scope = the renderable (where the raycast hits).
            universe.add_signal_handler(SignalKind::Click, btn_r, on_dump_click);

            println!(
                "[dump] button spawned at [0.35, 1.05, -0.35] — click in VR or with desktop pointer to dump bones"
            );
        } else {
            eprintln!("[dump] AvatarControlComponent not found — skipping dump button");
        }
    }

    for kind in [
        SignalKind::DragStart,
        SignalKind::DragMove,
        SignalKind::DragEnd,
        SignalKind::Click,
    ] {
        universe
            .systems
            .rx
            .add_global_handler(kind, on_xr_pointer_event);
    }

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

pub fn id(&self) -> Option<ComponentId>

Trait Implementations

impl Clone for OverlayComponent

fn clone(&self) -> OverlayComponent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for OverlayComponent

fn set_id(&mut self, component: ComponentId)

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 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.

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

Encode this component as an MMS Component Expression AST node.

impl Copy for OverlayComponent

impl Debug for OverlayComponent

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

Formats the value using the given formatter.

impl Default for OverlayComponent

fn default() -> OverlayComponent

Returns the “default value” for a type.