lnmp-spatial 0.5.16

Spatial awareness types and logic for LNMP protocol
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

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub enum SpatialType {
    Position2D = 0x01,
    Position3D = 0x02,
    Rotation = 0x03,
    Velocity = 0x04,
    Acceleration = 0x05,
    BoundingBox = 0x06,
    Quaternion = 0x07,
    Path = 0x08,
    Transform = 0x09,
    SpatialState = 0x0A,
    PositionDelta = 0x0B,
    RotationDelta = 0x0C,
    SpatialDelta = 0x0D,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Position2D {
    pub x: f32,
    pub y: f32,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Position3D {
    pub x: f32,
    pub y: f32,
    pub z: f32,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Rotation {
    pub pitch: f32,
    pub yaw: f32,
    pub roll: f32,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Velocity {
    pub vx: f32,
    pub vy: f32,
    pub vz: f32,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Acceleration {
    pub ax: f32,
    pub ay: f32,
    pub az: f32,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct BoundingBox {
    pub min_x: f32,
    pub min_y: f32,
    pub min_z: f32,
    pub max_x: f32,
    pub max_y: f32,
    pub max_z: f32,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Quaternion {
    pub qx: f32,
    pub qy: f32,
    pub qz: f32,
    pub qw: f32,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Path {
    pub points: Vec<Position3D>,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct Transform {
    pub position: Position3D,
    pub rotation: Rotation,
    pub scale: Position3D, // Using Position3D for scale x, y, z
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct SpatialState {
    pub position: Option<Position3D>,
    pub rotation: Option<Rotation>,
    pub velocity: Option<Velocity>,
    pub acceleration: Option<Acceleration>,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct PositionDelta {
    pub dx: f32,
    pub dy: f32,
    pub dz: f32,
}

#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct RotationDelta {
    pub d_pitch: f32,
    pub d_yaw: f32,
    pub d_roll: f32,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum SpatialDelta {
    Position(PositionDelta),
    Rotation(RotationDelta),
    State {
        position: Option<PositionDelta>,
        rotation: Option<RotationDelta>,
        velocity: Option<Velocity>, // Velocity is absolute, or should it be delta? Usually absolute update.
        acceleration: Option<Acceleration>,
    },
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PredictiveDelta {
    pub delta: PositionDelta,
    pub velocity: Velocity,
    pub predicted_next: Position3D,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum SpatialValue {
    S1(Position2D),
    S2(Position3D),
    S3(Rotation),
    S4(Velocity),
    S5(Acceleration),
    S6(BoundingBox),
    S7(Quaternion),
    S8(Path),
    S9(Transform),
    S10(SpatialState),
    S11(PositionDelta),
    S12(RotationDelta),
    S13(SpatialDelta),
}