physxx 0.3.1

Wrapper around the PhysX C++ API that aims to preserve the original API as much as possible.
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

use std::ffi::c_void;

use num_traits::FromPrimitive;

use crate::{
    AsPxBase, PxBaseRef, PxGeometry, PxGeometryHolder, PxGeometryType, PxMaterial, PxPhysicsRef,
    PxRigidActorRef, PxTransform, PxUserData,
};

bitflags! {
    pub struct PxShapeFlag: u8 {
        const SCENE_QUERY_SHAPE = physx_sys::PxShapeFlag::eSCENE_QUERY_SHAPE as u8;
        const SIMULATION_SHAPE = physx_sys::PxShapeFlag::eSIMULATION_SHAPE as u8;
        const TRIGGER_SHAPE = physx_sys::PxShapeFlag::eTRIGGER_SHAPE as u8;
        const VISUALIZATION = physx_sys::PxShapeFlag::eVISUALIZATION as u8;
    }
}
impl Default for PxShapeFlag {
    fn default() -> Self {
        Self::VISUALIZATION | Self::SIMULATION_SHAPE
    }
}

#[derive(Debug, PartialEq, Eq, Hash)]
pub struct PxShape(pub *mut physx_sys::PxShape, pub usize);
impl PxShape {
    pub fn new(
        physics: PxPhysicsRef,
        geometry: &dyn PxGeometry,
        materials: &[&PxMaterial],
        is_exclusive: Option<bool>,
        shape_flags: Option<PxShapeFlag>,
    ) -> Self {
        let mats = materials
            .iter()
            .map(|x| x.0)
            .collect::<Vec<*mut physx_sys::PxMaterial>>();
        Self(
            unsafe {
                physx_sys::PxPhysics_createShape_mut_1(
                    physics.0,
                    geometry.as_geometry_ptr(),
                    mats.as_ptr(),
                    materials.len() as u16,
                    is_exclusive.unwrap_or(false),
                    physx_sys::PxShapeFlags {
                        mBits: shape_flags.unwrap_or_default().bits,
                    },
                )
            },
            0,
        )
    }
    pub(crate) fn from_ptr(ptr: *mut physx_sys::PxShape) -> Self {
        let mut s = Self(ptr, 0);
        s.acquire_reference();
        s
    }
    pub(crate) fn acquire_reference(&mut self) {
        self.1 += 1;
        unsafe { physx_sys::PxShape_acquireReference_mut(self.0) }
    }
    pub fn get_geometry(&self) -> PxGeometryHolder {
        PxGeometryHolder(unsafe { physx_sys::PxShape_getGeometry(self.0) })
    }
    pub fn set_geometry(&self, geometry: &dyn PxGeometry) {
        unsafe { physx_sys::PxShape_setGeometry_mut(self.0, geometry.as_geometry_ptr()) }
    }
    pub fn get_geometry_type(&self) -> PxGeometryType {
        PxGeometryType::from_i32(unsafe { physx_sys::PxShape_getGeometryType(self.0) }).unwrap()
    }
    pub fn get_local_pose(&self) -> PxTransform {
        PxTransform(unsafe { physx_sys::PxShape_getLocalPose(self.0) })
    }
    pub fn set_local_pose(&self, pose: &PxTransform) {
        unsafe {
            physx_sys::PxShape_setLocalPose_mut(self.0, &pose.0 as *const physx_sys::PxTransform)
        }
    }
    pub fn get_global_pose(&self, actor: PxRigidActorRef) -> PxTransform {
        PxTransform(unsafe { physx_sys::PxShapeExt_getGlobalPose_mut(self.0, actor.0) })
    }
    pub fn get_actor(&self) -> Option<PxRigidActorRef> {
        unsafe {
            let p = physx_sys::PxShape_getActor(self.0);
            if p.is_null() {
                None
            } else {
                Some(PxRigidActorRef(p))
            }
        }
    }
    pub fn get_flags(&self) -> PxShapeFlag {
        PxShapeFlag::from_bits(unsafe { physx_sys::PxShape_getFlags(self.0) }.mBits).unwrap()
    }
    pub fn set_flag(&self, flag: PxShapeFlag, value: bool) {
        unsafe { physx_sys::PxShape_setFlag_mut(self.0, flag.bits as u32, value) }
    }
    pub fn set_flags(&self, flags: PxShapeFlag) {
        unsafe {
            physx_sys::PxShape_setFlags_mut(self.0, physx_sys::PxShapeFlags { mBits: flags.bits })
        }
    }
    pub fn get_contact_offset(&self) -> f32 {
        unsafe { physx_sys::PxShape_getContactOffset(self.0) }
    }
    pub fn set_contact_offset(&self, offset: f32) {
        unsafe { physx_sys::PxShape_setContactOffset_mut(self.0, offset) }
    }
    pub fn get_rest_offset(&self) -> f32 {
        unsafe { physx_sys::PxShape_getRestOffset(self.0) }
    }
    pub fn set_rest_offset(&self, offset: f32) {
        unsafe { physx_sys::PxShape_setRestOffset_mut(self.0, offset) }
    }
}
impl AsPxBase for PxShape {
    fn as_base(&self) -> PxBaseRef {
        PxBaseRef(self.0 as _)
    }
}
impl PxUserData for PxShape {
    fn raw_user_data_mut(&self) -> &mut *mut c_void {
        unsafe { &mut (*self.0).userData }
    }
    fn raw_user_data(&self) -> &*mut c_void {
        unsafe { &(*self.0).userData }
    }
}
impl Clone for PxShape {
    fn clone(&self) -> Self {
        Self::from_ptr(self.0)
    }
}
impl Drop for PxShape {
    fn drop(&mut self) {
        for _ in 0..self.1 {
            unsafe {
                physx_sys::PxShape_release_mut(self.0);
            }
        }
    }
}
unsafe impl Sync for PxShape {}
unsafe impl Send for PxShape {}