Struct OpacityComponent 

pub struct OpacityComponent {
    pub opacity: f32,
    pub multiple_layers: bool,
}

Per-instance opacity multiplier for a renderable.

Intended to be attached as a descendant of a RenderableComponent.

Note: opacity is a multiplier (0..1). It combines with the instance color alpha and any sampled texture alpha in the shader.

Fields

opacity: f32

multiple_layers: bool

If true, this renderable should be treated as requiring correct multi-layer blending.

This routes the instance into the sorted (slow) transparent pass. When false, the instance can use the instanced (fast) transparent pass.

Implementations

impl OpacityComponent

pub fn new() -> Self

Examples found in repository

examples/opacity-example.rs (line 130)

fn spawn_text_label_with_bg(
    universe: &mut engine::Universe,
    position: (f32, f32, f32),
    text: &str,
    bg_opacity: f32,
) {
    // T_root {
    //   T_bg { R_bg { Color black, Opacity } }
    //   T_scale { TXT { filtering } }
    // }

    let text_root = universe
        .world
        .add_component(TransformComponent::new().with_position(position.0, position.1, position.2));

    // Background quad (slightly behind the glyph quads).
    let (cols, rows) = text_block_dimensions(text);
    let text_scale = 0.18_f32;
    let pad_x = 0.55_f32;
    let pad_y = 0.45_f32;
    let bg_w = cols as f32 * text_scale + pad_x;
    let bg_h = rows as f32 * text_scale + pad_y;

    let bg_t = universe.world.add_component(
        TransformComponent::new()
            .with_position(1.5, 0.0, -0.02)
            .with_scale(bg_w, bg_h, 1.0),
    );
    let bg_r = universe.world.add_component(RenderableComponent::square());
    let _ = universe.attach(text_root, bg_t);
    let _ = universe.attach(bg_t, bg_r);

    let bg_c = universe
        .world
        .add_component(ColorComponent::rgba(0.0, 0.0, 0.0, 1.0));
    let _ = universe.attach(bg_r, bg_c);

    let bg_o = universe
        .world
        .add_component(OpacityComponent::new().with_opacity(bg_opacity));
    let _ = universe.attach(bg_r, bg_o);

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

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

    // Keep it crisp.
    let filtering = universe
        .world
        .add_component(TextureFilteringComponent::nearest());
    let _ = universe.attach(text_c, filtering);

    // Force the label into the transparent pass so it layers correctly with the background.
    // (Pass selection currently does not consider texture alpha.)
    let color = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 0.998));
    let _ = universe.attach(text_c, color);

    universe.add(text_root);
}

fn spawn_demo_spot(
    universe: &mut engine::Universe,
    spot_pos: (f32, f32, f32),
    opacity: f32,
    multiple_layers: bool,
    grid_n: i32,
) {
    let spot = universe
        .world
        .add_component(TransformComponent::new().with_position(spot_pos.0, spot_pos.1, spot_pos.2));

    // All cubes inherit this color.
    let white = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(spot, white);

    // All cubes inherit this opacity (no per-cube OpacityComponent needed).
    let mut oc = OpacityComponent::new().with_opacity(opacity);
    if multiple_layers {
        oc = oc.with_multiple_layers();
    }
    let oc = universe.world.add_component(oc);
    let _ = universe.attach(spot, oc);

    universe.add(spot);

    // Cube grid.
    let n = grid_n.max(1);
    let spacing = if n <= 2 { 1.0 } else { 0.6 };
    let cube_scale = if n <= 2 { 0.8 } else { 0.45 };
    let half = (n as f32 - 1.0) * spacing * 0.5;

    for z in 0..n {
        for y in 0..n {
            for x in 0..n {
                let px = x as f32 * spacing - half;
                let py = y as f32 * spacing;
                let pz = z as f32 * spacing - half;

                spawn_cube(
                    universe,
                    spot,
                    (px, py, pz),
                    (cube_scale, cube_scale, cube_scale),
                    None,
                    None,
                );
            }
        }
    }

    // Label above.
    let label = format!(
        "opacity: {:.2}\nmulti-layer: {}",
        opacity,
        if multiple_layers { "true" } else { "false" }
    );
    // Keep labels away from the cube volume so they don't intersect.
    let label_y = spot_pos.1 + (n as f32 * spacing) + 1.8;
    let label_x = spot_pos.0 - (half + 0.6);
    let label_z = spot_pos.2 - (half + 1.0);
    spawn_text_label(universe, (label_x, label_y, label_z), &label);
}

fn spawn_demo_strip_pair(
    universe: &mut engine::Universe,
    spot_pos: (f32, f32, f32),
    transparent_multiple_layers: bool,
) {
    let n_z: i32 = 4;
    let spacing = 1.0;
    let cube_scale = 0.8;
    let half_z = (n_z as f32 - 1.0) * spacing * 0.5;

    // Transparent strip (1x4 along Z).
    let transparent_root = universe
        .world
        .add_component(TransformComponent::new().with_position(spot_pos.0, spot_pos.1, spot_pos.2));

    let white = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(transparent_root, white);

    let mut oc = OpacityComponent::new().with_opacity(0.50);
    if transparent_multiple_layers {
        oc = oc.with_multiple_layers();
    }
    let oc = universe.world.add_component(oc);
    let _ = universe.attach(transparent_root, oc);

    universe.add(transparent_root);

    for z in 0..n_z {
        let pz = z as f32 * spacing - half_z;
        spawn_cube(
            universe,
            transparent_root,
            (0.0, 0.0, pz),
            (cube_scale, cube_scale, cube_scale),
            None,
            None,
        );
    }

    // Opaque strip to the left, same spacing/scale.
    let opaque_root = universe
        .world
        .add_component(TransformComponent::new().with_position(
            spot_pos.0 - spacing,
            spot_pos.1,
            spot_pos.2,
        ));
    let white = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(opaque_root, white);
    universe.add(opaque_root);

    for z in 0..n_z {
        let pz = z as f32 * spacing - half_z;
        spawn_cube(
            universe,
            opaque_root,
            (0.0, 0.0, pz),
            (cube_scale, cube_scale, cube_scale),
            None,
            None,
        );
    }

    let label = format!(
        "mini: opaque + transparent strip\ntransparent opacity: 0.50\nmulti-layer: {}",
        if transparent_multiple_layers {
            "true"
        } else {
            "false"
        }
    );
    let label_y = spot_pos.1 + spacing + 1.8;
    let label_x = spot_pos.0 - (spacing * 2.6);
    let label_z = spot_pos.2 - (half_z + 1.0);
    spawn_text_label(universe, (label_x, label_y, label_z), &label);
}

fn spawn_demo_xy_plane(
    universe: &mut engine::Universe,
    spot_pos: (f32, f32, f32),
    opacity: f32,
    n_x: i32,
    n_y: i32,
    z: f32,
) {
    let spot = universe
        .world
        .add_component(TransformComponent::new().with_position(spot_pos.0, spot_pos.1, spot_pos.2));

    let white = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(spot, white);

    let oc = universe
        .world
        .add_component(OpacityComponent::new().with_opacity(opacity));
    let _ = universe.attach(spot, oc);

    universe.add(spot);

    let nx = n_x.max(1);
    let ny = n_y.max(1);
    let spacing = 0.45;
    let cube_scale = 0.35;
    let half_x = (nx as f32 - 1.0) * spacing * 0.5;

    for y in 0..ny {
        for x in 0..nx {
            let px = x as f32 * spacing - half_x;
            let py = y as f32 * spacing;
            spawn_cube(
                universe,
                spot,
                (px, py, z),
                (cube_scale, cube_scale, cube_scale),
                None,
                None,
            );
        }
    }

    // Label in front of the plane.
    let label = format!(
        "XY plane: {}x{}\nopacity: {:.2}\nmulti-layer: false",
        nx, ny, opacity
    );
    let label_x = spot_pos.0 - (half_x + 0.6);
    let label_y = spot_pos.1 + (ny as f32 * spacing) + 1.2;
    let label_z = spot_pos.2 - 2.5;
    spawn_text_label_with_bg(universe, (label_x, label_y, label_z), &label, 0.50);
}

pub fn with_value(self, value: u8) -> Self

Convenience: set opacity from an 8-bit value (0..255).

pub fn with_opacity(self, opacity: f32) -> Self

Examples found in repository

examples/opacity-example.rs (line 130)

fn spawn_text_label_with_bg(
    universe: &mut engine::Universe,
    position: (f32, f32, f32),
    text: &str,
    bg_opacity: f32,
) {
    // T_root {
    //   T_bg { R_bg { Color black, Opacity } }
    //   T_scale { TXT { filtering } }
    // }

    let text_root = universe
        .world
        .add_component(TransformComponent::new().with_position(position.0, position.1, position.2));

    // Background quad (slightly behind the glyph quads).
    let (cols, rows) = text_block_dimensions(text);
    let text_scale = 0.18_f32;
    let pad_x = 0.55_f32;
    let pad_y = 0.45_f32;
    let bg_w = cols as f32 * text_scale + pad_x;
    let bg_h = rows as f32 * text_scale + pad_y;

    let bg_t = universe.world.add_component(
        TransformComponent::new()
            .with_position(1.5, 0.0, -0.02)
            .with_scale(bg_w, bg_h, 1.0),
    );
    let bg_r = universe.world.add_component(RenderableComponent::square());
    let _ = universe.attach(text_root, bg_t);
    let _ = universe.attach(bg_t, bg_r);

    let bg_c = universe
        .world
        .add_component(ColorComponent::rgba(0.0, 0.0, 0.0, 1.0));
    let _ = universe.attach(bg_r, bg_c);

    let bg_o = universe
        .world
        .add_component(OpacityComponent::new().with_opacity(bg_opacity));
    let _ = universe.attach(bg_r, bg_o);

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

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

    // Keep it crisp.
    let filtering = universe
        .world
        .add_component(TextureFilteringComponent::nearest());
    let _ = universe.attach(text_c, filtering);

    // Force the label into the transparent pass so it layers correctly with the background.
    // (Pass selection currently does not consider texture alpha.)
    let color = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 0.998));
    let _ = universe.attach(text_c, color);

    universe.add(text_root);
}

fn spawn_demo_spot(
    universe: &mut engine::Universe,
    spot_pos: (f32, f32, f32),
    opacity: f32,
    multiple_layers: bool,
    grid_n: i32,
) {
    let spot = universe
        .world
        .add_component(TransformComponent::new().with_position(spot_pos.0, spot_pos.1, spot_pos.2));

    // All cubes inherit this color.
    let white = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(spot, white);

    // All cubes inherit this opacity (no per-cube OpacityComponent needed).
    let mut oc = OpacityComponent::new().with_opacity(opacity);
    if multiple_layers {
        oc = oc.with_multiple_layers();
    }
    let oc = universe.world.add_component(oc);
    let _ = universe.attach(spot, oc);

    universe.add(spot);

    // Cube grid.
    let n = grid_n.max(1);
    let spacing = if n <= 2 { 1.0 } else { 0.6 };
    let cube_scale = if n <= 2 { 0.8 } else { 0.45 };
    let half = (n as f32 - 1.0) * spacing * 0.5;

    for z in 0..n {
        for y in 0..n {
            for x in 0..n {
                let px = x as f32 * spacing - half;
                let py = y as f32 * spacing;
                let pz = z as f32 * spacing - half;

                spawn_cube(
                    universe,
                    spot,
                    (px, py, pz),
                    (cube_scale, cube_scale, cube_scale),
                    None,
                    None,
                );
            }
        }
    }

    // Label above.
    let label = format!(
        "opacity: {:.2}\nmulti-layer: {}",
        opacity,
        if multiple_layers { "true" } else { "false" }
    );
    // Keep labels away from the cube volume so they don't intersect.
    let label_y = spot_pos.1 + (n as f32 * spacing) + 1.8;
    let label_x = spot_pos.0 - (half + 0.6);
    let label_z = spot_pos.2 - (half + 1.0);
    spawn_text_label(universe, (label_x, label_y, label_z), &label);
}

fn spawn_demo_strip_pair(
    universe: &mut engine::Universe,
    spot_pos: (f32, f32, f32),
    transparent_multiple_layers: bool,
) {
    let n_z: i32 = 4;
    let spacing = 1.0;
    let cube_scale = 0.8;
    let half_z = (n_z as f32 - 1.0) * spacing * 0.5;

    // Transparent strip (1x4 along Z).
    let transparent_root = universe
        .world
        .add_component(TransformComponent::new().with_position(spot_pos.0, spot_pos.1, spot_pos.2));

    let white = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(transparent_root, white);

    let mut oc = OpacityComponent::new().with_opacity(0.50);
    if transparent_multiple_layers {
        oc = oc.with_multiple_layers();
    }
    let oc = universe.world.add_component(oc);
    let _ = universe.attach(transparent_root, oc);

    universe.add(transparent_root);

    for z in 0..n_z {
        let pz = z as f32 * spacing - half_z;
        spawn_cube(
            universe,
            transparent_root,
            (0.0, 0.0, pz),
            (cube_scale, cube_scale, cube_scale),
            None,
            None,
        );
    }

    // Opaque strip to the left, same spacing/scale.
    let opaque_root = universe
        .world
        .add_component(TransformComponent::new().with_position(
            spot_pos.0 - spacing,
            spot_pos.1,
            spot_pos.2,
        ));
    let white = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(opaque_root, white);
    universe.add(opaque_root);

    for z in 0..n_z {
        let pz = z as f32 * spacing - half_z;
        spawn_cube(
            universe,
            opaque_root,
            (0.0, 0.0, pz),
            (cube_scale, cube_scale, cube_scale),
            None,
            None,
        );
    }

    let label = format!(
        "mini: opaque + transparent strip\ntransparent opacity: 0.50\nmulti-layer: {}",
        if transparent_multiple_layers {
            "true"
        } else {
            "false"
        }
    );
    let label_y = spot_pos.1 + spacing + 1.8;
    let label_x = spot_pos.0 - (spacing * 2.6);
    let label_z = spot_pos.2 - (half_z + 1.0);
    spawn_text_label(universe, (label_x, label_y, label_z), &label);
}

fn spawn_demo_xy_plane(
    universe: &mut engine::Universe,
    spot_pos: (f32, f32, f32),
    opacity: f32,
    n_x: i32,
    n_y: i32,
    z: f32,
) {
    let spot = universe
        .world
        .add_component(TransformComponent::new().with_position(spot_pos.0, spot_pos.1, spot_pos.2));

    let white = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(spot, white);

    let oc = universe
        .world
        .add_component(OpacityComponent::new().with_opacity(opacity));
    let _ = universe.attach(spot, oc);

    universe.add(spot);

    let nx = n_x.max(1);
    let ny = n_y.max(1);
    let spacing = 0.45;
    let cube_scale = 0.35;
    let half_x = (nx as f32 - 1.0) * spacing * 0.5;

    for y in 0..ny {
        for x in 0..nx {
            let px = x as f32 * spacing - half_x;
            let py = y as f32 * spacing;
            spawn_cube(
                universe,
                spot,
                (px, py, z),
                (cube_scale, cube_scale, cube_scale),
                None,
                None,
            );
        }
    }

    // Label in front of the plane.
    let label = format!(
        "XY plane: {}x{}\nopacity: {:.2}\nmulti-layer: false",
        nx, ny, opacity
    );
    let label_x = spot_pos.0 - (half_x + 0.6);
    let label_y = spot_pos.1 + (ny as f32 * spacing) + 1.2;
    let label_z = spot_pos.2 - 2.5;
    spawn_text_label_with_bg(universe, (label_x, label_y, label_z), &label, 0.50);
}

pub fn with_multiple_layers(self) -> Self

Mark this opacity as requiring correct multi-layer blending.

This opts the renderable into the sorted transparent pass (no instancing).

Examples found in repository

examples/opacity-example.rs (line 177)

fn spawn_demo_spot(
    universe: &mut engine::Universe,
    spot_pos: (f32, f32, f32),
    opacity: f32,
    multiple_layers: bool,
    grid_n: i32,
) {
    let spot = universe
        .world
        .add_component(TransformComponent::new().with_position(spot_pos.0, spot_pos.1, spot_pos.2));

    // All cubes inherit this color.
    let white = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(spot, white);

    // All cubes inherit this opacity (no per-cube OpacityComponent needed).
    let mut oc = OpacityComponent::new().with_opacity(opacity);
    if multiple_layers {
        oc = oc.with_multiple_layers();
    }
    let oc = universe.world.add_component(oc);
    let _ = universe.attach(spot, oc);

    universe.add(spot);

    // Cube grid.
    let n = grid_n.max(1);
    let spacing = if n <= 2 { 1.0 } else { 0.6 };
    let cube_scale = if n <= 2 { 0.8 } else { 0.45 };
    let half = (n as f32 - 1.0) * spacing * 0.5;

    for z in 0..n {
        for y in 0..n {
            for x in 0..n {
                let px = x as f32 * spacing - half;
                let py = y as f32 * spacing;
                let pz = z as f32 * spacing - half;

                spawn_cube(
                    universe,
                    spot,
                    (px, py, pz),
                    (cube_scale, cube_scale, cube_scale),
                    None,
                    None,
                );
            }
        }
    }

    // Label above.
    let label = format!(
        "opacity: {:.2}\nmulti-layer: {}",
        opacity,
        if multiple_layers { "true" } else { "false" }
    );
    // Keep labels away from the cube volume so they don't intersect.
    let label_y = spot_pos.1 + (n as f32 * spacing) + 1.8;
    let label_x = spot_pos.0 - (half + 0.6);
    let label_z = spot_pos.2 - (half + 1.0);
    spawn_text_label(universe, (label_x, label_y, label_z), &label);
}

fn spawn_demo_strip_pair(
    universe: &mut engine::Universe,
    spot_pos: (f32, f32, f32),
    transparent_multiple_layers: bool,
) {
    let n_z: i32 = 4;
    let spacing = 1.0;
    let cube_scale = 0.8;
    let half_z = (n_z as f32 - 1.0) * spacing * 0.5;

    // Transparent strip (1x4 along Z).
    let transparent_root = universe
        .world
        .add_component(TransformComponent::new().with_position(spot_pos.0, spot_pos.1, spot_pos.2));

    let white = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(transparent_root, white);

    let mut oc = OpacityComponent::new().with_opacity(0.50);
    if transparent_multiple_layers {
        oc = oc.with_multiple_layers();
    }
    let oc = universe.world.add_component(oc);
    let _ = universe.attach(transparent_root, oc);

    universe.add(transparent_root);

    for z in 0..n_z {
        let pz = z as f32 * spacing - half_z;
        spawn_cube(
            universe,
            transparent_root,
            (0.0, 0.0, pz),
            (cube_scale, cube_scale, cube_scale),
            None,
            None,
        );
    }

    // Opaque strip to the left, same spacing/scale.
    let opaque_root = universe
        .world
        .add_component(TransformComponent::new().with_position(
            spot_pos.0 - spacing,
            spot_pos.1,
            spot_pos.2,
        ));
    let white = universe
        .world
        .add_component(ColorComponent::rgba(1.0, 1.0, 1.0, 1.0));
    let _ = universe.attach(opaque_root, white);
    universe.add(opaque_root);

    for z in 0..n_z {
        let pz = z as f32 * spacing - half_z;
        spawn_cube(
            universe,
            opaque_root,
            (0.0, 0.0, pz),
            (cube_scale, cube_scale, cube_scale),
            None,
            None,
        );
    }

    let label = format!(
        "mini: opaque + transparent strip\ntransparent opacity: 0.50\nmulti-layer: {}",
        if transparent_multiple_layers {
            "true"
        } else {
            "false"
        }
    );
    let label_y = spot_pos.1 + spacing + 1.8;
    let label_x = spot_pos.0 - (spacing * 2.6);
    let label_z = spot_pos.2 - (half_z + 1.0);
    spawn_text_label(universe, (label_x, label_y, label_z), &label);
}

Trait Implementations

impl Clone for OpacityComponent

fn clone(&self) -> OpacityComponent

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for OpacityComponent

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

impl Debug for OpacityComponent

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

Formats the value using the given formatter.

impl Default for OpacityComponent

fn default() -> Self

Returns the “default value” for a type.