alex/beta-minecraft-rust

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
133
134
135
136
137
138
139
140
141
142
143
144
145

//! Ports of `AxisAlignedBB`, the intercept helpers of `Vec3D` and `MovingObjectPosition`.

use glam::DVec3;

#[derive(Clone, Copy, PartialEq, Debug, Default)]
pub struct Aabb {
    pub min: DVec3,
    pub max: DVec3,
}

impl Aabb {
    pub const fn new(min: DVec3, max: DVec3) -> Self {
        Self { min, max }
    }

    pub fn from_coords(x1: f64, y1: f64, z1: f64, x2: f64, y2: f64, z2: f64) -> Self {
        Self::new(DVec3::new(x1, y1, z1), DVec3::new(x2, y2, z2))
    }

    /// `addCoord`: grown in the direction of a movement.
    pub fn expand_towards(&self, d: DVec3) -> Self {
        let mut b = *self;
        for axis in 0..3 {
            if d[axis] < 0.0 {
                b.min[axis] += d[axis];
            }
            if d[axis] > 0.0 {
                b.max[axis] += d[axis];
            }
        }
        b
    }

    /// `expand`: grown by `d` on every side.
    pub fn inflate(&self, d: DVec3) -> Self {
        Self::new(self.min - d, self.max + d)
    }

    /// `contract`.
    pub fn deflate(&self, d: DVec3) -> Self {
        Self::new(self.min + d, self.max - d)
    }

    /// `getOffsetBoundingBox`.
    pub fn offset(&self, d: DVec3) -> Self {
        Self::new(self.min + d, self.max + d)
    }

    fn clip(&self, other: &Self, axis: usize, mut delta: f64) -> f64 {
        let (a, b) = ((axis + 1) % 3, (axis + 2) % 3);
        let overlaps = |i: usize| other.max[i] > self.min[i] && other.min[i] < self.max[i];
        if !overlaps(a) || !overlaps(b) {
            return delta;
        }
        if delta > 0.0 && other.max[axis] <= self.min[axis] {
            delta = delta.min(self.min[axis] - other.max[axis]);
        }
        if delta < 0.0 && other.min[axis] >= self.max[axis] {
            delta = delta.max(self.max[axis] - other.min[axis]);
        }
        delta
    }

    /// `calculateXOffset`: how far `other` may move along x before hitting this box.
    pub fn clip_x(&self, other: &Self, dx: f64) -> f64 {
        self.clip(other, 0, dx)
    }

    pub fn clip_y(&self, other: &Self, dy: f64) -> f64 {
        self.clip(other, 1, dy)
    }

    pub fn clip_z(&self, other: &Self, dz: f64) -> f64 {
        self.clip(other, 2, dz)
    }

    /// `intersectsWith`: open intervals on every axis.
    pub fn intersects(&self, other: &Self) -> bool {
        (0..3).all(|i| other.max[i] > self.min[i] && other.min[i] < self.max[i])
    }

    /// `isVecInside`.
    pub fn contains(&self, p: DVec3) -> bool {
        (0..3).all(|i| p[i] > self.min[i] && p[i] < self.max[i])
    }

    pub fn average_edge(&self) -> f64 {
        let d = self.max - self.min;
        (d.x + d.y + d.z) / 3.0
    }

    /// `calculateIntercept`: the nearest face hit by the segment and its side.
    pub fn intercept(&self, start: DVec3, end: DVec3) -> Option<(DVec3, u8)> {
        nearest_face(start, end, self.min, self.max)
    }
}

/// `Vec3D.getIntermediateWithXValue` and friends: the point of the segment where an axis has
/// a value, if within the segment.
pub fn intermediate(start: DVec3, end: DVec3, axis: usize, value: f64) -> Option<DVec3> {
    let d = end - start;
    if d[axis] * d[axis] < f64::from(1.0e-7_f32) {
        return None;
    }
    let t = (value - start[axis]) / d[axis];
    (0.0..=1.0).contains(&t).then(|| start + d * t)
}

/// The face intercepts of `collisionRayTrace`/`calculateIntercept` for a box, nearest first by
/// distance from `start`, with the side numbers 4, 5, 0, 1, 2, 3 for -x, +x, -y, +y, -z, +z.
pub fn nearest_face(start: DVec3, end: DVec3, min: DVec3, max: DVec3) -> Option<(DVec3, u8)> {
    let candidates = [
        (0, min.x, 4),
        (0, max.x, 5),
        (1, min.y, 0),
        (1, max.y, 1),
        (2, min.z, 2),
        (2, max.z, 3),
    ];
    let mut best: Option<(DVec3, u8)> = None;
    for (axis, value, side) in candidates {
        let Some(p) = intermediate(start, end, axis, value) else {
            continue;
        };
        let (a, b) = ((axis + 1) % 3, (axis + 2) % 3);
        let inside = |i: usize| p[i] >= min[i] && p[i] <= max[i];
        if !inside(a) || !inside(b) {
            continue;
        }
        if best.is_none_or(|(q, _)| start.distance_squared(p) < start.distance_squared(q)) {
            best = Some((p, side));
        }
    }
    best
}

/// `MovingObjectPosition` for a block.
#[derive(Clone, Copy, PartialEq, Debug)]
pub struct BlockHit {
    pub x: i32,
    pub y: i32,
    pub z: i32,
    pub side: u8,
    pub point: DVec3,
}