transvoxel 0.5.1

Implementation of Eric Lengyel's Transvoxel Algorithm
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

/*!
Mapping system between XYZ and UVW coordinates
*/
use crate::density::Coordinate;

use super::super::structs::*;
use super::super::transition_sides::*;
use super::super::voxel_coordinates::*;
use super::aux_tables;

#[derive(Debug)]
pub struct XYZ {
    pub x: isize,
    pub y: isize,
    pub z: isize,
}
#[derive(Debug)]
/**
Rotation information for one of the 6 [TransitionSide]
*/
pub struct Rotation {
    /// The side is just stored along here for convenience
    pub side: TransitionSide,
    /// Where the origin of the UVW system is, in the XYZ system. It is used both for cells and blocks. 0 is at the lowest of the cell or block, 1 at the highest
    pub uvw_base: XYZ,
    /// The direction of the U unit vector, in the XYZ system. Components can be -1 0 or 1
    pub u: XYZ,
    /// The direction of the V unit vector, in the XYZ system. Components can be -1 0 or 1
    pub v: XYZ,
    /// The direction of the W unit vector, in the XYZ system. Components can be -1 0 or 1
    pub w: XYZ,
    /// The direction of the X unit vector, in the UVW system. Components can be -1 0 or 1
    pub plus_x_as_uvw: HighResolutionVoxelDelta,
    /// The direction of the Y unit vector, in the UVW system. Components can be -1 0 or 1
    pub plus_y_as_uvw: HighResolutionVoxelDelta,
    /// The direction of the Z unit vector, in the UVW system. Components can be -1 0 or 1
    pub plus_z_as_uvw: HighResolutionVoxelDelta,
}

impl XYZ {
    const fn from(xyz: (isize, isize, isize)) -> Self {
        XYZ {
            x: xyz.0,
            y: xyz.1,
            z: xyz.2,
        }
    }
}

impl Rotation {
    pub fn for_side(side: TransitionSide) -> &'static Self {
        &aux_tables::ROTATIONS[side as usize]
    }

    /**
    Gives the position of this voxel relative to the block (each coordinate ranging from 0 to 1)
    */
    pub fn to_position_in_block<F>(
        &self,
        block_size: usize,
        voxel_index: &HighResolutionVoxelIndex,
    ) -> Position<F>
    where F: Coordinate
    {
        let cell_index = voxel_index.cell;
        let delta = voxel_index.delta;
        // We multiply by 2 most things to divide in the end, in an attempt to reduce floating point operations (maybe need to measure if this is gaining us anything)
        let x = self.uvw_base.x * 2 * block_size as isize
            + self.u.x * (2 * cell_index.cell_u as isize + delta.u)
            + self.v.x * (2 * cell_index.cell_v as isize + delta.v)
            + self.w.x * delta.w;
        let x = F::half(x) * F::from_ratio(1, block_size);
        let y = self.uvw_base.y * 2 * block_size as isize
            + self.u.y * (2 * cell_index.cell_u as isize + delta.u)
            + self.v.y * (2 * cell_index.cell_v as isize + delta.v)
            + self.w.y * delta.w;
        let y = F::half(y) * F::from_ratio(1, block_size);
        let z = self.uvw_base.z * 2 * block_size as isize
            + self.u.z * (2 * cell_index.cell_u as isize + delta.u)
            + self.v.z * (2 * cell_index.cell_v as isize + delta.v)
            + self.w.z * delta.w;
        let z = F::half(z) * F::from_ratio(1, block_size);
        Position { x: x, y: y, z: z }
    }

    pub fn to_regular_voxel_index(
        &self,
        block_size: usize,
        cell_index: &TransitionCellIndex,
        face_u: usize,
        face_v: usize,
    ) -> RegularVoxelIndex {
        let x = self.uvw_base.x * block_size as isize
            + self.u.x * (cell_index.cell_u + face_u) as isize
            + self.v.x * (cell_index.cell_v + face_v) as isize;
        let y = self.uvw_base.y * block_size as isize
            + self.u.y * (cell_index.cell_u + face_u) as isize
            + self.v.y * (cell_index.cell_v + face_v) as isize;
        let z = self.uvw_base.z * block_size as isize
            + self.u.z * (cell_index.cell_u + face_u) as isize
            + self.v.z * (cell_index.cell_v + face_v) as isize;
        return RegularVoxelIndex { x, y, z };
    }

    pub const fn from(
        side: TransitionSide,
        uvw_base: (isize, isize, isize),
        u: (isize, isize, isize),
        v: (isize, isize, isize),
        w: (isize, isize, isize),
        _xyz_base: (isize, isize, isize),
        x: (isize, isize, isize),
        y: (isize, isize, isize),
        z: (isize, isize, isize),
    ) -> Self {
        Rotation {
            side: side,
            uvw_base: XYZ::from(uvw_base),
            u: XYZ::from(u),
            v: XYZ::from(v),
            w: XYZ::from(w),
            plus_x_as_uvw: HighResolutionVoxelDelta::from(x.0, x.1, x.2),
            plus_y_as_uvw: HighResolutionVoxelDelta::from(y.0, y.1, y.2),
            plus_z_as_uvw: HighResolutionVoxelDelta::from(z.0, z.1, z.2),
        }
    }

    pub fn default() -> &'static Self {
        &aux_tables::ROTATIONS[0]
    }
}