impetus 0.23.3

Physics engine — 2D/3D rigid body simulation, collision detection, constraints, and spatial queries for AGNOS
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

//! Rigid bodies — static, dynamic, kinematic.

use serde::{Deserialize, Serialize};

/// Unique handle to a rigid body.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub struct BodyHandle(pub u64);

/// Body type.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum BodyType {
    /// Immovable, infinite mass.
    Static,
    /// Affected by forces and collisions.
    Dynamic,
    /// Moved by user code, affects dynamic bodies but isn't affected by them.
    Kinematic,
}

/// Descriptor for creating a rigid body.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BodyDesc {
    pub body_type: BodyType,
    pub position: [f64; 3],
    pub rotation: f64,
    #[serde(default)]
    pub linear_velocity: [f64; 3],
    #[serde(default)]
    pub angular_velocity: f64,
    #[serde(default)]
    pub linear_damping: f64,
    #[serde(default)]
    pub angular_damping: f64,
    #[serde(default)]
    pub fixed_rotation: bool,
    #[serde(default)]
    pub gravity_scale: Option<f64>,
}

impl Default for BodyDesc {
    fn default() -> Self {
        Self {
            body_type: BodyType::Dynamic,
            position: [0.0, 0.0, 0.0],
            rotation: 0.0,
            linear_velocity: [0.0, 0.0, 0.0],
            angular_velocity: 0.0,
            linear_damping: 0.0,
            angular_damping: 0.0,
            fixed_rotation: false,
            gravity_scale: None,
        }
    }
}

/// Runtime state of a body (read from simulation).
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct BodyState {
    pub handle: BodyHandle,
    pub body_type: BodyType,
    pub position: [f64; 3],
    pub rotation: f64,
    pub linear_velocity: [f64; 3],
    pub angular_velocity: f64,
    pub is_sleeping: bool,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn default_body_desc() {
        let desc = BodyDesc::default();
        assert_eq!(desc.body_type, BodyType::Dynamic);
        assert_eq!(desc.position, [0.0, 0.0, 0.0]);
        assert_eq!(desc.rotation, 0.0);
        assert_eq!(desc.linear_damping, 0.0);
        assert_eq!(desc.angular_damping, 0.0);
        assert!(!desc.fixed_rotation);
        assert_eq!(desc.gravity_scale, None);
    }

    #[test]
    fn body_desc_serde() {
        let desc = BodyDesc {
            body_type: BodyType::Static,
            position: [5.0, 3.0, 0.0],
            rotation: 1.57,
            ..Default::default()
        };
        let json = serde_json::to_string(&desc).unwrap();
        let back: BodyDesc = serde_json::from_str(&json).unwrap();
        assert_eq!(desc, back);
    }

    #[test]
    fn body_desc_kinematic_serde() {
        let desc = BodyDesc {
            body_type: BodyType::Kinematic,
            position: [1.0, 2.0, 0.0],
            linear_velocity: [3.0, 4.0, 0.0],
            angular_velocity: 0.5,
            fixed_rotation: true,
            gravity_scale: Some(0.5),
            ..Default::default()
        };
        let json = serde_json::to_string(&desc).unwrap();
        let back: BodyDesc = serde_json::from_str(&json).unwrap();
        assert_eq!(desc, back);
    }

    #[test]
    fn body_handle_eq() {
        assert_eq!(BodyHandle(1), BodyHandle(1));
        assert_ne!(BodyHandle(1), BodyHandle(2));
    }

    #[test]
    fn body_state_serde() {
        let state = BodyState {
            handle: BodyHandle(42),
            body_type: BodyType::Dynamic,
            position: [1.0, 2.0, 0.0],
            rotation: 0.5,
            linear_velocity: [3.0, 4.0, 0.0],
            angular_velocity: 1.0,
            is_sleeping: false,
        };
        let json = serde_json::to_string(&state).unwrap();
        let back: BodyState = serde_json::from_str(&json).unwrap();
        assert_eq!(state, back);
    }

    #[test]
    fn body_state_sleeping() {
        let state = BodyState {
            handle: BodyHandle(0),
            body_type: BodyType::Static,
            position: [0.0, 0.0, 0.0],
            rotation: 0.0,
            linear_velocity: [0.0, 0.0, 0.0],
            angular_velocity: 0.0,
            is_sleeping: true,
        };
        assert!(state.is_sleeping);
    }
}