Represents a FEM softbody including everything to calculate its definition like geometry and material properties. More...

#include <PxSoftBody.h>

Inheritance diagram for physx::PxSoftBody:

[legend]

Collaboration diagram for physx::PxSoftBody:

[legend]

Public Member Functions
virtual void	setSoftBodyFlag (PxSoftBodyFlag::Enum flag, bool val)=0
	Set a single softbody flag.

virtual void	setSoftBodyFlags (PxSoftBodyFlags flags)=0
	Set the softbody flags.

virtual PxSoftBodyFlags	getSoftBodyFlag () const =0
	Get the softbody flags.

virtual void	setParameter (const PxFEMParameters parameters)=0
	Set parameter for FEM internal solve.

virtual PxFEMParameters	getParameter () const =0
	Get parameter for FEM internal solve.

virtual void	readData (PxSoftBodyData::Enum flags, PxBuffer &buffer, bool flush=false)=0
	Issues a read command to the PxSoftBody.

virtual void	readData (PxSoftBodyData::Enum flags, bool flush=false)=0
	Issues a read command to the PxSoftBody.

virtual void	writeData (PxSoftBodyData::Enum flags, PxBuffer &buffer, bool flush=false)=0
	Issues a write command to the PxSoftBody.

virtual void	writeData (PxSoftBodyData::Enum flags, bool flush=false)=0
	Issues a write command to the PxSoftBody.

virtual PxCudaContextManager *	getCudaContextManager () const =0
	Return the cuda context manager.

virtual void	setWakeCounter (PxReal wakeCounterValue)=0
	Sets the wake counter for the soft body.

virtual PxReal	getWakeCounter () const =0
	Returns the wake counter of the soft body.

virtual bool	isSleeping () const =0
	Returns true if this soft body is sleeping.

virtual void	setSolverIterationCounts (PxU32 minPositionIters, PxU32 minVelocityIters=1)=0
	Sets the solver iteration counts for the body.

virtual void	getSolverIterationCounts (PxU32 &minPositionIters, PxU32 &minVelocityIters) const =0
	Retrieves the solver iteration counts.

virtual PxShape *	getShape ()=0
	Retrieves the shape pointer belonging to the actor.

virtual PxTetrahedronMesh *	getCollisionMesh ()=0
	Retrieve the collision mesh pointer.

virtual PxTetrahedronMesh *	getSimulationMesh ()=0
	Retrieves the simulation mesh pointer.

virtual PxSoftBodyAuxData *	getSoftBodyAuxData ()=0
	Retrieves the simulation state pointer.

virtual bool	attachShape (PxShape &shape)=0
	Attaches a shape.

virtual bool	attachSimulationMesh (PxTetrahedronMesh &simulationMesh, PxSoftBodyAuxData &softBodyAuxData)=0
	Attaches a simulation mesh.

virtual void	detachShape ()=0
	Detaches the shape.

virtual void	detachSimulationMesh ()=0
	Detaches the simulation mesh.

virtual void	release ()=0
	Releases the softbody.

virtual void	addParticleFilter (PxPBDParticleSystem particlesystem, const PxParticleBuffer buffer, PxU32 particleId, PxU32 tetId)=0
	Creates a collision filter between a particle and a tetrahedron in the soft body's collision mesh.

virtual void	removeParticleFilter (PxPBDParticleSystem particlesystem, const PxParticleBuffer buffer, PxU32 particleId, PxU32 tetId)=0
	Removes a collision filter between a particle and a tetrahedron in the soft body's collision mesh.

virtual PxU32	addParticleAttachment (PxPBDParticleSystem particlesystem, const PxParticleBuffer buffer, PxU32 particleId, PxU32 tetId, const PxVec4 &barycentric)=0
	Creates an attachment between a particle and a soft body. Be aware that destroying the particle system before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the particle system does not.

virtual void	removeParticleAttachment (PxPBDParticleSystem *particlesystem, PxU32 handle)=0
	Removes an attachment between a particle and a soft body. Be aware that destroying the particle system before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the particle system does not.

virtual void	addRigidFilter (PxRigidActor *actor, PxU32 vertId)=0
	Creates a collision filter between a vertex in a soft body and a rigid body.

virtual void	removeRigidFilter (PxRigidActor *actor, PxU32 vertId)=0
	Removes a collision filter between a vertex in a soft body and a rigid body.

virtual PxU32	addRigidAttachment (PxRigidActor actor, PxU32 vertId, const PxVec3 &actorSpacePose, PxConeLimitedConstraint constraint=NULL)=0
	Creates a rigid attachment between a soft body and a rigid body. Be aware that destroying the rigid body before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the rigid body does not.

virtual void	removeRigidAttachment (PxRigidActor *actor, PxU32 handle)=0
	Releases a rigid attachment between a soft body and a rigid body. Be aware that destroying the rigid body before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the rigid body does not.

virtual void	addTetRigidFilter (PxRigidActor *actor, PxU32 tetIdx)=0
	Creates collision filter between a tetrahedron in a soft body and a rigid body.

virtual void	removeTetRigidFilter (PxRigidActor *actor, PxU32 tetIdx)=0
	Removes collision filter between a tetrahedron in a soft body and a rigid body.

virtual PxU32	addTetRigidAttachment (PxRigidActor actor, PxU32 tetIdx, const PxVec4 &barycentric, const PxVec3 &actorSpacePose, PxConeLimitedConstraint constraint=NULL)=0
	Creates a rigid attachment between a soft body and a rigid body. Be aware that destroying the rigid body before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the rigid body does not.

virtual void	addSoftBodyFilter (PxSoftBody *otherSoftBody, PxU32 otherTetIdx, PxU32 tetIdx1)=0
	Creates collision filter between a tetrahedron in a soft body and a tetrahedron in another soft body.

virtual void	removeSoftBodyFilter (PxSoftBody *otherSoftBody, PxU32 otherTetIdx, PxU32 tetIdx1)=0
	Removes collision filter between a tetrahedron in a soft body and a tetrahedron in other soft body.

virtual void	addSoftBodyFilters (PxSoftBody otherSoftBody, PxU32 otherTetIndices, PxU32 *tetIndices, PxU32 tetIndicesSize)=0
	Creates collision filters between a tetrahedron in a soft body with another soft body.

virtual void	removeSoftBodyFilters (PxSoftBody otherSoftBody, PxU32 otherTetIndices, PxU32 *tetIndices, PxU32 tetIndicesSize)=0
	Removes collision filters between a tetrahedron in a soft body with another soft body.

virtual PxU32	addSoftBodyAttachment (PxSoftBody softbody0, PxU32 tetIdx0, const PxVec4 &tetBarycentric0, PxU32 tetIdx1, const PxVec4 &tetBarycentric1, PxConeLimitedConstraint constraint=NULL)=0
	Creates an attachment between two soft bodies.

virtual void	removeSoftBodyAttachment (PxSoftBody *softbody0, PxU32 handle)=0
	Releases an attachment between a soft body and the other soft body. Be aware that destroying the soft body before destroying the attachment is illegal and may cause a crash.

virtual void	addClothFilter (PxFEMCloth *cloth, PxU32 triIdx, PxU32 tetIdx)=0
	Creates collision filter between a tetrahedron in a soft body and a triangle in a cloth.

virtual void	removeClothFilter (PxFEMCloth *cloth, PxU32 triIdx, PxU32 tetIdx)=0
	Removes collision filter between a tetrahedron in a soft body and a triangle in a cloth.

virtual PxU32	addClothAttachment (PxFEMCloth cloth, PxU32 triIdx, const PxVec4 &triBarycentric, PxU32 tetIdx, const PxVec4 &tetBarycentric, PxConeLimitedConstraint constraint=NULL)=0
	Creates an attachment between a soft body and a cloth. Be aware that destroying the rigid body before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the cloth does not.

virtual void	removeClothAttachment (PxFEMCloth *cloth, PxU32 handle)=0
	Releases an attachment between a cloth and a soft body. Be aware that destroying the cloth before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the cloth does not.

virtual PxBuffer *	getSimPositionInvMassCPU ()=0
	Access to the vertices of the simulation mesh on the host.

virtual PxBuffer *	getKinematicTargetCPU ()=0
	Access to the vertices of the simulation mesh on the host.

virtual PxBuffer *	getSimVelocityInvMassCPU ()=0
	Access to the velocities of the simulation mesh on the host.

virtual PxBuffer *	getPositionInvMassCPU ()=0
	Access to the vertices of the collision mesh on the host.

virtual PxBuffer *	getRestPositionInvMassCPU ()=0
	Access to the rest vertices of the collision mesh on the host.

virtual PxBounds3	getWorldBounds (float inflation=1.01f) const =0
	Retrieves the axis aligned bounding box enclosing the soft body.

virtual PxU32	getGpuSoftBodyIndex ()=0
	Returns the GPU soft body index.

virtual const char *	getConcreteTypeName () const PX_OVERRIDE
	Returns string name of dynamic type.

Public Member Functions inherited from physx::PxActor
virtual PxActorType::Enum	getType () const =0
	Retrieves the type of actor.

virtual PxScene *	getScene () const =0
	Retrieves the scene which this actor belongs to.

virtual void	setName (const char *name)=0
	Sets a name string for the object that can be retrieved with getName().

virtual const char *	getName () const =0
	Retrieves the name string set with setName().

virtual void	setActorFlag (PxActorFlag::Enum flag, bool value)=0
	Raises or clears a particular actor flag.

virtual void	setActorFlags (PxActorFlags inFlags)=0
	Sets the actor flags.

virtual PxActorFlags	getActorFlags () const =0
	Reads the PxActor flags.

virtual void	setDominanceGroup (PxDominanceGroup dominanceGroup)=0
	Assigns dynamic actors a dominance group identifier.

virtual PxDominanceGroup	getDominanceGroup () const =0
	Retrieves the value set with setDominanceGroup().

virtual void	setOwnerClient (PxClientID inClient)=0
	Sets the owner client of an actor.

virtual PxClientID	getOwnerClient () const =0
	Returns the owner client that was specified at creation time.

virtual PxAggregate *	getAggregate () const =0
	Retrieves the aggregate the actor might be a part of.

Public Member Functions inherited from physx::PxBase
template<class T >
T *	is ()

template<class T >
const T *	is () const

PX_FORCE_INLINE PxType	getConcreteType () const
	Returns concrete type of object.

PX_FORCE_INLINE void	setBaseFlag (PxBaseFlag::Enum flag, bool value)
	Set PxBaseFlag

PX_FORCE_INLINE void	setBaseFlags (PxBaseFlags inFlags)
	Set PxBaseFlags

PX_FORCE_INLINE PxBaseFlags	getBaseFlags () const
	Returns PxBaseFlags.

virtual bool	isReleasable () const
	Whether the object is subordinate.

Protected Member Functions
PX_INLINE	PxSoftBody (PxType concreteType, PxBaseFlags baseFlags)

PX_INLINE	PxSoftBody (PxBaseFlags baseFlags)

virtual bool	isKindOf (const char *name) const PX_OVERRIDE
	Returns whether a given type name matches with the type of this instance.

Protected Member Functions inherited from physx::PxActor
PX_INLINE	PxActor (PxType concreteType, PxBaseFlags baseFlags)

PX_INLINE	PxActor (PxBaseFlags baseFlags)

Protected Member Functions inherited from physx::PxBase
PX_INLINE	PxBase (PxType concreteType, PxBaseFlags baseFlags)
	Constructor setting concrete type and base flags.

PX_INLINE	PxBase (PxBaseFlags baseFlags)
	Deserialization constructor setting base flags.

virtual	~PxBase ()
	Destructor.

template<class T >
bool	typeMatch () const

Additional Inherited Members
Public Attributes inherited from physx::PxActor
void *	userData
	user can assign this to whatever, usually to create a 1:1 relationship with a user object.

Protected Attributes inherited from physx::PxBase
PxType	mConcreteType

PxBaseFlags	mBaseFlags

PxU32	mBuiltInRefCount

Detailed Description

Represents a FEM softbody including everything to calculate its definition like geometry and material properties.

Member Function Documentation

◆ addClothAttachment()

virtual PxU32 physx::PxSoftBody::addClothAttachment	(	PxFEMCloth *	cloth,
		PxU32	triIdx,
		const PxVec4 &	triBarycentric,
		PxU32	tetIdx,
		const PxVec4 &	tetBarycentric,
		PxConeLimitedConstraint *	constraint = `NULL`
	)

pure virtual

Creates an attachment between a soft body and a cloth. Be aware that destroying the rigid body before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the cloth does not.

This method attaches a point inside a tetrahedron of the collision mesh to a cloth.

Warning: Feature under development, only for internal usage.

Parameters

[in]	cloth	The cloth actor used for the attachment
[in]	triIdx	The index of a triangle in the cloth mesh that contains the point to be attached to the soft body
[in]	triBarycentric	The barycentric coordinates of the attachment point inside the triangle specified by triangleIdx
[in]	tetIdx	The index of a tetrahedron in the softbody's collision mesh that contains the point to be attached to the cloth
[in]	tetBarycentric	The barycentric coordinates of the attachment point inside the tetrahedron specified by tetIdx
[in]	constraint	The user defined cone distance limit constraint to limit the movement between a triangle in the fem cloth and a tet in the soft body.

Returns: Returns a handle that identifies the attachment created. This handle can be used to release the attachment later

Implemented in physx::NpSoftBody.

◆ addClothFilter()

virtual void physx::PxSoftBody::addClothFilter	(	PxFEMCloth *	cloth,
		PxU32	triIdx,
		PxU32	tetIdx
	)

pure virtual

Creates collision filter between a tetrahedron in a soft body and a triangle in a cloth.

Warning: Feature under development, only for internal usage.

Parameters

[in]	cloth	The cloth actor used for collision filter
[in]	triIdx	The index of the triangle in the cloth mesh to be filtered.
[in]	tetIdx	The index of the tetrahedron in the softbody's collision mesh to be filtered.

Implemented in physx::NpSoftBody.

◆ addParticleAttachment()

virtual PxU32 physx::PxSoftBody::addParticleAttachment	(	PxPBDParticleSystem *	particlesystem,
		const PxParticleBuffer *	buffer,
		PxU32	particleId,
		PxU32	tetId,
		const PxVec4 &	barycentric
	)

pure virtual

Creates an attachment between a particle and a soft body. Be aware that destroying the particle system before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the particle system does not.

Parameters

[in]	particlesystem	The particle system used for the attachment
[in]	buffer	The PxParticleBuffer to which the particle belongs to.
[in]	particleId	The particle that is attached to a tetrahedron in the soft body's collision mesh.
[in]	tetId	The tetrahedron in the soft body's collision mesh to attach the particle to.
[in]	barycentric	The barycentric coordinates of the particle attachment position with respect to the tetrahedron specified with tetId.

Returns: Returns a handle that identifies the attachment created. This handle can be used to release the attachment later

Implemented in physx::NpSoftBody.

◆ addParticleFilter()

virtual void physx::PxSoftBody::addParticleFilter	(	PxPBDParticleSystem *	particlesystem,
		const PxParticleBuffer *	buffer,
		PxU32	particleId,
		PxU32	tetId
	)

pure virtual

Creates a collision filter between a particle and a tetrahedron in the soft body's collision mesh.

Parameters

[in]	particlesystem	The particle system used for the collision filter
[in]	buffer	The PxParticleBuffer to which the particle belongs to.
[in]	particleId	The particle whose collisions with the tetrahedron in the soft body are filtered.
[in]	tetId	The tetradedron in the soft body that is filtered. If tetId is PX_MAX_TETID, this particle will filter against all tetrahedra in this soft body

Implemented in physx::NpSoftBody.

◆ addRigidAttachment()

virtual PxU32 physx::PxSoftBody::addRigidAttachment	(	PxRigidActor *	actor,
		PxU32	vertId,
		const PxVec3 &	actorSpacePose,
		PxConeLimitedConstraint *	constraint = `NULL`
	)

pure virtual

Creates a rigid attachment between a soft body and a rigid body. Be aware that destroying the rigid body before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the rigid body does not.

This method attaches a vertex on the soft body collision mesh to the rigid body.

Parameters

[in]	actor	The rigid body actor used for the attachment
[in]	vertId	The index of a vertex in the softbody's collision mesh that gets attached to the rigid body.
[in]	actorSpacePose	The location of the attachment point expressed in the rigid body's coordinate system.
[in]	constraint	The user defined cone distance limit constraint to limit the movement between a vertex in the soft body and rigid body.

Returns: Returns a handle that identifies the attachment created. This handle can be used to relese the attachment later

Implemented in physx::NpSoftBody.

◆ addRigidFilter()

virtual void physx::PxSoftBody::addRigidFilter	(	PxRigidActor *	actor,
		PxU32	vertId
	)

pure virtual

Creates a collision filter between a vertex in a soft body and a rigid body.

Parameters

[in]	actor	The rigid body actor used for the collision filter
[in]	vertId	The index of a vertex in the softbody's collision mesh whose collisions with the rigid body are filtered.

Implemented in physx::NpSoftBody.

◆ addSoftBodyAttachment()

virtual PxU32 physx::PxSoftBody::addSoftBodyAttachment	(	PxSoftBody *	softbody0,
		PxU32	tetIdx0,
		const PxVec4 &	tetBarycentric0,
		PxU32	tetIdx1,
		const PxVec4 &	tetBarycentric1,
		PxConeLimitedConstraint *	constraint = `NULL`
	)

pure virtual

Creates an attachment between two soft bodies.

This method attaches a point inside a tetrahedron of the collision mesh to a point in another soft body's tetrahedron collision mesh.

Parameters

[in]	softbody0	The soft body actor used for the attachment
[in]	tetIdx0	The index of a tetrahedron in the other soft body that contains the point to be attached to the soft body
[in]	tetBarycentric0	The barycentric coordinates of the attachment point inside the tetrahedron specified by tetIdx0
[in]	tetIdx1	The index of a tetrahedron in the softbody's collision mesh that contains the point to be attached to the softbody0
[in]	tetBarycentric1	The barycentric coordinates of the attachment point inside the tetrahedron specified by tetIdx1
[in]	constraint	The user defined cone distance limit constraint to limit the movement between tets.

Returns: Returns a handle that identifies the attachment created. This handle can be used to release the attachment later

Implemented in physx::NpSoftBody.

◆ addSoftBodyFilter()

virtual void physx::PxSoftBody::addSoftBodyFilter	(	PxSoftBody *	otherSoftBody,
		PxU32	otherTetIdx,
		PxU32	tetIdx1
	)

pure virtual

Creates collision filter between a tetrahedron in a soft body and a tetrahedron in another soft body.

Parameters

[in]	otherSoftBody	The other soft body actor used for collision filter
[in]	otherTetIdx	The index of the tetrahedron in the other softbody's collision mesh to be filtered.
[in]	tetIdx1	The index of the tetrahedron in the softbody's collision mesh to be filtered.

Implemented in physx::NpSoftBody.

◆ addSoftBodyFilters()

virtual void physx::PxSoftBody::addSoftBodyFilters	(	PxSoftBody *	otherSoftBody,
		PxU32 *	otherTetIndices,
		PxU32 *	tetIndices,
		PxU32	tetIndicesSize
	)

pure virtual

Creates collision filters between a tetrahedron in a soft body with another soft body.

Parameters

[in]	otherSoftBody	The other soft body actor used for collision filter
[in]	otherTetIndices	The indices of the tetrahedron in the other softbody's collision mesh to be filtered.
[in]	tetIndices	The indices of the tetrahedron of the softbody's collision mesh to be filtered.
[in]	tetIndicesSize	The size of tetIndices.

Implemented in physx::NpSoftBody.

◆ addTetRigidAttachment()

virtual PxU32 physx::PxSoftBody::addTetRigidAttachment	(	PxRigidActor *	actor,
		PxU32	tetIdx,
		const PxVec4 &	barycentric,
		const PxVec3 &	actorSpacePose,
		PxConeLimitedConstraint *	constraint = `NULL`
	)

pure virtual

Creates a rigid attachment between a soft body and a rigid body. Be aware that destroying the rigid body before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the rigid body does not.

This method attaches a point inside a tetrahedron of the collision to the rigid body.

Parameters

[in]	actor	The rigid body actor used for the attachment
[in]	tetIdx	The index of a tetrahedron in the softbody's collision mesh that contains the point to be attached to the rigid body
[in]	barycentric	The barycentric coordinates of the attachment point inside the tetrahedron specified by tetIdx
[in]	actorSpacePose	The location of the attachment point expressed in the rigid body's coordinate system.
[in]	constraint	The user defined cone distance limit constraint to limit the movement between a tet and rigid body.

Returns: Returns a handle that identifies the attachment created. This handle can be used to release the attachment later

Implemented in physx::NpSoftBody.

◆ addTetRigidFilter()

virtual void physx::PxSoftBody::addTetRigidFilter	(	PxRigidActor *	actor,
		PxU32	tetIdx
	)

pure virtual

Creates collision filter between a tetrahedron in a soft body and a rigid body.

Parameters

[in]	actor	The rigid body actor used for collision filter
[in]	tetIdx	The index of a tetrahedron in the softbody's collision mesh whose collisions with the rigid body is filtered.

Implemented in physx::NpSoftBody.

◆ attachShape()

virtual bool physx::PxSoftBody::attachShape ( PxShape & shape )

pure virtual

Attaches a shape.

Attaches the shape to use for collision detection

Parameters

[in] shape The shape to use for collisions

Returns: Returns true if the operation was successful

Implemented in physx::NpSoftBody.

◆ attachSimulationMesh()

virtual bool physx::PxSoftBody::attachSimulationMesh	(	PxTetrahedronMesh &	simulationMesh,
		PxSoftBodyAuxData &	softBodyAuxData
	)

pure virtual

Attaches a simulation mesh.

Attaches the simulation mesh (geometry) and a state containing inverse mass, rest pose etc. required to compute the softbody deformation.

Parameters

[in]	simulationMesh	The tetrahedral mesh used to compute the softbody's deformation
[in]	softBodyAuxData	A state that contain a mapping from simulation to collision mesh, volume information etc.

Returns: Returns true if the operation was successful

Implemented in physx::NpSoftBody.

◆ detachShape()

virtual void physx::PxSoftBody::detachShape ( )

pure virtual

Detaches the shape.

Detaches the shape used for collision detection.

See also: void detachSimulationMesh()

Implemented in physx::NpSoftBody.

◆ detachSimulationMesh()

virtual void physx::PxSoftBody::detachSimulationMesh ( )

pure virtual

Detaches the simulation mesh.

Detaches the simulation mesh and simulation state used to compute the softbody deformation.

See also: void detachShape()

Implemented in physx::NpSoftBody.

◆ getCollisionMesh()

virtual PxTetrahedronMesh * physx::PxSoftBody::getCollisionMesh ( )

pure virtual

Retrieve the collision mesh pointer.

Allows to access the geometry of the tetrahedral mesh used to perform collision detection

Returns: Pointer to the collision mesh

Implemented in physx::NpSoftBody.

◆ getConcreteTypeName()

virtual const char * physx::PxSoftBody::getConcreteTypeName ( ) const

inlinevirtual

Returns string name of dynamic type.

Returns: Class name of most derived type of this object.

Implements physx::PxBase.

◆ getCudaContextManager()

virtual PxCudaContextManager * physx::PxSoftBody::getCudaContextManager ( ) const

pure virtual

Return the cuda context manager.

Returns: The cuda context manager

Implemented in physx::NpSoftBody.

◆ getGpuSoftBodyIndex()

virtual PxU32 physx::PxSoftBody::getGpuSoftBodyIndex ( )

pure virtual

Returns the GPU soft body index.

Returns: The GPU index, or 0xFFFFFFFF if the soft body is not in a scene.

Implemented in physx::NpSoftBody.

◆ getKinematicTargetCPU()

virtual PxBuffer * physx::PxSoftBody::getKinematicTargetCPU ( )

pure virtual

Access to the vertices of the simulation mesh on the host.

Each element uses 4 float values containing position and inverseMass per vertex [x, y, z, inverseMass] The inverse mass must match the inverse mass in the simVelocityCPU buffer at the same index. A copy of this value is stored in the simVelocityCPU buffer to allow for faster access on the GPU. If the inverse masses in those two buffers don't match, the simulation may produce wrong results

Allows to access the CPU buffer of the simulation mesh's vertices

Returns: The buffer that contains the simulation mesh's vertex positions (x, y, z) and the inverse mass as 4th component

Implemented in physx::NpSoftBody.

◆ getParameter()

virtual PxFEMParameters physx::PxSoftBody::getParameter ( ) const

pure virtual

Get parameter for FEM internal solve.

Returns: The FEM parameters

Implemented in physx::NpSoftBody.

◆ getPositionInvMassCPU()

virtual PxBuffer * physx::PxSoftBody::getPositionInvMassCPU ( )

pure virtual

Access to the vertices of the collision mesh on the host.

Each element uses 4 float values containing position and inverseMass per vertex [x, y, z, inverseMass] The inverse mass on the collision mesh has no effect, it can be set to an arbitrary value.

Allows to access the CPU buffer of the collision mesh's vertices

Returns: The buffer that contains the collision mesh's vertex positions (x, y, z) and the inverse mass as 4th component

Implemented in physx::NpSoftBody.

◆ getRestPositionInvMassCPU()

virtual PxBuffer * physx::PxSoftBody::getRestPositionInvMassCPU ( )

pure virtual

Access to the rest vertices of the collision mesh on the host.

Each element uses 4 float values containing position and inverseMass per vertex [x, y, z, inverseMass] The inverse mass on the collision mesh has no effect, it can be set to an arbitrary value.

Allows to access the CPU buffer of the collision mesh's rest vertices

Returns: The buffer that contains the collision mesh's rest vertex positions (x, y, z) and the inverse mass as 4th component

Implemented in physx::NpSoftBody.

◆ getShape()

virtual PxShape * physx::PxSoftBody::getShape ( )

pure virtual

Retrieves the shape pointer belonging to the actor.

Returns: Pointer to the collision mesh's shape

See also: PxShape getNbShapes() PxShape::release()

Implemented in physx::NpSoftBody.

◆ getSimPositionInvMassCPU()

virtual PxBuffer * physx::PxSoftBody::getSimPositionInvMassCPU ( )

pure virtual

Access to the vertices of the simulation mesh on the host.

Each element uses 4 float values containing position and inverseMass per vertex [x, y, z, inverseMass] The inverse mass must match the inverse mass in the simVelocityCPU buffer at the same index. A copy of this value is stored in the simVelocityCPU buffer to allow for faster access on the GPU. If the inverse masses in those two buffers don't match, the simulation may produce wrong results

Allows to access the CPU buffer of the simulation mesh's vertices

Returns: The buffer that contains the simulation mesh's vertex positions (x, y, z) and the inverse mass as 4th component

Implemented in physx::NpSoftBody.

◆ getSimulationMesh()

virtual PxTetrahedronMesh * physx::PxSoftBody::getSimulationMesh ( )

pure virtual

Retrieves the simulation mesh pointer.

Allows to access the geometry of the tetrahedral mesh used to compute the object's deformation

Returns: Pointer to the simulation mesh

Implemented in physx::NpSoftBody.

◆ getSimVelocityInvMassCPU()

virtual PxBuffer * physx::PxSoftBody::getSimVelocityInvMassCPU ( )

pure virtual

Access to the velocities of the simulation mesh on the host.

Each element uses 4 float values containing velocity and inverseMass per vertex [x, y, z, inverseMass] The inverse mass must match the inverse mass in the simPositionInvMassCPU buffer at the same index. A copy of this value is stored in the simPositionInvMassCPU buffer to allow for faster access on the GPU. If the inverse masses in those two buffers don't match, the simulation may produce wrong results

Allows to access the CPU buffer of the simulation mesh's vertices

Returns: The buffer that contains the simulation mesh's velocities (x, y, z) and the inverse mass as 4th component

Implemented in physx::NpSoftBody.

◆ getSoftBodyAuxData()

virtual PxSoftBodyAuxData * physx::PxSoftBody::getSoftBodyAuxData ( )

pure virtual

Retrieves the simulation state pointer.

Allows to access the additional data of the simulation mesh (inverse mass, rest state etc.). The geometry part of the data is stored in the simulation mesh.

Returns: Pointer to the simulation state

Implemented in physx::NpSoftBody.

◆ getSoftBodyFlag()

virtual PxSoftBodyFlags physx::PxSoftBody::getSoftBodyFlag ( ) const

pure virtual

Get the softbody flags.

Returns: The softbody flags

Implemented in physx::NpSoftBody.

◆ getSolverIterationCounts()

virtual void physx::PxSoftBody::getSolverIterationCounts	(	PxU32 &	minPositionIters,
		PxU32 &	minVelocityIters
	)		const

pure virtual

Retrieves the solver iteration counts.

See also: setSolverIterationCounts()

Implemented in physx::NpSoftBody.

◆ getWakeCounter()

virtual PxReal physx::PxSoftBody::getWakeCounter ( ) const

pure virtual

Returns the wake counter of the soft body.

Returns: The wake counter of the soft body.

See also: isSleeping() setWakeCounter()

Implemented in physx::NpSoftBody.

◆ getWorldBounds()

virtual PxBounds3 physx::PxSoftBody::getWorldBounds ( float inflation = 1.01f ) const

pure virtual

Retrieves the axis aligned bounding box enclosing the soft body.

Note: It is not allowed to use this method while the simulation is running (except during PxScene::collide(), in PxContactModifyCallback or in contact report callbacks).

Parameters

[in] inflation Scale factor for computed world bounds. Box extents are multiplied by this value.

Returns: The soft body's bounding box.

See also: PxBounds3

Implements physx::PxActor.

Implemented in physx::NpSoftBody.

◆ isKindOf()

virtual bool physx::PxSoftBody::isKindOf ( const char * superClass ) const

inlineprotectedvirtual

Returns whether a given type name matches with the type of this instance.

Reimplemented from physx::PxActor.

◆ isSleeping()

virtual bool physx::PxSoftBody::isSleeping ( ) const

pure virtual

Returns true if this soft body is sleeping.

When an actor does not move for a period of time, it is no longer simulated in order to save time. This state is called sleeping. However, because the object automatically wakes up when it is either touched by an awake object, or a sleep-affecting property is changed by the user, the entire sleep mechanism should be transparent to the user.

A soft body can only go to sleep if all vertices are ready for sleeping. A soft body is guaranteed to be awake if at least one of the following holds:

The wake counter is positive (
See also
setWakeCounter()).
The velocity of any vertex is above the sleep threshold.

If a soft body is sleeping, the following state is guaranteed:

The wake counter is zero.
The linear velocity of all vertices is zero.

When a soft body gets inserted into a scene, it will be considered asleep if all the points above hold, else it will be treated as awake.

Note: It is invalid to use this method if the soft body has not been added to a scene already.

Returns: True if the soft body is sleeping.

See also: isSleeping()

Implemented in physx::NpSoftBody.

◆ readData() [1/2]

virtual void physx::PxSoftBody::readData	(	PxSoftBodyData::Enum	flags,
		bool	flush = `false`
	)

pure virtual

Issues a read command to the PxSoftBody.

Read operations are scheduled and then flushed in PxScene::simulate(). Read operations are known to be finished when PxBuffer::map() returns.

PxSoftBodyData::ePOSITION_INVMASS, PxSoftBodyData::eSIM_POSITION_INVMASS and PxSoftBodyData::eSIM_VELOCITY can be read from the PxSoftBody.

The data to read from the GPU is written to the corresponding cpu buffer that a softbody provides. Those cpu buffers are accessible through getPositionInvMassCPU(), getSimPositionInvMassCPU() or getSimVelocityInvMassCPU().

Parameters

[in]	flags	Specifies which PxSoftBody data to read from.
[in]	flush	If set to true the command gets executed immediately, otherwise it will get executed the next time copy commands are flushed.

See also: writeData(), PxSoftBodyData

Implemented in physx::NpSoftBody.

◆ readData() [2/2]

virtual void physx::PxSoftBody::readData	(	PxSoftBodyData::Enum	flags,
		PxBuffer &	buffer,
		bool	flush = `false`
	)

pure virtual

Issues a read command to the PxSoftBody.

Read operations are scheduled and then flushed in PxScene::simulate(). Read operations are known to be finished when PxBuffer::map() returns.

PxSoftBodyData::ePOSITION_INVMASS, PxSoftBodyData::eSIM_POSITION_INVMASS and PxSoftBodyData::eSIM_VELOCITY can be read from the PxSoftBody.

The softbody class offers internal cpu buffers that can be used to hold the data. The cpu buffers are accessible through getPositionInvMassCPU(), getSimPositionInvMassCPU() and getSimVelocityInvMassCPU().

Parameters

[in]	flags	Specifies which PxSoftBody data to read from.
[in]	buffer	Specifies buffer to which data is written to.
[in]	flush	If set to true the command gets executed immediately, otherwise it will get executed the next time copy commands are flushed.

See also: writeData(), PxBuffer, PxSoftBodyData

Implemented in physx::NpSoftBody.

◆ release()

virtual void physx::PxSoftBody::release ( )

pure virtual

Releases the softbody.

Releases the softbody and frees its resources.

Implements physx::PxActor.

Implemented in physx::NpSoftBody.

◆ removeClothAttachment()

virtual void physx::PxSoftBody::removeClothAttachment	(	PxFEMCloth *	cloth,
		PxU32	handle
	)

pure virtual

Releases an attachment between a cloth and a soft body. Be aware that destroying the cloth before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the cloth does not.

This method removes a previously-created attachment between a point inside a collision mesh tetrahedron and a point inside a cloth mesh.

Warning: Feature under development, only for internal usage.

Parameters

[in]	cloth	The cloth actor used for the attachment
[in]	handle	Index that identifies the attachment. This handle gets returned by the addClothAttachment when the attachment is created

Implemented in physx::NpSoftBody.

◆ removeClothFilter()

virtual void physx::PxSoftBody::removeClothFilter	(	PxFEMCloth *	cloth,
		PxU32	triIdx,
		PxU32	tetIdx
	)

pure virtual

Removes collision filter between a tetrahedron in a soft body and a triangle in a cloth.

Warning: Feature under development, only for internal usage.

Parameters

[in]	cloth	The cloth actor used for collision filter
[in]	triIdx	The index of the triangle in the cloth mesh to be filtered.
[in]	tetIdx	The index of the tetrahedron in the softbody's collision mesh to be filtered.

Implemented in physx::NpSoftBody.

◆ removeParticleAttachment()

virtual void physx::PxSoftBody::removeParticleAttachment	(	PxPBDParticleSystem *	particlesystem,
		PxU32	handle
	)

pure virtual

Removes an attachment between a particle and a soft body. Be aware that destroying the particle system before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the particle system does not.

Parameters

[in]	particlesystem	The particle system used for the attachment
[in]	handle	Index that identifies the attachment. This handle gets returned by the addParticleAttachment when the attachment is created

Implemented in physx::NpSoftBody.

◆ removeParticleFilter()

virtual void physx::PxSoftBody::removeParticleFilter	(	PxPBDParticleSystem *	particlesystem,
		const PxParticleBuffer *	buffer,
		PxU32	particleId,
		PxU32	tetId
	)

pure virtual

Removes a collision filter between a particle and a tetrahedron in the soft body's collision mesh.

Parameters

[in]	particlesystem	The particle system used for the collision filter
[in]	buffer	The PxParticleBuffer to which the particle belongs to.
[in]	particleId	The particle whose collisions with the tetrahedron in the soft body are filtered.
[in]	tetId	The tetrahedron in the soft body is filtered.

Implemented in physx::NpSoftBody.

◆ removeRigidAttachment()

virtual void physx::PxSoftBody::removeRigidAttachment	(	PxRigidActor *	actor,
		PxU32	handle
	)

pure virtual

Releases a rigid attachment between a soft body and a rigid body. Be aware that destroying the rigid body before destroying the attachment is illegal and may cause a crash. The soft body keeps track of these attachments but the rigid body does not.

This method removes a previously-created attachment between a vertex of the soft body collision mesh and the rigid body.

Parameters

[in]	actor	The rigid body actor used for the attachment
[in]	handle	Index that identifies the attachment. This handle gets returned by the addRigidAttachment when the attachment is created

Implemented in physx::NpSoftBody.

◆ removeRigidFilter()

virtual void physx::PxSoftBody::removeRigidFilter	(	PxRigidActor *	actor,
		PxU32	vertId
	)

pure virtual

Removes a collision filter between a vertex in a soft body and a rigid body.

Parameters

[in]	actor	The rigid body actor used for the collision filter
[in]	vertId	The index of a vertex in the softbody's collision mesh whose collisions with the rigid body are filtered.

Implemented in physx::NpSoftBody.

◆ removeSoftBodyAttachment()

virtual void physx::PxSoftBody::removeSoftBodyAttachment	(	PxSoftBody *	softbody0,
		PxU32	handle
	)

pure virtual

Releases an attachment between a soft body and the other soft body. Be aware that destroying the soft body before destroying the attachment is illegal and may cause a crash.

This method removes a previously-created attachment between a point inside a tetrahedron of the collision mesh to a point in another soft body's tetrahedron collision mesh.

Parameters

[in]	softbody0	The softbody actor used for the attachment.
[in]	handle	Index that identifies the attachment. This handle gets returned by the addSoftBodyAttachment when the attachment is created.

Implemented in physx::NpSoftBody.

◆ removeSoftBodyFilter()

virtual void physx::PxSoftBody::removeSoftBodyFilter	(	PxSoftBody *	otherSoftBody,
		PxU32	otherTetIdx,
		PxU32	tetIdx1
	)

pure virtual

Removes collision filter between a tetrahedron in a soft body and a tetrahedron in other soft body.

Parameters

[in]	otherSoftBody	The other soft body actor used for collision filter
[in]	otherTetIdx	The index of the other tetrahedron in the other softbody's collision mesh whose collision with the tetrahedron with the soft body is filtered.
[in]	tetIdx1	The index of the tetrahedron in the softbody's collision mesh whose collision with the other tetrahedron with the other soft body is filtered.

Implemented in physx::NpSoftBody.

◆ removeSoftBodyFilters()

virtual void physx::PxSoftBody::removeSoftBodyFilters	(	PxSoftBody *	otherSoftBody,
		PxU32 *	otherTetIndices,
		PxU32 *	tetIndices,
		PxU32	tetIndicesSize
	)

pure virtual

Removes collision filters between a tetrahedron in a soft body with another soft body.

Parameters

[in]	otherSoftBody	The other soft body actor used for collision filter
[in]	otherTetIndices	The indices of the tetrahedron in the other softbody's collision mesh to be filtered.
[in]	tetIndices	The indices of the tetrahedron of the softbody's collision mesh to be filtered.
[in]	tetIndicesSize	The size of tetIndices.

Implemented in physx::NpSoftBody.

◆ removeTetRigidFilter()

virtual void physx::PxSoftBody::removeTetRigidFilter	(	PxRigidActor *	actor,
		PxU32	tetIdx
	)

pure virtual

Removes collision filter between a tetrahedron in a soft body and a rigid body.

Parameters

[in]	actor	The rigid body actor used for collision filter
[in]	tetIdx	The index of a tetrahedron in the softbody's collision mesh whose collisions with the rigid body is filtered.

Implemented in physx::NpSoftBody.

◆ setParameter()

virtual void physx::PxSoftBody::setParameter ( const PxFEMParameters parameters )

pure virtual

Set parameter for FEM internal solve.

Parameters

[in] parameters The FEM parameters

Implemented in physx::NpSoftBody.

◆ setSoftBodyFlag()

virtual void physx::PxSoftBody::setSoftBodyFlag	(	PxSoftBodyFlag::Enum	flag,
		bool	val
	)

pure virtual

Set a single softbody flag.

Parameters

[in]	flag	The flag to set or clear
[in]	val	The new state of the flag

Implemented in physx::NpSoftBody.

◆ setSoftBodyFlags()

virtual void physx::PxSoftBody::setSoftBodyFlags ( PxSoftBodyFlags flags )

pure virtual

Set the softbody flags.

Parameters

[in] flags The new softbody flags

Implemented in physx::NpSoftBody.

◆ setSolverIterationCounts()

virtual void physx::PxSoftBody::setSolverIterationCounts	(	PxU32	minPositionIters,
		PxU32	minVelocityIters = `1`
	)

pure virtual

Sets the solver iteration counts for the body.

The solver iteration count determines how accurately deformation and contacts are resolved. If you are having trouble with softbodies that are not as stiff as they should be, then setting a higher position iteration count may improve the behavior.

If intersecting bodies are being depenetrated too violently, increase the number of velocity iterations.

Default: 4 position iterations, 1 velocity iteration

Parameters

[in]	minPositionIters	Minimal number of position iterations the solver should perform for this body. Range: [1,255]
[in]	minVelocityIters	Minimal number of velocity iterations the solver should perform for this body. Range: [1,255]

See also: getSolverIterationCounts()

Implemented in physx::NpSoftBody.

◆ setWakeCounter()

virtual void physx::PxSoftBody::setWakeCounter ( PxReal wakeCounterValue )

pure virtual

Sets the wake counter for the soft body.

The wake counter value determines the minimum amount of time until the soft body can be put to sleep. Please note that a soft body will not be put to sleep if any vertex velocity is above the specified threshold or if other awake objects are touching it.

Note: Passing in a positive value will wake the soft body up automatically.

Default: 0.4 (which corresponds to 20 frames for a time step of 0.02)

Parameters

[in] wakeCounterValue Wake counter value. Range: [0, PX_MAX_F32)

See also: isSleeping() getWakeCounter()

Implemented in physx::NpSoftBody.

◆ writeData() [1/2]

virtual void physx::PxSoftBody::writeData	(	PxSoftBodyData::Enum	flags,
		bool	flush = `false`
	)

pure virtual

Issues a write command to the PxSoftBody.

Write operations are scheduled and then flushed in PxScene::simulate(). Write operations are known to be finished when PxScene::fetchResult() returns.

PxSoftBodyData::eSIM_POSITION_INVMASS and PxSoftBodyData::eSIM_VELOCITY can be written to the PxSoftBody. PxSoftBodyData::ePOSITION_INVMASS is read only, because the collision-mesh vertices are driven by the simulation-mesh vertices, which can be written to with PxSoftBodyData::eSIM_POSITION_INVMASS.

The data to write to the GPU is taken from the corresponding cpu buffer that a softbody provides. Those cpu buffers are accessible through getPositionInvMassCPU(), getSimPositionInvMassCPU() or getSimVelocityInvMassCPU().

Parameters

[in]	flags	Specifies which PxSoftBody data to write to.
[in]	flush	If set to true the command gets executed immediately, otherwise it will get executed the next time copy commands are flushed.

See also: readData(), PxSoftBodyData

Implemented in physx::NpSoftBody.

◆ writeData() [2/2]

virtual void physx::PxSoftBody::writeData	(	PxSoftBodyData::Enum	flags,
		PxBuffer &	buffer,
		bool	flush = `false`
	)

pure virtual

Issues a write command to the PxSoftBody.

Write operations are scheduled and then flushed in PxScene::simulate(). Write operations are known to be finished when PxScene::fetchResult() returns.

PxSoftBodyData::eSIM_POSITION_INVMASS and PxSoftBodyData::eSIM_VELOCITY can be written to the PxSoftBody. PxSoftBodyData::ePOSITION_INVMASS is read only, because the collision-mesh vertices are driven by the simulation-mesh vertices, which can be written to with PxSoftBodyData::eSIM_POSITION_INVMASS.

The softbody class offers internal cpu buffers that can be used to hold the data. The cpu buffers are accessible through getPositionInvMassCPU(), getSimPositionInvMassCPU() and getSimVelocityInvMassCPU(). Consider to use the PxSoftBodyExt::commit() extension method if all buffers should get written.

Parameters

[in]	flags	Specifies which PxSoftBody data to write to.
[in]	buffer	Specifies buffer from which data is read.
[in]	flush	If set to true the command gets executed immediately, otherwise it will get executed the next time copy commands are flushed.

See also: readData(), PxBuffer, PxSoftBodyData, PxSoftBodyExt::commit

Implemented in physx::NpSoftBody.

The documentation for this class was generated from the following file:

RavEngine/deps/physx/physx/include/PxSoftBody.h

Public Member Functions

Protected Member Functions

Additional Inherited Members

Detailed Description

Member Function Documentation

◆ addClothAttachment()

◆ addClothFilter()

◆ addParticleAttachment()

◆ addParticleFilter()

◆ addRigidAttachment()

◆ addRigidFilter()

◆ addSoftBodyAttachment()

◆ addSoftBodyFilter()

◆ addSoftBodyFilters()

◆ addTetRigidAttachment()

◆ addTetRigidFilter()

◆ attachShape()

◆ attachSimulationMesh()

◆ detachShape()

◆ detachSimulationMesh()

◆ getCollisionMesh()

◆ getConcreteTypeName()

◆ getCudaContextManager()

◆ getGpuSoftBodyIndex()

◆ getKinematicTargetCPU()

◆ getParameter()

◆ getPositionInvMassCPU()

◆ getRestPositionInvMassCPU()

◆ getShape()

◆ getSimPositionInvMassCPU()

◆ getSimulationMesh()

◆ getSimVelocityInvMassCPU()

◆ getSoftBodyAuxData()

◆ getSoftBodyFlag()

◆ getSolverIterationCounts()

◆ getWakeCounter()

◆ getWorldBounds()

◆ isKindOf()

◆ isSleeping()

◆ readData() [1/2]

◆ readData() [2/2]

◆ release()

◆ removeClothAttachment()

◆ removeClothFilter()

◆ removeParticleAttachment()

◆ removeParticleFilter()

◆ removeRigidAttachment()

◆ removeRigidFilter()

◆ removeSoftBodyAttachment()

◆ removeSoftBodyFilter()

◆ removeSoftBodyFilters()

◆ removeTetRigidFilter()

◆ setParameter()

◆ setSoftBodyFlag()

◆ setSoftBodyFlags()

◆ setSolverIterationCounts()

◆ setWakeCounter()

◆ writeData() [1/2]

◆ writeData() [2/2]