Init

physx/source/lowlevel/api/include/PxsMaterialCore.h

@@ -0,0 +1,127 @@
+//
+// 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 PXS_MATERIAL_H
+#define PXS_MATERIAL_H
+
+#include "foundation/PxVec3.h"
+#include "common/PxMetaData.h"
+#include "PxMaterial.h"
+#include "PsUserAllocated.h"
+#include "PsUtilities.h"
+#include "CmPhysXCommon.h"
+#include "CmUtils.h"
+
+namespace physx
+{
+
+#define	MATERIAL_INVALID_HANDLE	0xffff
+
+	PX_ALIGN_PREFIX(16) struct PxsMaterialData 
+	{
+		PxReal					dynamicFriction;				//4
+		PxReal					staticFriction;					//8
+		PxReal					restitution;					//12
+		PxMaterialFlags			flags;							//14
+		PxU8					fricRestCombineMode;			//15
+		PxU8					padding;						//16
+
+		PxsMaterialData()
+		:	dynamicFriction(0.0f)
+		,	staticFriction(0.0f)
+		,	restitution(0.0f)
+		,	fricRestCombineMode((PxCombineMode::eAVERAGE << 4) | PxCombineMode::eAVERAGE)
+		,	padding(PX_PADDING_8)
+		{}
+
+		PxsMaterialData(const PxEMPTY) {}
+
+		PX_CUDA_CALLABLE PX_FORCE_INLINE PxCombineMode::Enum getFrictionCombineMode() const
+		{
+			return PxCombineMode::Enum(fricRestCombineMode >> 4);
+		}
+
+		PX_CUDA_CALLABLE PX_FORCE_INLINE PxCombineMode::Enum getRestitutionCombineMode() const
+		{
+			return PxCombineMode::Enum(fricRestCombineMode & 0xf);
+		}
+
+		PX_FORCE_INLINE void setFrictionCombineMode(PxCombineMode::Enum frictionFlags)
+		{
+			fricRestCombineMode = Ps::to8((fricRestCombineMode & 0xf) | (frictionFlags << 4));
+		}
+
+		PX_FORCE_INLINE void setRestitutionCombineMode(PxCombineMode::Enum restitutionFlags)
+		{
+			fricRestCombineMode = Ps::to8((fricRestCombineMode & 0xf0) | (restitutionFlags));
+		}
+
+	}PX_ALIGN_SUFFIX(16);
+
+
+	class PxsMaterialCore : public PxsMaterialData, public Ps::UserAllocated
+	{
+	public:
+					
+											PxsMaterialCore(const PxsMaterialData& desc)
+											:	PxsMaterialData(desc)
+											,	mNxMaterial(0)
+											,	mMaterialIndex(MATERIAL_INVALID_HANDLE)
+											,	mPadding(PX_PADDING_16)
+											{
+											}
+
+											PxsMaterialCore()
+											:	mNxMaterial(0)
+											,	mMaterialIndex(MATERIAL_INVALID_HANDLE)
+											,	mPadding(PX_PADDING_16)
+											{
+											}
+
+											PxsMaterialCore(const PxEMPTY) : PxsMaterialData(PxEmpty) {}
+
+											~PxsMaterialCore()
+											{
+											}
+
+	PX_FORCE_INLINE	void					setNxMaterial(PxMaterial* m)					{ mNxMaterial = m;		}
+	PX_FORCE_INLINE	PxMaterial*				getNxMaterial()					const			{ return mNxMaterial;	}
+	PX_FORCE_INLINE	void					setMaterialIndex(const PxU16 materialIndex)		{ mMaterialIndex = materialIndex; }
+	PX_FORCE_INLINE	PxU16					getMaterialIndex()				const			{ return mMaterialIndex; }
+
+	protected:
+					PxMaterial*				mNxMaterial;
+					PxU16					mMaterialIndex; //handle assign by the handle manager
+					PxU16					mPadding;
+	};
+
+} //namespace phyxs
+
+#endif

physx/source/lowlevel/api/include/PxsMaterialManager.h

@@ -0,0 +1,149 @@
+//
+// 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 PXS_MATERIALMANAGER
+#define PXS_MATERIALMANAGER
+
+#include "PxsMaterialCore.h"
+#include "PsAlignedMalloc.h"
+
+namespace physx
+{
+	struct PxsMaterialInfo
+	{
+		PxU16 mMaterialIndex0;
+		PxU16 mMaterialIndex1;
+	};
+
+	class PxsMaterialManager 
+	{
+	public:
+		PxsMaterialManager()
+		{
+			const PxU32 matCount = 128;
+			materials = reinterpret_cast<PxsMaterialCore*>(physx::shdfnd::AlignedAllocator<16>().allocate(sizeof(PxsMaterialCore)*matCount,  __FILE__, __LINE__));
+			maxMaterials = matCount;
+			for(PxU32 i=0; i<matCount; ++i)
+			{
+				materials[i].setMaterialIndex(MATERIAL_INVALID_HANDLE);
+			}
+		}
+
+		~PxsMaterialManager()
+		{
+			physx::shdfnd::AlignedAllocator<16>().deallocate(materials);
+		}
+
+		void setMaterial(PxsMaterialCore* mat)
+		{
+			const PxU16 materialIndex = mat->getMaterialIndex();
+			resize(PxU32(materialIndex) + 1);
+			materials[materialIndex] = *mat;
+		}
+
+		void updateMaterial(PxsMaterialCore* mat)
+		{
+			materials[mat->getMaterialIndex()] =*mat;
+		}
+
+		void removeMaterial(PxsMaterialCore* mat)
+		{
+			mat->setMaterialIndex(MATERIAL_INVALID_HANDLE);
+		}
+
+		PX_FORCE_INLINE PxsMaterialCore* getMaterial(const PxU32 index)const
+		{
+			PX_ASSERT(index <  maxMaterials);
+			return &materials[index];
+		}
+
+		PxU32 getMaxSize()const 
+		{
+			return maxMaterials;
+		}
+
+		void resize(PxU32 minValueForMax)
+		{			
+			if(maxMaterials>=minValueForMax)
+				return;
+
+			const PxU32 numMaterials = maxMaterials;
+			
+			maxMaterials = (minValueForMax+31)&~31;
+			PxsMaterialCore* mat = reinterpret_cast<PxsMaterialCore*>(physx::shdfnd::AlignedAllocator<16>().allocate(sizeof(PxsMaterialCore)*maxMaterials,  __FILE__, __LINE__));
+			for(PxU32 i=0; i<numMaterials; ++i)
+			{
+				mat[i] = materials[i];
+			}
+			for(PxU32 i = numMaterials; i < maxMaterials; ++i)
+			{
+				mat[i].setMaterialIndex(MATERIAL_INVALID_HANDLE);
+			}
+
+			physx::shdfnd::AlignedAllocator<16>().deallocate(materials);
+
+			materials = mat;
+		}
+
+		PxsMaterialCore* materials;//make sure materials's start address is 16 bytes align
+		PxU32 maxMaterials;
+		PxU32 mPad[2];
+	};
+
+	class PxsMaterialManagerIterator
+	{
+	
+	public:
+		PxsMaterialManagerIterator(PxsMaterialManager& manager) : mManager(manager), mIndex(0)
+		{
+		}
+
+		bool getNextMaterial(PxsMaterialCore*& materialCore)
+		{
+			const PxU32 maxSize = mManager.getMaxSize();
+			PxU32 index = mIndex;
+			while(index < maxSize && mManager.getMaterial(index)->getMaterialIndex() == MATERIAL_INVALID_HANDLE)
+				index++;
+			materialCore = NULL;
+			if(index < maxSize)
+				materialCore = mManager.getMaterial(index++);
+			mIndex = index;
+			return materialCore!=NULL;
+		}
+
+	private:
+		PxsMaterialManagerIterator& operator=(const PxsMaterialManagerIterator&);
+		PxsMaterialManager&	mManager;
+		PxU32				mIndex;
+	};
+
+}
+
+#endif

physx/source/lowlevel/api/include/PxvConfig.h

@@ -0,0 +1,47 @@
+//
+// 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 PXD_CONFIG_H
+#define PXD_CONFIG_H
+
+/*! \file internal top level include file for lowlevel. */
+
+#include "CmPhysXCommon.h"
+#include "PxPhysXConfig.h"
+
+/************************************************************************/
+/* Compiler workarounds                                                 */
+/************************************************************************/
+#if PX_VC
+#pragma warning(disable: 4355 )	// "this" used in base member initializer list
+#pragma warning(disable: 4146 ) // unary minus operator applied to unsigned type.
+#endif
+
+#endif

physx/source/lowlevel/api/include/PxvDynamics.h

@@ -0,0 +1,183 @@
+//
+// 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 PXV_DYNAMICS_H
+#define PXV_DYNAMICS_H
+
+#include "foundation/PxVec3.h"
+#include "foundation/PxQuat.h"
+#include "foundation/PxTransform.h"
+#include "foundation/PxSimpleTypes.h"
+#include "PsIntrinsics.h"
+#include "PxRigidDynamic.h"
+
+namespace physx
+{
+
+/*!
+\file
+Dynamics interface.
+*/
+
+struct PxsRigidCore
+{
+//= ATTENTION! =====================================================================================
+// Changing the data layout of this class breaks the binary serialization format.  See comments for 
+// PX_BINARY_SERIAL_VERSION.  If a modification is required, please adjust the getBinaryMetaData 
+// function.  If the modification is made on a custom branch, please change PX_BINARY_SERIAL_VERSION
+// accordingly.
+//==================================================================================================
+
+	PxsRigidCore() : mFlags(0), solverIterationCounts(0)	{}
+	PxsRigidCore(const PxEMPTY) : mFlags(PxEmpty)			{}
+
+	PX_ALIGN_PREFIX(16)
+	PxTransform			body2World PX_ALIGN_SUFFIX(16);
+	PxRigidBodyFlags	mFlags;					// API body flags
+	PxU16				solverIterationCounts;	// vel iters are in low word and pos iters in high word.
+
+	PX_FORCE_INLINE	PxU32 isKinematic()			const	{ return mFlags & PxRigidBodyFlag::eKINEMATIC;				}
+	PX_FORCE_INLINE PxU32 hasCCD()				const	{ return mFlags & PxRigidBodyFlag::eENABLE_CCD;				}
+	PX_FORCE_INLINE	PxU32 hasCCDFriction()		const	{ return mFlags & PxRigidBodyFlag::eENABLE_CCD_FRICTION;	}
+	PX_FORCE_INLINE	PxU32 hasIdtBody2Actor()	const	{ return mFlags & PxRigidBodyFlag::eRESERVED;				}
+};
+PX_COMPILE_TIME_ASSERT(sizeof(PxsRigidCore) == 32);
+
+struct PxsBodyCore: public PxsRigidCore
+{
+//= ATTENTION! =====================================================================================
+// Changing the data layout of this class breaks the binary serialization format.  See comments for 
+// PX_BINARY_SERIAL_VERSION.  If a modification is required, please adjust the getBinaryMetaData 
+// function.  If the modification is made on a custom branch, please change PX_BINARY_SERIAL_VERSION
+// accordingly.
+//==================================================================================================
+
+	PxsBodyCore() : PxsRigidCore() { kinematicLink = PxU8(0); }
+	PxsBodyCore(const PxEMPTY) : PxsRigidCore(PxEmpty)		{}
+
+	PX_FORCE_INLINE	const PxTransform& getBody2Actor()	const	{ return body2Actor;	}
+	PX_FORCE_INLINE	void setBody2Actor(const PxTransform& t)
+	{
+		if(t.p.isZero() && t.q.isIdentity())
+			mFlags |= PxRigidBodyFlag::eRESERVED;
+		else
+			mFlags.clear(PxRigidBodyFlag::eRESERVED);
+
+		body2Actor = t;
+	}
+	protected:
+	PxTransform				body2Actor;
+	public:
+	PxReal					ccdAdvanceCoefficient;	//64
+
+	PxVec3					linearVelocity;
+	PxReal					maxPenBias;
+
+	PxVec3					angularVelocity;
+	PxReal					contactReportThreshold;	//96
+    
+	PxReal					maxAngularVelocitySq;
+	PxReal					maxLinearVelocitySq;
+	PxReal					linearDamping;
+	PxReal					angularDamping;			//112
+
+	PxVec3					inverseInertia;
+	PxReal					inverseMass;			//128
+	
+	PxReal					maxContactImpulse;			
+	PxReal					sleepThreshold;				   
+	PxReal					freezeThreshold;			
+	PxReal					wakeCounter;			//144 this is authoritative wakeCounter
+
+	PxReal					solverWakeCounter;		//this is calculated by the solver when it performs sleepCheck. It is committed to wakeCounter in ScAfterIntegrationTask if the body is still awake.
+	PxU32					numCountedInteractions;
+	PxU32					numBodyInteractions;	//Used by adaptive force to keep track of the total number of body interactions
+	PxU8					isFastMoving;			//This could be a single bit but it's a u8 at the moment for simplicity's sake
+	PxU8					disableGravity;			//This could be a single bit but it's a u8 at the moment for simplicity's sake
+	PxRigidDynamicLockFlags	lockFlags;				//This is u8. 
+	PxU8					kinematicLink;			//160 This indicates whether the articulation link is kinematic link. All fits into 16 byte alignment
+	
+													// PT: TODO: revisit this / move to PxsCCD.cpp
+	PX_FORCE_INLINE	bool	shouldCreateContactReports()	const
+	{
+		const PxU32* binary = reinterpret_cast<const PxU32*>(&contactReportThreshold);
+		return *binary != 0x7f7fffff;	// PX_MAX_REAL
+	}
+
+	// PT: moved from Sc::BodyCore ctor - we don't want to duplicate all this in immediate mode
+	PX_FORCE_INLINE	void	init(	const PxTransform& bodyPose,
+									const PxVec3& inverseInertia_, PxReal inverseMass_,
+									PxReal wakeCounter_, PxReal scaleSpeed,
+									PxReal linearDamping_, PxReal angularDamping_,
+									PxReal maxLinearVelocitySq_, PxReal maxAngularVelocitySq_)
+	{
+		PX_ASSERT(bodyPose.p.isFinite());
+		PX_ASSERT(bodyPose.q.isFinite());
+
+		// PT: TODO: unify naming convention
+
+		// From PxsRigidCore
+		body2World				= bodyPose;
+		mFlags					= PxRigidBodyFlags();
+		solverIterationCounts	= (1 << 8) | 4;
+
+		setBody2Actor(PxTransform(PxIdentity));
+
+		ccdAdvanceCoefficient	= 0.15f;
+		linearVelocity			= PxVec3(0.0f);
+		maxPenBias				= -1e32f;//-PX_MAX_F32;
+		angularVelocity			= PxVec3(0.0f);
+		contactReportThreshold	= PX_MAX_F32;	
+		maxAngularVelocitySq	= maxAngularVelocitySq_;
+		maxLinearVelocitySq		= maxLinearVelocitySq_;
+		linearDamping			= linearDamping_;
+		angularDamping			= angularDamping_;
+		inverseInertia			= inverseInertia_;
+		inverseMass				= inverseMass_;
+		maxContactImpulse		= 1e32f;// PX_MAX_F32;
+		sleepThreshold			= 5e-5f * scaleSpeed * scaleSpeed;
+		freezeThreshold			= 2.5e-5f * scaleSpeed * scaleSpeed;
+		wakeCounter				= wakeCounter_;
+		// PT: this one is not initialized?
+		//solverWakeCounter
+		// PT: these are initialized in BodySim ctor
+		//numCountedInteractions;
+		//numBodyInteractions;
+		isFastMoving			= false;
+		disableGravity			= false;
+		lockFlags				= PxRigidDynamicLockFlags(0);
+	}
+};
+
+PX_COMPILE_TIME_ASSERT(sizeof(PxsBodyCore) == 160);
+
+}
+
+#endif

physx/source/lowlevel/api/include/PxvGeometry.h

@@ -0,0 +1,80 @@
+//
+// 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 PXV_GEOMETRY_H
+#define PXV_GEOMETRY_H
+
+#include "foundation/PxTransform.h"
+#include "PxvConfig.h"
+
+/*!
+\file
+Geometry interface
+*/
+
+/************************************************************************/
+/* Shapes                                                               */
+/************************************************************************/
+
+// moved to
+#include "GuGeometryUnion.h"
+
+namespace physx
+{
+
+struct PxsShapeCore
+{
+//= ATTENTION! =====================================================================================
+// Changing the data layout of this class breaks the binary serialization format.  See comments for 
+// PX_BINARY_SERIAL_VERSION.  If a modification is required, please adjust the getBinaryMetaData 
+// function.  If the modification is made on a custom branch, please change PX_BINARY_SERIAL_VERSION
+// accordingly.
+//==================================================================================================
+
+// PX_SERIALIZATION
+	PxsShapeCore()									{}
+	PxsShapeCore(const PxEMPTY) : geometry(PxEmpty)	{}
+//~PX_SERIALIZATION
+
+	// PT: TODO: unify naming convention
+	PX_ALIGN_PREFIX(16)
+	PxTransform			transform PX_ALIGN_SUFFIX(16);
+	PxReal				contactOffset;
+	PxU8				mShapeFlags;			// !< API shape flags	// PT: TODO: use PxShapeFlags here. Needs to move flags to separate file.
+	PxU8				mOwnsMaterialIdxMemory;	// PT: for de-serialization to avoid deallocating material index list. Moved there from Sc::ShapeCore (since one byte was free).
+	PxU16				materialIndex;
+	Gu::GeometryUnion	geometry;
+};
+
+PX_COMPILE_TIME_ASSERT( (sizeof(PxsShapeCore)&0xf) == 0);
+
+}
+
+#endif

physx/source/lowlevel/api/include/PxvGlobals.h

@@ -0,0 +1,116 @@
+//
+// 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 PXD_INIT_H
+#define PXD_INIT_H
+
+#include "PxvConfig.h"
+#include "PsBasicTemplates.h"
+
+namespace physx
+{
+
+/*!
+\file
+PhysX Low-level, Memory management
+*/
+
+/************************************************************************/
+/* Error Handling                                                       */
+/************************************************************************/
+
+
+enum PxvErrorCode
+{
+	PXD_ERROR_NO_ERROR = 0,
+	PXD_ERROR_INVALID_PARAMETER,
+	PXD_ERROR_INVALID_PARAMETER_SIZE,
+	PXD_ERROR_INTERNAL_ERROR,
+	PXD_ERROR_NOT_IMPLEMENTED,
+	PXD_ERROR_NO_CONTEXT,
+	PXD_ERROR_NO_TASK_MANAGER,
+	PXD_ERROR_WARNING
+};
+
+class PxShape;
+class PxRigidActor;
+struct PxsShapeCore;
+struct PxsRigidCore;
+
+struct PxvOffsetTable
+{
+	PX_FORCE_INLINE PxvOffsetTable() {}
+
+	PX_FORCE_INLINE const PxShape* convertPxsShape2Px(const PxsShapeCore* pxs) const
+	{
+		return shdfnd::pointerOffset<const PxShape*>(pxs, pxsShapeCore2PxShape); 
+	}
+
+	PX_FORCE_INLINE const PxRigidActor* convertPxsRigidCore2PxRigidBody(const PxsRigidCore* pxs) const
+	{
+		return shdfnd::pointerOffset<const PxRigidActor*>(pxs, pxsRigidCore2PxRigidBody); 
+	}
+
+	PX_FORCE_INLINE const PxRigidActor* convertPxsRigidCore2PxRigidStatic(const PxsRigidCore* pxs) const
+	{
+		return shdfnd::pointerOffset<const PxRigidActor*>(pxs, pxsRigidCore2PxRigidStatic); 
+	}
+
+	ptrdiff_t	pxsShapeCore2PxShape;
+	ptrdiff_t	pxsRigidCore2PxRigidBody;
+	ptrdiff_t	pxsRigidCore2PxRigidStatic;
+};
+extern PxvOffsetTable gPxvOffsetTable;
+
+/*!
+Initialize low-level implementation.
+*/
+
+void PxvInit(const PxvOffsetTable& offsetTable);
+
+
+/*!
+Shut down low-level implementation.
+*/
+void PxvTerm();
+
+/*!
+Initialize low-level implementation.
+*/
+
+void PxvRegisterHeightFields();
+
+#if PX_SUPPORT_GPU_PHYSX
+class PxPhysXGpu* PxvGetPhysXGpu(bool createIfNeeded);
+#endif
+
+}
+
+#endif

physx/source/lowlevel/api/include/PxvManager.h

@@ -0,0 +1,213 @@
+//
+// 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 PXV_MANAGER_H
+#define PXV_MANAGER_H
+
+#include "foundation/PxVec3.h"
+#include "foundation/PxQuat.h"
+#include "foundation/PxTransform.h"
+#include "foundation/PxMemory.h"
+#include "PxvConfig.h"
+#include "PxvGeometry.h"
+
+namespace physx
+{
+
+/*!
+\file
+Manager interface
+*/
+
+/************************************************************************/
+/* Managers                                                             */
+/************************************************************************/
+
+class PxsContactManager;
+
+struct PxsRigidCore;
+struct PxsShapeCore;
+class PxsRigidBody;
+
+/*!
+Type of PXD_MANAGER_CCD_MODE property
+*/
+enum PxvContactManagerCCDMode
+{
+	PXD_MANAGER_CCD_NONE,
+	PXD_MANAGER_CCD_LINEAR
+};
+
+/*!
+Manager descriptor
+*/
+struct PxvManagerDescRigidRigid
+{
+	/*!
+	Manager user data
+
+	\sa PXD_MANAGER_USER_DATA
+	*/
+	//void* userData;
+
+	/*!
+	Dominance setting for one way interactions.
+	A dominance of 0 means the corresp. body will 
+	not be pushable by the other body in the constraint.
+	\sa PXD_MANAGER_DOMINANCE0
+	*/
+	PxU8		dominance0;
+	
+	/*!
+	Dominance setting for one way interactions.
+	A dominance of 0 means the corresp. body will 
+	not be pushable by the other body in the constraint.
+	\sa PXD_MANAGER_DOMINANCE1
+	*/
+	PxU8 	dominance1;
+
+	/*!
+	PxsRigidBodies
+	*/
+	PxsRigidBody*	rigidBody0;
+	PxsRigidBody*	rigidBody1;
+
+	/*!
+	Shape Core structures
+	*/
+	const PxsShapeCore*	shapeCore0;
+	const PxsShapeCore*	shapeCore1;
+
+	/*!
+	Body Core structures
+	*/
+	PxsRigidCore*	rigidCore0;
+	PxsRigidCore*	rigidCore1;
+
+	/*!
+	Enable contact information reporting.
+	*/
+	int		reportContactInfo;
+
+	/*!
+	Enable contact impulse threshold reporting.
+	*/
+	int		hasForceThreshold;
+
+	/*!
+	Enable generated contacts to be changeable
+	*/
+	int		contactChangeable;
+
+	/*!
+	Disable strong friction
+	*/
+	//int		disableStrongFriction;
+
+	/*!
+	Contact resolution rest distance.
+	*/
+	PxReal		restDistance;
+
+	/*!
+	Disable contact response
+	*/
+	int		disableResponse;
+
+	/*!
+	Disable discrete contact generation
+	*/
+	int		disableDiscreteContact;
+
+	/*!
+	Disable CCD contact generation
+	*/
+	int		disableCCDContact;
+
+	/*!
+	Is connected to an articulation (1 - first body, 2 - second body)
+	*/
+	int		hasArticulations;
+
+	/*!
+	is connected to a dynamic (1 - first body, 2 - second body)
+	*/
+	int		hasDynamics;
+
+	/*!
+	Is the pair touching? Use when re-creating the manager with prior knowledge about touch status.
+	
+	positive: pair is touching
+	0:        touch state unknown (this is a new pair)
+	negative: pair is not touching
+
+	Default is 0
+	*/
+	int		hasTouch;
+
+	/*!
+	Identifies whether body 1 is kinematic. We can treat kinematics as statics and embed velocity into constraint
+	because kinematic bodies' velocities will not change
+	*/
+	bool    body1Kinematic;
+
+	/*
+	Index entries into the transform cache for shape 0
+	*/
+	PxU32 transformCache0;
+
+	/*
+	Index entries into the transform cache for shape 1
+	*/
+	PxU32 transformCache1;
+
+	PxvManagerDescRigidRigid()
+	{
+		PxMemSet(this, 0, sizeof(PxvManagerDescRigidRigid));
+
+		dominance0 = 1u;
+		dominance1 = 1u;
+	}
+};
+
+
+/*!
+Report struct for contact manager touch reports
+*/
+struct PxvContactManagerTouchEvent
+{
+	PxsContactManager*	manager;	// Manager handle
+	void*				userData;	// Manager userdata
+};
+
+}
+
+#endif
+

physx/source/lowlevel/api/include/PxvSimStats.h

@@ -0,0 +1,114 @@
+//
+// 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 PXV_SIM_STATS_H
+#define PXV_SIM_STATS_H
+
+#include "foundation/PxAssert.h"
+#include "foundation/PxMemory.h"
+#include "geometry/PxGeometry.h"
+#include "CmPhysXCommon.h"
+
+namespace physx
+{
+
+/*!
+\file
+Context handling
+*/
+
+/************************************************************************/
+/* Context handling, types                                              */
+/************************************************************************/
+
+/*!
+Description: contains statistics for the simulation.
+*/
+struct PxvSimStats
+{
+	PxvSimStats() { clearAll(); }
+	void clearAll() { PxMemZero(this, sizeof(PxvSimStats)); }		// set counters to zero
+
+	PX_FORCE_INLINE void incCCDPairs(PxGeometryType::Enum g0, PxGeometryType::Enum g1)
+	{
+		PX_ASSERT(g0 <= g1);  // That's how they should be sorted
+		mNbCCDPairs[g0][g1]++;
+	}
+
+	PX_FORCE_INLINE void decCCDPairs(PxGeometryType::Enum g0, PxGeometryType::Enum g1)
+	{
+		PX_ASSERT(g0 <= g1);  // That's how they should be sorted
+		PX_ASSERT(mNbCCDPairs[g0][g1]);
+		mNbCCDPairs[g0][g1]--;
+	}
+
+	PX_FORCE_INLINE void incModifiedContactPairs(PxGeometryType::Enum g0, PxGeometryType::Enum g1)
+	{
+		PX_ASSERT(g0 <= g1);  // That's how they should be sorted
+		mNbModifiedContactPairs[g0][g1]++;
+	}
+
+	PX_FORCE_INLINE void decModifiedContactPairs(PxGeometryType::Enum g0, PxGeometryType::Enum g1)
+	{
+		PX_ASSERT(g0 <= g1);  // That's how they should be sorted
+		PX_ASSERT(mNbModifiedContactPairs[g0][g1]);
+		mNbModifiedContactPairs[g0][g1]--;
+	}
+
+	// PT: those guys are now persistent and shouldn't be cleared each frame
+	PxU32	mNbDiscreteContactPairs	[PxGeometryType::eGEOMETRY_COUNT][PxGeometryType::eGEOMETRY_COUNT];
+	PxU32	mNbCCDPairs				[PxGeometryType::eGEOMETRY_COUNT][PxGeometryType::eGEOMETRY_COUNT];
+
+	PxU32	mNbModifiedContactPairs	[PxGeometryType::eGEOMETRY_COUNT][PxGeometryType::eGEOMETRY_COUNT];
+
+	PxU32	mNbDiscreteContactPairsTotal;		// PT: sum of mNbDiscreteContactPairs, i.e. number of pairs reaching narrow phase
+	PxU32	mNbDiscreteContactPairsWithCacheHits;
+	PxU32	mNbDiscreteContactPairsWithContacts;
+	PxU32	mNbActiveConstraints;
+	PxU32	mNbActiveDynamicBodies;
+	PxU32	mNbActiveKinematicBodies;
+
+	PxU32	mNbAxisSolverConstraints;
+	PxU32	mTotalCompressedContactSize;
+	PxU32	mTotalConstraintSize;
+	PxU32	mPeakConstraintBlockAllocations;
+
+	PxU32	mNbNewPairs;
+	PxU32	mNbLostPairs;
+
+	PxU32	mNbNewTouches;
+	PxU32	mNbLostTouches;
+
+	PxU32	mNbPartitions;
+};
+
+}
+
+#endif

physx/source/lowlevel/api/src/px_globals.cpp

@@ -0,0 +1,94 @@
+//
+// 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.  
+
+#include "PxvGlobals.h"
+#include "PxsContext.h"
+#include "PxcContactMethodImpl.h"
+#include "GuContactMethodImpl.h"
+
+
+#if PX_SUPPORT_GPU_PHYSX
+#include "PxPhysXGpu.h"
+
+physx::PxPhysXGpu* gPxPhysXGpu;
+#endif
+
+namespace physx
+{
+
+PxvOffsetTable gPxvOffsetTable;
+
+void PxvInit(const PxvOffsetTable& offsetTable)
+{
+#if PX_SUPPORT_GPU_PHYSX
+	gPxPhysXGpu = NULL;
+#endif
+	gPxvOffsetTable = offsetTable;
+}
+
+void PxvTerm()
+{
+#if PX_SUPPORT_GPU_PHYSX
+	if (gPxPhysXGpu)
+	{
+		gPxPhysXGpu->release();
+		gPxPhysXGpu = NULL;
+	}
+#endif
+}
+
+}
+
+#if PX_SUPPORT_GPU_PHYSX
+namespace physx
+{
+	//forward declare stuff from PxPhysXGpuModuleLoader.cpp
+	void PxLoadPhysxGPUModule(const char* appGUID);
+	typedef physx::PxPhysXGpu* (PxCreatePhysXGpu_FUNC)();
+	extern PxCreatePhysXGpu_FUNC* g_PxCreatePhysXGpu_Func;
+
+	PxPhysXGpu* PxvGetPhysXGpu(bool createIfNeeded)
+	{
+		if (!gPxPhysXGpu && createIfNeeded)
+		{
+#ifdef PX_PHYSX_GPU_STATIC
+			gPxPhysXGpu = PxCreatePhysXGpu();
+#else
+			PxLoadPhysxGPUModule(NULL);
+			if (g_PxCreatePhysXGpu_Func)
+			{
+				gPxPhysXGpu = g_PxCreatePhysXGpu_Func();
+			}
+#endif
+		}
+		
+		return gPxPhysXGpu;
+	}
+}
+#endif