// // 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 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