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

use glam::Vec3;

use crate::{
    AsPxPtr, PxConvexMeshCookingResult, PxCookingRef, PxDefaultMemoryInputData,
    PxDefaultMemoryOutputStream, PxPhysicsRef, PxReferenceCounted,
};

bitflags! {
    pub struct PxConvexFlag: u32 {
        const _16_BIT_INDICES = physx_sys::PxConvexFlag::e16_BIT_INDICES;
        const CHECK_ZERO_AREA_TRIANGLES = physx_sys::PxConvexFlag::eCHECK_ZERO_AREA_TRIANGLES;
        const COMPUTE_CONVEX = physx_sys::PxConvexFlag::eCOMPUTE_CONVEX;
        const DISABLE_MESH_VALIDATION = physx_sys::PxConvexFlag::eDISABLE_MESH_VALIDATION;
        const FAST_INERTIA_COMPUTATION = physx_sys::PxConvexFlag::eFAST_INERTIA_COMPUTATION;
        const GPU_COMPATIBLE = physx_sys::PxConvexFlag::eGPU_COMPATIBLE;
        const PLANE_SHIFTING = physx_sys::PxConvexFlag::ePLANE_SHIFTING;
        const QUANTIZE_INPUT = physx_sys::PxConvexFlag::eQUANTIZE_INPUT;
        const SHIFT_VERTICES = physx_sys::PxConvexFlag::eSHIFT_VERTICES;
    }
}

pub struct PxConvexMeshDesc {
    pub points: Vec<Vec3>,
    pub indices: Option<Vec<u32>>,
    pub vertex_limit: Option<u16>,
    pub flags: Option<PxConvexFlag>,
}

#[derive(Debug)]
pub struct PxConvexMesh(pub *mut physx_sys::PxConvexMesh);
impl PxConvexMesh {
    pub fn new(physics: PxPhysicsRef, input: &impl AsPxPtr<*mut physx_sys::PxInputStream>) -> Self {
        unsafe {
            let mesh = physx_sys::PxPhysics_createConvexMesh_mut(physics.0, input.as_px_ptr());
            Self(mesh)
        }
    }
    pub fn from_desc(
        physics: PxPhysicsRef,
        cooking: PxCookingRef,
        desc: PxConvexMeshDesc,
    ) -> Result<Self, PxConvexMeshCookingResult> {
        let stream = PxDefaultMemoryOutputStream::new();
        let mut res = PxConvexMeshCookingResult::Success;
        if !cooking.cook_convex_mesh(&desc, &stream, &mut res) {
            Err(res)
        } else {
            let input = PxDefaultMemoryInputData::new(stream.get_data());
            Ok(Self::new(physics, &input))
        }
    }
    pub(crate) fn from_ptr(ptr: *mut physx_sys::PxConvexMesh) -> Self {
        let mut s = Self(ptr);
        s.acquire_reference();
        s
    }
    pub(crate) fn acquire_reference(&mut self) {
        unsafe { physx_sys::PxConvexMesh_acquireReference_mut(self.0) }
    }
}
impl PxReferenceCounted for PxConvexMesh {
    fn get_reference_count(&self) -> u32 {
        unsafe { physx_sys::PxConvexMesh_getReferenceCount(self.0) }
    }
}
impl Clone for PxConvexMesh {
    fn clone(&self) -> Self {
        Self::from_ptr(self.0)
    }
}
impl Drop for PxConvexMesh {
    fn drop(&mut self) {
        unsafe { physx_sys::PxConvexMesh_release_mut(self.0) }
    }
}
unsafe impl Sync for PxConvexMesh {}
unsafe impl Send for PxConvexMesh {}

bitflags! {
    pub struct PxMeshFlag: u32 {
        const _16_BIT_INDICES = physx_sys::PxMeshFlag::e16_BIT_INDICES;
        const FLIPNORMALS = physx_sys::PxMeshFlag::eFLIPNORMALS;
    }
}

pub struct PxTriangleMeshDesc {
    pub points: Vec<Vec3>,
    pub indices: Vec<u32>,
    pub flags: Option<PxMeshFlag>,
}

#[derive(Debug)]
pub struct PxTriangleMesh(pub *mut physx_sys::PxTriangleMesh);
impl PxTriangleMesh {
    pub fn new(physics: PxPhysicsRef, input: &impl AsPxPtr<*mut physx_sys::PxInputStream>) -> Self {
        unsafe {
            let mesh = physx_sys::PxPhysics_createTriangleMesh_mut(physics.0, input.as_px_ptr());
            Self(mesh)
        }
    }
    pub(crate) fn from_ptr(ptr: *mut physx_sys::PxTriangleMesh) -> Self {
        let mut s = Self(ptr);
        s.acquire_reference();
        s
    }
    pub(crate) fn acquire_reference(&mut self) {
        unsafe { physx_sys::PxTriangleMesh_acquireReference_mut(self.0) }
    }
    pub fn get_nb_vertices(&self) -> u32 {
        unsafe { physx_sys::PxTriangleMesh_getNbVertices(self.0) }
    }
    pub fn get_nb_triangles(&self) -> u32 {
        unsafe { physx_sys::PxTriangleMesh_getNbTriangles(self.0) }
    }
}
impl PxReferenceCounted for PxTriangleMesh {
    fn get_reference_count(&self) -> u32 {
        unsafe { physx_sys::PxTriangleMesh_getReferenceCount(self.0) }
    }
}
impl Clone for PxTriangleMesh {
    fn clone(&self) -> Self {
        Self::from_ptr(self.0)
    }
}
impl Drop for PxTriangleMesh {
    fn drop(&mut self) {
        unsafe { physx_sys::PxTriangleMesh_release_mut(self.0) }
    }
}
unsafe impl Sync for PxTriangleMesh {}
unsafe impl Send for PxTriangleMesh {}