Struct Brz 

pub struct Brz {
    pub index_data: BrzIndexData,
    pub blob_data: Vec<u8>,
}

Fields

index_data: BrzIndexData

blob_data: Vec<u8>

(Compressed) blob data as one contiguous byte array.

Implementations

impl Brz

pub fn open(path: impl AsRef<Path>) -> Result<Brz, BrzError>

Open and read a brz archive from a file path.

Examples found in repository

examples/brz_to_brz.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let src = PathBuf::from("./world.brz");
    let dst = PathBuf::from("./world_copy.brz");

    let pending = Brz::open(src)?.to_pending()?;
    Brz::write_pending(dst, pending)?;

    Ok(())
}

examples/brz_to_brdb.rs (line 9)

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

    let pending = Brz::open(src)?.to_pending()?;
    Brdb::open(dst)?.write_pending("Import brz", pending)?;

    Ok(())
}

examples/read_brz.rs (line 9)

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

    // The API for reading a brz is identical to reading a Brdb
    let db = Brz::open(path)?.into_reader();

    let data = db.global_data()?;
    println!("Basic Brick assets: {:?}", data.basic_brick_asset_names);
    println!("Wire ports: {:?}", data.component_wire_port_names);
    println!("Component types: {:?}", data.component_type_names);
    println!("Component structs: {:?}", data.component_data_struct_names);
    println!("Component schemas: {}", db.components_schema()?);

    let chunks = db.brick_chunk_index(1)?;
    println!("Brick chunks: {chunks:?}");
    for chunk in chunks {
        let soa = db.brick_chunk_soa(1, chunk.index)?;
        println!("Brick soa: {soa:?}");
        if chunk.num_components > 0 {
            let (_soa, components) = db.component_chunk_soa(1, chunk.index)?;
            for c in components {
                println!("Component: {c}");
            }
        }
        if chunk.num_wires > 0 {
            let soa = db.wire_chunk_soa(1, chunk.index)?;
            println!("Wires soa: {soa}");
        }
    }

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

    Ok(())
}

examples/world_replace_owner.rs (line 55)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let src = PathBuf::from("world.brdb");
    let dst = PathBuf::from("world_patched.brz");

    assert!(src.exists());

    let db = Brdb::open(src)?.into_reader();

    let owners = db.owners_soa()?;

    // Parse the owners from BrdbValues
    let mut new_soa = OwnerTableSoA::try_from(&owners.to_value())?;

    // Modify the owner ids
    new_soa
        .display_names
        .iter_mut()
        .for_each(|id| *id = "PUBLIC".to_owned());
    new_soa
        .user_names
        .iter_mut()
        .for_each(|id| *id = "PUBLIC".to_owned());
    new_soa
        .user_ids
        .iter_mut()
        .for_each(|id| *id = Guid::default());

    // convert the owners struct of arrays into bytes using the owners schema
    let content = db.owners_schema()?.write_brdb(OWNER_TABLE_SOA, &new_soa)?;

    let patch = BrPendingFs::Root(vec![(
        "World".to_owned(),
        BrPendingFs::Folder(Some(vec![(
            "0".to_string(),
            BrPendingFs::Folder(Some(vec![(
                "Owners.mps".to_string(),
                BrPendingFs::File(Some(content)),
            )])),
        )])),
    )]);

    // use .to_pending_patch() if you want to update the same world
    let pending = db.to_pending()?.with_patch(patch)?;
    if dst.exists() {
        std::fs::remove_file(&dst)?;
    }
    Brz::write_pending(&dst, pending)?;

    println!("{}", Brz::open(&dst)?.into_reader().owners_soa()?);

    Ok(())
}

pub fn new(path: impl AsRef<Path>) -> Result<Brz, BrzError>

Open and read a brz archive from a file path.

Examples found in repository

examples/write_brz.rs (line 21)

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

    let mut world = World::new();
    world.meta.bundle.description = "Example World".to_string();
    world.bricks.push(Brick {
        position: (0, 0, 6).into(),
        color: (255, 0, 0).into(),
        ..Default::default()
    });

    if path.exists() {
        std::fs::remove_file(&path)?;
    }
    world.write_brz(&path)?;

    let db = Brz::new(&path)?.into_reader();

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

    let soa = db.brick_chunk_soa(1, (0, 0, 0).into())?;
    let color = soa.colors_and_alphas[0];
    assert_eq!(color.r, 255);
    assert_eq!(color.g, 0);
    assert_eq!(color.b, 0);
    assert_eq!(color.a, 5);

    Ok(())
}

pub fn read_slice(buf: &[u8]) -> Result<Brz, BrzError>

Read a brz archive from a byte slice.

pub fn read(r: &mut impl Read) -> Result<Brz, BrzError>

pub fn to_vec(&self, zstd_level: Option<i32>) -> Result<Vec<u8>, BrzError>

Write a brz archive to a byte vector.

pub fn to_pending(&self) -> Result<BrPendingFs, BrError>

Examples found in repository

examples/brz_to_brz.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let src = PathBuf::from("./world.brz");
    let dst = PathBuf::from("./world_copy.brz");

    let pending = Brz::open(src)?.to_pending()?;
    Brz::write_pending(dst, pending)?;

    Ok(())
}

examples/brz_to_brdb.rs (line 9)

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

    let pending = Brz::open(src)?.to_pending()?;
    Brdb::open(dst)?.write_pending("Import brz", pending)?;

    Ok(())
}

pub fn write_pending( path: impl AsRef<Path>, pending: BrPendingFs, ) -> Result<(), BrError>

Write a pending fs to a brz file.

Examples found in repository

examples/brdb_to_brz.rs (line 10)

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

    let pending = Brdb::open(src)?.to_pending()?;
    Brz::write_pending(dst, pending)?;

    Ok(())
}

examples/brz_to_brz.rs (line 10)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let src = PathBuf::from("./world.brz");
    let dst = PathBuf::from("./world_copy.brz");

    let pending = Brz::open(src)?.to_pending()?;
    Brz::write_pending(dst, pending)?;

    Ok(())
}

examples/world_replace_owner.rs (line 53)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let src = PathBuf::from("world.brdb");
    let dst = PathBuf::from("world_patched.brz");

    assert!(src.exists());

    let db = Brdb::open(src)?.into_reader();

    let owners = db.owners_soa()?;

    // Parse the owners from BrdbValues
    let mut new_soa = OwnerTableSoA::try_from(&owners.to_value())?;

    // Modify the owner ids
    new_soa
        .display_names
        .iter_mut()
        .for_each(|id| *id = "PUBLIC".to_owned());
    new_soa
        .user_names
        .iter_mut()
        .for_each(|id| *id = "PUBLIC".to_owned());
    new_soa
        .user_ids
        .iter_mut()
        .for_each(|id| *id = Guid::default());

    // convert the owners struct of arrays into bytes using the owners schema
    let content = db.owners_schema()?.write_brdb(OWNER_TABLE_SOA, &new_soa)?;

    let patch = BrPendingFs::Root(vec![(
        "World".to_owned(),
        BrPendingFs::Folder(Some(vec![(
            "0".to_string(),
            BrPendingFs::Folder(Some(vec![(
                "Owners.mps".to_string(),
                BrPendingFs::File(Some(content)),
            )])),
        )])),
    )]);

    // use .to_pending_patch() if you want to update the same world
    let pending = db.to_pending()?.with_patch(patch)?;
    if dst.exists() {
        std::fs::remove_file(&dst)?;
    }
    Brz::write_pending(&dst, pending)?;

    println!("{}", Brz::open(&dst)?.into_reader().owners_soa()?);

    Ok(())
}

pub fn save(path: impl AsRef<Path>, world: &World) -> Result<(), BrError>

Write a brz archive to a file.

pub fn save_uncompressed( path: impl AsRef<Path>, world: &World, ) -> Result<(), BrError>

Write a brz archive to a file with no compression

pub fn write( &self, w: &mut impl Write, zstd_level: Option<i32>, ) -> Result<(), BrzError>

Write a brz archive to a writer.

Trait Implementations

impl AsRef<Brz> for Brz

fn as_ref(&self) -> &Brz

Converts this type into a shared reference of the (usually inferred) input type.

impl Clone for Brz

fn clone(&self) -> Brz

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> IntoReader for &'a Brz

type Inner = BrzIndex<&'a Brz>

fn into_reader(self) -> BrReader<Self::Inner>

impl IntoReader for Brz

type Inner = BrzIndex<Brz>

fn into_reader(self) -> BrReader<Self::Inner>