Struct physx::physics::PhysicsFoundation

pub struct PhysicsFoundation<Allocator: AllocatorCallback, Geom: Shape> { /* private fields */ }

A PxPhysics, PxFoundation and optional PxPvd combined into one struct for ease of use. Parametrized by the Foundation’s Allocator and the Physics’ Shape type.

Implementations

impl<Allocator: AllocatorCallback, Geom: Shape> PhysicsFoundation<Allocator, Geom>

pub fn new(allocator: Allocator) -> PhysicsFoundation<Allocator, Geom>

pub fn set_profiler<P: ProfilerCallback>(&mut self, profiler: P)

Set the profiler callback to a struct that implements the ProfilerCallback trait.

Examples found in repository

examples/profiler.rs (lines 105-107)

fn main() {
    // Holds a PxFoundation and a PxPhysics.
    // Also has an optional Pvd and transport, not enabled by default.
    // The default allocator is the one provided by PhysX.
    let mut physics = PhysicsFoundation::<_, PxShape>::default();

    physics.set_profiler(PrintProfilerCallback {
        start: std::time::Instant::now(),
    });
    // Setup the scene object.  The PxScene type alias makes this much cleaner.
    // There are lots of unwrap calls due to potential null pointers.
    let mut scene: Owner<PxScene> = physics
        .create(SceneDescriptor {
            gravity: PxVec3::new(0.0, -9.81, 0.0),
            on_advance: Some(OnAdvance),
            ..SceneDescriptor::new(())
        })
        .unwrap();

    let mut material = physics.create_material(0.5, 0.5, 0.6, ()).unwrap();

    let ground_plane = physics
        .create_plane(PxVec3::new(0.0, 1.0, 0.0), 0.0, material.as_mut(), ())
        .unwrap();
    // The scene owns actors that are added to it.  They can be retrieved using the
    // various getters on the scene.
    scene.add_static_actor(ground_plane);

    let sphere_geo = PxSphereGeometry::new(10.0);

    let mut sphere_actor = physics
        .create_rigid_dynamic(
            PxTransform::from_translation(&PxVec3::new(0.0, 40.0, 100.0)),
            &sphere_geo,
            material.as_mut(),
            10.0,
            PxTransform::default(),
            (),
        )
        .unwrap();
    sphere_actor.set_angular_damping(0.5);
    sphere_actor.set_rigid_body_flag(RigidBodyFlag::EnablePoseIntegrationPreview, true);
    scene.add_dynamic_actor(sphere_actor);

    for _ in 0..100 {
        #[allow(unsafe_code)]
        // SAFETY: it's unsafe /shrug
        let mut sb = unsafe { ScratchBuffer::new(4) };

        // Calls both simulate and fetch_results.  More complex simulation update
        // controls are not fully supported.
        scene
            .step(0.1, None::<&mut physx_sys::PxBaseTask>, Some(&mut sb), true)
            .expect("error occured during simulation");
    }
}

pub fn set_assert_handler<AH: AssertHandler>(&mut self, handler: AH)

Set the global PhysX assert handler to a struct that implements the AssertHandler trait.

Examples found in repository

examples/assert_handler.rs (line 24)

fn main() {
    // Holds a PxFoundation and a PxPhysics.
    // Also has an optional Pvd and transport, not enabled by default.
    // The default allocator is the one provided by PhysX.
    let builder = PhysicsFoundationBuilder::default();
    let mut physics: PhysicsFoundation<physx::foundation::DefaultAllocator, PxShape> =
        builder.build().expect("a foundation being built");

    physics.set_assert_handler(AssertHandler);

    #[allow(unsafe_code)]
    // SAFETY: Calling assertion handlers explicitly since they are not part of
    // of the safe API of physx since they are only normally called from within
    // the SDK itself
    unsafe {
        let assert_handler = physx_sys::phys_PxGetAssertHandler();

        let expr = CString::new("1 != 2").unwrap();
        let file = CString::new(file!()).unwrap();

        let mut should_ignore = false;
        physx_sys::PxAssertHandler_opCall_mut(
            assert_handler,
            expr.as_ptr(),
            file.as_ptr(),
            line!() as _,
            &mut should_ignore as *mut _,
        );

        let expr = CString::new("false").unwrap();
        physx_sys::PxAssertHandler_opCall_mut(
            assert_handler,
            expr.as_ptr(),
            file.as_ptr(),
            line!() as _,
            &mut should_ignore as *mut _,
        );
    }
}

pub unsafe fn with_allocator_error_callback( allocator: Allocator, error_callback: *mut PxErrorCallback ) -> PhysicsFoundation<Allocator, Geom>

Safety

error_callback must live as long as the returned value

pub fn physics(&self) -> &PxPhysics<Geom>

pub fn foundation(&self) -> &PxFoundation<Allocator>

pub fn pvd(&self) -> Option<&VisualDebugger>

pub fn physics_mut(&mut self) -> &mut PxPhysics<Geom>

pub fn foundation_mut(&mut self) -> &mut PxFoundation<Allocator>

Examples found in repository

examples/error_callback.rs (line 30)

fn main() {
    // Holds a PxFoundation and a PxPhysics.
    // Also has an optional Pvd and transport, not enabled by default.
    // The default allocator is the one provided by PhysX.
    let mut builder = PhysicsFoundationBuilder::default();
    builder.with_error_callback(ErrorCallback);
    let mut physics: PhysicsFoundation<physx::foundation::DefaultAllocator, PxShape> =
        builder.build().expect("a foundation being built");

    #[allow(unsafe_code)]
    // SAFETY: Invoking the underlying error reporting functions to demonstrate
    // the error callback, this code is not part of the safe API since it is
    // normally only invoked by the underlying SDK
    unsafe {
        let error_callback =
            physx_sys::PxFoundation_getErrorCallback_mut(physics.foundation_mut().as_mut_ptr());
        let msg = CString::new("this is just a warning").unwrap();
        let file = CString::new(file!()).unwrap();

        physx_sys::PxErrorCallback_reportError_mut(
            error_callback,
            PxErrorCode::DebugWarning,
            msg.as_ptr(),
            file.as_ptr(),
            line!() as _,
        );

        let msg = CString::new("this is an invalid operation").unwrap();
        physx_sys::PxErrorCallback_reportError_mut(
            error_callback,
            PxErrorCode::InvalidOperation,
            msg.as_ptr(),
            file.as_ptr(),
            line!() as _,
        );
    }
}

pub fn pvd_mut(&mut self) -> Option<&mut VisualDebugger>

Trait Implementations

impl<T, Allocator: AllocatorCallback, Geom: Shape> Class<T> for PhysicsFoundation<Allocator, Geom>where PxPhysics: Class<T>,

fn as_ptr(&self) -> *const T

Returns a raw const pointer to the wrapped type. Retrieving a raw pointer is safe. However, pretty much any use of a raw pointer is unsafe. In particular: this pointer should not be used to construct a second owning wrapper around the pointer.

fn as_mut_ptr(&mut self) -> *mut T

Returns a raw mut pointer to the wrapped type. Retrieving a raw pointer is safe. However, pretty much any use of a raw pointer is unsafe. In particular: this pointer should not be used to construct a second owning wrapper around the pointer.

impl<Geom: Shape> Default for PhysicsFoundation<DefaultAllocator, Geom>

fn default() -> Self

Returns the “default value” for a type.

impl<Allocator: AllocatorCallback, Geom: Shape> Drop for PhysicsFoundation<Allocator, Geom>

fn drop(&mut self)

Executes the destructor for this type.

impl<Allocator: AllocatorCallback, Geom: Shape> Physics for PhysicsFoundation<Allocator, Geom>

type Shape = Geom

fn create<Desc: Descriptor<Self>>(&mut self, desc: Desc) -> Desc::Target

fn create_scene<U, L, S, D, C, OC, OT, OCB, OWS, OA>( &mut self, scene_descriptor: SceneDescriptor<U, L, S, D, C, OC, OT, OCB, OWS, OA> ) -> Option<Owner<PxScene<U, L, S, D, C, OC, OT, OCB, OWS, OA>>>where L: ArticulationLink, S: RigidStatic, D: RigidDynamic, C: ArticulationReducedCoordinate, OC: CollisionCallback, OT: TriggerCallback, OCB: ConstraintBreakCallback, OWS: WakeSleepCallback<L, S, D>, OA: AdvanceCallback<L, D>,

Create a new scene with from a descriptor.

fn create_aggregate<L, S, D, C>( &mut self, max_actors: u32, max_shapes: u32, filter_hint: AggregateFilterHint ) -> Option<Owner<PxAggregate<L, S, D, C>>>where L: ArticulationLink, S: RigidStatic, D: RigidDynamic, C: ArticulationReducedCoordinate,

Create a new aggregate.

fn create_articulation_reduced_coordinate<U, L: ArticulationLink>( &mut self, user_data: U ) -> Option<Owner<PxArticulationReducedCoordinate<U, L>>>

Create a new articulation. Must be added to a scene with the same user data types.

fn create_bvh(&mut self, stream: &mut PxInputStream) -> Option<Owner<Bvh>>

Create a new BVH.

fn create_constraint( &mut self, first_actor: &mut impl RigidActor, second_actor: &mut impl RigidActor, connector: &mut PxConstraintConnector, shaders: &PxConstraintShaderTable, data_size: u32 ) -> Option<Owner<Constraint>>

Create a new constraint. The constraint class-trait is not implemented yet.

fn create_convex_mesh( &mut self, stream: &mut PxInputStream ) -> Option<Owner<ConvexMesh>>

Create a new convex mesh. The convex mesh class-trait is not implemented yet.

fn create_height_field( &mut self, stream: &mut PxInputStream ) -> Option<Owner<HeightField>>

Create a new height field.

fn create_material( &mut self, static_friction: f32, dynamic_friction: f32, restitution: f32, user_data: <<Self::Shape as Shape>::Material as UserData>::UserData ) -> Option<Owner<<Self::Shape as Shape>::Material>>

Create a new material with ref count set to one.

fn create_pruning_structure( &mut self, actors: Vec<&mut impl RigidActor> ) -> Option<Owner<PruningStructure>>

Create a new pruning structure. The pruning structure class-trait is not implemented yet.

fn create_dynamic<U>( &mut self, transform: &PxTransform, user_data: U ) -> Option<Owner<PxRigidDynamic<U, Self::Shape>>>

Create a dynamic actor with given transform and user data. Other fields are initialized to their defaults.

fn create_static<U>( &mut self, transform: PxTransform, user_data: U ) -> Option<Owner<PxRigidStatic<U, Self::Shape>>>

Create a static actor with given transform and user data. Other fields are initialized to their defaults.

fn create_shape( &mut self, geometry: &impl Geometry, materials: &mut [&mut <Self::Shape as Shape>::Material], is_exclusive: bool, shape_flags: ShapeFlags, user_data: <Self::Shape as UserData>::UserData ) -> Option<Owner<Self::Shape>>

Create a new shape.

fn create_triangle_mesh( &mut self, stream: &mut PxInputStream ) -> Option<Owner<TriangleMesh>>

Create a new pruning structure. The pruning structure class-trait is not implemented yet.

fn create_rigid_dynamic<U>( &mut self, transform: PxTransform, geometry: &impl Geometry, material: &mut <Self::Shape as Shape>::Material, density: f32, shape_transform: PxTransform, user_data: U ) -> Option<Owner<PxRigidDynamic<U, Self::Shape>>>

Create a new rigid dynamic actor.

fn create_rigid_static<U>( &mut self, transform: PxTransform, geometry: &impl Geometry, material: &mut <Self::Shape as Shape>::Material, shape_transform: PxTransform, user_data: U ) -> Option<Owner<PxRigidStatic<U, Self::Shape>>>

Create a new rigid static actor.

fn create_plane<U>( &mut self, normal: PxVec3, offset: f32, material: &mut <Self::Shape as Shape>::Material, user_data: U ) -> Option<Owner<PxRigidStatic<U, Self::Shape>>>

Create a plane, with plane equation normal.dot(v) + offset = 0.

fn get_bvhs(&self) -> Vec<&Bvh>

Get the BVHs created by this physics object.

fn get_convex_meshes(&self) -> Vec<&ConvexMesh>

Get the convex meshes created by this physics object.

fn get_height_fields(&self) -> Vec<&HeightField>

Get the height fields created by this physics object.

fn get_materials(&self) -> Vec<&<Self::Shape as Shape>::Material>

Get the height fields created by this physics object.

fn get_shapes(&self) -> Vec<&Self::Shape>

Get the shapes created by this physics object.

fn get_triangle_meshes(&self) -> Vec<&TriangleMesh>

Get the triangle mesghes created by this object.

fn get_tolerances_scale(&self) -> Option<&PxTolerancesScale>

Get the tolerance scale.

fn get_physics_insertion_callback(&mut self) -> Option<&mut PxInsertionCallback>

Get the physics insertion callback, used for real-time cooking of physics meshes.