include/PxSoftBody.h
File members: include/PxSoftBody.h
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of NVIDIA CORPORATION nor the names of its
// contributors may be used to endorse or promote products derived
// from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
// OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Copyright (c) 2008-2023 NVIDIA Corporation. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
#ifndef PX_SOFT_BODY_H
#define PX_SOFT_BODY_H
#include "PxFEMParameter.h"
#include "PxActor.h"
#include "PxConeLimitedConstraint.h"
#include "PxSoftBodyFlag.h"
#if !PX_DOXYGEN
namespace physx
{
#endif
#if PX_VC
#pragma warning(push)
#pragma warning(disable : 4435)
#endif
class PxCudaContextManager;
class PxTetrahedronMesh;
class PxSoftBodyAuxData;
class PxFEMCloth;
class PxParticleBuffer;
#define PX_MAX_TETID 0x000fffff
struct PxSoftBodyFlag
{
enum Enum
{
eDISABLE_SELF_COLLISION = 1 << 0,
eCOMPUTE_STRESS_TENSOR = 1 << 1,
eENABLE_CCD = 1 << 2,
eDISPLAY_SIM_MESH = 1 << 3,
eKINEMATIC = 1 << 4,
ePARTIALLY_KINEMATIC = 1 << 5
};
};
typedef PxFlags<PxSoftBodyFlag::Enum, PxU32> PxSoftBodyFlags;
class PxSoftBody : public PxActor
{
public:
virtual ~PxSoftBody() {}
virtual void setSoftBodyFlag(PxSoftBodyFlag::Enum flag, bool val) = 0;
virtual void setSoftBodyFlags(PxSoftBodyFlags flags) = 0;
virtual PxSoftBodyFlags getSoftBodyFlag() const = 0;
virtual void setParameter(PxFEMParameters parameters) = 0;
virtual PxFEMParameters getParameter() const = 0;
virtual PxVec4* getPositionInvMassBufferD() = 0;
virtual PxVec4* getRestPositionBufferD() = 0;
virtual PxVec4* getSimPositionInvMassBufferD() = 0;
virtual PxVec4* getSimVelocityBufferD() = 0;
virtual void markDirty(PxSoftBodyDataFlags flags) = 0;
virtual void setKinematicTargetBufferD(const PxVec4* positions, PxSoftBodyFlags flags) = 0;
virtual PxCudaContextManager* getCudaContextManager() const = 0;
virtual void setWakeCounter(PxReal wakeCounterValue) = 0;
virtual PxReal getWakeCounter() const = 0;
virtual bool isSleeping() const = 0;
virtual void setSolverIterationCounts(PxU32 minPositionIters, PxU32 minVelocityIters = 1) = 0;
virtual void getSolverIterationCounts(PxU32& minPositionIters, PxU32& minVelocityIters) const = 0;
virtual PxShape* getShape() = 0;
virtual PxTetrahedronMesh* getCollisionMesh() = 0;
virtual const PxTetrahedronMesh* getCollisionMesh() const = 0;
virtual PxTetrahedronMesh* getSimulationMesh() = 0;
virtual const PxTetrahedronMesh* getSimulationMesh() const = 0;
virtual PxSoftBodyAuxData* getSoftBodyAuxData() = 0;
virtual const PxSoftBodyAuxData* getSoftBodyAuxData() const = 0;
virtual bool attachShape(PxShape& shape) = 0;
virtual bool attachSimulationMesh(PxTetrahedronMesh& simulationMesh, PxSoftBodyAuxData& softBodyAuxData) = 0;
virtual void detachShape() = 0;
virtual void detachSimulationMesh() = 0;
virtual void release() = 0;
virtual void addParticleFilter(PxPBDParticleSystem* particlesystem, const PxParticleBuffer* buffer, PxU32 particleId, PxU32 tetId) = 0;
virtual void removeParticleFilter(PxPBDParticleSystem* particlesystem, const PxParticleBuffer* buffer, PxU32 particleId, PxU32 tetId) = 0;
virtual PxU32 addParticleAttachment(PxPBDParticleSystem* particlesystem, const PxParticleBuffer* buffer, PxU32 particleId, PxU32 tetId, const PxVec4& barycentric) = 0;
virtual void removeParticleAttachment(PxPBDParticleSystem* particlesystem, PxU32 handle) = 0;
virtual void addRigidFilter(PxRigidActor* actor, PxU32 vertId) = 0;
virtual void removeRigidFilter(PxRigidActor* actor, PxU32 vertId) = 0;
virtual PxU32 addRigidAttachment(PxRigidActor* actor, PxU32 vertId, const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint = NULL) = 0;
virtual void removeRigidAttachment(PxRigidActor* actor, PxU32 handle) = 0;
virtual void addTetRigidFilter(PxRigidActor* actor, PxU32 tetIdx) = 0;
virtual void removeTetRigidFilter(PxRigidActor* actor, PxU32 tetIdx) = 0;
virtual PxU32 addTetRigidAttachment(PxRigidActor* actor, PxU32 tetIdx, const PxVec4& barycentric, const PxVec3& actorSpacePose, PxConeLimitedConstraint* constraint = NULL) = 0;
virtual void addSoftBodyFilter(PxSoftBody* otherSoftBody, PxU32 otherTetIdx, PxU32 tetIdx1) = 0;
virtual void removeSoftBodyFilter(PxSoftBody* otherSoftBody, PxU32 otherTetIdx, PxU32 tetIdx1) = 0;
virtual void addSoftBodyFilters(PxSoftBody* otherSoftBody, PxU32* otherTetIndices, PxU32* tetIndices, PxU32 tetIndicesSize) = 0;
virtual void removeSoftBodyFilters(PxSoftBody* otherSoftBody, PxU32* otherTetIndices, PxU32* tetIndices, PxU32 tetIndicesSize) = 0;
virtual PxU32 addSoftBodyAttachment(PxSoftBody* softbody0, PxU32 tetIdx0, const PxVec4& tetBarycentric0, PxU32 tetIdx1, const PxVec4& tetBarycentric1,
PxConeLimitedConstraint* constraint = NULL, PxReal constraintOffset = 0.0f) = 0;
virtual void removeSoftBodyAttachment(PxSoftBody* softbody0, PxU32 handle) = 0;
virtual void addClothFilter(PxFEMCloth* cloth, PxU32 triIdx, PxU32 tetIdx) = 0;
virtual void removeClothFilter(PxFEMCloth* cloth, PxU32 triIdx, PxU32 tetIdx) = 0;
virtual void addVertClothFilter(PxFEMCloth* cloth, PxU32 vertIdx, PxU32 tetIdx) = 0;
virtual void removeVertClothFilter(PxFEMCloth* cloth, PxU32 vertIdx, PxU32 tetIdx) = 0;
virtual PxU32 addClothAttachment(PxFEMCloth* cloth, PxU32 triIdx, const PxVec4& triBarycentric, PxU32 tetIdx, const PxVec4& tetBarycentric,
PxConeLimitedConstraint* constraint = NULL, PxReal constraintOffset = 0.0f) = 0;
virtual void removeClothAttachment(PxFEMCloth* cloth, PxU32 handle) = 0;
virtual PxBounds3 getWorldBounds(float inflation = 1.01f) const = 0;
virtual PxU32 getGpuSoftBodyIndex() = 0;
virtual const char* getConcreteTypeName() const PX_OVERRIDE { return "PxSoftBody"; }
protected:
PX_INLINE PxSoftBody(PxType concreteType, PxBaseFlags baseFlags) : PxActor(concreteType, baseFlags) {}
PX_INLINE PxSoftBody(PxBaseFlags baseFlags) : PxActor(baseFlags) {}
virtual bool isKindOf(const char* name) const PX_OVERRIDE { PX_IS_KIND_OF(name, "PxSoftBody", PxActor); }
};
PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec4 PxConfigureSoftBodyKinematicTarget(const PxVec4& target, bool isActive)
{
PxVec4 result = target;
if (isActive)
result.w = 0.0f;
else
{
//Any non-zero value will mark the target as inactive
if (result.w == 0.0f)
result.w = 1.0f;
}
return result;
}
PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec4 PxConfigureSoftBodyKinematicTarget(const PxVec3& target, bool isActive)
{
return PxConfigureSoftBodyKinematicTarget(PxVec4(target, 0.0f), isActive);
}
#if PX_VC
#pragma warning(pop)
#endif
#if !PX_DOXYGEN
} // namespace physx
#endif
#endif