Struct Entity 

pub struct Entity {
    pub asset: BString,
    pub id: Option<usize>,
    pub owner_index: Option<u32>,
    pub location: Vector3f,
    pub rotation: Quat4f,
    pub frozen: bool,
    pub sleeping: bool,
    pub velocity: Vector3f,
    pub angular_velocity: Vector3f,
    pub color_and_alpha: EntityColors,
    pub data: Arc<Box<dyn BrdbComponent>>,
}

Fields

asset: BString

id: Option<usize>

An internal ID for linking entities to joints, etc

owner_index: Option<u32>

location: Vector3f

rotation: Quat4f

frozen: bool

sleeping: bool

velocity: Vector3f

angular_velocity: Vector3f

color_and_alpha: EntityColors

data: Arc<Box<dyn BrdbComponent>>

Implementations

impl Entity

pub fn is_brick_grid(&self) -> bool

Examples found in repository

examples/read_world.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // world file from argv
    let filename = std::env::args()
        .nth(1)
        .unwrap_or_else(|| "world.brdb".to_string());
    let path = PathBuf::from(filename);
    if !path.exists() {
        eprintln!("File does not exist: {}", path.display());
        std::process::exit(1);
    }

    let db = Brdb::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 mut grid_ids = vec![1];

    // Iterate all entity chunks to find dynamic brick grids...
    // This could totally be a helper function
    for index in db.entity_chunk_index()? {
        for e in db.entity_chunk(index)? {
            // Ensure the chunk is a dynamic brick grid
            if !e.is_brick_grid() {
                continue;
            }
            let Some(id) = e.id else {
                continue;
            };
            grid_ids.push(id);
        }
    }

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

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

    Ok(())
}

examples/world_remove_shadows.rs (line 20)

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

    assert!(src.exists());

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

    let mut grid_ids = vec![1];

    // Iterate all entity chunks to find dynamic brick grids...
    // This could totally be a helper function
    for index in db.entity_chunk_index()? {
        for e in db.entity_chunk(index)? {
            // Ensure the chunk is a dynamic brick grid
            if !e.is_brick_grid() {
                continue;
            }
            let Some(id) = e.id else {
                continue;
            };
            grid_ids.push(id);
        }
    }

    let component_schema = db.components_schema()?;
    let mut grids_files = vec![];

    // Iterate all grids (there can be bricks on entities)
    for grid in &grid_ids {
        let chunks = db.brick_chunk_index(*grid)?;
        let mut chunk_files = vec![];
        let mut num_grid_modified = 0;

        // Iterate all chunks in the grid
        for index in chunks {
            let mut num_chunk_modified = 0;
            if index.num_components == 0 {
                println!("ignoring grid {grid} chunk {} with no components", *index);
                continue;
            }

            // Iterate all the components in the chunk
            let (mut soa, components) = db.component_chunk(*grid, *index)?;
            for mut s in components {
                // Disable the shadow casting property if it's present and true
                if s.prop("bCastShadows")
                    .is_ok_and(|v| v.as_brdb_bool().unwrap_or_default())
                {
                    println!(
                        "grid {grid} chunk {} mutating component {}",
                        *index,
                        s.get_name()
                    );
                    s.set_prop("bCastShadows", BrdbValue::Bool(false))?;
                    num_grid_modified += 1;
                    num_chunk_modified += 1;
                }

                soa.unwritten_struct_data.push(Box::new(s));
            }

            if num_chunk_modified == 0 {
                continue;
            }

            chunk_files.push((
                format!("{}.mps", *index),
                // ComponentChunkSoA::to_bytes ensures the extra data is written after the SoA data
                BrPendingFs::File(Some(soa.to_bytes(&component_schema)?)),
            ));
        }

        if num_grid_modified == 0 {
            println!("grid {grid} has no shadow-casting components, skipping");
            continue;
        } else {
            println!(
                "grid {grid} has {num_grid_modified} shadow-casting components in {} files",
                chunk_files.len()
            );
        }

        grids_files.push((
            grid.to_string(),
            BrPendingFs::Folder(Some(vec![(
                "Components".to_string(),
                BrPendingFs::Folder(Some(chunk_files)),
            )])),
        ))
    }

    let patch = BrPendingFs::Root(vec![(
        "World".to_owned(),
        BrPendingFs::Folder(Some(vec![(
            "0".to_string(),
            BrPendingFs::Folder(Some(vec![(
                "Bricks".to_string(),
                BrPendingFs::Folder(Some(vec![(
                    "Grids".to_string(),
                    BrPendingFs::Folder(Some(grids_files)),
                )])),
            )])),
        )])),
    )]);

    // 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)?;
    }
    Brdb::new(&dst)?.write_pending("Disable Shadow Casting", pending)?;

    // Ensure all the components can be read
    let db = Brdb::open(dst)?.into_reader();
    for grid in grid_ids {
        let chunks = db.brick_chunk_index(grid)?;
        for index in chunks {
            if index.num_components == 0 {
                continue;
            }
            let (_soa, _components) = db.component_chunk(grid, *index)?;
        }
    }

    Ok(())
}

Trait Implementations

impl Clone for Entity

fn clone(&self) -> Entity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for Entity

fn default() -> Self

Returns the “default value” for a type.