267 lines
9.5 KiB
C++
267 lines
9.5 KiB
C++
//
|
|
// 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-2019 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_PHYSICS_NP_FACTORY
|
|
#define PX_PHYSICS_NP_FACTORY
|
|
|
|
#include "PsPool.h"
|
|
#include "PsMutex.h"
|
|
#include "PsHashSet.h"
|
|
|
|
#include "GuMeshFactory.h"
|
|
#include "CmPhysXCommon.h"
|
|
#include "PxPhysXConfig.h"
|
|
#include "PxShape.h"
|
|
#include "PxArticulationBase.h"
|
|
|
|
namespace physx
|
|
{
|
|
|
|
class PxActor;
|
|
|
|
class PxRigidActor;
|
|
|
|
class PxRigidStatic;
|
|
class NpRigidStatic;
|
|
|
|
class PxRigidDynamic;
|
|
class NpRigidDynamic;
|
|
|
|
class NpConnectorArray;
|
|
|
|
struct PxConstraintShaderTable;
|
|
class PxConstraintConnector;
|
|
class PxConstraint;
|
|
class NpConstraint;
|
|
|
|
class PxArticulation;
|
|
class PxArticulationReducedCoordinate;
|
|
class NpArticulation;
|
|
class NpArticulationReducedCoordinate;
|
|
class PxArticulationLink;
|
|
class NpArticulationLink;
|
|
class NpArticulationJoint;
|
|
class NpArticulationJointReducedCoordinate;
|
|
|
|
class PxMaterial;
|
|
class NpMaterial;
|
|
|
|
class PxGeometry;
|
|
|
|
class NpShape;
|
|
|
|
class NpScene;
|
|
|
|
class PxAggregate;
|
|
class NpAggregate;
|
|
|
|
class NpConnectorArray;
|
|
class NpPtrTableStorageManager;
|
|
|
|
namespace Cm
|
|
{
|
|
class Collection;
|
|
}
|
|
|
|
namespace Scb
|
|
{
|
|
class RigidObject;
|
|
class Articulation;
|
|
}
|
|
|
|
namespace pvdsdk
|
|
{
|
|
class PvdDataStream;
|
|
class PsPvd;
|
|
}
|
|
|
|
class NpFactoryListener : public GuMeshFactoryListener
|
|
{
|
|
protected:
|
|
virtual ~NpFactoryListener(){}
|
|
};
|
|
|
|
class NpFactory : public GuMeshFactory
|
|
{
|
|
PX_NOCOPY(NpFactory)
|
|
public:
|
|
NpFactory();
|
|
private:
|
|
~NpFactory();
|
|
public:
|
|
static void createInstance();
|
|
static void destroyInstance();
|
|
static void registerArticulations();
|
|
static void registerArticulationRCs();
|
|
|
|
void release();
|
|
|
|
void addCollection(const Cm::Collection& collection);
|
|
|
|
PX_INLINE static NpFactory& getInstance() { return *mInstance; }
|
|
|
|
// Rigid dynamic
|
|
PxRigidDynamic* createRigidDynamic(const PxTransform& pose);
|
|
void addRigidDynamic(PxRigidDynamic*, bool lock=true);
|
|
void releaseRigidDynamicToPool(NpRigidDynamic&);
|
|
// PT: TODO: add missing functions
|
|
// PxU32 getNbRigidDynamics() const;
|
|
// PxU32 getRigidDynamics(PxRigidDynamic** userBuffer, PxU32 bufferSize, PxU32 startIndex) const;
|
|
|
|
// Rigid static
|
|
PxRigidStatic* createRigidStatic(const PxTransform& pose);
|
|
void addRigidStatic(PxRigidStatic*, bool lock=true);
|
|
void releaseRigidStaticToPool(NpRigidStatic&);
|
|
// PT: TODO: add missing functions
|
|
// PxU32 getNbRigidStatics() const;
|
|
// PxU32 getRigidStatics(PxRigidStatic** userBuffer, PxU32 bufferSize, PxU32 startIndex) const;
|
|
|
|
// Shapes
|
|
NpShape* createShape(const PxGeometry& geometry, PxShapeFlags shapeFlags, PxMaterial*const* materials, PxU16 materialCount, bool isExclusive);
|
|
void addShape(PxShape*, bool lock=true);
|
|
void releaseShapeToPool(NpShape&);
|
|
PxU32 getNbShapes() const;
|
|
PxU32 getShapes(PxShape** userBuffer, PxU32 bufferSize, PxU32 startIndex) const;
|
|
|
|
// Constraints
|
|
PxConstraint* createConstraint(PxRigidActor* actor0, PxRigidActor* actor1, PxConstraintConnector& connector, const PxConstraintShaderTable& shaders, PxU32 dataSize);
|
|
void addConstraint(PxConstraint*, bool lock=true);
|
|
void releaseConstraintToPool(NpConstraint&);
|
|
// PT: TODO: add missing functions
|
|
// PxU32 getNbConstraints() const;
|
|
// PxU32 getConstraints(PxConstraint** userBuffer, PxU32 bufferSize, PxU32 startIndex) const;
|
|
|
|
// Articulations
|
|
PxArticulation* createArticulation();
|
|
void addArticulation(PxArticulationBase*, bool lock=true);
|
|
void releaseArticulationToPool(PxArticulationBase& articulation);
|
|
PxArticulationReducedCoordinate* createArticulationRC();
|
|
NpArticulation* createNpArticulation();
|
|
NpArticulationReducedCoordinate* createNpArticulationRC();
|
|
// PT: TODO: add missing functions
|
|
// PxU32 getNbArticulations() const;
|
|
// PxU32 getArticulations(PxArticulation** userBuffer, PxU32 bufferSize, PxU32 startIndex) const;
|
|
|
|
// Articulation links
|
|
NpArticulationLink* createNpArticulationLink(PxArticulationBase&root, NpArticulationLink* parent, const PxTransform& pose);
|
|
void releaseArticulationLinkToPool(NpArticulationLink& articulation);
|
|
PxArticulationLink* createArticulationLink(PxArticulationBase&, NpArticulationLink* parent, const PxTransform& pose);
|
|
|
|
// Articulation joints
|
|
NpArticulationJoint* createNpArticulationJoint(NpArticulationLink& parent, const PxTransform& parentFrame, NpArticulationLink& child, const PxTransform& childFrame);
|
|
void releaseArticulationJointToPool(NpArticulationJoint& articulationJoint);
|
|
NpArticulationJointReducedCoordinate* createNpArticulationJointRC(NpArticulationLink& parent, const PxTransform& parentFrame, NpArticulationLink& child, const PxTransform& childFrame);
|
|
void releaseArticulationJointRCToPool(NpArticulationJointReducedCoordinate& articulationJoint);
|
|
|
|
// Aggregates
|
|
PxAggregate* createAggregate(PxU32 maxActors, bool selfCollisions);
|
|
void addAggregate(PxAggregate*, bool lock=true);
|
|
void releaseAggregateToPool(NpAggregate&);
|
|
// PT: TODO: add missing functions
|
|
// PxU32 getNbAggregates() const;
|
|
// PxU32 getAggregates(PxAggregate** userBuffer, PxU32 bufferSize, PxU32 startIndex) const;
|
|
|
|
// Materials
|
|
PxMaterial* createMaterial(PxReal staticFriction, PxReal dynamicFriction, PxReal restitution);
|
|
void releaseMaterialToPool(NpMaterial& material);
|
|
|
|
// It's easiest to track these uninvasively, so it's OK to use the Px pointers
|
|
void onActorRelease(PxActor*);
|
|
void onConstraintRelease(PxConstraint*);
|
|
void onAggregateRelease(PxAggregate*);
|
|
void onArticulationRelease(PxArticulationBase*);
|
|
void onShapeRelease(PxShape*);
|
|
|
|
NpConnectorArray* acquireConnectorArray();
|
|
void releaseConnectorArray(NpConnectorArray*);
|
|
|
|
NpPtrTableStorageManager& getPtrTableStorageManager() { return *mPtrTableStorageManager; }
|
|
|
|
#if PX_SUPPORT_PVD
|
|
void setNpFactoryListener( NpFactoryListener& );
|
|
#endif
|
|
|
|
private:
|
|
void releaseExclusiveShapeUserReferences();
|
|
|
|
Ps::Pool<NpConnectorArray> mConnectorArrayPool;
|
|
Ps::Mutex mConnectorArrayPoolLock;
|
|
|
|
NpPtrTableStorageManager* mPtrTableStorageManager;
|
|
|
|
Ps::HashSet<PxAggregate*> mAggregateTracking;
|
|
Ps::HashSet<PxArticulationBase*> mArticulationTracking;
|
|
Ps::HashSet<PxConstraint*> mConstraintTracking;
|
|
Ps::HashSet<PxActor*> mActorTracking;
|
|
Ps::CoalescedHashSet<PxShape*> mShapeTracking;
|
|
|
|
Ps::Pool2<NpRigidDynamic, 4096> mRigidDynamicPool;
|
|
Ps::Mutex mRigidDynamicPoolLock;
|
|
|
|
Ps::Pool2<NpRigidStatic, 4096> mRigidStaticPool;
|
|
Ps::Mutex mRigidStaticPoolLock;
|
|
|
|
Ps::Pool2<NpShape, 4096> mShapePool;
|
|
Ps::Mutex mShapePoolLock;
|
|
|
|
Ps::Pool2<NpAggregate, 4096> mAggregatePool;
|
|
Ps::Mutex mAggregatePoolLock;
|
|
|
|
Ps::Pool2<NpConstraint, 4096> mConstraintPool;
|
|
Ps::Mutex mConstraintPoolLock;
|
|
|
|
Ps::Pool2<NpMaterial, 4096> mMaterialPool;
|
|
Ps::Mutex mMaterialPoolLock;
|
|
|
|
Ps::Pool2<NpArticulation, 4096> mArticulationPool;
|
|
Ps::Mutex mArticulationPoolLock;
|
|
|
|
Ps::Pool2<NpArticulationReducedCoordinate, 4096> mArticulationRCPool;
|
|
Ps::Mutex mArticulationRCPoolLock;
|
|
|
|
Ps::Pool2<NpArticulationLink, 4096> mArticulationLinkPool;
|
|
Ps::Mutex mArticulationLinkPoolLock;
|
|
|
|
Ps::Pool2<NpArticulationJoint, 4096> mArticulationJointPool;
|
|
Ps::Mutex mArticulationJointPoolLock;
|
|
|
|
Ps::Pool2<NpArticulationJointReducedCoordinate, 4096> mArticulationRCJointPool;
|
|
Ps::Mutex mArticulationJointRCPoolLock;
|
|
|
|
static NpFactory* mInstance;
|
|
|
|
#if PX_SUPPORT_PVD
|
|
NpFactoryListener* mNpFactoryListener;
|
|
#endif
|
|
};
|
|
|
|
}
|
|
|
|
#endif
|