Revision control
Copy as Markdown
// Copyright (c) 2001-2004 NovodeX AG. All rights reserved.
// Copyright (c) 2004-2008 AGEIA Technologies, Inc. All rights reserved.
// SPDX-FileCopyrightText: Copyright (c) 2008-2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
#ifndef NP_PVD_SCENEQUERYCOLLECTOR_H
#define NP_PVD_SCENEQUERYCOLLECTOR_H
#include "geometry/PxGeometryHelpers.h"
#include "PxFiltering.h"
#include "PxQueryReport.h"
#include "PxQueryFiltering.h"
#include "foundation/PxArray.h"
#include "foundation/PxMutex.h"
#if PX_SUPPORT_PVD
namespace physx
{
namespace Vd
{
class PvdSceneClient;
struct QueryID { enum Enum {
QUERY_RAYCAST_ANY_OBJECT,
QUERY_RAYCAST_CLOSEST_OBJECT,
QUERY_RAYCAST_ALL_OBJECTS,
QUERY_OVERLAP_SPHERE_ALL_OBJECTS,
QUERY_OVERLAP_AABB_ALL_OBJECTS,
QUERY_OVERLAP_OBB_ALL_OBJECTS,
QUERY_OVERLAP_CAPSULE_ALL_OBJECTS,
QUERY_OVERLAP_CONVEX_ALL_OBJECTS,
QUERY_LINEAR_OBB_SWEEP_CLOSEST_OBJECT,
QUERY_LINEAR_CAPSULE_SWEEP_CLOSEST_OBJECT,
QUERY_LINEAR_CONVEX_SWEEP_CLOSEST_OBJECT
}; };
struct PvdReference
{
PX_FORCE_INLINE PvdReference() {}
PX_FORCE_INLINE PvdReference(const char* arrayName, PxU32 baseIndex, PxU32 count) : mArrayName(arrayName), mBaseIndex(baseIndex), mCount(count) {}
const char* mArrayName;
PxU32 mBaseIndex;
PxU32 mCount;
};
struct PvdRaycast
{
PxU32 mType;
PxFilterData mFilterData;
PxU32 mFilterFlags;
PxVec3 mOrigin;
PxVec3 mUnitDir;
PxReal mDistance;
PvdReference mHits;
};
struct PvdOverlap
{
PxU32 mType;
PxFilterData mFilterData;
PxU32 mFilterFlags;
PxTransform mPose;
PvdReference mGeometries;
PvdReference mHits;
};
struct PvdSweep
{
PxU32 mType;
PxU32 mFilterFlags;
PxVec3 mUnitDir;
PxReal mDistance;
PvdReference mGeometries;
PvdReference mPoses;
PvdReference mFilterData;
PvdReference mHits;
};
struct PvdSqHit
{
const void* mShape;
const void* mActor;
PxU32 mFaceIndex;
PxU32 mFlags;
PxVec3 mImpact;
PxVec3 mNormal;
PxF32 mDistance;
PxF32 mU;
PxF32 mV;
PvdSqHit()
{
setDefaults(0xFFFFffff, NULL, NULL);
}
explicit PvdSqHit(const PxOverlapHit& hit)
{
setDefaults(hit.faceIndex, hit.shape, hit.actor);
}
explicit PvdSqHit(const PxRaycastHit& hit)
{
setDefaults(hit.faceIndex, hit.shape, hit.actor);
mImpact = hit.position;
mNormal = hit.normal;
mDistance = hit.distance;
mFlags = hit.flags;
mU = hit.u;
mV = hit.v;
}
explicit PvdSqHit(const PxSweepHit& hit)
{
setDefaults(hit.faceIndex, hit.shape, hit.actor);
mImpact = hit.position;
mNormal = hit.normal;
mDistance = hit.distance;
mFlags = hit.flags;
}
private:
void setDefaults(PxU32 faceIndex, const void* shape, const void* actor)
{
mShape = shape;
mActor = actor;
mFaceIndex = faceIndex;
mFlags = 0;
mImpact = mNormal = PxVec3(0.0f);
mDistance = mU = mV = 0.0f;
}
};
template <class T>
class NamedArray : public PxArray<T>
{
public:
NamedArray(const char* names[2]) { mNames[0] = names[0]; mNames[1] = names[1]; }
const char* mNames[2];
};
class PvdSceneQueryCollector
{
PX_NOCOPY(PvdSceneQueryCollector)
public:
PvdSceneQueryCollector(Vd::PvdSceneClient* pvd, bool isBatched);
~PvdSceneQueryCollector() {}
void clear()
{
PxMutex::ScopedLock lock(mMutex);
mAccumulatedRaycastQueries.clear();
mAccumulatedOverlapQueries.clear();
mAccumulatedSweepQueries.clear();
mPvdSqHits.clear();
mPoses.clear();
mFilterData.clear();
}
void clearGeometryArrays()
{
mGeometries0.clear();
mGeometries1.clear();
}
void release();
void raycast(const PxVec3& origin, const PxVec3& unitDir, PxReal distance, const PxRaycastHit* hit, PxU32 hitsNum, const PxQueryFilterData& filterData, bool multipleHits);
void sweep(const PxGeometry& geometry, const PxTransform& pose, const PxVec3& unitDir, PxReal distance, const PxSweepHit* hit, PxU32 hitsNum, const PxQueryFilterData& filterData, bool multipleHits);
void overlapMultiple(const PxGeometry& geometry, const PxTransform& pose, const PxOverlapHit* hit, PxU32 hitsNum, const PxQueryFilterData& filterData);
PX_FORCE_INLINE PxMutex& getLock() { return mMutex; }
template <class T>
PX_FORCE_INLINE const char* getArrayName(const NamedArray<T>& namedArray) const { return namedArray.mNames[mIsBatched]; }
PX_FORCE_INLINE const NamedArray<PxGeometryHolder>& getGeometries(PxU32 index) const { return index ? mGeometries1 : mGeometries0; }
PX_FORCE_INLINE NamedArray<PxGeometryHolder>& getGeometries(PxU32 index) { return index ? mGeometries1 : mGeometries0; }
PX_FORCE_INLINE const NamedArray<PxGeometryHolder>& getCurrentFrameGeometries() const { return getGeometries(mInUse); }
PX_FORCE_INLINE const NamedArray<PxGeometryHolder>& getPrevFrameGeometries() const { return getGeometries(mInUse ^ 1); }
void prepareNextFrameGeometries()
{
mInUse ^= 1;
getGeometries(mInUse).clear();
}
NamedArray<PvdRaycast> mAccumulatedRaycastQueries;
NamedArray<PvdSweep> mAccumulatedSweepQueries;
NamedArray<PvdOverlap> mAccumulatedOverlapQueries;
NamedArray<PvdSqHit> mPvdSqHits;
NamedArray<PxTransform> mPoses;
NamedArray<PxFilterData> mFilterData;
private:
Vd::PvdSceneClient* mPVD;
PxMutex mMutex;
NamedArray<PxGeometryHolder>mGeometries0;
NamedArray<PxGeometryHolder>mGeometries1;
PxU32 mInUse;
const bool mIsBatched;
};
}
}
#endif // PX_SUPPORT_PVD
#endif // NP_PVD_SCENEQUERYCOLLECTOR_H