blobs 0.2.1

NOT-Soft body physics in 2D
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

use crate::*;

#[derive(Clone, Debug)]
pub struct DebugData {
    pub bodies: Vec<DebugRigidBody>,
    pub joints: Vec<DebugJoint>,
    pub colliders: Vec<DebugCollider>,
    pub springs: Vec<DebugSpring>,
}

#[derive(Copy, Clone, Debug)]
pub struct DebugRigidBody {
    pub transform: Affine2,
}

#[derive(Copy, Clone, Debug)]
pub struct DebugJoint {
    pub body_a: Vec2,
    pub body_b: Vec2,
}

#[derive(Copy, Clone, Debug)]
pub struct DebugCollider {
    pub transform: Affine2,
    pub radius: f32,
}

#[derive(Copy, Clone, Debug)]
pub struct DebugSpring {
    pub body_a: Vec2,
    pub body_b: Vec2,
}

pub(crate) fn make_debug_data(physics: &Physics) -> DebugData {
    let bodies = physics
        .rbd_set
        .arena
        .iter()
        .map(|(_, body)| {
            let transform = Affine2::from_angle_translation(body.rotation, body.position);
            DebugRigidBody { transform }
        })
        .collect();

    let joints = physics
        .joints
        .iter()
        .map(|(_, joint)| {
            let body_a = physics.rbd_set.arena[*joint.rigid_body_a].position;
            let body_b = physics.rbd_set.arena[*joint.rigid_body_b].position;
            DebugJoint { body_a, body_b }
        })
        .collect();

    let colliders = physics
        .col_set
        .arena
        .iter()
        .map(|(_, collider)| {
            let radius = match collider.shape.as_ball() {
                Some(ball) => ball.radius,
                None => {
                    println!("Invalid shape, expected ball");
                    1.0
                }
            };
    
            DebugCollider {
                transform: collider.absolute_transform,
                radius,
            }
        })
        .collect();

    let springs = physics
        .springs
        .iter()
        .map(|(_, spring)| {
            let body_a = physics.rbd_set.arena[*spring.rigid_body_a].position;
            let body_b = physics.rbd_set.arena[*spring.rigid_body_b].position;
            DebugSpring { body_a, body_b }
        })
        .collect();

    DebugData {
        bodies,
        joints,
        colliders,
        springs,
    }
}