Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

4 files changed, 612 insertions, 0 deletions

diff --git a/PhysX_3.4/Source/SceneQuery/include/SqPruner.h b/PhysX_3.4/Source/SceneQuery/include/SqPruner.h
new file mode 100644
index 00000000..8a8bcbfa
--- /dev/null
+++ b/PhysX_3.4/Source/SceneQuery/include/SqPruner.h
@@ -0,0 +1,246 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2016 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 "PxGeometry.h"
+#include "PxQueryReport.h"
+#include "PsUserAllocated.h"
+#include "SqPruningStructure.h"
+#include "GuSphere.h"
+#include "GuBox.h"
+#include "GuCapsule.h"
+
+namespace physx
+{	
+	namespace Gu
+	{
+		class ShapeData;
+	}
+}
+
+namespace physx
+{	
+	namespace Cm
+	{
+		class RenderOutput;
+	}
+
+namespace Sq
+{
+
+typedef PxU32 PrunerHandle;
+
+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
+	 *  \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 = 1, bool hasPruningStructure = false) = 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 = 1) = 0;
+
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	/**
+	 *	Updates objects with new bounds.
+	 *	\param		handles		[in]	the objects to update
+	 *  \param		newBounds	[in]	updated bounds. Can be NULL if bounds have been written already through getPayload calls.
+	 *  \param		count		[in]	the number of objects to update
+	 */
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	virtual void						updateObjects(const PrunerHandle* handles, const PxBounds3* newBounds, PxU32 count = 1) = 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
+	*/
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	virtual void						updateObjects(const PrunerHandle* handles, const PxU32* indices, const PxBounds3* newBounds, PxU32 count = 1) = 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.
+	 * returns true if finished
+	 */
+	///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+	virtual bool						buildStep() = 0;	
+};
+
+//////////////////////////////////////////////////////////////////////////
+/**
+*	Creates AABBPruner
+*/
+//////////////////////////////////////////////////////////////////////////
+IncrementalPruner* createAABBPruner(bool incrementalRebuild);
+
+}
+
+}
+
+#endif // SQ_PRUNER_H
diff --git a/PhysX_3.4/Source/SceneQuery/include/SqPrunerMergeData.h b/PhysX_3.4/Source/SceneQuery/include/SqPrunerMergeData.h
new file mode 100644
index 00000000..d7744362
--- /dev/null
+++ b/PhysX_3.4/Source/SceneQuery/include/SqPrunerMergeData.h
@@ -0,0 +1,62 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2016 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
diff --git a/PhysX_3.4/Source/SceneQuery/include/SqPruningStructure.h b/PhysX_3.4/Source/SceneQuery/include/SqPruningStructure.h
new file mode 100644
index 00000000..424597e5
--- /dev/null
+++ b/PhysX_3.4/Source/SceneQuery/include/SqPruningStructure.h
@@ -0,0 +1,110 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2016 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									exportExtraData(PxSerializationContext&);
+			void									importExtraData(PxDeserializationContext&);
+			virtual			void					requires(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
diff --git a/PhysX_3.4/Source/SceneQuery/include/SqSceneQueryManager.h b/PhysX_3.4/Source/SceneQuery/include/SqSceneQueryManager.h
new file mode 100644
index 00000000..4315a7fc
--- /dev/null
+++ b/PhysX_3.4/Source/SceneQuery/include/SqSceneQueryManager.h
@@ -0,0 +1,194 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2016 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 "ScbActor.h" // needed for offset table
+// threading
+#include "PsSync.h"
+
+namespace physx
+{
+
+class PxRigidActor;
+class NpShape;
+class NpBatchQuery;
+
+namespace Scb
+{
+	class Scene;
+	class Shape;
+}
+
+namespace Sc
+{
+	class ActorCore;
+	struct SqBoundsSync;
+}
+
+namespace Sq
+{
+	typedef size_t PrunerData;
+	#define SQ_INVALID_PRUNER_DATA	0xffffffff
+
+	struct ActorShape;
+	struct PrunerPayload;
+	class Pruner;
+
+	struct OffsetTable
+	{
+		PX_FORCE_INLINE	OffsetTable() {}
+		PX_FORCE_INLINE const Scb::Actor&		convertPxActor2Scb(const PxActor& actor) const		{ return *Ps::pointerOffset<const Scb::Actor*>(&actor, pxActorToScbActor[actor.getConcreteType()]); }
+		PX_FORCE_INLINE const Sc::ActorCore&	convertScbActor2Sc(const Scb::Actor& actor) const	{ return *Ps::pointerOffset<const Sc::ActorCore*>(&actor, scbToSc[actor.getScbType()]); }
+
+		ptrdiff_t pxActorToScbActor[PxConcreteType::ePHYSX_CORE_COUNT];
+		ptrdiff_t scbToSc[ScbType::TYPE_COUNT];
+	};
+	extern OffsetTable gOffsetTable;
+
+	// 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);
+						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;
+	};
+
+	struct DynamicBoundsSync : public Sc::SqBoundsSync
+	{
+		virtual void sync(const PxU32* sqRefs, const PxU32* indices, const PxBounds3* bounds, PxU32 count);
+		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 NpShape& shape, const PxRigidActor& actor, bool dynamic, const PxBounds3* bounds=NULL, bool hasPrunerStructure = false);
+						void							removePrunerShape(PrunerData shapeData);
+						const PrunerPayload&			getPayload(PrunerData shapeData) const;
+
+	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];	}
+
+						void							preallocate(PxU32 staticShapes, PxU32 dynamicShapes);
+						void							markForUpdate(PrunerData s);
+						void							setDynamicTreeRebuildRateHint(PxU32 dynTreeRebuildRateHint);
+						
+						void							flushUpdates();
+						void							forceDynamicTreeRebuild(bool rebuildStaticStructure, bool rebuildDynamicStructure);
+
+						DynamicBoundsSync&				getDynamicBoundsSync()					{ return mDynamicBoundsSync; }
+
+		// Force a rebuild of the aabb/loose octree etc to allow raycasting on multiple threads.
+						void							processSimUpdates();
+						void							validateSimUpdates();
+						void							afterSync(bool commit);
+						void							shiftOrigin(const PxVec3& shift);
+
+						void							flushMemory();
+	private:
+						PrunerExt						mPrunerExt[PruningIndex::eCOUNT];
+
+						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;
+
+						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 size_t((h << 1) | index); }
+	PX_FORCE_INLINE PxU32 getPrunerIndex(PrunerData data)					{ return PxU32(data & 1); }
+	PX_FORCE_INLINE PrunerHandle getPrunerHandle(PrunerData data)			{ return PxU32(data >> 1); }
+
+	///////////////////////////////////////////////////////////////////////////////
+
+
+} // namespace Sq
+
+}
+
+/** @} */
+#endif