dynamis-model 0.4.2

GPU-driven physics engine
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
150
151
152
153
154
155
156
157
158
159
160
161
162

use crate::collider::ColliderDesc;
use crate::shape::Shape;

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct BodyHandle {
    pub id: u32,
    pub generation: u32,
}

#[derive(Clone, Copy, Debug, PartialEq)]
pub struct BodyState {
    pub position: [f32; 3],
    pub orientation: [f32; 4],
    pub velocity: [f32; 3],
    pub angular_velocity: [f32; 3],
    pub inverse_mass: f32,
    pub sleeping: bool,
    pub step: u64,
}

pub const DEFAULT_COLLISION_GROUP: u32 = 0x0000_0001;
pub const DEFAULT_COLLISION_MASK: u32 = 0xFFFF_FFFF;
pub const BODY_DESC_COLLIDERS_MAX: usize = 4;

#[derive(Clone, Debug)]
pub struct BodyDesc {
    pub colliders: Vec<ColliderDesc>,
    pub position: [f32; 3],
    pub orientation: [f32; 4],
    pub velocity: [f32; 3],
    pub angular_velocity: [f32; 3],
    pub mass: f32,
    pub collision_group: u32,
    pub collision_mask: u32,
    pub kinematic: bool,
    pub ccd: bool,
}

impl BodyDesc {
    pub fn new(collider: ColliderDesc) -> Self {
        Self {
            colliders: vec![collider],
            position: [0.0; 3],
            orientation: [0.0, 0.0, 0.0, 1.0],
            velocity: [0.0; 3],
            angular_velocity: [0.0; 3],
            mass: 1.0,
            collision_group: DEFAULT_COLLISION_GROUP,
            collision_mask: DEFAULT_COLLISION_MASK,
            kinematic: false,
            ccd: false,
        }
    }

    pub fn collider(mut self, collider: ColliderDesc) -> Self {
        assert!(
            self.colliders.len() < BODY_DESC_COLLIDERS_MAX,
            "a body supports at most four colliders"
        );
        self.colliders.push(collider);
        self
    }

    pub fn sphere(radius: f32) -> Self {
        Self::new(ColliderDesc::new(Shape::sphere(radius)))
    }

    pub fn cuboid(half_extents: [f32; 3]) -> Self {
        Self::new(ColliderDesc::new(Shape::cuboid(half_extents)))
    }

    pub fn capsule(radius: f32, half_height: f32) -> Self {
        Self::new(ColliderDesc::new(Shape::capsule(radius, half_height)))
    }

    pub fn cylinder(radius: f32, half_height: f32) -> Self {
        Self::new(ColliderDesc::new(Shape::cylinder(radius, half_height)))
    }

    pub fn static_sphere(radius: f32) -> Self {
        Self {
            mass: 0.0,
            ..Self::sphere(radius)
        }
    }

    pub fn position(mut self, position: [f32; 3]) -> Self {
        self.position = position;
        self
    }

    pub fn restitution(mut self, restitution: f32) -> Self {
        self.colliders[0].restitution = restitution;
        self
    }

    pub fn friction(mut self, friction: f32) -> Self {
        assert!(friction >= 0.0, "friction must be non-negative");
        self.colliders[0].friction = friction;
        self
    }

    pub fn sensor(mut self, sensor: bool) -> Self {
        assert!(
            !self.colliders.is_empty(),
            "a body needs at least one collider"
        );
        self.colliders[0].sensor = sensor;
        self
    }

    pub fn orientation(mut self, orientation: [f32; 4]) -> Self {
        assert!(
            (orientation[0] * orientation[0]
                + orientation[1] * orientation[1]
                + orientation[2] * orientation[2]
                + orientation[3] * orientation[3]
                - 1.0)
                .abs()
                < 1e-4,
            "orientation must be a unit quaternion"
        );
        self.orientation = orientation;
        self
    }

    pub fn velocity(mut self, velocity: [f32; 3]) -> Self {
        self.velocity = velocity;
        self
    }

    pub fn angular_velocity(mut self, angular_velocity: [f32; 3]) -> Self {
        self.angular_velocity = angular_velocity;
        self
    }

    pub fn mass(mut self, mass: f32) -> Self {
        assert!(mass >= 0.0, "mass must be non-negative");
        self.mass = mass;
        self
    }

    pub fn collision_group(mut self, group: u32) -> Self {
        self.collision_group = group;
        self
    }

    pub fn collision_mask(mut self, mask: u32) -> Self {
        self.collision_mask = mask;
        self
    }

    pub fn kinematic(mut self, kinematic: bool) -> Self {
        self.kinematic = kinematic;
        self
    }

    pub fn ccd(mut self, ccd: bool) -> Self {
        self.ccd = ccd;
        self
    }
}