nucleation 0.3.1

A high-performance Minecraft schematic parser and utility library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

pub mod brushes;
pub mod enums;
pub mod shapes;

pub use brushes::*;
pub use enums::*;
pub use shapes::*;

use crate::universal_schematic::UniversalSchematic;

pub struct BuildingTool<'a> {
    schematic: &'a mut UniversalSchematic,
}

impl<'a> BuildingTool<'a> {
    pub fn new(schematic: &'a mut UniversalSchematic) -> Self {
        Self { schematic }
    }

    /// Fill a shape with a brush using generic trait objects (pure Rust API).
    pub fn fill(&mut self, shape: &impl Shape, brush: &impl Brush) {
        let (min_x, min_y, min_z, max_x, max_y, max_z) = shape.bounds();
        self.schematic
            .ensure_bounds((min_x, min_y, min_z), (max_x, max_y, max_z));

        shape.for_each_point(|x, y, z| {
            let normal = shape.normal_at(x, y, z);
            if let Some(block) = brush.get_block(x, y, z, normal) {
                self.schematic.set_block(x, y, z, &block);
            }
        });
    }

    /// Fill a ShapeEnum with a BrushEnum, passing parametric `t` to brushes that support it.
    pub fn fill_enum(&mut self, shape: &ShapeEnum, brush: &BrushEnum) {
        let (min_x, min_y, min_z, max_x, max_y, max_z) = shape.bounds();
        self.schematic
            .ensure_bounds((min_x, min_y, min_z), (max_x, max_y, max_z));

        shape.for_each_point(|x, y, z| {
            let normal = shape.normal_at(x, y, z);
            let t = shape.parameter_at(x, y, z);
            if let Some(block) = brush.get_block_with_parameter(x, y, z, normal, t) {
                self.schematic.set_block(x, y, z, &block);
            }
        });
    }

    /// Repeat a shape+brush fill at regular offset intervals.
    /// Creates `count` copies of the shape, each offset by `offset * i` from the original.
    pub fn rstack(
        &mut self,
        shape: &ShapeEnum,
        brush: &BrushEnum,
        count: usize,
        offset: (i32, i32, i32),
    ) {
        for i in 0..count {
            let dx = offset.0 * i as i32;
            let dy = offset.1 * i as i32;
            let dz = offset.2 * i as i32;
            let translated = TranslatedShape::new(shape, dx, dy, dz);
            let (min_x, min_y, min_z, max_x, max_y, max_z) = translated.bounds();
            self.schematic
                .ensure_bounds((min_x, min_y, min_z), (max_x, max_y, max_z));

            translated.for_each_point(|x, y, z| {
                let normal = translated.normal_at(x, y, z);
                let t = shape.parameter_at(x - dx, y - dy, z - dz);
                if let Some(block) = brush.get_block_with_parameter(x, y, z, normal, t) {
                    self.schematic.set_block(x, y, z, &block);
                }
            });
        }
    }
}

/// Internal helper that wraps a ShapeEnum with a translation offset.
struct TranslatedShape<'a> {
    inner: &'a ShapeEnum,
    dx: i32,
    dy: i32,
    dz: i32,
}

impl<'a> TranslatedShape<'a> {
    fn new(inner: &'a ShapeEnum, dx: i32, dy: i32, dz: i32) -> Self {
        Self { inner, dx, dy, dz }
    }
}

impl Shape for TranslatedShape<'_> {
    fn contains(&self, x: i32, y: i32, z: i32) -> bool {
        self.inner.contains(x - self.dx, y - self.dy, z - self.dz)
    }

    fn points(&self) -> Vec<(i32, i32, i32)> {
        self.inner
            .points()
            .into_iter()
            .map(|(x, y, z)| (x + self.dx, y + self.dy, z + self.dz))
            .collect()
    }

    fn normal_at(&self, x: i32, y: i32, z: i32) -> (f64, f64, f64) {
        self.inner.normal_at(x - self.dx, y - self.dy, z - self.dz)
    }

    fn bounds(&self) -> (i32, i32, i32, i32, i32, i32) {
        let (min_x, min_y, min_z, max_x, max_y, max_z) = self.inner.bounds();
        (
            min_x + self.dx,
            min_y + self.dy,
            min_z + self.dz,
            max_x + self.dx,
            max_y + self.dy,
            max_z + self.dz,
        )
    }

    fn for_each_point<F>(&self, mut f: F)
    where
        F: FnMut(i32, i32, i32),
    {
        let dx = self.dx;
        let dy = self.dy;
        let dz = self.dz;
        self.inner.for_each_point(|x, y, z| {
            f(x + dx, y + dy, z + dz);
        });
    }
}