Enum BrickType 

pub enum BrickType {
    Basic(BString),
    Procedural {
        asset: BString,
        size: BrickSize,
    },
}

Variants

Basic(BString)

Procedural

Fields

asset: BString

size: BrickSize

Implementations

impl BrickType

pub const fn str(asset: &'static str) -> Self

Examples found in repository

examples/write_fixtures.rs (line 396)

fn spawner_world() -> World {
    // Prefab-embedding fixture: an outer prefab whose spawner gate references
    // an inner single-brick prefab embedded at Prefabs/Uploads/<BLAKE3>.brz.
    // Single grid, single chunk, one insertion-ordered prefab map entry —
    // fully deterministic. The inner archive is written raw (no zstd) so the
    // embedded bytes are cross-language reproducible.
    let mut inner = World::new();
    inner.meta.bundle.description = "Inner prefab".to_string();
    inner.bricks.push(Brick {
        position: (0, 0, 6).into(),
        color: (255, 0, 0).into(),
        ..Default::default()
    });
    inner.make_prefab();
    let inner_bytes = {
        let pending = inner.to_unsaved().unwrap().to_pending().unwrap();
        let mut buf = Vec::new();
        pending
            .to_brz_data(None)
            .unwrap()
            .write(&mut buf, None)
            .unwrap();
        buf
    };

    let mut world = World::new();
    world.register_all_components();
    world.meta.bundle.description = "Spawner fixture".to_string();
    let prefab_path = world.add_prefab(inner_bytes);
    world.bricks.push(
        Brick {
            asset: brdb::BrickType::str("B_1x1_Gate_Exec_PrefabSpawner"),
            position: (0, 0, 1).into(),
            ..Default::default()
        }
        .with_component(
            assets::LiteralComponent::new("BrickComponentType_WireGraph_Exec_PrefabSpawner")
                .with_data([(
                    "Prefab",
                    Box::new(prefab_path) as Box<dyn AsBrdbValue>,
                )]),
        ),
    );
    world.make_prefab();
    world
}

impl BrickType

pub fn is_procedural(&self) -> bool

pub fn is_basic(&self) -> bool

pub fn asset(&self) -> &BString

Examples found in repository

examples/extract_components.rs (line 31)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let args: Vec<String> = std::env::args().collect();
    let path = PathBuf::from(
        args.get(1)
            .expect("usage: extract_components <zoo.brdb> [out.rs]"),
    );
    let out_path = args.get(2).map(PathBuf::from);
    let db = Brdb::open(path)?.into_reader();
    let data = db.global_data()?;

    // The standalone phase attaches otherwise-brickless components to this generic host for
    // probing; it is never a real component host, so it is filtered out of the host lists.
    let standalone_host_brick = brdb::assets::bricks::B_1X1F_ROUND;
    let standalone_host: &str = standalone_host_brick.asset().as_ref();

    // component type index -> host brick asset name(s) / wire port indices.
    // Host names are resolved inline (basic and procedural bricks index different
    // name sets), so this stores names rather than type indices.
    let mut bricks: BTreeMap<u16, BTreeSet<String>> = BTreeMap::new();
    let mut inputs: BTreeMap<u16, BTreeSet<u16>> = BTreeMap::new();
    let mut outputs: BTreeMap<u16, BTreeSet<u16>> = BTreeMap::new();

    // Grid 1 is the main grid; higher ids are microchip inner grids. Probe
    // until a grid id is missing (same convention as read_components).
    for gid in 1..64 {
        let chunks = match db.brick_chunk_index(gid) {
            Ok(c) => c,
            Err(_) => break,
        };
        for chunk in &chunks {
            // brick index -> brick type index (basic-brick asset), for the
            // host-brick mapping.
            let bsoa = db.brick_chunk_soa(gid, chunk.index)?;
            let pb_start = bsoa.procedural_brick_starting_index;
            // Procedural brick type index (>= pb_start) -> procedural asset index, via the
            // per-size run-length counters (same expansion SoA::iter_bricks uses).
            let proc_asset_by_size: Vec<u32> = bsoa
                .brick_size_counters
                .iter()
                .flat_map(|c| std::iter::repeat(c.asset_index).take(c.num_sizes as usize))
                .collect();
            let brick_types = bsoa.brick_type_indices;

            if chunk.num_components > 0 {
                let (csoa, components) = db.component_chunk_soa(gid, chunk.index)?;
                let brick_indices = csoa.component_brick_indices;
                // Expand run-length (type_index, num_instances) into a flat
                // per-instance list of component type indices.
                let type_indices = csoa
                    .component_type_counters
                    .iter()
                    .flat_map(|v| {
                        let ti = v.type_index as u16;
                        (0..v.num_instances).map(move |_| ti)
                    })
                    .collect::<Vec<_>>();
                for i in 0..components.len() {
                    let comp_ty = type_indices[i];
                    // ensure every placed component is present even with no wires
                    inputs.entry(comp_ty).or_default();
                    outputs.entry(comp_ty).or_default();
                    let brick_index = brick_indices[i].as_brdb_u32()? as usize;
                    if let Some(&bt) = brick_types.get(brick_index) {
                        // Basic bricks index basic_brick_asset_names directly; procedural
                        // bricks (type index >= pb_start) map through the size run-lengths to
                        // a procedural_brick_asset_names index.
                        let host = if bt < pb_start {
                            data.basic_brick_asset_names.get_index(bt as usize).cloned()
                        } else {
                            proc_asset_by_size
                                .get((bt - pb_start) as usize)
                                .and_then(|&ai| {
                                    data.procedural_brick_asset_names.get_index(ai as usize).cloned()
                                })
                        };
                        if let Some(host) = host {
                            if host != standalone_host {
                                bricks.entry(comp_ty).or_default().insert(host);
                            }
                        }
                    }
                }
            }

            if chunk.num_wires > 0 {
                let soa = db.wire_chunk_soa(gid, chunk.index)?.to_value();
                let soa: WireChunkSoA = (&soa).try_into()?;
                // local and remote ports are distinct types, so handle each in
                // its own loop (they share component_type_index / port_index).
                for p in &soa.local_wire_sources {
                    outputs
                        .entry(p.component_type_index)
                        .or_default()
                        .insert(p.port_index);
                }
                for p in &soa.remote_wire_sources {
                    outputs
                        .entry(p.component_type_index)
                        .or_default()
                        .insert(p.port_index);
                }
                for p in &soa.local_wire_targets {
                    inputs
                        .entry(p.component_type_index)
                        .or_default()
                        .insert(p.port_index);
                }
                for p in &soa.remote_wire_targets {
                    inputs
                        .entry(p.component_type_index)
                        .or_default()
                        .insert(p.port_index);
                }
            }
        }
    }

    // Resolve indices to names.
    let name_of = |idx: u16| data.component_type_names.get_index(idx as usize).cloned();
    let port_of = |idx: u16| data.component_wire_port_names.get_index(idx as usize).cloned();

    let all: BTreeSet<u16> = bricks
        .keys()
        .chain(inputs.keys())
        .chain(outputs.keys())
        .copied()
        .collect();

    // (name, host bricks, input ports, output ports), sorted by name.
    let mut rows: Vec<(String, Vec<String>, Vec<String>, Vec<String>)> = Vec::new();
    for ty in all {
        let Some(name) = name_of(ty) else { continue };
        let mut bs: Vec<String> = bricks
            .get(&ty)
            .map(|s| s.iter().cloned().collect())
            .unwrap_or_default();
        bs.sort();
        bs.dedup();
        let mut ins: Vec<String> = inputs
            .get(&ty)
            .map(|s| s.iter().filter_map(|&p| port_of(p)).collect())
            .unwrap_or_default();
        ins.sort();
        ins.dedup();
        let mut outs: Vec<String> = outputs
            .get(&ty)
            .map(|s| s.iter().filter_map(|&p| port_of(p)).collect())
            .unwrap_or_default();
        outs.sort();
        outs.dedup();
        rows.push((name, bs, ins, outs));
    }
    rows.sort_by(|a, b| a.0.cmp(&b.0));

    let mut out = String::new();
    macro_rules! w {
        ($($t:tt)*) => { writeln!(out, $($t)*).unwrap() };
    }
    let slice = |v: &[String]| {
        v.iter()
            .map(|s| format!("{s:?}"))
            .collect::<Vec<_>>()
            .join(", ")
    };

    w!("// Autogenerated from a zoo save:");
    w!("//   cargo run --example extract_components -- <zoo.brdb> src/assets/component_catalog.rs");
    w!("// Do not edit by hand.");
    w!();
    w!("/// Per-component catalog entry: the full component type name, its host");
    w!("/// brick asset(s), and its wire input/output port names. Extracted from a");
    w!("/// fully-placed, fully-wired \"zoo\" save (mirrors brs-js's COMPONENTS).");
    w!("#[derive(Debug, Clone, Copy, PartialEq, Eq)]");
    w!("pub struct ComponentInfo {{");
    w!("    /// e.g. \"BrickComponentType_WireGraph_Exec_Branch\".");
    w!("    pub name: &'static str,");
    w!("    /// Host brick asset name(s) that carry this component.");
    w!("    pub bricks: &'static [&'static str],");
    w!("    /// Wire input port names.");
    w!("    pub inputs: &'static [&'static str],");
    w!("    /// Wire output port names.");
    w!("    pub outputs: &'static [&'static str],");
    w!("}}");
    w!();
    w!("impl ComponentInfo {{");
    w!("    /// The primary host brick asset (first, if any).");
    w!("    pub const fn brick(&self) -> Option<&'static str> {{");
    w!("        self.bricks.first().copied()");
    w!("    }}");
    w!("}}");
    w!();
    w!(
        "/// Every component present in the zoo, sorted by `name` (binary-searchable)."
    );
    w!("pub static COMPONENTS: &[ComponentInfo] = &[");
    for (name, bs, ins, outs) in &rows {
        w!(
            "    ComponentInfo {{ name: {name:?}, bricks: &[{}], inputs: &[{}], outputs: &[{}] }},",
            slice(bs),
            slice(ins),
            slice(outs),
        );
    }
    w!("];");
    w!();
    w!("/// Look up a component by its full type name.");
    w!("pub fn component(name: &str) -> Option<&'static ComponentInfo> {{");
    w!("    COMPONENTS");
    w!("        .binary_search_by(|c| c.name.cmp(name))");
    w!("        .ok()");
    w!("        .map(|i| &COMPONENTS[i])");
    w!("}}");

    if let Some(ref p) = out_path {
        std::fs::write(p, &out)?;
        eprintln!("Wrote {}", p.display());
    } else {
        print!("{out}");
    }
    eprintln!(
        "Extracted {} components ({} with host bricks)",
        rows.len(),
        rows.iter().filter(|r| !r.1.is_empty()).count(),
    );
    Ok(())
}

Trait Implementations

impl Clone for BrickType

fn clone(&self) -> BrickType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BrickType

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

Formats the value using the given formatter.

impl Eq for BrickType

impl<T: Into<BString>, B: Into<BrickSize>> From<(T, B)> for BrickType

fn from((asset, size): (T, B)) -> Self

Converts to this type from the input type.

impl<T: Into<BString>> From<T> for BrickType

fn from(asset: T) -> Self

Converts to this type from the input type.

impl Ord for BrickType

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for BrickType

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for BrickType

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for BrickType