Revision control
- //
// 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-2021 NVIDIA Corporation. All rights reserved.
+ // Copyright (c) 2008-2026 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 PXS_SIMULATION_CONTROLLER_H
#define PXS_SIMULATION_CONTROLLER_H
+ #include "PxDirectGPUAPI.h"
#include "foundation/PxSimpleTypes.h"
#include "foundation/PxPreprocessor.h"
#include "foundation/PxTransform.h"
- #include "CmBitMap.h"
- #include "PsArray.h"
-
+ #include "CmPinnableArray.h"
+ #include "CmPinnableBitMap.h"
+ #include "foundation/PxUserAllocated.h"
+ #include "PxScene.h"
+ #include "PxParticleSystem.h"
+ #include "PxArticulationTendonData.h"
+ #include "PxNodeIndex.h"
namespace physx
{
namespace Dy
{
class Context;
struct Constraint;
- class ArticulationV;
class FeatherstoneArticulation;
struct ArticulationJointCore;
- }
-
- namespace Cm
- {
- class EventProfiler;
+ class ParticleSystemCore;
+ class ParticleSystem;
+
+ #if PX_SUPPORT_GPU_PHYSX
+ class DeformableSurface;
+ class DeformableVolume;
+ #endif
}
namespace Bp
{
class BoundsArray;
class BroadPhase;
+ class AABBManagerBase;
}
namespace IG
{
- class SimpleIslandManager;
class IslandSim;
- class NodeIndex;
+ }
+
+ namespace Sc
+ {
+ class BodySim;
+ class ShapeSimBase;
}
class PxsTransformCache;
class PxvNphaseImplementationContext;
class PxBaseTask;
+ class PxsContext;
- struct PxsBodySim;
- struct PxsShapeSim;
class PxsRigidBody;
- class PxsKernelWranglerManager;
- class PxsHeapMemoryAllocatorManager;
- template<typename T> class PxgIterator;
- struct PxgSolverConstraintManagerConstants;
+ struct PxsShapeCore;
+
+ struct PxsExternalAccelerationProvider;
-
- class PxsSimulationControllerCallback
+ class PxsSimulationControllerCallback : public PxUserAllocated
{
public:
- virtual void updateScBodyAndShapeSim(PxBaseTask* continuation) = 0;
+ virtual void updateScBodyAndShapeSim(PxBaseTask* continuation) = 0;
virtual PxU32 getNbCcdBodies() = 0;
virtual ~PxsSimulationControllerCallback() {}
};
+ #if PX_SUPPORT_OMNI_PVD
+ class PxsSimulationControllerOVDCallbacks : public PxUserAllocated
+ {
+ public:
+ virtual void processRigidDynamicSet(const PxsRigidBody* const * rigids, const void* dataVec, const PxRigidDynamicGPUIndex* gpuIndices, PxRigidDynamicGPUAPIWriteType::Enum dataType, PxU32 nbElements) = 0;
+ virtual void processArticulationSet(const Dy::FeatherstoneArticulation* const * simBodyVec, const void* dataVec, const PxArticulationGPUIndex* indexVec, PxArticulationGPUAPIWriteType::Enum dataType, PxU32 nbElements,
+ PxU32 maxLinks, PxU32 maxDofs, PxU32 maxFixedTendons, PxU32 maxTendonJoints, PxU32 maxSpatialTendons, PxU32 maxSpatialTendonAttachments) = 0;
+
+ // Returns the number of elements in a data block as well as the size of the datablock, see PxArticulationGPUAPIWriteType::Enum for where the sizes etc are derived
+ PX_FORCE_INLINE void getArticulationDataElements(PxArticulationGPUAPIWriteType::Enum dataType, PxU32 maxLinks, PxU32 maxDofs, PxU32 maxFixedTendons, PxU32 maxTendonJoints, PxU32 maxSpatialTendons, PxU32 maxSpatialTendonAttachments,
+ PxU32& nbSubElements, PxU32& blockSize) const;
- class PxsSimulationController
+ virtual ~PxsSimulationControllerOVDCallbacks() {}
+ };
+ #endif
+
+ class PxsSimulationController : public PxUserAllocated
{
public:
- PxsSimulationController(PxsSimulationControllerCallback* callback): mCallback(callback){}
- virtual ~PxsSimulationController(){}
-
- virtual void addJoint(const PxU32 edgeIndex, Dy::Constraint* constraint, IG::IslandSim& islandSim, Ps::Array<PxU32>& jointIndices,
- Ps::Array<PxgSolverConstraintManagerConstants, Ps::VirtualAllocator>& managerIter, PxU32 uniqueId) = 0;
- virtual void removeJoint(const PxU32 edgeIndex, Dy::Constraint* constraint, Ps::Array<PxU32>& jointIndices, IG::IslandSim& islandSim) = 0;
- virtual void addShape(PxsShapeSim* shapeSim, const PxU32 index) = 0;
- virtual void removeShape(const PxU32 index) = 0;
- virtual void addDynamic(PxsRigidBody* rigidBody, const IG::NodeIndex& nodeIndex) = 0;
- virtual void addDynamics(PxsRigidBody** rigidBody, const PxU32* nodeIndex, PxU32 nbToProcess) = 0;
- virtual void addArticulation(Dy::ArticulationV* articulation, const IG::NodeIndex& nodeIndex) = 0;
- virtual void releaseArticulation(Dy::ArticulationV* articulation, const IG::NodeIndex& nodeIndex) = 0;
- virtual void releaseDeferredArticulationIds() = 0;
- virtual void updateDynamic(const bool isArticulationLink, const IG::NodeIndex&) = 0;
- virtual void updateJoint(const PxU32 edgeIndex, Dy::Constraint* constraint) = 0;
- virtual void updateBodies(PxsRigidBody** rigidBodies, PxU32* nodeIndices, const PxU32 nbBodies) = 0;
- virtual void updateBodiesAndShapes(PxBaseTask* continuation) = 0;
- virtual void update(const PxU32 bitMapWordCounts) = 0;
- virtual void updateArticulation(Dy::ArticulationV* articulation, const IG::NodeIndex& nodeIndex) = 0;
- virtual void updateArticulationJoint(Dy::ArticulationV* articulation, const IG::NodeIndex& nodeIndex) = 0;
- virtual void gpuDmabackData(PxsTransformCache& cache, Bp::BoundsArray& boundArray, Cm::BitMapPinned& changedAABBMgrHandles) = 0;
- virtual void udpateScBodyAndShapeSim(PxsTransformCache& cache, Bp::BoundsArray& boundArray, PxBaseTask* continuation) = 0;
- virtual PxU32* getActiveBodies() = 0;
- virtual PxU32* getDeactiveBodies() = 0;
- virtual void** getRigidBodies() = 0;
- virtual PxU32 getNbBodies() = 0;
-
- virtual PxU32* getUnfrozenShapes() = 0;
- virtual PxU32* getFrozenShapes() = 0;
- virtual PxsShapeSim** getShapeSims() = 0;
- virtual PxU32 getNbFrozenShapes() = 0;
- virtual PxU32 getNbUnfrozenShapes() = 0;
-
- virtual void clear() = 0;
- virtual void setBounds(Bp::BoundsArray* boundArray) = 0;
- virtual void reserve(const PxU32 nbBodies) = 0;
-
- virtual PxU32 getArticulationRemapIndex(const PxU32 nodeIndex) = 0;
+ PxsSimulationController(PxsSimulationControllerCallback* callback, PxIntBool gpu) : mCallback(callback), mGPU(gpu) {}
+ virtual ~PxsSimulationController(){}
+
+ virtual void addPxgShape(Sc::ShapeSimBase* /*shapeSimBase*/, const PxsShapeCore* /*shapeCore*/, PxNodeIndex /*nodeIndex*/, PxU32 /*index*/){}
+ virtual void setPxgShapeBodyNodeIndex(PxNodeIndex /*nodeIndex*/, PxU32 /*index*/) {}
+ virtual void removePxgShape(PxU32 /*index*/){}
+
+ virtual void addDynamic(PxsRigidBody* /*rigidBody*/, const PxNodeIndex& /*nodeIndex*/){}
+ virtual void addDynamics(PxsRigidBody** /*rigidBody*/, const PxU32* /*nodeIndex*/, PxU32 /*nbBodies*/) {}
+ virtual void addArticulation(Dy::FeatherstoneArticulation* /*articulation*/, const PxNodeIndex& /*nodeIndex*/) {}
+ virtual void releaseArticulation(Dy::FeatherstoneArticulation* /*articulation*/, const PxNodeIndex& /*nodeIndex*/) {}
+ virtual void releaseDeferredArticulationIds() {}
+
+ #if PX_SUPPORT_GPU_PHYSX
+ virtual void addSoftBody(Dy::DeformableVolume* /*deformableVolume*/, const PxNodeIndex& /*nodeIndex*/) {}
+ virtual void releaseSoftBody(Dy::DeformableVolume* /*deformableVolume*/) {}
+ virtual void releaseDeferredSoftBodyIds() {}
+ virtual void activateSoftbody(Dy::DeformableVolume* /*deformableVolume*/) {}
+ virtual void deactivateSoftbody(Dy::DeformableVolume* /*deformableVolume*/) {}
+ virtual void activateSoftbodySelfCollision(Dy::DeformableVolume* /*deformableVolume*/) {}
+ virtual void deactivateSoftbodySelfCollision(Dy::DeformableVolume* /*deformableVolume*/) {}
+ virtual void setSoftBodyWakeCounter(Dy::DeformableVolume* /*deformableVolume*/) {}
+
+
+ virtual PxU32 addRigidAttachment(Dy::DeformableVolume* /*deformableVolume*/, const PxNodeIndex& /*softBodyNodeIndex*/,
+ PxsRigidBody* /*rigidBody*/, const PxNodeIndex& /*rigidNodeIndex*/, PxU32 /*vertIndex*/, const PxVec3& /*actorSpacePose*/,
+ const bool /*isActive*/, bool /*doConversion*/) { return 0; }
+ virtual void removeRigidAttachment(Dy::DeformableVolume* /*deformableVolume*/, PxU32 /*handle*/) {}
+
+ virtual void addTetRigidFilter(Dy::DeformableVolume* /*deformableVolume*/,
+ const PxNodeIndex& /*rigidNodeIndex*/, PxU32 /*tetId*/) {}
+
+ virtual PxU32 addTetRigidAttachment(Dy::DeformableVolume* /*deformableVolume*/,
+ PxsRigidBody* /*rigidBody*/, const PxNodeIndex& /*rigidNodeIndex*/, PxU32 /*tetIdx*/,
+ const PxVec4& /*barycentrics*/, const PxVec3& /*actorSpacePose*/,
+ const bool /*isActive*/, bool /*doConversion*/) { return 0; }
+
+ virtual void removeTetRigidFilter(Dy::DeformableVolume* /*deformableVolume*/,
+ const PxNodeIndex& /*rigidNodeIndex*/, PxU32 /*tetId*/) {}
+
+ virtual void addSoftBodyFilter(Dy::DeformableVolume* /*deformableVolume0*/, Dy::DeformableVolume* /*deformableVolume1*/, PxU32 /*tetIdx0*/,
+ PxU32 /*tetIdx1*/) {}
+ virtual void removeSoftBodyFilter(Dy::DeformableVolume* /*deformableVolume0*/, Dy::DeformableVolume* /*deformableVolume1*/, PxU32 /*tetIdx0*/,
+ PxU32 /*tetId1*/) {}
+ virtual void addSoftBodyFilters(Dy::DeformableVolume* /*deformableVolume0*/, Dy::DeformableVolume* /*deformableVolume1*/, PxU32* /*tetIndices0*/, PxU32* /*tetIndices1*/,
+ PxU32 /*tetIndicesSize*/) {}
+ virtual void removeSoftBodyFilters(Dy::DeformableVolume* /*deformableVolume0*/, Dy::DeformableVolume* /*deformableVolume1*/, PxU32* /*tetIndices0*/, PxU32* /*tetIndices1*/,
+ PxU32 /*tetIndicesSize*/) {}
+
+ virtual PxU32 addSoftBodyAttachment(Dy::DeformableVolume* /*deformableVolume0*/, Dy::DeformableVolume* /*deformableVolume1*/, PxU32 /*tetIdx0*/, PxU32 /*tetIdx1*/,
+ const PxVec4& /*tetBarycentric0*/, const PxVec4& /*tetBarycentric1*/,
+ const bool /*isActive*/, bool /*doConversion*/) { return 0; }
+
+ virtual void removeSoftBodyAttachment(Dy::DeformableVolume* /*deformableVolume0*/, PxU32 /*handle*/) {}
+
+ virtual void addClothFilter(Dy::DeformableVolume* /*deformableVolume*/, Dy::DeformableSurface* /*deformableSurface*/, PxU32 /*triIdx*/, PxU32 /*tetIdx*/) {}
+ virtual void removeClothFilter(Dy::DeformableVolume* /*deformableVolume*/, Dy::DeformableSurface* /*deformableSurface*/, PxU32 /*triIdx*/, PxU32 /*tetIdx*/) {}
+
+ virtual void addVertClothFilter(Dy::DeformableVolume* /*deformableVolume*/, Dy::DeformableSurface* /*deformableSurface*/, PxU32 /*vertIdx*/, PxU32 /*tetIdx*/) {}
+ virtual void removeVertClothFilter(Dy::DeformableVolume* /*deformableVolume*/, Dy::DeformableSurface* /*deformableSurface*/, PxU32 /*vertIdx*/, PxU32 /*tetIdx*/) {}
+
+ virtual PxU32 addClothAttachment(Dy::DeformableVolume* /*deformableVolume*/, Dy::DeformableSurface* /*deformableSurface*/, PxU32 /*triIdx*/,
+ const PxVec4& /*triBarycentric*/, PxU32 /*tetIdx*/, const PxVec4& /*tetBarycentric*/,
+ const bool /*isActive*/, bool /*doConversion*/) { return 0; }
+
+ virtual void removeClothAttachment(Dy::DeformableVolume* /*deformableVolume*/,PxU32 /*handle*/) {}
+
+ virtual void addFEMCloth(Dy::DeformableSurface*, const PxNodeIndex&) {}
+ virtual void releaseFEMCloth(Dy::DeformableSurface*) {}
+ virtual void releaseDeferredFEMClothIds() {}
+ virtual void activateCloth(Dy::DeformableSurface*) {}
+ virtual void deactivateCloth(Dy::DeformableSurface*) {}
+ virtual void setClothWakeCounter(Dy::DeformableSurface*) {}
+
+ virtual PxU32 addRigidAttachment(Dy::DeformableSurface* /*cloth*/, const PxNodeIndex& /*clothNodeIndex*/,
+ PxsRigidBody* /*rigidBody*/, const PxNodeIndex& /*rigidNodeIndex*/, PxU32 /*vertIndex*/, const PxVec3& /*actorSpacePose*/,
+ const bool /*isActive*/) { return 0; }
+ virtual void removeRigidAttachment(Dy::DeformableSurface* /*cloth*/, PxU32 /*handle*/) {}
+
+ virtual void addTriRigidFilter(Dy::DeformableSurface* /*deformableSurface*/,
+ const PxNodeIndex& /*rigidNodeIndex*/, PxU32 /*triIdx*/) {}
+
+ virtual void removeTriRigidFilter(Dy::DeformableSurface* /*deformableSurface*/,
+ const PxNodeIndex& /*rigidNodeIndex*/, PxU32 /*triIdx*/) {}
+
+ virtual PxU32 addTriRigidAttachment(Dy::DeformableSurface* /*deformableSurface*/,
+ PxsRigidBody* /*rigidBody*/, const PxNodeIndex& /*rigidNodeIndex*/, PxU32 /*triIdx*/, const PxVec4& /*barycentrics*/,
+ const PxVec3& /*actorSpacePose*/,
+ const bool /*isActive*/) { return 0; }
+
+ virtual void removeTriRigidAttachment(Dy::DeformableSurface* /*deformableSurface*/, PxU32 /*handle*/) {}
+
+ virtual void addClothFilter(Dy::DeformableSurface* /*deformableSurface0*/, Dy::DeformableSurface* /*deformableSurface1*/, PxU32 /*triIdx0*/, PxU32 /*triIdx1*/) {}
+ virtual void removeClothFilter(Dy::DeformableSurface* /*deformableSurface0*/, Dy::DeformableSurface* /*deformableSurface1*/, PxU32 /*triIdx0*/, PxU32 /*triIdx1*/) {}
+
+ virtual PxU32 addTriClothAttachment(Dy::DeformableSurface* /*deformableSurface0*/, Dy::DeformableSurface* /*deformableSurface1*/, PxU32 /*triIdx0*/, PxU32 /*triIdx1*/,
+ const PxVec4& /*triBarycentric0*/, const PxVec4& /*triBarycentric1*/, const bool /*addToActive*/) { return 0; }
+
+ virtual void removeTriClothAttachment(Dy::DeformableSurface* /*deformableSurface*/, PxU32 /*handle*/) {}
+
+ virtual void addParticleSystem(Dy::ParticleSystem* /*particleSystem*/, const PxNodeIndex& /*nodeIndex*/) {}
+ virtual void releaseParticleSystem(Dy::ParticleSystem* /*particleSystem*/) {}
+ virtual void releaseDeferredParticleSystemIds() {}
+
+ #endif
+
+ virtual void setEnableOVDReadback(bool) {}
+ virtual bool getEnableOVDReadback() const { return false; }
+ virtual void setEnableOVDCollisionReadback(bool) {}
+ virtual bool getEnableOVDCollisionReadback() const { return false; }
+
+ #if PX_SUPPORT_OMNI_PVD
+ virtual void setOVDCallbacks(PxsSimulationControllerOVDCallbacks& /*ovdCallbacks*/) {}
+ #endif
+
+ virtual void updateDynamic(Dy::FeatherstoneArticulation* /*articulation*/, const PxNodeIndex& /*nodeIndex*/) {}
+ virtual void addJoint(const Dy::Constraint&) {}
+ virtual void updateJoint(const PxU32 /*edgeIndex*/, Dy::Constraint* /*constraint*/){}
+ virtual void updateBodies(PxsRigidBody** /*rigidBodies*/, PxU32* /*nodeIndices*/, const PxU32 /*nbBodies*/, PxsExternalAccelerationProvider* /*externalAccelerations*/) {}
+ // virtual void updateBody(PxsRigidBody* /*rigidBody*/, const PxU32 /*nodeIndex*/) {}
+ virtual void updateBodies(PxBaseTask* /*continuation*/){}
+ virtual void updateShapes(PxBaseTask* /*continuation*/) {}
+ virtual void preIntegrateAndUpdateBound(PxBaseTask* /*continuation*/, const PxVec3 /*gravity*/, const PxReal /*dt*/){}
+ virtual void updateParticleSystemsAndSoftBodies(){}
+ virtual void sortContacts(){}
+ virtual void update(Cm::PinnableBitMap& /*changedHandleMap*/){}
+ virtual void updateArticulation(Dy::FeatherstoneArticulation* /*articulation*/, const PxNodeIndex& /*nodeIndex*/) {}
+ virtual void updateArticulationJoint(Dy::FeatherstoneArticulation* /*articulation*/, const PxNodeIndex& /*nodeIndex*/) {}
+ // virtual void updateArticulationTendon(Dy::FeatherstoneArticulation* /*articulation*/, const PxNodeIndex& /*nodeIndex*/) {}
+ virtual void updateArticulationExtAccel(Dy::FeatherstoneArticulation* /*articulation*/, const PxNodeIndex& /*nodeIndex*/) {}
+ virtual void updateArticulationAfterIntegration(PxsContext* /*llContext*/, Bp::AABBManagerBase* /*aabbManager*/,
+ PxArray<Sc::BodySim*>& /*ccdBodies*/, PxBaseTask* /*continuation*/, IG::IslandSim& /*islandSim*/, float /*dt*/, bool /*isSleepingDisabled*/) {}
+
+ virtual void mergeChangedAABBMgHandle() {}
+ virtual void gpuDmabackData(PxsTransformCache& /*cache*/, Bp::BoundsArray& /*boundArray*/, Cm::PinnableBitMap& /*changedAABBMgrHandles*/, bool /*enableDirectGPUAPI*/){}
+ virtual void updateScBodyAndShapeSim(PxsTransformCache& cache, Bp::BoundsArray& boundArray, PxBaseTask* continuation) = 0;
+
+ // PdHC: Returns pointer to GPU-computed rigid body accelerations, or NULL if not available.
+ // Accelerations are computed on GPU using velocity-delta in gpuMemDmaBack for both
+ // DirectGPU and non-DirectGPU (CPU Frontend + GPU Backend) modes.
+ // GPU implementations (PxgSimulationController) provide actual data; CPU implementations return NULL.
+ virtual const void* getRigidBodyAccelerations() const { return NULL; }
+
+ virtual PxU32* getActiveBodies() { return NULL; }
+ virtual PxU32* getDeactiveBodies() { return NULL; }
+ virtual void** getRigidBodies() { return NULL; }
+ virtual PxU32 getNbBodies() { return 0; }
+
+ virtual PxU32* getUnfrozenShapes() { return NULL; }
+ virtual PxU32* getFrozenShapes() { return NULL; }
+ virtual Sc::ShapeSimBase** getShapeSims() { return NULL; }
+ virtual PxU32 getNbFrozenShapes() { return 0; }
+ virtual PxU32 getNbUnfrozenShapes() { return 0; }
+ virtual PxU32 getNbShapes() { return 0; }
+
+ virtual void clear() { }
+ virtual void setBounds(Bp::BoundsArray* /*boundArray*/){}
+ virtual void reserve(const PxU32 /*nbBodies*/) {}
+
+ virtual PxU32 getArticulationRemapIndex(const PxU32 /*nodeIndex*/) { return PX_INVALID_U32;}
+
+ //KS - the methods below here should probably be wrapped in if PX_SUPPORT_GPU_PHYSX
+ // PT: isn't the whole class only needed for GPU anyway?
+ // AD: Yes.
+
+ virtual void setDeformableSurfaceGpuPostSolveCallback(PxPostSolveCallback* /*postSolveCallback*/) { }
+ virtual void setDeformableVolumeGpuPostSolveCallback(PxPostSolveCallback* /*postSolveCallback*/) { }
+
+ // NEW DIRECT-GPU API
+
+ virtual bool getRigidDynamicData(void* /*data*/, const PxRigidDynamicGPUIndex* /*gpuIndices*/, PxRigidDynamicGPUAPIReadType::Enum /*dataType*/, PxU32 /*nbElements*/, CUevent /*startEvent*/, CUevent /*finishEvent*/) const { return false; }
+ virtual bool setRigidDynamicData(const void* /*data*/, const PxRigidDynamicGPUIndex* /*gpuIndices*/, PxRigidDynamicGPUAPIWriteType::Enum /*dataType*/, PxU32 /*nbElements*/, CUevent /*startEvent*/, CUevent /*finishEvent*/) { return false; }
+
+ virtual bool getArticulationData(void* /*data*/, const PxArticulationGPUIndex* /*gpuIndices*/, PxArticulationGPUAPIReadType::Enum /*dataType*/, PxU32 /*nbElements*/, CUevent /*startEvent*/, CUevent /*finishEvent*/) const { return false; }
+ virtual bool setArticulationData(const void* /*data*/, const PxArticulationGPUIndex* /*gpuIndices*/, PxArticulationGPUAPIWriteType::Enum /*dataType*/, PxU32 /*nbElements*/, CUevent /*startEvent*/, CUevent /*finishEvent*/) { return false; }
+ virtual bool computeArticulationData(void* /*data*/, const PxArticulationGPUIndex* /*gpuIndices*/, PxArticulationGPUAPIComputeType::Enum /*operation*/, PxU32 /*nbElements*/, CUevent /*startEvent*/, CUevent /*finishEvent*/) { return false; }
+
+ virtual bool evaluateSDFDistances(PxVec4* /*localGradientAndSDFConcatenated*/, const PxShapeGPUIndex* /*shapeIndices*/, const PxVec4* /*localSamplePointsConcatenated*/, const PxU32* /*samplePointCountPerShape*/, PxU32 /*nbElements*/, PxU32 /*maxPointCount*/, CUevent /*startEvent = NULL*/, CUevent /*finishEvent = NULL*/) { return false; }
+ virtual bool copyContactData(void* /*data*/, PxU32* /*numContactPairs*/, const PxU32 /*maxContactPairs*/, CUevent /*startEvent*/, CUevent /*copyEvent*/) { return false; }
+
+ virtual PxArticulationGPUAPIMaxCounts getArticulationGPUAPIMaxCounts() const { return PxArticulationGPUAPIMaxCounts(); }
+
+ virtual bool getD6JointData(void* /*data*/, const PxD6JointGPUIndex* /*gpuIndices*/, PxD6JointGPUAPIReadType::Enum /*dataType*/, PxU32 /*nbElements*/, PxF32 /*oneOverDt*/, CUevent /*startEvent*/, CUevent /*finishEvent*/) const { return false; }
+
+ // END NEW DIRECT-GPU API
+
+
+ virtual PxU32 getInternalShapeIndex(const PxsShapeCore& /*shapeCore*/) { return PX_INVALID_U32; }
+
+ virtual void syncParticleData() {}
+
+ virtual void updateBoundsAndShapes(Bp::AABBManagerBase& /*aabbManager*/, bool /*useDirectApi*/){}
+
+ #if PX_SUPPORT_GPU_PHYSX
+ virtual PxU32 getNbDeactivatedDeformableSurfaces() const { return 0; }
+ virtual PxU32 getNbActivatedDeformableSurfaces() const { return 0; }
+
+ virtual Dy::DeformableSurface** getDeactivatedDeformableSurfaces() const { return NULL; }
+ virtual Dy::DeformableSurface** getActivatedDeformableSurfaces() const { return NULL; }
+
+ virtual PxU32 getNbDeactivatedDeformableVolumes() const { return 0; }
+ virtual PxU32 getNbActivatedDeformableVolumes() const { return 0; }
+
+ virtual Dy::DeformableVolume** getDeactivatedDeformableVolumes() const { return NULL; }
+ virtual Dy::DeformableVolume** getActivatedDeformableVolumes() const { return NULL; }
+
+ virtual const PxReal* getDeformableVolumeWakeCounters() const { return NULL; }
+
+ virtual bool hasDeformableSurfaces() const { return false; }
+ virtual bool hasDeformableVolumes() const { return false; }
+ #endif
protected:
- PxsSimulationControllerCallback* mCallback;
-
+ PxsSimulationControllerCallback* mCallback;
+ public:
+ const PxIntBool mGPU; // PT: true for GPU version, used to quickly skip calls for CPU version
};
- PxsSimulationController* createSimulationController(PxsSimulationControllerCallback* callback);
+ #if PX_SUPPORT_OMNI_PVD
+ PX_FORCE_INLINE void PxsSimulationControllerOVDCallbacks::getArticulationDataElements(PxArticulationGPUAPIWriteType::Enum dataType, PxU32 maxLinks, PxU32 maxDofs, PxU32 maxFixedTendons, PxU32 maxTendonJoints, PxU32 maxSpatialTendons, PxU32 maxSpatialTendonAttachments,
+ PxU32& nbSubElements, PxU32& blockSize) const
+ {
+ PxU32 singleSubElementSize = 0;
+ switch(dataType)
+ {
+ case PxArticulationGPUAPIWriteType::eJOINT_POSITION:
+ case PxArticulationGPUAPIWriteType::eJOINT_VELOCITY:
+ case PxArticulationGPUAPIWriteType::eJOINT_FORCE:
+ case PxArticulationGPUAPIWriteType::eJOINT_TARGET_VELOCITY:
+ case PxArticulationGPUAPIWriteType::eJOINT_TARGET_POSITION:
+ {
+ nbSubElements = maxDofs;
+ singleSubElementSize = sizeof(PxReal);
+ break;
+ }
+ case PxArticulationGPUAPIWriteType::eROOT_GLOBAL_POSE:
+ {
+ nbSubElements = 1;
+ singleSubElementSize = sizeof(PxTransform);
+ break;
+ }
+ case PxArticulationGPUAPIWriteType::eROOT_LINEAR_VELOCITY:
+ case PxArticulationGPUAPIWriteType::eROOT_ANGULAR_VELOCITY:
+ {
+ nbSubElements = 1;
+ singleSubElementSize = sizeof(PxVec3);
+ break;
+ }
+ case PxArticulationGPUAPIWriteType::eLINK_FORCE:
+ case PxArticulationGPUAPIWriteType::eLINK_TORQUE:
+ {
+ nbSubElements = maxLinks;
+ singleSubElementSize = sizeof(PxVec3);
+ break;
+ }
+ case PxArticulationGPUAPIWriteType::eFIXED_TENDON:
+ {
+ nbSubElements = maxFixedTendons;
+ singleSubElementSize = sizeof(PxGpuFixedTendonData);
+ break;
+ }
+ case PxArticulationGPUAPIWriteType::eFIXED_TENDON_JOINT:
+ {
+ nbSubElements = maxFixedTendons * maxTendonJoints;
+ singleSubElementSize = sizeof(PxGpuTendonJointCoefficientData);
+ break;
+ }
+ case PxArticulationGPUAPIWriteType::eSPATIAL_TENDON:
+ {
+ nbSubElements = maxSpatialTendons;
+ singleSubElementSize = sizeof(PxGpuSpatialTendonData);
+ break;
+ }
+ case PxArticulationGPUAPIWriteType::eSPATIAL_TENDON_ATTACHMENT:
+ {
+ nbSubElements = maxSpatialTendons * maxSpatialTendonAttachments;
+ singleSubElementSize = sizeof(PxGpuTendonAttachmentData);
+ break;
+ }
+ default:
+ PX_ALWAYS_ASSERT();
+ nbSubElements = 0;
+ singleSubElementSize = 0;
+ break;
+ }
+ blockSize = singleSubElementSize * nbSubElements;
+ }
+ #endif
+
}
#endif