Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

31 files changed, 6571 insertions, 0 deletions

diff --git a/PxShared/include/foundation/Px.h b/PxShared/include/foundation/Px.h
new file mode 100644
index 00000000..6dc74aa2
--- /dev/null
+++ b/PxShared/include/foundation/Px.h
@@ -0,0 +1,92 @@
+// 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 PXFOUNDATION_PX_H
+#define PXFOUNDATION_PX_H
+
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/PxSimpleTypes.h"
+
+/** files to always include */
+#include <string.h>
+#include <stdlib.h>
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+typedef uint32_t PxU32;
+
+class PxAllocatorCallback;
+class PxErrorCallback;
+struct PxErrorCode;
+class PxAssertHandler;
+
+class PxInputStream;
+class PxInputData;
+class PxOutputStream;
+
+class PxVec2;
+class PxVec3;
+class PxVec4;
+class PxMat33;
+class PxMat44;
+class PxPlane;
+class PxQuat;
+class PxTransform;
+class PxBounds3;
+
+/** enum for empty constructor tag*/
+enum PxEMPTY
+{
+	PxEmpty
+};
+
+/** enum for zero constructor tag for vectors and matrices */
+enum PxZERO
+{
+	PxZero
+};
+
+/** enum for identity constructor flag for quaternions, transforms, and matrices */
+enum PxIDENTITY
+{
+	PxIdentity
+};
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PX_H
diff --git a/PxShared/include/foundation/PxAllocatorCallback.h b/PxShared/include/foundation/PxAllocatorCallback.h
new file mode 100644
index 00000000..e5b36c6f
--- /dev/null
+++ b/PxShared/include/foundation/PxAllocatorCallback.h
@@ -0,0 +1,95 @@
+// 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 PXFOUNDATION_PXALLOCATORCALLBACK_H
+#define PXFOUNDATION_PXALLOCATORCALLBACK_H
+
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/Px.h"
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief Abstract base class for an application defined memory allocator that can be used by the Nv library.
+
+\note The SDK state should not be modified from within any allocation/free function.
+
+<b>Threading:</b> All methods of this class should be thread safe as it can be called from the user thread
+or the physics processing thread(s).
+*/
+
+class PxAllocatorCallback
+{
+  public:
+	/**
+	\brief destructor
+	*/
+	virtual ~PxAllocatorCallback()
+	{
+	}
+
+	/**
+	\brief Allocates size bytes of memory, which must be 16-byte aligned.
+
+	This method should never return NULL.  If you run out of memory, then
+	you should terminate the app or take some other appropriate action.
+
+	<b>Threading:</b> This function should be thread safe as it can be called in the context of the user thread
+	and physics processing thread(s).
+
+	\param size			Number of bytes to allocate.
+	\param typeName		Name of the datatype that is being allocated
+	\param filename		The source file which allocated the memory
+	\param line			The source line which allocated the memory
+	\return				The allocated block of memory.
+	*/
+	virtual void* allocate(size_t size, const char* typeName, const char* filename, int line) = 0;
+
+	/**
+	\brief Frees memory previously allocated by allocate().
+
+	<b>Threading:</b> This function should be thread safe as it can be called in the context of the user thread
+	and physics processing thread(s).
+
+	\param ptr Memory to free.
+	*/
+	virtual void deallocate(void* ptr) = 0;
+};
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXALLOCATORCALLBACK_H
diff --git a/PxShared/include/foundation/PxAssert.h b/PxShared/include/foundation/PxAssert.h
new file mode 100644
index 00000000..dbd5c9f9
--- /dev/null
+++ b/PxShared/include/foundation/PxAssert.h
@@ -0,0 +1,95 @@
+// 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 PXFOUNDATION_PXASSERT_H
+#define PXFOUNDATION_PXASSERT_H
+
+/** \addtogroup foundation
+@{ */
+
+#include "foundation/Px.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/* Base class to handle assert failures */
+class PxAssertHandler
+{
+  public:
+	virtual ~PxAssertHandler()
+	{
+	}
+	virtual void operator()(const char* exp, const char* file, int line, bool& ignore) = 0;
+};
+
+PX_FOUNDATION_API PxAssertHandler& PxGetAssertHandler();
+PX_FOUNDATION_API void PxSetAssertHandler(PxAssertHandler& handler);
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+#if !PX_ENABLE_ASSERTS
+#define PX_ASSERT(exp) ((void)0)
+#define PX_ALWAYS_ASSERT_MESSAGE(exp) ((void)0)
+#define PX_ASSERT_WITH_MESSAGE(condition, message) ((void)0)
+#else
+#if PX_VC
+#define PX_CODE_ANALYSIS_ASSUME(exp)                                                                                   \
+	__analysis_assume(!!(exp)) // This macro will be used to get rid of analysis warning messages if a PX_ASSERT is used
+// to "guard" illegal mem access, for example.
+#else
+#define PX_CODE_ANALYSIS_ASSUME(exp)
+#endif
+#define PX_ASSERT(exp)                                                                                                 \
+	{                                                                                                                  \
+		static bool _ignore = false;                                                                                   \
+		((void)((!!(exp)) || (!_ignore && (physx::PxGetAssertHandler()(#exp, __FILE__, __LINE__, _ignore), false))));  \
+		PX_CODE_ANALYSIS_ASSUME(exp);                                                                                  \
+	}
+#define PX_ALWAYS_ASSERT_MESSAGE(exp)                                                                                  \
+	{                                                                                                                  \
+		static bool _ignore = false;                                                                                   \
+		if(!_ignore)                                                                                                   \
+			physx::PxGetAssertHandler()(exp, __FILE__, __LINE__, _ignore);                                             \
+	}
+#define PX_ASSERT_WITH_MESSAGE(exp, message)                                                                             \
+	{                                                                                                                    \
+		static bool _ignore = false;                                                                                     \
+		((void)((!!(exp)) || (!_ignore && (physx::PxGetAssertHandler()(message, __FILE__, __LINE__, _ignore), false)))); \
+		PX_CODE_ANALYSIS_ASSUME(exp);                                                                                    \
+	}
+#endif
+
+#define PX_ALWAYS_ASSERT() PX_ASSERT(0)
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXASSERT_H
diff --git a/PxShared/include/foundation/PxBitAndData.h b/PxShared/include/foundation/PxBitAndData.h
new file mode 100644
index 00000000..2327f925
--- /dev/null
+++ b/PxShared/include/foundation/PxBitAndData.h
@@ -0,0 +1,87 @@
+// 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 PXFOUNDATION_PXBITANDDATA_H
+#define PXFOUNDATION_PXBITANDDATA_H
+
+#include "foundation/Px.h"
+
+/** \addtogroup foundation
+  @{
+*/
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+template <typename storageType, storageType bitMask>
+class PxBitAndDataT
+{
+  public:
+	PX_FORCE_INLINE PxBitAndDataT(const PxEMPTY)
+	{
+	}
+	PX_FORCE_INLINE PxBitAndDataT() : mData(0)
+	{
+	}
+	PX_FORCE_INLINE PxBitAndDataT(storageType data, bool bit = false)
+	{
+		mData = bit ? storageType(data | bitMask) : data;
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE operator storageType() const
+	{
+		return storageType(mData & ~bitMask);
+	}
+	PX_CUDA_CALLABLE PX_FORCE_INLINE void setBit()
+	{
+		mData |= bitMask;
+	}
+	PX_CUDA_CALLABLE PX_FORCE_INLINE void clearBit()
+	{
+		mData &= ~bitMask;
+	}
+	PX_CUDA_CALLABLE PX_FORCE_INLINE storageType isBitSet() const
+	{
+		return storageType(mData & bitMask);
+	}
+
+  protected:
+	storageType mData;
+};
+typedef PxBitAndDataT<unsigned char, 0x80> PxBitAndByte;
+typedef PxBitAndDataT<unsigned short, 0x8000> PxBitAndWord;
+typedef PxBitAndDataT<unsigned int, 0x80000000> PxBitAndDword;
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // PXFOUNDATION_PXBITANDDATA_H
diff --git a/PxShared/include/foundation/PxBounds3.h b/PxShared/include/foundation/PxBounds3.h
new file mode 100644
index 00000000..e3fbc9ec
--- /dev/null
+++ b/PxShared/include/foundation/PxBounds3.h
@@ -0,0 +1,480 @@
+// 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 PXFOUNDATION_PXBOUNDS3_H
+#define PXFOUNDATION_PXBOUNDS3_H
+
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/PxTransform.h"
+#include "foundation/PxMat33.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+// maximum extents defined such that floating point exceptions are avoided for standard use cases
+#define PX_MAX_BOUNDS_EXTENTS (PX_MAX_REAL * 0.25f)
+
+/**
+\brief Class representing 3D range or axis aligned bounding box.
+
+Stored as minimum and maximum extent corners. Alternate representation
+would be center and dimensions.
+May be empty or nonempty. For nonempty bounds, minimum <= maximum has to hold for all axes.
+Empty bounds have to be represented as minimum = PX_MAX_BOUNDS_EXTENTS and maximum = -PX_MAX_BOUNDS_EXTENTS for all
+axes.
+All other representations are invalid and the behavior is undefined.
+*/
+class PxBounds3
+{
+  public:
+	/**
+	\brief Default constructor, not performing any initialization for performance reason.
+	\remark Use empty() function below to construct empty bounds.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxBounds3()
+	{
+	}
+
+	/**
+	\brief Construct from two bounding points
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxBounds3(const PxVec3& minimum, const PxVec3& maximum);
+
+	/**
+	\brief Return empty bounds.
+	*/
+	static PX_CUDA_CALLABLE PX_FORCE_INLINE PxBounds3 empty();
+
+	/**
+	\brief returns the AABB containing v0 and v1.
+	\param v0 first point included in the AABB.
+	\param v1 second point included in the AABB.
+	*/
+	static PX_CUDA_CALLABLE PX_FORCE_INLINE PxBounds3 boundsOfPoints(const PxVec3& v0, const PxVec3& v1);
+
+	/**
+	\brief returns the AABB from center and extents vectors.
+	\param center Center vector
+	\param extent Extents vector
+	*/
+	static PX_CUDA_CALLABLE PX_FORCE_INLINE PxBounds3 centerExtents(const PxVec3& center, const PxVec3& extent);
+
+	/**
+	\brief Construct from center, extent, and (not necessarily orthogonal) basis
+	*/
+	static PX_CUDA_CALLABLE PX_INLINE PxBounds3
+	basisExtent(const PxVec3& center, const PxMat33& basis, const PxVec3& extent);
+
+	/**
+	\brief Construct from pose and extent
+	*/
+	static PX_CUDA_CALLABLE PX_INLINE PxBounds3 poseExtent(const PxTransform& pose, const PxVec3& extent);
+
+	/**
+	\brief gets the transformed bounds of the passed AABB (resulting in a bigger AABB).
+
+	This version is safe to call for empty bounds.
+
+	\param[in] matrix Transform to apply, can contain scaling as well
+	\param[in] bounds The bounds to transform.
+	*/
+	static PX_CUDA_CALLABLE PX_INLINE PxBounds3 transformSafe(const PxMat33& matrix, const PxBounds3& bounds);
+
+	/**
+	\brief gets the transformed bounds of the passed AABB (resulting in a bigger AABB).
+
+	Calling this method for empty bounds leads to undefined behavior. Use #transformSafe() instead.
+
+	\param[in] matrix Transform to apply, can contain scaling as well
+	\param[in] bounds The bounds to transform.
+	*/
+	static PX_CUDA_CALLABLE PX_INLINE PxBounds3 transformFast(const PxMat33& matrix, const PxBounds3& bounds);
+
+	/**
+	\brief gets the transformed bounds of the passed AABB (resulting in a bigger AABB).
+
+	This version is safe to call for empty bounds.
+
+	\param[in] transform Transform to apply, can contain scaling as well
+	\param[in] bounds The bounds to transform.
+	*/
+	static PX_CUDA_CALLABLE PX_INLINE PxBounds3 transformSafe(const PxTransform& transform, const PxBounds3& bounds);
+
+	/**
+	\brief gets the transformed bounds of the passed AABB (resulting in a bigger AABB).
+
+	Calling this method for empty bounds leads to undefined behavior. Use #transformSafe() instead.
+
+	\param[in] transform Transform to apply, can contain scaling as well
+	\param[in] bounds The bounds to transform.
+	*/
+	static PX_CUDA_CALLABLE PX_INLINE PxBounds3 transformFast(const PxTransform& transform, const PxBounds3& bounds);
+
+	/**
+	\brief Sets empty to true
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE void setEmpty();
+
+	/**
+	\brief Sets the bounds to maximum size [-PX_MAX_BOUNDS_EXTENTS, PX_MAX_BOUNDS_EXTENTS].
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE void setMaximal();
+
+	/**
+	\brief expands the volume to include v
+	\param v Point to expand to.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE void include(const PxVec3& v);
+
+	/**
+	\brief expands the volume to include b.
+	\param b Bounds to perform union with.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE void include(const PxBounds3& b);
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool isEmpty() const;
+
+	/**
+	\brief indicates whether the intersection of this and b is empty or not.
+	\param b Bounds to test for intersection.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool intersects(const PxBounds3& b) const;
+
+	/**
+	 \brief computes the 1D-intersection between two AABBs, on a given axis.
+	 \param	a		the other AABB
+	 \param	axis	the axis (0, 1, 2)
+	 */
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool intersects1D(const PxBounds3& a, uint32_t axis) const;
+
+	/**
+	\brief indicates if these bounds contain v.
+	\param v Point to test against bounds.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool contains(const PxVec3& v) const;
+
+	/**
+	 \brief	checks a box is inside another box.
+	 \param	box		the other AABB
+	 */
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool isInside(const PxBounds3& box) const;
+
+	/**
+	\brief returns the center of this axis aligned box.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 getCenter() const;
+
+	/**
+	\brief get component of the box's center along a given axis
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float getCenter(uint32_t axis) const;
+
+	/**
+	\brief get component of the box's extents along a given axis
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float getExtents(uint32_t axis) const;
+
+	/**
+	\brief returns the dimensions (width/height/depth) of this axis aligned box.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 getDimensions() const;
+
+	/**
+	\brief returns the extents, which are half of the width/height/depth.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 getExtents() const;
+
+	/**
+	\brief scales the AABB.
+
+	This version is safe to call for empty bounds.
+
+	\param scale Factor to scale AABB by.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE void scaleSafe(float scale);
+
+	/**
+	\brief scales the AABB.
+
+	Calling this method for empty bounds leads to undefined behavior. Use #scaleSafe() instead.
+
+	\param scale Factor to scale AABB by.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE void scaleFast(float scale);
+
+	/**
+	fattens the AABB in all 3 dimensions by the given distance.
+
+	This version is safe to call for empty bounds.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE void fattenSafe(float distance);
+
+	/**
+	fattens the AABB in all 3 dimensions by the given distance.
+
+	Calling this method for empty bounds leads to undefined behavior. Use #fattenSafe() instead.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE void fattenFast(float distance);
+
+	/**
+	checks that the AABB values are not NaN
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool isFinite() const;
+
+	/**
+	checks that the AABB values describe a valid configuration.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool isValid() const;
+
+	PxVec3 minimum, maximum;
+};
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE PxBounds3::PxBounds3(const PxVec3& minimum_, const PxVec3& maximum_)
+: minimum(minimum_), maximum(maximum_)
+{
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE PxBounds3 PxBounds3::empty()
+{
+	return PxBounds3(PxVec3(PX_MAX_BOUNDS_EXTENTS), PxVec3(-PX_MAX_BOUNDS_EXTENTS));
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxBounds3::isFinite() const
+{
+	return minimum.isFinite() && maximum.isFinite();
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE PxBounds3 PxBounds3::boundsOfPoints(const PxVec3& v0, const PxVec3& v1)
+{
+	return PxBounds3(v0.minimum(v1), v0.maximum(v1));
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE PxBounds3 PxBounds3::centerExtents(const PxVec3& center, const PxVec3& extent)
+{
+	return PxBounds3(center - extent, center + extent);
+}
+
+PX_CUDA_CALLABLE PX_INLINE PxBounds3
+PxBounds3::basisExtent(const PxVec3& center, const PxMat33& basis, const PxVec3& extent)
+{
+	// extended basis vectors
+	PxVec3 c0 = basis.column0 * extent.x;
+	PxVec3 c1 = basis.column1 * extent.y;
+	PxVec3 c2 = basis.column2 * extent.z;
+
+	PxVec3 w;
+	// find combination of base vectors that produces max. distance for each component = sum of abs()
+	w.x = PxAbs(c0.x) + PxAbs(c1.x) + PxAbs(c2.x);
+	w.y = PxAbs(c0.y) + PxAbs(c1.y) + PxAbs(c2.y);
+	w.z = PxAbs(c0.z) + PxAbs(c1.z) + PxAbs(c2.z);
+
+	return PxBounds3(center - w, center + w);
+}
+
+PX_CUDA_CALLABLE PX_INLINE PxBounds3 PxBounds3::poseExtent(const PxTransform& pose, const PxVec3& extent)
+{
+	return basisExtent(pose.p, PxMat33(pose.q), extent);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE void PxBounds3::setEmpty()
+{
+	minimum = PxVec3(PX_MAX_BOUNDS_EXTENTS);
+	maximum = PxVec3(-PX_MAX_BOUNDS_EXTENTS);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE void PxBounds3::setMaximal()
+{
+	minimum = PxVec3(-PX_MAX_BOUNDS_EXTENTS);
+	maximum = PxVec3(PX_MAX_BOUNDS_EXTENTS);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE void PxBounds3::include(const PxVec3& v)
+{
+	PX_ASSERT(isValid());
+	minimum = minimum.minimum(v);
+	maximum = maximum.maximum(v);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE void PxBounds3::include(const PxBounds3& b)
+{
+	PX_ASSERT(isValid());
+	minimum = minimum.minimum(b.minimum);
+	maximum = maximum.maximum(b.maximum);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxBounds3::isEmpty() const
+{
+	PX_ASSERT(isValid());
+	return minimum.x > maximum.x;
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxBounds3::intersects(const PxBounds3& b) const
+{
+	PX_ASSERT(isValid() && b.isValid());
+	return !(b.minimum.x > maximum.x || minimum.x > b.maximum.x || b.minimum.y > maximum.y || minimum.y > b.maximum.y ||
+	         b.minimum.z > maximum.z || minimum.z > b.maximum.z);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxBounds3::intersects1D(const PxBounds3& a, uint32_t axis) const
+{
+	PX_ASSERT(isValid() && a.isValid());
+	return maximum[axis] >= a.minimum[axis] && a.maximum[axis] >= minimum[axis];
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxBounds3::contains(const PxVec3& v) const
+{
+	PX_ASSERT(isValid());
+
+	return !(v.x < minimum.x || v.x > maximum.x || v.y < minimum.y || v.y > maximum.y || v.z < minimum.z ||
+	         v.z > maximum.z);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxBounds3::isInside(const PxBounds3& box) const
+{
+	PX_ASSERT(isValid() && box.isValid());
+	if(box.minimum.x > minimum.x)
+		return false;
+	if(box.minimum.y > minimum.y)
+		return false;
+	if(box.minimum.z > minimum.z)
+		return false;
+	if(box.maximum.x < maximum.x)
+		return false;
+	if(box.maximum.y < maximum.y)
+		return false;
+	if(box.maximum.z < maximum.z)
+		return false;
+	return true;
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 PxBounds3::getCenter() const
+{
+	PX_ASSERT(isValid());
+	return (minimum + maximum) * 0.5f;
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxBounds3::getCenter(uint32_t axis) const
+{
+	PX_ASSERT(isValid());
+	return (minimum[axis] + maximum[axis]) * 0.5f;
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxBounds3::getExtents(uint32_t axis) const
+{
+	PX_ASSERT(isValid());
+	return (maximum[axis] - minimum[axis]) * 0.5f;
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 PxBounds3::getDimensions() const
+{
+	PX_ASSERT(isValid());
+	return maximum - minimum;
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 PxBounds3::getExtents() const
+{
+	PX_ASSERT(isValid());
+	return getDimensions() * 0.5f;
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE void PxBounds3::scaleSafe(float scale)
+{
+	PX_ASSERT(isValid());
+	if(!isEmpty())
+		scaleFast(scale);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE void PxBounds3::scaleFast(float scale)
+{
+	PX_ASSERT(isValid());
+	*this = centerExtents(getCenter(), getExtents() * scale);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE void PxBounds3::fattenSafe(float distance)
+{
+	PX_ASSERT(isValid());
+	if(!isEmpty())
+		fattenFast(distance);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE void PxBounds3::fattenFast(float distance)
+{
+	PX_ASSERT(isValid());
+	minimum.x -= distance;
+	minimum.y -= distance;
+	minimum.z -= distance;
+
+	maximum.x += distance;
+	maximum.y += distance;
+	maximum.z += distance;
+}
+
+PX_CUDA_CALLABLE PX_INLINE PxBounds3 PxBounds3::transformSafe(const PxMat33& matrix, const PxBounds3& bounds)
+{
+	PX_ASSERT(bounds.isValid());
+	return !bounds.isEmpty() ? transformFast(matrix, bounds) : bounds;
+}
+
+PX_CUDA_CALLABLE PX_INLINE PxBounds3 PxBounds3::transformFast(const PxMat33& matrix, const PxBounds3& bounds)
+{
+	PX_ASSERT(bounds.isValid());
+	return PxBounds3::basisExtent(matrix * bounds.getCenter(), matrix, bounds.getExtents());
+}
+
+PX_CUDA_CALLABLE PX_INLINE PxBounds3 PxBounds3::transformSafe(const PxTransform& transform, const PxBounds3& bounds)
+{
+	PX_ASSERT(bounds.isValid());
+	return !bounds.isEmpty() ? transformFast(transform, bounds) : bounds;
+}
+
+PX_CUDA_CALLABLE PX_INLINE PxBounds3 PxBounds3::transformFast(const PxTransform& transform, const PxBounds3& bounds)
+{
+	PX_ASSERT(bounds.isValid());
+	return PxBounds3::basisExtent(transform.transform(bounds.getCenter()), PxMat33(transform.q), bounds.getExtents());
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxBounds3::isValid() const
+{
+	return (isFinite() && (((minimum.x <= maximum.x) && (minimum.y <= maximum.y) && (minimum.z <= maximum.z)) ||
+	                       ((minimum.x == PX_MAX_BOUNDS_EXTENTS) && (minimum.y == PX_MAX_BOUNDS_EXTENTS) &&
+	                        (minimum.z == PX_MAX_BOUNDS_EXTENTS) && (maximum.x == -PX_MAX_BOUNDS_EXTENTS) &&
+	                        (maximum.y == -PX_MAX_BOUNDS_EXTENTS) && (maximum.z == -PX_MAX_BOUNDS_EXTENTS))));
+}
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXBOUNDS3_H
diff --git a/PxShared/include/foundation/PxErrorCallback.h b/PxShared/include/foundation/PxErrorCallback.h
new file mode 100644
index 00000000..27869d39
--- /dev/null
+++ b/PxShared/include/foundation/PxErrorCallback.h
@@ -0,0 +1,73 @@
+// 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 PXFOUNDATION_PXERRORCALLBACK_H
+#define PXFOUNDATION_PXERRORCALLBACK_H
+
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/PxErrors.h"
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief User defined interface class.  Used by the library to emit debug information.
+
+\note The SDK state should not be modified from within any error reporting functions.
+
+<b>Threading:</b> The SDK sequences its calls to the output stream using a mutex, so the class need not
+be implemented in a thread-safe manner if the SDK is the only client.
+*/
+class PxErrorCallback
+{
+  public:
+	virtual ~PxErrorCallback()
+	{
+	}
+
+	/**
+	\brief Reports an error code.
+	\param code Error code, see #PxErrorCode
+	\param message Message to display.
+	\param file File error occured in.
+	\param line Line number error occured on.
+	*/
+	virtual void reportError(PxErrorCode::Enum code, const char* message, const char* file, int line) = 0;
+};
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXERRORCALLBACK_H
diff --git a/PxShared/include/foundation/PxErrors.h b/PxShared/include/foundation/PxErrors.h
new file mode 100644
index 00000000..00745e3b
--- /dev/null
+++ b/PxShared/include/foundation/PxErrors.h
@@ -0,0 +1,93 @@
+// 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 PXFOUNDATION_PXERRORS_H
+#define PXFOUNDATION_PXERRORS_H
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/Px.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief Error codes
+
+These error codes are passed to #PxErrorCallback
+
+@see PxErrorCallback
+*/
+
+struct PxErrorCode
+{
+	enum Enum
+	{
+		eNO_ERROR          = 0,
+
+		//! \brief An informational message.
+		eDEBUG_INFO        = 1,
+
+		//! \brief a warning message for the user to help with debugging
+		eDEBUG_WARNING     = 2,
+
+		//! \brief method called with invalid parameter(s)
+		eINVALID_PARAMETER = 4,
+
+		//! \brief method was called at a time when an operation is not possible
+		eINVALID_OPERATION = 8,
+
+		//! \brief method failed to allocate some memory
+		eOUT_OF_MEMORY     = 16,
+
+		/** \brief The library failed for some reason.
+	    Possibly you have passed invalid values like NaNs, which are not checked for.
+	    */
+		eINTERNAL_ERROR    = 32,
+
+		//! \brief An unrecoverable error, execution should be halted and log output flushed
+		eABORT             = 64,
+
+		//! \brief The SDK has determined that an operation may result in poor performance.
+		ePERF_WARNING      = 128,
+
+		//! \brief A bit mask for including all errors
+		eMASK_ALL          = -1
+	};
+};
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXERRORS_H
diff --git a/PxShared/include/foundation/PxFlags.h b/PxShared/include/foundation/PxFlags.h
new file mode 100644
index 00000000..0fa82783
--- /dev/null
+++ b/PxShared/include/foundation/PxFlags.h
@@ -0,0 +1,375 @@
+// 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 PXFOUNDATION_PXFLAGS_H
+#define PXFOUNDATION_PXFLAGS_H
+
+/** \addtogroup foundation
+  @{
+*/
+
+#include "foundation/Px.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+/**
+\brief Container for bitfield flag variables associated with a specific enum type.
+
+This allows for type safe manipulation for bitfields.
+
+<h3>Example</h3>
+    // enum that defines each bit...
+    struct MyEnum
+    {
+        enum Enum
+        {
+            eMAN  = 1,
+            eBEAR = 2,
+            ePIG  = 4,
+        };
+    };
+
+    // implements some convenient global operators.
+    PX_FLAGS_OPERATORS(MyEnum::Enum, uint8_t);
+
+    PxFlags<MyEnum::Enum, uint8_t> myFlags;
+    myFlags |= MyEnum::eMAN;
+    myFlags |= MyEnum::eBEAR | MyEnum::ePIG;
+    if(myFlags & MyEnum::eBEAR)
+    {
+        doSomething();
+    }
+*/
+
+template <typename enumtype, typename storagetype = uint32_t>
+class PxFlags
+{
+  public:
+	typedef storagetype InternalType;
+
+	PX_CUDA_CALLABLE PX_INLINE explicit PxFlags(const PxEMPTY)
+	{
+	}
+	PX_CUDA_CALLABLE PX_INLINE PxFlags(void);
+	PX_CUDA_CALLABLE PX_INLINE PxFlags(enumtype e);
+	PX_CUDA_CALLABLE PX_INLINE PxFlags(const PxFlags<enumtype, storagetype>& f);
+	PX_CUDA_CALLABLE PX_INLINE explicit PxFlags(storagetype b);
+
+	PX_CUDA_CALLABLE PX_INLINE bool isSet(enumtype e) const;
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& set(enumtype e);
+	PX_CUDA_CALLABLE PX_INLINE bool operator==(enumtype e) const;
+	PX_CUDA_CALLABLE PX_INLINE bool operator==(const PxFlags<enumtype, storagetype>& f) const;
+	PX_CUDA_CALLABLE PX_INLINE bool operator==(bool b) const;
+	PX_CUDA_CALLABLE PX_INLINE bool operator!=(enumtype e) const;
+	PX_CUDA_CALLABLE PX_INLINE bool operator!=(const PxFlags<enumtype, storagetype>& f) const;
+
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator=(const PxFlags<enumtype, storagetype>& f);
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator=(enumtype e);
+
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator|=(enumtype e);
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator|=(const PxFlags<enumtype, storagetype>& f);
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator|(enumtype e) const;
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator|(const PxFlags<enumtype, storagetype>& f) const;
+
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator&=(enumtype e);
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator&=(const PxFlags<enumtype, storagetype>& f);
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator&(enumtype e) const;
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator&(const PxFlags<enumtype, storagetype>& f) const;
+
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator^=(enumtype e);
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype>& operator^=(const PxFlags<enumtype, storagetype>& f);
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator^(enumtype e) const;
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator^(const PxFlags<enumtype, storagetype>& f) const;
+
+	PX_CUDA_CALLABLE PX_INLINE PxFlags<enumtype, storagetype> operator~(void) const;
+
+	PX_CUDA_CALLABLE PX_INLINE operator bool(void) const;
+	PX_CUDA_CALLABLE PX_INLINE operator uint8_t(void) const;
+	PX_CUDA_CALLABLE PX_INLINE operator uint16_t(void) const;
+	PX_CUDA_CALLABLE PX_INLINE operator uint32_t(void) const;
+
+	PX_CUDA_CALLABLE PX_INLINE void clear(enumtype e);
+
+  public:
+	friend PX_INLINE PxFlags<enumtype, storagetype> operator&(enumtype a, PxFlags<enumtype, storagetype>& b)
+	{
+		PxFlags<enumtype, storagetype> out;
+		out.mBits = a & b.mBits;
+		return out;
+	}
+
+  private:
+	storagetype mBits;
+};
+
+#define PX_FLAGS_OPERATORS(enumtype, storagetype)                                                                      \
+	PX_INLINE PxFlags<enumtype, storagetype> operator|(enumtype a, enumtype b)                                         \
+	{                                                                                                                  \
+		PxFlags<enumtype, storagetype> r(a);                                                                           \
+		r |= b;                                                                                                        \
+		return r;                                                                                                      \
+	}                                                                                                                  \
+	PX_INLINE PxFlags<enumtype, storagetype> operator&(enumtype a, enumtype b)                                         \
+	{                                                                                                                  \
+		PxFlags<enumtype, storagetype> r(a);                                                                           \
+		r &= b;                                                                                                        \
+		return r;                                                                                                      \
+	}                                                                                                                  \
+	PX_INLINE PxFlags<enumtype, storagetype> operator~(enumtype a)                                                     \
+	{                                                                                                                  \
+		return ~PxFlags<enumtype, storagetype>(a);                                                                     \
+	}
+
+#define PX_FLAGS_TYPEDEF(x, y)                                                                                         \
+	typedef PxFlags<x::Enum, y> x##s;                                                                                  \
+	PX_FLAGS_OPERATORS(x::Enum, y)
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>::PxFlags(void)
+{
+	mBits = 0;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>::PxFlags(enumtype e)
+{
+	mBits = static_cast<storagetype>(e);
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>::PxFlags(const PxFlags<enumtype, storagetype>& f)
+{
+	mBits = f.mBits;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>::PxFlags(storagetype b)
+{
+	mBits = b;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE bool PxFlags<enumtype, storagetype>::isSet(enumtype e) const
+{
+	return (mBits & static_cast<storagetype>(e)) == static_cast<storagetype>(e);
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::set(enumtype e)
+{
+	mBits = static_cast<storagetype>(e);
+	return *this;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE bool PxFlags<enumtype, storagetype>::operator==(enumtype e) const
+{
+	return mBits == static_cast<storagetype>(e);
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE bool PxFlags<enumtype, storagetype>::operator==(const PxFlags<enumtype, storagetype>& f) const
+{
+	return mBits == f.mBits;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE bool PxFlags<enumtype, storagetype>::operator==(bool b) const
+{
+	return bool(*this) == b;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE bool PxFlags<enumtype, storagetype>::operator!=(enumtype e) const
+{
+	return mBits != static_cast<storagetype>(e);
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE bool PxFlags<enumtype, storagetype>::operator!=(const PxFlags<enumtype, storagetype>& f) const
+{
+	return mBits != f.mBits;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::operator=(enumtype e)
+{
+	mBits = static_cast<storagetype>(e);
+	return *this;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::operator=(const PxFlags<enumtype, storagetype>& f)
+{
+	mBits = f.mBits;
+	return *this;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::operator|=(enumtype e)
+{
+	mBits |= static_cast<storagetype>(e);
+	return *this;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::
+operator|=(const PxFlags<enumtype, storagetype>& f)
+{
+	mBits |= f.mBits;
+	return *this;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::operator|(enumtype e) const
+{
+	PxFlags<enumtype, storagetype> out(*this);
+	out |= e;
+	return out;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::
+operator|(const PxFlags<enumtype, storagetype>& f) const
+{
+	PxFlags<enumtype, storagetype> out(*this);
+	out |= f;
+	return out;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::operator&=(enumtype e)
+{
+	mBits &= static_cast<storagetype>(e);
+	return *this;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::
+operator&=(const PxFlags<enumtype, storagetype>& f)
+{
+	mBits &= f.mBits;
+	return *this;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::operator&(enumtype e) const
+{
+	PxFlags<enumtype, storagetype> out = *this;
+	out.mBits &= static_cast<storagetype>(e);
+	return out;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::
+operator&(const PxFlags<enumtype, storagetype>& f) const
+{
+	PxFlags<enumtype, storagetype> out = *this;
+	out.mBits &= f.mBits;
+	return out;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::operator^=(enumtype e)
+{
+	mBits ^= static_cast<storagetype>(e);
+	return *this;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>& PxFlags<enumtype, storagetype>::
+operator^=(const PxFlags<enumtype, storagetype>& f)
+{
+	mBits ^= f.mBits;
+	return *this;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::operator^(enumtype e) const
+{
+	PxFlags<enumtype, storagetype> out = *this;
+	out.mBits ^= static_cast<storagetype>(e);
+	return out;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::
+operator^(const PxFlags<enumtype, storagetype>& f) const
+{
+	PxFlags<enumtype, storagetype> out = *this;
+	out.mBits ^= f.mBits;
+	return out;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype> PxFlags<enumtype, storagetype>::operator~(void) const
+{
+	PxFlags<enumtype, storagetype> out;
+	out.mBits = storagetype(~mBits);
+	return out;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>::operator bool(void) const
+{
+	return mBits ? true : false;
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>::operator uint8_t(void) const
+{
+	return static_cast<uint8_t>(mBits);
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>::operator uint16_t(void) const
+{
+	return static_cast<uint16_t>(mBits);
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE PxFlags<enumtype, storagetype>::operator uint32_t(void) const
+{
+	return static_cast<uint32_t>(mBits);
+}
+
+template <typename enumtype, typename storagetype>
+PX_INLINE void PxFlags<enumtype, storagetype>::clear(enumtype e)
+{
+	mBits &= ~static_cast<storagetype>(e);
+}
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXFLAGS_H
diff --git a/PxShared/include/foundation/PxFoundation.h b/PxShared/include/foundation/PxFoundation.h
new file mode 100644
index 00000000..deaeffd1
--- /dev/null
+++ b/PxShared/include/foundation/PxFoundation.h
@@ -0,0 +1,147 @@
+// 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_FOUNDATION_PX_FOUNDATION_H
+#define PX_FOUNDATION_PX_FOUNDATION_H
+
+/** \addtogroup foundation
+  @{
+*/
+
+#include "foundation/Px.h"
+#include "foundation/PxErrors.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief Foundation SDK singleton class.
+
+You need to have an instance of this class to instance the higher level SDKs.
+*/
+class PX_FOUNDATION_API PxFoundation
+{
+  public:
+	/**
+	\brief Destroys the instance it is called on.
+
+	The operation will fail, if there are still modules referencing the foundation object. Release all dependent modules
+	prior
+	to calling this method.
+
+	@see PxCreateFoundation()
+	*/
+	virtual void release() = 0;
+
+	/**
+	retrieves error callback
+	*/
+	virtual PxErrorCallback& getErrorCallback() = 0;
+
+	/**
+	Sets mask of errors to report.
+	*/
+	virtual void setErrorLevel(PxErrorCode::Enum mask = PxErrorCode::eMASK_ALL) = 0;
+
+	/**
+	Retrieves mask of errors to be reported.
+	*/
+	virtual PxErrorCode::Enum getErrorLevel() const = 0;
+
+	/**
+	Retrieves the allocator this object was created with.
+	*/
+	virtual PxAllocatorCallback& getAllocatorCallback() = 0;
+
+	/**
+	Retrieves if allocation names are being passed to allocator callback.
+	*/
+	virtual bool getReportAllocationNames() const = 0;
+
+	/**
+	Set if allocation names are being passed to allocator callback.
+	\details Enabled by default in debug and checked build, disabled by default in profile and release build.
+	*/
+	virtual void setReportAllocationNames(bool value) = 0;
+
+  protected:
+	virtual ~PxFoundation()
+	{
+	}
+};
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/**
+\brief Creates an instance of the foundation class
+
+The foundation class is needed to initialize higher level SDKs. There may be only one instance per process.
+Calling this method after an instance has been created already will result in an error message and NULL will be
+returned.
+
+\param version Version number we are expecting (should be PX_FOUNDATION_VERSION)
+\param allocator User supplied interface for allocating memory(see #PxAllocatorCallback)
+\param errorCallback User supplied interface for reporting errors and displaying messages(see #PxErrorCallback)
+\return Foundation instance on success, NULL if operation failed
+
+@see PxFoundation
+*/
+
+PX_C_EXPORT PX_FOUNDATION_API physx::PxFoundation* PX_CALL_CONV
+PxCreateFoundation(physx::PxU32 version, physx::PxAllocatorCallback& allocator, physx::PxErrorCallback& errorCallback);
+/**
+\brief Retrieves the Foundation SDK after it has been created.
+
+\note The behavior of this method is undefined if the foundation instance has not been created already.
+
+@see PxCreateFoundation()
+*/
+PX_C_EXPORT PX_FOUNDATION_API physx::PxFoundation& PX_CALL_CONV PxGetFoundation();
+
+namespace physx
+{
+class PxProfilerCallback;
+}
+
+/**
+\brief Get the callback that will be used for all profiling.
+*/
+PX_C_EXPORT PX_FOUNDATION_API physx::PxProfilerCallback* PX_CALL_CONV PxGetProfilerCallback();
+
+/**
+\brief Set the callback that will be used for all profiling.
+*/
+PX_C_EXPORT PX_FOUNDATION_API void PX_CALL_CONV PxSetProfilerCallback(physx::PxProfilerCallback* profiler);
+
+/** @} */
+#endif // PX_FOUNDATION_PX_FOUNDATION_H
diff --git a/PxShared/include/foundation/PxFoundationVersion.h b/PxShared/include/foundation/PxFoundationVersion.h
new file mode 100644
index 00000000..7766142d
--- /dev/null
+++ b/PxShared/include/foundation/PxFoundationVersion.h
@@ -0,0 +1,65 @@
+// 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_FOUNDATION_VERSION_NUMBER_H
+#define PX_FOUNDATION_VERSION_NUMBER_H
+
+/*
+VersionNumbers:  The combination of these
+numbers uniquely identifies the API, and should
+be incremented when the SDK API changes.  This may
+include changes to file formats.
+
+This header is included in the main SDK header files
+so that the entire SDK and everything that builds on it
+is completely rebuilt when this file changes.  Thus,
+this file is not to include a frequently changing
+build number.  See BuildNumber.h for that.
+
+Each of these three values should stay below 255 because
+sometimes they are stored in a byte.
+*/
+/** \addtogroup foundation
+  @{
+*/
+
+#define PX_FOUNDATION_VERSION_MAJOR 1
+#define PX_FOUNDATION_VERSION_MINOR 0
+#define PX_FOUNDATION_VERSION_BUGFIX 0
+
+/**
+The constant PX_FOUNDATION_VERSION is used when creating certain PhysX module objects.
+This is to ensure that the application is using the same header version as the library was built with.
+*/
+#define PX_FOUNDATION_VERSION                                                                                          \
+	((PX_FOUNDATION_VERSION_MAJOR << 24) + (PX_FOUNDATION_VERSION_MINOR << 16) + (PX_FOUNDATION_VERSION_BUGFIX << 8) + 0)
+
+#endif // PX_FOUNDATION_VERSION_NUMBER_H
+
+/** @} */
diff --git a/PxShared/include/foundation/PxIO.h b/PxShared/include/foundation/PxIO.h
new file mode 100644
index 00000000..d7b75749
--- /dev/null
+++ b/PxShared/include/foundation/PxIO.h
@@ -0,0 +1,138 @@
+// 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 PXFOUNDATION_PXIO_H
+#define PXFOUNDATION_PXIO_H
+
+/** \addtogroup common
+  @{
+*/
+
+#include "foundation/PxSimpleTypes.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief Input stream class for I/O.
+
+The user needs to supply a PxInputStream implementation to a number of methods to allow the SDK to read data.
+*/
+
+class PxInputStream
+{
+  public:
+	/**
+	\brief read from the stream. The number of bytes read may be less than the number requested.
+
+	\param[in] dest the destination address to which the data will be read
+	\param[in] count the number of bytes requested
+
+	\return the number of bytes read from the stream.
+	*/
+
+	virtual uint32_t read(void* dest, uint32_t count) = 0;
+
+	virtual ~PxInputStream()
+	{
+	}
+};
+
+/**
+\brief Input data class for I/O which provides random read access.
+
+The user needs to supply a PxInputData implementation to a number of methods to allow the SDK to read data.
+*/
+
+class PxInputData : public PxInputStream
+{
+  public:
+	/**
+	\brief return the length of the input data
+
+	\return size in bytes of the input data
+	*/
+
+	virtual uint32_t getLength() const = 0;
+
+	/**
+	\brief seek to the given offset from the start of the data.
+
+	\param[in] offset the offset to seek to. 	If greater than the length of the data, this call is equivalent to
+	seek(length);
+	*/
+
+	virtual void seek(uint32_t offset) = 0;
+
+	/**
+	\brief return the current offset from the start of the data
+
+	\return the offset to seek to.
+	*/
+
+	virtual uint32_t tell() const = 0;
+
+	virtual ~PxInputData()
+	{
+	}
+};
+
+/**
+\brief Output stream class for I/O.
+
+The user needs to supply a PxOutputStream implementation to a number of methods to allow the SDK to write data.
+*/
+
+class PxOutputStream
+{
+  public:
+	/**
+	\brief write to the stream. The number of bytes written may be less than the number sent.
+
+	\param[in] src the destination address from which the data will be written
+	\param[in] count the number of bytes to be written
+
+	\return the number of bytes written to the stream by this call.
+	*/
+
+	virtual uint32_t write(const void* src, uint32_t count) = 0;
+
+	virtual ~PxOutputStream()
+	{
+	}
+};
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXIO_H
diff --git a/PxShared/include/foundation/PxIntrinsics.h b/PxShared/include/foundation/PxIntrinsics.h
new file mode 100644
index 00000000..ad354850
--- /dev/null
+++ b/PxShared/include/foundation/PxIntrinsics.h
@@ -0,0 +1,45 @@
+// 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 PXFOUNDATION_PXINTRINSICS_H
+#define PXFOUNDATION_PXINTRINSICS_H
+
+#include "foundation/PxPreprocessor.h"
+
+#if PX_WINDOWS_FAMILY
+#include "foundation/windows/PxWindowsIntrinsics.h"
+#elif(PX_LINUX || PX_ANDROID || PX_APPLE_FAMILY || PX_PS4)
+#include "foundation/unix/PxUnixIntrinsics.h"
+#elif PX_XBOXONE
+#include "foundation/XboxOne/PxXboxOneIntrinsics.h"
+#else
+#error "Platform not supported!"
+#endif
+
+#endif // #ifndef PXFOUNDATION_PXINTRINSICS_H
diff --git a/PxShared/include/foundation/PxMat33.h b/PxShared/include/foundation/PxMat33.h
new file mode 100644
index 00000000..53720bba
--- /dev/null
+++ b/PxShared/include/foundation/PxMat33.h
@@ -0,0 +1,396 @@
+// 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 PXFOUNDATION_PXMAT33_H
+#define PXFOUNDATION_PXMAT33_H
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/PxVec3.h"
+#include "foundation/PxQuat.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+/*!
+\brief 3x3 matrix class
+
+Some clarifications, as there have been much confusion about matrix formats etc in the past.
+
+Short:
+- Matrix have base vectors in columns (vectors are column matrices, 3x1 matrices).
+- Matrix is physically stored in column major format
+- Matrices are concaternated from left
+
+Long:
+Given three base vectors a, b and c the matrix is stored as
+
+|a.x b.x c.x|
+|a.y b.y c.y|
+|a.z b.z c.z|
+
+Vectors are treated as columns, so the vector v is
+
+|x|
+|y|
+|z|
+
+And matrices are applied _before_ the vector (pre-multiplication)
+v' = M*v
+
+|x'|   |a.x b.x c.x|   |x|   |a.x*x + b.x*y + c.x*z|
+|y'| = |a.y b.y c.y| * |y| = |a.y*x + b.y*y + c.y*z|
+|z'|   |a.z b.z c.z|   |z|   |a.z*x + b.z*y + c.z*z|
+
+
+Physical storage and indexing:
+To be compatible with popular 3d rendering APIs (read D3d and OpenGL)
+the physical indexing is
+
+|0 3 6|
+|1 4 7|
+|2 5 8|
+
+index = column*3 + row
+
+which in C++ translates to M[column][row]
+
+The mathematical indexing is M_row,column and this is what is used for _-notation
+so _12 is 1st row, second column and operator(row, column)!
+
+*/
+class PxMat33
+{
+  public:
+	//! Default constructor
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxMat33()
+	{
+	}
+
+	//! identity constructor
+	PX_CUDA_CALLABLE PX_INLINE PxMat33(PxIDENTITY r)
+	: column0(1.0f, 0.0f, 0.0f), column1(0.0f, 1.0f, 0.0f), column2(0.0f, 0.0f, 1.0f)
+	{
+		PX_UNUSED(r);
+	}
+
+	//! zero constructor
+	PX_CUDA_CALLABLE PX_INLINE PxMat33(PxZERO r) : column0(0.0f), column1(0.0f), column2(0.0f)
+	{
+		PX_UNUSED(r);
+	}
+
+	//! Construct from three base vectors
+	PX_CUDA_CALLABLE PxMat33(const PxVec3& col0, const PxVec3& col1, const PxVec3& col2)
+	: column0(col0), column1(col1), column2(col2)
+	{
+	}
+
+	//! constructor from a scalar, which generates a multiple of the identity matrix
+	explicit PX_CUDA_CALLABLE PX_INLINE PxMat33(float r)
+	: column0(r, 0.0f, 0.0f), column1(0.0f, r, 0.0f), column2(0.0f, 0.0f, r)
+	{
+	}
+
+	//! Construct from float[9]
+	explicit PX_CUDA_CALLABLE PX_INLINE PxMat33(float values[])
+	: column0(values[0], values[1], values[2])
+	, column1(values[3], values[4], values[5])
+	, column2(values[6], values[7], values[8])
+	{
+	}
+
+	//! Construct from a quaternion
+	explicit PX_CUDA_CALLABLE PX_FORCE_INLINE PxMat33(const PxQuat& q)
+	{
+		const float x = q.x;
+		const float y = q.y;
+		const float z = q.z;
+		const float w = q.w;
+
+		const float x2 = x + x;
+		const float y2 = y + y;
+		const float z2 = z + z;
+
+		const float xx = x2 * x;
+		const float yy = y2 * y;
+		const float zz = z2 * z;
+
+		const float xy = x2 * y;
+		const float xz = x2 * z;
+		const float xw = x2 * w;
+
+		const float yz = y2 * z;
+		const float yw = y2 * w;
+		const float zw = z2 * w;
+
+		column0 = PxVec3(1.0f - yy - zz, xy + zw, xz - yw);
+		column1 = PxVec3(xy - zw, 1.0f - xx - zz, yz + xw);
+		column2 = PxVec3(xz + yw, yz - xw, 1.0f - xx - yy);
+	}
+
+	//! Copy constructor
+	PX_CUDA_CALLABLE PX_INLINE PxMat33(const PxMat33& other)
+	: column0(other.column0), column1(other.column1), column2(other.column2)
+	{
+	}
+
+	//! Assignment operator
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxMat33& operator=(const PxMat33& other)
+	{
+		column0 = other.column0;
+		column1 = other.column1;
+		column2 = other.column2;
+		return *this;
+	}
+
+	//! Construct from diagonal, off-diagonals are zero.
+	PX_CUDA_CALLABLE PX_INLINE static const PxMat33 createDiagonal(const PxVec3& d)
+	{
+		return PxMat33(PxVec3(d.x, 0.0f, 0.0f), PxVec3(0.0f, d.y, 0.0f), PxVec3(0.0f, 0.0f, d.z));
+	}
+
+	/**
+	\brief returns true if the two matrices are exactly equal
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool operator==(const PxMat33& m) const
+	{
+		return column0 == m.column0 && column1 == m.column1 && column2 == m.column2;
+	}
+
+	//! Get transposed matrix
+	PX_CUDA_CALLABLE PX_FORCE_INLINE const PxMat33 getTranspose() const
+	{
+		const PxVec3 v0(column0.x, column1.x, column2.x);
+		const PxVec3 v1(column0.y, column1.y, column2.y);
+		const PxVec3 v2(column0.z, column1.z, column2.z);
+
+		return PxMat33(v0, v1, v2);
+	}
+
+	//! Get the real inverse
+	PX_CUDA_CALLABLE PX_INLINE const PxMat33 getInverse() const
+	{
+		const float det = getDeterminant();
+		PxMat33 inverse;
+
+		if(det != 0)
+		{
+			const float invDet = 1.0f / det;
+
+			inverse.column0.x = invDet * (column1.y * column2.z - column2.y * column1.z);
+			inverse.column0.y = invDet * -(column0.y * column2.z - column2.y * column0.z);
+			inverse.column0.z = invDet * (column0.y * column1.z - column0.z * column1.y);
+
+			inverse.column1.x = invDet * -(column1.x * column2.z - column1.z * column2.x);
+			inverse.column1.y = invDet * (column0.x * column2.z - column0.z * column2.x);
+			inverse.column1.z = invDet * -(column0.x * column1.z - column0.z * column1.x);
+
+			inverse.column2.x = invDet * (column1.x * column2.y - column1.y * column2.x);
+			inverse.column2.y = invDet * -(column0.x * column2.y - column0.y * column2.x);
+			inverse.column2.z = invDet * (column0.x * column1.y - column1.x * column0.y);
+
+			return inverse;
+		}
+		else
+		{
+			return PxMat33(PxIdentity);
+		}
+	}
+
+	//! Get determinant
+	PX_CUDA_CALLABLE PX_INLINE float getDeterminant() const
+	{
+		return column0.dot(column1.cross(column2));
+	}
+
+	//! Unary minus
+	PX_CUDA_CALLABLE PX_INLINE const PxMat33 operator-() const
+	{
+		return PxMat33(-column0, -column1, -column2);
+	}
+
+	//! Add
+	PX_CUDA_CALLABLE PX_INLINE const PxMat33 operator+(const PxMat33& other) const
+	{
+		return PxMat33(column0 + other.column0, column1 + other.column1, column2 + other.column2);
+	}
+
+	//! Subtract
+	PX_CUDA_CALLABLE PX_INLINE const PxMat33 operator-(const PxMat33& other) const
+	{
+		return PxMat33(column0 - other.column0, column1 - other.column1, column2 - other.column2);
+	}
+
+	//! Scalar multiplication
+	PX_CUDA_CALLABLE PX_INLINE const PxMat33 operator*(float scalar) const
+	{
+		return PxMat33(column0 * scalar, column1 * scalar, column2 * scalar);
+	}
+
+	friend PxMat33 operator*(float, const PxMat33&);
+
+	//! Matrix vector multiplication (returns 'this->transform(vec)')
+	PX_CUDA_CALLABLE PX_INLINE const PxVec3 operator*(const PxVec3& vec) const
+	{
+		return transform(vec);
+	}
+
+	// a <op>= b operators
+
+	//! Matrix multiplication
+	PX_CUDA_CALLABLE PX_FORCE_INLINE const PxMat33 operator*(const PxMat33& other) const
+	{
+		// Rows from this <dot> columns from other
+		// column0 = transform(other.column0) etc
+		return PxMat33(transform(other.column0), transform(other.column1), transform(other.column2));
+	}
+
+	//! Equals-add
+	PX_CUDA_CALLABLE PX_INLINE PxMat33& operator+=(const PxMat33& other)
+	{
+		column0 += other.column0;
+		column1 += other.column1;
+		column2 += other.column2;
+		return *this;
+	}
+
+	//! Equals-sub
+	PX_CUDA_CALLABLE PX_INLINE PxMat33& operator-=(const PxMat33& other)
+	{
+		column0 -= other.column0;
+		column1 -= other.column1;
+		column2 -= other.column2;
+		return *this;
+	}
+
+	//! Equals scalar multiplication
+	PX_CUDA_CALLABLE PX_INLINE PxMat33& operator*=(float scalar)
+	{
+		column0 *= scalar;
+		column1 *= scalar;
+		column2 *= scalar;
+		return *this;
+	}
+
+	//! Equals matrix multiplication
+	PX_CUDA_CALLABLE PX_INLINE PxMat33& operator*=(const PxMat33& other)
+	{
+		*this = *this * other;
+		return *this;
+	}
+
+	//! Element access, mathematical way!
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE float operator()(unsigned int row, unsigned int col) const
+	{
+		return (*this)[col][row];
+	}
+
+	//! Element access, mathematical way!
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE float& operator()(unsigned int row, unsigned int col)
+	{
+		return (*this)[col][row];
+	}
+
+	// Transform etc
+
+	//! Transform vector by matrix, equal to v' = M*v
+	PX_CUDA_CALLABLE PX_FORCE_INLINE const PxVec3 transform(const PxVec3& other) const
+	{
+		return column0 * other.x + column1 * other.y + column2 * other.z;
+	}
+
+	//! Transform vector by matrix transpose, v' = M^t*v
+	PX_CUDA_CALLABLE PX_INLINE const PxVec3 transformTranspose(const PxVec3& other) const
+	{
+		return PxVec3(column0.dot(other), column1.dot(other), column2.dot(other));
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE const float* front() const
+	{
+		return &column0.x;
+	}
+
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3& operator[](unsigned int num)
+	{
+		return (&column0)[num];
+	}
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE const PxVec3& operator[](unsigned int num) const
+	{
+		return (&column0)[num];
+	}
+
+	// Data, see above for format!
+
+	PxVec3 column0, column1, column2; // the three base vectors
+};
+
+// implementation from PxQuat.h
+PX_CUDA_CALLABLE PX_INLINE PxQuat::PxQuat(const PxMat33& m)
+{
+	if(m.column2.z < 0)
+	{
+		if(m.column0.x > m.column1.y)
+		{
+			float t = 1 + m.column0.x - m.column1.y - m.column2.z;
+			*this = PxQuat(t, m.column0.y + m.column1.x, m.column2.x + m.column0.z, m.column1.z - m.column2.y) *
+			        (0.5f / PxSqrt(t));
+		}
+		else
+		{
+			float t = 1 - m.column0.x + m.column1.y - m.column2.z;
+			*this = PxQuat(m.column0.y + m.column1.x, t, m.column1.z + m.column2.y, m.column2.x - m.column0.z) *
+			        (0.5f / PxSqrt(t));
+		}
+	}
+	else
+	{
+		if(m.column0.x < -m.column1.y)
+		{
+			float t = 1 - m.column0.x - m.column1.y + m.column2.z;
+			*this = PxQuat(m.column2.x + m.column0.z, m.column1.z + m.column2.y, t, m.column0.y - m.column1.x) *
+			        (0.5f / PxSqrt(t));
+		}
+		else
+		{
+			float t = 1 + m.column0.x + m.column1.y + m.column2.z;
+			*this = PxQuat(m.column1.z - m.column2.y, m.column2.x - m.column0.z, m.column0.y - m.column1.x, t) *
+			        (0.5f / PxSqrt(t));
+		}
+	}
+}
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXMAT33_H
diff --git a/PxShared/include/foundation/PxMat44.h b/PxShared/include/foundation/PxMat44.h
new file mode 100644
index 00000000..f6445468
--- /dev/null
+++ b/PxShared/include/foundation/PxMat44.h
@@ -0,0 +1,376 @@
+// 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 PXFOUNDATION_PXMAT44_H
+#define PXFOUNDATION_PXMAT44_H
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/PxQuat.h"
+#include "foundation/PxVec4.h"
+#include "foundation/PxMat33.h"
+#include "foundation/PxTransform.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/*!
+\brief 4x4 matrix class
+
+This class is layout-compatible with D3D and OpenGL matrices. More notes on layout are given in the PxMat33
+
+@see PxMat33 PxTransform
+*/
+
+class PxMat44
+{
+  public:
+	//! Default constructor
+	PX_CUDA_CALLABLE PX_INLINE PxMat44()
+	{
+	}
+
+	//! identity constructor
+	PX_CUDA_CALLABLE PX_INLINE PxMat44(PxIDENTITY r)
+	: column0(1.0f, 0.0f, 0.0f, 0.0f)
+	, column1(0.0f, 1.0f, 0.0f, 0.0f)
+	, column2(0.0f, 0.0f, 1.0f, 0.0f)
+	, column3(0.0f, 0.0f, 0.0f, 1.0f)
+	{
+		PX_UNUSED(r);
+	}
+
+	//! zero constructor
+	PX_CUDA_CALLABLE PX_INLINE PxMat44(PxZERO r) : column0(PxZero), column1(PxZero), column2(PxZero), column3(PxZero)
+	{
+		PX_UNUSED(r);
+	}
+
+	//! Construct from four 4-vectors
+	PX_CUDA_CALLABLE PxMat44(const PxVec4& col0, const PxVec4& col1, const PxVec4& col2, const PxVec4& col3)
+	: column0(col0), column1(col1), column2(col2), column3(col3)
+	{
+	}
+
+	//! constructor that generates a multiple of the identity matrix
+	explicit PX_CUDA_CALLABLE PX_INLINE PxMat44(float r)
+	: column0(r, 0.0f, 0.0f, 0.0f)
+	, column1(0.0f, r, 0.0f, 0.0f)
+	, column2(0.0f, 0.0f, r, 0.0f)
+	, column3(0.0f, 0.0f, 0.0f, r)
+	{
+	}
+
+	//! Construct from three base vectors and a translation
+	PX_CUDA_CALLABLE PxMat44(const PxVec3& col0, const PxVec3& col1, const PxVec3& col2, const PxVec3& col3)
+	: column0(col0, 0), column1(col1, 0), column2(col2, 0), column3(col3, 1.0f)
+	{
+	}
+
+	//! Construct from float[16]
+	explicit PX_CUDA_CALLABLE PX_INLINE PxMat44(float values[])
+	: column0(values[0], values[1], values[2], values[3])
+	, column1(values[4], values[5], values[6], values[7])
+	, column2(values[8], values[9], values[10], values[11])
+	, column3(values[12], values[13], values[14], values[15])
+	{
+	}
+
+	//! Construct from a quaternion
+	explicit PX_CUDA_CALLABLE PX_INLINE PxMat44(const PxQuat& q)
+	{
+		const float x = q.x;
+		const float y = q.y;
+		const float z = q.z;
+		const float w = q.w;
+
+		const float x2 = x + x;
+		const float y2 = y + y;
+		const float z2 = z + z;
+
+		const float xx = x2 * x;
+		const float yy = y2 * y;
+		const float zz = z2 * z;
+
+		const float xy = x2 * y;
+		const float xz = x2 * z;
+		const float xw = x2 * w;
+
+		const float yz = y2 * z;
+		const float yw = y2 * w;
+		const float zw = z2 * w;
+
+		column0 = PxVec4(1.0f - yy - zz, xy + zw, xz - yw, 0.0f);
+		column1 = PxVec4(xy - zw, 1.0f - xx - zz, yz + xw, 0.0f);
+		column2 = PxVec4(xz + yw, yz - xw, 1.0f - xx - yy, 0.0f);
+		column3 = PxVec4(0.0f, 0.0f, 0.0f, 1.0f);
+	}
+
+	//! Construct from a diagonal vector
+	explicit PX_CUDA_CALLABLE PX_INLINE PxMat44(const PxVec4& diagonal)
+	: column0(diagonal.x, 0.0f, 0.0f, 0.0f)
+	, column1(0.0f, diagonal.y, 0.0f, 0.0f)
+	, column2(0.0f, 0.0f, diagonal.z, 0.0f)
+	, column3(0.0f, 0.0f, 0.0f, diagonal.w)
+	{
+	}
+
+	//! Construct from Mat33 and a translation
+	PX_CUDA_CALLABLE PxMat44(const PxMat33& axes, const PxVec3& position)
+	: column0(axes.column0, 0.0f), column1(axes.column1, 0.0f), column2(axes.column2, 0.0f), column3(position, 1.0f)
+	{
+	}
+
+	PX_CUDA_CALLABLE PxMat44(const PxTransform& t)
+	{
+		*this = PxMat44(PxMat33(t.q), t.p);
+	}
+
+	/**
+	\brief returns true if the two matrices are exactly equal
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool operator==(const PxMat44& m) const
+	{
+		return column0 == m.column0 && column1 == m.column1 && column2 == m.column2 && column3 == m.column3;
+	}
+
+	//! Copy constructor
+	PX_CUDA_CALLABLE PX_INLINE PxMat44(const PxMat44& other)
+	: column0(other.column0), column1(other.column1), column2(other.column2), column3(other.column3)
+	{
+	}
+
+	//! Assignment operator
+	PX_CUDA_CALLABLE PX_INLINE PxMat44& operator=(const PxMat44& other)
+	{
+		column0 = other.column0;
+		column1 = other.column1;
+		column2 = other.column2;
+		column3 = other.column3;
+		return *this;
+	}
+
+	//! Get transposed matrix
+	PX_CUDA_CALLABLE PX_INLINE const PxMat44 getTranspose() const
+	{
+		return PxMat44(
+		    PxVec4(column0.x, column1.x, column2.x, column3.x), PxVec4(column0.y, column1.y, column2.y, column3.y),
+		    PxVec4(column0.z, column1.z, column2.z, column3.z), PxVec4(column0.w, column1.w, column2.w, column3.w));
+	}
+
+	//! Unary minus
+	PX_CUDA_CALLABLE PX_INLINE const PxMat44 operator-() const
+	{
+		return PxMat44(-column0, -column1, -column2, -column3);
+	}
+
+	//! Add
+	PX_CUDA_CALLABLE PX_INLINE const PxMat44 operator+(const PxMat44& other) const
+	{
+		return PxMat44(column0 + other.column0, column1 + other.column1, column2 + other.column2,
+		               column3 + other.column3);
+	}
+
+	//! Subtract
+	PX_CUDA_CALLABLE PX_INLINE const PxMat44 operator-(const PxMat44& other) const
+	{
+		return PxMat44(column0 - other.column0, column1 - other.column1, column2 - other.column2,
+		               column3 - other.column3);
+	}
+
+	//! Scalar multiplication
+	PX_CUDA_CALLABLE PX_INLINE const PxMat44 operator*(float scalar) const
+	{
+		return PxMat44(column0 * scalar, column1 * scalar, column2 * scalar, column3 * scalar);
+	}
+
+	friend PxMat44 operator*(float, const PxMat44&);
+
+	//! Matrix multiplication
+	PX_CUDA_CALLABLE PX_INLINE const PxMat44 operator*(const PxMat44& other) const
+	{
+		// Rows from this <dot> columns from other
+		// column0 = transform(other.column0) etc
+		return PxMat44(transform(other.column0), transform(other.column1), transform(other.column2),
+		               transform(other.column3));
+	}
+
+	// a <op>= b operators
+
+	//! Equals-add
+	PX_CUDA_CALLABLE PX_INLINE PxMat44& operator+=(const PxMat44& other)
+	{
+		column0 += other.column0;
+		column1 += other.column1;
+		column2 += other.column2;
+		column3 += other.column3;
+		return *this;
+	}
+
+	//! Equals-sub
+	PX_CUDA_CALLABLE PX_INLINE PxMat44& operator-=(const PxMat44& other)
+	{
+		column0 -= other.column0;
+		column1 -= other.column1;
+		column2 -= other.column2;
+		column3 -= other.column3;
+		return *this;
+	}
+
+	//! Equals scalar multiplication
+	PX_CUDA_CALLABLE PX_INLINE PxMat44& operator*=(float scalar)
+	{
+		column0 *= scalar;
+		column1 *= scalar;
+		column2 *= scalar;
+		column3 *= scalar;
+		return *this;
+	}
+
+	//! Equals matrix multiplication
+	PX_CUDA_CALLABLE PX_INLINE PxMat44& operator*=(const PxMat44& other)
+	{
+		*this = *this * other;
+		return *this;
+	}
+
+	//! Element access, mathematical way!
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE float operator()(unsigned int row, unsigned int col) const
+	{
+		return (*this)[col][row];
+	}
+
+	//! Element access, mathematical way!
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE float& operator()(unsigned int row, unsigned int col)
+	{
+		return (*this)[col][row];
+	}
+
+	//! Transform vector by matrix, equal to v' = M*v
+	PX_CUDA_CALLABLE PX_INLINE const PxVec4 transform(const PxVec4& other) const
+	{
+		return column0 * other.x + column1 * other.y + column2 * other.z + column3 * other.w;
+	}
+
+	//! Transform vector by matrix, equal to v' = M*v
+	PX_CUDA_CALLABLE PX_INLINE const PxVec3 transform(const PxVec3& other) const
+	{
+		return transform(PxVec4(other, 1.0f)).getXYZ();
+	}
+
+	//! Rotate vector by matrix, equal to v' = M*v
+	PX_CUDA_CALLABLE PX_INLINE const PxVec4 rotate(const PxVec4& other) const
+	{
+		return column0 * other.x + column1 * other.y + column2 * other.z; // + column3*0;
+	}
+
+	//! Rotate vector by matrix, equal to v' = M*v
+	PX_CUDA_CALLABLE PX_INLINE const PxVec3 rotate(const PxVec3& other) const
+	{
+		return rotate(PxVec4(other, 1.0f)).getXYZ();
+	}
+
+	PX_CUDA_CALLABLE PX_INLINE const PxVec3 getBasis(int num) const
+	{
+		PX_ASSERT(num >= 0 && num < 3);
+		return (&column0)[num].getXYZ();
+	}
+
+	PX_CUDA_CALLABLE PX_INLINE const PxVec3 getPosition() const
+	{
+		return column3.getXYZ();
+	}
+
+	PX_CUDA_CALLABLE PX_INLINE void setPosition(const PxVec3& position)
+	{
+		column3.x = position.x;
+		column3.y = position.y;
+		column3.z = position.z;
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE const float* front() const
+	{
+		return &column0.x;
+	}
+
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec4& operator[](unsigned int num)
+	{
+		return (&column0)[num];
+	}
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE const PxVec4& operator[](unsigned int num) const
+	{
+		return (&column0)[num];
+	}
+
+	PX_CUDA_CALLABLE PX_INLINE void scale(const PxVec4& p)
+	{
+		column0 *= p.x;
+		column1 *= p.y;
+		column2 *= p.z;
+		column3 *= p.w;
+	}
+
+	PX_CUDA_CALLABLE PX_INLINE const PxMat44 inverseRT(void) const
+	{
+		PxVec3 r0(column0.x, column1.x, column2.x), r1(column0.y, column1.y, column2.y),
+		    r2(column0.z, column1.z, column2.z);
+
+		return PxMat44(r0, r1, r2, -(r0 * column3.x + r1 * column3.y + r2 * column3.z));
+	}
+
+	PX_CUDA_CALLABLE PX_INLINE bool isFinite() const
+	{
+		return column0.isFinite() && column1.isFinite() && column2.isFinite() && column3.isFinite();
+	}
+
+	// Data, see above for format!
+
+	PxVec4 column0, column1, column2, column3; // the four base vectors
+};
+
+// implementation from PxTransform.h
+PX_CUDA_CALLABLE PX_FORCE_INLINE PxTransform::PxTransform(const PxMat44& m)
+{
+	PxVec3 column0 = PxVec3(m.column0.x, m.column0.y, m.column0.z);
+	PxVec3 column1 = PxVec3(m.column1.x, m.column1.y, m.column1.z);
+	PxVec3 column2 = PxVec3(m.column2.x, m.column2.y, m.column2.z);
+
+	q = PxQuat(PxMat33(column0, column1, column2));
+	p = PxVec3(m.column3.x, m.column3.y, m.column3.z);
+}
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXMAT44_H
diff --git a/PxShared/include/foundation/PxMath.h b/PxShared/include/foundation/PxMath.h
new file mode 100644
index 00000000..c3434dcc
--- /dev/null
+++ b/PxShared/include/foundation/PxMath.h
@@ -0,0 +1,338 @@
+// 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 PXFOUNDATION_PXMATH_H
+#define PXFOUNDATION_PXMATH_H
+
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/PxPreprocessor.h"
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable : 4985) // 'symbol name': attributes not present on previous declaration
+#endif
+#include <math.h>
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#include <float.h>
+#include "foundation/PxIntrinsics.h"
+#include "foundation/PxAssert.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+// constants
+static const float PxPi = float(3.141592653589793);
+static const float PxHalfPi = float(1.57079632679489661923);
+static const float PxTwoPi = float(6.28318530717958647692);
+static const float PxInvPi = float(0.31830988618379067154);
+static const float PxInvTwoPi = float(0.15915494309189533577);
+static const float PxPiDivTwo = float(1.57079632679489661923);
+static const float PxPiDivFour = float(0.78539816339744830962);
+
+/**
+\brief The return value is the greater of the two specified values.
+*/
+template <class T>
+PX_CUDA_CALLABLE PX_FORCE_INLINE T PxMax(T a, T b)
+{
+	return a < b ? b : a;
+}
+
+//! overload for float to use fsel on xbox
+template <>
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxMax(float a, float b)
+{
+	return intrinsics::selectMax(a, b);
+}
+
+/**
+\brief The return value is the lesser of the two specified values.
+*/
+template <class T>
+PX_CUDA_CALLABLE PX_FORCE_INLINE T PxMin(T a, T b)
+{
+	return a < b ? a : b;
+}
+
+template <>
+//! overload for float to use fsel on xbox
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxMin(float a, float b)
+{
+	return intrinsics::selectMin(a, b);
+}
+
+/*
+Many of these are just implemented as PX_CUDA_CALLABLE PX_FORCE_INLINE calls to the C lib right now,
+but later we could replace some of them with some approximations or more
+clever stuff.
+*/
+
+/**
+\brief abs returns the absolute value of its argument.
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxAbs(float a)
+{
+	return intrinsics::abs(a);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxEquals(float a, float b, float eps)
+{
+	return (PxAbs(a - b) < eps);
+}
+
+/**
+\brief abs returns the absolute value of its argument.
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE double PxAbs(double a)
+{
+	return ::fabs(a);
+}
+
+/**
+\brief abs returns the absolute value of its argument.
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE int32_t PxAbs(int32_t a)
+{
+	return ::abs(a);
+}
+
+/**
+\brief Clamps v to the range [hi,lo]
+*/
+template <class T>
+PX_CUDA_CALLABLE PX_FORCE_INLINE T PxClamp(T v, T lo, T hi)
+{
+	PX_ASSERT(lo <= hi);
+	return PxMin(hi, PxMax(lo, v));
+}
+
+//!	\brief Square root.
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxSqrt(float a)
+{
+	return intrinsics::sqrt(a);
+}
+
+//!	\brief Square root.
+PX_CUDA_CALLABLE PX_FORCE_INLINE double PxSqrt(double a)
+{
+	return ::sqrt(a);
+}
+
+//!	\brief reciprocal square root.
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxRecipSqrt(float a)
+{
+	return intrinsics::recipSqrt(a);
+}
+
+//!	\brief reciprocal square root.
+PX_CUDA_CALLABLE PX_FORCE_INLINE double PxRecipSqrt(double a)
+{
+	return 1 / ::sqrt(a);
+}
+
+//! trigonometry -- all angles are in radians.
+
+//!	\brief Sine of an angle ( <b>Unit:</b> Radians )
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxSin(float a)
+{
+	return intrinsics::sin(a);
+}
+
+//!	\brief Sine of an angle ( <b>Unit:</b> Radians )
+PX_CUDA_CALLABLE PX_FORCE_INLINE double PxSin(double a)
+{
+	return ::sin(a);
+}
+
+//!	\brief Cosine of an angle (<b>Unit:</b> Radians)
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxCos(float a)
+{
+	return intrinsics::cos(a);
+}
+
+//!	\brief Cosine of an angle (<b>Unit:</b> Radians)
+PX_CUDA_CALLABLE PX_FORCE_INLINE double PxCos(double a)
+{
+	return ::cos(a);
+}
+
+/**
+\brief Tangent of an angle.
+<b>Unit:</b> Radians
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxTan(float a)
+{
+	return ::tanf(a);
+}
+
+/**
+\brief Tangent of an angle.
+<b>Unit:</b> Radians
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE double PxTan(double a)
+{
+	return ::tan(a);
+}
+
+/**
+\brief Arcsine.
+Returns angle between -PI/2 and PI/2 in radians
+<b>Unit:</b> Radians
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxAsin(float f)
+{
+	return ::asinf(PxClamp(f, -1.0f, 1.0f));
+}
+
+/**
+\brief Arcsine.
+Returns angle between -PI/2 and PI/2 in radians
+<b>Unit:</b> Radians
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE double PxAsin(double f)
+{
+	return ::asin(PxClamp(f, -1.0, 1.0));
+}
+
+/**
+\brief Arccosine.
+Returns angle between 0 and PI in radians
+<b>Unit:</b> Radians
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxAcos(float f)
+{
+	return ::acosf(PxClamp(f, -1.0f, 1.0f));
+}
+
+/**
+\brief Arccosine.
+Returns angle between 0 and PI in radians
+<b>Unit:</b> Radians
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE double PxAcos(double f)
+{
+	return ::acos(PxClamp(f, -1.0, 1.0));
+}
+
+/**
+\brief ArcTangent.
+Returns angle between -PI/2 and PI/2 in radians
+<b>Unit:</b> Radians
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxAtan(float a)
+{
+	return ::atanf(a);
+}
+
+/**
+\brief ArcTangent.
+Returns angle between -PI/2 and PI/2 in radians
+<b>Unit:</b> Radians
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE double PxAtan(double a)
+{
+	return ::atan(a);
+}
+
+/**
+\brief Arctangent of (x/y) with correct sign.
+Returns angle between -PI and PI in radians
+<b>Unit:</b> Radians
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxAtan2(float x, float y)
+{
+	return ::atan2f(x, y);
+}
+
+/**
+\brief Arctangent of (x/y) with correct sign.
+Returns angle between -PI and PI in radians
+<b>Unit:</b> Radians
+*/
+PX_CUDA_CALLABLE PX_FORCE_INLINE double PxAtan2(double x, double y)
+{
+	return ::atan2(x, y);
+}
+
+//!	\brief returns true if the passed number is a finite floating point number as opposed to INF, NAN, etc.
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxIsFinite(float f)
+{
+	return intrinsics::isFinite(f);
+}
+
+//!	\brief returns true if the passed number is a finite floating point number as opposed to INF, NAN, etc.
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool PxIsFinite(double f)
+{
+	return intrinsics::isFinite(f);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxFloor(float a)
+{
+	return ::floorf(a);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxExp(float a)
+{
+	return ::expf(a);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxCeil(float a)
+{
+	return ::ceilf(a);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxSign(float a)
+{
+	return physx::intrinsics::sign(a);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxPow(float x, float y)
+{
+	return ::powf(x, y);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE float PxLog(float x)
+{
+	return ::logf(x);
+}
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXMATH_H
diff --git a/PxShared/include/foundation/PxMathUtils.h b/PxShared/include/foundation/PxMathUtils.h
new file mode 100644
index 00000000..6897dad2
--- /dev/null
+++ b/PxShared/include/foundation/PxMathUtils.h
@@ -0,0 +1,73 @@
+// 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 PXFOUNDATION_PXMATHUTILS_H
+#define PXFOUNDATION_PXMATHUTILS_H
+
+/** \addtogroup common
+  @{
+*/
+
+#include "foundation/Px.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief finds the shortest rotation between two vectors.
+
+\param[in] from the vector to start from
+\param[in] target the vector to rotate to
+\return a rotation about an axis normal to the two vectors which takes one to the other via the shortest path
+*/
+
+PX_FOUNDATION_API PxQuat PxShortestRotation(const PxVec3& from, const PxVec3& target);
+
+/* \brief diagonalizes a 3x3 symmetric matrix y
+
+The returned matrix satisfies M = R * D * R', where R is the rotation matrix for the output quaternion, R' its
+transpose, and D the diagonal matrix
+
+If the matrix is not symmetric, the result is undefined.
+
+\param[in] m the matrix to diagonalize
+\param[out] axes a quaternion rotation which diagonalizes the matrix
+\return the vector diagonal of the diagonalized matrix.
+*/
+
+PX_FOUNDATION_API PxVec3 PxDiagonalize(const PxMat33& m, PxQuat& axes);
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif
diff --git a/PxShared/include/foundation/PxMemory.h b/PxShared/include/foundation/PxMemory.h
new file mode 100644
index 00000000..9bf108cc
--- /dev/null
+++ b/PxShared/include/foundation/PxMemory.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 PXFOUNDATION_PXMEMORY_H
+#define PXFOUNDATION_PXMEMORY_H
+
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/Px.h"
+#include "foundation/PxIntrinsics.h"
+#include "foundation/PxSimpleTypes.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief Sets the bytes of the provided buffer to zero.
+
+\param dest Pointer to block of memory to set zero.
+\param count Number of bytes to set to zero.
+
+\return Pointer to memory block (same as input)
+*/
+PX_FORCE_INLINE void* PxMemZero(void* dest, PxU32 count)
+{
+	return physx::intrinsics::memZero(dest, count);
+}
+
+/**
+\brief Sets the bytes of the provided buffer to the specified value.
+
+\param dest Pointer to block of memory to set to the specified value.
+\param c Value to set the bytes of the block of memory to.
+\param count Number of bytes to set to the specified value.
+
+\return Pointer to memory block (same as input)
+*/
+PX_FORCE_INLINE void* PxMemSet(void* dest, PxI32 c, PxU32 count)
+{
+	return physx::intrinsics::memSet(dest, c, count);
+}
+
+/**
+\brief Copies the bytes of one memory block to another. The memory blocks must not overlap.
+
+\note Use #PxMemMove if memory blocks overlap.
+
+\param dest Pointer to block of memory to copy to.
+\param src Pointer to block of memory to copy from.
+\param count Number of bytes to copy.
+
+\return Pointer to destination memory block
+*/
+PX_FORCE_INLINE void* PxMemCopy(void* dest, const void* src, PxU32 count)
+{
+	return physx::intrinsics::memCopy(dest, src, count);
+}
+
+/**
+\brief Copies the bytes of one memory block to another. The memory blocks can overlap.
+
+\note Use #PxMemCopy if memory blocks do not overlap.
+
+\param dest Pointer to block of memory to copy to.
+\param src Pointer to block of memory to copy from.
+\param count Number of bytes to copy.
+
+\return Pointer to destination memory block
+*/
+PX_FORCE_INLINE void* PxMemMove(void* dest, const void* src, PxU32 count)
+{
+	return physx::intrinsics::memMove(dest, src, count);
+}
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // PXFOUNDATION_PXMEMORY_H
diff --git a/PxShared/include/foundation/PxPlane.h b/PxShared/include/foundation/PxPlane.h
new file mode 100644
index 00000000..2b4671f7
--- /dev/null
+++ b/PxShared/include/foundation/PxPlane.h
@@ -0,0 +1,145 @@
+// 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 PXFOUNDATION_PXPLANE_H
+#define PXFOUNDATION_PXPLANE_H
+
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/PxMath.h"
+#include "foundation/PxVec3.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief Representation of a plane.
+
+ Plane equation used: n.dot(v) + d = 0
+*/
+class PxPlane
+{
+  public:
+	/**
+	\brief Constructor
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxPlane()
+	{
+	}
+
+	/**
+	\brief Constructor from a normal and a distance
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxPlane(float nx, float ny, float nz, float distance) : n(nx, ny, nz), d(distance)
+	{
+	}
+
+	/**
+	\brief Constructor from a normal and a distance
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxPlane(const PxVec3& normal, float distance) : n(normal), d(distance)
+	{
+	}
+
+	/**
+	\brief Constructor from a point on the plane and a normal
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxPlane(const PxVec3& point, const PxVec3& normal)
+	: n(normal), d(-point.dot(n)) // p satisfies normal.dot(p) + d = 0
+	{
+	}
+
+	/**
+	\brief Constructor from three points
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxPlane(const PxVec3& p0, const PxVec3& p1, const PxVec3& p2)
+	{
+		n = (p1 - p0).cross(p2 - p0).getNormalized();
+		d = -p0.dot(n);
+	}
+
+	/**
+	\brief returns true if the two planes are exactly equal
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool operator==(const PxPlane& p) const
+	{
+		return n == p.n && d == p.d;
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float distance(const PxVec3& p) const
+	{
+		return p.dot(n) + d;
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool contains(const PxVec3& p) const
+	{
+		return PxAbs(distance(p)) < (1.0e-7f);
+	}
+
+	/**
+	\brief projects p into the plane
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 project(const PxVec3& p) const
+	{
+		return p - n * distance(p);
+	}
+
+	/**
+	\brief find an arbitrary point in the plane
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 pointInPlane() const
+	{
+		return -n * d;
+	}
+
+	/**
+	\brief equivalent plane with unit normal
+	*/
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE void normalize()
+	{
+		float denom = 1.0f / n.magnitude();
+		n *= denom;
+		d *= denom;
+	}
+
+	PxVec3 n; //!< The normal to the plane
+	float d;  //!< The distance from the origin
+};
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXPLANE_H
diff --git a/PxShared/include/foundation/PxPreprocessor.h b/PxShared/include/foundation/PxPreprocessor.h
new file mode 100644
index 00000000..c763fb2c
--- /dev/null
+++ b/PxShared/include/foundation/PxPreprocessor.h
@@ -0,0 +1,529 @@
+// 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 PXFOUNDATION_PXPREPROCESSOR_H
+#define PXFOUNDATION_PXPREPROCESSOR_H
+
+#include <stddef.h>
+#if !(defined(__clang__) && (defined(_WIN32) || defined(_WIN64)))
+#include <ciso646>  // detect std::lib, unless clang on windows is used (PxMetaDataGenerator issue)
+#endif
+/** \addtogroup foundation
+  @{
+*/
+
+/*
+The following preprocessor identifiers specify compiler, OS, and architecture.
+All definitions have a value of 1 or 0, use '#if' instead of '#ifdef'.
+*/
+
+/**
+Compiler defines, see http://sourceforge.net/p/predef/wiki/Compilers/
+*/
+#if defined(_MSC_VER)
+#if _MSC_VER >= 1900
+#define PX_VC 14
+#elif _MSC_VER >= 1800
+#define PX_VC 12
+#elif _MSC_VER >= 1700
+#define PX_VC 11
+#elif _MSC_VER >= 1600
+#define PX_VC 10
+#elif _MSC_VER >= 1500
+#define PX_VC 9
+#else
+#error "Unknown VC version"
+#endif
+#elif defined(__clang__)
+#define PX_CLANG 1
+#elif defined(__GNUC__) // note: __clang__ implies __GNUC__
+#define PX_GCC 1
+#else
+#error "Unknown compiler"
+#endif
+
+/**
+Operating system defines, see http://sourceforge.net/p/predef/wiki/OperatingSystems/
+*/
+#if defined(_XBOX_ONE)
+#define PX_XBOXONE 1
+#elif defined(_WIN64) // note: _XBOX_ONE implies _WIN64
+#define PX_WIN64 1
+#elif defined(_WIN32) // note: _M_PPC implies _WIN32
+#define PX_WIN32 1
+#elif defined(__ANDROID__)
+#define PX_ANDROID 1
+#elif defined(__linux__) || defined (__EMSCRIPTEN__) // note: __ANDROID__ implies __linux__
+#define PX_LINUX 1
+#elif defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))
+#define PX_IOS 1
+#elif defined(__APPLE__)
+#define PX_OSX 1
+#elif defined(__ORBIS__)
+#define PX_PS4 1
+#else
+#error "Unknown operating system"
+#endif
+
+/**
+Architecture defines, see http://sourceforge.net/p/predef/wiki/Architectures/
+*/
+#if defined(__x86_64__) || defined(_M_X64) // ps4 compiler defines _M_X64 without value
+#define PX_X64 1
+#elif defined(__i386__) || defined(_M_IX86) || defined (__EMSCRIPTEN__)
+#define PX_X86 1
+#elif defined(__arm64__) || defined(__aarch64__)
+#define PX_A64 1
+#elif defined(__arm__) || defined(_M_ARM)
+#define PX_ARM 1
+#elif defined(__ppc__) || defined(_M_PPC) || defined(__CELLOS_LV2__)
+#define PX_PPC 1
+#else
+#error "Unknown architecture"
+#endif
+
+/**
+SIMD defines
+*/
+#if defined(__i386__) || defined(_M_IX86) || defined(__x86_64__) || defined(_M_X64) || defined (__EMSCRIPTEN__)
+#define PX_SSE2 1
+#endif
+#if defined(_M_ARM) || defined(__ARM_NEON__)
+#define PX_NEON 1
+#endif
+#if defined(_M_PPC) || defined(__CELLOS_LV2__)
+#define PX_VMX 1
+#endif
+
+/**
+define anything not defined on this platform to 0
+*/
+#ifndef PX_VC
+#define PX_VC 0
+#endif
+#ifndef PX_CLANG
+#define PX_CLANG 0
+#endif
+#ifndef PX_GCC
+#define PX_GCC 0
+#endif
+#ifndef PX_XBOXONE
+#define PX_XBOXONE 0
+#endif
+#ifndef PX_WIN64
+#define PX_WIN64 0
+#endif
+#ifndef PX_WIN32
+#define PX_WIN32 0
+#endif
+#ifndef PX_ANDROID
+#define PX_ANDROID 0
+#endif
+#ifndef PX_LINUX
+#define PX_LINUX 0
+#endif
+#ifndef PX_IOS
+#define PX_IOS 0
+#endif
+#ifndef PX_OSX
+#define PX_OSX 0
+#endif
+#ifndef PX_PS4
+#define PX_PS4 0
+#endif
+#ifndef PX_X64
+#define PX_X64 0
+#endif
+#ifndef PX_X86
+#define PX_X86 0
+#endif
+#ifndef PX_A64
+#define PX_A64 0
+#endif
+#ifndef PX_ARM
+#define PX_ARM 0
+#endif
+#ifndef PX_PPC
+#define PX_PPC 0
+#endif
+#ifndef PX_SSE2
+#define PX_SSE2 0
+#endif
+#ifndef PX_NEON
+#define PX_NEON 0
+#endif
+#ifndef PX_VMX
+#define PX_VMX 0
+#endif
+
+/*
+define anything not defined through the command line to 0
+*/
+#ifndef PX_DEBUG
+#define PX_DEBUG 0
+#endif
+#ifndef PX_CHECKED
+#define PX_CHECKED 0
+#endif
+#ifndef PX_PROFILE
+#define PX_PROFILE 0
+#endif
+#ifndef PX_NVTX
+#define PX_NVTX 0
+#endif
+#ifndef PX_DOXYGEN
+#define PX_DOXYGEN 0
+#endif
+
+/**
+family shortcuts
+*/
+// compiler
+#define PX_GCC_FAMILY (PX_CLANG || PX_GCC)
+// os
+#define PX_WINDOWS_FAMILY (PX_WIN32 || PX_WIN64)
+#define PX_MICROSOFT_FAMILY (PX_XBOXONE || PX_WINDOWS_FAMILY)
+#define PX_LINUX_FAMILY (PX_LINUX || PX_ANDROID)
+#define PX_APPLE_FAMILY (PX_IOS || PX_OSX)                  // equivalent to #if __APPLE__
+#define PX_UNIX_FAMILY (PX_LINUX_FAMILY || PX_APPLE_FAMILY) // shortcut for unix/posix platforms
+#if defined(__EMSCRIPTEN__)
+#define PX_EMSCRIPTEN 1
+#else
+#define PX_EMSCRIPTEN 0
+#endif
+// architecture
+#define PX_INTEL_FAMILY (PX_X64 || PX_X86)
+#define PX_ARM_FAMILY (PX_ARM || PX_A64)
+#define PX_P64_FAMILY (PX_X64 || PX_A64) // shortcut for 64-bit architectures
+
+/**
+C++ standard library defines
+*/
+#if defined(_LIBCPP_VERSION) || PX_WIN64 || PX_WIN32 || PX_PS4 || PX_XBOXONE || PX_EMSCRIPTEN
+#define PX_LIBCPP 1
+#else
+#define PX_LIBCPP 0
+#endif
+
+// legacy define for PhysX
+#define PX_WINDOWS (PX_WINDOWS_FAMILY && !PX_ARM_FAMILY)
+
+/**
+Assert macro
+*/
+#ifndef PX_ENABLE_ASSERTS
+#if PX_DEBUG && !defined(__CUDACC__)
+#define PX_ENABLE_ASSERTS 1
+#else
+#define PX_ENABLE_ASSERTS 0
+#endif
+#endif
+
+/**
+DLL export macros
+*/
+#ifndef PX_C_EXPORT
+#if PX_WINDOWS_FAMILY || PX_LINUX
+#define PX_C_EXPORT extern "C"
+#else
+#define PX_C_EXPORT
+#endif
+#endif
+
+#if PX_UNIX_FAMILY&& __GNUC__ >= 4
+#define PX_UNIX_EXPORT __attribute__((visibility("default")))
+#else
+#define PX_UNIX_EXPORT
+#endif
+
+#if PX_WINDOWS_FAMILY
+#define PX_DLL_EXPORT __declspec(dllexport)
+#define PX_DLL_IMPORT __declspec(dllimport)
+#else
+#define PX_DLL_EXPORT PX_UNIX_EXPORT
+#define PX_DLL_IMPORT
+#endif
+
+/**
+Define API function declaration
+
+PX_FOUNDATION_DLL=1 - used by the DLL library (PhysXCommon) to export the API
+PX_FOUNDATION_DLL=0 - for windows configurations where the PX_FOUNDATION_API is linked through standard static linking
+no definition       - this will allow DLLs and libraries to use the exported API from PhysXCommon
+
+*/
+
+#if PX_WINDOWS_FAMILY && !PX_ARM_FAMILY
+#ifndef PX_FOUNDATION_DLL
+#define PX_FOUNDATION_API PX_DLL_IMPORT
+#elif PX_FOUNDATION_DLL
+#define PX_FOUNDATION_API PX_DLL_EXPORT
+#endif
+#elif PX_UNIX_FAMILY
+#ifdef PX_FOUNDATION_DLL
+#define PX_FOUNDATION_API PX_UNIX_EXPORT
+#endif
+#endif
+
+#ifndef PX_FOUNDATION_API
+#define PX_FOUNDATION_API
+#endif
+
+/**
+Calling convention
+*/
+#ifndef PX_CALL_CONV
+#if PX_MICROSOFT_FAMILY
+#define PX_CALL_CONV __cdecl
+#else
+#define PX_CALL_CONV
+#endif
+#endif
+
+/**
+Pack macros - disabled on SPU because they are not supported
+*/
+#if PX_VC
+#define PX_PUSH_PACK_DEFAULT __pragma(pack(push, 8))
+#define PX_POP_PACK __pragma(pack(pop))
+#elif PX_GCC_FAMILY
+#define PX_PUSH_PACK_DEFAULT _Pragma("pack(push, 8)")
+#define PX_POP_PACK _Pragma("pack(pop)")
+#else
+#define PX_PUSH_PACK_DEFAULT
+#define PX_POP_PACK
+#endif
+
+/**
+Inline macro
+*/
+#define PX_INLINE inline
+#if PX_MICROSOFT_FAMILY
+#pragma inline_depth(255)
+#endif
+
+/**
+Force inline macro
+*/
+#if PX_VC
+#define PX_FORCE_INLINE __forceinline
+#elif PX_LINUX // Workaround; Fedora Core 3 do not agree with force inline and PxcPool
+#define PX_FORCE_INLINE inline
+#elif PX_GCC_FAMILY
+#define PX_FORCE_INLINE inline __attribute__((always_inline))
+#else
+#define PX_FORCE_INLINE inline
+#endif
+
+/**
+Noinline macro
+*/
+#if PX_MICROSOFT_FAMILY
+#define PX_NOINLINE __declspec(noinline)
+#elif PX_GCC_FAMILY
+#define PX_NOINLINE __attribute__((noinline))
+#else
+#define PX_NOINLINE
+#endif
+
+/**
+Restrict macro
+*/
+#if defined(__CUDACC__)
+#define PX_RESTRICT __restrict__
+#else
+#define PX_RESTRICT __restrict
+#endif
+
+/**
+Noalias macro
+*/
+#if PX_MICROSOFT_FAMILY
+#define PX_NOALIAS __declspec(noalias)
+#else
+#define PX_NOALIAS
+#endif
+
+/**
+Alignment macros
+
+PX_ALIGN_PREFIX and PX_ALIGN_SUFFIX can be used for type alignment instead of aligning individual variables as follows:
+PX_ALIGN_PREFIX(16)
+struct A {
+...
+} PX_ALIGN_SUFFIX(16);
+This declaration style is parsed correctly by Visual Assist.
+
+*/
+#ifndef PX_ALIGN
+#if PX_MICROSOFT_FAMILY
+#define PX_ALIGN(alignment, decl) __declspec(align(alignment)) decl
+#define PX_ALIGN_PREFIX(alignment) __declspec(align(alignment))
+#define PX_ALIGN_SUFFIX(alignment)
+#elif PX_GCC_FAMILY
+#define PX_ALIGN(alignment, decl) decl __attribute__((aligned(alignment)))
+#define PX_ALIGN_PREFIX(alignment)
+#define PX_ALIGN_SUFFIX(alignment) __attribute__((aligned(alignment)))
+#elif defined __CUDACC__
+#define PX_ALIGN(alignment, decl) __align__(alignment) decl
+#define PX_ALIGN_PREFIX(alignment)
+#define PX_ALIGN_SUFFIX(alignment) __align__(alignment))
+#else
+#define PX_ALIGN(alignment, decl)
+#define PX_ALIGN_PREFIX(alignment)
+#define PX_ALIGN_SUFFIX(alignment)
+#endif
+#endif
+
+/**
+Deprecated macro
+- To deprecate a function: Place PX_DEPRECATED at the start of the function header (leftmost word).
+- To deprecate a 'typedef', a 'struct' or a 'class': Place PX_DEPRECATED directly after the keywords ('typdef',
+'struct', 'class').
+
+Use these macro definitions to create warnings for deprecated functions
+\#define PX_DEPRECATED __declspec(deprecated) // Microsoft
+\#define PX_DEPRECATED __attribute__((deprecated())) // GCC
+*/
+#define PX_DEPRECATED
+
+/**
+General defines
+*/
+
+// static assert
+#if(defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 7))) || (PX_PS4) || (PX_APPLE_FAMILY)
+#define PX_COMPILE_TIME_ASSERT(exp) typedef char PxCompileTimeAssert_Dummy[(exp) ? 1 : -1] __attribute__((unused))
+#else
+#define PX_COMPILE_TIME_ASSERT(exp) typedef char PxCompileTimeAssert_Dummy[(exp) ? 1 : -1]
+#endif
+
+#if PX_GCC_FAMILY
+#define PX_OFFSET_OF(X, Y) __builtin_offsetof(X, Y)
+#else
+#define PX_OFFSET_OF(X, Y) offsetof(X, Y)
+#endif
+
+#define PX_OFFSETOF_BASE 0x100 // casting the null ptr takes a special-case code path, which we don't want
+#define PX_OFFSET_OF_RT(Class, Member)                                                                                 \
+	(reinterpret_cast<size_t>(&reinterpret_cast<Class*>(PX_OFFSETOF_BASE)->Member) - size_t(PX_OFFSETOF_BASE))
+
+// check that exactly one of NDEBUG and _DEBUG is defined
+#if !defined(NDEBUG) ^ defined(_DEBUG)
+#error Exactly one of NDEBUG and _DEBUG needs to be defined!
+#endif
+
+// make sure PX_CHECKED is defined in all _DEBUG configurations as well
+#if !PX_CHECKED && PX_DEBUG
+#error PX_CHECKED must be defined when PX_DEBUG is defined
+#endif
+
+#ifdef __CUDACC__
+#define PX_CUDA_CALLABLE __host__ __device__
+#else
+#define PX_CUDA_CALLABLE
+#endif
+
+// avoid unreferenced parameter warning
+// preferred solution: omit the parameter's name from the declaration
+template <class T>
+PX_CUDA_CALLABLE PX_INLINE void PX_UNUSED(T const&)
+{
+}
+
+// Ensure that the application hasn't tweaked the pack value to less than 8, which would break
+// matching between the API headers and the binaries
+// This assert works on win32/win64, but may need further specialization on other platforms.
+// Some GCC compilers need the compiler flag -malign-double to be set.
+// Apparently the apple-clang-llvm compiler doesn't support malign-double.
+#if PX_PS4 || PX_APPLE_FAMILY
+struct PxPackValidation
+{
+	char _;
+	long a;
+};
+#elif PX_ANDROID
+struct PxPackValidation
+{
+	char _;
+	double a;
+};
+#else
+struct PxPackValidation
+{
+	char _;
+	long long a;
+};
+#endif
+#if !PX_APPLE_FAMILY
+PX_COMPILE_TIME_ASSERT(PX_OFFSET_OF(PxPackValidation, a) == 8);
+#endif
+
+// use in a cpp file to suppress LNK4221
+#if PX_VC
+#define PX_DUMMY_SYMBOL                                                                                                \
+	namespace                                                                                                          \
+	{                                                                                                                  \
+	char PxDummySymbol;                                                                                                \
+	}
+#else
+#define PX_DUMMY_SYMBOL
+#endif
+
+#if PX_GCC_FAMILY
+#define PX_WEAK_SYMBOL __attribute__((weak)) // this is to support SIMD constant merging in template specialization
+#else
+#define PX_WEAK_SYMBOL
+#endif
+
+// Macro for avoiding default assignment and copy, because doing this by inheritance can increase class size on some
+// platforms.
+#define PX_NOCOPY(Class)                                                                                               \
+	\
+protected:                                                                                                             \
+	Class(const Class&);                                                                                               \
+	Class& operator=(const Class&);
+
+#define PX_STRINGIZE_HELPER(X) #X
+#define PX_STRINGIZE(X) PX_STRINGIZE_HELPER(X)
+
+#define PX_CONCAT_HELPER(X, Y) X##Y
+#define PX_CONCAT(X, Y) PX_CONCAT_HELPER(X, Y)
+
+#ifndef DISABLE_CUDA_PHYSX
+//CUDA is currently supported only on windows 
+#define PX_SUPPORT_GPU_PHYSX ((PX_WINDOWS_FAMILY) || (PX_LINUX && PX_X64))
+#else
+#define PX_SUPPORT_GPU_PHYSX 0
+#endif
+
+#define PX_SUPPORT_COMPUTE_PHYSX 0
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXPREPROCESSOR_H
diff --git a/PxShared/include/foundation/PxProfiler.h b/PxShared/include/foundation/PxProfiler.h
new file mode 100644
index 00000000..6b181c09
--- /dev/null
+++ b/PxShared/include/foundation/PxProfiler.h
@@ -0,0 +1,116 @@
+// 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.
+
+#ifndef PXFOUNDATION_PXPROFILER_H
+#define PXFOUNDATION_PXPROFILER_H
+
+#include "foundation/PxFoundation.h"
+
+namespace physx
+{
+
+/**
+\brief The pure virtual callback interface for general purpose instrumentation and profiling of GameWorks modules as
+well as applications
+*/
+class PxProfilerCallback
+{
+protected:
+	virtual ~PxProfilerCallback()	{}
+
+public:
+	/**************************************************************************************************************************
+	Instrumented profiling events
+	***************************************************************************************************************************/
+
+	/**
+	\brief Mark the beginning of a nested profile block
+	\param[in] eventName	Event name. Must be a persistent const char *
+	\param[in] detached		True for cross thread events
+	\param[in] contextId	the context id of this zone. Zones with the same id belong to the same group. 0 is used for no specific group.
+	\return Returns implementation-specific profiler data for this event
+	*/
+	virtual void* zoneStart(const char* eventName, bool detached, uint64_t contextId) = 0;
+
+	/**
+	\brief Mark the end of a nested profile block
+	\param[in] profilerData	The data returned by the corresponding zoneStart call (or NULL if not available)
+	\param[in] eventName	The name of the zone ending, must match the corresponding name passed with 'zoneStart'. Must be a persistent const char *.
+	\param[in] detached		True for cross thread events. Should match the value passed to zoneStart.
+	\param[in] contextId	The context of this zone. Should match the value passed to zoneStart.
+
+	\note eventName plus contextId can be used to uniquely match up start and end of a zone.
+	*/
+	virtual void zoneEnd(void* profilerData, const char* eventName, bool detached, uint64_t contextId) = 0;
+};
+
+class PxProfileScoped
+{
+  public:
+	PX_FORCE_INLINE PxProfileScoped(const char* eventName, bool detached, uint64_t contextId) : mCallback(PxGetProfilerCallback()), mProfilerData(NULL)
+	{
+		if(mCallback)
+		{
+			mEventName		= eventName;
+			mContextId		= contextId;
+			mDetached		= detached;
+			mProfilerData	= mCallback->zoneStart(eventName, detached, contextId);
+		}
+	}
+
+	PX_FORCE_INLINE ~PxProfileScoped()
+	{
+		if(mCallback)
+			mCallback->zoneEnd(mProfilerData, mEventName, mDetached, mContextId);
+	}
+	physx::PxProfilerCallback*	mCallback;
+	const char*					mEventName;
+	void*						mProfilerData;
+	uint64_t					mContextId;
+	bool						mDetached;
+};
+
+} // end of physx namespace
+
+#if PX_DEBUG || PX_CHECKED || PX_PROFILE
+	#define PX_PROFILE_ZONE(x, y)										\
+		physx::PxProfileScoped PX_CONCAT(_scoped, __LINE__)(x, false, y)
+	#define PX_PROFILE_START_CROSSTHREAD(x, y)							\
+		if(PxGetProfilerCallback())										\
+			PxGetProfilerCallback()->zoneStart(x, true, y)
+	#define PX_PROFILE_STOP_CROSSTHREAD(x, y)							\
+		if(PxGetProfilerCallback())										\
+			PxGetProfilerCallback()->zoneEnd(NULL, x, true, y)
+#else
+	#define PX_PROFILE_ZONE(x, y)
+	#define PX_PROFILE_START_CROSSTHREAD(x, y)
+	#define PX_PROFILE_STOP_CROSSTHREAD(x, y)
+#endif
+
+#define PX_PROFILE_POINTER_TO_U64(pointer) static_cast<uint64_t>(reinterpret_cast<size_t>(pointer))
+
+#endif // PXFOUNDATION_PXPROFILER_H
diff --git a/PxShared/include/foundation/PxQuat.h b/PxShared/include/foundation/PxQuat.h
new file mode 100644
index 00000000..bf55c6d2
--- /dev/null
+++ b/PxShared/include/foundation/PxQuat.h
@@ -0,0 +1,403 @@
+// 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 PXFOUNDATION_PXQUAT_H
+#define PXFOUNDATION_PXQUAT_H
+
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/PxVec3.h"
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief This is a quaternion class. For more information on quaternion mathematics
+consult a mathematics source on complex numbers.
+
+*/
+
+class PxQuat
+{
+  public:
+	/**
+	\brief Default constructor, does not do any initialization.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat()
+	{
+	}
+
+	//! identity constructor
+	PX_CUDA_CALLABLE PX_INLINE PxQuat(PxIDENTITY r) : x(0.0f), y(0.0f), z(0.0f), w(1.0f)
+	{
+		PX_UNUSED(r);
+	}
+
+	/**
+	\brief Constructor from a scalar: sets the real part w to the scalar value, and the imaginary parts (x,y,z) to zero
+	*/
+	explicit PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat(float r) : x(0.0f), y(0.0f), z(0.0f), w(r)
+	{
+	}
+
+	/**
+	\brief Constructor.  Take note of the order of the elements!
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat(float nx, float ny, float nz, float nw) : x(nx), y(ny), z(nz), w(nw)
+	{
+	}
+
+	/**
+	\brief Creates from angle-axis representation.
+
+	Axis must be normalized!
+
+	Angle is in radians!
+
+	<b>Unit:</b> Radians
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxQuat(float angleRadians, const PxVec3& unitAxis)
+	{
+		PX_ASSERT(PxAbs(1.0f - unitAxis.magnitude()) < 1e-3f);
+		const float a = angleRadians * 0.5f;
+		const float s = PxSin(a);
+		w = PxCos(a);
+		x = unitAxis.x * s;
+		y = unitAxis.y * s;
+		z = unitAxis.z * s;
+	}
+
+	/**
+	\brief Copy ctor.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat(const PxQuat& v) : x(v.x), y(v.y), z(v.z), w(v.w)
+	{
+	}
+
+	/**
+	\brief Creates from orientation matrix.
+
+	\param[in] m Rotation matrix to extract quaternion from.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE explicit PxQuat(const PxMat33& m); /* defined in PxMat33.h */
+
+	/**
+	\brief returns true if quat is identity
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool isIdentity() const
+	{
+		return x==0.0f && y==0.0f && z==0.0f && w==1.0f;
+	}
+
+	/**
+	\brief returns true if all elements are finite (not NAN or INF, etc.)
+	*/
+	PX_CUDA_CALLABLE bool isFinite() const
+	{
+		return PxIsFinite(x) && PxIsFinite(y) && PxIsFinite(z) && PxIsFinite(w);
+	}
+
+	/**
+	\brief returns true if finite and magnitude is close to unit
+	*/
+	PX_CUDA_CALLABLE bool isUnit() const
+	{
+		const float unitTolerance = 1e-4f;
+		return isFinite() && PxAbs(magnitude() - 1) < unitTolerance;
+	}
+
+	/**
+	\brief returns true if finite and magnitude is reasonably close to unit to allow for some accumulation of error vs
+	isValid
+	*/
+	PX_CUDA_CALLABLE bool isSane() const
+	{
+		const float unitTolerance = 1e-2f;
+		return isFinite() && PxAbs(magnitude() - 1) < unitTolerance;
+	}
+
+	/**
+	\brief returns true if the two quaternions are exactly equal
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool operator==(const PxQuat& q) const
+	{
+		return x == q.x && y == q.y && z == q.z && w == q.w;
+	}
+
+	/**
+	\brief converts this quaternion to angle-axis representation
+	*/
+	PX_CUDA_CALLABLE PX_INLINE void toRadiansAndUnitAxis(float& angle, PxVec3& axis) const
+	{
+		const float quatEpsilon = 1.0e-8f;
+		const float s2 = x * x + y * y + z * z;
+		if(s2 < quatEpsilon * quatEpsilon) // can't extract a sensible axis
+		{
+			angle = 0.0f;
+			axis = PxVec3(1.0f, 0.0f, 0.0f);
+		}
+		else
+		{
+			const float s = PxRecipSqrt(s2);
+			axis = PxVec3(x, y, z) * s;
+			angle = PxAbs(w) < quatEpsilon ? PxPi : PxAtan2(s2 * s, w) * 2.0f;
+		}
+	}
+
+	/**
+	\brief Gets the angle between this quat and the identity quaternion.
+
+	<b>Unit:</b> Radians
+	*/
+	PX_CUDA_CALLABLE PX_INLINE float getAngle() const
+	{
+		return PxAcos(w) * 2.0f;
+	}
+
+	/**
+	\brief Gets the angle between this quat and the argument
+
+	<b>Unit:</b> Radians
+	*/
+	PX_CUDA_CALLABLE PX_INLINE float getAngle(const PxQuat& q) const
+	{
+		return PxAcos(dot(q)) * 2.0f;
+	}
+
+	/**
+	\brief This is the squared 4D vector length, should be 1 for unit quaternions.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float magnitudeSquared() const
+	{
+		return x * x + y * y + z * z + w * w;
+	}
+
+	/**
+	\brief returns the scalar product of this and other.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float dot(const PxQuat& v) const
+	{
+		return x * v.x + y * v.y + z * v.z + w * v.w;
+	}
+
+	PX_CUDA_CALLABLE PX_INLINE PxQuat getNormalized() const
+	{
+		const float s = 1.0f / magnitude();
+		return PxQuat(x * s, y * s, z * s, w * s);
+	}
+
+	PX_CUDA_CALLABLE PX_INLINE float magnitude() const
+	{
+		return PxSqrt(magnitudeSquared());
+	}
+
+	// modifiers:
+	/**
+	\brief maps to the closest unit quaternion.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE float normalize() // convert this PxQuat to a unit quaternion
+	{
+		const float mag = magnitude();
+		if(mag != 0.0f)
+		{
+			const float imag = 1.0f / mag;
+
+			x *= imag;
+			y *= imag;
+			z *= imag;
+			w *= imag;
+		}
+		return mag;
+	}
+
+	/*
+	\brief returns the conjugate.
+
+	\note for unit quaternions, this is the inverse.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxQuat getConjugate() const
+	{
+		return PxQuat(-x, -y, -z, w);
+	}
+
+	/*
+	\brief returns imaginary part.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec3 getImaginaryPart() const
+	{
+		return PxVec3(x, y, z);
+	}
+
+	/** brief computes rotation of x-axis */
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 getBasisVector0() const
+	{
+		const float x2 = x * 2.0f;
+		const float w2 = w * 2.0f;
+		return PxVec3((w * w2) - 1.0f + x * x2, (z * w2) + y * x2, (-y * w2) + z * x2);
+	}
+
+	/** brief computes rotation of y-axis */
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 getBasisVector1() const
+	{
+		const float y2 = y * 2.0f;
+		const float w2 = w * 2.0f;
+		return PxVec3((-z * w2) + x * y2, (w * w2) - 1.0f + y * y2, (x * w2) + z * y2);
+	}
+
+	/** brief computes rotation of z-axis */
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 getBasisVector2() const
+	{
+		const float z2 = z * 2.0f;
+		const float w2 = w * 2.0f;
+		return PxVec3((y * w2) + x * z2, (-x * w2) + y * z2, (w * w2) - 1.0f + z * z2);
+	}
+
+	/**
+	rotates passed vec by this (assumed unitary)
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE const PxVec3 rotate(const PxVec3& v) const
+	{
+		const float vx = 2.0f * v.x;
+		const float vy = 2.0f * v.y;
+		const float vz = 2.0f * v.z;
+		const float w2 = w * w - 0.5f;
+		const float dot2 = (x * vx + y * vy + z * vz);
+		return PxVec3((vx * w2 + (y * vz - z * vy) * w + x * dot2), (vy * w2 + (z * vx - x * vz) * w + y * dot2),
+		              (vz * w2 + (x * vy - y * vx) * w + z * dot2));
+	}
+
+	/**
+	inverse rotates passed vec by this (assumed unitary)
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE const PxVec3 rotateInv(const PxVec3& v) const
+	{
+		const float vx = 2.0f * v.x;
+		const float vy = 2.0f * v.y;
+		const float vz = 2.0f * v.z;
+		const float w2 = w * w - 0.5f;
+		const float dot2 = (x * vx + y * vy + z * vz);
+		return PxVec3((vx * w2 - (y * vz - z * vy) * w + x * dot2), (vy * w2 - (z * vx - x * vz) * w + y * dot2),
+		              (vz * w2 - (x * vy - y * vx) * w + z * dot2));
+	}
+
+	/**
+	\brief Assignment operator
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat& operator=(const PxQuat& p)
+	{
+		x = p.x;
+		y = p.y;
+		z = p.z;
+		w = p.w;
+		return *this;
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat& operator*=(const PxQuat& q)
+	{
+		const float tx = w * q.x + q.w * x + y * q.z - q.y * z;
+		const float ty = w * q.y + q.w * y + z * q.x - q.z * x;
+		const float tz = w * q.z + q.w * z + x * q.y - q.x * y;
+
+		w = w * q.w - q.x * x - y * q.y - q.z * z;
+		x = tx;
+		y = ty;
+		z = tz;
+
+		return *this;
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat& operator+=(const PxQuat& q)
+	{
+		x += q.x;
+		y += q.y;
+		z += q.z;
+		w += q.w;
+		return *this;
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat& operator-=(const PxQuat& q)
+	{
+		x -= q.x;
+		y -= q.y;
+		z -= q.z;
+		w -= q.w;
+		return *this;
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat& operator*=(const float s)
+	{
+		x *= s;
+		y *= s;
+		z *= s;
+		w *= s;
+		return *this;
+	}
+
+	/** quaternion multiplication */
+	PX_CUDA_CALLABLE PX_INLINE PxQuat operator*(const PxQuat& q) const
+	{
+		return PxQuat(w * q.x + q.w * x + y * q.z - q.y * z, w * q.y + q.w * y + z * q.x - q.z * x,
+		              w * q.z + q.w * z + x * q.y - q.x * y, w * q.w - x * q.x - y * q.y - z * q.z);
+	}
+
+	/** quaternion addition */
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat operator+(const PxQuat& q) const
+	{
+		return PxQuat(x + q.x, y + q.y, z + q.z, w + q.w);
+	}
+
+	/** quaternion subtraction */
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat operator-() const
+	{
+		return PxQuat(-x, -y, -z, -w);
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat operator-(const PxQuat& q) const
+	{
+		return PxQuat(x - q.x, y - q.y, z - q.z, w - q.w);
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxQuat operator*(float r) const
+	{
+		return PxQuat(x * r, y * r, z * r, w * r);
+	}
+
+	/** the quaternion elements */
+	float x, y, z, w;
+};
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXQUAT_H
diff --git a/PxShared/include/foundation/PxSimpleTypes.h b/PxShared/include/foundation/PxSimpleTypes.h
new file mode 100644
index 00000000..a88f5acd
--- /dev/null
+++ b/PxShared/include/foundation/PxSimpleTypes.h
@@ -0,0 +1,112 @@
+// 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 PXFOUNDATION_PXSIMPLETYPES_H
+#define PXFOUNDATION_PXSIMPLETYPES_H
+
+/** \addtogroup foundation
+  @{
+*/
+
+// Platform specific types:
+// Design note: Its OK to use int for general loop variables and temps.
+
+#include "foundation/PxPreprocessor.h"
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable : 4668) // suppressing warning generated by Microsoft Visual Studio when including this standard
+// header
+#endif
+
+#if PX_LINUX
+#define __STDC_LIMIT_MACROS
+#endif
+
+#include <stdint.h>
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#if PX_VC // we could use inttypes.h starting with VC12
+#define PX_PRIu64 "I64u"
+#else
+#if !PX_PS4 && !PX_APPLE_FAMILY
+#define __STDC_FORMAT_MACROS
+#endif
+#include <inttypes.h>
+#define PX_PRIu64 PRIu64
+#endif
+
+namespace physx
+{
+typedef int64_t PxI64;
+typedef uint64_t PxU64;
+typedef int32_t PxI32;
+typedef uint32_t PxU32;
+typedef int16_t PxI16;
+typedef uint16_t PxU16;
+typedef int8_t PxI8;
+typedef uint8_t PxU8;
+typedef float PxF32;
+typedef double PxF64;
+typedef float PxReal;
+}
+
+// Type ranges
+
+// These are here because we sometimes have non-IEEE compliant platforms to deal with.
+// Removal is under consideration (issue GWSD-34)
+
+#define PX_MAX_F32 3.4028234663852885981170418348452e+38F
+// maximum possible float value
+#define PX_MAX_F64 DBL_MAX // maximum possible double value
+
+#define PX_EPS_F32 FLT_EPSILON // maximum relative error of float rounding
+#define PX_EPS_F64 DBL_EPSILON // maximum relative error of double rounding
+
+#define PX_MAX_REAL PX_MAX_F32
+#define PX_EPS_REAL PX_EPS_F32
+#define PX_NORMALIZATION_EPSILON float(1e-20f)
+
+// Legacy type ranges used by PhysX
+#define PX_MAX_I8 INT8_MAX
+#define PX_MIN_I8 INT8_MIN
+#define PX_MAX_U8 UINT8_MAX
+#define PX_MIN_U8 UINT8_MIN
+#define PX_MAX_I16 INT16_MAX
+#define PX_MIN_I16 INT16_MIN
+#define PX_MAX_U16 UINT16_MAX
+#define PX_MIN_U16 UINT16_MIN
+#define PX_MAX_I32 INT32_MAX
+#define PX_MIN_I32 INT32_MIN
+#define PX_MAX_U32 UINT32_MAX
+#define PX_MIN_U32 UINT32_MIN
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXSIMPLETYPES_H
diff --git a/PxShared/include/foundation/PxStrideIterator.h b/PxShared/include/foundation/PxStrideIterator.h
new file mode 100644
index 00000000..70229956
--- /dev/null
+++ b/PxShared/include/foundation/PxStrideIterator.h
@@ -0,0 +1,353 @@
+// 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 PXFOUNDATION_PXSTRIDEITERATOR_H
+#define PXFOUNDATION_PXSTRIDEITERATOR_H
+
+#include "foundation/Px.h"
+#include "foundation/PxAssert.h"
+
+/** \addtogroup foundation
+  @{
+*/
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief Iterator class for iterating over arrays of data that may be interleaved with other data.
+
+This class is used for iterating over arrays of elements that may have a larger element to element
+offset, called the stride, than the size of the element itself (non-contiguous).
+
+The template parameter T denotes the type of the element accessed. The stride itself
+is stored as a member field so multiple instances of a PxStrideIterator class can have
+different strides. This is useful for cases were the stride depends on runtime configuration.
+
+The stride iterator can be used for index based access, e.g.:
+\code
+    PxStrideIterator<PxVec3> strideArray(...);
+    for (unsigned i = 0; i < 10; ++i)
+    {
+        PxVec3& vec = strideArray[i];
+        ...
+    }
+\endcode
+or iteration by increment, e.g.:
+\code
+    PxStrideIterator<PxVec3> strideBegin(...);
+    PxStrideIterator<PxVec3> strideEnd(strideBegin + 10);
+    for (PxStrideIterator<PxVec3> it = strideBegin; it < strideEnd; ++it)
+    {
+        PxVec3& vec = *it;
+        ...
+    }
+\endcode
+
+Two special cases:
+- A stride of sizeof(T) represents a regular c array of type T.
+- A stride of 0 can be used to describe re-occurrence of the same element multiple times.
+
+*/
+template <typename T>
+class PxStrideIterator
+{
+
+#if !PX_DOXYGEN
+	template <typename X>
+	struct StripConst
+	{
+		typedef X Type;
+	};
+
+	template <typename X>
+	struct StripConst<const X>
+	{
+		typedef X Type;
+	};
+#endif
+
+  public:
+	/**
+	\brief Constructor.
+
+	Optionally takes a pointer to an element and a stride.
+
+	\param[in] ptr pointer to element, defaults to NULL.
+	\param[in] stride stride for accessing consecutive elements, defaults to the size of one element.
+	*/
+	explicit PX_INLINE PxStrideIterator(T* ptr = NULL, PxU32 stride = sizeof(T)) : mPtr(ptr), mStride(stride)
+	{
+		PX_ASSERT(mStride == 0 || sizeof(T) <= mStride);
+	}
+
+	/**
+	\brief Copy constructor.
+
+	\param[in] strideIterator PxStrideIterator to be copied.
+	*/
+	PX_INLINE PxStrideIterator(const PxStrideIterator<typename StripConst<T>::Type>& strideIterator)
+	: mPtr(strideIterator.ptr()), mStride(strideIterator.stride())
+	{
+		PX_ASSERT(mStride == 0 || sizeof(T) <= mStride);
+	}
+
+	/**
+	\brief Get pointer to element.
+	*/
+	PX_INLINE T* ptr() const
+	{
+		return mPtr;
+	}
+
+	/**
+	\brief Get stride.
+	*/
+	PX_INLINE PxU32 stride() const
+	{
+		return mStride;
+	}
+
+	/**
+	\brief Indirection operator.
+	*/
+	PX_INLINE T& operator*() const
+	{
+		return *mPtr;
+	}
+
+	/**
+	\brief Dereferencing operator.
+	*/
+	PX_INLINE T* operator->() const
+	{
+		return mPtr;
+	}
+
+	/**
+	\brief Indexing operator.
+	*/
+	PX_INLINE T& operator[](unsigned int i) const
+	{
+		return *byteAdd(mPtr, i * stride());
+	}
+
+	/**
+	\brief Pre-increment operator.
+	*/
+	PX_INLINE PxStrideIterator& operator++()
+	{
+		mPtr = byteAdd(mPtr, stride());
+		return *this;
+	}
+
+	/**
+	\brief Post-increment operator.
+	*/
+	PX_INLINE PxStrideIterator operator++(int)
+	{
+		PxStrideIterator tmp = *this;
+		mPtr = byteAdd(mPtr, stride());
+		return tmp;
+	}
+
+	/**
+	\brief Pre-decrement operator.
+	*/
+	PX_INLINE PxStrideIterator& operator--()
+	{
+		mPtr = byteSub(mPtr, stride());
+		return *this;
+	}
+
+	/**
+	\brief Post-decrement operator.
+	*/
+	PX_INLINE PxStrideIterator operator--(int)
+	{
+		PxStrideIterator tmp = *this;
+		mPtr = byteSub(mPtr, stride());
+		return tmp;
+	}
+
+	/**
+	\brief Addition operator.
+	*/
+	PX_INLINE PxStrideIterator operator+(unsigned int i) const
+	{
+		return PxStrideIterator(byteAdd(mPtr, i * stride()), stride());
+	}
+
+	/**
+	\brief Subtraction operator.
+	*/
+	PX_INLINE PxStrideIterator operator-(unsigned int i) const
+	{
+		return PxStrideIterator(byteSub(mPtr, i * stride()), stride());
+	}
+
+	/**
+	\brief Addition compound assignment operator.
+	*/
+	PX_INLINE PxStrideIterator& operator+=(unsigned int i)
+	{
+		mPtr = byteAdd(mPtr, i * stride());
+		return *this;
+	}
+
+	/**
+	\brief Subtraction compound assignment operator.
+	*/
+	PX_INLINE PxStrideIterator& operator-=(unsigned int i)
+	{
+		mPtr = byteSub(mPtr, i * stride());
+		return *this;
+	}
+
+	/**
+	\brief Iterator difference.
+	*/
+	PX_INLINE int operator-(const PxStrideIterator& other) const
+	{
+		PX_ASSERT(isCompatible(other));
+		int byteDiff = static_cast<int>(reinterpret_cast<const PxU8*>(mPtr) - reinterpret_cast<const PxU8*>(other.mPtr));
+		return byteDiff / static_cast<int>(stride());
+	}
+
+	/**
+	\brief Equality operator.
+	*/
+	PX_INLINE bool operator==(const PxStrideIterator& other) const
+	{
+		PX_ASSERT(isCompatible(other));
+		return mPtr == other.mPtr;
+	}
+
+	/**
+	\brief Inequality operator.
+	*/
+	PX_INLINE bool operator!=(const PxStrideIterator& other) const
+	{
+		PX_ASSERT(isCompatible(other));
+		return mPtr != other.mPtr;
+	}
+
+	/**
+	\brief Less than operator.
+	*/
+	PX_INLINE bool operator<(const PxStrideIterator& other) const
+	{
+		PX_ASSERT(isCompatible(other));
+		return mPtr < other.mPtr;
+	}
+
+	/**
+	\brief Greater than operator.
+	*/
+	PX_INLINE bool operator>(const PxStrideIterator& other) const
+	{
+		PX_ASSERT(isCompatible(other));
+		return mPtr > other.mPtr;
+	}
+
+	/**
+	\brief Less or equal than operator.
+	*/
+	PX_INLINE bool operator<=(const PxStrideIterator& other) const
+	{
+		PX_ASSERT(isCompatible(other));
+		return mPtr <= other.mPtr;
+	}
+
+	/**
+	\brief Greater or equal than operator.
+	*/
+	PX_INLINE bool operator>=(const PxStrideIterator& other) const
+	{
+		PX_ASSERT(isCompatible(other));
+		return mPtr >= other.mPtr;
+	}
+
+  private:
+	PX_INLINE static T* byteAdd(T* ptr, PxU32 bytes)
+	{
+		return const_cast<T*>(reinterpret_cast<const T*>(reinterpret_cast<const PxU8*>(ptr) + bytes));
+	}
+
+	PX_INLINE static T* byteSub(T* ptr, PxU32 bytes)
+	{
+		return const_cast<T*>(reinterpret_cast<const T*>(reinterpret_cast<const PxU8*>(ptr) - bytes));
+	}
+
+	PX_INLINE bool isCompatible(const PxStrideIterator& other) const
+	{
+		int byteDiff = static_cast<int>(reinterpret_cast<const PxU8*>(mPtr) - reinterpret_cast<const PxU8*>(other.mPtr));
+		return (stride() == other.stride()) && (abs(byteDiff) % stride() == 0);
+	}
+
+	T* mPtr;
+	PxU32 mStride;
+};
+
+/**
+\brief Addition operator.
+*/
+template <typename T>
+PX_INLINE PxStrideIterator<T> operator+(int i, PxStrideIterator<T> it)
+{
+	it += i;
+	return it;
+}
+
+/**
+\brief Stride iterator factory function which infers the iterator type.
+*/
+template <typename T>
+PX_INLINE PxStrideIterator<T> PxMakeIterator(T* ptr, PxU32 stride = sizeof(T))
+{
+	return PxStrideIterator<T>(ptr, stride);
+}
+
+/**
+\brief Stride iterator factory function which infers the iterator type.
+*/
+template <typename T>
+PX_INLINE PxStrideIterator<const T> PxMakeIterator(const T* ptr, PxU32 stride = sizeof(T))
+{
+	return PxStrideIterator<const T>(ptr, stride);
+}
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // PXFOUNDATION_PXSTRIDEITERATOR_H
diff --git a/PxShared/include/foundation/PxTransform.h b/PxShared/include/foundation/PxTransform.h
new file mode 100644
index 00000000..cffc1d3e
--- /dev/null
+++ b/PxShared/include/foundation/PxTransform.h
@@ -0,0 +1,215 @@
+// 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 PXFOUNDATION_PXTRANSFORM_H
+#define PXFOUNDATION_PXTRANSFORM_H
+/** \addtogroup foundation
+  @{
+*/
+
+#include "foundation/PxQuat.h"
+#include "foundation/PxPlane.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/*!
+\brief class representing a rigid euclidean transform as a quaternion and a vector
+*/
+
+class PxTransform
+{
+  public:
+	PxQuat q;
+	PxVec3 p;
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxTransform()
+	{
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE explicit PxTransform(const PxVec3& position) : q(PxIdentity), p(position)
+	{
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE explicit PxTransform(PxIDENTITY r) : q(PxIdentity), p(PxZero)
+	{
+		PX_UNUSED(r);
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE explicit PxTransform(const PxQuat& orientation) : q(orientation), p(0)
+	{
+		PX_ASSERT(orientation.isSane());
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxTransform(float x, float y, float z, PxQuat aQ = PxQuat(PxIdentity))
+	: q(aQ), p(x, y, z)
+	{
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxTransform(const PxVec3& p0, const PxQuat& q0) : q(q0), p(p0)
+	{
+		PX_ASSERT(q0.isSane());
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE explicit PxTransform(const PxMat44& m); // defined in PxMat44.h
+
+	/**
+	\brief returns true if the two transforms are exactly equal
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool operator==(const PxTransform& t) const
+	{
+		return p == t.p && q == t.q;
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxTransform operator*(const PxTransform& x) const
+	{
+		PX_ASSERT(x.isSane());
+		return transform(x);
+	}
+
+	//! Equals matrix multiplication
+	PX_CUDA_CALLABLE PX_INLINE PxTransform& operator*=(PxTransform& other)
+	{
+		*this = *this * other;
+		return *this;
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxTransform getInverse() const
+	{
+		PX_ASSERT(isFinite());
+		return PxTransform(q.rotateInv(-p), q.getConjugate());
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 transform(const PxVec3& input) const
+	{
+		PX_ASSERT(isFinite());
+		return q.rotate(input) + p;
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 transformInv(const PxVec3& input) const
+	{
+		PX_ASSERT(isFinite());
+		return q.rotateInv(input - p);
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 rotate(const PxVec3& input) const
+	{
+		PX_ASSERT(isFinite());
+		return q.rotate(input);
+	}
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 rotateInv(const PxVec3& input) const
+	{
+		PX_ASSERT(isFinite());
+		return q.rotateInv(input);
+	}
+
+	//! Transform transform to parent (returns compound transform: first src, then *this)
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxTransform transform(const PxTransform& src) const
+	{
+		PX_ASSERT(src.isSane());
+		PX_ASSERT(isSane());
+		// src = [srct, srcr] -> [r*srct + t, r*srcr]
+		return PxTransform(q.rotate(src.p) + p, q * src.q);
+	}
+
+	/**
+	\brief returns true if finite and q is a unit quaternion
+	*/
+
+	PX_CUDA_CALLABLE bool isValid() const
+	{
+		return p.isFinite() && q.isFinite() && q.isUnit();
+	}
+
+	/**
+	\brief returns true if finite and quat magnitude is reasonably close to unit to allow for some accumulation of error
+	vs isValid
+	*/
+
+	PX_CUDA_CALLABLE bool isSane() const
+	{
+		return isFinite() && q.isSane();
+	}
+
+	/**
+	\brief returns true if all elems are finite (not NAN or INF, etc.)
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool isFinite() const
+	{
+		return p.isFinite() && q.isFinite();
+	}
+
+	//! Transform transform from parent (returns compound transform: first src, then this->inverse)
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxTransform transformInv(const PxTransform& src) const
+	{
+		PX_ASSERT(src.isSane());
+		PX_ASSERT(isFinite());
+		// src = [srct, srcr] -> [r^-1*(srct-t), r^-1*srcr]
+		PxQuat qinv = q.getConjugate();
+		return PxTransform(qinv.rotate(src.p - p), qinv * src.q);
+	}
+
+	/**
+	\brief transform plane
+	*/
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxPlane transform(const PxPlane& plane) const
+	{
+		PxVec3 transformedNormal = rotate(plane.n);
+		return PxPlane(transformedNormal, plane.d - p.dot(transformedNormal));
+	}
+
+	/**
+	\brief inverse-transform plane
+	*/
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxPlane inverseTransform(const PxPlane& plane) const
+	{
+		PxVec3 transformedNormal = rotateInv(plane.n);
+		return PxPlane(transformedNormal, plane.d + p.dot(plane.n));
+	}
+
+	/**
+	\brief return a normalized transform (i.e. one in which the quaternion has unit magnitude)
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxTransform getNormalized() const
+	{
+		return PxTransform(p, q.getNormalized());
+	}
+};
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXTRANSFORM_H
diff --git a/PxShared/include/foundation/PxUnionCast.h b/PxShared/include/foundation/PxUnionCast.h
new file mode 100644
index 00000000..2b622033
--- /dev/null
+++ b/PxShared/include/foundation/PxUnionCast.h
@@ -0,0 +1,64 @@
+// 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 PXFOUNDATION_PXUNIONCAST_H
+#define PXFOUNDATION_PXUNIONCAST_H
+
+#include "foundation/Px.h"
+
+/** \addtogroup foundation
+@{
+*/
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+template <class A, class B>
+PX_FORCE_INLINE A PxUnionCast(B b)
+{
+	union AB
+	{
+		AB(B bb) : _b(bb)
+		{
+		}
+		B _b;
+		A _a;
+	} u(b);
+	return u._a;
+}
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+
+#endif // PXFOUNDATION_PXUNIONCAST_H
diff --git a/PxShared/include/foundation/PxVec2.h b/PxShared/include/foundation/PxVec2.h
new file mode 100644
index 00000000..91db0865
--- /dev/null
+++ b/PxShared/include/foundation/PxVec2.h
@@ -0,0 +1,347 @@
+// 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 PXFOUNDATION_PXVEC2_H
+#define PXFOUNDATION_PXVEC2_H
+
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/PxMath.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief 2 Element vector class.
+
+This is a 2-dimensional vector class with public data members.
+*/
+class PxVec2
+{
+  public:
+	/**
+	\brief default constructor leaves data uninitialized.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2()
+	{
+	}
+
+	/**
+	\brief zero constructor.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2(PxZERO r) : x(0.0f), y(0.0f)
+	{
+		PX_UNUSED(r);
+	}
+
+	/**
+	\brief Assigns scalar parameter to all elements.
+
+	Useful to initialize to zero or one.
+
+	\param[in] a Value to assign to elements.
+	*/
+	explicit PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2(float a) : x(a), y(a)
+	{
+	}
+
+	/**
+	\brief Initializes from 2 scalar parameters.
+
+	\param[in] nx Value to initialize X component.
+	\param[in] ny Value to initialize Y component.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2(float nx, float ny) : x(nx), y(ny)
+	{
+	}
+
+	/**
+	\brief Copy ctor.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2(const PxVec2& v) : x(v.x), y(v.y)
+	{
+	}
+
+	// Operators
+
+	/**
+	\brief Assignment operator
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2& operator=(const PxVec2& p)
+	{
+		x = p.x;
+		y = p.y;
+		return *this;
+	}
+
+	/**
+	\brief element access
+	*/
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE float& operator[](int index)
+	{
+		PX_ASSERT(index >= 0 && index <= 1);
+
+		return reinterpret_cast<float*>(this)[index];
+	}
+
+	/**
+	\brief element access
+	*/
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE const float& operator[](int index) const
+	{
+		PX_ASSERT(index >= 0 && index <= 1);
+
+		return reinterpret_cast<const float*>(this)[index];
+	}
+
+	/**
+	\brief returns true if the two vectors are exactly equal.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool operator==(const PxVec2& v) const
+	{
+		return x == v.x && y == v.y;
+	}
+
+	/**
+	\brief returns true if the two vectors are not exactly equal.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool operator!=(const PxVec2& v) const
+	{
+		return x != v.x || y != v.y;
+	}
+
+	/**
+	\brief tests for exact zero vector
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool isZero() const
+	{
+		return x == 0.0f && y == 0.0f;
+	}
+
+	/**
+	\brief returns true if all 2 elems of the vector are finite (not NAN or INF, etc.)
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool isFinite() const
+	{
+		return PxIsFinite(x) && PxIsFinite(y);
+	}
+
+	/**
+	\brief is normalized - used by API parameter validation
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool isNormalized() const
+	{
+		const float unitTolerance = 1e-4f;
+		return isFinite() && PxAbs(magnitude() - 1) < unitTolerance;
+	}
+
+	/**
+	\brief returns the squared magnitude
+
+	Avoids calling PxSqrt()!
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float magnitudeSquared() const
+	{
+		return x * x + y * y;
+	}
+
+	/**
+	\brief returns the magnitude
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float magnitude() const
+	{
+		return PxSqrt(magnitudeSquared());
+	}
+
+	/**
+	\brief negation
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2 operator-() const
+	{
+		return PxVec2(-x, -y);
+	}
+
+	/**
+	\brief vector addition
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2 operator+(const PxVec2& v) const
+	{
+		return PxVec2(x + v.x, y + v.y);
+	}
+
+	/**
+	\brief vector difference
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2 operator-(const PxVec2& v) const
+	{
+		return PxVec2(x - v.x, y - v.y);
+	}
+
+	/**
+	\brief scalar post-multiplication
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2 operator*(float f) const
+	{
+		return PxVec2(x * f, y * f);
+	}
+
+	/**
+	\brief scalar division
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2 operator/(float f) const
+	{
+		f = 1.0f / f; // PT: inconsistent notation with operator /=
+		return PxVec2(x * f, y * f);
+	}
+
+	/**
+	\brief vector addition
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2& operator+=(const PxVec2& v)
+	{
+		x += v.x;
+		y += v.y;
+		return *this;
+	}
+
+	/**
+	\brief vector difference
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2& operator-=(const PxVec2& v)
+	{
+		x -= v.x;
+		y -= v.y;
+		return *this;
+	}
+
+	/**
+	\brief scalar multiplication
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2& operator*=(float f)
+	{
+		x *= f;
+		y *= f;
+		return *this;
+	}
+	/**
+	\brief scalar division
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2& operator/=(float f)
+	{
+		f = 1.0f / f; // PT: inconsistent notation with operator /
+		x *= f;
+		y *= f;
+		return *this;
+	}
+
+	/**
+	\brief returns the scalar product of this and other.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float dot(const PxVec2& v) const
+	{
+		return x * v.x + y * v.y;
+	}
+
+	/** return a unit vector */
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2 getNormalized() const
+	{
+		const float m = magnitudeSquared();
+		return m > 0.0f ? *this * PxRecipSqrt(m) : PxVec2(0, 0);
+	}
+
+	/**
+	\brief normalizes the vector in place
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float normalize()
+	{
+		const float m = magnitude();
+		if(m > 0.0f)
+			*this /= m;
+		return m;
+	}
+
+	/**
+	\brief a[i] * b[i], for all i.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2 multiply(const PxVec2& a) const
+	{
+		return PxVec2(x * a.x, y * a.y);
+	}
+
+	/**
+	\brief element-wise minimum
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2 minimum(const PxVec2& v) const
+	{
+		return PxVec2(PxMin(x, v.x), PxMin(y, v.y));
+	}
+
+	/**
+	\brief returns MIN(x, y);
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float minElement() const
+	{
+		return PxMin(x, y);
+	}
+
+	/**
+	\brief element-wise maximum
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec2 maximum(const PxVec2& v) const
+	{
+		return PxVec2(PxMax(x, v.x), PxMax(y, v.y));
+	}
+
+	/**
+	\brief returns MAX(x, y);
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float maxElement() const
+	{
+		return PxMax(x, y);
+	}
+
+	float x, y;
+};
+
+PX_CUDA_CALLABLE static PX_FORCE_INLINE PxVec2 operator*(float f, const PxVec2& v)
+{
+	return PxVec2(f * v.x, f * v.y);
+}
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXVEC2_H
diff --git a/PxShared/include/foundation/PxVec3.h b/PxShared/include/foundation/PxVec3.h
new file mode 100644
index 00000000..b4fb07d4
--- /dev/null
+++ b/PxShared/include/foundation/PxVec3.h
@@ -0,0 +1,393 @@
+// 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 PXFOUNDATION_PXVEC3_H
+#define PXFOUNDATION_PXVEC3_H
+
+/** \addtogroup foundation
+@{
+*/
+
+#include "foundation/PxMath.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+/**
+\brief 3 Element vector class.
+
+This is a 3-dimensional vector class with public data members.
+*/
+class PxVec3
+{
+  public:
+	/**
+	\brief default constructor leaves data uninitialized.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3()
+	{
+	}
+
+	/**
+	\brief zero constructor.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3(PxZERO r) : x(0.0f), y(0.0f), z(0.0f)
+	{
+		PX_UNUSED(r);
+	}
+
+	/**
+	\brief Assigns scalar parameter to all elements.
+
+	Useful to initialize to zero or one.
+
+	\param[in] a Value to assign to elements.
+	*/
+	explicit PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3(float a) : x(a), y(a), z(a)
+	{
+	}
+
+	/**
+	\brief Initializes from 3 scalar parameters.
+
+	\param[in] nx Value to initialize X component.
+	\param[in] ny Value to initialize Y component.
+	\param[in] nz Value to initialize Z component.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3(float nx, float ny, float nz) : x(nx), y(ny), z(nz)
+	{
+	}
+
+	/**
+	\brief Copy ctor.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3(const PxVec3& v) : x(v.x), y(v.y), z(v.z)
+	{
+	}
+
+	// Operators
+
+	/**
+	\brief Assignment operator
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3& operator=(const PxVec3& p)
+	{
+		x = p.x;
+		y = p.y;
+		z = p.z;
+		return *this;
+	}
+
+	/**
+	\brief element access
+	*/
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE float& operator[](unsigned int index)
+	{
+		PX_ASSERT(index <= 2);
+
+		return reinterpret_cast<float*>(this)[index];
+	}
+
+	/**
+	\brief element access
+	*/
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_FORCE_INLINE const float& operator[](unsigned int index) const
+	{
+		PX_ASSERT(index <= 2);
+
+		return reinterpret_cast<const float*>(this)[index];
+	}
+	/**
+	\brief returns true if the two vectors are exactly equal.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool operator==(const PxVec3& v) const
+	{
+		return x == v.x && y == v.y && z == v.z;
+	}
+
+	/**
+	\brief returns true if the two vectors are not exactly equal.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool operator!=(const PxVec3& v) const
+	{
+		return x != v.x || y != v.y || z != v.z;
+	}
+
+	/**
+	\brief tests for exact zero vector
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool isZero() const
+	{
+		return x == 0.0f && y == 0.0f && z == 0.0f;
+	}
+
+	/**
+	\brief returns true if all 3 elems of the vector are finite (not NAN or INF, etc.)
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool isFinite() const
+	{
+		return PxIsFinite(x) && PxIsFinite(y) && PxIsFinite(z);
+	}
+
+	/**
+	\brief is normalized - used by API parameter validation
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE bool isNormalized() const
+	{
+		const float unitTolerance = 1e-4f;
+		return isFinite() && PxAbs(magnitude() - 1) < unitTolerance;
+	}
+
+	/**
+	\brief returns the squared magnitude
+
+	Avoids calling PxSqrt()!
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float magnitudeSquared() const
+	{
+		return x * x + y * y + z * z;
+	}
+
+	/**
+	\brief returns the magnitude
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float magnitude() const
+	{
+		return PxSqrt(magnitudeSquared());
+	}
+
+	/**
+	\brief negation
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 operator-() const
+	{
+		return PxVec3(-x, -y, -z);
+	}
+
+	/**
+	\brief vector addition
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 operator+(const PxVec3& v) const
+	{
+		return PxVec3(x + v.x, y + v.y, z + v.z);
+	}
+
+	/**
+	\brief vector difference
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 operator-(const PxVec3& v) const
+	{
+		return PxVec3(x - v.x, y - v.y, z - v.z);
+	}
+
+	/**
+	\brief scalar post-multiplication
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 operator*(float f) const
+	{
+		return PxVec3(x * f, y * f, z * f);
+	}
+
+	/**
+	\brief scalar division
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 operator/(float f) const
+	{
+		f = 1.0f / f;
+		return PxVec3(x * f, y * f, z * f);
+	}
+
+	/**
+	\brief vector addition
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3& operator+=(const PxVec3& v)
+	{
+		x += v.x;
+		y += v.y;
+		z += v.z;
+		return *this;
+	}
+
+	/**
+	\brief vector difference
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3& operator-=(const PxVec3& v)
+	{
+		x -= v.x;
+		y -= v.y;
+		z -= v.z;
+		return *this;
+	}
+
+	/**
+	\brief scalar multiplication
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3& operator*=(float f)
+	{
+		x *= f;
+		y *= f;
+		z *= f;
+		return *this;
+	}
+	/**
+	\brief scalar division
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3& operator/=(float f)
+	{
+		f = 1.0f / f;
+		x *= f;
+		y *= f;
+		z *= f;
+		return *this;
+	}
+
+	/**
+	\brief returns the scalar product of this and other.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float dot(const PxVec3& v) const
+	{
+		return x * v.x + y * v.y + z * v.z;
+	}
+
+	/**
+	\brief cross product
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 cross(const PxVec3& v) const
+	{
+		return PxVec3(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
+	}
+
+	/** return a unit vector */
+
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 getNormalized() const
+	{
+		const float m = magnitudeSquared();
+		return m > 0.0f ? *this * PxRecipSqrt(m) : PxVec3(0, 0, 0);
+	}
+
+	/**
+	\brief normalizes the vector in place
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float normalize()
+	{
+		const float m = magnitude();
+		if(m > 0.0f)
+			*this /= m;
+		return m;
+	}
+
+	/**
+	\brief normalizes the vector in place. Does nothing if vector magnitude is under PX_NORMALIZATION_EPSILON.
+	Returns vector magnitude if >= PX_NORMALIZATION_EPSILON and 0.0f otherwise.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float normalizeSafe()
+	{
+		const float mag = magnitude();
+		if(mag < PX_NORMALIZATION_EPSILON)
+			return 0.0f;
+		*this *= 1.0f / mag;
+		return mag;
+	}
+
+	/**
+	\brief normalizes the vector in place. Asserts if vector magnitude is under PX_NORMALIZATION_EPSILON.
+	returns vector magnitude.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float normalizeFast()
+	{
+		const float mag = magnitude();
+		PX_ASSERT(mag >= PX_NORMALIZATION_EPSILON);
+		*this *= 1.0f / mag;
+		return mag;
+	}
+
+	/**
+	\brief a[i] * b[i], for all i.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 multiply(const PxVec3& a) const
+	{
+		return PxVec3(x * a.x, y * a.y, z * a.z);
+	}
+
+	/**
+	\brief element-wise minimum
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 minimum(const PxVec3& v) const
+	{
+		return PxVec3(PxMin(x, v.x), PxMin(y, v.y), PxMin(z, v.z));
+	}
+
+	/**
+	\brief returns MIN(x, y, z);
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float minElement() const
+	{
+		return PxMin(x, PxMin(y, z));
+	}
+
+	/**
+	\brief element-wise maximum
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 maximum(const PxVec3& v) const
+	{
+		return PxVec3(PxMax(x, v.x), PxMax(y, v.y), PxMax(z, v.z));
+	}
+
+	/**
+	\brief returns MAX(x, y, z);
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE float maxElement() const
+	{
+		return PxMax(x, PxMax(y, z));
+	}
+
+	/**
+	\brief returns absolute values of components;
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec3 abs() const
+	{
+		return PxVec3(PxAbs(x), PxAbs(y), PxAbs(z));
+	}
+
+	float x, y, z;
+};
+
+PX_CUDA_CALLABLE static PX_FORCE_INLINE PxVec3 operator*(float f, const PxVec3& v)
+{
+	return PxVec3(f * v.x, f * v.y, f * v.z);
+}
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXVEC3_H
diff --git a/PxShared/include/foundation/PxVec4.h b/PxShared/include/foundation/PxVec4.h
new file mode 100644
index 00000000..883fdf7e
--- /dev/null
+++ b/PxShared/include/foundation/PxVec4.h
@@ -0,0 +1,376 @@
+// 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 PXFOUNDATION_PXVEC4_H
+#define PXFOUNDATION_PXVEC4_H
+/** \addtogroup foundation
+@{
+*/
+#include "foundation/PxMath.h"
+#include "foundation/PxVec3.h"
+#include "foundation/PxAssert.h"
+
+/**
+\brief 4 Element vector class.
+
+This is a 4-dimensional vector class with public data members.
+*/
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+class PxVec4
+{
+  public:
+	/**
+	\brief default constructor leaves data uninitialized.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4()
+	{
+	}
+
+	/**
+	\brief zero constructor.
+	*/
+	PX_CUDA_CALLABLE PX_FORCE_INLINE PxVec4(PxZERO r) : x(0.0f), y(0.0f), z(0.0f), w(0.0f)
+	{
+		PX_UNUSED(r);
+	}
+
+	/**
+	\brief Assigns scalar parameter to all elements.
+
+	Useful to initialize to zero or one.
+
+	\param[in] a Value to assign to elements.
+	*/
+	explicit PX_CUDA_CALLABLE PX_INLINE PxVec4(float a) : x(a), y(a), z(a), w(a)
+	{
+	}
+
+	/**
+	\brief Initializes from 3 scalar parameters.
+
+	\param[in] nx Value to initialize X component.
+	\param[in] ny Value to initialize Y component.
+	\param[in] nz Value to initialize Z component.
+	\param[in] nw Value to initialize W component.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4(float nx, float ny, float nz, float nw) : x(nx), y(ny), z(nz), w(nw)
+	{
+	}
+
+	/**
+	\brief Initializes from 3 scalar parameters.
+
+	\param[in] v Value to initialize the X, Y, and Z components.
+	\param[in] nw Value to initialize W component.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4(const PxVec3& v, float nw) : x(v.x), y(v.y), z(v.z), w(nw)
+	{
+	}
+
+	/**
+	\brief Initializes from an array of scalar parameters.
+
+	\param[in] v Value to initialize with.
+	*/
+	explicit PX_CUDA_CALLABLE PX_INLINE PxVec4(const float v[]) : x(v[0]), y(v[1]), z(v[2]), w(v[3])
+	{
+	}
+
+	/**
+	\brief Copy ctor.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4(const PxVec4& v) : x(v.x), y(v.y), z(v.z), w(v.w)
+	{
+	}
+
+	// Operators
+
+	/**
+	\brief Assignment operator
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4& operator=(const PxVec4& p)
+	{
+		x = p.x;
+		y = p.y;
+		z = p.z;
+		w = p.w;
+		return *this;
+	}
+
+	/**
+	\brief element access
+	*/
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_INLINE float& operator[](unsigned int index)
+	{
+		PX_ASSERT(index <= 3);
+
+		return reinterpret_cast<float*>(this)[index];
+	}
+
+	/**
+	\brief element access
+	*/
+	PX_DEPRECATED PX_CUDA_CALLABLE PX_INLINE const float& operator[](unsigned int index) const
+	{
+		PX_ASSERT(index <= 3);
+
+		return reinterpret_cast<const float*>(this)[index];
+	}
+
+	/**
+	\brief returns true if the two vectors are exactly equal.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool operator==(const PxVec4& v) const
+	{
+		return x == v.x && y == v.y && z == v.z && w == v.w;
+	}
+
+	/**
+	\brief returns true if the two vectors are not exactly equal.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool operator!=(const PxVec4& v) const
+	{
+		return x != v.x || y != v.y || z != v.z || w != v.w;
+	}
+
+	/**
+	\brief tests for exact zero vector
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool isZero() const
+	{
+		return x == 0 && y == 0 && z == 0 && w == 0;
+	}
+
+	/**
+	\brief returns true if all 3 elems of the vector are finite (not NAN or INF, etc.)
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool isFinite() const
+	{
+		return PxIsFinite(x) && PxIsFinite(y) && PxIsFinite(z) && PxIsFinite(w);
+	}
+
+	/**
+	\brief is normalized - used by API parameter validation
+	*/
+	PX_CUDA_CALLABLE PX_INLINE bool isNormalized() const
+	{
+		const float unitTolerance = 1e-4f;
+		return isFinite() && PxAbs(magnitude() - 1) < unitTolerance;
+	}
+
+	/**
+	\brief returns the squared magnitude
+
+	Avoids calling PxSqrt()!
+	*/
+	PX_CUDA_CALLABLE PX_INLINE float magnitudeSquared() const
+	{
+		return x * x + y * y + z * z + w * w;
+	}
+
+	/**
+	\brief returns the magnitude
+	*/
+	PX_CUDA_CALLABLE PX_INLINE float magnitude() const
+	{
+		return PxSqrt(magnitudeSquared());
+	}
+
+	/**
+	\brief negation
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4 operator-() const
+	{
+		return PxVec4(-x, -y, -z, -w);
+	}
+
+	/**
+	\brief vector addition
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4 operator+(const PxVec4& v) const
+	{
+		return PxVec4(x + v.x, y + v.y, z + v.z, w + v.w);
+	}
+
+	/**
+	\brief vector difference
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4 operator-(const PxVec4& v) const
+	{
+		return PxVec4(x - v.x, y - v.y, z - v.z, w - v.w);
+	}
+
+	/**
+	\brief scalar post-multiplication
+	*/
+
+	PX_CUDA_CALLABLE PX_INLINE PxVec4 operator*(float f) const
+	{
+		return PxVec4(x * f, y * f, z * f, w * f);
+	}
+
+	/**
+	\brief scalar division
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4 operator/(float f) const
+	{
+		f = 1.0f / f;
+		return PxVec4(x * f, y * f, z * f, w * f);
+	}
+
+	/**
+	\brief vector addition
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4& operator+=(const PxVec4& v)
+	{
+		x += v.x;
+		y += v.y;
+		z += v.z;
+		w += v.w;
+		return *this;
+	}
+
+	/**
+	\brief vector difference
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4& operator-=(const PxVec4& v)
+	{
+		x -= v.x;
+		y -= v.y;
+		z -= v.z;
+		w -= v.w;
+		return *this;
+	}
+
+	/**
+	\brief scalar multiplication
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4& operator*=(float f)
+	{
+		x *= f;
+		y *= f;
+		z *= f;
+		w *= f;
+		return *this;
+	}
+	/**
+	\brief scalar division
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4& operator/=(float f)
+	{
+		f = 1.0f / f;
+		x *= f;
+		y *= f;
+		z *= f;
+		w *= f;
+		return *this;
+	}
+
+	/**
+	\brief returns the scalar product of this and other.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE float dot(const PxVec4& v) const
+	{
+		return x * v.x + y * v.y + z * v.z + w * v.w;
+	}
+
+	/** return a unit vector */
+
+	PX_CUDA_CALLABLE PX_INLINE PxVec4 getNormalized() const
+	{
+		float m = magnitudeSquared();
+		return m > 0.0f ? *this * PxRecipSqrt(m) : PxVec4(0, 0, 0, 0);
+	}
+
+	/**
+	\brief normalizes the vector in place
+	*/
+	PX_CUDA_CALLABLE PX_INLINE float normalize()
+	{
+		float m = magnitude();
+		if(m > 0.0f)
+			*this /= m;
+		return m;
+	}
+
+	/**
+	\brief a[i] * b[i], for all i.
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4 multiply(const PxVec4& a) const
+	{
+		return PxVec4(x * a.x, y * a.y, z * a.z, w * a.w);
+	}
+
+	/**
+	\brief element-wise minimum
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4 minimum(const PxVec4& v) const
+	{
+		return PxVec4(PxMin(x, v.x), PxMin(y, v.y), PxMin(z, v.z), PxMin(w, v.w));
+	}
+
+	/**
+	\brief element-wise maximum
+	*/
+	PX_CUDA_CALLABLE PX_INLINE PxVec4 maximum(const PxVec4& v) const
+	{
+		return PxVec4(PxMax(x, v.x), PxMax(y, v.y), PxMax(z, v.z), PxMax(w, v.w));
+	}
+
+	PX_CUDA_CALLABLE PX_INLINE PxVec3 getXYZ() const
+	{
+		return PxVec3(x, y, z);
+	}
+
+	/**
+	\brief set vector elements to zero
+	*/
+	PX_CUDA_CALLABLE PX_INLINE void setZero()
+	{
+		x = y = z = w = 0.0f;
+	}
+
+	float x, y, z, w;
+};
+
+PX_CUDA_CALLABLE static PX_INLINE PxVec4 operator*(float f, const PxVec4& v)
+{
+	return PxVec4(f * v.x, f * v.y, f * v.z, f * v.w);
+}
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+/** @} */
+#endif // #ifndef PXFOUNDATION_PXVEC4_H
diff --git a/PxShared/include/foundation/unix/PxUnixIntrinsics.h b/PxShared/include/foundation/unix/PxUnixIntrinsics.h
new file mode 100644
index 00000000..7c0916f0
--- /dev/null
+++ b/PxShared/include/foundation/unix/PxUnixIntrinsics.h
@@ -0,0 +1,181 @@
+// 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 PXFOUNDATION_PXUNIXINTRINSICS_H
+#define PXFOUNDATION_PXUNIXINTRINSICS_H
+
+#include "foundation/Px.h"
+#include "foundation/PxAssert.h"
+
+#if !(PX_LINUX || PX_ANDROID || PX_PS4 || PX_APPLE_FAMILY)
+#error "This file should only be included by Unix builds!!"
+#endif
+
+#if PX_LINUX && PX_ARM
+	// Linux ARM toolchain can somehow end up including cmath header after math.h, which will undef a bunch of macros and place them in std namespace
+	#ifndef isfinite
+		#define isfinite	std::isfinite
+	#endif
+#endif
+
+#include <math.h>
+#include <float.h>
+
+namespace physx
+{
+namespace intrinsics
+{
+//! \brief platform-specific absolute value
+PX_CUDA_CALLABLE PX_FORCE_INLINE float abs(float a)
+{
+	return ::fabsf(a);
+}
+
+//! \brief platform-specific select float
+PX_CUDA_CALLABLE PX_FORCE_INLINE float fsel(float a, float b, float c)
+{
+	return (a >= 0.0f) ? b : c;
+}
+
+//! \brief platform-specific sign
+PX_CUDA_CALLABLE PX_FORCE_INLINE float sign(float a)
+{
+	return (a >= 0.0f) ? 1.0f : -1.0f;
+}
+
+//! \brief platform-specific reciprocal
+PX_CUDA_CALLABLE PX_FORCE_INLINE float recip(float a)
+{
+	return 1.0f / a;
+}
+
+//! \brief platform-specific reciprocal estimate
+PX_CUDA_CALLABLE PX_FORCE_INLINE float recipFast(float a)
+{
+	return 1.0f / a;
+}
+
+//! \brief platform-specific square root
+PX_CUDA_CALLABLE PX_FORCE_INLINE float sqrt(float a)
+{
+	return ::sqrtf(a);
+}
+
+//! \brief platform-specific reciprocal square root
+PX_CUDA_CALLABLE PX_FORCE_INLINE float recipSqrt(float a)
+{
+	return 1.0f / ::sqrtf(a);
+}
+
+PX_CUDA_CALLABLE PX_FORCE_INLINE float recipSqrtFast(float a)
+{
+	return 1.0f / ::sqrtf(a);
+}
+
+//! \brief platform-specific sine
+PX_CUDA_CALLABLE PX_FORCE_INLINE float sin(float a)
+{
+	return ::sinf(a);
+}
+
+//! \brief platform-specific cosine
+PX_CUDA_CALLABLE PX_FORCE_INLINE float cos(float a)
+{
+	return ::cosf(a);
+}
+
+//! \brief platform-specific minimum
+PX_CUDA_CALLABLE PX_FORCE_INLINE float selectMin(float a, float b)
+{
+	return a < b ? a : b;
+}
+
+//! \brief platform-specific maximum
+PX_CUDA_CALLABLE PX_FORCE_INLINE float selectMax(float a, float b)
+{
+	return a > b ? a : b;
+}
+
+//! \brief platform-specific finiteness check (not INF or NAN)
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool isFinite(float a)
+{
+	return !!isfinite(a);
+}
+
+//! \brief platform-specific finiteness check (not INF or NAN)
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool isFinite(double a)
+{
+	return !!isfinite(a);
+}
+
+/*!
+Sets \c count bytes starting at \c dst to zero.
+*/
+PX_FORCE_INLINE void* memZero(void* dest, uint32_t count)
+{
+	return memset(dest, 0, count);
+}
+
+/*!
+Sets \c count bytes starting at \c dst to \c c.
+*/
+PX_FORCE_INLINE void* memSet(void* dest, int32_t c, uint32_t count)
+{
+	return memset(dest, c, count);
+}
+
+/*!
+Copies \c count bytes from \c src to \c dst. User memMove if regions overlap.
+*/
+PX_FORCE_INLINE void* memCopy(void* dest, const void* src, uint32_t count)
+{
+	return memcpy(dest, src, count);
+}
+
+/*!
+Copies \c count bytes from \c src to \c dst. Supports overlapping regions.
+*/
+PX_FORCE_INLINE void* memMove(void* dest, const void* src, uint32_t count)
+{
+	return memmove(dest, src, count);
+}
+
+/*!
+Set 128B to zero starting at \c dst+offset. Must be aligned.
+*/
+PX_FORCE_INLINE void memZero128(void* dest, uint32_t offset = 0)
+{
+	PX_ASSERT(((size_t(dest) + offset) & 0x7f) == 0);
+	memSet(reinterpret_cast<char*>(dest) + offset, 0, 128);
+}
+
+} // namespace intrinsics
+} // namespace physx
+
+#endif // #ifndef PXFOUNDATION_PXUNIXINTRINSICS_H
diff --git a/PxShared/include/foundation/windows/PxWindowsFoundationDelayLoadHook.h b/PxShared/include/foundation/windows/PxWindowsFoundationDelayLoadHook.h
new file mode 100644
index 00000000..f328e529
--- /dev/null
+++ b/PxShared/include/foundation/windows/PxWindowsFoundationDelayLoadHook.h
@@ -0,0 +1,71 @@
+// 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_FOUNDATION_DELAY_LOAD_HOOK
+#define PX_FOUNDATION_DELAY_LOAD_HOOK
+
+#include "foundation/PxPreprocessor.h"
+
+/** \addtogroup foundation
+@{
+*/
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+	/**
+ 	\brief PxFoundationDelayLoadHook
+
+	This is a helper class for delay loading the PxFoundation dll. 
+	If a PxFoundation dll with a non-default file name needs to be loaded, 
+	PxFoundationDelayLoadHook can be sub-classed to provide the custom file names.
+
+	Once the names are set, the instance must be set for use by the loading dll. 
+ 	*/
+	class PxFoundationDelayLoadHook
+	{
+	public:
+		PxFoundationDelayLoadHook() {}
+		virtual ~PxFoundationDelayLoadHook() {}
+
+		virtual const char* getPxFoundationDEBUGDllName() const = 0;
+		virtual const char* getPxFoundationCHECKEDDllName() const = 0;
+		virtual const char* getPxFoundationPROFILEDllName() const = 0;
+		virtual const char* getPxFoundationDllName() const = 0;
+
+	protected:
+	private:
+	};
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+/** @} */
+#endif
diff --git a/PxShared/include/foundation/windows/PxWindowsIntrinsics.h b/PxShared/include/foundation/windows/PxWindowsIntrinsics.h
new file mode 100644
index 00000000..bff41375
--- /dev/null
+++ b/PxShared/include/foundation/windows/PxWindowsIntrinsics.h
@@ -0,0 +1,188 @@
+// 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 PXFOUNDATION_PXWINDOWSINTRINSICS_H
+#define PXFOUNDATION_PXWINDOWSINTRINSICS_H
+
+#include "foundation/Px.h"
+#include "foundation/PxAssert.h"
+
+#if !PX_WINDOWS_FAMILY
+#error "This file should only be included by Windows builds!!"
+#endif
+
+#include <math.h>
+#include <float.h>
+
+#if !PX_DOXYGEN
+namespace physx
+{
+namespace intrinsics
+{
+#endif
+
+//! \brief platform-specific absolute value
+PX_CUDA_CALLABLE PX_FORCE_INLINE float abs(float a)
+{
+	return ::fabsf(a);
+}
+
+//! \brief platform-specific select float
+PX_CUDA_CALLABLE PX_FORCE_INLINE float fsel(float a, float b, float c)
+{
+	return (a >= 0.0f) ? b : c;
+}
+
+//! \brief platform-specific sign
+PX_CUDA_CALLABLE PX_FORCE_INLINE float sign(float a)
+{
+	return (a >= 0.0f) ? 1.0f : -1.0f;
+}
+
+//! \brief platform-specific reciprocal
+PX_CUDA_CALLABLE PX_FORCE_INLINE float recip(float a)
+{
+	return 1.0f / a;
+}
+
+//! \brief platform-specific reciprocal estimate
+PX_CUDA_CALLABLE PX_FORCE_INLINE float recipFast(float a)
+{
+	return 1.0f / a;
+}
+
+//! \brief platform-specific square root
+PX_CUDA_CALLABLE PX_FORCE_INLINE float sqrt(float a)
+{
+	return ::sqrtf(a);
+}
+
+//! \brief platform-specific reciprocal square root
+PX_CUDA_CALLABLE PX_FORCE_INLINE float recipSqrt(float a)
+{
+	return 1.0f / ::sqrtf(a);
+}
+
+//! \brief platform-specific reciprocal square root estimate
+PX_CUDA_CALLABLE PX_FORCE_INLINE float recipSqrtFast(float a)
+{
+	return 1.0f / ::sqrtf(a);
+}
+
+//! \brief platform-specific sine
+PX_CUDA_CALLABLE PX_FORCE_INLINE float sin(float a)
+{
+	return ::sinf(a);
+}
+
+//! \brief platform-specific cosine
+PX_CUDA_CALLABLE PX_FORCE_INLINE float cos(float a)
+{
+	return ::cosf(a);
+}
+
+//! \brief platform-specific minimum
+PX_CUDA_CALLABLE PX_FORCE_INLINE float selectMin(float a, float b)
+{
+	return a < b ? a : b;
+}
+
+//! \brief platform-specific maximum
+PX_CUDA_CALLABLE PX_FORCE_INLINE float selectMax(float a, float b)
+{
+	return a > b ? a : b;
+}
+
+//! \brief platform-specific finiteness check (not INF or NAN)
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool isFinite(float a)
+{
+#ifdef __CUDACC__
+	return !!isfinite(a);
+#else
+	return (0 == ((_FPCLASS_SNAN | _FPCLASS_QNAN | _FPCLASS_NINF | _FPCLASS_PINF) & _fpclass(a)));
+#endif
+}
+
+//! \brief platform-specific finiteness check (not INF or NAN)
+PX_CUDA_CALLABLE PX_FORCE_INLINE bool isFinite(double a)
+{
+#ifdef __CUDACC__
+	return !!isfinite(a);
+#else
+	return (0 == ((_FPCLASS_SNAN | _FPCLASS_QNAN | _FPCLASS_NINF | _FPCLASS_PINF) & _fpclass(a)));
+#endif
+}
+
+/*!
+Sets \c count bytes starting at \c dst to zero.
+*/
+PX_FORCE_INLINE void* memZero(void* dest, uint32_t count)
+{
+	return memset(dest, 0, count);
+}
+
+/*!
+Sets \c count bytes starting at \c dst to \c c.
+*/
+PX_FORCE_INLINE void* memSet(void* dest, int32_t c, uint32_t count)
+{
+	return memset(dest, c, count);
+}
+
+/*!
+Copies \c count bytes from \c src to \c dst. User memMove if regions overlap.
+*/
+PX_FORCE_INLINE void* memCopy(void* dest, const void* src, uint32_t count)
+{
+	return memcpy(dest, src, count);
+}
+
+/*!
+Copies \c count bytes from \c src to \c dst. Supports overlapping regions.
+*/
+PX_FORCE_INLINE void* memMove(void* dest, const void* src, uint32_t count)
+{
+	return memmove(dest, src, count);
+}
+
+/*!
+Set 128B to zero starting at \c dst+offset. Must be aligned.
+*/
+PX_FORCE_INLINE void memZero128(void* dest, uint32_t offset = 0)
+{
+	PX_ASSERT(((size_t(dest) + offset) & 0x7f) == 0);
+	memSet(reinterpret_cast<char*>(dest) + offset, 0, 128);
+}
+
+#if !PX_DOXYGEN
+} // namespace intrinsics
+} // namespace physx
+#endif
+
+#endif // #ifndef PXFOUNDATION_PXWINDOWSINTRINSICS_H