Enum LogicGate 

pub enum LogicGate {
    BoolAnd,
    BoolOr,
    BoolXor,
    BoolNand,
    BoolNor,
    BoolNot,
    BitAnd,
    BitOr,
    BitXor,
    BitNand,
    BitNor,
    BitNot,
    BitShiftLeft,
    BitShiftRight,
    Add,
    Sub,
    Mul,
    ModFloored,
    Mod,
    Div,
    Ceil,
    Floor,
    Blend,
    Eq,
    Neq,
    Lt,
    Leq,
    Gt,
    Geq,
    Const,
    EdgeDetector,
}

Variants

BoolAnd

BoolOr

BoolXor

BoolNand

BoolNor

BoolNot

BitAnd

BitOr

BitXor

BitNand

BitNor

BitNot

BitShiftLeft

BitShiftRight

Add

Sub

Mul

ModFloored

Mod

Div

Ceil

Floor

Blend

Eq

Neq

Lt

Leq

Gt

Geq

Const

EdgeDetector

Implementations

impl LogicGate

pub const COMPONENT_BOOL_AND: BString

pub const COMPONENT_BOOL_OR: BString

pub const COMPONENT_BOOL_XOR: BString

pub const COMPONENT_BOOL_NAND: BString

pub const COMPONENT_BOOL_NOR: BString

pub const COMPONENT_BOOL_NOT: BString

pub const COMPONENT_BIT_AND: BString

pub const COMPONENT_BIT_OR: BString

pub const COMPONENT_BIT_XOR: BString

pub const COMPONENT_BIT_NAND: BString

pub const COMPONENT_BIT_NOR: BString

pub const COMPONENT_BIT_NOT: BString

pub const COMPONENT_BIT_SHIFT_LEFT: BString

pub const COMPONENT_BIT_SHIFT_RIGHT: BString

pub const COMPONENT_SUB: BString

pub const COMPONENT_MUL: BString

pub const COMPONENT_MOD_FLOORED: BString

pub const COMPONENT_MOD: BString

pub const COMPONENT_DIV: BString

pub const COMPONENT_ADD: BString

pub const COMPONENT_CEIL: BString

pub const COMPONENT_FLOOR: BString

pub const COMPONENT_EQ: BString

pub const COMPONENT_NEQ: BString

pub const COMPONENT_LT: BString

pub const COMPONENT_LEQ: BString

pub const COMPONENT_GT: BString

pub const COMPONENT_GEQ: BString

pub const COMPONENT_CONST: BString

pub const COMPONENT_BLEND: BString

pub const COMPONENT_EDGE_DETECTOR: BString

pub const STRUCT_BOOL_BOOL_STR: &str = "BrickComponentData_WireGraph_Expr_Bool_Bool"

pub const STRUCT_BINARY_BOOLBOOL_BOOL_STR: &str = "BrickComponentData_WireGraph_Expr_BoolBool_Bool"

pub const STRUCT_COMPARE_STR: &str = "BrickComponentData_WireGraph_Expr_Compare"

pub const STRUCT_FLOAT_FLOAT_STR: &str = "BrickComponentData_WireGraph_Expr_Float_Float"

pub const STRUCT_INT_INT_STR: &str = "BrickComponentData_WireGraph_Expr_Int_Int"

pub const STRUCT_BINARY_INTINT_INT_STR: &str = "BrickComponentData_WireGraph_Expr_IntInt_Int"

pub const STRUCT_MATH_COMPARE_STR: &str = "BrickComponentData_WireGraph_Expr_MathCompare"

pub const STRUCT_NUMNUM_NUM_STR: &str = "BrickComponentData_WireGraph_Expr_PrimMathVariantPrimMathVariant_PrimMathVariant"

pub const STRUCT_CONSTANT_STR: &str = "BrickComponentData_WireGraphPseudo_Const"

pub const STRUCT_BLEND_STR: &str = "BrickComponentData_WireGraph_Expr_MathBlend"

pub const STRUCT_EDGE_DETECTOR_STR: &str = "BrickComponentData_WireGraph_Expr_EdgeDetector"

pub const STRUCT_BOOL_BOOL: BString

pub const STRUCT_BINARY_BOOLBOOL_BOOL: BString

pub const STRUCT_COMPARE: BString

pub const STRUCT_FLOAT_FLOAT: BString

pub const STRUCT_INT_INT: BString

pub const STRUCT_INTINT_INT: BString

pub const STRUCT_MATH_COMPARE: BString

pub const STRUCT_NUMNUM_NUM: BString

pub const STRUCT_CONST: BString

pub const STRUCT_BLEND: BString

pub const STRUCT_EDGE_DETECTOR: BString

pub const BOOL_INPUT: BString

pub const BOOL_INPUT_A: BString

pub const BOOL_INPUT_B: BString

pub const BOOL_OUTPUT: BString

pub const INPUT: BString

pub const BLEND: BString

pub const INPUT_A: BString

pub const INPUT_B: BString

pub const OUTPUT: BString

pub const VALUE: BString

pub const RISING_EDGE: BString

pub const FALLING_EDGE: BString

pub const fn component_name(&self) -> BString

pub const fn is_bool_input(&self) -> bool

pub const fn is_bool_output(&self) -> bool

pub const fn struct_name(&self) -> BString

pub fn schema(&self) -> BrdbSchemaMeta

pub fn wire_port_names(&self) -> Vec<BString>

pub fn data_index(&self, name: &str) -> (Option<usize>, Option<usize>)

pub fn num_inputs(&self) -> usize

pub fn default_inputs(&self) -> Vec<Box<dyn AsBrdbValue>>

pub fn default_outputs(&self) -> Vec<Box<dyn AsBrdbValue>>

pub fn input_of(&self, brick_id: usize) -> WirePort

pub fn input_a_of(&self, brick_id: usize) -> WirePort

Examples found in repository

examples/write_fixtures.rs (line 194)

fn wires_world() -> World {
    // Mirror of examples/write_wire.rs (single grid, single chunk — fully
    // deterministic), extended to 3 bricks/2 wires: a boolean NOT gate feeds
    // one input of an AND gate, whose output feeds a rerouter.
    let mut world = World::new();
    world.register_all_components();
    world.meta.bundle.description = "Wire fixture".to_string();

    let (a, a_id) = Brick {
        position: (30, 0, 1).into(),
        color: (255, 0, 0).into(),
        asset: assets::bricks::B_REROUTE,
        ..Default::default()
    }
    .with_component(assets::components::Rerouter)
    .with_id_split();
    let (b, b_id) = Brick {
        position: (15, 0, 1).into(),
        color: (0, 255, 0).into(),
        asset: assets::components::LogicGate::BoolAnd.brick(),
        ..Default::default()
    }
    .with_component(assets::components::LogicGate::BoolAnd.component())
    .with_id_split();
    let (c, c_id) = Brick {
        position: (0, 0, 1).into(),
        color: (0, 0, 255).into(),
        asset: assets::components::LogicGate::BoolNot.brick(),
        ..Default::default()
    }
    .with_component(assets::components::LogicGate::BoolNot.component())
    .with_id_split();

    world.add_bricks([a, b, c]);
    // Wire 1: NOT.output -> AND.inputA
    world.add_wire_connection(
        assets::components::LogicGate::BoolNot.output_of(c_id),
        assets::components::LogicGate::BoolAnd.input_a_of(b_id),
    );
    // Wire 2: AND.output -> Rerouter.input
    world.add_wire_connection(
        assets::components::LogicGate::BoolAnd.output_of(b_id),
        assets::components::Rerouter::input_of(a_id),
    );

    world
}

pub fn input_b_of(&self, brick_id: usize) -> WirePort

pub fn input_blend_of(&self, brick_id: usize) -> WirePort

pub fn output_of(&self, brick_id: usize) -> WirePort

Examples found in repository

examples/write_wire.rs (line 35)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = PathBuf::from("./example_wire.brdb");

    // Ensures the memory db can be created without errors
    let db = Brdb::new(&path)?.into_reader();
    let mut world = World::new();
    // Register the built-in component type/struct mappings so the gate and
    // rerouter component types resolve when writing.
    world.register_all_components();
    world.meta.bundle.description = "Example World".to_string();

    let (a, a_id) = Brick {
        position: (0, 0, 1).into(),
        color: (255, 0, 0).into(),
        asset: assets::bricks::B_REROUTE,
        ..Default::default()
    }
    .with_component(assets::components::Rerouter)
    .with_id_split();
    let (b, b_id) = Brick {
        position: (15, 0, 1).into(),
        color: (255, 0, 0).into(),
        asset: assets::components::LogicGate::BoolNot.brick(),
        ..Default::default()
    }
    .with_component(assets::components::LogicGate::BoolNot.component())
    .with_id_split();

    world.add_bricks([a, b]);
    world.add_wire_connection(
        assets::components::LogicGate::BoolNot.output_of(b_id),
        assets::components::Rerouter::input_of(a_id),
    );

    db.save("example world", &world)?;

    println!("{}", db.get_fs()?.render());

    Ok(())
}

examples/write_fixtures.rs (line 193)

fn wires_world() -> World {
    // Mirror of examples/write_wire.rs (single grid, single chunk — fully
    // deterministic), extended to 3 bricks/2 wires: a boolean NOT gate feeds
    // one input of an AND gate, whose output feeds a rerouter.
    let mut world = World::new();
    world.register_all_components();
    world.meta.bundle.description = "Wire fixture".to_string();

    let (a, a_id) = Brick {
        position: (30, 0, 1).into(),
        color: (255, 0, 0).into(),
        asset: assets::bricks::B_REROUTE,
        ..Default::default()
    }
    .with_component(assets::components::Rerouter)
    .with_id_split();
    let (b, b_id) = Brick {
        position: (15, 0, 1).into(),
        color: (0, 255, 0).into(),
        asset: assets::components::LogicGate::BoolAnd.brick(),
        ..Default::default()
    }
    .with_component(assets::components::LogicGate::BoolAnd.component())
    .with_id_split();
    let (c, c_id) = Brick {
        position: (0, 0, 1).into(),
        color: (0, 0, 255).into(),
        asset: assets::components::LogicGate::BoolNot.brick(),
        ..Default::default()
    }
    .with_component(assets::components::LogicGate::BoolNot.component())
    .with_id_split();

    world.add_bricks([a, b, c]);
    // Wire 1: NOT.output -> AND.inputA
    world.add_wire_connection(
        assets::components::LogicGate::BoolNot.output_of(c_id),
        assets::components::LogicGate::BoolAnd.input_a_of(b_id),
    );
    // Wire 2: AND.output -> Rerouter.input
    world.add_wire_connection(
        assets::components::LogicGate::BoolAnd.output_of(b_id),
        assets::components::Rerouter::input_of(a_id),
    );

    world
}

pub fn rising_edge_of(&self, brick_id: usize) -> WirePort

pub fn falling_edge_of(&self, brick_id: usize) -> WirePort

pub fn component(self) -> LogicGateComponent

Examples found in repository

examples/write_wire.rs (line 30)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = PathBuf::from("./example_wire.brdb");

    // Ensures the memory db can be created without errors
    let db = Brdb::new(&path)?.into_reader();
    let mut world = World::new();
    // Register the built-in component type/struct mappings so the gate and
    // rerouter component types resolve when writing.
    world.register_all_components();
    world.meta.bundle.description = "Example World".to_string();

    let (a, a_id) = Brick {
        position: (0, 0, 1).into(),
        color: (255, 0, 0).into(),
        asset: assets::bricks::B_REROUTE,
        ..Default::default()
    }
    .with_component(assets::components::Rerouter)
    .with_id_split();
    let (b, b_id) = Brick {
        position: (15, 0, 1).into(),
        color: (255, 0, 0).into(),
        asset: assets::components::LogicGate::BoolNot.brick(),
        ..Default::default()
    }
    .with_component(assets::components::LogicGate::BoolNot.component())
    .with_id_split();

    world.add_bricks([a, b]);
    world.add_wire_connection(
        assets::components::LogicGate::BoolNot.output_of(b_id),
        assets::components::Rerouter::input_of(a_id),
    );

    db.save("example world", &world)?;

    println!("{}", db.get_fs()?.render());

    Ok(())
}

examples/write_fixtures.rs (line 179)

fn wires_world() -> World {
    // Mirror of examples/write_wire.rs (single grid, single chunk — fully
    // deterministic), extended to 3 bricks/2 wires: a boolean NOT gate feeds
    // one input of an AND gate, whose output feeds a rerouter.
    let mut world = World::new();
    world.register_all_components();
    world.meta.bundle.description = "Wire fixture".to_string();

    let (a, a_id) = Brick {
        position: (30, 0, 1).into(),
        color: (255, 0, 0).into(),
        asset: assets::bricks::B_REROUTE,
        ..Default::default()
    }
    .with_component(assets::components::Rerouter)
    .with_id_split();
    let (b, b_id) = Brick {
        position: (15, 0, 1).into(),
        color: (0, 255, 0).into(),
        asset: assets::components::LogicGate::BoolAnd.brick(),
        ..Default::default()
    }
    .with_component(assets::components::LogicGate::BoolAnd.component())
    .with_id_split();
    let (c, c_id) = Brick {
        position: (0, 0, 1).into(),
        color: (0, 0, 255).into(),
        asset: assets::components::LogicGate::BoolNot.brick(),
        ..Default::default()
    }
    .with_component(assets::components::LogicGate::BoolNot.component())
    .with_id_split();

    world.add_bricks([a, b, c]);
    // Wire 1: NOT.output -> AND.inputA
    world.add_wire_connection(
        assets::components::LogicGate::BoolNot.output_of(c_id),
        assets::components::LogicGate::BoolAnd.input_a_of(b_id),
    );
    // Wire 2: AND.output -> Rerouter.input
    world.add_wire_connection(
        assets::components::LogicGate::BoolAnd.output_of(b_id),
        assets::components::Rerouter::input_of(a_id),
    );

    world
}

pub fn component_with_overrides( self, overrides: HashMap<BString, Box<dyn AsBrdbValue>>, ) -> LogicGateComponent

Examples found in repository

examples/write_fixtures.rs (lines 306-315)

fn components_world() -> World {
    // Single grid, single chunk (all positions < 2048) — fully deterministic.
    // register_all_components() embeds the full component catalog so every
    // type below (light/interact/wiregraph-pseudo/expr) resolves; each
    // component below carries non-default property values, and #4/#5 exercise
    // a WireGraphVariant-typed property (BufferTicks' Input/Output, and the
    // Constant gate's Value).
    let mut world = World::new();
    world.register_all_components();
    world.meta.bundle.description = "Component fixture".to_string();

    // 1: Point light — non-default brightness/radius/color, decoupled from
    // brick color (bUseBrickColor: false).
    world.bricks.push(
        Brick {
            position: (0, 0, 6).into(),
            color: (255, 255, 255).into(),
            ..Default::default()
        }
        .with_component(assets::LiteralComponent::new("Component_PointLight").with_data([
            ("bMatchBrickShape", Box::new(false) as Box<dyn AsBrdbValue>),
            ("bEnabled", Box::new(true)),
            ("Brightness", Box::new(500.0f32)),
            ("Radius", Box::new(800.0f32)),
            (
                "Color",
                Box::new(SavedBrickColor { r: 10, g: 20, b: 30, a: 255 }),
            ),
            ("bUseBrickColor", Box::new(false)),
            ("bCastShadows", Box::new(true)),
        ])),
    );

    // 2: Spot light — narrow cone, non-default brightness/color.
    world.bricks.push(
        Brick {
            position: (20, 0, 6).into(),
            color: (255, 255, 0).into(),
            ..Default::default()
        }
        .with_component(assets::LiteralComponent::new("Component_SpotLight").with_data([
            ("InnerConeAngle", Box::new(15.0f32) as Box<dyn AsBrdbValue>),
            ("OuterConeAngle", Box::new(45.0f32)),
            ("bEnabled", Box::new(true)),
            ("Brightness", Box::new(300.0f32)),
            ("Radius", Box::new(600.0f32)),
            (
                "Color",
                Box::new(SavedBrickColor { r: 255, g: 0, b: 0, a: 255 }),
            ),
            ("bUseBrickColor", Box::new(false)),
            ("bCastShadows", Box::new(true)),
        ])),
    );

    // 3: Interact — custom prompt text, hidden interaction.
    world.bricks.push(
        Brick {
            position: (40, 0, 6).into(),
            color: (0, 255, 255).into(),
            ..Default::default()
        }
        .with_component(assets::LiteralComponent::new("Component_Interact").with_data([
            (
                "Message",
                Box::new("You interacted!".to_string()) as Box<dyn AsBrdbValue>,
            ),
            ("ConsoleTag", Box::new("fixture_interact".to_string())),
            ("bAllowNearbyInteraction", Box::new(false)),
            ("bHiddenInteraction", Box::new(true)),
            ("PromptCustomLabel", Box::new("Open Door".to_string())),
        ])),
    );

    // 4: Buffer (ticks) — WireGraphPseudo component whose Input/Output are
    // WireGraphVariant; non-default counters plus a Number/Bool variant pair.
    world.bricks.push(
        Brick {
            position: (60, 0, 1).into(),
            color: (128, 0, 128).into(),
            asset: assets::components::BufferTicks::default().brick(),
            ..Default::default()
        }
        .with_component(assets::components::BufferTicks {
            current_ticks: 3,
            ticks_to_wait: 10,
            input: WireVariant::Number(2.5),
            output: WireVariant::Bool(true),
        }),
    );

    // 5: Blend gate — WireGraph_Expr_MathBlend's InputA/InputB are each a
    // WireGraphPrimMathVariant (here an f64 and an i64 tag, showing the
    // variant is polymorphic per-port); Blend itself is a plain f64.
    world.bricks.push(
        Brick {
            position: (80, 0, 1).into(),
            color: (0, 128, 0).into(),
            asset: assets::components::LogicGate::Blend.brick(),
            ..Default::default()
        }
        .with_component(assets::components::LogicGate::Blend.component_with_overrides(
            HashMap::from([
                (
                    "InputA".into(),
                    Box::new(WireVariant::Number(10.0)) as Box<dyn AsBrdbValue>,
                ),
                ("InputB".into(), Box::new(WireVariant::Int(7))),
                ("Blend".into(), Box::new(0.75f64)),
            ]),
        )),
    );

    world
}

pub fn brick(self) -> BrickType

Examples found in repository

examples/write_wire.rs (line 27)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = PathBuf::from("./example_wire.brdb");

    // Ensures the memory db can be created without errors
    let db = Brdb::new(&path)?.into_reader();
    let mut world = World::new();
    // Register the built-in component type/struct mappings so the gate and
    // rerouter component types resolve when writing.
    world.register_all_components();
    world.meta.bundle.description = "Example World".to_string();

    let (a, a_id) = Brick {
        position: (0, 0, 1).into(),
        color: (255, 0, 0).into(),
        asset: assets::bricks::B_REROUTE,
        ..Default::default()
    }
    .with_component(assets::components::Rerouter)
    .with_id_split();
    let (b, b_id) = Brick {
        position: (15, 0, 1).into(),
        color: (255, 0, 0).into(),
        asset: assets::components::LogicGate::BoolNot.brick(),
        ..Default::default()
    }
    .with_component(assets::components::LogicGate::BoolNot.component())
    .with_id_split();

    world.add_bricks([a, b]);
    world.add_wire_connection(
        assets::components::LogicGate::BoolNot.output_of(b_id),
        assets::components::Rerouter::input_of(a_id),
    );

    db.save("example world", &world)?;

    println!("{}", db.get_fs()?.render());

    Ok(())
}

examples/write_fixtures.rs (line 176)

fn wires_world() -> World {
    // Mirror of examples/write_wire.rs (single grid, single chunk — fully
    // deterministic), extended to 3 bricks/2 wires: a boolean NOT gate feeds
    // one input of an AND gate, whose output feeds a rerouter.
    let mut world = World::new();
    world.register_all_components();
    world.meta.bundle.description = "Wire fixture".to_string();

    let (a, a_id) = Brick {
        position: (30, 0, 1).into(),
        color: (255, 0, 0).into(),
        asset: assets::bricks::B_REROUTE,
        ..Default::default()
    }
    .with_component(assets::components::Rerouter)
    .with_id_split();
    let (b, b_id) = Brick {
        position: (15, 0, 1).into(),
        color: (0, 255, 0).into(),
        asset: assets::components::LogicGate::BoolAnd.brick(),
        ..Default::default()
    }
    .with_component(assets::components::LogicGate::BoolAnd.component())
    .with_id_split();
    let (c, c_id) = Brick {
        position: (0, 0, 1).into(),
        color: (0, 0, 255).into(),
        asset: assets::components::LogicGate::BoolNot.brick(),
        ..Default::default()
    }
    .with_component(assets::components::LogicGate::BoolNot.component())
    .with_id_split();

    world.add_bricks([a, b, c]);
    // Wire 1: NOT.output -> AND.inputA
    world.add_wire_connection(
        assets::components::LogicGate::BoolNot.output_of(c_id),
        assets::components::LogicGate::BoolAnd.input_a_of(b_id),
    );
    // Wire 2: AND.output -> Rerouter.input
    world.add_wire_connection(
        assets::components::LogicGate::BoolAnd.output_of(b_id),
        assets::components::Rerouter::input_of(a_id),
    );

    world
}

fn components_world() -> World {
    // Single grid, single chunk (all positions < 2048) — fully deterministic.
    // register_all_components() embeds the full component catalog so every
    // type below (light/interact/wiregraph-pseudo/expr) resolves; each
    // component below carries non-default property values, and #4/#5 exercise
    // a WireGraphVariant-typed property (BufferTicks' Input/Output, and the
    // Constant gate's Value).
    let mut world = World::new();
    world.register_all_components();
    world.meta.bundle.description = "Component fixture".to_string();

    // 1: Point light — non-default brightness/radius/color, decoupled from
    // brick color (bUseBrickColor: false).
    world.bricks.push(
        Brick {
            position: (0, 0, 6).into(),
            color: (255, 255, 255).into(),
            ..Default::default()
        }
        .with_component(assets::LiteralComponent::new("Component_PointLight").with_data([
            ("bMatchBrickShape", Box::new(false) as Box<dyn AsBrdbValue>),
            ("bEnabled", Box::new(true)),
            ("Brightness", Box::new(500.0f32)),
            ("Radius", Box::new(800.0f32)),
            (
                "Color",
                Box::new(SavedBrickColor { r: 10, g: 20, b: 30, a: 255 }),
            ),
            ("bUseBrickColor", Box::new(false)),
            ("bCastShadows", Box::new(true)),
        ])),
    );

    // 2: Spot light — narrow cone, non-default brightness/color.
    world.bricks.push(
        Brick {
            position: (20, 0, 6).into(),
            color: (255, 255, 0).into(),
            ..Default::default()
        }
        .with_component(assets::LiteralComponent::new("Component_SpotLight").with_data([
            ("InnerConeAngle", Box::new(15.0f32) as Box<dyn AsBrdbValue>),
            ("OuterConeAngle", Box::new(45.0f32)),
            ("bEnabled", Box::new(true)),
            ("Brightness", Box::new(300.0f32)),
            ("Radius", Box::new(600.0f32)),
            (
                "Color",
                Box::new(SavedBrickColor { r: 255, g: 0, b: 0, a: 255 }),
            ),
            ("bUseBrickColor", Box::new(false)),
            ("bCastShadows", Box::new(true)),
        ])),
    );

    // 3: Interact — custom prompt text, hidden interaction.
    world.bricks.push(
        Brick {
            position: (40, 0, 6).into(),
            color: (0, 255, 255).into(),
            ..Default::default()
        }
        .with_component(assets::LiteralComponent::new("Component_Interact").with_data([
            (
                "Message",
                Box::new("You interacted!".to_string()) as Box<dyn AsBrdbValue>,
            ),
            ("ConsoleTag", Box::new("fixture_interact".to_string())),
            ("bAllowNearbyInteraction", Box::new(false)),
            ("bHiddenInteraction", Box::new(true)),
            ("PromptCustomLabel", Box::new("Open Door".to_string())),
        ])),
    );

    // 4: Buffer (ticks) — WireGraphPseudo component whose Input/Output are
    // WireGraphVariant; non-default counters plus a Number/Bool variant pair.
    world.bricks.push(
        Brick {
            position: (60, 0, 1).into(),
            color: (128, 0, 128).into(),
            asset: assets::components::BufferTicks::default().brick(),
            ..Default::default()
        }
        .with_component(assets::components::BufferTicks {
            current_ticks: 3,
            ticks_to_wait: 10,
            input: WireVariant::Number(2.5),
            output: WireVariant::Bool(true),
        }),
    );

    // 5: Blend gate — WireGraph_Expr_MathBlend's InputA/InputB are each a
    // WireGraphPrimMathVariant (here an f64 and an i64 tag, showing the
    // variant is polymorphic per-port); Blend itself is a plain f64.
    world.bricks.push(
        Brick {
            position: (80, 0, 1).into(),
            color: (0, 128, 0).into(),
            asset: assets::components::LogicGate::Blend.brick(),
            ..Default::default()
        }
        .with_component(assets::components::LogicGate::Blend.component_with_overrides(
            HashMap::from([
                (
                    "InputA".into(),
                    Box::new(WireVariant::Number(10.0)) as Box<dyn AsBrdbValue>,
                ),
                ("InputB".into(), Box::new(WireVariant::Int(7))),
                ("Blend".into(), Box::new(0.75f64)),
            ]),
        )),
    );

    world
}

Trait Implementations

impl Clone for LogicGate

fn clone(&self) -> LogicGate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for LogicGate

impl Debug for LogicGate

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

Formats the value using the given formatter.

impl Eq for LogicGate

impl From<LogicGate> for LogicGateComponent

fn from(ty: LogicGate) -> Self

Converts to this type from the input type.

impl Hash for LogicGate

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for LogicGate

fn eq(&self, other: &LogicGate) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for LogicGate