Struct Position 

pub struct Position {
    pub x: i32,
    pub y: i32,
    pub z: i32,
}

Fields

x: i32

y: i32

z: i32

Implementations

impl Position

pub const ZERO: Self

pub const ONE: Self

pub const CHUNK_SIZE: Self

pub const CHUNK_HALF: Self

pub const X: Self

pub const Y: Self

pub const Z: Self

pub const NORTH: Self

pub const SOUTH: Self

pub const EAST: Self

pub const WEST: Self

pub const UP: Self

pub const DOWN: Self

pub const fn new(x: i32, y: i32, z: i32) -> Self

Examples found in repository

examples/world_move_bricks.rs (line 26)

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(())
}

pub fn to_relative(self) -> (ChunkIndex, RelativePosition)

pub fn from_relative(chunk: ChunkIndex, pos: RelativePosition) -> Self

Trait Implementations

impl Add for Position

type Output = Position

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl AddAssign for Position

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl Clone for Position

fn clone(&self) -> Position

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Position

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

Formats the value using the given formatter.

impl Default for Position

fn default() -> Position

Returns the “default value” for a type.

impl Div<i32> for Position

type Output = Position

The resulting type after applying the / operator.

fn div(self, scalar: i32) -> Self::Output

Performs the / operation.

impl DivAssign<i32> for Position

fn div_assign(&mut self, scalar: i32)

Performs the /= operation.

impl From<(i32, i32, i32)> for Position

fn from((x, y, z): (i32, i32, i32)) -> Self

Converts to this type from the input type.

impl From<BrickSize> for Position

fn from(size: BrickSize) -> Self

Converts to this type from the input type.

impl Mul<i32> for Position

type Output = Position

The resulting type after applying the * operator.

fn mul(self, scalar: i32) -> Self::Output

Performs the * operation.

impl MulAssign<i32> for Position

fn mul_assign(&mut self, scalar: i32)

Performs the *= operation.

impl Neg for Position

type Output = Position

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Ord for Position

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 Position

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Position

fn partial_cmp(&self, other: &Position) -> 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 Sub for Position

type Output = Position

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self::Output

Performs the - operation.

impl SubAssign for Position

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl Copy for Position

impl Eq for Position

impl StructuralPartialEq for Position