dynamis-model 0.4.1

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

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ConstraintKind {
    Ball,
    Distance,
    Revolute,
    Prismatic,
    Fixed,
}

#[derive(Clone, Copy, Debug)]
pub struct ConstraintDesc {
    pub kind: ConstraintKind,
    pub anchor_a: [f32; 3],
    pub anchor_b: [f32; 3],
    pub axis: [f32; 3],
    pub distance: f32,
}

impl ConstraintDesc {
    pub fn ball(anchor_a: [f32; 3], anchor_b: [f32; 3]) -> Self {
        Self {
            kind: ConstraintKind::Ball,
            anchor_a,
            anchor_b,
            axis: [0.0, 1.0, 0.0],
            distance: 0.0,
        }
    }

    pub fn distance(anchor_a: [f32; 3], anchor_b: [f32; 3], distance: f32) -> Self {
        assert!(distance >= 0.0, "constraint distance must be non-negative");
        Self {
            kind: ConstraintKind::Distance,
            anchor_a,
            anchor_b,
            axis: [0.0, 1.0, 0.0],
            distance,
        }
    }

    pub fn revolute(anchor_a: [f32; 3], anchor_b: [f32; 3], axis: [f32; 3]) -> Self {
        assert!(axis != [0.0; 3], "revolute axis must be non-zero");
        Self {
            kind: ConstraintKind::Revolute,
            anchor_a,
            anchor_b,
            axis,
            distance: 0.0,
        }
    }

    pub fn prismatic(anchor_a: [f32; 3], anchor_b: [f32; 3], axis: [f32; 3]) -> Self {
        assert!(axis != [0.0; 3], "prismatic axis must be non-zero");
        Self {
            kind: ConstraintKind::Prismatic,
            anchor_a,
            anchor_b,
            axis,
            distance: 0.0,
        }
    }

    pub fn fixed(anchor_a: [f32; 3], anchor_b: [f32; 3]) -> Self {
        Self {
            kind: ConstraintKind::Fixed,
            anchor_a,
            anchor_b,
            axis: [0.0, 1.0, 0.0],
            distance: 0.0,
        }
    }
}

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