Struct BrdbSchemaGlobalData 

pub struct BrdbSchemaGlobalData {
    pub entity_type_names: IndexSet<String>,
    pub entity_data_class_names: IndexSet<String>,
    pub basic_brick_asset_names: IndexSet<String>,
    pub procedural_brick_asset_names: IndexSet<String>,
    pub material_asset_names: IndexSet<String>,
    pub component_type_names: IndexSet<String>,
    pub component_data_struct_names: Vec<String>,
    pub component_wire_port_names: IndexSet<String>,
    pub external_asset_types: HashSet<String>,
    pub external_asset_references: IndexSet<(String, String)>,
    pub global_grid_entity_type_index: i32,
}

Fields

entity_type_names: IndexSet<String>

entity_data_class_names: IndexSet<String>

basic_brick_asset_names: IndexSet<String>

procedural_brick_asset_names: IndexSet<String>

material_asset_names: IndexSet<String>

component_type_names: IndexSet<String>

component_data_struct_names: Vec<String>

component_wire_port_names: IndexSet<String>

external_asset_types: HashSet<String>

Internal set for type checking, not used in the BRDB.

external_asset_references: IndexSet<(String, String)>

global_grid_entity_type_index: i32

Index into entity_type_names for the BP_BrickGrid_Global_C entity type, or -1 if the save has no global grid.

Implementations

impl BrdbSchemaGlobalData

pub fn add_brick_meta(&mut self, brick: &Brick)

pub fn get_struct_name(&self, type_name: &str) -> Option<&str>

pub fn get_entity_class_name(&self, type_name: &str) -> Option<&str>

pub fn get_port_index(&self, port_name: &str) -> Option<u16>

pub fn get_component_type_index(&self, type_name: &str) -> Option<u16>

pub fn has_component_type(&self, type_name: &str) -> bool

pub fn add_entity_type(&mut self, type_name: &str)

pub fn add_entity_type_with_class(&mut self, type_name: &str, class_name: &str)

Register an entity type with its explicit data-class name. Keeps entity_type_names and entity_data_class_names parallel as the saved-world format requires.

pub fn basic_brick_asset_by_index( &self, index: usize, ) -> Result<BString, BrdbSchemaError>

pub fn procedural_brick_asset_by_index( &self, index: usize, ) -> Result<BString, BrdbSchemaError>

pub fn material_asset_by_index( &self, index: usize, ) -> Result<BString, BrdbSchemaError>

pub fn proc_brick_starting_index(&self) -> u32

proc_brick_starting_index needs to exist because the type ids of brick assets are stored in the GlobalData, and the type ids of procedural bricks are assigned starting from the end of the basic brick asset names.

When new brick assets are added, the length of the basic brick asset names will increase, and the type ids of procedural bricks in older chunks will not match the new basic brick asset names.

This offset allows older chunks to properly load, assuming the global data does not change the order of brick asset names (by external tools)

Examples found in repository

examples/world_move_bricks.rs (line 43)

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

    println!("Warning - This code will break if the brick chunk struct changes!!");

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

    let data = db.global_data()?;
    let mut grid = UnsavedGrid::default();

    let mut total_bricks = 0;
    for chunk in db.brick_chunk_index(1)? {
        for brick in db
            .brick_chunk_soa(1, chunk.index)?
            .iter_bricks(chunk.index, data.clone())
        {
            // If we wanted wires/components, we'd need to track the bricks here by their chunk index and brick index
            total_bricks += 1;

            let mut brick = brick?;
            brick.position += Position::new(3000, 0, 0);
            grid.add_brick(data.as_ref(), &brick);
        }

        if chunk.num_components > 0 {
            println!("sorry, this example doesn't handle components");
        }
        if chunk.num_wires > 0 {
            println!("sorry, this example doesn't handle wires");
        }
    }
    println!("{total_bricks} bricks");

    let mut pending = db.to_pending()?;

    // Replace the main grid (1) with the grid we created
    *pending.cd_mut("World/0/Bricks/Grids/1")? = grid.to_pending(
        data.proc_brick_starting_index(),
        db.components_schema()?.as_ref(),
    )?;

    if dst.exists() {
        std::fs::remove_file(&dst)?;
    }
    Brdb::new(&dst)?.write_pending("Move the bricks", pending)?;

    // Verify bricks can be read
    let db = Brdb::open(dst)?.into_reader();
    for chunk in db.brick_chunk_index(1)? {
        let _ = db.brick_chunk_soa(1, chunk.index)?;
    }

    Ok(())
}

Trait Implementations

impl AsBrdbValue for BrdbSchemaGlobalData

fn as_brdb_struct_prop_value( &self, schema: &BrdbSchema, _struct_name: BrdbInterned, prop_name: BrdbInterned, ) -> Result<&dyn AsBrdbValue, BrdbSchemaError>

Read a specific struct property value from the schema.

fn as_brdb_struct_prop_array( &self, schema: &BrdbSchema, _struct_name: BrdbInterned, prop_name: BrdbInterned, ) -> Result<BrdbArrayIter<'_>, BrdbSchemaError>

Get the the number of entries in a struct property.

fn as_brdb_bool(&self) -> Result<bool, BrdbSchemaError>

fn as_brdb_u8(&self) -> Result<u8, BrdbSchemaError>

fn as_brdb_u16(&self) -> Result<u16, BrdbSchemaError>

fn as_brdb_u32(&self) -> Result<u32, BrdbSchemaError>

fn as_brdb_u64(&self) -> Result<u64, BrdbSchemaError>

fn as_brdb_i8(&self) -> Result<i8, BrdbSchemaError>

fn as_brdb_i16(&self) -> Result<i16, BrdbSchemaError>

fn as_brdb_i32(&self) -> Result<i32, BrdbSchemaError>

fn as_brdb_i64(&self) -> Result<i64, BrdbSchemaError>

fn as_brdb_f32(&self) -> Result<f32, BrdbSchemaError>

fn as_brdb_f64(&self) -> Result<f64, BrdbSchemaError>

fn as_brdb_str(&self) -> Result<&str, BrdbSchemaError>

fn as_brdb_asset( &self, _schema: &BrdbSchema, _ty: &str, ) -> Result<Option<usize>, BrdbSchemaError>

fn as_brdb_enum( &self, _schema: &BrdbSchema, _def: &BrdbSchemaEnum, ) -> Result<i32, BrdbSchemaError>

fn as_brdb_wire_variant(&self) -> Result<WireVariant, BrdbSchemaError>

fn as_brdb_wire_array_variant( &self, ) -> Result<WireArrayVariant, BrdbSchemaError>

fn as_brdb_wire_map_variant(&self) -> Result<WireMapVariant, BrdbSchemaError>

fn as_brdb_variant_member(&self) -> Option<&str>

When this value should encode as a named member of a schema variant (a tagged union whose members are structs, e.g. BRInventoryEntryVariant -> BRInventoryEntryNothing), return the member struct’s name. The writer emits uint(tag) + <that struct>. None (the default) means “not a struct-member variant” and the writer falls back to the wire map/array/scalar variant paths.

fn has_brdb_struct_prop( &self, _schema: &BrdbSchema, _struct_name: BrdbInterned, _prop_name: BrdbInterned, ) -> bool

Cheap presence probe for a struct property. When this returns false, the schema writer takes the default/zero path directly instead of paying for a MissingStructField error (two String allocations) per unset field. Implementations that can’t answer cheaply keep the default true; the writer then falls back to the erroring accessors below.

fn as_brdb_struct_prop_map( &self, _schema: &BrdbSchema, _struct_name: BrdbInterned, _prop_name: BrdbInterned, ) -> Result<BrdbMapIter<'_>, BrdbSchemaError>

Get the the number of entries in a struct property.

impl Clone for BrdbSchemaGlobalData

fn clone(&self) -> BrdbSchemaGlobalData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BrdbSchemaGlobalData

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

Formats the value using the given formatter.

impl Default for BrdbSchemaGlobalData

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for BrdbSchemaGlobalData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for BrdbSchemaGlobalData

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.