Init
This commit is contained in:
397
physx/source/scenequery/include/SqPruner.h
Normal file
397
physx/source/scenequery/include/SqPruner.h
Normal file
@ -0,0 +1,397 @@
|
||||
//
|
||||
// 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) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
|
||||
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
|
||||
|
||||
#ifndef SQ_PRUNER_H
|
||||
#define SQ_PRUNER_H
|
||||
|
||||
#include "foundation/PxBounds3.h"
|
||||
#include "geometry/PxGeometry.h"
|
||||
#include "PxQueryReport.h"
|
||||
#include "PxQueryFiltering.h"
|
||||
#include "PsUserAllocated.h"
|
||||
#include "SqPruningStructure.h"
|
||||
#include "GuSphere.h"
|
||||
#include "GuBox.h"
|
||||
#include "GuCapsule.h"
|
||||
|
||||
namespace physx
|
||||
{
|
||||
namespace Gu
|
||||
{
|
||||
class ShapeData;
|
||||
class BVHStructure;
|
||||
}
|
||||
}
|
||||
|
||||
namespace physx
|
||||
{
|
||||
namespace Cm
|
||||
{
|
||||
class RenderOutput;
|
||||
}
|
||||
|
||||
namespace Sq
|
||||
{
|
||||
|
||||
typedef PxU32 PrunerHandle;
|
||||
typedef PxU32 PrunerCompoundId;
|
||||
|
||||
static const PrunerHandle INVALID_PRUNERHANDLE = 0xFFffFFff;
|
||||
static const PxReal SQ_PRUNER_INFLATION = 1.01f; // pruner test shape inflation (not narrow phase shape)
|
||||
|
||||
struct PrunerPayload
|
||||
{
|
||||
size_t data[2];
|
||||
|
||||
PX_FORCE_INLINE bool operator == (const PrunerPayload& other) const
|
||||
{
|
||||
return (data[0] == other.data[0]) && (data[1] == other.data[1]);
|
||||
}
|
||||
};
|
||||
|
||||
struct PrunerCallback
|
||||
{
|
||||
virtual PxAgain invoke(PxReal& distance, const PrunerPayload& payload) = 0;
|
||||
virtual ~PrunerCallback() {}
|
||||
};
|
||||
|
||||
class Pruner : public Ps::UserAllocated
|
||||
{
|
||||
public:
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* \brief Adds objects to the pruner.
|
||||
* \param results [out] an array for resulting handles
|
||||
* \param bounds [in] an array of bounds. These bounds are used as-is so they should be pre-inflated if inflation is needed.
|
||||
* \param userData [in] an array of object data
|
||||
* \param count [in] the number of objects in the arrays
|
||||
* \param hasPruningStructure [in] if added objects have pruning structure. The structure will be merged later, adding the objects will not invalidate the pruner.
|
||||
*
|
||||
* \return true if success, false if internal allocation failed. The first failing add results in a INVALID_PRUNERHANDLE.
|
||||
*
|
||||
* Handles are usable as indices. Each handle is either be a recycled handle returned by the client via removeObjects(),
|
||||
* or a fresh handle that is either zero, or one greater than the last fresh handle returned.
|
||||
*
|
||||
* Objects and bounds in the arrays have the same number of elements and ordering.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual bool addObjects(PrunerHandle* results, const PxBounds3* bounds, const PrunerPayload* userData, PxU32 count, bool hasPruningStructure) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Removes objects from the pruner.
|
||||
* \param handles [in] the objects to remove
|
||||
* \param count [in] the number of objects to remove
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void removeObjects(const PrunerHandle* handles, PxU32 count) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Updates objects after manually updating their bounds via "getPayload" calls.
|
||||
* \param handles [in] the objects to update
|
||||
* \param count [in] the number of objects to update
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void updateObjectsAfterManualBoundsUpdates(const PrunerHandle* handles, PxU32 count) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Updates objects with new indexed bounds.
|
||||
* \param handles [in] the objects to update
|
||||
* \param indices [in] the indices of the bounds in the bounds array
|
||||
* \param newBounds [in] updated bounds array
|
||||
* \param count [in] the number of objects to update
|
||||
*
|
||||
* \warning THESE BOUNDS WILL BE INFLATED ON-THE-FLY. So this is inconsistent with the "addObjects" behavior.
|
||||
* \warning The inflation value is hardcoded in Sq::inflateBounds().
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void updateObjectsAndInflateBounds(const PrunerHandle* handles, const PxU32* indices, const PxBounds3* newBounds, PxU32 count) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Makes the queries consistent with previous changes.
|
||||
* This function must be called before starting queries on an updated Pruner and assert otherwise.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void commit() = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Merges pruning structure to current pruner, parameters may differ for each pruner implementation
|
||||
* \param mergeParams [in] Pruning structure to merge.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void merge(const void* mergeParams) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Query functions
|
||||
*
|
||||
* Note: return value may disappear if PrunerCallback contains the necessary information
|
||||
* currently it is still used for the dynamic pruner internally (to decide if added objects must be queried)
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual PxAgain raycast(const PxVec3& origin, const PxVec3& unitDir, PxReal& inOutDistance, PrunerCallback&) const = 0;
|
||||
virtual PxAgain overlap(const Gu::ShapeData& queryVolume, PrunerCallback&) const = 0;
|
||||
virtual PxAgain sweep(const Gu::ShapeData& queryVolume, const PxVec3& unitDir, PxReal& inOutDistance, PrunerCallback&) const = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Retrieve the object data associated with the handle
|
||||
*
|
||||
* \param handle The handle returned by addObjects()
|
||||
*
|
||||
* \return A reference to the object data
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual const PrunerPayload& getPayload(PrunerHandle handle) const = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Retrieve the object data associated with the handle, plus the destination address for its matrix. The user is then expected to write the new AABB there.
|
||||
*
|
||||
* \param handle [in] The handle returned by addObjects()
|
||||
* \param bounds [out] destination address for this object's bounds
|
||||
*
|
||||
* \return A reference to the object data
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual const PrunerPayload& getPayload(PrunerHandle handle, PxBounds3*& bounds) const = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Preallocate space
|
||||
*
|
||||
* \param entries the number of entries to preallocate space for
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void preallocate(PxU32 entries) = 0;
|
||||
|
||||
// shift the origin of the pruner objects
|
||||
virtual void shiftOrigin(const PxVec3& shift) = 0;
|
||||
|
||||
virtual ~Pruner() {}
|
||||
|
||||
// additional 'internal' interface
|
||||
virtual void visualize(Cm::RenderOutput&, PxU32) const {}
|
||||
};
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Pruner building accel structure over time base class
|
||||
*/
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
class IncrementalPruner: public Pruner
|
||||
{
|
||||
public:
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* gets rid of internal accel struct.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void purge() = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* sets the rebuild hint rate used for step building the accel structure.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void setRebuildRateHint(PxU32 nbStepsForRebuild) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Steps the accel structure build.
|
||||
* synchronousCall specifies if initialization can happen. It should not initialize build when called from a different thread
|
||||
* returns true if finished
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual bool buildStep(bool synchronousCall = true) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Prepares new tree build
|
||||
* returns true if new tree is needed
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual bool prepareBuild() = 0;
|
||||
};
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
// Compound flag to use for static/dynamic filtering atm
|
||||
struct CompoundFlag
|
||||
{
|
||||
enum Enum
|
||||
{
|
||||
STATIC_COMPOUND = (1<<0),
|
||||
DYNAMIC_COMPOUND = (1<<1)
|
||||
};
|
||||
};
|
||||
|
||||
PX_COMPILE_TIME_ASSERT(PxQueryFlag::eSTATIC & CompoundFlag::STATIC_COMPOUND);
|
||||
PX_COMPILE_TIME_ASSERT(PxQueryFlag::eDYNAMIC & CompoundFlag::DYNAMIC_COMPOUND);
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Pruner holding compound objects
|
||||
*/
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
class CompoundPruner: public Ps::UserAllocated
|
||||
{
|
||||
public:
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* \brief Adds compound to the pruner.
|
||||
* \param results [out] an array for resulting handles
|
||||
* \param bvhStructure [in] BVH structure holding bounds and BVH.
|
||||
* \param compoundId [in] compound id
|
||||
* \param transform [in] compound transform
|
||||
* \param userData [in] an array of object data
|
||||
*
|
||||
* \return true if success, false if internal allocation failed. The first failing add results in a INVALID_PRUNERHANDLE.
|
||||
*
|
||||
* Handles are usable as indices. Each handle is either be a recycled handle returned by the client via removeObjects(),
|
||||
* or a fresh handle that is either zero, or one greater than the last fresh handle returned.
|
||||
*
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual bool addCompound(PrunerHandle* results, const Gu::BVHStructure& bvhStructure, PrunerCompoundId compoundId, const PxTransform& transform, CompoundFlag::Enum flags, const PrunerPayload* userData) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Removes compound from the pruner.
|
||||
* \param compoundId [in] compound to remove
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void removeCompound(PrunerCompoundId compoundId) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Updates compound object
|
||||
* \param compoundId [in] compound to update
|
||||
* \param transform [in] compound transformation
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void updateCompound(PrunerCompoundId compoundId, const PxTransform& transform) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Updates object after manually updating their bounds via "getPayload" calls.
|
||||
* \param compoundId [in] compound that the object belongs to
|
||||
* \param handle [in] the object to update
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void updateObjectAfterManualBoundsUpdates(PrunerCompoundId compoundId, const PrunerHandle handle) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Removes object from compound pruner.
|
||||
* \param compoundId [in] compound that the object belongs to
|
||||
* \param handle [in] the object to remove
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual void removeObject(PrunerCompoundId compoundId, const PrunerHandle handle) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* \brief Adds object to the pruner.
|
||||
* \param compoundId [in] compound that the object belongs to
|
||||
* \param result [out] an array for resulting handles
|
||||
* \param bounds [in] an array of bounds. These bounds are used as-is so they should be pre-inflated if inflation is needed.
|
||||
* \param userData [in] an array of object data
|
||||
*
|
||||
* \return true if success, false if internal allocation failed. The first failing add results in a INVALID_PRUNERHANDLE.
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual bool addObject(PrunerCompoundId compoundId, PrunerHandle& result, const PxBounds3& bounds, const PrunerPayload userData) = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Query functions
|
||||
*
|
||||
* Note: return value may disappear if PrunerCallback contains the necessary information
|
||||
* currently it is still used for the dynamic pruner internally (to decide if added objects must be queried)
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual PxAgain raycast(const PxVec3& origin, const PxVec3& unitDir, PxReal& inOutDistance, PrunerCallback&, PxQueryFlags flags) const = 0;
|
||||
virtual PxAgain overlap(const Gu::ShapeData& queryVolume, PrunerCallback&, PxQueryFlags flags) const = 0;
|
||||
virtual PxAgain sweep(const Gu::ShapeData& queryVolume, const PxVec3& unitDir, PxReal& inOutDistance, PrunerCallback&, PxQueryFlags flags) const = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Retrieve the object data associated with the handle
|
||||
*
|
||||
* \param handle [in] The handle returned by addObjects()
|
||||
* \param compoundId [in] The compound id
|
||||
*
|
||||
* \return A reference to the object data
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual const PrunerPayload& getPayload(PrunerHandle handle, PrunerCompoundId compoundId) const = 0;
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Retrieve the object data associated with the handle, plus the destination address for its matrix. The user is then expected to write the new AABB there.
|
||||
*
|
||||
* \param handle [in] The handle returned by addObjects()
|
||||
* \param compoundId [in] The compound id
|
||||
* \param bounds [out] destination address for this object's bounds
|
||||
*
|
||||
* \return A reference to the object data
|
||||
*/
|
||||
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
virtual const PrunerPayload& getPayload(PrunerHandle handle, PrunerCompoundId compoundId, PxBounds3*& bounds) const = 0;
|
||||
|
||||
|
||||
// shift the origin of the pruner objects
|
||||
virtual void shiftOrigin(const PxVec3& shift) = 0;
|
||||
|
||||
virtual ~CompoundPruner() {}
|
||||
|
||||
// additional 'internal' interface
|
||||
virtual void visualize(Cm::RenderOutput&, PxU32) const {}
|
||||
|
||||
};
|
||||
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
/**
|
||||
* Creates AABBPruner
|
||||
*/
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
IncrementalPruner* createAABBPruner(bool incrementalRebuild);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
#endif // SQ_PRUNER_H
|
||||
62
physx/source/scenequery/include/SqPrunerMergeData.h
Normal file
62
physx/source/scenequery/include/SqPrunerMergeData.h
Normal file
@ -0,0 +1,62 @@
|
||||
//
|
||||
// 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) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
|
||||
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
|
||||
|
||||
|
||||
#ifndef SQ_PRUNER_MERGE_DATA
|
||||
#define SQ_PRUNER_MERGE_DATA
|
||||
/** \addtogroup physics
|
||||
@{ */
|
||||
|
||||
#include "CmPhysXCommon.h"
|
||||
|
||||
namespace physx
|
||||
{
|
||||
namespace Sq
|
||||
{
|
||||
class AABBTreeRuntimeNode;
|
||||
|
||||
struct AABBPrunerMergeData
|
||||
{
|
||||
AABBPrunerMergeData(PxU32 nbNodes, const AABBTreeRuntimeNode* nodes, PxU32 nbObjects, const PxU32* indices)
|
||||
: mNbNodes(nbNodes), mAABBTreeNodes(nodes), mNbObjects(nbObjects), mAABBTreeIndices(indices)
|
||||
{
|
||||
}
|
||||
|
||||
PxU32 mNbNodes; // Nb nodes in AABB tree
|
||||
const AABBTreeRuntimeNode* mAABBTreeNodes; // AABB tree runtime nodes
|
||||
PxU32 mNbObjects; // Nb objects in AABB tree
|
||||
const PxU32* mAABBTreeIndices; // AABB tree indices
|
||||
};
|
||||
|
||||
} // namespace Sq
|
||||
|
||||
}
|
||||
|
||||
/** @} */
|
||||
#endif // SQ_PRUNING_STRUCTURE
|
||||
111
physx/source/scenequery/include/SqPruningStructure.h
Normal file
111
physx/source/scenequery/include/SqPruningStructure.h
Normal file
@ -0,0 +1,111 @@
|
||||
//
|
||||
// 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) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
|
||||
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
|
||||
|
||||
|
||||
#ifndef SQ_PRUNING_STRUCTURE
|
||||
#define SQ_PRUNING_STRUCTURE
|
||||
/** \addtogroup physics
|
||||
@{ */
|
||||
|
||||
#include "CmPhysXCommon.h"
|
||||
|
||||
#include "PxPruningStructure.h"
|
||||
|
||||
#include "PsUserAllocated.h"
|
||||
|
||||
namespace physx
|
||||
{
|
||||
namespace Sq
|
||||
{
|
||||
class AABBTreeRuntimeNode;
|
||||
|
||||
struct PruningIndex
|
||||
{
|
||||
enum Enum
|
||||
{
|
||||
eSTATIC = 0,
|
||||
eDYNAMIC = 1,
|
||||
|
||||
eCOUNT = 2
|
||||
};
|
||||
};
|
||||
|
||||
class PruningStructure : public PxPruningStructure, public Ps::UserAllocated
|
||||
{
|
||||
PX_NOCOPY(PruningStructure)
|
||||
public:
|
||||
// PX_SERIALIZATION
|
||||
PruningStructure(PxBaseFlags baseFlags);
|
||||
virtual void resolveReferences(PxDeserializationContext& );
|
||||
static PruningStructure* createObject(PxU8*& address, PxDeserializationContext& context);
|
||||
static void getBinaryMetaData(PxOutputStream& stream);
|
||||
void preExportDataReset() {}
|
||||
void exportExtraData(PxSerializationContext&);
|
||||
void importExtraData(PxDeserializationContext&);
|
||||
virtual void requiresObjects(PxProcessPxBaseCallback&);
|
||||
//~PX_SERIALIZATION
|
||||
|
||||
// PX_PRUNING_STRUCTURE
|
||||
virtual PxU32 getRigidActors(PxRigidActor** userBuffer, PxU32 bufferSize, PxU32 startIndex=0) const;
|
||||
virtual PxU32 getNbRigidActors() const { return mNbActors; }
|
||||
void release();
|
||||
// ~PX_PRUNING_STRUCTURE
|
||||
|
||||
PruningStructure();
|
||||
~PruningStructure();
|
||||
|
||||
bool build(PxRigidActor*const* actors, PxU32 nbActors);
|
||||
|
||||
PX_FORCE_INLINE PxU32 getNbActors() const { return mNbActors; }
|
||||
PX_FORCE_INLINE PxActor*const* getActors() const { return mActors; }
|
||||
|
||||
PX_FORCE_INLINE AABBTreeRuntimeNode* getTreeNodes(PruningIndex::Enum currentTree) const { return mAABBTreeNodes[currentTree]; }
|
||||
PX_FORCE_INLINE PxU32 getTreeNbNodes(PruningIndex::Enum currentTree) const { return mNbNodes[currentTree]; }
|
||||
|
||||
PX_FORCE_INLINE PxU32* getTreeIndices(PruningIndex::Enum currentTree) const { return mAABBTreeIndices[currentTree]; }
|
||||
PX_FORCE_INLINE PxU32 getNbObjects(PruningIndex::Enum currentTree) const { return mNbObjects[currentTree]; }
|
||||
|
||||
PX_FORCE_INLINE bool isValid() const { return mValid; }
|
||||
void invalidate(PxActor* actor);
|
||||
|
||||
private:
|
||||
PxU32 mNbNodes[2]; // Nb nodes in AABB tree
|
||||
AABBTreeRuntimeNode* mAABBTreeNodes[2]; // AABB tree runtime nodes
|
||||
PxU32 mNbObjects[2]; // Nb objects in AABB tree
|
||||
PxU32* mAABBTreeIndices[2]; // AABB tree indices
|
||||
PxU32 mNbActors; // Nb actors from which the pruner structure was build
|
||||
PxActor** mActors; // actors used for pruner structure build, used later for serialization
|
||||
bool mValid; // pruning structure validity
|
||||
};
|
||||
} // namespace Sq
|
||||
|
||||
}
|
||||
|
||||
/** @} */
|
||||
#endif // SQ_PRUNING_STRUCTURE
|
||||
221
physx/source/scenequery/include/SqSceneQueryManager.h
Normal file
221
physx/source/scenequery/include/SqSceneQueryManager.h
Normal file
@ -0,0 +1,221 @@
|
||||
//
|
||||
// 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) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
|
||||
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
|
||||
|
||||
|
||||
#ifndef PX_PHYSICS_SCENEQUERYMANAGER
|
||||
#define PX_PHYSICS_SCENEQUERYMANAGER
|
||||
/** \addtogroup physics
|
||||
@{ */
|
||||
|
||||
#include "PxSceneDesc.h"
|
||||
#include "CmBitMap.h"
|
||||
#include "PsArray.h"
|
||||
#include "SqPruner.h"
|
||||
#include "PsMutex.h"
|
||||
#include "PxActor.h" // needed for offset table
|
||||
#include "ScScene.h"
|
||||
// threading
|
||||
#include "PsSync.h"
|
||||
|
||||
namespace physx
|
||||
{
|
||||
namespace Scb
|
||||
{
|
||||
class Scene;
|
||||
class Shape;
|
||||
class Actor;
|
||||
}
|
||||
|
||||
namespace Gu
|
||||
{
|
||||
class BVHStructure;
|
||||
}
|
||||
|
||||
namespace Sq
|
||||
{
|
||||
typedef size_t PrunerData;
|
||||
#define SQ_INVALID_PRUNER_DATA 0xffffffff
|
||||
|
||||
struct PrunerPayload;
|
||||
class Pruner;
|
||||
class CompoundPruner;
|
||||
|
||||
// PT: extended pruner structure. We might want to move the additional data to the pruner itself later.
|
||||
struct PrunerExt
|
||||
{
|
||||
PrunerExt();
|
||||
~PrunerExt();
|
||||
|
||||
void init(PxPruningStructureType::Enum type, PxU64 contextID, PxU32 sceneLimit);
|
||||
void flushMemory();
|
||||
void preallocate(PxU32 nbShapes);
|
||||
void flushShapes(PxU32 index);
|
||||
|
||||
void addToDirtyList(PrunerHandle handle);
|
||||
Ps::IntBool isDirty(PrunerHandle handle) const;
|
||||
void removeFromDirtyList(PrunerHandle handle);
|
||||
void growDirtyList(PrunerHandle handle);
|
||||
|
||||
PX_FORCE_INLINE PxPruningStructureType::Enum type() const { return mPrunerType; }
|
||||
PX_FORCE_INLINE const Pruner* pruner() const { return mPruner; }
|
||||
PX_FORCE_INLINE Pruner* pruner() { return mPruner; }
|
||||
PX_FORCE_INLINE PxU32 timestamp() const { return mTimestamp; }
|
||||
PX_FORCE_INLINE void invalidateTimestamp() { mTimestamp++; }
|
||||
|
||||
private:
|
||||
Pruner* mPruner;
|
||||
Cm::BitMap mDirtyMap;
|
||||
Ps::Array<PrunerHandle> mDirtyList;
|
||||
PxPruningStructureType::Enum mPrunerType;
|
||||
PxU32 mTimestamp;
|
||||
|
||||
PX_NOCOPY(PrunerExt)
|
||||
|
||||
friend class SceneQueryManager;
|
||||
};
|
||||
|
||||
typedef Ps::Pair<PrunerCompoundId, PrunerHandle> CompoundPair;
|
||||
typedef Ps::CoalescedHashSet<CompoundPair > CompoundPrunerSet;
|
||||
// AB: extended compoud pruner structure, buffers compound shape changes and flushes them.
|
||||
struct CompoundPrunerExt
|
||||
{
|
||||
CompoundPrunerExt();
|
||||
~CompoundPrunerExt();
|
||||
|
||||
void flushMemory();
|
||||
void preallocate(PxU32 nbShapes);
|
||||
void flushShapes();
|
||||
|
||||
void addToDirtyList(PrunerCompoundId compoundId, PrunerHandle handle);
|
||||
Ps::IntBool isDirty(PrunerCompoundId compoundId, PrunerHandle handle) const;
|
||||
void removeFromDirtyList(PrunerCompoundId compoundId, PrunerHandle handle);
|
||||
|
||||
PX_FORCE_INLINE const CompoundPruner* pruner() const { return mPruner; }
|
||||
PX_FORCE_INLINE CompoundPruner* pruner() { return mPruner; }
|
||||
|
||||
private:
|
||||
CompoundPruner* mPruner;
|
||||
CompoundPrunerSet mDirtyList;
|
||||
|
||||
PX_NOCOPY(CompoundPrunerExt)
|
||||
|
||||
friend class SceneQueryManager;
|
||||
};
|
||||
|
||||
|
||||
struct DynamicBoundsSync : public Sc::SqBoundsSync
|
||||
{
|
||||
virtual void sync(const PrunerHandle* handles, const PxU32* indices, const PxBounds3* bounds, PxU32 count, const Cm::BitMap& dirtyShapeSimMap);
|
||||
|
||||
Pruner* mPruner;
|
||||
PxU32* mTimestamp;
|
||||
};
|
||||
|
||||
class SceneQueryManager : public Ps::UserAllocated
|
||||
{
|
||||
PX_NOCOPY(SceneQueryManager)
|
||||
public:
|
||||
SceneQueryManager(Scb::Scene& scene, PxPruningStructureType::Enum staticStructure,
|
||||
PxPruningStructureType::Enum dynamicStructure, PxU32 dynamicTreeRebuildRateHint,
|
||||
const PxSceneLimits& limits);
|
||||
~SceneQueryManager();
|
||||
|
||||
PrunerData addPrunerShape(const Scb::Shape& scbShape, const Scb::Actor& scbActor, bool dynamic, PrunerCompoundId compoundId, const PxBounds3* bounds=NULL, bool hasPrunerStructure = false);
|
||||
void removePrunerShape(PrunerCompoundId compoundId, PrunerData shapeData);
|
||||
const PrunerPayload& getPayload(PrunerCompoundId compoundId, PrunerData shapeData) const;
|
||||
|
||||
void addPruningStructure(const Sq::PruningStructure& ps);
|
||||
void addCompoundShape(const Gu::BVHStructure& bvhStructure, PrunerCompoundId compoundId, const PxTransform& compoundTransform, PrunerData* prunerData, const Scb::Shape** scbShapes, const Scb::Actor& scbActor);
|
||||
|
||||
public:
|
||||
PX_FORCE_INLINE Scb::Scene& getScene() const { return mScene; }
|
||||
PX_FORCE_INLINE PxU32 getDynamicTreeRebuildRateHint() const { return mRebuildRateHint; }
|
||||
|
||||
PX_FORCE_INLINE const PrunerExt& get(PruningIndex::Enum index) const { return mPrunerExt[index]; }
|
||||
PX_FORCE_INLINE PrunerExt& get(PruningIndex::Enum index) { return mPrunerExt[index]; }
|
||||
|
||||
PX_FORCE_INLINE const CompoundPrunerExt& getCompoundPruner() const { return mCompoundPrunerExt; }
|
||||
|
||||
void preallocate(PxU32 staticShapes, PxU32 dynamicShapes);
|
||||
void markForUpdate(PrunerCompoundId compoundId, PrunerData s);
|
||||
void setDynamicTreeRebuildRateHint(PxU32 dynTreeRebuildRateHint);
|
||||
|
||||
void flushUpdates();
|
||||
void forceDynamicTreeRebuild(bool rebuildStaticStructure, bool rebuildDynamicStructure);
|
||||
void sceneQueryBuildStep(PruningIndex::Enum index);
|
||||
|
||||
void updateCompoundActors(Sc::BodyCore*const* bodies, PxU32 numBodies);
|
||||
void updateCompoundActor(PrunerCompoundId compoundId, const PxTransform& compoundTransform, bool dynamic);
|
||||
void removeCompoundActor(PrunerCompoundId compoundId, bool dynamic);
|
||||
|
||||
DynamicBoundsSync& getDynamicBoundsSync() { return mDynamicBoundsSync; }
|
||||
|
||||
bool prepareSceneQueriesUpdate(PruningIndex::Enum index);
|
||||
|
||||
// Force a rebuild of the aabb/loose octree etc to allow raycasting on multiple threads.
|
||||
void afterSync(PxSceneQueryUpdateMode::Enum updateMode);
|
||||
void shiftOrigin(const PxVec3& shift);
|
||||
|
||||
void flushMemory();
|
||||
private:
|
||||
PrunerExt mPrunerExt[PruningIndex::eCOUNT];
|
||||
CompoundPrunerExt mCompoundPrunerExt;
|
||||
|
||||
PxU32 mRebuildRateHint;
|
||||
|
||||
Scb::Scene& mScene;
|
||||
|
||||
// threading
|
||||
shdfnd::Mutex mSceneQueryLock; // to make sure only one query updates the dirty pruner structure if multiple queries run in parallel
|
||||
|
||||
DynamicBoundsSync mDynamicBoundsSync;
|
||||
|
||||
volatile bool mPrunerNeedsUpdating;
|
||||
|
||||
void flushShapes();
|
||||
};
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// PT: TODO: replace PrunerData with just PxU32 to save memory on Win64. Breaks binary compatibility though.
|
||||
// PT: was previously called 'ActorShape' but does not contain an actor or shape pointer, contrary to the Np-level struct with the same name.
|
||||
// PT: it only contains a pruner index (0 or 1) and a pruner handle. Hence the new name.
|
||||
PX_FORCE_INLINE PrunerData createPrunerData(PxU32 index, PrunerHandle h) { return PrunerData((h << 1) | index); }
|
||||
PX_FORCE_INLINE PxU32 getPrunerIndex(PrunerData data) { return PxU32(data & 1); }
|
||||
PX_FORCE_INLINE PrunerHandle getPrunerHandle(PrunerData data) { return PrunerHandle(data >> 1); }
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
|
||||
} // namespace Sq
|
||||
|
||||
}
|
||||
|
||||
/** @} */
|
||||
#endif
|
||||
Reference in New Issue
Block a user