Struct RaycastableComponent 

pub struct RaycastableComponent {
    pub enable: bool,
    pub pointer_events: PointerEvents,
    pub interaction_priority: u8,
}

Controls whether renderables should be eligible for ray casting (BVH insertion).

This is intentionally separate from RenderableComponent so raycasting policy can be expressed via topology/components rather than renderable data.

Fields

enable: bool

If true, ray casting is enabled.

pointer_events: PointerEvents

Which pointer event types this object captures vs. passes through to hits behind it.

interaction_priority: u8

Higher values win interaction ordering before distance-based tie-breaking.

Implementations

impl RaycastableComponent

pub fn new(enable: bool) -> Self

pub fn enabled() -> Self

Examples found in repository

examples/button-press.rs (line 192)

fn spawn_raycastable_cube(
    universe: &mut engine::Universe,
    parent: engine::ecs::ComponentId,
    pos: [f32; 3],
    scale: [f32; 3],
) -> engine::ecs::ComponentId {
    use engine::ecs::component::{RaycastableComponent, RenderableComponent, TransformComponent};

    let t = universe.world.add_component(
        TransformComponent::new()
            .with_position(pos[0], pos[1], pos[2])
            .with_scale(scale[0], scale[1], scale[2]),
    );
    let r = universe.world.add_component(RenderableComponent::cube());
    let rc = universe
        .world
        .add_component(RaycastableComponent::enabled());

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

    r
}

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

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

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

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

examples/pointer-events.rs (line 104)

fn spawn_click_cube(
    universe: &mut engine::Universe,
    parent: engine::ecs::ComponentId,
    pos: [f32; 3],
) -> engine::ecs::ComponentId {
    use engine::ecs::component::{
        ColorComponent, RaycastableComponent, RenderableComponent, TransformComponent,
    };

    let root = universe.world.add_component(
        TransformComponent::new()
            .with_position(pos[0], pos[1], pos[2])
            .with_scale(0.40, 0.40, 0.40),
    );
    let color_node = universe
        .world
        .add_component(ColorComponent::rgba(0.25, 0.55, 1.0, 1.0));
    let r = universe.world.add_component(RenderableComponent::cube());
    let rc = universe
        .world
        .add_component(RaycastableComponent::enabled());

    // Build the subtree before connecting to the live parent so that
    // RaycastableComponent is already a child of RenderableComponent when
    // RegisterRenderable is processed (renderable_is_raycastable checks children).
    let _ = universe.attach(root, color_node);
    let _ = universe.attach(color_node, r);
    let _ = universe.attach(r, rc);
    let _ = universe.attach(parent, root);

    CLICK_CUBES
        .get_or_init(|| Mutex::new(Default::default()))
        .lock()
        .unwrap()
        .insert(
            root,
            ClickCubeState {
                color_node,
                click_count: 0,
            },
        );

    universe.add_signal_handler(engine::ecs::SignalKind::Click, root, on_click_cube);

    root
}

// ---------------------------------------------------------------------------
// Drag cube — follows pointer while held
// ---------------------------------------------------------------------------

fn on_drag_move(
    world: &mut engine::ecs::World,
    emit: &mut dyn engine::ecs::SignalEmitter,
    env: &engine::ecs::Signal,
) {
    let Some(engine::ecs::EventSignal::DragMove { delta_world, .. }) = env.event.as_ref() else {
        return;
    };
    let delta = *delta_world;

    // Walk up from the hit renderable to find the TransformComponent to move.
    let mut cur = Some(env.scope);
    while let Some(id) = cur {
        if world
            .get_component_by_id_as::<engine::ecs::component::TransformComponent>(id)
            .is_some()
        {
            let [x, y, z] = world
                .get_component_by_id_as::<engine::ecs::component::TransformComponent>(id)
                .map(|t| t.transform.translation)
                .unwrap_or([0.0; 3]);

            emit.push_intent_now(
                id,
                engine::ecs::IntentValue::SetPosition {
                    component_ids: vec![id],
                    position: [x + delta[0], y + delta[1], z + delta[2]],
                },
            );
            return;
        }
        cur = world.parent_of(id);
    }
}

fn spawn_drag_cube(
    universe: &mut engine::Universe,
    parent: engine::ecs::ComponentId,
    pos: [f32; 3],
    color: [f32; 4],
) -> engine::ecs::ComponentId {
    use engine::ecs::component::{
        ColorComponent, RaycastableComponent, RenderableComponent, TransformComponent,
    };

    let root = universe.world.add_component(
        TransformComponent::new()
            .with_position(pos[0], pos[1], pos[2])
            .with_scale(0.45, 0.45, 0.45),
    );
    let color_node = universe
        .world
        .add_component(ColorComponent::rgba(color[0], color[1], color[2], color[3]));
    let r = universe.world.add_component(RenderableComponent::cube());
    let rc = universe
        .world
        .add_component(RaycastableComponent::enabled());

    let _ = universe.attach(root, color_node);
    let _ = universe.attach(color_node, r);
    let _ = universe.attach(r, rc);
    let _ = universe.attach(parent, root);

    universe.add_signal_handler(engine::ecs::SignalKind::DragMove, r, on_drag_move);

    root
}

// ---------------------------------------------------------------------------
// "Both" cube — drag to move, click to cycle color
// ---------------------------------------------------------------------------

#[derive(Debug)]
struct BothCubeState {
    color_node: engine::ecs::ComponentId,
    click_count: u32,
}

static BOTH_CUBES: OnceLock<
    Mutex<std::collections::HashMap<engine::ecs::ComponentId, BothCubeState>>,
> = OnceLock::new();

fn on_both_cube(
    world: &mut engine::ecs::World,
    emit: &mut dyn engine::ecs::SignalEmitter,
    env: &engine::ecs::Signal,
) {
    match env.event.as_ref() {
        Some(engine::ecs::EventSignal::DragMove { delta_world, .. }) => {
            on_drag_move(world, emit, env);
            let _ = delta_world;
        }
        Some(engine::ecs::EventSignal::Click { .. }) => {
            let map = BOTH_CUBES.get_or_init(|| Mutex::new(Default::default()));
            let mut guard = map.lock().unwrap();
            // scope is the renderable; walk up to find the cube root registered in the map
            let mut cur = Some(env.scope);
            let mut found_root = None;
            while let Some(id) = cur {
                if guard.contains_key(&id) {
                    found_root = Some(id);
                    break;
                }
                cur = world.parent_of(id);
            }
            let Some(root) = found_root else { return };
            let Some(state) = guard.get_mut(&root) else {
                return;
            };

            state.click_count += 1;
            let colors = click_cube_colors();
            let rgba = colors[state.click_count as usize % colors.len()];
            emit.push_intent_now(
                root,
                engine::ecs::IntentValue::SetColor {
                    component_ids: vec![state.color_node],
                    rgba,
                },
            );
        }
        _ => {}
    }
}

fn spawn_both_cube(
    universe: &mut engine::Universe,
    parent: engine::ecs::ComponentId,
    pos: [f32; 3],
) -> engine::ecs::ComponentId {
    use engine::ecs::component::{
        ColorComponent, RaycastableComponent, RenderableComponent, TransformComponent,
    };

    let root = universe.world.add_component(
        TransformComponent::new()
            .with_position(pos[0], pos[1], pos[2])
            .with_scale(0.45, 0.45, 0.45),
    );
    let color_node = universe
        .world
        .add_component(ColorComponent::rgba(0.95, 0.60, 0.20, 1.0));
    let r = universe.world.add_component(RenderableComponent::cube());
    let rc = universe
        .world
        .add_component(RaycastableComponent::enabled());

    let _ = universe.attach(root, color_node);
    let _ = universe.attach(color_node, r);
    let _ = universe.attach(r, rc);
    let _ = universe.attach(parent, root);

    BOTH_CUBES
        .get_or_init(|| Mutex::new(Default::default()))
        .lock()
        .unwrap()
        .insert(
            root,
            BothCubeState {
                color_node,
                click_count: 0,
            },
        );

    universe.add_signal_handler(engine::ecs::SignalKind::DragMove, r, on_both_cube);
    universe.add_signal_handler(engine::ecs::SignalKind::Click, r, on_both_cube);

    root
}

examples/font-example.rs (line 162)

    fn spawn_text_block(
        universe: &mut engine::Universe,
        position: (f32, f32, f32),
        scale: f32,
        text: &str,
        font_texture_uri: Option<&str>,
        text_color_rgba: Option<[f32; 4]>,
        shadow: Option<TextShadowComponent>,
        filtering: TextureFilteringComponent,
    ) -> f32 {
        // T_root { T_scale { [Color] { TXT { shadow, filtering } } } }
        let text_root = universe.world.add_component(
            TransformComponent::new().with_position(position.0, position.1, position.2),
        );

        let text_scale = universe
            .world
            .add_component(TransformComponent::new().with_scale(scale, scale, 1.0));
        let _ = universe.attach(text_root, text_scale);

        let text_parent = if let Some([r, g, b, a]) = text_color_rgba {
            let color = universe
                .world
                .add_component(ColorComponent::rgba(r, g, b, a));
            let _ = universe.attach(text_scale, color);
            color
        } else {
            text_scale
        };

        let text_c = universe.world.add_component(TextComponent::new(text));
        let _ = universe.attach(text_parent, text_c);

        // Explicit opt-in: make the glyph renderables pickable.
        // TextSystem will propagate this to all spawned glyph quads.
        let raycastable = universe
            .world
            .add_component(RaycastableComponent::enabled());
        let _ = universe.attach(text_c, raycastable);

        // Route glyph quads into the alpha-to-coverage cutout pass.
        let cutout = universe
            .world
            .add_component(TransparentCutoutComponent::new());
        let _ = universe.attach(text_c, cutout);

        if let Some(shadow) = shadow {
            let shadow_id = universe.world.add_component(shadow);
            let _ = universe.attach(text_c, shadow_id);
        }

        // Optional: override the font atlas for this text block.
        // TextSystem will propagate this to all glyph renderables.
        if let Some(uri) = font_texture_uri {
            let tex = universe
                .world
                .add_component(TextureComponent::with_uri(uri));
            let _ = universe.attach(text_c, tex);
        }

        let filtering_id = universe.world.add_component(filtering);
        let _ = universe.attach(text_c, filtering_id);

        universe.add(text_root);

        estimate_text_height_world(text, scale)
    }

examples/example_util/mod.rs (line 240)

pub fn spawn_desktop_camera_controls_hint(
    universe: &mut engine::Universe,
    camera_transform: engine::ecs::ComponentId,
) -> engine::ecs::ComponentId {
    use engine::ecs::component::{
        ColorComponent, EditorComponent, EmissiveComponent, RaycastableComponent, TextComponent,
        TextureFilteringComponent, TransformComponent,
    };

    // We intentionally do NOT parent the hint under the camera rig.
    // This keeps it out of the camera subtree (and avoids inheriting camera motion/rotation).
    //
    // Instead, we place it in world space based on the camera rig's current pose.
    // That makes it start out “in front-right of the camera” without being attached.
    let (cam_pos, cam_rot) = universe
        .world
        .get_component_by_id_as::<TransformComponent>(camera_transform)
        .map(|t| (t.transform.translation, t.transform.rotation))
        .unwrap_or(([0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 1.0]));

    // Camera convention in examples: forward is -Z.
    // Local-space offset from the camera rig at spawn time.
    let local_offset = [0.65, 0.25, -1.7];

    // Rotate the offset by the camera rig's rotation so it appears in front-right of the view.
    let world_offset = mittens_engine::utils::math::quat_rotate_vec3(cam_rot, local_offset);
    let world_pos = [
        cam_pos[0] + world_offset[0],
        cam_pos[1] + world_offset[1],
        cam_pos[2] + world_offset[2],
    ];

    let hint_root = universe.world.add_component(
        TransformComponent::new()
            .with_position(world_pos[0], world_pos[1], world_pos[2])
            .with_scale(0.055, 0.055, 1.0),
    );

    // Put the hint into an editor subtree so clicking it attaches gizmos.
    let editor_root = universe.world.add_component(EditorComponent::new());
    let _ = universe.attach(hint_root, editor_root);

    let text = universe.world.add_component(TextComponent::new(
        "use wasd/rf/qe\nand right-mouse\nclick and drag\nto move/look",
    ));

    // Make glyph renderables raycastable so the hint can be clicked without adding a
    // large invisible pick plane (clicking is per-glyph / per-text-quad).
    let raycastable = universe
        .world
        .add_component(RaycastableComponent::enabled());
    let _ = universe.attach(text, raycastable);

    // Text color should be an immediate child of the TextComponent root.
    let color = universe
        .world
        .add_component(ColorComponent::rgba(0.0, 0.0, 0.0, 1.0));
    let _ = universe.attach(text, color);

    // TextSystem looks for these as immediate children of the TextComponent root.
    let emissive = universe.world.add_component(EmissiveComponent::on());
    let filtering = universe
        .world
        .add_component(TextureFilteringComponent::nearest_magnification());

    let cutout = universe
        .world
        .add_component(TransparentCutoutComponent::new());
    let _ = universe.attach(text, cutout);

    let _ = universe.attach(editor_root, text);
    let _ = universe.attach(text, emissive);
    let _ = universe.attach(text, filtering);

    // Ensure the text is initialized even if the caller only adds the camera rig.
    universe.add(hint_root);

    hint_root
}

Additional examples can be found in:

• examples/bisket-vr-demo.rs
• examples/vr-input.rs
• examples/vtuber-joints-example.rs

pub fn disabled() -> Self

Examples found in repository

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

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

pub fn drag_only() -> Self

Captures drag events only; click falls through to hits behind this object.

pub fn click_only() -> Self

Captures click events only; drag falls through to hits behind this object.

pub fn with_interaction_priority(self, interaction_priority: u8) -> Self

Trait Implementations

impl Clone for RaycastableComponent

fn clone(&self) -> RaycastableComponent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for RaycastableComponent

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 as_any(&self) -> &dyn Any

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

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

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

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 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 Copy for RaycastableComponent

impl Debug for RaycastableComponent

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

Formats the value using the given formatter.

impl Default for RaycastableComponent

fn default() -> RaycastableComponent

Returns the “default value” for a type.