gridmap 0.0.2

library for handling infinite multi-dimensional grids of cells
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

//! Rotate indexes

use super::Transform;

/// Define the four possible orientations
#[repr(u8)]
#[derive(PartialEq, Eq, Clone, Copy)]
pub enum Rotation {
    /// No rotation
    None = 0,

    /// Rotate by 90°
    Quarter = 1,

    /// Rotate by 180°
    Half = 2,

    /// Rotate by -90°
    ThreeQuarters = 3,
}

/// Define a rotation axis in 3D
#[repr(u8)]
#[derive(PartialEq, Eq, Clone, Copy)]
pub enum Axis3D {
    X = 0,
    Y = 1,
    Z = 2,
}

/// Rotate the index
pub struct Rotate2(pub Rotation);

/// Rotate the index
pub struct Rotate3 {
    /// Rotation to apply
    pub rotation: Rotation,

    /// Axis to rotate around
    pub axis: Axis3D,

    /// Is the coordinate system left-handed ?
    pub left_handed: bool,
}

/// Apply the transformation to the given index
impl Transform<2> for Rotate2 {
    fn apply(&self, index: &mut [isize; 2]) {
        let [x, y] = *index;

        match self.0 {
            // 180°
            Rotation::Half => {
                index[0] = -x;
                index[1] = -y;
            }

            // Quarter rotation
            Rotation::Quarter => {
                index[0] = -y;
                index[1] = x;
            }
            Rotation::ThreeQuarters => {
                index[0] = y;
                index[1] = -x;
            }

            _ => {
                // if rotation is none, do nothing
            }
        }
    }
}

/// Apply the transformation to the given index
impl Transform<3> for Rotate3 {
    fn apply(&self, index: &mut [isize; 3]) {
        let [x, y, z] = *index;

        match (self.axis, self.rotation, self.left_handed) {
            // 180°
            (Axis3D::X, Rotation::Half, _) => {
                index[1] = -y;
                index[2] = -z;
            }
            (Axis3D::Y, Rotation::Half, _) => {
                index[0] = -x;
                index[2] = -z;
            }
            (Axis3D::Z, Rotation::Half, _) => {
                index[0] = -x;
                index[1] = -y;
            }

            // X-axis
            (Axis3D::X, Rotation::Quarter, false) | (Axis3D::X, Rotation::ThreeQuarters, true) => {
                index[1] = -z;
                index[2] = y;
            }
            (Axis3D::X, Rotation::Quarter, true) | (Axis3D::X, Rotation::ThreeQuarters, false) => {
                index[1] = z;
                index[2] = -y;
            }

            // Y-axis
            (Axis3D::Y, Rotation::Quarter, false) | (Axis3D::Y, Rotation::ThreeQuarters, true) => {
                index[0] = z;
                index[2] = -x;
            }
            (Axis3D::Y, Rotation::Quarter, true) | (Axis3D::Y, Rotation::ThreeQuarters, false) => {
                index[0] = -z;
                index[2] = x;
            }

            // Z-axis
            (Axis3D::Z, Rotation::Quarter, false) | (Axis3D::Z, Rotation::ThreeQuarters, true) => {
                index[0] = -y;
                index[1] = x;
            }
            (Axis3D::Z, Rotation::Quarter, true) | (Axis3D::Z, Rotation::ThreeQuarters, false) => {
                index[0] = y;
                index[1] = -x;
            }

            // No rotation
            _ => {
                // if rotation is none, do nothing
            }
        }
    }
}