#![allow(clippy::new_ret_no_self)]
use crate::{
convex_mesh::ConvexMesh, height_field::HeightField, traits::Class, triangle_mesh::TriangleMesh,
};
#[rustfmt::skip]
pub use physx_sys::{
PxBoxGeometry,
PxCapsuleGeometry,
PxConvexMeshGeometry,
PxConvexMeshGeometryFlag as ConvexMeshGeometryFlag,
PxConvexMeshGeometryFlags as ConvexMeshGeometryFlags,
PxGeometry,
PxGeometryType as GeometryType,
PxHeightFieldGeometry,
PxMeshGeometryFlag as MeshGeometryFlag,
PxMeshGeometryFlags as MeshGeometryFlags,
PxPlaneGeometry,
PxSphereGeometry,
PxTriangleMeshGeometry,
};
#[rustfmt::skip]
use physx_sys::{
PxBoxGeometry_isValid,
PxBoxGeometry_new,
PxCapsuleGeometry_isValid,
PxCapsuleGeometry_new,
PxConvexMeshGeometry_isValid,
PxConvexMeshGeometry_new,
PxGeometry_getType,
PxHeightFieldGeometry_isValid,
PxHeightFieldGeometry_new,
PxMeshScale,
PxPlaneGeometry_isValid,
PxPlaneGeometry_new,
PxSphereGeometry_isValid,
PxSphereGeometry_new,
PxTriangleMeshGeometry_isValid,
PxTriangleMeshGeometry_new,
};
use std::ptr;
impl<T> Geometry for T where T: Class<PxGeometry> {}
pub trait Geometry: Class<PxGeometry> {
fn get_type(&self) -> GeometryType {
unsafe { PxGeometry_getType(self.as_ptr() as *const _) }
}
}
impl<T> SphereGeometry for T where T: Class<PxSphereGeometry> + Geometry {}
pub trait SphereGeometry: Class<PxSphereGeometry> + Geometry {
fn new(radius: f32) -> PxSphereGeometry {
unsafe { PxSphereGeometry_new(radius) }
}
fn default() -> PxSphereGeometry {
unsafe { PxSphereGeometry_new(0.0) }
}
fn is_valid(&self) -> bool {
unsafe { PxSphereGeometry_isValid(self.as_ptr()) }
}
}
impl<T> PlaneGeometry for T where T: Class<PxPlaneGeometry> + Geometry {}
pub trait PlaneGeometry: Class<PxPlaneGeometry> + Geometry {
fn new() -> PxPlaneGeometry {
unsafe { PxPlaneGeometry_new() }
}
fn default() -> PxPlaneGeometry {
unsafe { PxPlaneGeometry_new() }
}
fn is_valid(&self) -> bool {
unsafe { PxPlaneGeometry_isValid(self.as_ptr()) }
}
}
impl<T> CapsuleGeometry for T where T: Class<PxCapsuleGeometry> + Geometry {}
pub trait CapsuleGeometry: Class<PxCapsuleGeometry> + Geometry {
fn new(radius: f32, half_height: f32) -> PxCapsuleGeometry {
unsafe { PxCapsuleGeometry_new(radius, half_height) }
}
fn default() -> PxCapsuleGeometry {
unsafe { PxCapsuleGeometry_new(0.0, 0.0) }
}
fn is_valid(&self) -> bool {
unsafe { PxCapsuleGeometry_isValid(self.as_ptr()) }
}
}
impl<T> BoxGeometry for T where T: Class<PxBoxGeometry> + Geometry {}
pub trait BoxGeometry: Class<PxBoxGeometry> + Geometry {
fn new(half_x: f32, half_y: f32, half_z: f32) -> PxBoxGeometry {
unsafe { PxBoxGeometry_new(half_x, half_y, half_z) }
}
fn default() -> PxBoxGeometry {
unsafe { PxBoxGeometry_new(0.0, 0.0, 0.0) }
}
fn is_valid(&self) -> bool {
unsafe { PxBoxGeometry_isValid(self.as_ptr()) }
}
}
impl<T> ConvexMeshGeometry for T where T: Class<PxConvexMeshGeometry> + Geometry {}
pub trait ConvexMeshGeometry: Class<PxConvexMeshGeometry> + Geometry {
fn new(
mesh: &mut ConvexMesh,
scaling: &impl Class<PxMeshScale>,
flags: ConvexMeshGeometryFlags,
) -> PxConvexMeshGeometry {
unsafe { PxConvexMeshGeometry_new(mesh.as_mut_ptr(), scaling.as_ptr(), flags) }
}
fn default() -> PxConvexMeshGeometry {
unsafe {
PxConvexMeshGeometry_new(
ptr::null_mut(),
ptr::null(),
ConvexMeshGeometryFlags::TightBounds,
)
}
}
fn is_valid(&self) -> bool {
unsafe { PxConvexMeshGeometry_isValid(self.as_ptr()) }
}
}
impl<T> TriangleMeshGeometry for T where T: Class<PxTriangleMeshGeometry> + Geometry {}
pub trait TriangleMeshGeometry: Class<PxTriangleMeshGeometry> + Geometry {
fn new(
mesh: &mut TriangleMesh,
scaling: &impl Class<PxMeshScale>,
flags: MeshGeometryFlags,
) -> PxTriangleMeshGeometry {
unsafe { PxTriangleMeshGeometry_new(mesh.as_mut_ptr(), scaling.as_ptr(), flags) }
}
fn default() -> PxTriangleMeshGeometry {
unsafe {
PxTriangleMeshGeometry_new(ptr::null_mut(), ptr::null(), MeshGeometryFlags::empty())
}
}
#[inline]
fn is_valid(&self) -> bool {
unsafe { PxTriangleMeshGeometry_isValid(self.as_ptr()) }
}
}
impl<T> HeightFieldGeometry for T where T: Class<PxHeightFieldGeometry> + Geometry {}
pub trait HeightFieldGeometry: Class<PxHeightFieldGeometry> + Geometry {
fn new(
height_field: &mut HeightField,
flags: MeshGeometryFlags,
height_scale: f32,
row_scale: f32,
column_scale: f32,
) -> PxHeightFieldGeometry {
unsafe {
PxHeightFieldGeometry_new(
height_field.as_mut_ptr(),
flags,
height_scale,
row_scale,
column_scale,
)
}
}
fn default() -> PxHeightFieldGeometry {
unsafe {
PxHeightFieldGeometry_new(ptr::null_mut(), MeshGeometryFlags::empty(), 1.0, 1.0, 1.0)
}
}
fn is_valid(&self) -> bool {
unsafe { PxHeightFieldGeometry_isValid(self.as_ptr()) }
}
}