boxdd 0.6.0

Safe, ergonomic Rust bindings for Box2D v3
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

use boxdd_sys::ffi;

use crate::error::Result;
use crate::types::{BodyId, ContactData, JointId, ShapeId};
use crate::world::BodyCall;

use super::super::scoped::Body;
use super::{attachments::body_contact_data_in_impl, check_native_body_count, raw_body_id};

#[inline]
pub(crate) fn body_shape_count_impl(id: BodyId) -> i32 {
    unsafe { ffi::b2Body_GetShapeCount(raw_body_id(id)) }
}

#[inline]
pub(crate) fn body_shapes_in_impl(body: BodyCall<'_>) -> Result<Vec<ShapeId>> {
    let cap = check_native_body_count(
        "Body::shapes",
        "shape_count",
        body_shape_count_impl(body.id()),
    )?;
    let id = raw_body_id(body.id());
    body.with_output_identity_resolver(|resolver| unsafe {
        crate::core::ffi_vec::try_read_mapped_from_ffi(
            cap,
            |ptr, cap| ffi::b2Body_GetShapes(id, ptr, cap),
            |raw| resolver.shape(raw),
        )
    })
}

#[inline]
pub(crate) fn body_joint_count_impl(id: BodyId) -> i32 {
    unsafe { ffi::b2Body_GetJointCount(raw_body_id(id)) }
}

#[inline]
pub(crate) fn body_joints_in_impl(body: BodyCall<'_>) -> Result<Vec<JointId>> {
    let cap = check_native_body_count(
        "Body::joints",
        "joint_count",
        body_joint_count_impl(body.id()),
    )?;
    let id = raw_body_id(body.id());
    body.with_output_identity_resolver(|resolver| unsafe {
        crate::core::ffi_vec::try_read_mapped_from_ffi(
            cap,
            |ptr, cap| ffi::b2Body_GetJoints(id, ptr, cap),
            |raw| resolver.joint(raw),
        )
    })
}

impl Body<'_> {
    pub fn contact_data(&self) -> Result<Vec<ContactData>> {
        self.body_access().call(body_contact_data_in_impl)
    }

    pub fn shape_count(&self) -> Result<i32> {
        self.body_access().call(|_| {
            check_native_body_count(
                "Body::shape_count",
                "shape_count",
                body_shape_count_impl(self.body_id()),
            )
        })
    }

    pub fn shapes(&self) -> Result<Vec<ShapeId>> {
        self.body_access().call(body_shapes_in_impl)
    }

    pub fn joint_count(&self) -> Result<i32> {
        self.body_access().call(|_| {
            check_native_body_count(
                "Body::joint_count",
                "joint_count",
                body_joint_count_impl(self.body_id()),
            )
        })
    }

    pub fn joints(&self) -> Result<Vec<JointId>> {
        self.body_access().call(body_joints_in_impl)
    }
}