Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

25 files changed, 7821 insertions, 0 deletions

diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnJointRepXSerializer.cpp b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnJointRepXSerializer.cpp
new file mode 100644
index 00000000..94d60453
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnJointRepXSerializer.cpp
@@ -0,0 +1,137 @@
+// 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.  
+#include "PxMetaDataObjects.h"
+#include "PxExtensionMetaDataObjects.h"
+#include "ExtJointMetaDataExtensions.h" 
+#include "SnRepXSerializerImpl.h"
+#include "PxJointRepXSerializer.h"
+
+namespace physx { 
+
+	template<typename TJointType>
+	inline TJointType* createJoint( PxPhysics& physics, 
+									   PxRigidActor* actor0, const PxTransform& localFrame0, 
+									   PxRigidActor* actor1, const PxTransform& localFrame1 )
+	{
+		PX_UNUSED(physics);
+		PX_UNUSED(actor0);
+		PX_UNUSED(actor1);
+		PX_UNUSED(localFrame0);
+		PX_UNUSED(localFrame1);
+		return NULL;
+	}
+
+	template<>
+	inline PxD6Joint* createJoint<PxD6Joint>(PxPhysics& physics, 
+										PxRigidActor* actor0, const PxTransform& localFrame0, 
+										PxRigidActor* actor1, const PxTransform& localFrame1)
+	{
+		return PxD6JointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
+	}
+
+	template<>
+	inline PxDistanceJoint*	createJoint<PxDistanceJoint>(PxPhysics& physics, 
+									 		  PxRigidActor* actor0, const PxTransform& localFrame0, 
+											  PxRigidActor* actor1, const PxTransform& localFrame1)
+	{
+		return PxDistanceJointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
+	}
+
+	template<>
+	inline PxFixedJoint* createJoint<PxFixedJoint>(PxPhysics& physics, 
+										   PxRigidActor* actor0, const PxTransform& localFrame0, 
+										   PxRigidActor* actor1, const PxTransform& localFrame1)
+	{
+		return PxFixedJointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
+	}
+
+	template<>
+	inline PxPrismaticJoint* createJoint<PxPrismaticJoint>(PxPhysics& physics, 
+											   PxRigidActor* actor0, const PxTransform& localFrame0, 
+											   PxRigidActor* actor1, const PxTransform& localFrame1)
+	{
+		return PxPrismaticJointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
+	}
+
+	template<>
+	inline PxRevoluteJoint*	createJoint<PxRevoluteJoint>(PxPhysics& physics, 
+											  PxRigidActor* actor0, const PxTransform& localFrame0, 
+											  PxRigidActor* actor1, const PxTransform& localFrame1)
+	{
+		return PxRevoluteJointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
+	}
+
+	template<>
+	inline PxSphericalJoint* createJoint<PxSphericalJoint>(PxPhysics& physics, 
+											   PxRigidActor* actor0, const PxTransform& localFrame0, 
+											   PxRigidActor* actor1, const PxTransform& localFrame1)
+	{
+		return PxSphericalJointCreate( physics, actor0, localFrame0, actor1, localFrame1 );
+	}
+	
+	template<typename TJointType>
+	PxRepXObject PxJointRepXSerializer<TJointType>::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
+	{
+		PxRigidActor* actor0 = NULL;
+		PxRigidActor* actor1 = NULL;
+		PxTransform localPose0 = PxTransform(PxIdentity);
+		PxTransform localPose1 = PxTransform(PxIdentity);
+		bool ok = true;
+		if ( inReader.gotoChild( "Actors" ) )
+		{
+			ok = readReference<PxRigidActor>( inReader, *inCollection, "actor0", actor0 );
+			ok &= readReference<PxRigidActor>( inReader, *inCollection, "actor1", actor1 );
+			inReader.leaveChild();
+		}
+		TJointType* theJoint = !ok ? NULL : createJoint<TJointType>( inArgs.physics, actor0, localPose0, actor1, localPose1 );
+		
+		if ( theJoint )
+        {
+            PxConstraint* constraint = theJoint->getConstraint();
+			PX_ASSERT( constraint );
+			inCollection->add( *constraint ); 
+			this->fileToObjectImpl( theJoint, inReader, inAllocator, inArgs, inCollection );
+        }
+		return PxCreateRepXObject(theJoint);
+	}
+
+	template<typename TJointType>
+	void PxJointRepXSerializer<TJointType>::objectToFileImpl( const TJointType* inObj, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs&   ) 
+	{
+		writeAllProperties( inObj, inWriter, inTempBuffer, *inCollection );
+	}
+	
+	// explicit instantiations
+	template struct PxJointRepXSerializer<PxFixedJoint>;
+	template struct PxJointRepXSerializer<PxDistanceJoint>;
+	template struct PxJointRepXSerializer<PxD6Joint>;
+	template struct PxJointRepXSerializer<PxPrismaticJoint>;
+	template struct PxJointRepXSerializer<PxRevoluteJoint>;
+	template struct PxJointRepXSerializer<PxSphericalJoint>;
+}
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnPxStreamOperators.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnPxStreamOperators.h
new file mode 100644
index 00000000..efca5662
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnPxStreamOperators.h
@@ -0,0 +1,134 @@
+// 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_PXSTREAMOPERATORS_H
+#define PX_PXSTREAMOPERATORS_H
+
+#include "foundation/PxVec3.h"
+#include "foundation/PxTransform.h"
+#include "foundation/PxBounds3.h"
+#include "PxFiltering.h"
+
+#include "PsString.h"
+
+namespace physx
+{
+	static inline PxU32 strLenght( const char* inStr )
+	{
+		return inStr ? PxU32(strlen(inStr)) : 0;
+	}
+}
+
+namespace physx // ADL requires we put the operators in the same namespace as the underlying type of PxOutputStream
+{
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, const char* inString )
+	{
+		if ( inString && *inString )
+		{
+			ioStream.write( inString, PxU32(strlen(inString)) );
+		}
+		return ioStream;
+	}
+
+	template<typename TDataType>
+	inline PxOutputStream& toStream( PxOutputStream& ioStream, const char* inFormat, const TDataType inData )
+	{
+		char buffer[128] = { 0 };
+		Ps::snprintf( buffer, 128, inFormat, inData );
+		ioStream << buffer;
+		return ioStream;
+	}
+
+	struct endl_obj {};
+	//static endl_obj endl;
+
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, bool inData ) { ioStream << (inData ? "true" : "false"); return ioStream; }
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxI32 inData ) { return toStream( ioStream, "%d",  inData ); }
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxU16 inData ) {	return toStream( ioStream, "%u", PxU32(inData) ); }
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxU8 inData ) {	return toStream( ioStream, "%u", PxU32(inData) ); }
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, char inData ) {	return toStream( ioStream, "%c", inData ); }
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxU32 inData ) {	return toStream( ioStream, "%u", inData ); }
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxU64 inData ) {	return toStream( ioStream, "%" PX_PRIu64, inData ); }
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, const void* inData ) { return ioStream << PX_PROFILE_POINTER_TO_U64( inData ); }
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxF32 inData ) { return toStream( ioStream, "%g", PxF64(inData) ); }
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, PxF64 inData ) { return toStream( ioStream, "%g", inData ); }
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, endl_obj) { return ioStream << "\n"; }
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, const PxVec3& inData ) 
+	{ 
+		ioStream << inData[0];
+		ioStream << " ";
+		ioStream << inData[1];
+		ioStream << " ";
+		ioStream << inData[2];
+		return ioStream;
+	}
+
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, const PxQuat& inData ) 
+	{
+		ioStream << inData.x;
+		ioStream << " ";
+		ioStream << inData.y;
+		ioStream << " ";
+		ioStream << inData.z;
+		ioStream << " ";
+		ioStream << inData.w;
+		return ioStream;
+	}
+
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, const PxTransform& inData ) 
+	{
+		ioStream << inData.q;
+		ioStream << " ";
+		ioStream << inData.p;
+		return ioStream;
+	}
+
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, const PxBounds3& inData )
+	{
+		ioStream << inData.minimum;
+		ioStream << " ";
+		ioStream << inData.maximum;
+		return ioStream;
+	}
+
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, const PxFilterData& inData )
+	{
+		ioStream << inData.word0 << " " << inData.word1 << " " << inData.word2 << " " << inData.word3;
+		return ioStream;
+	}
+
+	inline PxOutputStream& operator << ( PxOutputStream& ioStream, struct PxMetaDataPlane& inData )
+	{
+		ioStream << inData.normal;
+		ioStream << " ";
+		ioStream << inData.distance;
+		return ioStream;
+	}
+}
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepX1_0Defaults.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepX1_0Defaults.h
new file mode 100644
index 00000000..31ad950e
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepX1_0Defaults.h
@@ -0,0 +1,245 @@
+// 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.  
+
+	DEFINE_REPX_DEFAULT_PROPERTY("PxBoxGeometry.HalfExtents", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphereGeometry.Radius", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.Scale.Scale", "1 1 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.Scale.Rotation", "0 0 0 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.ConvexMesh", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.Scale.Scale", "1 1 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.Scale.Rotation", "0 0 0 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.MeshFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.TriangleMesh", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightField", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightScale", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.RowScale", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.ColumnScale", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightFieldFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Length", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Mass", "1000" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Speed", "10" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.DynamicFriction", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.StaticFriction", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.DynamicFrictionV", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.StaticFrictionV", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.DirOfAnisotropy", "1 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.FrictionCombineMode", "eAVERAGE" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.RestitutionCombineMode", "eAVERAGE" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.LocalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.SimulationFilterData", "0 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.QueryFilterData", "0 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.ContactOffset", "0.02" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.RestOffset", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.Flags", "eSIMULATION_SHAPE|eSCENE_QUERY_SHAPE|eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.ClientBehaviorBits", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.GlobalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ClientBehaviorBits", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.CMassLocalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.Mass", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.MassSpaceInertiaTensor", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.GlobalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.LinearVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.AngularVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.LinearDamping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.AngularDamping", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.MaxAngularVelocity", "7" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SleepEnergyThreshold", "0.005" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SolverIterationCounts.minPositionIters", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SolverIterationCounts.minVelocityIters", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ContactReportThreshold", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.RigidDynamicFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ParentPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ChildPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TargetOrientation", "0 0 0 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TargetVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.InternalCompliance", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ExternalCompliance", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimit.yLimit", "0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimit.zLimit", "0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimitEnabled", "false" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimit.lower", "-0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimit.upper", "0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimitEnabled", "false" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.ClientBehaviorBits", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.CMassLocalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.Mass", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.MassSpaceInertiaTensor", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.GlobalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.LinearVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.AngularVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.MaxProjectionIterations", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SeparationTolerance", "0.1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.InternalDriveIterations", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.ExternalDriveIterations", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SolverIterationCounts.minPositionIters", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SolverIterationCounts.minVelocityIters", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eX", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eY", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eZ", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eTWIST", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eSWING1", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eSWING2", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Value", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Upper", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Lower", "-1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.YAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.ZAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DrivePosition", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DriveVelocity.linear", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DriveVelocity.angular", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.MinDistance", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.MaxDistance", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Tolerance", "0.025" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.DistanceJointFlags", "eMAX_DISTANCE_ENABLED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Upper", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Lower", "-1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveVelocity", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveGearRatio", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.RevoluteJointFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.ContactDistance", "0.01" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Upper", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Lower", "-3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.PrismaticJointFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.UserData", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.YAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.ZAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.SphericalJointFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("THEEND", "false" )
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepX3_1Defaults.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepX3_1Defaults.h
new file mode 100644
index 00000000..a3e52a73
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepX3_1Defaults.h
@@ -0,0 +1,274 @@
+// 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.  
+
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Length", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Mass", "1000" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Speed", "10" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxBoxGeometry.HalfExtents", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphereGeometry.Radius", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.Scale.Scale", "1 1 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.Scale.Rotation", "0 0 0 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.ConvexMesh", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.Scale.Scale", "1 1 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.Scale.Rotation", "0 0 0 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.MeshFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.TriangleMesh", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightField", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightScale", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.RowScale", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.ColumnScale", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightFieldFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.DynamicFriction", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.StaticFriction", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.DynamicFrictionV", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.StaticFrictionV", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.DirOfAnisotropy", "1 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.FrictionCombineMode", "eAVERAGE" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.RestitutionCombineMode", "eAVERAGE" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.LocalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.SimulationFilterData", "0 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.QueryFilterData", "0 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.ContactOffset", "0.02" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.RestOffset", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.Flags", "eSIMULATION_SHAPE|eSCENE_QUERY_SHAPE|eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.ClientBehaviorBits", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.GlobalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ClientBehaviorBits", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.GlobalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.CMassLocalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.Mass", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.MassSpaceInertiaTensor", "1 1 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.LinearVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.AngularVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.LinearDamping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.AngularDamping", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.MaxAngularVelocity", "7" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SleepThreshold", "0.005" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SolverIterationCounts.minPositionIters", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SolverIterationCounts.minVelocityIters", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ContactReportThreshold", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.RigidDynamicFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ParentPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ChildPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TargetOrientation", "0 0 0 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TargetVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.InternalCompliance", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ExternalCompliance", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimit.yLimit", "0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimit.zLimit", "0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TangentialSpring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TangentialDamping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimitContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimitEnabled", "false" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimit.lower", "-0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimit.upper", "0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimitEnabled", "false" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimitContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.ClientBehaviorBits", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.GlobalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.CMassLocalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.Mass", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.MassSpaceInertiaTensor", "1 1 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.LinearVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.AngularVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.MaxProjectionIterations", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SeparationTolerance", "0.1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.InternalDriveIterations", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.ExternalDriveIterations", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SolverIterationCounts.minPositionIters", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SolverIterationCounts.minVelocityIters", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SleepThreshold", "0.005" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eX", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eY", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eZ", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eTWIST", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eSWING1", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eSWING2", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Value", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Upper", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Lower", "-1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.YAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.ZAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DrivePosition", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DriveVelocity.linear", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DriveVelocity.angular", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.MinDistance", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.MaxDistance", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Tolerance", "0.025" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.DistanceJointFlags", "eMAX_DISTANCE_ENABLED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Upper", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Lower", "-1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveVelocity", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveGearRatio", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.RevoluteJointFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.ContactDistance", "0.01" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Upper", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Lower", "-3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.PrismaticJointFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.YAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.ZAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.SphericalJointFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.ClientBehaviorBits", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.MotionConstraintScaleBias.scale", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.MotionConstraintScaleBias.bias", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.GlobalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.ExternalAcceleration", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.DampingCoefficient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.SolverFrequency", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.SleepLinearVelocity", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("THEEND", "false" )
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepX3_2Defaults.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepX3_2Defaults.h
new file mode 100644
index 00000000..f3959504
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepX3_2Defaults.h
@@ -0,0 +1,313 @@
+// 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.  
+
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Length", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Mass", "1000" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTolerancesScale.Speed", "10" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxBoxGeometry.HalfExtents", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphereGeometry.Radius", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.Scale.Scale", "1 1 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.Scale.Rotation", "0 0 0 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxConvexMeshGeometry.ConvexMesh", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.Scale.Scale", "1 1 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.Scale.Rotation", "0 0 0 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.MeshFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxTriangleMeshGeometry.TriangleMesh", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightField", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightScale", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.RowScale", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.ColumnScale", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxHeightFieldGeometry.HeightFieldFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.DynamicFriction", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.StaticFriction", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.FrictionCombineMode", "eAVERAGE" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxMaterial.RestitutionCombineMode", "eAVERAGE" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.LocalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.SimulationFilterData", "0 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.QueryFilterData", "0 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.ContactOffset", "0.02" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.RestOffset", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.Flags", "eSIMULATION_SHAPE|eSCENE_QUERY_SHAPE|eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxShape.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.ClientBehaviorBits", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidStatic.GlobalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ClientBehaviorBits", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.GlobalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.CMassLocalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.Mass", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.MassSpaceInertiaTensor", "1 1 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.LinearVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.AngularVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.LinearDamping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.AngularDamping", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.MaxAngularVelocity", "7" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SleepThreshold", "0.005" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SolverIterationCounts.minPositionIters", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.SolverIterationCounts.minVelocityIters", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.ContactReportThreshold", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRigidDynamic.RigidDynamicFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ParentPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ChildPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TargetOrientation", "0 0 0 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TargetVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.InternalCompliance", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.ExternalCompliance", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimit.yLimit", "0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimit.zLimit", "0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TangentialSpring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TangentialDamping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimitContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.SwingLimitEnabled", "false" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimit.lower", "-0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimit.upper", "0.78539816339" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimitEnabled", "false" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationJoint.TwistLimitContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.ClientBehaviorBits", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.GlobalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.CMassLocalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.Mass", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.MassSpaceInertiaTensor", "1 1 1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.LinearVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulationLink.AngularVelocity", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.MaxProjectionIterations", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SeparationTolerance", "0.1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.InternalDriveIterations", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.ExternalDriveIterations", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SolverIterationCounts.minPositionIters", "4" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SolverIterationCounts.minVelocityIters", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.SleepThreshold", "0.005" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxArticulation.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eX", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eY", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eZ", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eTWIST", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eSWING1", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Motion.eSWING2", "eLOCKED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.LinearLimit.Value", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Upper", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.TwistLimit.Lower", "-1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.YAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.SwingLimit.ZAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eX.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eY.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eZ.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSWING.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eTWIST.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.ForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.Drive.eSLERP.Flags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DrivePosition", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DriveVelocity.linear", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.DriveVelocity.angular", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxD6Joint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxFixedJoint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.MinDistance", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.MaxDistance", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Tolerance", "0.025" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxDistanceJoint.DistanceJointFlags", "eMAX_DISTANCE_ENABLED" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Upper", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.Limit.Lower", "-1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveVelocity", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveForceLimit", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.DriveGearRatio", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.RevoluteJointFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxRevoluteJoint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.ContactDistance", "0.01" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Upper", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.Limit.Lower", "-3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.PrismaticJointFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxPrismaticJoint.ProjectionAngularTolerance", "3.14159" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.Actors.actor0", "8887040" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.Actors.actor1", "8887456" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LocalPose.eACTOR0", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LocalPose.eACTOR1", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.BreakForce.force", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.BreakForce.torque", "3.40282e+038" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.ConstraintFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Restitution", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Spring", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.ContactDistance", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.YAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.LimitCone.ZAngle", "1.5708" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.SphericalJointFlags", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxSphericalJoint.ProjectionLinearTolerance", "1e+010" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.Name", "" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.ClientBehaviorBits", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.MotionConstraintScaleBias.scale", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.MotionConstraintScaleBias.bias", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.GlobalPose", "0 0 0 1 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.ExternalAcceleration", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.DampingCoefficient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.SolverFrequency", "1" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.SleepLinearVelocity", "0" )
+    DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.InertiaScale", "1" ) 
+    DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.FrictionCoefficient", "0" ) 
+    DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.DragCoefficient", "0" ) 
+    DEFINE_REPX_DEFAULT_PROPERTY("PxCloth.CollisionMassScale", "0" ) 
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.ExternalAcceleration", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.ParticleMass", "0.001" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.Restitution", "0.5" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.DynamicFriction", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.StaticFriction", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.SimulationFilterData", "0 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.MaxMotionDistance", "0.06" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.RestOffset", "0.004" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.ContactOffset", "0.008" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.GridSize", "0.96" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.ProjectionPlane", "0 0 1 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.ParticleReadDataFlags", "ePOSITION_BUFFER|eFLAGS_BUFFER" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleSystem.ParticleBaseFlags", "eCOLLISION_WITH_DYNAMIC_ACTORS|eENABLED|ePER_PARTICLE_REST_OFFSET|ePER_PARTICLE_COLLISION_CACHE_HINT")
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.ActorFlags", "eVISUALIZATION" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.DominanceGroup", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.OwnerClient", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.Damping", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.ExternalAcceleration", "0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.ParticleMass", "0.001" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.Restitution", "0.5" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.DynamicFriction", "0.05" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.StaticFriction", "0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.SimulationFilterData", "0 0 0 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.MaxMotionDistance", "0.06" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.RestOffset", "0.004" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.ContactOffset", "0.008" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.GridSize", "0.64" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.ProjectionPlane", "0 0 1 0" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.Stiffness", "20" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.Viscosity", "6" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.RestParticleDistance", "0.02" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.ParticleReadDataFlags", "ePOSITION_BUFFER|eFLAGS_BUFFER" )
+	DEFINE_REPX_DEFAULT_PROPERTY("PxParticleFluid.ParticleBaseFlags", "eCOLLISION_WITH_DYNAMIC_ACTORS|eENABLED|ePER_PARTICLE_REST_OFFSET|ePER_PARTICLE_COLLISION_CACHE_HINT")
+	DEFINE_REPX_DEFAULT_PROPERTY("PxAggregate.SelfCollision", "false" )
+	DEFINE_REPX_DEFAULT_PROPERTY("THEEND", "false" )
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXCollection.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXCollection.h
new file mode 100644
index 00000000..b479754d
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXCollection.h
@@ -0,0 +1,173 @@
+// 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_REPXCOLLECTION_H
+#define PX_REPXCOLLECTION_H
+
+#include "common/PxTolerancesScale.h"
+#include "PxRepXSerializer.h"
+
+namespace physx { namespace Sn {
+	
+	struct	XmlNode;
+	
+	struct RepXCollectionItem
+	{
+		PxRepXObject		liveObject;
+		XmlNode*			descriptor;
+		RepXCollectionItem( PxRepXObject inItem = PxRepXObject(), XmlNode* inDescriptor = NULL )
+			: liveObject( inItem )
+			, descriptor( inDescriptor )
+		{
+		}
+	};
+
+	struct RepXDefaultEntry
+	{
+		const char* name;
+		const char* value;
+		RepXDefaultEntry( const char* pn, const char* val ) : name( pn ), value( val ){}
+	};
+
+	/**
+	*	The result of adding an object to the collection.
+	*/
+	struct RepXAddToCollectionResult
+	{
+		enum Enum
+		{
+			Success,
+			SerializerNotFound,
+			InvalidParameters, //Null data passed in.
+			AlreadyInCollection
+		};
+
+		PxSerialObjectId	collectionId;
+		Enum				result;
+
+		RepXAddToCollectionResult( Enum inResult = Success, const PxSerialObjectId inId = 0 )
+			: collectionId( inId )
+			, result( inResult )
+		{
+		}
+		bool isValid() { return result == Success && collectionId != 0; }
+	};
+	/**
+	*	A RepX collection contains a set of static data objects that can be transformed
+	*	into live objects.  It uses RepX serializer to do two transformations:
+	*	live object <-> collection object (descriptor)
+	*	collection object <-> file system.
+	*
+	*	A live object is considered to be something live in the physics
+	*	world such as a material or a rigidstatic.
+	*
+	*	A collection object is a piece of data from which a live object
+	*	of identical characteristics can be created.  
+	*
+	*	Clients need to pass PxCollection so that objects can resolve
+	*	references.  In addition, objects must be added in an order such that
+	*	references can be resolved in the first place.  So objects must be added
+	*	to the collection *after* objects they are dependent upon.
+	*
+	*	When deserializing from a file, the collection will allocate char*'s that will
+	*	not be freed when the collection itself is freed.  The user must be responsible
+	*	for these character allocations.
+	*/
+	class RepXCollection 
+	{
+	protected:
+		virtual ~RepXCollection(){}
+
+	public:
+		virtual void destroy() = 0;
+
+		/**
+		*	Set the scale on this collection.  The scale is saved with the collection.
+		*
+		*	If the scale wasn't set, it will be invalid.
+		*/
+		virtual void  setTolerancesScale( const PxTolerancesScale& inScale ) = 0;
+
+		/**
+		*	Get the scale that was set at collection creation time or at load time.
+		*	If this is a loaded file and the source data does not contain a scale
+		*	this value will be invalid (PxTolerancesScale::isValid()).
+		*/
+		virtual PxTolerancesScale getTolerancesScale() const = 0;
+
+		/**
+		*	Set the up vector on this collection.  The up vector is saved with the collection.
+		*
+		*	If the up vector wasn't set, it will be (0,0,0).
+		*/
+		virtual void  setUpVector( const PxVec3& inUpVector ) = 0;
+
+		/**
+		* If the up vector wasn't set, it will be (0,0,0).  Else this will be the up vector
+		* optionally set when the collection was created.
+		*/
+		virtual PxVec3	getUpVector() const = 0;
+
+		virtual const char* getVersion() = 0;
+		static const char* getLatestVersion();
+
+		//Necessary accessor functions for translation/upgrading.
+		virtual const RepXCollectionItem* begin() const = 0;
+		virtual const RepXCollectionItem* end() const = 0;
+
+
+		//Performs a deep copy of the repx node.
+		virtual XmlNode* copyRepXNode( const XmlNode* srcNode ) = 0;
+
+		virtual void addCollectionItem( RepXCollectionItem inItem ) = 0;
+
+		//Create a new repx node with this name.  Its value is unset.
+		virtual XmlNode& createRepXNode( const char* name ) = 0;
+
+		virtual RepXCollection& createCollection( const char* inVersionStr ) = 0;
+		//Release this when finished.
+		virtual XmlReaderWriter& createNodeEditor() = 0;
+
+		virtual PxAllocatorCallback& getAllocator() = 0;
+
+		virtual bool instantiateCollection( PxRepXInstantiationArgs& inArgs, PxCollection& inPxCollection ) = 0;
+
+		
+		virtual RepXAddToCollectionResult addRepXObjectToCollection( const PxRepXObject& inObject, PxCollection* inCollection, PxRepXInstantiationArgs& inArgs ) = 0;
+
+		/**
+		 *	Save this collection out to a file stream.  Uses the RepX serialize to perform 
+		 *	collection object->file conversions.
+		 *
+		 *	/param[in] inStream Write-only stream to save collection out to.
+		 */
+		virtual void save( PxOutputStream& inStream ) = 0;
+	};
+} }
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXCoreSerializer.cpp b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXCoreSerializer.cpp
new file mode 100644
index 00000000..104e521c
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXCoreSerializer.cpp
@@ -0,0 +1,1158 @@
+// 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.  
+
+#include "PxPhysicsAPI.h"
+#include "PxMetaDataObjects.h"
+#include "CmIO.h"
+#include "SnPxStreamOperators.h"
+#include "PsUtilities.h"
+#include "SnXmlImpl.h"			
+#include "SnXmlSerializer.h"		
+#include "SnXmlDeserializer.h"		
+#include "SnRepXCoreSerializer.h"
+
+using namespace physx::Sn;
+namespace physx { 
+	typedef PxProfileHashMap< const PxSerialObjectId, const PxArticulationLink* > TArticulationLinkLinkMap;
+	typedef PxReadOnlyPropertyInfo<PxPropertyInfoName::PxArticulationLink_InboundJoint, PxArticulationLink, PxArticulationJoint *> TIncomingJointPropType;
+		
+	//*************************************************************
+	//	Actual RepXSerializer implementations for PxMaterial
+	//*************************************************************
+	PxMaterial* PxMaterialRepXSerializer::allocateObject( PxRepXInstantiationArgs& inArgs )
+	{
+		return inArgs.physics.createMaterial(0, 0, 0);
+	}
+
+	PxRepXObject PxShapeRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
+	{
+		PxProfileAllocatorWrapper wrapper( inAllocator.getAllocator() );
+		TReaderNameStack names( wrapper );
+		PxProfileArray<PxU32> contexts( wrapper );
+		bool hadError = false;
+		RepXVisitorReader<PxShape> theVisitor( names, contexts, inArgs, inReader, NULL, inAllocator, *inCollection, hadError );
+
+		Ps::Array<PxMaterial*> materials;
+		PxGeometry* geometry = NULL; 
+		parseShape( theVisitor, geometry, materials );
+		if(hadError)
+			return PxRepXObject();
+		PxShape *theShape = inArgs.physics.createShape( *geometry, materials.begin(), Ps::to16(materials.size()) );
+
+		switch(geometry->getType())
+		{
+		case PxGeometryType::eSPHERE :
+			static_cast<PxSphereGeometry*>(geometry)->~PxSphereGeometry();
+			break;
+		case PxGeometryType::ePLANE :
+			static_cast<PxPlaneGeometry*>(geometry)->~PxPlaneGeometry();
+			break;
+		case PxGeometryType::eCAPSULE :
+			static_cast<PxCapsuleGeometry*>(geometry)->~PxCapsuleGeometry();
+			break;
+		case PxGeometryType::eBOX :
+			static_cast<PxBoxGeometry*>(geometry)->~PxBoxGeometry();
+			break;
+		case PxGeometryType::eCONVEXMESH :
+			static_cast<PxConvexMeshGeometry*>(geometry)->~PxConvexMeshGeometry();
+			break;
+		case PxGeometryType::eTRIANGLEMESH :
+			static_cast<PxTriangleMeshGeometry*>(geometry)->~PxTriangleMeshGeometry();
+			break;
+		case PxGeometryType::eHEIGHTFIELD :
+			static_cast<PxHeightFieldGeometry*>(geometry)->~PxHeightFieldGeometry();
+			break;
+
+		case PxGeometryType::eGEOMETRY_COUNT:
+		case PxGeometryType::eINVALID:
+			PX_ASSERT(0);			
+		}		
+		inAllocator.getAllocator().deallocate(geometry);
+
+		bool ret = readAllProperties( inArgs, inReader, theShape, inAllocator, *inCollection );
+
+		return ret ? PxCreateRepXObject(theShape) : PxRepXObject();
+	}
+
+	//*************************************************************
+	//	Actual RepXSerializer implementations for PxTriangleMesh
+	//*************************************************************
+
+	template<typename TTriIndexElem>
+	inline void writeTriangle( MemoryBuffer& inTempBuffer, const Triangle<TTriIndexElem>& inTriangle )
+	{
+		inTempBuffer << inTriangle.mIdx0 
+			<< " " << inTriangle.mIdx1
+			<< " " << inTriangle.mIdx2;
+	}
+
+	PxU32 materialAccess( const PxTriangleMesh* inMesh, PxU32 inIndex ) { return inMesh->getTriangleMaterialIndex( inIndex ); }
+	template<typename TDataType>
+	void writeDatatype( MemoryBuffer& inTempBuffer, const TDataType& inType ) { inTempBuffer << inType; }
+
+	void PxBVH33TriangleMeshRepXSerializer::objectToFileImpl( const PxBVH33TriangleMesh* mesh, PxCollection* /*inCollection*/, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& inArgs )
+	{
+		bool hasMatIndex = mesh->getTriangleMaterialIndex(0) != 0xffff;
+		PxU32 numVertices = mesh->getNbVertices();
+		const PxVec3* vertices = mesh->getVertices();
+		writeBuffer( inWriter, inTempBuffer, 2, vertices, numVertices, "Points", writePxVec3 );
+		bool isU16 = mesh->getTriangleMeshFlags() & PxTriangleMeshFlag::e16_BIT_INDICES ? true : false;
+		PxU32 triCount = mesh->getNbTriangles();
+		const void* indices = mesh->getTriangles();
+		if ( isU16 )
+			writeBuffer( inWriter, inTempBuffer, 2, reinterpret_cast<const Triangle<PxU16>* >( indices ), triCount, "Triangles", writeTriangle<PxU16> );
+		else
+			writeBuffer( inWriter, inTempBuffer, 2, reinterpret_cast<const Triangle<PxU32>* >( indices ), triCount, "Triangles", writeTriangle<PxU32> );
+		if ( hasMatIndex )
+			writeBuffer( inWriter, inTempBuffer, 6, mesh, materialAccess, triCount, "materialIndices", writeDatatype<PxU32> );
+
+		//Cooked stream			
+		PxTriangleMeshDesc meshDesc;
+		meshDesc.points.count = numVertices;
+		meshDesc.points.data = vertices;
+		meshDesc.points.stride = sizeof(PxVec3);
+		meshDesc.triangles.count = triCount;
+		meshDesc.triangles.data = indices;
+		meshDesc.triangles.stride = isU16?3*sizeof(PxU16):3*sizeof(PxU32);
+
+		if(isU16)
+		{
+			meshDesc.triangles.stride = sizeof(PxU16)*3;
+			meshDesc.flags |= PxMeshFlag::e16_BIT_INDICES;
+		}
+		else
+		{
+			meshDesc.triangles.stride = sizeof(PxU32)*3;
+		}
+
+		if(hasMatIndex)
+		{
+			PxMaterialTableIndex* materialIndices = new PxMaterialTableIndex[triCount];
+			for(PxU32 i = 0; i < triCount; i++)
+				materialIndices[i] = mesh->getTriangleMaterialIndex(i);
+
+			meshDesc.materialIndices.data = materialIndices;
+			meshDesc.materialIndices.stride = sizeof(PxMaterialTableIndex);
+
+		}
+
+		if(inArgs.cooker != NULL)
+		{
+			TMemoryPoolManager theManager(mAllocator);
+			MemoryBuffer theTempBuf( &theManager );
+			theTempBuf.clear();
+			inArgs.cooker->cookTriangleMesh( meshDesc, theTempBuf );
+
+			writeBuffer( inWriter, inTempBuffer, 16, theTempBuf.mBuffer, theTempBuf.mWriteOffset, "CookedData", writeDatatype<PxU8> );
+		}
+
+		delete []meshDesc.materialIndices.data;
+	}
+
+	PxRepXObject PxBVH33TriangleMeshRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* /*inCollection*/ )
+	{
+		//We can't do a simple inverse; we *have* to cook data to get a mesh.
+		PxTriangleMeshDesc theDesc;
+		readStridedBufferProperty<PxVec3>( inReader, "points", theDesc.points, inAllocator);
+		readStridedBufferProperty<Triangle<PxU32> >( inReader, "triangles", theDesc.triangles, inAllocator);
+		PxU32 triCount;
+		readStridedBufferProperty<PxMaterialTableIndex>( inReader, "materialIndices", theDesc.materialIndices, triCount, inAllocator);
+		PxStridedData cookedData;
+		cookedData.stride = sizeof(PxU8);
+		PxU32 dataSize;
+		readStridedBufferProperty<PxU8>( inReader, "CookedData", cookedData, dataSize, inAllocator);
+
+		TMemoryPoolManager theManager(inAllocator.getAllocator());	
+		MemoryBuffer theTempBuf( &theManager );
+
+//		PxTriangleMesh* theMesh = NULL;			
+		PxBVH33TriangleMesh* theMesh = NULL;			
+
+		if(dataSize != 0)
+		{				
+			theTempBuf.write(cookedData.data, dataSize*sizeof(PxU8));
+//			theMesh = inArgs.physics.createTriangleMesh( theTempBuf );
+			theMesh = static_cast<PxBVH33TriangleMesh*>(inArgs.physics.createTriangleMesh( theTempBuf ));
+		}
+
+		if(theMesh == NULL)
+		{
+			PX_ASSERT(inArgs.cooker);
+			theTempBuf.clear();
+
+			{
+				PxCookingParams params = inArgs.cooker->getParams();
+				params.midphaseDesc = PxMeshMidPhase::eBVH33;
+				inArgs.cooker->setParams(params);
+			}
+
+			inArgs.cooker->cookTriangleMesh( theDesc, theTempBuf );
+//			theMesh = inArgs.physics.createTriangleMesh( theTempBuf );
+			theMesh = static_cast<PxBVH33TriangleMesh*>(inArgs.physics.createTriangleMesh( theTempBuf ));
+		}					
+
+		return PxCreateRepXObject( theMesh );
+	}
+
+	void PxBVH34TriangleMeshRepXSerializer::objectToFileImpl( const PxBVH34TriangleMesh* mesh, PxCollection* /*inCollection*/, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& inArgs )
+	{
+		bool hasMatIndex = mesh->getTriangleMaterialIndex(0) != 0xffff;
+		PxU32 numVertices = mesh->getNbVertices();
+		const PxVec3* vertices = mesh->getVertices();
+		writeBuffer( inWriter, inTempBuffer, 2, vertices, numVertices, "Points", writePxVec3 );
+		bool isU16 = mesh->getTriangleMeshFlags() & PxTriangleMeshFlag::e16_BIT_INDICES ? true : false;
+		PxU32 triCount = mesh->getNbTriangles();
+		const void* indices = mesh->getTriangles();
+		if ( isU16 )
+			writeBuffer( inWriter, inTempBuffer, 2, reinterpret_cast<const Triangle<PxU16>* >( indices ), triCount, "Triangles", writeTriangle<PxU16> );
+		else
+			writeBuffer( inWriter, inTempBuffer, 2, reinterpret_cast<const Triangle<PxU32>* >( indices ), triCount, "Triangles", writeTriangle<PxU32> );
+		if ( hasMatIndex )
+			writeBuffer( inWriter, inTempBuffer, 6, mesh, materialAccess, triCount, "materialIndices", writeDatatype<PxU32> );
+
+		//Cooked stream			
+		PxTriangleMeshDesc meshDesc;
+		meshDesc.points.count = numVertices;
+		meshDesc.points.data = vertices;
+		meshDesc.points.stride = sizeof(PxVec3);
+		meshDesc.triangles.count = triCount;
+		meshDesc.triangles.data = indices;
+		meshDesc.triangles.stride = isU16?3*sizeof(PxU16):3*sizeof(PxU32);
+
+		if(isU16)
+		{
+			meshDesc.triangles.stride = sizeof(PxU16)*3;
+			meshDesc.flags |= PxMeshFlag::e16_BIT_INDICES;
+		}
+		else
+		{
+			meshDesc.triangles.stride = sizeof(PxU32)*3;
+		}
+
+		if(hasMatIndex)
+		{
+			PxMaterialTableIndex* materialIndices = new PxMaterialTableIndex[triCount];
+			for(PxU32 i = 0; i < triCount; i++)
+				materialIndices[i] = mesh->getTriangleMaterialIndex(i);
+
+			meshDesc.materialIndices.data = materialIndices;
+			meshDesc.materialIndices.stride = sizeof(PxMaterialTableIndex);
+
+		}
+
+		if(inArgs.cooker != NULL)
+		{
+			TMemoryPoolManager theManager(mAllocator);
+			MemoryBuffer theTempBuf( &theManager );
+			theTempBuf.clear();
+			inArgs.cooker->cookTriangleMesh( meshDesc, theTempBuf );
+
+			writeBuffer( inWriter, inTempBuffer, 16, theTempBuf.mBuffer, theTempBuf.mWriteOffset, "CookedData", writeDatatype<PxU8> );
+		}
+
+		delete []meshDesc.materialIndices.data;
+	}
+
+	PxRepXObject PxBVH34TriangleMeshRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* /*inCollection*/ )
+	{
+		//We can't do a simple inverse; we *have* to cook data to get a mesh.
+		PxTriangleMeshDesc theDesc;
+		readStridedBufferProperty<PxVec3>( inReader, "points", theDesc.points, inAllocator);
+		readStridedBufferProperty<Triangle<PxU32> >( inReader, "triangles", theDesc.triangles, inAllocator);
+		PxU32 triCount;
+		readStridedBufferProperty<PxMaterialTableIndex>( inReader, "materialIndices", theDesc.materialIndices, triCount, inAllocator);
+		PxStridedData cookedData;
+		cookedData.stride = sizeof(PxU8);
+		PxU32 dataSize;
+		readStridedBufferProperty<PxU8>( inReader, "CookedData", cookedData, dataSize, inAllocator);
+
+		TMemoryPoolManager theManager(inAllocator.getAllocator());	
+		MemoryBuffer theTempBuf( &theManager );
+
+//		PxTriangleMesh* theMesh = NULL;			
+		PxBVH34TriangleMesh* theMesh = NULL;			
+
+		if(dataSize != 0)
+		{				
+			theTempBuf.write(cookedData.data, dataSize*sizeof(PxU8));
+//			theMesh = inArgs.physics.createTriangleMesh( theTempBuf );
+			theMesh = static_cast<PxBVH34TriangleMesh*>(inArgs.physics.createTriangleMesh( theTempBuf ));
+		}
+
+		if(theMesh == NULL)
+		{
+			PX_ASSERT(inArgs.cooker);
+			theTempBuf.clear();
+
+			{
+				PxCookingParams params = inArgs.cooker->getParams();
+				params.midphaseDesc = PxMeshMidPhase::eBVH34;
+				inArgs.cooker->setParams(params);
+			}
+
+			inArgs.cooker->cookTriangleMesh( theDesc, theTempBuf );
+//			theMesh = inArgs.physics.createTriangleMesh( theTempBuf );
+			theMesh = static_cast<PxBVH34TriangleMesh*>(inArgs.physics.createTriangleMesh( theTempBuf ));
+		}					
+
+		return PxCreateRepXObject(theMesh);
+	}
+
+
+	//*************************************************************
+	//	Actual RepXSerializer implementations for PxHeightField
+	//*************************************************************
+	void PxHeightFieldRepXSerializer::objectToFileImpl( const PxHeightField* inHeightField, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& /*inArgs*/)
+	{
+		PxHeightFieldDesc theDesc;
+
+		theDesc.nbRows					= inHeightField->getNbRows();
+		theDesc.nbColumns				= inHeightField->getNbColumns();
+		theDesc.format					= inHeightField->getFormat();
+		theDesc.samples.stride			= inHeightField->getSampleStride();
+		theDesc.samples.data			= NULL;
+		theDesc.thickness				= inHeightField->getThickness();
+		theDesc.convexEdgeThreshold		= inHeightField->getConvexEdgeThreshold();
+		theDesc.flags					= inHeightField->getFlags();
+
+		PxU32 theCellCount = inHeightField->getNbRows() * inHeightField->getNbColumns();
+		PxU32 theSampleStride = sizeof( PxHeightFieldSample );
+		PxU32 theSampleBufSize = theCellCount * theSampleStride;
+		PxHeightFieldSample* theSamples = reinterpret_cast< PxHeightFieldSample*> ( inTempBuffer.mManager->allocate( theSampleBufSize ) );
+		inHeightField->saveCells( theSamples, theSampleBufSize );
+		theDesc.samples.data = theSamples;
+		writeAllProperties( &theDesc, inWriter, inTempBuffer, *inCollection );
+		writeStridedBufferProperty<PxHeightFieldSample>( inWriter, inTempBuffer, "samples", theDesc.samples, theDesc.nbRows * theDesc.nbColumns, 6, writeHeightFieldSample);
+		inTempBuffer.mManager->deallocate( reinterpret_cast<PxU8*>(theSamples) );
+	}
+
+	PxRepXObject PxHeightFieldRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
+	{
+		PX_ASSERT(inArgs.cooker);
+		PxHeightFieldDesc theDesc;
+		readAllProperties( inArgs, inReader, &theDesc, inAllocator, *inCollection );
+		//Now read the data...
+		PxU32 count = 0; //ignored becaues numRows and numColumns tells the story
+		readStridedBufferProperty<PxHeightFieldSample>( inReader, "samples", theDesc.samples, count, inAllocator);
+		PxHeightField* retval = inArgs.cooker->createHeightField( theDesc, inArgs.physics.getPhysicsInsertionCallback() );
+		return PxCreateRepXObject(retval);
+	}
+
+	//*************************************************************
+	//	Actual RepXSerializer implementations for PxConvexMesh
+	//*************************************************************
+	void PxConvexMeshRepXSerializer::objectToFileImpl( const PxConvexMesh* mesh, PxCollection* /*inCollection*/, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& inArgs )
+	{
+		writeBuffer( inWriter, inTempBuffer, 2, mesh->getVertices(), mesh->getNbVertices(), "points", writePxVec3 );
+
+		if(inArgs.cooker != NULL)
+		{
+			//Cache cooked Data
+			PxConvexMeshDesc theDesc;
+			theDesc.points.data = mesh->getVertices();
+			theDesc.points.stride = sizeof(PxVec3);
+			theDesc.points.count = mesh->getNbVertices();
+
+			theDesc.flags = PxConvexFlag::eCOMPUTE_CONVEX;
+			TMemoryPoolManager theManager(mAllocator);
+			MemoryBuffer theTempBuf( &theManager );
+			inArgs.cooker->cookConvexMesh( theDesc, theTempBuf );
+
+			writeBuffer( inWriter, inTempBuffer, 16, theTempBuf.mBuffer, theTempBuf.mWriteOffset, "CookedData", writeDatatype<PxU8> );
+		}
+
+	}
+
+	//Conversion from scene object to descriptor.
+	PxRepXObject PxConvexMeshRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* /*inCollection*/)
+	{
+		PxConvexMeshDesc theDesc;
+		readStridedBufferProperty<PxVec3>( inReader, "points", theDesc.points, inAllocator);
+		theDesc.flags = PxConvexFlag::eCOMPUTE_CONVEX;
+
+		PxStridedData cookedData;
+		cookedData.stride = sizeof(PxU8);
+		PxU32 dataSize;
+		readStridedBufferProperty<PxU8>( inReader, "CookedData", cookedData, dataSize, inAllocator);
+
+		TMemoryPoolManager theManager(inAllocator.getAllocator());
+		MemoryBuffer theTempBuf( &theManager );
+
+		PxConvexMesh* theMesh = NULL;
+
+		if(dataSize != 0)
+		{
+			theTempBuf.write(cookedData.data, dataSize*sizeof(PxU8));
+			theMesh = inArgs.physics.createConvexMesh( theTempBuf );
+		}
+
+		if(theMesh == NULL)
+		{
+			PX_ASSERT(inArgs.cooker);
+			theTempBuf.clear();
+
+			inArgs.cooker->cookConvexMesh( theDesc, theTempBuf );
+			theMesh = inArgs.physics.createConvexMesh( theTempBuf );
+		}					
+
+		return PxCreateRepXObject(theMesh);
+	}
+
+	//*************************************************************
+	//	Actual RepXSerializer implementations for PxRigidStatic
+	//*************************************************************
+	PxRigidStatic* PxRigidStaticRepXSerializer::allocateObject( PxRepXInstantiationArgs& inArgs )
+	{
+		return inArgs.physics.createRigidStatic( PxTransform(PxIdentity) );
+	}
+
+	//*************************************************************
+	//	Actual RepXSerializer implementations for PxRigidDynamic
+	//*************************************************************
+	PxRigidDynamic* PxRigidDynamicRepXSerializer::allocateObject( PxRepXInstantiationArgs& inArgs )
+	{
+		return inArgs.physics.createRigidDynamic( PxTransform(PxIdentity) );
+	}
+
+	//*************************************************************
+	//	Actual RepXSerializer implementations for PxArticulation
+	//*************************************************************
+	void PxArticulationRepXSerializer::objectToFileImpl( const PxArticulation* inObj, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& /*inArgs*/)
+	{
+		TNameStack nameStack( inTempBuffer.mManager->mWrapper );
+		Sn::TArticulationLinkLinkMap linkMap( inTempBuffer.mManager->mWrapper );
+		RepXVisitorWriter<PxArticulation> writer( nameStack, inWriter, inObj, inTempBuffer, *inCollection, &linkMap );
+		RepXPropertyFilter<RepXVisitorWriter<PxArticulation> > theOp( writer );
+		visitAllProperties<PxArticulation>( theOp );
+	}
+	PxArticulation* PxArticulationRepXSerializer::allocateObject( PxRepXInstantiationArgs& inArgs ) { return inArgs.physics.createArticulation(); }
+
+	//*************************************************************
+	//	Actual RepXSerializer implementations for PxAggregate
+	//*************************************************************
+	void PxAggregateRepXSerializer::objectToFileImpl( const PxAggregate* data, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& /*inArgs*/)
+	{
+		PxArticulationLink *link = NULL;
+		inWriter.addAndGotoChild( "Actors" );
+		for(PxU32 i = 0; i < data->getNbActors(); ++i)
+		{
+			PxActor* actor;
+
+			if(data->getActors(&actor, 1, i))
+			{
+				link = actor->is<PxArticulationLink>();
+			}
+
+			if(link && !link->getInboundJoint() )
+			{
+				writeProperty( inWriter, *inCollection, inTempBuffer, "PxArticulationRef",  &link->getArticulation());			
+			}
+			else if( !link )
+			{
+				PxSerialObjectId theId = 0;
+
+				theId = inCollection->getId( *actor );
+				if( theId == 0 )
+					theId = PX_PROFILE_POINTER_TO_U64( actor );
+
+				writeProperty( inWriter, *inCollection, inTempBuffer, "PxActorRef", theId );			
+			}
+		}
+
+		inWriter.leaveChild( );
+
+		writeProperty( inWriter, *inCollection, inTempBuffer, "NumActors", data->getNbActors() );
+		writeProperty( inWriter, *inCollection, inTempBuffer, "MaxNbActors", data->getMaxNbActors() );
+		writeProperty( inWriter, *inCollection, inTempBuffer, "SelfCollision", data->getSelfCollision() );
+
+		writeAllProperties( data, inWriter, inTempBuffer, *inCollection );
+	}
+
+	PxRepXObject PxAggregateRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
+	{
+		PxU32 numActors;
+		readProperty( inReader, "NumActors", numActors );
+		PxU32 maxNbActors;
+		readProperty( inReader, "MaxNbActors", maxNbActors );
+		
+		bool selfCollision;
+		bool ret = readProperty( inReader, "SelfCollision", selfCollision );
+
+		PxAggregate* theAggregate = inArgs.physics.createAggregate(maxNbActors, selfCollision);
+		ret &= readAllProperties( inArgs, inReader, theAggregate, inAllocator, *inCollection );
+
+		inReader.pushCurrentContext();
+		if ( inReader.gotoChild( "Actors" ) )
+		{
+			inReader.pushCurrentContext();
+			for( bool matSuccess = inReader.gotoFirstChild(); matSuccess;
+				matSuccess = inReader.gotoNextSibling() )
+			{
+				const char* actorType = inReader.getCurrentItemName();
+				if ( 0 == physx::shdfnd::stricmp( actorType, "PxActorRef" ) ) 
+				{
+					PxActor *actor = NULL;
+					ret &= readReference<PxActor>( inReader, *inCollection, actor );
+
+					if(actor)
+					{
+						PxScene *currScene = actor->getScene();
+						if(currScene)
+						{
+							currScene->removeActor(*actor);
+						}
+						theAggregate->addActor(*actor);
+					}
+				}
+				else if ( 0 == physx::shdfnd::stricmp( actorType, "PxArticulationRef" ) ) 
+				{
+					PxArticulation* articulation = NULL;
+					ret &= readReference<PxArticulation>( inReader, *inCollection, articulation );
+					if(articulation)
+					{
+						PxScene *currScene = articulation->getScene();
+						if(currScene)
+						{
+							currScene->removeArticulation(*articulation);
+						}
+						theAggregate->addArticulation(*articulation);
+					}
+				}	
+			}
+			inReader.popCurrentContext();
+			inReader.leaveChild();
+		}
+		inReader.popCurrentContext();
+
+		return ret ? PxCreateRepXObject(theAggregate) : PxRepXObject();
+	}
+
+	//*************************************************************
+	//	Actual RepXSerializer implementations for PxClothFabric
+	//*************************************************************
+#if PX_USE_CLOTH_API
+
+	void writeFabricPhase( PxOutputStream& stream, const PxClothFabricPhase& phase )
+	{
+		const PxU32ToName* conv = PxEnumTraits<PxClothFabricPhaseType::Enum>().NameConversion;
+		for ( ; conv->mName != NULL; ++conv )
+			if ( conv->mValue == PxU32(phase.phaseType) ) 
+				stream << conv->mName;
+		stream << " " << phase.setIndex;
+	}
+
+	namespace Sn {
+		template<> struct StrToImpl<PxClothFabricPhase> 
+		{
+			void strto( PxClothFabricPhase& datatype, const char*& ioData )
+			{
+				char buffer[512];
+				eatwhite( ioData );
+				nullTerminateWhite(ioData, buffer, 512 );
+
+				const PxU32ToName* conv = PxEnumTraits<PxClothFabricPhaseType::Enum>().NameConversion;
+				for ( ; conv->mName != NULL; ++conv )
+					if ( 0 == physx::shdfnd::stricmp( buffer, conv->mName ) )
+						datatype = static_cast<PxClothFabricPhaseType::Enum>( conv->mValue );
+
+				StrToImpl<PxU32>().strto( datatype.setIndex, ioData );
+			}
+		};
+	}
+
+	void PxClothFabricRepXSerializer::objectToFileImpl( const PxClothFabric* data, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& /*inArgs*/)
+	{
+
+		PxProfileAllocatorWrapper& wrapper( inTempBuffer.mManager->getWrapper() );
+		PxU32 numParticles = data->getNbParticles();
+		PxU32 numPhases = data->getNbPhases();
+		PxU32 numRestvalues = data->getNbRestvalues();
+		PxU32 numSets = data->getNbSets();
+		PxU32 numIndices = data->getNbParticleIndices();
+		PxU32 numTethers = data->getNbTethers();
+
+		PxProfileArray<PxU8> dataBuffer( wrapper );
+		PxU32 numInts = PxMax(PxMax(numIndices, numRestvalues), numTethers);
+		dataBuffer.resize( PxU32(PxMax( PxMax( numInts * sizeof(PxU32), numTethers * sizeof(PxReal) ), 
+			numPhases * sizeof(PxClothFabricPhase)) ) );
+
+		PxClothFabricPhase* phasePtr( reinterpret_cast<PxClothFabricPhase*>( dataBuffer.begin() ) );
+		PxU32* indexPtr( reinterpret_cast<PxU32*>( dataBuffer.begin() ) );
+
+		writeProperty( inWriter, *inCollection, inTempBuffer, "NbParticles", numParticles );
+
+		data->getPhases( phasePtr, numPhases );
+		writeBuffer( inWriter, inTempBuffer, 18, phasePtr, PtrAccess<PxClothFabricPhase>, numPhases, "Phases", writeFabricPhase );
+
+		PX_COMPILE_TIME_ASSERT( sizeof( PxReal ) == sizeof( PxU32 ) );
+		PxReal* realPtr = reinterpret_cast< PxReal* >( indexPtr );
+		data->getRestvalues( realPtr, numRestvalues );
+		writeBuffer( inWriter, inTempBuffer, 18, realPtr, PtrAccess<PxReal>, numRestvalues, "Restvalues", BasicDatatypeWrite<PxReal> );
+
+		data->getSets( indexPtr, numSets );
+		writeBuffer( inWriter, inTempBuffer, 18, indexPtr, PtrAccess<PxU32>, numSets, "Sets", BasicDatatypeWrite<PxU32> );
+
+		data->getParticleIndices( indexPtr, numIndices );
+		writeBuffer( inWriter, inTempBuffer, 18, indexPtr, PtrAccess<PxU32>, numIndices, "ParticleIndices", BasicDatatypeWrite<PxU32> );
+
+		data->getTetherAnchors( indexPtr, numTethers );
+		writeBuffer( inWriter, inTempBuffer, 18, indexPtr, PtrAccess<PxU32>, numTethers, "TetherAnchors", BasicDatatypeWrite<PxU32> );
+
+		data->getTetherLengths( realPtr, numTethers );
+		writeBuffer( inWriter, inTempBuffer, 18, realPtr, PtrAccess<PxReal>, numTethers, "TetherLengths", BasicDatatypeWrite<PxReal> );
+	}
+
+	//Conversion from scene object to descriptor.
+	PxRepXObject PxClothFabricRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* /*inCollection*/)
+	{
+		PxU32 strideIgnored = 0;
+
+		PxClothFabricDesc desc;	
+
+		readProperty( inReader, "NbParticles", desc.nbParticles );
+
+		readStridedBufferProperty<PxClothFabricPhase>( inReader, "Phases", const_cast<PxClothFabricPhase*&>(desc.phases), strideIgnored, desc.nbPhases, inAllocator );
+
+		PxU32 numRestvalues = 0;
+		readStridedBufferProperty<PxF32>( inReader, "Restvalues", const_cast<PxF32*&>(desc.restvalues), strideIgnored, numRestvalues, inAllocator );
+
+		readStridedBufferProperty<PxU32>( inReader, "Sets", const_cast<PxU32*&>(desc.sets), strideIgnored, desc.nbSets, inAllocator );
+
+		PxU32 numIndices = 0;
+		readStridedBufferProperty<PxU32>( inReader, "ParticleIndices", const_cast<PxU32*&>(desc.indices), strideIgnored, numIndices, inAllocator );
+
+		readStridedBufferProperty<PxU32>( inReader, "TetherAnchors", const_cast<PxU32*&>(desc.tetherAnchors), strideIgnored, desc.nbTethers, inAllocator );
+		readStridedBufferProperty<PxF32>( inReader, "TetherLengths", const_cast<PxF32*&>(desc.tetherLengths), strideIgnored, desc.nbTethers, inAllocator );
+
+		PxClothFabric* newFabric = inArgs.physics.createClothFabric( desc );
+
+		PX_ASSERT( newFabric );
+		return PxCreateRepXObject(newFabric);
+	}
+
+	//*************************************************************
+	//	Actual RepXSerializer implementations for PxCloth
+	//*************************************************************
+	void clothParticleWriter( PxOutputStream& stream, const PxClothParticle& particle )
+	{
+		stream << particle.pos << " " << particle.invWeight;
+	}
+
+	namespace Sn {
+		template<> struct StrToImpl<PxClothParticle> 
+		{
+			void strto( PxClothParticle& datatype, const char*& ioData )
+			{
+				StrToImpl<PxF32>().strto( datatype.pos[0], ioData );
+				StrToImpl<PxF32>().strto( datatype.pos[1], ioData );
+				StrToImpl<PxF32>().strto( datatype.pos[2], ioData );
+				StrToImpl<PxF32>().strto( datatype.invWeight, ioData );
+			}
+		};
+
+		template<> struct StrToImpl<PxClothCollisionSphere> 
+		{
+			void strto( PxClothCollisionSphere& datatype, const char*& ioData )
+			{
+				StrToImpl<PxF32>().strto( datatype.pos[0], ioData );
+				StrToImpl<PxF32>().strto( datatype.pos[1], ioData );
+				StrToImpl<PxF32>().strto( datatype.pos[2], ioData );
+				StrToImpl<PxF32>().strto( datatype.radius, ioData );
+			}
+		};
+
+		template<> struct StrToImpl<PxClothCollisionPlane> 
+		{
+			void strto( PxClothCollisionPlane& datatype, const char*& ioData )
+			{
+				StrToImpl<PxF32>().strto( datatype.normal[0], ioData );
+				StrToImpl<PxF32>().strto( datatype.normal[1], ioData );
+				StrToImpl<PxF32>().strto( datatype.normal[2], ioData );
+				StrToImpl<PxF32>().strto( datatype.distance, ioData );
+			}
+		};
+
+		template<> struct StrToImpl<PxClothCollisionTriangle> 
+		{
+			void strto( PxClothCollisionTriangle& datatype, const char*& ioData )
+			{
+				StrToImpl<PxVec3>().strto( datatype.vertex0, ioData );
+				StrToImpl<PxVec3>().strto( datatype.vertex1, ioData );
+				StrToImpl<PxVec3>().strto( datatype.vertex2, ioData );
+			}
+		};
+
+		template<> struct StrToImpl<PxVec4> 
+		{
+			void strto( PxVec4& datatype, const char*& ioData )
+			{
+				StrToImpl<PxF32>().strto( datatype.x, ioData );
+				StrToImpl<PxF32>().strto( datatype.y, ioData );
+				StrToImpl<PxF32>().strto( datatype.z, ioData );
+				StrToImpl<PxF32>().strto( datatype.w, ioData );
+			}
+		};
+
+		template<> struct StrToImpl<PxClothParticleMotionConstraint> 
+		{
+			void strto( PxClothParticleMotionConstraint& datatype, const char*& ioData )
+			{
+				StrToImpl<PxVec3>().strto( datatype.pos, ioData );
+				StrToImpl<PxF32>().strto( datatype.radius, ioData );
+			}
+		};
+		
+		template<> struct StrToImpl<PxClothParticleSeparationConstraint> 
+		{
+			void strto( PxClothParticleSeparationConstraint& datatype, const char*& ioData )
+			{
+				StrToImpl<PxVec3>().strto( datatype.pos, ioData );
+				StrToImpl<PxF32>().strto( datatype.radius, ioData );
+			}
+		};
+		
+	}
+
+	void clothSphereWriter( PxOutputStream& stream, const PxClothCollisionSphere& sphere )
+	{
+		stream << sphere.pos << " " << sphere.radius;
+	}
+
+	void clothPlaneWriter( PxOutputStream& stream, const PxClothCollisionPlane& plane )
+	{
+		stream << plane.normal << " " << plane.distance;
+	}
+
+	void clothTriangleWriter( PxOutputStream& stream, const PxClothCollisionTriangle& triangle )
+	{
+		stream << triangle.vertex0 << " " << triangle.vertex1 << " " << triangle.vertex2;
+	}
+
+	void PxClothRepXSerializer::objectToFileImpl( const PxCloth* data, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& /*inArgs*/)
+	{
+		PxClothParticleData* readData( data->lockParticleData() );
+		writeBuffer( inWriter, inTempBuffer, 4, readData->particles, PtrAccess<PxClothParticle>, data->getNbParticles(), "Particles", clothParticleWriter );
+		readData->unlock();
+
+		writeReference( inWriter, *inCollection, "Fabric", data->getFabric() );
+
+		PxProfileArray<PxU8> dataBuffer( inTempBuffer.mManager->getWrapper() );
+
+		// collision data
+		const PxCloth& cloth = *data;
+		PxU32 numSpheres = cloth.getNbCollisionSpheres();
+		PxU32 numIndices = 2*cloth.getNbCollisionCapsules();
+		PxU32 numPlanes = cloth.getNbCollisionPlanes();
+		PxU32 numConvexes = cloth.getNbCollisionConvexes();
+		PxU32 numTriangles = cloth.getNbCollisionTriangles();
+
+		PxU32 sphereBytes = numSpheres * sizeof( PxClothCollisionSphere );
+		PxU32 pairBytes = numIndices * sizeof( PxU32 );
+		PxU32 planesBytes = numPlanes * sizeof(PxClothCollisionPlane);
+		PxU32 convexBytes = numConvexes * sizeof(PxU32);
+		PxU32 triangleBytes = numTriangles * sizeof(PxClothCollisionTriangle);
+
+		dataBuffer.resize( sphereBytes + pairBytes + planesBytes + convexBytes + triangleBytes);
+		PxClothCollisionSphere* spheresBuffer = reinterpret_cast<PxClothCollisionSphere*>( dataBuffer.begin() );
+		PxU32* indexBuffer = reinterpret_cast<PxU32*>(spheresBuffer + numSpheres);
+		PxClothCollisionPlane* planeBuffer = reinterpret_cast<PxClothCollisionPlane*>(indexBuffer + numIndices);
+		PxU32* convexBuffer = reinterpret_cast<PxU32*>(planeBuffer + numPlanes);
+		PxClothCollisionTriangle* trianglesBuffer = reinterpret_cast<PxClothCollisionTriangle*>(convexBuffer + numConvexes);
+
+		data->getCollisionData( spheresBuffer, indexBuffer, planeBuffer, convexBuffer, trianglesBuffer );
+		writeBuffer( inWriter, inTempBuffer, 4, spheresBuffer, PtrAccess<PxClothCollisionSphere>, numSpheres, "CollisionSpheres", clothSphereWriter );
+		writeBuffer( inWriter, inTempBuffer, 18, indexBuffer, PtrAccess<PxU32>, numIndices, "CollisionSpherePairs", BasicDatatypeWrite<PxU32> );
+		writeBuffer( inWriter, inTempBuffer, 4, planeBuffer, PtrAccess<PxClothCollisionPlane>, numPlanes, "CollisionPlanes", clothPlaneWriter );
+		writeBuffer( inWriter, inTempBuffer, 18, convexBuffer, PtrAccess<PxU32>, numConvexes, "CollisionConvexMasks", BasicDatatypeWrite<PxU32> );
+		writeBuffer( inWriter, inTempBuffer, 4, trianglesBuffer, PtrAccess<PxClothCollisionTriangle>, numTriangles, "CollisionTriangles", clothTriangleWriter );
+
+		// particle accelerations
+		PxU32 numParticleAccelerations = cloth.getNbParticleAccelerations();
+		PxU32 sizeParticleAccelerations = sizeof(PxVec4)*numParticleAccelerations;
+		if (dataBuffer.size() < sizeParticleAccelerations)
+			dataBuffer.resize(sizeof(PxClothParticle)*numParticleAccelerations);
+
+		PxVec4* particleAccelerations = reinterpret_cast<PxVec4*>(dataBuffer.begin());
+		cloth.getParticleAccelerations(particleAccelerations);
+		writeBuffer (inWriter, inTempBuffer, 4, reinterpret_cast<PxClothParticle*>(particleAccelerations), PtrAccess<PxClothParticle>, numParticleAccelerations, "ParticleAccelerations", clothParticleWriter );
+
+		//self collision indices
+		PxU32* particleCollisionIndices = reinterpret_cast<PxU32*>(dataBuffer.begin());
+		PxU32 numSelfCollisionIndices = cloth.getNbSelfCollisionIndices();
+		PxU32 sizeSelfCollisionIndices = sizeof(PxU32)*numSelfCollisionIndices;
+		if (dataBuffer.size() < sizeSelfCollisionIndices)
+			dataBuffer.resize(sizeSelfCollisionIndices);
+		data->getSelfCollisionIndices( particleCollisionIndices );
+		writeBuffer( inWriter, inTempBuffer, 18, particleCollisionIndices, PtrAccess<PxU32>, numSelfCollisionIndices, "SelfCollisionIndices", BasicDatatypeWrite<PxU32> );
+
+		// motion constraints
+		PxClothParticleMotionConstraint* motionConstraints = reinterpret_cast<PxClothParticleMotionConstraint*>(dataBuffer.begin());
+		PxU32 numMotionConstraints = cloth.getNbMotionConstraints();
+		PxU32 sizeMotionConstraints = sizeof(PxVec4)*numMotionConstraints;
+		if (dataBuffer.size() < sizeMotionConstraints)
+			dataBuffer.resize(sizeof(PxClothParticle)*numMotionConstraints);
+		data->getMotionConstraints( motionConstraints );
+		writeBuffer (inWriter, inTempBuffer, 4, reinterpret_cast<PxClothParticle*>(motionConstraints), PtrAccess<PxClothParticle>, numMotionConstraints, "MotionConstraints", clothParticleWriter );
+
+		// separation positions
+		PxU32 numSeparationConstraints= cloth.getNbSeparationConstraints();
+		PxU32 restSeparationConstraints = sizeof(PxVec4)*numSeparationConstraints;
+		if (dataBuffer.size() < restSeparationConstraints)
+			dataBuffer.resize(sizeof(PxClothParticle)*numSeparationConstraints);
+		PxClothParticleSeparationConstraint* separationConstraints = reinterpret_cast<PxClothParticleSeparationConstraint*>(dataBuffer.begin());
+		cloth.getSeparationConstraints(separationConstraints);
+		writeBuffer (inWriter, inTempBuffer, 4, reinterpret_cast<PxClothParticle*>(separationConstraints), PtrAccess<PxClothParticle>, numSeparationConstraints, "SeparationConstraints", clothParticleWriter );
+
+		// rest positions
+		PxU32 numRestPositions = cloth.getNbRestPositions();
+		PxU32 restPositionSize = sizeof(PxVec4)*numRestPositions;
+		if (dataBuffer.size() < restPositionSize)
+			dataBuffer.resize(sizeof(PxClothParticle)*numRestPositions);
+
+		PxVec4* restPositions = reinterpret_cast<PxVec4*>(dataBuffer.begin());
+		cloth.getRestPositions(restPositions);
+		writeBuffer (inWriter, inTempBuffer, 4, reinterpret_cast<PxClothParticle*>(restPositions), PtrAccess<PxClothParticle>, numRestPositions, "RestPositions", clothParticleWriter );
+
+		// virtual particles
+		PxU32 numVirtualParticles = data->getNbVirtualParticles();
+		PxU32 numWeightTableEntries = data->getNbVirtualParticleWeights();
+
+		PxU32 totalNeeded = static_cast<PxU32>( PxMax( numWeightTableEntries * sizeof( PxVec3 ), numVirtualParticles * 4  * sizeof( PxU32 ) ) );
+		if ( dataBuffer.size() < totalNeeded )
+			dataBuffer.resize( totalNeeded );
+
+		PxVec3* weightTableEntries = reinterpret_cast<PxVec3*>( dataBuffer.begin() );
+		data->getVirtualParticleWeights( weightTableEntries );
+		writeBuffer( inWriter, inTempBuffer, 6, weightTableEntries, PtrAccess<PxVec3>, numWeightTableEntries, "VirtualParticleWeights", BasicDatatypeWrite<PxVec3> );
+		PxU32* virtualParticles = reinterpret_cast<PxU32*>( dataBuffer.begin() );
+		data->getVirtualParticles( virtualParticles );
+		writeBuffer( inWriter, inTempBuffer, 18, virtualParticles, PtrAccess<PxU32>, numVirtualParticles * 4, "VirtualParticles", BasicDatatypeWrite<PxU32> );
+
+		// Now write the rest of the object data that the meta data generator got.
+		writeAllProperties( data, inWriter, inTempBuffer, *inCollection );
+	}
+
+	PxRepXObject PxClothRepXSerializer::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
+	{
+		PxU32 strideIgnored;
+		PxU32 numParticles;
+		PxClothParticle* particles = NULL;
+
+		PxU32 numSpheres;
+		PxClothCollisionSphere* spheres = NULL;
+		PxU32 numCapsules;
+		PxU32* capsules = NULL;
+		PxU32 numPlanes;
+		PxClothCollisionPlane* planes = NULL;
+		PxU32 numConvexMasks;
+		PxU32* convexMasks = NULL;
+		PxU32 numTriangles;
+		PxClothCollisionTriangle* triangles = NULL;
+
+		PxVec4* particleAccelerations = NULL;
+		PxU32 numParticleAccelerations = 0;
+		PxU32* selfCollisionIndices = NULL;
+		PxU32 numSelfCollisionIndices = 0;
+		PxClothParticleMotionConstraint* particleMotionConstraint = NULL;
+		PxU32 numParticleMotionConstraint = 0;
+		PxClothParticleSeparationConstraint* separationConstraints = NULL;
+		PxU32 numSeparationConstraints = 0;
+
+		PxVec4* restPositions = NULL;
+		PxU32 numRestPositions;
+		PxU32 numVirtualParticleWeights;
+		PxU32 numParticleIndices = 0;
+		PxVec3* virtualParticleWeights = NULL;
+		PxU32* virtualParticles = NULL;
+		PxClothFlags flags;
+		PxClothFabric* fabric = NULL;
+
+		readReference<PxClothFabric>( inReader, *inCollection, "Fabric", fabric );
+
+		if ( fabric == NULL )
+			return PxRepXObject();
+
+		readStridedBufferProperty<PxClothParticle>( inReader, "Particles", particles, strideIgnored, numParticles, inAllocator );
+
+		readStridedBufferProperty<PxClothCollisionSphere>( inReader, "CollisionSpheres", spheres, strideIgnored, numSpheres, inAllocator );
+		readStridedBufferProperty<PxU32>( inReader, "CollisionSpherePairs", capsules, strideIgnored, numCapsules, inAllocator );
+		readStridedBufferProperty<PxClothCollisionPlane>( inReader, "CollisionPlanes", planes, strideIgnored, numPlanes, inAllocator );
+		readStridedBufferProperty<PxU32>( inReader, "CollisionConvexMasks", convexMasks, strideIgnored, numConvexMasks, inAllocator );
+		readStridedBufferProperty<PxClothCollisionTriangle>( inReader, "CollisionTriangles", triangles, strideIgnored, numTriangles, inAllocator );
+
+		readFlagsProperty( inReader, inAllocator, "ClothFlags", PxEnumTraits<PxClothFlag::Enum>().NameConversion, flags );
+
+		readStridedBufferProperty<PxVec4>( inReader, "ParticleAccelerations", particleAccelerations, strideIgnored, numParticleAccelerations, inAllocator );
+		readStridedBufferProperty<PxU32>( inReader, "SelfCollisionIndices", selfCollisionIndices, strideIgnored, numSelfCollisionIndices, inAllocator );
+		readStridedBufferProperty<PxClothParticleMotionConstraint>( inReader, "MotionConstraints", particleMotionConstraint, strideIgnored, numParticleMotionConstraint, inAllocator );
+		readStridedBufferProperty<PxClothParticleSeparationConstraint>( inReader, "SeparationConstraints", separationConstraints, strideIgnored, numSeparationConstraints, inAllocator );
+		readStridedBufferProperty<PxVec4>( inReader, "RestPositions", restPositions, strideIgnored, numRestPositions, inAllocator );
+
+		readStridedBufferProperty<PxVec3>( inReader, "VirtualParticleWeights", virtualParticleWeights, strideIgnored, numVirtualParticleWeights, inAllocator );
+		readStridedBufferProperty<PxU32>( inReader, "VirtualParticles", virtualParticles, strideIgnored, numParticleIndices, inAllocator );
+
+		PxTransform initialPose( PxIdentity );
+		PxCloth* cloth = inArgs.physics.createCloth( initialPose, *fabric, reinterpret_cast<PxClothParticle*>( particles ), flags );
+		bool ret = readAllProperties( inArgs, inReader, cloth, inAllocator, *inCollection );
+
+		if( numSelfCollisionIndices )
+		{
+			cloth->setSelfCollisionIndices( selfCollisionIndices, numSelfCollisionIndices );
+		}
+		if( numParticleMotionConstraint )
+		{
+			cloth->setMotionConstraints( particleMotionConstraint );
+		}
+		if( numSeparationConstraints )
+		{
+			cloth->setSeparationConstraints( separationConstraints );
+		}
+		if( numParticleAccelerations )
+		{
+			cloth->setParticleAccelerations(particleAccelerations);
+		}
+
+		cloth->setCollisionSpheres(spheres, numSpheres);
+		while(numCapsules > 0)
+		{
+			PxU32 first = *capsules++, second = *capsules++;
+			cloth->addCollisionCapsule(first, second);
+			numCapsules -= 2;
+		}
+
+		cloth->setCollisionPlanes(planes, numPlanes);
+		while(numConvexMasks-- > 0)
+		{
+			cloth->addCollisionConvex(*convexMasks++);
+		}
+
+		cloth->setCollisionTriangles(triangles, numTriangles);
+
+		if (numRestPositions)
+			cloth->setRestPositions(restPositions);
+
+		PxU32 numVirtualParticles = numParticleIndices /4;
+		if ( numVirtualParticles && numVirtualParticleWeights )
+		{
+			cloth->setVirtualParticles( numVirtualParticles, reinterpret_cast<PxU32*>( virtualParticles ), 
+				numVirtualParticleWeights, reinterpret_cast<PxVec3*>( virtualParticleWeights ) );
+		}
+
+		return ret ? PxCreateRepXObject(cloth) : PxRepXObject();
+	}
+#endif // PX_USE_CLOTH_API
+	
+#if PX_USE_PARTICLE_SYSTEM_API
+	template<typename TParticleType>
+	inline TParticleType* createParticles( PxPhysics& physics, PxU32 maxParticles, bool perParticleRestOffset )
+	{
+		PX_UNUSED(physics);
+		PX_UNUSED(maxParticles);
+		PX_UNUSED(perParticleRestOffset);
+		return NULL;
+	}
+
+	template<>
+	inline PxParticleSystem* createParticles<PxParticleSystem>(PxPhysics& physics, PxU32 maxParticles, bool perParticleRestOffset)
+	{
+		return physics.createParticleSystem( maxParticles, perParticleRestOffset );
+	}
+	
+	template<>
+	inline PxParticleFluid* createParticles<PxParticleFluid>(PxPhysics& physics, PxU32 maxParticles, bool perParticleRestOffset)
+	{
+		return physics.createParticleFluid( maxParticles, perParticleRestOffset );
+	}
+
+	//*************************************************************
+	//	Actual RepXSerializer implementations for PxParticleSystem & PxParticleFluid
+	//*************************************************************
+	template<typename TParticleType>
+	void PxParticleRepXSerializer<TParticleType>::objectToFileImpl( const TParticleType* data, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& /*inArgs*/)
+	{
+		PxParticleReadData* readData( const_cast<TParticleType*>( data )->lockParticleReadData() );
+		writeProperty( inWriter, *inCollection, inTempBuffer, "NbParticles",			readData->nbValidParticles );
+		writeProperty( inWriter, *inCollection, inTempBuffer, "ValidParticleRange",	readData->validParticleRange );
+		PxParticleReadDataFlags readFlags(data->getParticleReadDataFlags());
+
+		if(readData->validParticleRange > 0)
+		{
+			writeBuffer( inWriter, inTempBuffer, 8 , readData->validParticleBitmap, PtrAccess<PxU32>, ((readData->validParticleRange-1) >> 5) + 1 ,"ValidParticleBitmap",	BasicDatatypeWrite<PxU32> );
+
+			writeStridedBufferProperty<PxVec3>( inWriter, inTempBuffer, "Positions", readData->positionBuffer, readData->nbValidParticles, 6, writePxVec3);
+
+			if(readFlags & PxParticleReadDataFlag::eVELOCITY_BUFFER)
+			{
+				writeStridedBufferProperty<PxVec3>( inWriter, inTempBuffer, "Velocities", readData->velocityBuffer, readData->nbValidParticles, 6, writePxVec3);
+			}
+			if(readFlags & PxParticleReadDataFlag::eREST_OFFSET_BUFFER)
+			{
+				writeStridedBufferProperty<PxF32>( inWriter, inTempBuffer, "RestOffsets", readData->restOffsetBuffer, readData->nbValidParticles, 6, BasicDatatypeWrite<PxF32>);
+			}
+			if(readFlags & PxParticleReadDataFlag::eFLAGS_BUFFER)
+			{
+				writeStridedFlagsProperty<PxParticleFlags>( inWriter, inTempBuffer, "Flags", readData->flagsBuffer, readData->nbValidParticles, 6, PxEnumTraits<PxParticleFlag::Enum>().NameConversion);
+			}
+		}
+		readData->unlock();
+
+		writeProperty( inWriter, *inCollection, inTempBuffer, "MaxParticles", data->getMaxParticles() );	
+
+		PxParticleBaseFlags baseFlags(data->getParticleBaseFlags());
+		writeFlagsProperty( inWriter, inTempBuffer, "ParticleBaseFlags", baseFlags, PxEnumTraits<PxParticleBaseFlag::Enum>().NameConversion );	
+
+		writeFlagsProperty( inWriter, inTempBuffer, "ParticleReadDataFlags", readFlags, PxEnumTraits<PxParticleReadDataFlag::Enum>().NameConversion );	
+
+		PxVec3	normal;
+		PxReal	distance;
+		data->getProjectionPlane(normal, distance);
+		PxMetaDataPlane plane(normal, distance);
+		writeProperty( inWriter, *inCollection, inTempBuffer, "ProjectionPlane",			plane);		
+
+		writeAllProperties( data, inWriter, inTempBuffer, *inCollection );
+	}	
+
+	template<typename TParticleType>
+	PxRepXObject PxParticleRepXSerializer<TParticleType>::fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
+	{
+		PxU32 strideIgnored = 0;
+		PxU32 numParticles = 0;
+		readProperty( inReader, "NbParticles", numParticles );
+
+		PxU32 validParticleRange = 0;
+		readProperty( inReader, "ValidParticleRange", validParticleRange );
+
+		PxU32 numWrite;
+		PxU32* tempValidParticleBitmap = NULL;
+		readStridedBufferProperty<PxU32>( inReader, "ValidParticleBitmap", tempValidParticleBitmap, strideIgnored, numWrite, inAllocator );
+		PxU32 *validParticleBitmap = reinterpret_cast<PxU32*>( tempValidParticleBitmap );
+
+		PxVec3* tempPosBuf = NULL;
+		readStridedBufferProperty<PxVec3>( inReader, "Positions", tempPosBuf, strideIgnored, numWrite, inAllocator );
+		PxStrideIterator<const PxVec3> posBuffer(reinterpret_cast<const PxVec3*> (tempPosBuf));
+
+		PxVec3* tempVelBuf = NULL;
+		readStridedBufferProperty<PxVec3>( inReader, "Velocities", tempVelBuf, strideIgnored, numWrite, inAllocator );
+		PxStrideIterator<const PxVec3> velBuffer(reinterpret_cast<const PxVec3*> (tempVelBuf));
+
+		PxF32* tempRestBuf = NULL;
+		readStridedBufferProperty<PxF32>( inReader, "RestOffsets", tempRestBuf, strideIgnored, numWrite, inAllocator );
+		PxStrideIterator<const PxF32> restBuffer(reinterpret_cast<const PxF32*> (tempRestBuf));
+
+		PxU32* tempFlagBuf = NULL;
+		readStridedFlagsProperty<PxU32>( inReader, "Flags", tempFlagBuf, strideIgnored, numWrite, inAllocator , PxEnumTraits<PxParticleFlag::Enum>().NameConversion);
+		PxStrideIterator<const PxU32> flagBuffer(reinterpret_cast<const PxU32*> (tempFlagBuf));
+
+		Ps::Array<PxU32>	validIndexBuf;
+		Ps::Array<PxVec3>	validPosBuf, validVelBuf;
+		Ps::Array<PxF32>	validRestBuf;
+		Ps::Array<PxU32>	validFlagBuf;
+
+		bool perParticleRestOffset = !!tempRestBuf;
+		bool bVelBuff = !!tempVelBuf;
+		bool bFlagBuff = !!tempFlagBuf;
+
+		if (validParticleRange > 0)
+		{
+			for (PxU32 w = 0; w <= (validParticleRange-1) >> 5; w++)
+			{
+				for (PxU32 b = validParticleBitmap[w]; b; b &= b-1)
+				{
+					PxU32	index = (w<<5|physx::shdfnd::lowestSetBit(b));
+					validIndexBuf.pushBack(index);
+					validPosBuf.pushBack(posBuffer[index]);
+					if(bVelBuff)
+						validVelBuf.pushBack(velBuffer[index]);
+					if(perParticleRestOffset)
+						validRestBuf.pushBack(restBuffer[index]);
+					if(bFlagBuff)
+						validFlagBuf.pushBack(flagBuffer[index]);
+				}			
+			} 
+
+			PX_ASSERT(validIndexBuf.size() == numParticles);
+
+			PxU32 maxParticleNum;
+			bool ret = readProperty( inReader, "MaxParticles", maxParticleNum );
+			TParticleType* theParticle( createParticles<TParticleType>( inArgs.physics, maxParticleNum, perParticleRestOffset ) );
+			PX_ASSERT( theParticle );
+			ret &= readAllProperties( inArgs, inReader, theParticle, inAllocator, *inCollection );
+
+			PxParticleBaseFlags baseFlags;
+			ret &= readFlagsProperty( inReader, inAllocator, "ParticleBaseFlags", PxEnumTraits<PxParticleBaseFlag::Enum>().NameConversion, baseFlags );
+
+			PxU32 flagData = 1;
+			for(PxU32 i = 0; i < 16; i++)
+			{		
+				flagData = PxU32(1 << i);
+				if( !(flagData & PxParticleBaseFlag::ePER_PARTICLE_REST_OFFSET) && (!!(PxU32(baseFlags)  & flagData)) )
+				{
+					theParticle->setParticleBaseFlag(PxParticleBaseFlag::Enum(flagData), true);
+				}					
+			}
+
+			PxParticleReadDataFlags readFlags;
+			ret &= readFlagsProperty( inReader, inAllocator, "ParticleReadDataFlags", PxEnumTraits<PxParticleReadDataFlag::Enum>().NameConversion, readFlags );
+			for(PxU32 i = 0; i < 16; i++)
+			{
+				flagData = PxU32(1 << i);
+				if( !!(PxU32(readFlags)  & flagData) )
+				{
+					theParticle->setParticleReadDataFlag(PxParticleReadDataFlag::Enum(flagData), true);
+				}					
+			}
+
+			PxParticleCreationData creationData;
+			creationData.numParticles = numParticles;
+			creationData.indexBuffer = PxStrideIterator<const PxU32>(validIndexBuf.begin());
+			creationData.positionBuffer = PxStrideIterator<const PxVec3>(validPosBuf.begin());
+			if(bVelBuff)
+				creationData.velocityBuffer = PxStrideIterator<const PxVec3>(validVelBuf.begin());
+			if(perParticleRestOffset)
+				creationData.restOffsetBuffer = PxStrideIterator<const PxF32>(validRestBuf.begin());
+			if(bFlagBuff)
+				creationData.flagBuffer = PxStrideIterator<const PxU32>(validFlagBuf.begin());
+
+			theParticle->createParticles(creationData);	
+
+			return ret ? PxCreateRepXObject(theParticle) : PxRepXObject();
+		}
+		else
+		{
+			Ps::getFoundation().error(PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__, 
+				"PxSerialization::createCollectionFromXml: PxParticleRepXSerializer: "
+				"Xml field \"ValidParticleRange\" is zero!");
+			return PxRepXObject();
+		}
+	}
+	// explicit instantiations
+	template struct PxParticleRepXSerializer<PxParticleSystem>;
+	template struct PxParticleRepXSerializer<PxParticleFluid>;	
+#endif // #if PX_USE_PARTICLE_SYSTEM_API
+}
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXCoreSerializer.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXCoreSerializer.h
new file mode 100644
index 00000000..edd61210
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXCoreSerializer.h
@@ -0,0 +1,156 @@
+// 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 SN_REPX_CORE_SERIALIZER_H
+#define SN_REPX_CORE_SERIALIZER_H
+/** \addtogroup RepXSerializers
+  @{
+*/
+#include "foundation/PxSimpleTypes.h"
+#include "SnRepXSerializerImpl.h"
+
+#if !PX_DOXYGEN
+namespace physx
+{
+#endif
+
+	template<typename TLiveType>
+	struct RepXSerializerImpl;
+	
+	class XmlReader;
+	class XmlMemoryAllocator;
+	class XmlWriter;
+	class MemoryBuffer;
+				
+	struct PxMaterialRepXSerializer : RepXSerializerImpl<PxMaterial>
+	{
+		PxMaterialRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxMaterial>( inCallback ) {}
+		virtual PxMaterial* allocateObject( PxRepXInstantiationArgs& );
+	};
+
+	struct PxShapeRepXSerializer : public RepXSerializerImpl<PxShape>
+	{
+		PxShapeRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxShape>( inCallback ) {}
+		virtual PxRepXObject fileToObject( XmlReader&, XmlMemoryAllocator&, PxRepXInstantiationArgs&, PxCollection* );
+		virtual PxShape* allocateObject( PxRepXInstantiationArgs& ) { return NULL; }
+	};
+	
+	struct PxBVH33TriangleMeshRepXSerializer  : public RepXSerializerImpl<PxBVH33TriangleMesh>
+	{
+		PxBVH33TriangleMeshRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxBVH33TriangleMesh>( inCallback ) {}
+		virtual void objectToFileImpl( const PxBVH33TriangleMesh*, PxCollection*, XmlWriter&, MemoryBuffer&, PxRepXInstantiationArgs& );
+		virtual PxRepXObject fileToObject( XmlReader&, XmlMemoryAllocator&, PxRepXInstantiationArgs&, PxCollection* );
+		virtual PxBVH33TriangleMesh* allocateObject( PxRepXInstantiationArgs&  ) { return NULL; }
+	};
+	struct PxBVH34TriangleMeshRepXSerializer  : public RepXSerializerImpl<PxBVH34TriangleMesh>
+	{
+		PxBVH34TriangleMeshRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxBVH34TriangleMesh>( inCallback ) {}
+		virtual void objectToFileImpl( const PxBVH34TriangleMesh*, PxCollection*, XmlWriter&, MemoryBuffer&, PxRepXInstantiationArgs& );
+		virtual PxRepXObject fileToObject( XmlReader&, XmlMemoryAllocator&, PxRepXInstantiationArgs&, PxCollection* );
+		virtual PxBVH34TriangleMesh* allocateObject( PxRepXInstantiationArgs&  ) { return NULL; }
+	};
+
+	struct PxHeightFieldRepXSerializer : public RepXSerializerImpl<PxHeightField>
+	{
+		PxHeightFieldRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxHeightField>( inCallback ) {}
+		virtual void objectToFileImpl( const PxHeightField*, PxCollection*, XmlWriter&, MemoryBuffer&, PxRepXInstantiationArgs& );
+		virtual PxRepXObject fileToObject( XmlReader&, XmlMemoryAllocator&, PxRepXInstantiationArgs&, PxCollection* );
+		virtual PxHeightField* allocateObject( PxRepXInstantiationArgs& ) { return NULL; }
+	};
+	
+	struct PxConvexMeshRepXSerializer  : public RepXSerializerImpl<PxConvexMesh>
+	{
+		PxConvexMeshRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxConvexMesh>( inCallback ) {}
+		virtual void objectToFileImpl( const PxConvexMesh*, PxCollection*, XmlWriter&, MemoryBuffer&, PxRepXInstantiationArgs& );
+		virtual PxRepXObject fileToObject( XmlReader&, XmlMemoryAllocator&, PxRepXInstantiationArgs&, PxCollection* );
+		virtual PxConvexMesh* allocateObject( PxRepXInstantiationArgs& ) { return NULL; }
+	};
+
+	struct PxRigidStaticRepXSerializer : public RepXSerializerImpl<PxRigidStatic>
+	{
+		PxRigidStaticRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxRigidStatic>( inCallback ) {}
+		virtual PxRigidStatic* allocateObject( PxRepXInstantiationArgs& );
+	};
+
+	struct PxRigidDynamicRepXSerializer : public RepXSerializerImpl<PxRigidDynamic>
+	{
+		PxRigidDynamicRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxRigidDynamic>( inCallback ) {}
+		virtual PxRigidDynamic* allocateObject( PxRepXInstantiationArgs& );
+	};
+	
+	struct PxArticulationRepXSerializer  : public RepXSerializerImpl<PxArticulation>
+	{
+		PxArticulationRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxArticulation>( inCallback ) {}
+		virtual void objectToFileImpl( const PxArticulation*, PxCollection*, XmlWriter&, MemoryBuffer&, PxRepXInstantiationArgs& );
+		virtual PxArticulation* allocateObject( PxRepXInstantiationArgs& );
+	};
+	
+	struct PxAggregateRepXSerializer :  public RepXSerializerImpl<PxAggregate>
+	{
+		PxAggregateRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxAggregate>( inCallback ) {}
+		virtual void objectToFileImpl( const PxAggregate*, PxCollection*, XmlWriter& , MemoryBuffer&, PxRepXInstantiationArgs& );
+		virtual PxRepXObject fileToObject( XmlReader&, XmlMemoryAllocator&, PxRepXInstantiationArgs&, PxCollection* );
+		virtual PxAggregate* allocateObject( PxRepXInstantiationArgs& ) { return NULL; }	
+	};
+
+#if PX_USE_CLOTH_API
+	struct PxClothFabricRepXSerializer : public RepXSerializerImpl<PxClothFabric>
+	{
+		PxClothFabricRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxClothFabric>( inCallback ) {}
+		virtual void objectToFileImpl( const PxClothFabric*, PxCollection*, XmlWriter&, MemoryBuffer&, PxRepXInstantiationArgs& );
+		virtual PxRepXObject fileToObject( XmlReader&, XmlMemoryAllocator&, PxRepXInstantiationArgs&, PxCollection* );
+		virtual PxClothFabric* allocateObject( PxRepXInstantiationArgs& ) { return NULL; }	
+	};
+
+	struct PxClothRepXSerializer : public RepXSerializerImpl<PxCloth>
+	{
+		PxClothRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<PxCloth>( inCallback ) {}
+		virtual void objectToFileImpl( const PxCloth*, PxCollection*, XmlWriter&, MemoryBuffer&, PxRepXInstantiationArgs& );
+		virtual PxRepXObject fileToObject( XmlReader&, XmlMemoryAllocator&, PxRepXInstantiationArgs&, PxCollection* );
+		virtual PxCloth* allocateObject( PxRepXInstantiationArgs& ) { return NULL; }	
+	};
+#endif
+	
+#if PX_USE_PARTICLE_SYSTEM_API
+	template<typename TParticleType>
+	struct PxParticleRepXSerializer : RepXSerializerImpl<TParticleType>
+	{
+		PxParticleRepXSerializer( PxAllocatorCallback& inCallback ) : RepXSerializerImpl<TParticleType>( inCallback ) {}
+		virtual void objectToFileImpl( const TParticleType*, PxCollection*, XmlWriter&, MemoryBuffer&, PxRepXInstantiationArgs& );
+		virtual PxRepXObject fileToObject( XmlReader&, XmlMemoryAllocator&, PxRepXInstantiationArgs&, PxCollection* );
+		virtual TParticleType* allocateObject( PxRepXInstantiationArgs& ) { return NULL; }	
+	};
+#endif
+
+#if !PX_DOXYGEN
+} // namespace physx
+#endif
+
+#endif
+/** @} */
+
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXSerializerImpl.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXSerializerImpl.h
new file mode 100644
index 00000000..08fe861a
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXSerializerImpl.h
@@ -0,0 +1,90 @@
+// 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_REPX_SERIALIZER_IMPL_H
+#define PX_REPX_SERIALIZER_IMPL_H
+
+#include "PsUserAllocated.h"
+#include "SnXmlVisitorWriter.h"
+#include "SnXmlVisitorReader.h"
+
+namespace physx { 
+	using namespace Sn;
+
+	/**
+	 *	The repx serializer impl takes the raw, untyped repx extension interface
+	 *	and implements the simpler functions plus does the reinterpret-casts required 
+	 *	for any object to implement the serializer safely.
+	 */
+	template<typename TLiveType>
+	struct RepXSerializerImpl : public PxRepXSerializer, shdfnd::UserAllocated
+	{
+	protected:
+		RepXSerializerImpl( const RepXSerializerImpl& inOther );
+		RepXSerializerImpl& operator=( const RepXSerializerImpl& inOther );
+
+	public:
+		PxAllocatorCallback& mAllocator;
+
+		RepXSerializerImpl( PxAllocatorCallback& inAllocator )
+			: mAllocator( inAllocator )
+		{
+		}
+				
+		virtual const char* getTypeName() { return PxTypeInfo<TLiveType>::name(); }
+		
+		virtual void objectToFile( const PxRepXObject& inLiveObject, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& inArgs )
+		{
+			const TLiveType* theObj = reinterpret_cast<const TLiveType*>( inLiveObject.serializable );
+			objectToFileImpl( theObj, inCollection, inWriter, inTempBuffer, inArgs );
+		}
+
+		virtual PxRepXObject fileToObject( XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
+		{
+			TLiveType* theObj( allocateObject( inArgs ) );
+			if ( theObj )
+				if(fileToObjectImpl( theObj, inReader, inAllocator, inArgs, inCollection ))
+					return PxCreateRepXObject(theObj);
+			return PxRepXObject();
+		}
+		
+		virtual void objectToFileImpl( const TLiveType* inObj, PxCollection* inCollection, XmlWriter& inWriter, MemoryBuffer& inTempBuffer, PxRepXInstantiationArgs& /*inArgs*/)
+		{
+			writeAllProperties( inObj, inWriter, inTempBuffer, *inCollection );
+		}
+
+		virtual bool fileToObjectImpl( TLiveType* inObj, XmlReader& inReader, XmlMemoryAllocator& inAllocator, PxRepXInstantiationArgs& inArgs, PxCollection* inCollection )
+		{
+			return readAllProperties( inArgs, inReader, inObj, inAllocator, *inCollection );
+		}
+
+		virtual TLiveType* allocateObject( PxRepXInstantiationArgs& inArgs ) = 0;
+	};
+}
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXUpgrader.cpp b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXUpgrader.cpp
new file mode 100644
index 00000000..5eb2f40e
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXUpgrader.cpp
@@ -0,0 +1,444 @@
+// 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. 
+
+#include "CmPhysXCommon.h"
+#include "SnXmlImpl.h" 
+#include "SnXmlReader.h"
+#include "SnXmlMemoryAllocator.h"
+#include "PsFoundation.h"
+#include "SnRepXCollection.h"
+#include "SnRepXUpgrader.h"
+
+using namespace physx::profile;
+
+namespace physx { namespace Sn {
+
+	#define DEFINE_REPX_DEFAULT_PROPERTY( name, val ) RepXDefaultEntry( name, val ),
+
+	static RepXDefaultEntry gRepX1_0Defaults[] = {
+	#include "SnRepX1_0Defaults.h"
+	};
+	static PxU32 gNumRepX1_0Default = sizeof( gRepX1_0Defaults ) / sizeof ( *gRepX1_0Defaults );
+
+	static RepXDefaultEntry gRepX3_1Defaults[] = {
+	#include "SnRepX3_1Defaults.h"
+	};
+	static PxU32 gNumRepX3_1Defaults = sizeof( gRepX3_1Defaults ) / sizeof ( *gRepX3_1Defaults );
+
+	static RepXDefaultEntry gRepX3_2Defaults[] = {
+	#include "SnRepX3_2Defaults.h"
+	};
+	static PxU32 gNumRepX3_2Defaults = sizeof( gRepX3_2Defaults ) / sizeof ( *gRepX3_2Defaults );
+	
+	inline const char* nextPeriod( const char* str )
+	{
+		for( ++str; str && *str && *str != '.'; ++str ); //empty loop intentional
+		return str;
+	}
+
+	inline bool safeStrEq(const char* lhs, const char* rhs)
+	{
+		if (lhs == rhs)
+			return true;
+		//If they aren't equal, and one of them is null,
+		//then they can't be equal.
+		//This is assuming that the null char* is not equal to
+		//the empty "" char*.
+		if (!lhs || !rhs)
+			return false;
+
+		return ::strcmp(lhs, rhs) == 0;
+	}
+	
+	typedef PxProfileHashMap<const char*, PxU32> TNameOffsetMap;
+	
+	void setMissingPropertiesToDefault( XmlNode* topNode, XmlReaderWriter& editor, const RepXDefaultEntry* defaults, PxU32 numDefaults, TNameOffsetMap& map )
+	{
+		for ( XmlNode* child = topNode->mFirstChild; child != NULL; child = child->mNextSibling )
+			setMissingPropertiesToDefault( child, editor, defaults, numDefaults, map );
+
+		const TNameOffsetMap::Entry* entry( map.find( topNode->mName ) );
+		if ( entry )
+		{
+			XmlReaderWriter& theReader( editor );
+			theReader.setNode( *topNode );
+			char nameBuffer[512] = {0};
+			size_t nameLen = strlen( topNode->mName );
+			//For each default property entry for this node type.
+			for ( const RepXDefaultEntry* item = defaults + entry->second; strncmp( item->name, topNode->mName, nameLen ) == 0; ++item )
+			{
+				bool childAdded = false;
+				const char* nameStart = item->name + nameLen;
+				++nameStart;
+				theReader.pushCurrentContext();
+				const char* str = nameStart;
+				while( *str )
+				{
+					 const char *period = nextPeriod( str );
+					 size_t len = size_t(PxMin( period - str, ptrdiff_t(1023) )); //can't be too careful these days.
+					 memcpy( nameBuffer, str, len );
+					 nameBuffer[len] = 0;
+					 if ( theReader.gotoChild( nameBuffer ) == false )
+					 {
+						 childAdded = true;
+						 theReader.addOrGotoChild( nameBuffer );
+					 }
+					 if (*period )
+						 str = period + 1;
+					 else
+						 str = period;
+				}
+				if ( childAdded )
+					theReader.setCurrentItemValue( item->value );
+				theReader.popCurrentContext();
+			}
+		}
+	}
+
+	
+	static void setMissingPropertiesToDefault( RepXCollection& collection, XmlReaderWriter& editor, const RepXDefaultEntry* defaults, PxU32 numDefaults )
+	{
+		PxProfileAllocatorWrapper wrapper( collection.getAllocator() );
+		//Release all strings at once, instead of piece by piece
+		XmlMemoryAllocatorImpl alloc( collection.getAllocator() );
+		//build a hashtable of the initial default value strings.
+		TNameOffsetMap nameOffsets( wrapper );
+		for ( PxU32 idx = 0; idx < numDefaults; ++idx )
+		{
+			const RepXDefaultEntry& item( defaults[idx] );
+			size_t nameLen = 0;
+			const char* periodPtr = nextPeriod (item.name);
+			for ( ; periodPtr && *periodPtr; ++periodPtr ) if( *periodPtr == '.' )	break;
+			if ( periodPtr == NULL || *periodPtr != '.' ) continue;
+			nameLen = size_t(periodPtr - item.name);
+			char* newMem = reinterpret_cast<char*>(alloc.allocate( PxU32(nameLen + 1) ));
+			memcpy( newMem, item.name, nameLen );
+			newMem[nameLen] = 0;
+		
+			if ( nameOffsets.find( newMem ) )
+				alloc.deallocate( reinterpret_cast<PxU8*>(newMem) );
+			else
+				nameOffsets.insert( newMem, idx );
+		}
+		//Run through each collection item, and recursively find it and its children
+		//If an object's name is in the hash map, check and add any properties that don't exist.
+		//else return.
+		for ( const RepXCollectionItem* item = collection.begin(), *end = collection.end(); item != end; ++ item )
+		{
+			RepXCollectionItem theItem( *item );
+			setMissingPropertiesToDefault( theItem.descriptor, editor, defaults, numDefaults, nameOffsets );
+		}
+	}
+
+	struct RecursiveTraversal
+	{
+		RecursiveTraversal(XmlReaderWriter& editor): mEditor(editor) {}
+		void traverse()
+		{
+			mEditor.pushCurrentContext();
+			updateNode();
+			for(bool exists = mEditor.gotoFirstChild(); exists; exists = mEditor.gotoNextSibling())
+				traverse();
+			mEditor.popCurrentContext();
+		}
+		virtual void updateNode() = 0;
+        virtual ~RecursiveTraversal() {}
+		XmlReaderWriter& mEditor;
+	protected:
+		RecursiveTraversal& operator=(const RecursiveTraversal&){return *this;}
+	};
+
+
+	RepXCollection& RepXUpgrader::upgrade10CollectionTo3_1Collection(RepXCollection& src)
+	{
+		XmlReaderWriter& editor( src.createNodeEditor() );
+		setMissingPropertiesToDefault(src, editor, gRepX1_0Defaults, gNumRepX1_0Default );
+
+		
+		RepXCollection* dest = &src.createCollection("3.1.1");
+		
+		for ( const RepXCollectionItem* item = src.begin(), *end = src.end(); item != end; ++ item )
+		{
+			//either src or dest could do the copy operation, it doesn't matter who does it.
+			RepXCollectionItem newItem( item->liveObject, src.copyRepXNode( item->descriptor ) );
+			editor.setNode( *const_cast<XmlNode*>( newItem.descriptor ) );
+			//Some old files have this name in their system.
+			editor.renameProperty( "MassSpaceInertia", "MassSpaceInertiaTensor" );
+			editor.renameProperty( "SleepEnergyThreshold", "SleepThreshold" );
+
+			if ( strstr( newItem.liveObject.typeName, "Joint" ) || strstr( newItem.liveObject.typeName, "joint" ) )
+			{
+				//Joints changed format a bit.  old joints looked like:
+				/*
+				<Actor0 >1627536</Actor0>
+				<Actor1 >1628368</Actor1>
+				<LocalPose0 >0 0 0 1 0.5 0.5 0.5</LocalPose0>
+				<LocalPose1 >0 0 0 1 0.3 0.3 0.3</LocalPose1>*/
+				//New joints look like:
+				/*
+				<Actors >
+					<actor0 >58320336</actor0>
+					<actor1 >56353568</actor1>
+				</Actors>
+				<LocalPose >
+					<eACTOR0 >0 0 0 1 0.5 0.5 0.5</eACTOR0>
+					<eACTOR1 >0 0 0 1 0.3 0.3 0.3</eACTOR1>
+				</LocalPose>
+				*/
+				const char* actor0, *actor1, *lp0, *lp1;
+				editor.readAndRemoveProperty( "Actor0", actor0 );
+				editor.readAndRemoveProperty( "Actor1", actor1 ); 
+				editor.readAndRemoveProperty( "LocalPose0", lp0 );
+				editor.readAndRemoveProperty( "LocalPose1", lp1 );
+
+				editor.addOrGotoChild( "Actors" );
+				editor.writePropertyIfNotEmpty( "actor0", actor0 );
+				editor.writePropertyIfNotEmpty( "actor1", actor1 );
+				editor.leaveChild();
+
+				editor.addOrGotoChild( "LocalPose" );
+				editor.writePropertyIfNotEmpty( "eACTOR0", lp0 );
+				editor.writePropertyIfNotEmpty( "eACTOR1", lp1 );
+				editor.leaveChild();
+			}
+
+
+
+			//now desc owns the new node.  Collections share a single allocation pool, however,
+			//which will get destroyed when all the collections referencing it are destroyed themselves.
+			//Data on nodes is shared between nodes, but the node structure itself is allocated.
+			dest->addCollectionItem( newItem );
+		}
+		editor.release();
+		src.destroy();
+		return *dest;
+	}
+	
+	RepXCollection& RepXUpgrader::upgrade3_1CollectionTo3_2Collection(RepXCollection& src)
+	{
+		XmlReaderWriter& editor( src.createNodeEditor() );
+		setMissingPropertiesToDefault(src, editor, gRepX3_1Defaults, gNumRepX3_1Defaults );
+
+		RepXCollection* dest = &src.createCollection("3.2.0");
+
+		for ( const RepXCollectionItem* item = src.begin(), *end = src.end(); item != end; ++ item )
+		{
+			//either src or dest could do the copy operation, it doesn't matter who does it.
+			RepXCollectionItem newItem( item->liveObject, src.copyRepXNode( item->descriptor ) );
+			editor.setNode( *const_cast<XmlNode*>( newItem.descriptor ) );
+			
+			if ( strstr( newItem.liveObject.typeName, "PxMaterial" ) )
+			{
+				editor.removeChild( "DynamicFrictionV" );
+				editor.removeChild( "StaticFrictionV" );
+				editor.removeChild( "dirOfAnisotropy" );	
+			}
+			//now desc owns the new node.  Collections share a single allocation pool, however,
+			//which will get destroyed when all the collections referencing it are destroyed themselves.
+			//Data on nodes is shared between nodes, but the node structure itself is allocated.
+			dest->addCollectionItem( newItem );
+		}
+		editor.release();
+		src.destroy();
+		return *dest;
+	}
+	
+	RepXCollection& RepXUpgrader::upgrade3_2CollectionTo3_3Collection(RepXCollection& src)
+	{
+		XmlReaderWriter& editor( src.createNodeEditor() );
+		setMissingPropertiesToDefault(src, editor, gRepX3_2Defaults, gNumRepX3_2Defaults );
+
+		RepXCollection* dest = &src.createCollection("3.3.0");
+
+		
+
+		struct RenameSpringToStiffness : public RecursiveTraversal
+		{
+			RenameSpringToStiffness(XmlReaderWriter& editor_): RecursiveTraversal(editor_) {}
+		
+			void updateNode()
+			{
+				mEditor.renameProperty("Spring", "Stiffness");
+				mEditor.renameProperty("TangentialSpring", "TangentialStiffness");
+			}
+		};
+
+
+		struct UpdateArticulationSwingLimit : public RecursiveTraversal
+		{
+			UpdateArticulationSwingLimit(XmlReaderWriter& editor_): RecursiveTraversal(editor_) {}
+		
+			void updateNode()
+			{
+				if(!Ps::stricmp(mEditor.getCurrentItemName(), "yLimit") && !Ps::stricmp(mEditor.getCurrentItemValue(), "0"))
+					mEditor.setCurrentItemValue("0.785398");
+
+				if(!Ps::stricmp(mEditor.getCurrentItemName(), "zLimit") && !Ps::stricmp(mEditor.getCurrentItemValue(), "0"))
+					mEditor.setCurrentItemValue("0.785398");
+
+				if(!Ps::stricmp(mEditor.getCurrentItemName(), "TwistLimit"))
+				{
+					mEditor.gotoFirstChild();
+					PxReal lower = PxReal(strtod(mEditor.getCurrentItemValue(), NULL));
+					mEditor.gotoNextSibling();
+					PxReal upper = PxReal(strtod(mEditor.getCurrentItemValue(), NULL));
+					mEditor.leaveChild();
+					if(lower>=upper)
+					{
+						mEditor.writePropertyIfNotEmpty("lower", "-0.785398");
+						mEditor.writePropertyIfNotEmpty("upper", "0.785398");
+					}
+				}
+			}
+		};
+
+
+		for ( const RepXCollectionItem* item = src.begin(), *end = src.end(); item != end; ++ item )
+		{
+			//either src or dest could do the copy operation, it doesn't matter who does it.
+			RepXCollectionItem newItem( item->liveObject, src.copyRepXNode( item->descriptor ) );	
+
+
+			if ( strstr( newItem.liveObject.typeName, "PxCloth" ) || strstr( newItem.liveObject.typeName, "PxClothFabric" ) )
+			{  
+				physx::shdfnd::getFoundation().error(PxErrorCode::eDEBUG_WARNING, __FILE__, __LINE__, "Didn't suppot PxCloth upgrate from 3.2 to 3.3! ");
+				continue;
+			}
+
+			if ( strstr( newItem.liveObject.typeName, "PxParticleSystem" ) || strstr( newItem.liveObject.typeName, "PxParticleFluid" ) )
+			{
+				editor.setNode( *const_cast<XmlNode*>( newItem.descriptor ) );
+				editor.renameProperty( "PositionBuffer", "Positions" );
+				editor.renameProperty( "VelocityBuffer", "Velocities" );
+				editor.renameProperty( "RestOffsetBuffer", "RestOffsets" );
+			}
+
+			if(strstr(newItem.liveObject.typeName, "PxPrismaticJoint" ) 
+			|| strstr(newItem.liveObject.typeName, "PxRevoluteJoint")
+			|| strstr(newItem.liveObject.typeName, "PxSphericalJoint")
+			|| strstr(newItem.liveObject.typeName, "PxD6Joint")
+			|| strstr(newItem.liveObject.typeName, "PxArticulation"))
+			{
+				editor.setNode( *const_cast<XmlNode*>( newItem.descriptor ) );
+				RenameSpringToStiffness(editor).traverse();
+			}
+
+			if(strstr(newItem.liveObject.typeName, "PxArticulation"))
+			{
+				editor.setNode( *const_cast<XmlNode*>( newItem.descriptor ) );
+				UpdateArticulationSwingLimit(editor).traverse();
+			}
+
+
+
+			//now dest owns the new node.  Collections share a single allocation pool, however,
+			//which will get destroyed when all the collections referencing it are destroyed themselves.
+			//Data on nodes is shared between nodes, but the node structure itself is allocated.
+			
+			dest->addCollectionItem( newItem );
+			
+		}
+		editor.release();
+		src.destroy();
+		
+		return *dest;
+	}
+
+	RepXCollection& RepXUpgrader::upgrade3_3CollectionTo3_4Collection(RepXCollection& src)
+	{
+		RepXCollection* dest = &src.createCollection("3.4.0");
+
+		for ( const RepXCollectionItem* item = src.begin(), *end = src.end(); item != end; ++ item )
+		{
+			if(strstr(item->liveObject.typeName, "PxTriangleMesh"))
+			{
+				PxRepXObject newMeshRepXObj("PxBVH33TriangleMesh", item->liveObject.serializable, item->liveObject.id);                      
+				XmlNode* newMeshNode = src.copyRepXNode( item->descriptor );
+				newMeshNode->mName = "PxBVH33TriangleMesh";
+				RepXCollectionItem newMeshItem(newMeshRepXObj, newMeshNode);
+				dest->addCollectionItem( newMeshItem );
+				continue;
+			}
+
+			RepXCollectionItem newItem( item->liveObject, src.copyRepXNode( item->descriptor ) );	
+			dest->addCollectionItem( newItem );
+		}
+		src.destroy();		
+		return *dest;
+	}
+
+	RepXCollection& RepXUpgrader::upgradeCollection(RepXCollection& src)
+	{
+		const char* srcVersion = src.getVersion();
+		if( safeStrEq( srcVersion, RepXCollection::getLatestVersion() ))
+           return src;		
+
+		static const char* oldVersions[] = {"1.0",
+											"3.1",
+											"3.1.1",
+											"3.2.0",
+											"3.3.0",
+											"3.3.1",	
+											"3.3.2"
+		};//should be increase order
+		
+		PxU32 grade = UINT16_MAX;
+		const PxU32 count = sizeof(oldVersions)/sizeof(oldVersions[0]);
+		for (PxU32 i=0; i<count; i++)
+	    {
+			if( safeStrEq( srcVersion, oldVersions[i] ))
+			{
+				grade = i;
+				break;
+			}
+		}
+
+		typedef RepXCollection& (*UPGRADE_FUNCTION)(RepXCollection& src);
+
+		UPGRADE_FUNCTION procs[count] = 
+		{
+			upgrade10CollectionTo3_1Collection,
+			NULL,
+			upgrade3_1CollectionTo3_2Collection,
+			upgrade3_2CollectionTo3_3Collection,
+			NULL,
+			NULL,
+			upgrade3_3CollectionTo3_4Collection,
+		};
+
+		RepXCollection* dest = &src;
+		for( PxU32 j = grade; j < count; j++ )
+		{
+			if( procs[j] )
+				dest = &(procs[j])(*dest);
+		}
+
+		return *dest;
+	}
+} }
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXUpgrader.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXUpgrader.h
new file mode 100644
index 00000000..9baf270c
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnRepXUpgrader.h
@@ -0,0 +1,53 @@
+// 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_REPX_UPGRADER_H
+#define PX_REPX_UPGRADER_H
+
+#include "foundation/PxSimpleTypes.h"
+
+namespace physx { namespace Sn {
+	class RepXCollection;
+
+	class RepXUpgrader
+	{
+	public:
+		//If a new collection is created, the source collection is destroyed.
+		//Thus you only need to release the new collection.
+		//This holds for all of the upgrade functions.
+		//So be aware, that the argument to these functions may not be valid
+		//after they are called, but the return value always will be valid.
+		static RepXCollection& upgradeCollection( RepXCollection& src );
+		static RepXCollection& upgrade10CollectionTo3_1Collection( RepXCollection& src );
+		static RepXCollection& upgrade3_1CollectionTo3_2Collection( RepXCollection& src );
+		static RepXCollection& upgrade3_2CollectionTo3_3Collection( RepXCollection& src );
+		static RepXCollection& upgrade3_3CollectionTo3_4Collection( RepXCollection& src );
+	};
+} }
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnSimpleXmlWriter.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnSimpleXmlWriter.h
new file mode 100644
index 00000000..6f63fefc
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnSimpleXmlWriter.h
@@ -0,0 +1,257 @@
+// 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_SIMPLEXMLWRITER_H
+#define PX_SIMPLEXMLWRITER_H
+
+#include "PsArray.h"
+#include "SnXmlMemoryPoolStreams.h"
+#include "CmPhysXCommon.h"
+
+namespace physx { namespace Sn {
+	class SimpleXmlWriter
+	{
+	public:
+		
+		struct STagWatcher
+		{
+			typedef SimpleXmlWriter TXmlWriterType;
+			TXmlWriterType& mWriter;
+			STagWatcher( const STagWatcher& inOther );
+			STagWatcher& operator-( const STagWatcher& inOther );
+			STagWatcher( TXmlWriterType& inWriter, const char* inTagName )
+				: mWriter( inWriter )
+			{
+				mWriter.beginTag( inTagName );
+			}
+			~STagWatcher() { mWriter.endTag(); }
+		protected:
+			STagWatcher& operator=(const STagWatcher&);
+		};
+
+		virtual ~SimpleXmlWriter(){}
+		virtual void beginTag( const char* inTagname ) = 0;
+		virtual void endTag() = 0;
+		virtual void addAttribute( const char* inName, const char* inValue ) = 0;
+		virtual void writeContentTag( const char* inTag, const char* inContent ) = 0;
+		virtual void addContent( const char* inContent ) = 0;
+		virtual PxU32 tabCount() = 0;
+	private:
+		SimpleXmlWriter& operator=(const SimpleXmlWriter&);
+	};
+
+	template<typename TStreamType>
+	class SimpleXmlWriterImpl : public SimpleXmlWriter
+	{
+		PxProfileAllocatorWrapper mWrapper;
+		TStreamType& mStream;
+		SimpleXmlWriterImpl( const SimpleXmlWriterImpl& inOther );
+		SimpleXmlWriterImpl& operator=( const SimpleXmlWriterImpl& inOther );
+		PxProfileArray<const char*>	mTags;
+		bool								mTagOpen;
+		PxU32							mInitialTagDepth;
+	public:
+
+		SimpleXmlWriterImpl( TStreamType& inStream, PxAllocatorCallback& inAllocator, PxU32 inInitialTagDepth = 0 )
+			: mWrapper( inAllocator )
+			, mStream( inStream )
+			, mTags( mWrapper )
+			, mTagOpen( false )
+			, mInitialTagDepth( inInitialTagDepth )
+		{
+		}
+		virtual ~SimpleXmlWriterImpl()
+		{
+			while( mTags.size() )
+				endTag();
+		}
+		PxU32 tabCount() { return mTags.size() + mInitialTagDepth; }
+
+		void writeTabs( PxU32 inSize )
+		{
+			inSize += mInitialTagDepth;
+			for ( PxU32 idx =0; idx < inSize; ++idx )
+				mStream << "\t";
+		}
+		void beginTag( const char* inTagname )
+		{
+			closeTag();
+			writeTabs(mTags.size());
+			mTags.pushBack( inTagname );
+			mStream << "<" << inTagname;
+			mTagOpen = true;
+		}
+		void addAttribute( const char* inName, const char* inValue )
+		{
+			PX_ASSERT( mTagOpen );
+			mStream << " " << inName << "=" << "\"" << inValue << "\"";
+		}
+		void closeTag(bool useNewline = true)
+		{
+			if ( mTagOpen )
+			{
+				mStream << " " << ">";
+				if (useNewline )
+					mStream << "\n";
+			}
+			mTagOpen = false;
+		}
+		void doEndOpenTag()
+		{
+			mStream << "</" << mTags.back() << ">" << "\n";
+		}
+		void endTag()
+		{
+			PX_ASSERT( mTags.size() );
+			if ( mTagOpen )
+				mStream << " " << "/>" << "\n";
+			else
+			{
+				writeTabs(mTags.size()-1);
+				doEndOpenTag();
+			}
+			mTagOpen = false;
+			mTags.popBack();
+		}
+
+		static bool IsNormalizableWhitespace(char c) { return c == 0x9 || c == 0xA || c == 0xD; }
+		static bool IsValidXmlCharacter(char c) { return IsNormalizableWhitespace(c) || c >= 0x20; }
+
+		void addContent( const char* inContent )
+		{
+			closeTag(false);
+			//escape xml
+			for( ; *inContent; inContent++ )
+			{
+				switch (*inContent) 
+				{
+				case '<':
+					mStream << "&lt;";
+					break;
+				case '>':
+					mStream << "&gt;";
+					break;
+				case '&':
+					mStream << "&amp;";
+					break;
+				case '\'':
+					mStream << "&apos;";
+					break;
+				case '"':
+					mStream << "&quot;";
+					break;
+				default:
+					if (IsValidXmlCharacter(*inContent)) {
+						if (IsNormalizableWhitespace(*inContent))
+						{
+							char s[32];
+							Ps::snprintf(s, 32, "&#x%02X;", unsigned(*inContent));
+							mStream << s;
+						}
+						else
+							mStream << *inContent;
+					}
+					break;
+				}
+			}
+		}
+
+		void writeContentTag( const char* inTag, const char* inContent )
+		{
+			beginTag( inTag );
+			addContent( inContent );
+			doEndOpenTag();
+			mTags.popBack();
+		}
+		void insertXml( const char* inXml )
+		{
+			closeTag();
+			mStream << inXml;
+		}
+	};
+
+	struct BeginTag
+	{
+		const char* mTagName;
+		BeginTag( const char* inTagName )
+			: mTagName( inTagName ) { }
+	};
+
+	struct EndTag
+	{
+		EndTag() {}
+	};
+
+	struct Att
+	{
+		const char* mAttName;
+		const char* mAttValue;
+		Att( const char* inAttName, const char* inAttValue )
+			: mAttName( inAttName )
+			, mAttValue( inAttValue ) {	}
+	};
+
+	struct Content
+	{
+		const char* mContent;
+		Content( const char* inContent )
+			: mContent( inContent ) { }
+	};
+
+	
+	struct ContentTag
+	{
+		const char* mTagName;
+		const char* mContent;
+		ContentTag( const char* inTagName, const char* inContent )
+			: mTagName( inTagName )
+			, mContent( inContent ) { }
+	};
+
+	inline SimpleXmlWriter& operator<<( SimpleXmlWriter& inWriter, const BeginTag& inTag ) { inWriter.beginTag( inTag.mTagName ); return inWriter; }
+	inline SimpleXmlWriter& operator<<( SimpleXmlWriter& inWriter, const EndTag& inTag ) { PX_UNUSED(inTag); inWriter.endTag(); return inWriter; }
+	inline SimpleXmlWriter& operator<<( SimpleXmlWriter& inWriter, const Att& inTag ) { inWriter.addAttribute(inTag.mAttName, inTag.mAttValue); return inWriter; }
+	inline SimpleXmlWriter& operator<<( SimpleXmlWriter& inWriter, const Content& inTag ) { inWriter.addContent(inTag.mContent); return inWriter; }
+	inline SimpleXmlWriter& operator<<( SimpleXmlWriter& inWriter, const ContentTag& inTag ) { inWriter.writeContentTag(inTag.mTagName, inTag.mContent); return inWriter; }
+
+	inline void writeProperty( SimpleXmlWriter& inWriter, MemoryBuffer& tempBuffer, const char* inPropName )
+	{
+		PxU8 data = 0;
+		tempBuffer.write( &data, sizeof(PxU8) );
+		inWriter.writeContentTag( inPropName, reinterpret_cast<const char*>( tempBuffer.mBuffer ) );
+		tempBuffer.clear();
+	}
+
+	template<typename TDataType>
+	inline void writeProperty( SimpleXmlWriter& inWriter, MemoryBuffer& tempBuffer, const char* inPropName, TDataType inValue )
+	{
+		tempBuffer << inValue;
+		writeProperty( inWriter, tempBuffer, inPropName );
+	}
+} }
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlDeserializer.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlDeserializer.h
new file mode 100644
index 00000000..fdb29359
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlDeserializer.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 PX_XML_DESERIALIZER_H
+#define PX_XML_DESERIALIZER_H
+
+#include "SnXmlVisitorReader.h"
+
+namespace physx { namespace Sn {
+	
+	//Definitions needed internally in the Serializer headers.
+	template<typename TTriIndexElem>
+	struct Triangle
+	{
+		TTriIndexElem mIdx0;
+		TTriIndexElem mIdx1;
+		TTriIndexElem mIdx2;
+		Triangle( TTriIndexElem inIdx0 = 0, TTriIndexElem inIdx1 = 0, TTriIndexElem inIdx2 = 0)
+			: mIdx0( inIdx0 )
+			, mIdx1( inIdx1 )
+			, mIdx2( inIdx2 )
+		{
+		}
+	};
+
+	struct XmlMemoryAllocateMemoryPoolAllocator
+	{
+		XmlMemoryAllocator* mAllocator;
+		XmlMemoryAllocateMemoryPoolAllocator( XmlMemoryAllocator* inAlloc ) : mAllocator( inAlloc ) {}
+
+		PxU8* allocate( PxU32 inSize ) { return mAllocator->allocate( inSize ); }
+		void deallocate( PxU8* inMem ) { mAllocator->deallocate( inMem ); }
+	};
+
+	inline void strtoLong( Triangle<PxU32>& ioDatatype,const char*& ioData )
+	{
+		strto( ioDatatype.mIdx0, ioData );
+		strto( ioDatatype.mIdx1, ioData );
+		strto( ioDatatype.mIdx2, ioData );
+	}
+
+	inline void strtoLong( PxHeightFieldSample& ioDatatype,const char*& ioData )
+	{
+		PxU32 tempData;
+		strto( tempData, ioData );
+		if ( isBigEndian() )
+		{
+			PxU32& theItem(tempData);
+			PxU32 theDest = 0;
+			PxU8* theReadPtr( reinterpret_cast< PxU8* >( &theItem ) );
+			PxU8* theWritePtr( reinterpret_cast< PxU8* >( &theDest ) );
+			//A height field sample is a 16 bit number
+			//followed by two bytes.
+
+			//We write this out as a 32 bit integer, LE.
+			//Thus, on a big endian, we need to move the bytes
+			//around a bit.
+			//LE - 1 2 3 4
+			//BE - 4 3 2 1 - after convert from xml number
+			//Correct BE - 2 1 3 4, just like LE but with the 16 number swapped
+			theWritePtr[0] = theReadPtr[2];
+			theWritePtr[1] = theReadPtr[3];
+			theWritePtr[2] = theReadPtr[1];
+			theWritePtr[3] = theReadPtr[0];
+			theItem = theDest;
+		}
+		ioDatatype = *reinterpret_cast<PxHeightFieldSample*>( &tempData );
+	}
+
+	template<typename TDataType>
+	inline void readStridedFlagsProperty( XmlReader& ioReader, const char* inPropName, TDataType*& outData, PxU32& outStride, PxU32& outCount, XmlMemoryAllocator& inAllocator,
+		  const PxU32ToName* inConversions)
+	{
+		const char* theSrcData;
+		outStride = sizeof( TDataType );
+		outData = NULL;
+		outCount = 0;
+		if ( ioReader.read( inPropName, theSrcData ) )
+		{
+			XmlMemoryAllocateMemoryPoolAllocator tempAllocator( &inAllocator );
+			MemoryBufferBase<XmlMemoryAllocateMemoryPoolAllocator> tempBuffer( &tempAllocator );
+
+			if ( theSrcData )
+			{
+				static PxU32 theCount = 0;
+				++theCount;
+				char* theStartData = const_cast< char*>( copyStr( &tempAllocator, theSrcData ) );
+				char* aData = strtok(theStartData, " \n");
+				while( aData )
+				{
+					TDataType tempValue;
+					stringToFlagsType( aData, inAllocator, tempValue, inConversions );						
+					aData = strtok(NULL," \n");
+					tempBuffer.write( &tempValue, sizeof(TDataType) );
+				}
+				outData = reinterpret_cast< TDataType* >( tempBuffer.mBuffer );
+				outCount = tempBuffer.mWriteOffset / sizeof( TDataType );
+				tempAllocator.deallocate( reinterpret_cast<PxU8*>(theStartData) );
+			}
+			tempBuffer.releaseBuffer();
+		}
+	}
+
+	template<typename TDataType>
+	inline void readStridedBufferProperty( XmlReader& ioReader, const char* inPropName, TDataType*& outData, PxU32& outStride, PxU32& outCount, XmlMemoryAllocator& inAllocator)
+	{
+		const char* theSrcData;
+		outStride = sizeof( TDataType );
+		outData = NULL;
+		outCount = 0;
+		if ( ioReader.read( inPropName, theSrcData ) )
+		{
+			XmlMemoryAllocateMemoryPoolAllocator tempAllocator( &inAllocator );
+			MemoryBufferBase<XmlMemoryAllocateMemoryPoolAllocator> tempBuffer( &tempAllocator );
+
+			if ( theSrcData )
+			{
+				static PxU32 theCount = 0;
+				++theCount;
+				char* theStartData = const_cast< char*>( copyStr( &tempAllocator, theSrcData ) );
+				const char* theData = theStartData;
+				PxU32 theLen = strLenght( theData );
+				const char* theEndData = theData + theLen;
+				while( theData < theEndData )
+				{
+					//These buffers are whitespace delimited.
+					TDataType theType;
+					strtoLong( theType, theData );
+					tempBuffer.write( &theType, sizeof(theType) );
+				}
+				outData = reinterpret_cast< TDataType* >( tempBuffer.mBuffer );
+				outCount = tempBuffer.mWriteOffset / sizeof( TDataType );
+				tempAllocator.deallocate( reinterpret_cast<PxU8*>(theStartData) );
+			}
+			tempBuffer.releaseBuffer();
+		}
+	}
+	
+	template<typename TDataType>
+	inline void readStridedBufferProperty( XmlReader& ioReader, const char* inPropName, PxStridedData& ioData, PxU32& outCount, XmlMemoryAllocator& inAllocator)
+	{
+		TDataType* tempData = NULL;
+		readStridedBufferProperty<TDataType>( ioReader, inPropName, tempData, ioData.stride, outCount, inAllocator ); 
+		ioData.data = tempData;
+	}
+	
+	template<typename TDataType>
+	inline void readStridedBufferProperty( XmlReader& ioReader, const char* inPropName, PxTypedStridedData<TDataType>& ioData, PxU32& outCount, XmlMemoryAllocator& inAllocator)
+	{
+		TDataType* tempData = NULL;
+		readStridedBufferProperty<TDataType>( ioReader, inPropName, tempData, ioData.stride, outCount, inAllocator );
+		ioData.data = reinterpret_cast<PxMaterialTableIndex*>( tempData );
+	}
+
+	template<typename TDataType>
+	inline void readStridedBufferProperty( XmlReader& ioReader, const char* inPropName, PxBoundedData& ioData, XmlMemoryAllocator& inAllocator)
+	{
+		return readStridedBufferProperty<TDataType>( ioReader, inPropName, ioData, ioData.count, inAllocator );
+	}
+
+} }
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlImpl.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlImpl.h
new file mode 100644
index 00000000..1718cc86
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlImpl.h
@@ -0,0 +1,242 @@
+// 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_XML_IMPL_H
+#define PX_XML_IMPL_H
+
+#include "SnXmlMemoryPool.h"
+#include "PsString.h"
+
+namespace physx { namespace Sn {
+
+typedef CMemoryPoolManager TMemoryPoolManager;
+
+namespace snXmlImpl {
+
+	inline PxU32 strLen( const char* inStr )
+	{
+		PxU32 len = 0;
+		if ( inStr )
+		{
+			while ( *inStr )
+			{
+				++len;
+				++inStr;
+			}
+		}
+		return len;
+	}
+}
+	inline const char* copyStr( PxAllocatorCallback& inAllocator, const char* inStr )
+	{
+		if ( inStr && *inStr )
+		{
+			PxU32 theLen = snXmlImpl::strLen( inStr );
+			//The memory will never be released by repx.  If you want it released, you need to pass in a custom allocator
+			//that tracks all allocations and releases unreleased allocations yourself.
+			char* dest = reinterpret_cast<char* >( inAllocator.allocate( theLen + 1, "Repx::const char*", __FILE__, __LINE__ ) );
+			memcpy( dest, inStr, theLen );
+			dest[theLen] = 0;
+			return dest;
+		}
+		return "";
+	}
+
+	template<typename TManagerType>
+	inline const char* copyStr( TManagerType* inMgr, const char* inStr )
+	{
+		if ( inStr && *inStr )
+		{
+			PxU32 theLen = snXmlImpl::strLen( inStr );
+			char* dest = reinterpret_cast<char* >( inMgr->allocate( theLen + 1 ) );
+			memcpy( dest, inStr, theLen );
+			dest[theLen] = 0;
+			return dest;
+		}
+		return "";
+	}
+
+	inline void releaseStr( TMemoryPoolManager* inMgr, const char* inStr, PxU32 )
+	{
+		if ( inStr && *inStr )
+		{
+			inMgr->deallocate( reinterpret_cast< PxU8* >( const_cast<char*>( inStr ) ) ); 
+		}
+	}
+
+	inline void releaseStr( TMemoryPoolManager* inMgr, const char* inStr )
+	{
+		if ( inStr && *inStr )
+		{
+			PxU32 theLen = snXmlImpl::strLen( inStr );
+			releaseStr( inMgr, inStr, theLen );
+		}
+	}
+
+	struct XmlNode
+	{
+		const char* mName; //Never released until all collections are released
+		const char* mData; //Never released until all collections are released
+		
+		XmlNode* mNextSibling;
+		XmlNode* mPreviousSibling;
+		XmlNode* mFirstChild;
+		XmlNode* mParent;
+		XmlNode( const XmlNode& );
+		XmlNode& operator=( const XmlNode& );
+
+		PX_INLINE void initPtrs()
+		{
+			mNextSibling = NULL;
+			mPreviousSibling = NULL;
+			mFirstChild = NULL;
+			mParent = NULL;
+		}
+
+		PX_INLINE XmlNode( const char* inName = "", const char* inData = "" ) 
+			: mName( inName )
+			, mData( inData ) 
+		{ initPtrs(); }
+
+		void addChild( XmlNode* inItem )
+		{
+			inItem->mParent = this;
+			if ( mFirstChild == NULL )
+				mFirstChild = inItem;
+			else
+			{
+				XmlNode* theNode = mFirstChild;
+				//Follow the chain till the end.
+				while( theNode->mNextSibling != NULL )
+					theNode = theNode->mNextSibling;
+				theNode->mNextSibling = inItem;
+				inItem->mPreviousSibling = theNode;
+			}
+		}
+
+		PX_INLINE XmlNode* findChildByName( const char* inName )
+		{
+			for ( XmlNode* theNode = mFirstChild; theNode; theNode = theNode->mNextSibling )
+			{
+				XmlNode* theRepXNode = theNode;
+				if ( physx::shdfnd::stricmp( theRepXNode->mName, inName ) == 0 )
+					return theNode;
+			}
+			return NULL;
+		}
+		
+		PX_INLINE void orphan()
+		{
+			if ( mParent )
+			{
+				if ( mParent->mFirstChild == this )
+					mParent->mFirstChild = mNextSibling;
+			}
+			if ( mPreviousSibling )
+				mPreviousSibling->mNextSibling = mNextSibling;
+			if ( mNextSibling )
+				mNextSibling->mPreviousSibling = mPreviousSibling;
+			if ( mFirstChild )
+				mFirstChild->mParent = NULL;
+			initPtrs();
+		}
+	};
+
+	inline XmlNode* allocateRepXNode( TMemoryPoolManager* inManager, const char* inName, const char* inData )
+	{
+		XmlNode* retval = inManager->allocate<XmlNode>();
+		retval->mName = copyStr( inManager, inName );
+		retval->mData = copyStr( inManager, inData );
+		return retval;
+	}
+
+	inline void release( TMemoryPoolManager* inManager, XmlNode* inNode )
+	{
+		//We *don't* release the strings associated with the node
+		//because they could be shared.  Instead, we just let them 'leak'
+		//in some sense, at least until the memory manager itself is deleted.
+		//DO NOT UNCOMMENT THE LINES BELOW!!
+		//releaseStr( inManager, inNode->mName );
+		//releaseStr( inManager, inNode->mData );
+		inManager->deallocate( inNode );
+	}
+
+	static PX_INLINE void releaseNodeAndChildren( TMemoryPoolManager* inManager, XmlNode* inNode )
+	{
+		if ( inNode->mFirstChild )
+		{
+			XmlNode* childNode( inNode->mFirstChild );
+			while( childNode )
+			{
+				XmlNode* _node( childNode );
+				childNode = _node->mNextSibling;
+				releaseNodeAndChildren( inManager, _node );
+			}
+		}
+		inNode->orphan();
+		release( inManager, inNode );
+	}
+
+	static XmlNode* copyRepXNodeAndSiblings( TMemoryPoolManager* inManager, const XmlNode* inNode, XmlNode* inParent );
+
+	static XmlNode* copyRepXNode( TMemoryPoolManager* inManager, const XmlNode* inNode, XmlNode* inParent = NULL )
+	{
+		XmlNode* newNode( allocateRepXNode( inManager, NULL, NULL ) );
+		newNode->mName = inNode->mName; //Some light structural sharing
+		newNode->mData = inNode->mData; //Some light structural sharing
+		newNode->mParent = inParent;
+		if ( inNode->mFirstChild )
+			newNode->mFirstChild = copyRepXNodeAndSiblings( inManager, inNode->mFirstChild, newNode );
+		return newNode;
+	}
+	
+	static XmlNode* copyRepXNodeAndSiblings( TMemoryPoolManager* inManager, const XmlNode* inNode, XmlNode* inParent )
+	{
+		XmlNode* sibling = inNode->mNextSibling;
+		if ( sibling ) sibling = copyRepXNodeAndSiblings( inManager, sibling, inParent );
+		XmlNode* newNode = copyRepXNode( inManager, inNode, inParent );
+		newNode->mNextSibling = sibling;
+		if ( sibling ) sibling->mPreviousSibling = newNode;
+		return newNode;
+	}
+
+	inline bool isBigEndian() { int i = 1; return *(reinterpret_cast<char*>(&i))==0; }
+	
+
+	struct NameStackEntry
+	{
+		const char* mName;
+		bool		mOpen;
+		NameStackEntry( const char* nm ) : mName( nm ), mOpen( false ) {}
+	};
+
+	typedef PxProfileArray<NameStackEntry> TNameStack;
+}  }
+
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlMemoryAllocator.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlMemoryAllocator.h
new file mode 100644
index 00000000..8172a312
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlMemoryAllocator.h
@@ -0,0 +1,129 @@
+// 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_XML_MEMORY_ALLOCATOR_H
+#define PX_XML_MEMORY_ALLOCATOR_H
+
+#include "foundation/PxSimpleTypes.h"
+
+namespace physx { 
+
+	class XmlMemoryAllocator
+	{
+	protected:
+		virtual ~XmlMemoryAllocator(){}
+	public:
+		virtual PxU8* allocate(PxU32 inSize) = 0;
+		virtual void deallocate( PxU8* inMem ) = 0;
+		virtual PxAllocatorCallback& getAllocator() = 0;
+		template<typename TObjectType>
+		TObjectType* allocate()
+		{
+			TObjectType* retval = reinterpret_cast< TObjectType* >( allocate( sizeof( TObjectType ) ) );
+			new (retval) TObjectType();
+			return retval;
+		}
+
+		template<typename TObjectType, typename TArgType>
+		TObjectType* allocate(const TArgType &arg)
+		{
+			TObjectType* retval = reinterpret_cast< TObjectType* >( allocate( sizeof( TObjectType ) ) );
+			new (retval) TObjectType(arg);
+			return retval;
+		}
+
+		template<typename TObjectType>
+		void deallocate( TObjectType* inObject )
+		{
+			deallocate( reinterpret_cast<PxU8*>( inObject ) );
+		}
+		template<typename TObjectType>
+		inline TObjectType* batchAllocate(PxU32 inCount )
+		{
+			TObjectType* retval = reinterpret_cast<TObjectType*>( allocate( sizeof(TObjectType) * inCount ) );
+			for ( PxU32 idx = 0; idx < inCount; ++idx )
+			{
+				new (retval + idx) TObjectType();
+			}
+			return retval;
+		}
+
+		template<typename TObjectType, typename TArgType>
+		inline TObjectType* batchAllocate(PxU32 inCount, const TArgType &arg)
+		{
+			TObjectType* retval = reinterpret_cast<TObjectType*>( allocate( sizeof(TObjectType) * inCount ) );
+			for ( PxU32 idx = 0; idx < inCount; ++idx )
+			{
+				new (retval + idx) TObjectType(arg);
+			}
+			return retval;
+		}
+
+
+		//Duplicate function definition for gcc.
+		template<typename TObjectType>
+		inline TObjectType* batchAllocate(TObjectType*, PxU32 inCount )
+		{
+			TObjectType* retval = reinterpret_cast<TObjectType*>( allocate( sizeof(TObjectType) * inCount ) );
+			for ( PxU32 idx = 0; idx < inCount; ++idx )
+			{
+				new (retval + idx) TObjectType();
+			}
+			return retval;
+		}
+	};
+	
+	struct XmlMemoryAllocatorImpl : public XmlMemoryAllocator
+	{
+		Sn::TMemoryPoolManager mManager;
+
+		XmlMemoryAllocatorImpl( PxAllocatorCallback& inAllocator )
+			: mManager( inAllocator )
+		{
+		}
+		XmlMemoryAllocatorImpl &operator=(const XmlMemoryAllocatorImpl &);
+		virtual PxAllocatorCallback& getAllocator()
+		{
+			return mManager.getWrapper().getAllocator();
+		}
+		
+		virtual PxU8* allocate(PxU32 inSize )
+		{
+			if ( !inSize )
+				return NULL;
+
+			return mManager.allocate( inSize );
+		}
+		virtual void deallocate( PxU8* inMem )
+		{
+			if ( inMem )
+				mManager.deallocate( inMem );
+		}
+	};
+}
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlMemoryPool.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlMemoryPool.h
new file mode 100644
index 00000000..2c1177e3
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlMemoryPool.h
@@ -0,0 +1,373 @@
+// 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_XML_MEMORYPOOL_H
+#define PX_XML_MEMORYPOOL_H
+
+#include "foundation/PxAssert.h"
+#include "PsArray.h"
+#include "PxProfileAllocatorWrapper.h"
+
+namespace physx { 
+
+	using namespace physx::profile;
+
+	/** 
+	 *	Linked list used to store next node ptr.
+	 */
+	struct SMemPoolNode
+	{
+		SMemPoolNode* mNextNode;
+	};
+
+	/**
+	 *	Template arguments are powers of two.
+	 *	A very fast memory pool that is not memory efficient.  It contains a vector of pointers
+	 *	to blocks of memory along with a linked list of free sections.  All sections are
+	 *	of the same size so allocating memory is very fast, there isn't a linear search
+	 *	through blocks of indeterminate size.  It also means there is memory wasted
+	 *	when objects aren't sized to powers of two.
+	 */
+	template<PxU8 TItemSize
+		, PxU8 TItemCount >
+	class CMemoryPool
+	{
+		typedef PxProfileArray<PxU8*> TPxU8PtrList;
+
+		PxProfileAllocatorWrapper& mWrapper;
+		TPxU8PtrList mAllMemory;
+		SMemPoolNode* mFirstFreeNode;
+	public:
+		CMemoryPool(PxProfileAllocatorWrapper& inWrapper) 
+			: mWrapper( inWrapper )
+			, mAllMemory( inWrapper )
+			, mFirstFreeNode( NULL )
+		{}
+		~CMemoryPool()
+		{
+			TPxU8PtrList::ConstIterator theEnd = mAllMemory.end();
+			for ( TPxU8PtrList::ConstIterator theIter = mAllMemory.begin();
+				theIter != theEnd; 
+				++theIter )
+			{
+				PxU8* thePtr = *theIter;
+				mWrapper.getAllocator().deallocate( thePtr );
+			}
+			mAllMemory.clear();
+			mFirstFreeNode = NULL;
+		}
+		//Using deallocated memory to hold the pointers to the next amount of memory.
+		PxU8* allocate()
+		{
+			if ( mFirstFreeNode )
+			{
+				PxU8* retval = reinterpret_cast<PxU8*>(mFirstFreeNode);
+				mFirstFreeNode = mFirstFreeNode->mNextNode;
+				return retval;
+			}
+			PxU32 itemSize = GetItemSize();
+			PxU32 itemCount = 1 << TItemCount;
+			//No free nodes, make some more.
+			PxU8* retval = reinterpret_cast<PxU8*>(mWrapper.getAllocator().allocate( itemCount * itemSize, "RepX fixed-size memory pool", __FILE__, __LINE__ ));
+			PxU8* dataPtr = retval + itemSize;
+			//Free extra chunks
+			for( PxU32 idx = 1; idx < itemCount; ++idx, dataPtr += itemSize )
+				deallocate( dataPtr );
+			mAllMemory.pushBack(retval);
+			return retval;
+		}
+		void deallocate( PxU8* inData )
+		{
+			SMemPoolNode* nodePtr = reinterpret_cast<SMemPoolNode*>(inData);
+			nodePtr->mNextNode = mFirstFreeNode;
+			mFirstFreeNode = nodePtr;
+		}
+		//We have to have at least a pointer's worth of memory
+		inline PxU32 GetItemSize() { return sizeof(SMemPoolNode) << TItemSize; }
+	};
+
+	typedef PxU32 TMemAllocSizeType;
+
+	struct SVariableMemPoolNode : SMemPoolNode
+	{
+		TMemAllocSizeType mSize;
+		SVariableMemPoolNode* NextNode() { return static_cast< SVariableMemPoolNode* >( mNextNode ); }
+	};
+
+	/**
+	 *	Manages variable sized allocations.  
+	 *	Keeps track of freed allocations in a insertion sorted
+	 *	list.  Allocating new memory traverses the list linearly.
+	 *	This object will split nodes if the node is more than
+	 *	twice as large as the request memory allocation.
+	 */
+	class CVariableMemoryPool
+	{
+		typedef PxProfileHashMap<TMemAllocSizeType, SVariableMemPoolNode*> TFreeNodeMap;
+		typedef PxProfileArray<PxU8*> TPxU8PtrList;
+		PxProfileAllocatorWrapper& mWrapper;
+		TPxU8PtrList mAllMemory;
+		TFreeNodeMap mFreeNodeMap;
+		PxU32 mMinAllocationSize;
+		
+		CVariableMemoryPool &operator=(const CVariableMemoryPool &);
+
+	public:
+		CVariableMemoryPool(PxProfileAllocatorWrapper& inWrapper, PxU32 inMinAllocationSize = 0x20 ) 
+			: mWrapper( inWrapper )
+			, mAllMemory( inWrapper )
+			, mFreeNodeMap( inWrapper)
+			, mMinAllocationSize( inMinAllocationSize )
+		{}
+
+		~CVariableMemoryPool()
+		{
+			TPxU8PtrList::ConstIterator theEnd = mAllMemory.end();
+			for ( TPxU8PtrList::ConstIterator theIter = mAllMemory.begin();
+				theIter != theEnd; 
+				++theIter )
+			{
+				PxU8* thePtr = *theIter;
+				mWrapper.getAllocator().deallocate( thePtr );
+			}
+			mAllMemory.clear();
+			mFreeNodeMap.clear();
+		}
+		PxU8* MarkMem( PxU8* inMem, TMemAllocSizeType inSize )
+		{
+			PX_ASSERT( inSize >= sizeof( SVariableMemPoolNode ) );
+			SVariableMemPoolNode* theMem = reinterpret_cast<SVariableMemPoolNode*>( inMem );
+			theMem->mSize = inSize;
+			return reinterpret_cast< PxU8* >( theMem + 1 );
+		}
+		//Using deallocated memory to hold the pointers to the next amount of memory.
+		PxU8* allocate( PxU32 size )
+		{
+			//Ensure we can place the size of the memory at the start
+			//of the memory block.
+			//Kai: to reduce the size of hash map, the requested size is aligned to 128 bytes
+			PxU32 theRequestedSize = (size + sizeof(SVariableMemPoolNode) + 127) & ~127;
+
+			TFreeNodeMap::Entry* entry = const_cast<TFreeNodeMap::Entry*>( mFreeNodeMap.find( theRequestedSize ) );
+			if ( NULL != entry )
+			{
+				SVariableMemPoolNode* theNode = entry->second;
+				PX_ASSERT( NULL != theNode );
+				PX_ASSERT( theNode->mSize == theRequestedSize );
+				entry->second = theNode->NextNode();
+				if (entry->second == NULL)
+					mFreeNodeMap.erase( theRequestedSize );
+
+				return reinterpret_cast< PxU8* >( theNode + 1 );
+			}
+
+			if ( theRequestedSize < mMinAllocationSize )
+				theRequestedSize = mMinAllocationSize;
+
+			//No large enough free nodes, make some more.
+			PxU8* retval = reinterpret_cast<PxU8*>(mWrapper.getAllocator().allocate( size_t(theRequestedSize), "RepX variable sized memory pool", __FILE__, __LINE__ ));
+			//If we allocated it, we free it.
+			mAllMemory.pushBack( retval );
+			return MarkMem( retval, theRequestedSize );
+		}
+
+		//The size is stored at the beginning of the memory block.
+		void deallocate( PxU8* inData )
+		{
+			SVariableMemPoolNode* theData = reinterpret_cast< SVariableMemPoolNode* >( inData ) - 1;
+			TMemAllocSizeType theSize = theData->mSize;
+			AddFreeMem( reinterpret_cast< PxU8* >( theData ), theSize );
+		}
+
+		void CheckFreeListInvariant( SVariableMemPoolNode* inNode )
+		{
+			if ( inNode && inNode->mNextNode )
+			{
+				PX_ASSERT( inNode->mSize <= inNode->NextNode()->mSize );
+			}
+		}
+
+		void AddFreeMem( PxU8* inMemory, TMemAllocSizeType inSize )
+		{
+			PX_ASSERT( inSize >= sizeof( SVariableMemPoolNode ) );
+			SVariableMemPoolNode* theNewNode = reinterpret_cast< SVariableMemPoolNode* >( inMemory );
+			theNewNode->mNextNode = NULL;
+			theNewNode->mSize = inSize;
+			TFreeNodeMap::Entry* entry = const_cast<TFreeNodeMap::Entry*>( mFreeNodeMap.find( inSize ) );
+			if (NULL != entry)
+			{
+				theNewNode->mNextNode = entry->second;
+				entry->second = theNewNode;
+			}
+			else
+			{
+				mFreeNodeMap.insert( inSize, theNewNode );
+			}
+		}
+	};
+
+	/**
+	 *	The manager keeps a list of memory pools for different sizes of allocations.
+	 *	Anything too large simply gets allocated using the new operator.
+	 *	This doesn't mark the memory with the size of the allocated memory thus
+	 *	allowing much more efficient allocation of small items.  For large enough
+	 *	allocations, it does mark the size.
+	 *	
+	 *	When using as a general memory manager, you need to wrap this class with
+	 *	something that actually does mark the returned allocation with the size
+	 *	of the allocation.
+	 */
+	class CMemoryPoolManager
+	{
+		CMemoryPoolManager &operator=(const CMemoryPoolManager &);
+
+	public:
+		PxProfileAllocatorWrapper mWrapper;
+
+		//CMemoryPool<0,8> m0ItemPool;
+		//CMemoryPool<1,8> m1ItemPool;
+		//CMemoryPool<2,8> m2ItemPool;
+		//CMemoryPool<3,8> m3ItemPool;
+		//CMemoryPool<4,8> m4ItemPool;
+		//CMemoryPool<5,8> m5ItemPool;
+		//CMemoryPool<6,8> m6ItemPool;
+		//CMemoryPool<7,8> m7ItemPool;
+		//CMemoryPool<8,8> m8ItemPool;
+		CVariableMemoryPool		mVariablePool;
+		CMemoryPoolManager( PxAllocatorCallback& inAllocator )
+			: mWrapper( inAllocator )
+			//, m0ItemPool( mWrapper )
+			//, m1ItemPool( mWrapper )
+			//, m2ItemPool( mWrapper )
+			//, m3ItemPool( mWrapper )
+			//, m4ItemPool( mWrapper )
+			//, m5ItemPool( mWrapper )
+			//, m6ItemPool( mWrapper )
+			//, m7ItemPool( mWrapper )
+			//, m8ItemPool( mWrapper )
+			, mVariablePool( mWrapper )
+		{
+		}
+		PxProfileAllocatorWrapper& getWrapper() { return mWrapper; }
+		inline PxU8* allocate( PxU32 inSize )
+		{
+			/*
+			if ( inSize <= m0ItemPool.GetItemSize() )
+				return m0ItemPool.allocate();
+			if ( inSize <= m1ItemPool.GetItemSize() )
+				return m1ItemPool.allocate();
+			if ( inSize <= m2ItemPool.GetItemSize() )
+				return m2ItemPool.allocate();
+			if ( inSize <= m3ItemPool.GetItemSize() )
+				return m3ItemPool.allocate();
+			if ( inSize <= m4ItemPool.GetItemSize() )
+				return m4ItemPool.allocate();
+			if ( inSize <= m5ItemPool.GetItemSize() )
+				return m5ItemPool.allocate();
+			if ( inSize <= m6ItemPool.GetItemSize() )
+				return m6ItemPool.allocate();
+			if ( inSize <= m7ItemPool.GetItemSize() )
+				return m7ItemPool.allocate();
+			if ( inSize <= m8ItemPool.GetItemSize() )
+				return m8ItemPool.allocate();
+				*/
+			return mVariablePool.allocate( inSize );
+		}
+		inline void deallocate( PxU8* inMemory )
+		{
+			if ( inMemory == NULL )
+				return;
+			/*
+			if ( inSize <= m0ItemPool.GetItemSize() )
+				m0ItemPool.deallocate(inMemory);
+			else if ( inSize <= m1ItemPool.GetItemSize() )
+				m1ItemPool.deallocate(inMemory);
+			else if ( inSize <= m2ItemPool.GetItemSize() )
+				m2ItemPool.deallocate(inMemory);
+			else if ( inSize <= m3ItemPool.GetItemSize() )
+				m3ItemPool.deallocate(inMemory);
+			else if ( inSize <= m4ItemPool.GetItemSize() )
+				m4ItemPool.deallocate(inMemory);
+			else if ( inSize <= m5ItemPool.GetItemSize() )
+				m5ItemPool.deallocate(inMemory);
+			else if ( inSize <= m6ItemPool.GetItemSize() )
+				m6ItemPool.deallocate(inMemory);
+			else if ( inSize <= m7ItemPool.GetItemSize() )
+				m7ItemPool.deallocate(inMemory);
+			else if ( inSize <= m8ItemPool.GetItemSize() )
+				m8ItemPool.deallocate(inMemory);
+			else
+			*/
+				mVariablePool.deallocate(inMemory);
+		}
+		/**
+		 *	allocate an object.  Calls constructor on the new memory.
+		 */
+		template<typename TObjectType>
+		inline TObjectType* allocate()
+		{
+			TObjectType* retval = reinterpret_cast<TObjectType*>( allocate( sizeof(TObjectType) ) );
+			new (retval)TObjectType();
+			return retval;
+		}
+
+		/**
+		 *	deallocate an object calling the destructor on the object.  
+		 *	This *must* be the concrete type, it cannot be a generic type.
+		 */
+		template<typename TObjectType>
+		inline void deallocate( TObjectType* inObject )
+		{
+			inObject->~TObjectType();
+			deallocate( reinterpret_cast<PxU8*>(inObject) );
+		}
+		
+		/**
+		 *	allocate an object.  Calls constructor on the new memory.
+		 */
+		template<typename TObjectType>
+		inline TObjectType* BatchAllocate(PxU32 inCount )
+		{
+			TObjectType* retval = reinterpret_cast<TObjectType*>( allocate( sizeof(TObjectType) * inCount ) );
+			return retval;
+		}
+
+		/**
+		 *	deallocate an object calling the destructor on the object.  
+		 *	This *must* be the concrete type, it cannot be a generic type.
+		 */
+		template<typename TObjectType>
+		inline void BatchDeallocate( TObjectType* inObject, PxU32 inCount )
+		{
+			PX_UNUSED(inCount);
+			deallocate( reinterpret_cast<PxU8*>(inObject) );
+		}
+	};
+}
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlMemoryPoolStreams.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlMemoryPoolStreams.h
new file mode 100644
index 00000000..375d1e2d
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlMemoryPoolStreams.h
@@ -0,0 +1,173 @@
+// 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_XML_MEMORY_POOL_STREAMS_H
+#define PX_XML_MEMORY_POOL_STREAMS_H
+
+#include "foundation/PxTransform.h"
+#include "foundation/PxIO.h"
+#include "SnXmlMemoryPool.h"
+#include "CmPhysXCommon.h"
+
+namespace physx {
+
+	template<typename TDataType>
+	struct XmlDefaultValue
+	{
+		bool force_compile_error;
+	};
+
+
+#define XML_DEFINE_DEFAULT_VALUE(type, defVal )		\
+	template<>											\
+	struct XmlDefaultValue<type>						\
+	{													\
+		type getDefaultValue() { return type(defVal); }	\
+	};
+
+	XML_DEFINE_DEFAULT_VALUE(PxU8, 0)
+	XML_DEFINE_DEFAULT_VALUE(PxI8, 0)
+	XML_DEFINE_DEFAULT_VALUE(PxU16, 0)
+	XML_DEFINE_DEFAULT_VALUE(PxI16, 0)
+	XML_DEFINE_DEFAULT_VALUE(PxU32, 0)
+	XML_DEFINE_DEFAULT_VALUE(PxI32, 0)
+	XML_DEFINE_DEFAULT_VALUE(PxU64, 0)
+	XML_DEFINE_DEFAULT_VALUE(PxI64, 0)
+	XML_DEFINE_DEFAULT_VALUE(PxF32, 0)
+	XML_DEFINE_DEFAULT_VALUE(PxF64, 0)
+
+#undef XML_DEFINE_DEFAULT_VALUE
+
+	template<>											
+	struct XmlDefaultValue<PxVec3>						
+	{													
+		PxVec3 getDefaultValue() { return PxVec3( 0,0,0 ); }	
+	};
+	
+	template<>											
+	struct XmlDefaultValue<PxTransform>						
+	{													
+		PxTransform getDefaultValue() { return PxTransform(PxIdentity); }	
+	};
+
+	template<>											
+	struct XmlDefaultValue<PxQuat>	
+	{													
+		PxQuat getDefaultValue() { return PxQuat(PxIdentity); }	
+	};
+
+/** 
+ *	Mapping of PxOutputStream to a memory pool manager.
+ *	Allows write-then-read semantics of a set of
+ *	data.  Can safely write up to 4GB of data; then you
+ *	will silently fail...
+ */
+
+template<typename TAllocatorType>
+struct MemoryBufferBase : public PxOutputStream, public PxInputStream
+{
+	TAllocatorType* mManager;
+	mutable PxU32	mWriteOffset;
+	mutable PxU32	mReadOffset;
+	PxU8*	mBuffer;
+	PxU32	mCapacity;
+
+
+	MemoryBufferBase( TAllocatorType* inManager )
+		: mManager( inManager )
+		, mWriteOffset( 0 )
+		, mReadOffset( 0 )
+		, mBuffer( NULL )
+		, mCapacity( 0 )
+	{
+	}
+	virtual						~MemoryBufferBase()
+	{
+		mManager->deallocate( mBuffer );
+	}
+	PxU8* releaseBuffer()
+	{
+		clear();
+		mCapacity = 0;
+		PxU8* retval(mBuffer);
+		mBuffer = NULL;
+		return retval;
+	}
+	void clear()
+	{
+		mWriteOffset = mReadOffset = 0;
+	}
+
+	virtual PxU32 read(void* dest, PxU32 count)
+	{
+		bool fits = ( mReadOffset + count ) <= mWriteOffset;
+		PX_ASSERT( fits );
+		if ( fits )
+		{
+			memcpy( dest, mBuffer + mReadOffset, count );
+			mReadOffset += count;
+			return count;
+		}
+		return 0;
+	}
+
+	inline void checkCapacity( PxU32 inNewCapacity )
+	{
+		if ( mCapacity < inNewCapacity )
+		{
+			PxU32 newCapacity = 32;
+			while( newCapacity < inNewCapacity )
+				newCapacity = newCapacity << 1;
+
+			PxU8* newData( mManager->allocate( newCapacity ) );
+			if ( mWriteOffset )
+				memcpy( newData, mBuffer, mWriteOffset );
+			mManager->deallocate( mBuffer );
+			mBuffer = newData;
+			mCapacity = newCapacity;
+		}
+	}
+
+	virtual PxU32 write(const void* src, PxU32 count)
+	{
+		checkCapacity( mWriteOffset + count );
+		memcpy( mBuffer + mWriteOffset, src, count );
+		mWriteOffset += count;
+		return count;
+	}
+};
+
+class MemoryBuffer : public MemoryBufferBase<CMemoryPoolManager >
+{
+public:
+	MemoryBuffer( CMemoryPoolManager* inManager ) : MemoryBufferBase<CMemoryPoolManager >( inManager ) {}
+};
+
+}
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlReader.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlReader.h
new file mode 100644
index 00000000..88053d96
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlReader.h
@@ -0,0 +1,130 @@
+// 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_XML_READER_H
+#define PX_XML_READER_H
+
+#include "foundation/PxSimpleTypes.h"
+#include "extensions/PxRepXSimpleType.h"
+
+namespace physx {
+	namespace Sn { struct XmlNode; }
+	
+	/**
+	 *	Reader used to read data out of the repx format.
+	 */
+	class XmlReader
+	{
+	protected:
+		virtual ~XmlReader(){}
+	public:
+		/** Read a key-value pair out of the database */
+		virtual bool read( const char* inName, const char*& outData ) = 0;
+		/** Read an object id out of the database */
+		virtual bool read( const char* inName, PxSerialObjectId& outId ) = 0;
+		/** Goto a child element by name.  That child becomes this reader's context */
+		virtual bool gotoChild( const char* inName ) = 0;
+		/** Goto the first child regardless of name */
+		virtual bool gotoFirstChild() = 0;
+		/** Goto the next sibling regardless of name */
+		virtual bool gotoNextSibling() = 0;
+		/** Count all children of the current object */
+		virtual PxU32 countChildren() = 0;
+		/** Get the name of the current item */
+		virtual const char* getCurrentItemName() = 0;
+		/** Get the value of the current item */
+		virtual const char* getCurrentItemValue() = 0;
+		/** Leave the current child */
+		virtual bool leaveChild() = 0;
+		/** Get reader for the parental object */
+		virtual XmlReader* getParentReader() = 0;
+
+		/**
+		 *	Ensures we don't leave the reader in an odd state
+		 *	due to not leaving a given child
+		 */
+		virtual void pushCurrentContext() = 0;
+		/** Pop the current context back to where it during push*/
+		virtual void popCurrentContext() = 0; 
+	};
+
+	//Used when upgrading a repx collection
+	class XmlReaderWriter : public XmlReader
+	{
+	public:
+		//Clears the stack of nodes (push/pop current node reset)
+		//and sets the current node to inNode.
+		virtual void setNode( Sn::XmlNode& node ) = 0;
+		//If the child exists, add it.
+		//the either way goto that child.
+		virtual void addOrGotoChild( const char* name ) = 0;
+		//Value is copied into the collection, inValue has no further references
+		//to it.
+		virtual void setCurrentItemValue( const char* value ) = 0;
+		//Removes the child but does not release the char* name or char* data ptrs.
+		//Those pointers are never released and are shared among collections.
+		//Thus copying nodes is cheap and safe.
+		virtual bool removeChild( const char* name ) = 0;
+		virtual void release() = 0;
+
+		bool renameProperty( const char* oldName, const char* newName )
+		{
+			if ( gotoChild( oldName ) )
+			{
+				const char* value = getCurrentItemValue();
+				leaveChild();
+				removeChild( oldName );
+				addOrGotoChild( newName );
+				setCurrentItemValue( value );
+				leaveChild();
+				return true;
+			}
+			return false;
+		}
+		bool readAndRemoveProperty( const char* name, const char*& outValue )
+		{
+			bool retval = read( name, outValue ); 
+			if ( retval ) removeChild( name );
+			return retval;
+		}
+
+		bool writePropertyIfNotEmpty( const char* name, const char* value )
+		{
+			if ( value && *value )
+			{ 
+				addOrGotoChild( name ); 
+				setCurrentItemValue( value ); 
+				leaveChild(); 
+				return true;
+			}
+			return false;
+		}
+	};
+
+} 
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlSerialization.cpp b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlSerialization.cpp
new file mode 100644
index 00000000..af86eafd
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlSerialization.cpp
@@ -0,0 +1,834 @@
+// 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.  
+#include "SnXmlImpl.h"
+#include "PsHash.h"
+#include "PsHashMap.h"
+#include "SnSimpleXmlWriter.h"
+#include "PsSort.h"
+#include "PsFastXml.h"
+#include "PsString.h"
+#include "SnXmlMemoryPool.h"
+#include "PxExtensionMetaDataObjects.h"
+#include "SnXmlVisitorWriter.h"
+#include "SnXmlVisitorReader.h"
+#include "SnXmlMemoryAllocator.h"
+#include "SnXmlStringToType.h"
+#include "PsString.h"
+#include "SnRepXCollection.h"
+#include "SnRepXUpgrader.h"
+#include "../SnSerializationRegistry.h"
+#include "PsFoundation.h"
+#include "CmCollection.h"
+
+using namespace physx;
+using namespace Sn;
+
+using namespace physx::profile; //for the foundation wrapper system.
+
+namespace physx { namespace Sn {	
+
+	class XmlNodeWriter : public SimpleXmlWriter
+	{
+		XmlMemoryAllocatorImpl&		mParseAllocator;
+		XmlNode*					mCurrentNode;
+		XmlNode*					mTopNode;
+		PxU32						mTabCount;
+
+	public:
+		XmlNodeWriter( XmlMemoryAllocatorImpl& inAllocator, PxU32 inTabCount = 0 ) 
+			: mParseAllocator( inAllocator ) 
+			, mCurrentNode( NULL )
+			, mTopNode( NULL )
+			, mTabCount( inTabCount )
+		{}
+		XmlNodeWriter& operator=(const XmlNodeWriter&);
+		virtual ~XmlNodeWriter(){}
+		void onNewNode( XmlNode* newNode )
+		{
+			if ( mCurrentNode != NULL )
+				mCurrentNode->addChild( newNode );
+			if ( mTopNode == NULL )
+				mTopNode = newNode;
+			mCurrentNode = newNode;
+			++mTabCount;
+		}
+
+		XmlNode* getTopNode() const { return mTopNode; }
+
+		virtual void beginTag( const char* inTagname )
+		{
+			onNewNode( allocateRepXNode( &mParseAllocator.mManager, inTagname, NULL ) );
+		}
+		virtual void endTag()
+		{
+			if ( mCurrentNode )
+				mCurrentNode = mCurrentNode->mParent;
+			if ( mTabCount )
+				--mTabCount;
+		}
+		virtual void addAttribute( const char*, const char* )
+		{
+			PX_ASSERT( false );
+		}
+		virtual void writeContentTag( const char* inTag, const char* inContent )
+		{
+			onNewNode( allocateRepXNode( &mParseAllocator.mManager, inTag, inContent ) );
+			endTag();
+		}
+		virtual void addContent( const char* inContent )
+		{
+			if ( mCurrentNode->mData )
+				releaseStr( &mParseAllocator.mManager, mCurrentNode->mData );
+			mCurrentNode->mData = copyStr( &mParseAllocator.mManager, inContent );
+		}
+		virtual PxU32 tabCount() { return mTabCount; }
+	};
+
+	struct XmlWriterImpl : public XmlWriter
+	{
+		PxU32				mTagDepth;
+		SimpleXmlWriter*	mWriter;
+		MemoryBuffer*		mMemBuffer;
+
+		XmlWriterImpl( SimpleXmlWriter* inWriter, MemoryBuffer* inMemBuffer )
+			: mTagDepth( 0 )
+			, mWriter( inWriter )
+			, mMemBuffer( inMemBuffer )
+		{
+		}
+		~XmlWriterImpl()
+		{
+			while( mTagDepth )
+			{
+				--mTagDepth;
+				mWriter->endTag();
+			}
+		}
+		virtual void write( const char* inName, const char* inData )
+		{
+			mWriter->writeContentTag( inName, inData );
+		}
+		virtual void write( const char* inName, const PxRepXObject& inLiveObject )
+		{
+			(*mMemBuffer) << inLiveObject.id;
+			writeProperty( *mWriter, *mMemBuffer, inName );
+		}
+		virtual void addAndGotoChild( const char* inName )
+		{
+			mWriter->beginTag( inName );
+			mTagDepth++;
+		}
+		virtual void leaveChild()
+		{
+			if ( mTagDepth )
+			{
+				mWriter->endTag();
+				--mTagDepth;
+			}
+		}
+	};
+
+	struct XmlParseArgs
+	{
+		XmlMemoryAllocatorImpl*					mAllocator;
+		PxProfileArray<RepXCollectionItem>*		mCollection;
+		
+		XmlParseArgs( XmlMemoryAllocatorImpl* inAllocator
+			, PxProfileArray<RepXCollectionItem>* inCollection)
+			: mAllocator( inAllocator )
+			, mCollection( inCollection )
+		{
+		}
+	};
+
+	struct XmlNodeReader : public XmlReaderWriter
+	{
+		PxProfileAllocatorWrapper mWrapper;
+		CMemoryPoolManager& mManager;
+		XmlNode* mCurrentNode;
+		XmlNode* mTopNode;
+		PxProfileArray<XmlNode*> mContext;
+		XmlNodeReader( XmlNode* inCurrentNode, PxAllocatorCallback& inAllocator, CMemoryPoolManager& nodePoolManager )
+			: mWrapper( inAllocator )
+			, mManager( nodePoolManager )
+			, mCurrentNode( inCurrentNode )
+			, mTopNode( inCurrentNode )
+			, mContext( mWrapper )
+		{
+		}
+
+		//Does this node exist as data in the format.
+		virtual bool read( const char* inName, const char*& outData )
+		{
+			XmlNode* theChild( mCurrentNode->findChildByName( inName ) );
+			if ( theChild )
+			{
+				outData = theChild->mData;
+				return outData && *outData;
+			}
+			return false;
+		}
+
+		virtual bool read( const char* inName, PxSerialObjectId& outId )
+		{
+			XmlNode* theChild( mCurrentNode->findChildByName( inName ) );
+			if ( theChild )
+			{
+				const char* theValue( theChild->mData );
+				strto( outId, theValue );
+				return true;
+			}
+			return false;
+		}
+
+		virtual bool gotoChild( const char* inName )
+		{
+			XmlNode* theChild( mCurrentNode->findChildByName( inName ) );
+			if ( theChild )
+			{
+				mCurrentNode =theChild;
+				return true;
+			}
+			return false;
+		}
+		virtual bool gotoFirstChild()
+		{
+			if ( mCurrentNode->mFirstChild )
+			{
+				mCurrentNode = mCurrentNode->mFirstChild;
+				return true;
+			}
+			return false;
+		}
+		virtual bool gotoNextSibling()
+		{
+			if ( mCurrentNode->mNextSibling )
+			{
+				mCurrentNode = mCurrentNode->mNextSibling;
+				return true;
+			}
+			return false;
+		}
+		virtual PxU32 countChildren()
+		{
+			PxU32 retval=  0;
+			for ( XmlNode* theChild = mCurrentNode->mFirstChild; theChild != NULL; theChild = theChild->mNextSibling )
+				++retval;
+			return retval;
+		}
+		virtual const char* getCurrentItemName()
+		{
+			return mCurrentNode->mName;
+		}
+		virtual const char* getCurrentItemValue()
+		{
+			return mCurrentNode->mData;
+		}
+
+		virtual bool leaveChild()
+		{
+			if ( mCurrentNode != mTopNode && mCurrentNode->mParent )
+			{
+				mCurrentNode = mCurrentNode->mParent;
+				return true;
+			}
+			return false;
+		}
+
+		virtual void pushCurrentContext()
+		{
+			mContext.pushBack( mCurrentNode );
+		}
+		virtual void popCurrentContext()
+		{
+			if ( mContext.size() )
+			{
+				mCurrentNode = mContext.back();
+				mContext.popBack();
+			}
+		}
+
+		virtual void setNode( XmlNode& inNode )
+		{
+			mContext.clear();
+			mCurrentNode = &inNode;
+			mTopNode = mCurrentNode;
+		}
+
+		virtual XmlReader* getParentReader()
+		{
+			XmlReader* retval = PX_PLACEMENT_NEW((mWrapper.getAllocator().allocate(sizeof(XmlNodeReader), "createNodeEditor",  __FILE__, __LINE__ )), XmlNodeReader) 
+				( mTopNode, mWrapper.getAllocator(), mManager );
+			return retval;
+		}
+
+		virtual void addOrGotoChild( const char* inName )
+		{
+			if ( gotoChild( inName )== false )
+			{
+				XmlNode* newNode = allocateRepXNode( &mManager, inName, NULL );
+				mCurrentNode->addChild( newNode );
+				mCurrentNode = newNode;
+			}
+		}
+		virtual void setCurrentItemValue( const char* inValue )
+		{
+			mCurrentNode->mData = copyStr( &mManager, inValue ); 
+		}
+		virtual bool removeChild( const char* name )
+		{
+			XmlNode* theChild( mCurrentNode->findChildByName( name ) );
+			if ( theChild )
+			{
+				releaseNodeAndChildren( &mManager, theChild );
+				return true;
+			}
+			return false;
+		}
+		virtual void release() { this->~XmlNodeReader(); mWrapper.getAllocator().deallocate(this); }
+
+	private:
+		XmlNodeReader& operator=(const XmlNodeReader&);
+	};
+
+	PX_INLINE void  freeNodeAndChildren( XmlNode* tempNode, TMemoryPoolManager& inManager )
+	{
+		for( XmlNode* theNode = tempNode->mFirstChild; theNode != NULL; theNode = theNode->mNextSibling )
+			freeNodeAndChildren( theNode, inManager );
+		tempNode->orphan();
+		release( &inManager, tempNode );
+	}
+
+	class XmlParser : public Ps::FastXml::Callback
+	{
+		XmlParseArgs			mParseArgs;
+		//For parse time only allocations
+		XmlMemoryAllocatorImpl& mParseAllocator;
+		XmlNode* mCurrentNode;
+		XmlNode* mTopNode;
+
+	public:
+		XmlParser( XmlParseArgs inArgs, XmlMemoryAllocatorImpl& inParseAllocator )
+			: mParseArgs( inArgs )
+			, mParseAllocator( inParseAllocator )
+			, mCurrentNode( NULL )
+			, mTopNode( NULL )
+		{
+		}
+
+		virtual ~XmlParser(){}
+
+		virtual bool processComment(const char* /*comment*/) { return true; }
+		// 'element' is the name of the element that is being closed.
+		// depth is the recursion depth of this element.
+		// Return true to continue processing the XML file.
+		// Return false to stop processing the XML file; leaves the read pointer of the stream right after this close tag.
+		// The bool 'isError' indicates whether processing was stopped due to an error, or intentionally canceled early.
+		virtual bool processClose(const char* /*element*/,physx::PxU32 /*depth*/,bool& /*isError*/)
+		{
+			mCurrentNode = mCurrentNode->mParent;
+			return true;
+		}
+
+		// return true to continue processing the XML document, false to skip.
+		virtual bool processElement(
+			const char *elementName,   // name of the element		
+			const char  *elementData,  // element data, null if none
+			const Ps::FastXml::AttributePairs& attr,      // attributes
+			PxI32 /*lineno*/)
+		{
+			XmlNode* newNode = allocateRepXNode( &mParseAllocator.mManager, elementName, elementData );
+			if ( mCurrentNode )
+				mCurrentNode->addChild( newNode );
+			mCurrentNode = newNode;
+			//Add the elements as children.
+			for( PxI32 item = 0; item < attr.getNbAttr(); item ++ )
+			{
+				XmlNode* node = allocateRepXNode( &mParseAllocator.mManager, attr.getKey(PxU32(item)), attr.getValue(PxU32(item)) );
+				mCurrentNode->addChild( node );
+			}
+			if ( mTopNode == NULL ) mTopNode = newNode;
+			return true;
+		}
+
+		XmlNode* getTopNode() { return mTopNode; }
+
+		virtual void *  allocate(PxU32 size)
+		{ 
+			if ( size )
+				return mParseAllocator.allocate(size);
+			return NULL; 
+		}
+		virtual void	deallocate(void *mem)
+		{ 
+			if ( mem )
+				mParseAllocator.deallocate(reinterpret_cast<PxU8*>(mem)); 
+		}
+
+	private:
+		XmlParser& operator=(const XmlParser&);
+	};
+
+	struct RepXCollectionSharedData
+	{
+		PxProfileAllocatorWrapper		mWrapper;
+		XmlMemoryAllocatorImpl			mAllocator;
+		PxU32							mRefCount;
+
+		RepXCollectionSharedData( PxAllocatorCallback& inAllocator )
+			: mWrapper( inAllocator )
+			, mAllocator( inAllocator )
+			, mRefCount( 0 )
+		{
+		}
+		~RepXCollectionSharedData() {}
+		
+		void addRef() { ++mRefCount;}
+		void release()
+		{
+			if ( mRefCount ) --mRefCount;
+			if ( !mRefCount ) { this->~RepXCollectionSharedData(); mWrapper.getAllocator().deallocate(this);} 
+		}
+	};
+
+	struct SharedDataPtr
+	{
+		RepXCollectionSharedData* mData;
+		SharedDataPtr( RepXCollectionSharedData* inData )
+			: mData( inData )
+		{
+			mData->addRef();
+		}
+		SharedDataPtr( const SharedDataPtr& inOther )
+			: mData( inOther.mData )
+		{
+			mData->addRef();
+		}
+		SharedDataPtr& operator=( const SharedDataPtr& inOther );
+		~SharedDataPtr()
+		{
+			mData->release();
+			mData = NULL;
+		}
+		RepXCollectionSharedData* operator->() { return mData; }
+		const RepXCollectionSharedData* operator->() const { return mData; }
+	};
+	
+	class RepXCollectionImpl : public RepXCollection, public Ps::UserAllocated
+	{
+		SharedDataPtr							mSharedData;
+
+		XmlMemoryAllocatorImpl&					mAllocator;
+		PxSerializationRegistry&				mSerializationRegistry;
+		PxProfileArray<RepXCollectionItem>		mCollection;
+		TMemoryPoolManager						mSerializationManager;
+		MemoryBuffer							mPropertyBuffer;
+		PxTolerancesScale						mScale;
+		PxVec3									mUpVector;
+		const char*								mVersionStr;
+		PxCollection*							mPxCollection;
+		
+	public:
+		RepXCollectionImpl( PxSerializationRegistry& inRegistry, PxAllocatorCallback& inAllocator, PxCollection& inPxCollection )
+			: mSharedData( &PX_NEW_REPX_SERIALIZER( RepXCollectionSharedData ))
+			, mAllocator( mSharedData->mAllocator )
+			, mSerializationRegistry( inRegistry )
+			, mCollection( mSharedData->mWrapper )
+			, mSerializationManager( inAllocator )
+			, mPropertyBuffer( &mSerializationManager )
+			, mUpVector( 0,0,0 )
+			, mVersionStr( getLatestVersion() )
+			, mPxCollection( &inPxCollection )
+		{
+			memset( &mScale, 0, sizeof( PxTolerancesScale ) );
+			PX_ASSERT( mScale.isValid() == false );
+		}
+
+		RepXCollectionImpl( PxSerializationRegistry& inRegistry, const RepXCollectionImpl& inSrc, const char* inNewVersion )
+			: mSharedData( inSrc.mSharedData )
+			, mAllocator( mSharedData->mAllocator )
+			, mSerializationRegistry( inRegistry )
+			, mCollection( mSharedData->mWrapper )
+			, mSerializationManager( mSharedData->mWrapper.getAllocator() )
+			, mPropertyBuffer( &mSerializationManager )
+			, mScale( inSrc.mScale )
+			, mUpVector( inSrc.mUpVector )
+			, mVersionStr( inNewVersion )
+			, mPxCollection( NULL )
+		{
+		}
+
+		virtual ~RepXCollectionImpl()
+		{
+			PxU32 numItems = mCollection.size();
+			for ( PxU32 idx = 0; idx < numItems; ++idx )
+			{
+				XmlNode* theNode = mCollection[idx].descriptor;
+				releaseNodeAndChildren( &mAllocator.mManager, theNode );
+			}
+		}
+		RepXCollectionImpl& operator=(const RepXCollectionImpl&);
+
+		virtual void destroy() 
+		{ 
+			PxProfileAllocatorWrapper tempWrapper( mSharedData->mWrapper.getAllocator() );
+			this->~RepXCollectionImpl();
+			tempWrapper.getAllocator().deallocate(this); 
+		}
+		
+		virtual void setTolerancesScale(const PxTolerancesScale& inScale) {  mScale = inScale; }
+		virtual PxTolerancesScale getTolerancesScale() const { return mScale; }
+		virtual void setUpVector( const PxVec3& inUpVector ) { mUpVector = inUpVector; }
+		virtual PxVec3 getUpVector() const { return mUpVector; }
+
+	
+		PX_INLINE RepXCollectionItem findItemBySceneItem( const PxRepXObject& inObject ) const
+		{
+			//See if the object is in the collection
+			for ( PxU32 idx =0; idx < mCollection.size(); ++idx )
+				if ( mCollection[idx].liveObject.serializable == inObject.serializable )
+					return mCollection[idx];
+			return RepXCollectionItem();
+		}
+
+		virtual RepXAddToCollectionResult addRepXObjectToCollection( const PxRepXObject& inObject, PxCollection* inCollection, PxRepXInstantiationArgs& inArgs )
+		{
+			PX_ASSERT( inObject.serializable );
+			PX_ASSERT( inObject.id );
+			if ( inObject.serializable == NULL || inObject.id == 0 )
+				return RepXAddToCollectionResult( RepXAddToCollectionResult::InvalidParameters );
+		
+			PxRepXSerializer* theSerializer = mSerializationRegistry.getRepXSerializer( inObject.typeName );
+			if ( theSerializer == NULL )
+				return RepXAddToCollectionResult( RepXAddToCollectionResult::SerializerNotFound );
+
+			RepXCollectionItem existing = findItemBySceneItem( inObject );
+			if ( existing.liveObject.serializable )
+				return RepXAddToCollectionResult( RepXAddToCollectionResult::AlreadyInCollection, existing.liveObject.id );
+			
+			XmlNodeWriter theXmlWriter( mAllocator, 1 );
+			XmlWriterImpl theRepXWriter( &theXmlWriter, &mPropertyBuffer );
+			{
+				SimpleXmlWriter::STagWatcher theWatcher( theXmlWriter, inObject.typeName );
+				writeProperty( theXmlWriter, mPropertyBuffer, "Id", inObject.id  );
+				theSerializer->objectToFile( inObject, inCollection, theRepXWriter, mPropertyBuffer,inArgs );
+			}
+			mCollection.pushBack( RepXCollectionItem( inObject, theXmlWriter.getTopNode() ) );
+			return RepXAddToCollectionResult( RepXAddToCollectionResult::Success, inObject.id );
+		}
+
+		virtual bool instantiateCollection( PxRepXInstantiationArgs& inArgs, PxCollection& inCollection )
+		{
+			for ( PxU32 idx =0; idx < mCollection.size(); ++idx )
+			{
+				RepXCollectionItem theItem( mCollection[idx] );
+				PxRepXSerializer* theSerializer = mSerializationRegistry.getRepXSerializer( theItem.liveObject.typeName );
+				if (theSerializer )				
+				{
+					XmlNodeReader theReader( theItem.descriptor, mAllocator.getAllocator(), mAllocator.mManager );
+					XmlMemoryAllocatorImpl instantiationAllocator( mAllocator.getAllocator() );
+					PxRepXObject theLiveObject = theSerializer->fileToObject( theReader, instantiationAllocator, inArgs, &inCollection );
+					if (theLiveObject.isValid())
+					{
+						const PxBase* s =  reinterpret_cast<const PxBase*>( theLiveObject.serializable ) ;
+                        inCollection.add( *const_cast<PxBase*>(s), PxSerialObjectId( theItem.liveObject.id ));
+                    }
+					else
+						return false;
+				}
+				else
+				{
+					Ps::getFoundation().error(PxErrorCode::eINTERNAL_ERROR, __FILE__, __LINE__, 
+						"PxSerialization::createCollectionFromXml: "
+						"PxRepXSerializer missing for type %s", theItem.liveObject.typeName);
+					return false;					
+				}				
+			}
+
+			return true;
+		}
+
+		void saveXmlNode( XmlNode* inNode, SimpleXmlWriter& inWriter )
+		{
+			XmlNode* theNode( inNode );
+			if ( theNode->mData && *theNode->mData && theNode->mFirstChild == NULL )
+				inWriter.writeContentTag( theNode->mName, theNode->mData );
+			else
+			{
+				inWriter.beginTag( theNode->mName );
+				if ( theNode->mData && *theNode->mData )
+					inWriter.addContent( theNode->mData );
+				for ( XmlNode* theChild = theNode->mFirstChild; 
+						theChild != NULL;
+						theChild = theChild->mNextSibling )
+					saveXmlNode( theChild, inWriter );
+				inWriter.endTag();
+			}
+		}
+
+		virtual void save( PxOutputStream& inStream )
+		{
+			SimpleXmlWriterImpl<PxOutputStream> theWriter( inStream, mAllocator.getAllocator() );
+			theWriter.beginTag( "PhysX30Collection" );
+			theWriter.addAttribute( "version", mVersionStr );
+			{
+				XmlWriterImpl theRepXWriter( &theWriter, &mPropertyBuffer );
+				writeProperty( theWriter, mPropertyBuffer, "UpVector", mUpVector );
+				theRepXWriter.addAndGotoChild( "Scale" );
+				writeAllProperties( &mScale, theRepXWriter, mPropertyBuffer, *mPxCollection);
+				theRepXWriter.leaveChild();
+			}
+			for ( PxU32 idx =0; idx < mCollection.size(); ++idx )
+			{
+				RepXCollectionItem theItem( mCollection[idx] );
+				XmlNode* theNode( theItem.descriptor );
+				saveXmlNode( theNode, theWriter );
+			}
+		}
+
+		void load( PxInputData& inFileBuf, SerializationRegistry& s )
+		{
+			inFileBuf.seek(0);
+			XmlParser theParser( XmlParseArgs( &mAllocator, &mCollection ), mAllocator );
+			Ps::FastXml* theFastXml = Ps::createFastXml( &theParser );
+			theFastXml->processXml( inFileBuf );
+			XmlNode* theTopNode = theParser.getTopNode();
+			if ( theTopNode != NULL )
+			{
+				{
+					
+					XmlMemoryAllocatorImpl instantiationAllocator( mAllocator.getAllocator() );
+					XmlNodeReader theReader( theTopNode, mAllocator.getAllocator(), mAllocator.mManager );
+					readProperty( theReader, "UpVector", mUpVector );
+					if ( theReader.gotoChild( "Scale" ) )
+					{
+						readAllProperties( PxRepXInstantiationArgs( s.getPhysics() ), theReader, &mScale, instantiationAllocator, *mPxCollection);
+						theReader.leaveChild();
+					}
+					const char* verStr = NULL;
+					if ( theReader.read( "version", verStr ) )
+						mVersionStr = verStr;
+				}
+				for ( XmlNode* theChild = theTopNode->mFirstChild; 
+						theChild != NULL;
+						theChild = theChild->mNextSibling )
+				{
+					if ( physx::shdfnd::stricmp( theChild->mName, "scale" ) == 0 
+						|| physx::shdfnd::stricmp( theChild->mName, "version" ) == 0 
+						|| physx::shdfnd::stricmp( theChild->mName, "upvector" ) == 0 )
+						continue;
+					XmlNodeReader theReader( theChild, mAllocator.getAllocator(), mAllocator.mManager );
+					PxRepXObject theObject;
+					theObject.typeName = theChild->mName;
+					theObject.serializable = NULL;
+					PxSerialObjectId theId = 0;
+					theReader.read( "Id", theId );
+					theObject.id = theId;
+					mCollection.pushBack( RepXCollectionItem( theObject, theChild ) );
+				}
+			}
+			else
+			{
+				Ps::getFoundation().error(PxErrorCode::eDEBUG_WARNING, __FILE__, __LINE__, 
+				"Cannot parse any object from the input buffer, please check the input repx data.");
+			}
+			theFastXml->release();
+		}
+		
+		virtual const char* getVersion() { return mVersionStr; }
+		
+		virtual const RepXCollectionItem* begin() const
+		{
+			return mCollection.begin();
+		}
+		virtual const RepXCollectionItem* end() const
+		{
+			return mCollection.end();
+		}
+		
+		virtual RepXCollection& createCollection( const char* inVersionStr )
+		{
+			PxAllocatorCallback& allocator = mSharedData->mWrapper.getAllocator(); 
+			RepXCollectionImpl* retval = PX_PLACEMENT_NEW((allocator.allocate(sizeof(RepXCollectionImpl), "createCollection",  __FILE__, __LINE__ )), RepXCollectionImpl) ( mSerializationRegistry, *this, inVersionStr );
+		
+			return *retval;
+		}
+		
+		//Performs a deep copy of the repx node.
+		virtual XmlNode* copyRepXNode( const XmlNode* srcNode ) 
+		{
+			return physx::Sn::copyRepXNode( &mAllocator.mManager, srcNode );
+		}
+
+		virtual void addCollectionItem( RepXCollectionItem inItem ) 
+		{
+			mCollection.pushBack( inItem );
+		}
+		
+		virtual PxAllocatorCallback& getAllocator() { return mSharedData->mAllocator.getAllocator(); }
+		//Create a new repx node with this name.  Its value is unset.
+		virtual XmlNode& createRepXNode( const char* name )
+		{
+			XmlNode* newNode = allocateRepXNode( &mSharedData->mAllocator.mManager, name, NULL );
+			return *newNode;
+		}
+
+		//Release this when finished.
+		virtual XmlReaderWriter& createNodeEditor()
+		{
+			PxAllocatorCallback& allocator = mSharedData->mWrapper.getAllocator(); 
+			XmlReaderWriter* retval = PX_PLACEMENT_NEW((allocator.allocate(sizeof(XmlNodeReader), "createNodeEditor",  __FILE__, __LINE__ )), XmlNodeReader) ( NULL, allocator, mAllocator.mManager );
+			return *retval;
+		}
+	};
+	
+	const char* RepXCollection::getLatestVersion()
+	{ 
+#define TOSTR_(x)   #x
+#define CONCAT_(a, b, c) TOSTR_(a.##b.##c)
+#define MAKE_VERSION_STR(a,b,c)  CONCAT_(a, b, c)
+
+		return MAKE_VERSION_STR(PX_PHYSICS_VERSION_MAJOR,PX_PHYSICS_VERSION_MINOR,PX_PHYSICS_VERSION_BUGFIX);
+
+	}
+
+	static RepXCollection* create(SerializationRegistry& s, PxAllocatorCallback& inAllocator, PxCollection& inCollection )
+	{
+		return PX_PLACEMENT_NEW((inAllocator.allocate(sizeof(RepXCollectionImpl), "RepXCollection::create",  __FILE__, __LINE__ )), RepXCollectionImpl) ( s, inAllocator, inCollection );
+	}
+
+	static RepXCollection* create(SerializationRegistry& s, PxInputData &data, PxAllocatorCallback& inAllocator, PxCollection& inCollection )
+	{			
+		RepXCollectionImpl* theCollection = static_cast<RepXCollectionImpl*>( create(s, inAllocator, inCollection ) );
+		theCollection->load( data, s );
+		return theCollection;
+	}
+}
+
+	bool PxSerialization::serializeCollectionToXml( PxOutputStream& outputStream, PxCollection& collection, PxSerializationRegistry& sr, PxCooking* cooking, const PxCollection* externalRefs, PxXmlMiscParameter* inArgs )
+	{
+		if( !PxSerialization::isSerializable(collection, sr, const_cast<PxCollection*>(externalRefs)) )
+			return false;
+		
+		bool bRet = true;
+
+		SerializationRegistry& sn = static_cast<SerializationRegistry&>(sr);
+		PxRepXInstantiationArgs args( sn.getPhysics(), cooking );
+
+		PxCollection* tmpCollection = PxCreateCollection();
+		PX_ASSERT(tmpCollection);
+
+		tmpCollection->add( collection );
+		if(externalRefs)
+		{
+			tmpCollection->add(*const_cast<PxCollection*>(externalRefs));
+		}
+		
+		PxAllocatorCallback& allocator = PxGetFoundation().getAllocatorCallback(); 
+		Sn::RepXCollection* theRepXCollection = Sn::create(sn, allocator, *tmpCollection );
+				
+		if(inArgs != NULL)
+		{
+			theRepXCollection->setTolerancesScale(inArgs->scale);
+			theRepXCollection->setUpVector(inArgs->upVector);
+		}		
+
+		PxU32 nbObjects = collection.getNbObjects();
+		if( nbObjects )
+		{
+			sortCollection( static_cast<Cm::Collection&>(collection), sn, true);
+
+            for( PxU32 i = 0; i < nbObjects; i++ )
+			{
+                PxBase& s = collection.getObject(i);
+				if( PxConcreteType::eSHAPE == s.getConcreteType() )
+				{
+					PxShape& shape = static_cast<PxShape&>(s);
+					if( shape.isExclusive() )
+						continue;
+				}
+				
+				PxSerialObjectId id = collection.getId(s);
+				if(id == PX_SERIAL_OBJECT_ID_INVALID)
+					id = static_cast<PxSerialObjectId>( reinterpret_cast<size_t>( &s ));
+				
+				PxRepXObject ro = PxCreateRepXObject( &s, id );
+				if ( ro.serializable == NULL || ro.id == 0 )
+				{
+					bRet = false;
+					break;
+				}
+					
+				theRepXCollection->addRepXObjectToCollection( ro, tmpCollection, args );				
+			}
+		}
+		tmpCollection->release();
+
+		theRepXCollection->save(outputStream);
+		theRepXCollection->destroy();
+		
+		
+		return bRet;
+	}
+	
+	PxCollection* PxSerialization::createCollectionFromXml(PxInputData& inputData, PxCooking& cooking, PxSerializationRegistry& sr, const PxCollection* externalRefs, PxStringTable* stringTable, PxXmlMiscParameter* outArgs)
+	{
+		SerializationRegistry& sn = static_cast<SerializationRegistry&>(sr);
+		PxCollection* collection = PxCreateCollection();
+		PX_ASSERT(collection);
+		
+		if( externalRefs )
+			collection->add(*const_cast<PxCollection*>(externalRefs));
+
+		PxAllocatorCallback& allocator = PxGetFoundation().getAllocatorCallback(); 
+		Sn::RepXCollection* theRepXCollection = Sn::create(sn, inputData, allocator, *collection);
+		theRepXCollection = &Sn::RepXUpgrader::upgradeCollection( *theRepXCollection );
+				
+		PxRepXInstantiationArgs args( sn.getPhysics(), &cooking, stringTable );  
+		if( !theRepXCollection->instantiateCollection(args, *collection) )
+		{
+			collection->release();
+			theRepXCollection->destroy();
+			return NULL;
+		}
+		
+		if( externalRefs )
+			collection->remove(*const_cast<PxCollection*>(externalRefs));
+		
+		if(outArgs != NULL)
+		{
+			outArgs->upVector = theRepXCollection->getUpVector();
+			outArgs->scale = theRepXCollection->getTolerancesScale();
+		}
+
+		theRepXCollection->destroy();
+		
+		return collection;
+	}
+} 
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlSerializer.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlSerializer.h
new file mode 100644
index 00000000..9effab4f
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlSerializer.h
@@ -0,0 +1,117 @@
+// 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_XML_SERIALIZER_H
+#define PX_XML_SERIALIZER_H
+
+#include "PxExtensionMetaDataObjects.h"
+#include "SnXmlVisitorWriter.h"
+
+namespace physx {
+
+namespace Sn {
+	
+	void writeHeightFieldSample( PxOutputStream& inStream, const PxHeightFieldSample& inSample )
+	{
+		PxU32 retval = 0;
+		PxU8* writePtr( reinterpret_cast< PxU8*>( &retval ) );
+		const PxU8* inPtr( reinterpret_cast<const PxU8*>( &inSample ) );
+		if ( isBigEndian() )
+		{
+			//Height field samples are a
+			//16 bit integer followed by two bytes.
+			//right now, data is 2 1 3 4
+			//We need a 32 bit integer that 
+			//when read in by a LE system is 4 3 2 1.
+			//Thus, we need a BE integer that looks like:
+			//4 3 2 1
+
+			writePtr[0] = inPtr[3];
+			writePtr[1] = inPtr[2];
+			writePtr[2] = inPtr[0];
+			writePtr[3] = inPtr[1];
+		}
+		else
+		{
+			writePtr[0] = inPtr[0];
+			writePtr[1] = inPtr[1];
+			writePtr[2] = inPtr[2];
+			writePtr[3] = inPtr[3];
+		}
+		inStream << retval;
+	}
+	
+	
+
+	template<typename TDataType, typename TWriteOperator>
+	inline void writeStridedBufferProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, const void* inData, PxU32 inStride, PxU32 inCount, PxU32 inItemsPerLine, TWriteOperator inOperator )
+	{
+		PX_ASSERT( inStride == 0 || inStride == sizeof( TDataType ) );
+		PX_UNUSED( inStride );
+		writeBuffer( writer, tempBuffer
+					, inItemsPerLine, reinterpret_cast<const TDataType*>( inData )
+					, inCount, inPropName, inOperator );
+	}
+
+	template<typename TDataType, typename TWriteOperator>
+	inline void writeStridedBufferProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, const PxStridedData& inData, PxU32 inCount, PxU32 inItemsPerLine, TWriteOperator inOperator )
+	{
+		writeStridedBufferProperty<TDataType>( writer, tempBuffer, inPropName, inData.data, inData.stride, inCount, inItemsPerLine, inOperator );
+	}
+	
+	template<typename TDataType, typename TWriteOperator>
+	inline void writeStridedBufferProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, const PxTypedStridedData<TDataType>& inData, PxU32 inCount, PxU32 inItemsPerLine, TWriteOperator inOperator )
+	{
+		writeStridedBufferProperty<TDataType>( writer, tempBuffer, inPropName, inData.data, inData.stride, inCount, inItemsPerLine, inOperator );
+	}
+	
+	template<typename TDataType, typename TWriteOperator>
+	inline void writeStridedBufferProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, const PxBoundedData& inData, PxU32 inItemsPerLine, TWriteOperator inWriteOperator )
+	{
+		writeStridedBufferProperty<TDataType>( writer, tempBuffer, inPropName, inData, inData.count, inItemsPerLine, inWriteOperator );
+	}
+
+	template<typename TDataType, typename TWriteOperator>
+	inline void writeStridedBufferProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, PxStrideIterator<const TDataType>& inData, PxU32 inCount, PxU32 inItemsPerLine, TWriteOperator inWriteOperator )
+	{
+		writeStrideBuffer<TDataType>(writer, tempBuffer
+					, inItemsPerLine, inData, PtrAccess<TDataType>
+					, inCount, inPropName, inData.stride(), inWriteOperator );
+	}
+
+	template<typename TDataType>
+	inline void writeStridedFlagsProperty( XmlWriter& writer, MemoryBuffer& tempBuffer, const char* inPropName, PxStrideIterator<const TDataType>& inData, PxU32 inCount, PxU32 inItemsPerLine, const PxU32ToName* inTable )
+	{
+		writeStrideFlags<TDataType>(writer, tempBuffer
+					, inItemsPerLine, inData, PtrAccess<TDataType>
+					, inCount, inPropName, inTable );
+	}
+	
+}
+}
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlSimpleXmlWriter.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlSimpleXmlWriter.h
new file mode 100644
index 00000000..7ee771b8
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlSimpleXmlWriter.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 PX_SIMPLEXMLWRITER_H
+#define PX_SIMPLEXMLWRITER_H
+
+#include "PsArray.h"
+#include "SnXmlMemoryPoolStreams.h"
+#include "CmPhysXCommon.h"
+
+namespace physx { namespace Sn {
+	class XmlWriter
+	{
+	public:
+		
+		struct STagWatcher
+		{
+			typedef XmlWriter TXmlWriterType;
+			TXmlWriterType& mWriter;
+			STagWatcher( const STagWatcher& inOther );
+			STagWatcher& operator-( const STagWatcher& inOther );
+			STagWatcher( TXmlWriterType& inWriter, const char* inTagName )
+				: mWriter( inWriter )
+			{
+				mWriter.beginTag( inTagName );
+			}
+			~STagWatcher() { mWriter.endTag(); }
+		};
+
+		virtual ~XmlWriter(){}
+		virtual void beginTag( const char* inTagname ) = 0;
+		virtual void endTag() = 0;
+		virtual void addAttribute( const char* inName, const char* inValue ) = 0;
+		virtual void writeContentTag( const char* inTag, const char* inContent ) = 0;
+		virtual void addContent( const char* inContent ) = 0;
+		virtual PxU32 tabCount() = 0;
+	};
+
+	template<typename TStreamType>
+	class XmlWriterImpl : public XmlWriter
+	{
+		PxProfileAllocatorWrapper mWrapper;
+		TStreamType& mStream;
+		XmlWriterImpl( const XmlWriterImpl& inOther );
+		XmlWriterImpl& operator=( const XmlWriterImpl& inOther );
+		PxProfileArray<const char*>	mTags;
+		bool								mTagOpen;
+		PxU32							mInitialTagDepth;
+	public:
+
+		XmlWriterImpl( TStreamType& inStream, PxAllocatorCallback& inAllocator, PxU32 inInitialTagDepth = 0 )
+			: mWrapper( inAllocator )
+			, mStream( inStream )
+			, mTags( mWrapper )
+			, mTagOpen( false )
+			, mInitialTagDepth( inInitialTagDepth )
+		{
+		}
+		virtual ~XmlWriterImpl()
+		{
+			while( mTags.size() )
+				endTag();
+		}
+		PxU32 tabCount() { return mTags.size() + mInitialTagDepth; }
+
+		void writeTabs( PxU32 inSize )
+		{
+			inSize += mInitialTagDepth;
+			for ( PxU32 idx =0; idx < inSize; ++idx )
+				mStream << "\t";
+		}
+		void beginTag( const char* inTagname )
+		{
+			closeTag();
+			writeTabs(mTags.size());
+			mTags.pushBack( inTagname );
+			mStream << "<" << inTagname;
+			mTagOpen = true;
+		}
+		void addAttribute( const char* inName, const char* inValue )
+		{
+			PX_ASSERT( mTagOpen );
+			mStream << " " << inName << "=" << "\"" << inValue << "\"";
+		}
+		void closeTag(bool useNewline = true)
+		{
+			if ( mTagOpen )
+			{
+				mStream << " " << ">";
+				if (useNewline )
+					mStream << "\n";
+			}
+			mTagOpen = false;
+		}
+		void doEndOpenTag()
+		{
+			mStream << "</" << mTags.back() << ">" << "\n";
+		}
+		void endTag()
+		{
+			PX_ASSERT( mTags.size() );
+			if ( mTagOpen )
+				mStream << " " << "/>" << "\n";
+			else
+			{
+				writeTabs(mTags.size()-1);
+				doEndOpenTag();
+			}
+			mTagOpen = false;
+			mTags.popBack();
+		}
+		void addContent( const char* inContent )
+		{
+			closeTag(false);
+			mStream << inContent;
+		}
+		void writeContentTag( const char* inTag, const char* inContent )
+		{
+			beginTag( inTag );
+			addContent( inContent );
+			doEndOpenTag();
+			mTags.popBack();
+		}
+		void insertXml( const char* inXml )
+		{
+			closeTag();
+			mStream << inXml;
+		}
+	};
+
+	struct BeginTag
+	{
+		const char* mTagName;
+		BeginTag( const char* inTagName )
+			: mTagName( inTagName ) { }
+	};
+
+	struct EndTag
+	{
+		EndTag() {}
+	};
+
+	struct Att
+	{
+		const char* mAttName;
+		const char* mAttValue;
+		Att( const char* inAttName, const char* inAttValue )
+			: mAttName( inAttName )
+			, mAttValue( inAttValue ) {	}
+	};
+
+	struct Content
+	{
+		const char* mContent;
+		Content( const char* inContent )
+			: mContent( inContent ) { }
+	};
+
+	
+	struct ContentTag
+	{
+		const char* mTagName;
+		const char* mContent;
+		ContentTag( const char* inTagName, const char* inContent )
+			: mTagName( inTagName )
+			, mContent( inContent ) { }
+	};
+
+	inline XmlWriter& operator<<( XmlWriter& inWriter, const BeginTag& inTag ) { inWriter.beginTag( inTag.mTagName ); return inWriter; }
+	inline XmlWriter& operator<<( XmlWriter& inWriter, const EndTag& inTag ) { inWriter.endTag(); return inWriter; }
+	inline XmlWriter& operator<<( XmlWriter& inWriter, const Att& inTag ) { inWriter.addAttribute(inTag.mAttName, inTag.mAttValue); return inWriter; }
+	inline XmlWriter& operator<<( XmlWriter& inWriter, const Content& inTag ) { inWriter.addContent(inTag.mContent); return inWriter; }
+	inline XmlWriter& operator<<( XmlWriter& inWriter, const ContentTag& inTag ) { inWriter.writeContentTag(inTag.mTagName, inTag.mContent); return inWriter; }
+
+	inline void writeProperty( XmlWriter& inWriter, MemoryBuffer& tempBuffer, const char* inPropName )
+	{
+		PxU8 data = 0;
+		tempBuffer.write( &data, sizeof(PxU8) );
+		inWriter.writeContentTag( inPropName, reinterpret_cast<const char*>( tempBuffer.mBuffer ) );
+		tempBuffer.clear();
+	}
+
+	template<typename TDataType>
+	inline void writeProperty( XmlWriter& inWriter, MemoryBuffer& tempBuffer, const char* inPropName, TDataType inValue )
+	{
+		tempBuffer << inValue;
+		writeProperty( inWriter, tempBuffer, inPropName );
+	}
+} }
+#endif
\ No newline at end of file
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlStringToType.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlStringToType.h
new file mode 100644
index 00000000..0361a2bf
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlStringToType.h
@@ -0,0 +1,275 @@
+// 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_XML_STRINGTOTYPE_H
+#define PX_XML_STRINGTOTYPE_H
+
+#include <stdio.h>
+#include <ctype.h>
+#include "PsString.h"
+#include "PxCoreUtilityTypes.h"
+#include "PxFiltering.h"
+
+//Remapping function name for gcc-based systems.
+#ifndef _MSC_VER
+#define _strtoui64 strtoull
+#endif
+
+
+namespace physx { namespace Sn {
+
+	template<typename TDataType>
+	struct StrToImpl
+	{
+		bool compile_error;
+	};
+
+	template<> struct StrToImpl<PxU64> { 
+		//Id's (void ptrs) are written to file as unsigned
+		//64 bit integers, so this method gets called more
+		//often than one might think.
+		PX_INLINE void strto( PxU64& ioDatatype,const char*& ioData )
+		{
+			ioDatatype = _strtoui64( ioData, const_cast<char **>(&ioData), 10 );
+		}
+	};
+
+	PX_INLINE PxF32 strToFloat(const char *str,const char **nextScan)
+	{
+		PxF32 ret;
+		while ( *str && isspace(static_cast<unsigned char>(*str))) str++; // skip leading whitespace
+		char temp[256] = "";
+		char *dest = temp;
+		char *end = &temp[255];
+		const char *begin = str;
+		while ( *str && !isspace(static_cast<unsigned char>(*str)) && dest < end ) // copy the number up to the first whitespace or eos
+		{
+			*dest++ = *str++;
+		}
+		*dest = 0;
+		ret = PxF32(strtod(temp,&end));
+		if ( nextScan )
+		{
+			*nextScan = begin+(end-temp);
+		}
+		return ret;
+	}
+	
+
+	template<> struct StrToImpl<PxU32> { 
+	PX_INLINE void strto( PxU32& ioDatatype,const char*& ioData )
+	{
+		ioDatatype = static_cast<PxU32>( strtoul( ioData,const_cast<char **>(&ioData), 10 ) );
+	}
+	};
+
+	template<> struct StrToImpl<PxI32> { 
+	PX_INLINE void strto( PxI32& ioDatatype,const char*& ioData )
+	{
+		ioDatatype = static_cast<PxI32>( strtoul( ioData,const_cast<char **>(&ioData), 10 ) );
+	}
+	};
+
+
+	template<> struct StrToImpl<PxU16> {
+	PX_INLINE void strto( PxU16& ioDatatype,const char*& ioData )
+	{
+		ioDatatype = static_cast<PxU16>( strtoul( ioData,const_cast<char **>(&ioData), 10 ) );
+	}
+	};
+
+	PX_INLINE void eatwhite(const char*& ioData )
+	{
+		if ( ioData )
+		{
+			while( isspace( static_cast<unsigned char>(*ioData) ) )
+				++ioData;
+		}
+	}
+
+	// copy the source data to the dest buffer until the first whitespace is encountered.
+	// Do not overflow the buffer based on the bufferLen provided.
+	// Advance the input 'ioData' pointer so that it sits just at the next whitespace
+	PX_INLINE void nullTerminateWhite(const char*& ioData,char *buffer,PxU32 bufferLen)
+	{
+		if ( ioData )
+		{
+			char *eof = buffer+(bufferLen-1);
+			char *dest = buffer;
+			while( *ioData && !isspace(static_cast<unsigned char>(*ioData)) && dest < eof )
+			{
+				*dest++ = *ioData++;
+			}
+			*dest = 0;
+		}
+	}
+
+	inline void nonNullTerminateWhite(const char*& ioData )
+	{
+		if ( ioData )
+		{
+			while( *ioData && !isspace( static_cast<unsigned char>(*ioData) ) )
+				++ioData;
+		}
+	}
+	
+	template<> struct StrToImpl<PxF32> {
+	inline void strto( PxF32& ioDatatype,const char*& ioData )
+	{
+		ioDatatype = strToFloat(ioData,&ioData); 
+	}
+	
+	};
+
+	
+	template<> struct StrToImpl<void*> {
+	inline void strto( void*& ioDatatype,const char*& ioData )
+	{
+		PxU64 theData;
+		StrToImpl<PxU64>().strto( theData, ioData );
+		ioDatatype = reinterpret_cast<void*>( static_cast<size_t>( theData ) );
+	}
+	};
+	
+
+	template<> struct StrToImpl<physx::PxVec3> {
+	inline void strto( physx::PxVec3& ioDatatype,const char*& ioData )
+	{
+		StrToImpl<PxF32>().strto( ioDatatype[0], ioData );
+		StrToImpl<PxF32>().strto( ioDatatype[1], ioData );
+		StrToImpl<PxF32>().strto( ioDatatype[2], ioData );
+	}
+	};
+	
+	template<> struct StrToImpl<PxU8*> {
+	inline void strto( PxU8*& /*ioDatatype*/,const char*& /*ioData*/)
+	{
+	}
+	};
+
+	template<> struct StrToImpl<bool> {
+	inline void strto( bool& ioType,const char*& inValue )
+	{
+		ioType = physx::shdfnd::stricmp( inValue, "true" ) == 0 ? true : false;
+	}
+	};
+	
+	template<> struct StrToImpl<PxU8> {
+	PX_INLINE void strto( PxU8& ioType,const char* & inValue)
+	{
+		ioType = static_cast<PxU8>( strtoul( inValue,const_cast<char **>(&inValue), 10 ) );
+	}
+	};
+
+	template<> struct StrToImpl<PxFilterData> {
+	PX_INLINE void strto( PxFilterData& ioType,const char*& inValue)
+	{
+		ioType.word0 = static_cast<PxU32>( strtoul( inValue,const_cast<char **>(&inValue), 10 ) );
+		ioType.word1 = static_cast<PxU32>( strtoul( inValue,const_cast<char **>(&inValue), 10 ) );
+		ioType.word2 = static_cast<PxU32>( strtoul( inValue,const_cast<char **>(&inValue), 10 ) );
+		ioType.word3 = static_cast<PxU32>( strtoul( inValue, NULL, 10 ) );
+	}
+	};
+	
+
+	template<> struct StrToImpl<PxQuat> {
+	PX_INLINE void strto( PxQuat& ioType,const char*& inValue )
+	{
+		ioType.x = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.y = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.z = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.w = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+	}
+	};
+	
+	template<> struct StrToImpl<PxTransform> {
+	PX_INLINE void strto( PxTransform& ioType,const char*& inValue)
+	{
+		ioType.q.x = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.q.y = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.q.z = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.q.w = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+
+		ioType.p[0] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.p[1] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.p[2] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+	}
+	};
+
+	template<> struct StrToImpl<PxBounds3> {
+	PX_INLINE void strto( PxBounds3& ioType,const char*& inValue)
+	{
+		ioType.minimum[0] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.minimum[1] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.minimum[2] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+
+		ioType.maximum[0] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.maximum[1] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.maximum[2] = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+	}
+	};
+	
+	template<> struct StrToImpl<PxMetaDataPlane> {
+	PX_INLINE void strto( PxMetaDataPlane& ioType,const char*& inValue)
+	{
+		ioType.normal.x = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.normal.y = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.normal.z = static_cast<PxReal>( strToFloat( inValue, &inValue ) );
+		ioType.distance = static_cast<PxReal>( strToFloat( inValue, &inValue ) );		
+	}
+	};
+
+	
+	template<> struct StrToImpl<PxRigidDynamic*> { 
+		PX_INLINE void strto( PxRigidDynamic*& /*ioDatatype*/,const char*& /*ioData*/)
+		{
+		}
+	};
+
+	template<typename TDataType>
+	inline void strto( TDataType& ioType,const char*& ioData )
+	{
+		if ( ioData && *ioData ) StrToImpl<TDataType>().strto( ioType, ioData );
+	}
+
+	template<typename TDataType>
+	inline void strtoLong( TDataType& ioType,const char*& ioData )
+	{
+		if ( ioData && *ioData ) StrToImpl<TDataType>().strto( ioType, ioData );
+	}
+
+	template<typename TDataType>
+	inline void stringToType( const char* inValue, TDataType& ioType )
+	{
+		const char* theValue( inValue );
+		return strto( ioType, theValue );
+	}
+
+} }
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlVisitorReader.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlVisitorReader.h
new file mode 100644
index 00000000..e003edf0
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlVisitorReader.h
@@ -0,0 +1,889 @@
+// 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_XML_VISITOR_READER_H
+#define PX_XML_VISITOR_READER_H
+
+#include "PsArray.h"
+#include "PsUtilities.h"
+#include "RepXMetaDataPropertyVisitor.h"
+#include "SnPxStreamOperators.h"
+#include "SnXmlMemoryPoolStreams.h"
+#include "SnXmlReader.h"
+#include "SnXmlImpl.h"
+#include "SnXmlMemoryAllocator.h"
+#include "SnXmlStringToType.h"
+
+namespace physx { namespace Sn {
+	
+	
+	inline PxU32 findEnumByName( const char* inName, const PxU32ToName* inTable )
+	{
+		for ( PxU32 idx = 0; inTable[idx].mName != NULL; ++idx )
+		{
+			if ( physx::shdfnd::stricmp( inTable[idx].mName, inName ) == 0 )
+				return inTable[idx].mValue;
+		}
+		return 0;
+	}
+
+	PX_INLINE void stringToFlagsType( const char* strData, XmlMemoryAllocator& alloc, PxU32& ioType, const PxU32ToName* inTable )
+	{
+		if ( inTable == NULL )
+			return;
+		ioType = 0;
+		if ( strData && *strData)
+		{
+			//Destructively parse the string to get out the different flags.
+			char* theValue = const_cast<char*>( copyStr( &alloc, strData ) );
+			char* theMarker = theValue;
+			char* theNext = theValue;
+			while( theNext && *theNext )
+			{
+				++theNext;
+				if( *theNext == '|' )
+				{
+					*theNext = 0;
+					++theNext;
+					ioType |= static_cast< PxU32 > ( findEnumByName( theMarker, inTable ) );
+					theMarker = theNext;
+				}
+			}
+			if ( theMarker && *theMarker )
+				ioType |= static_cast< PxU32 > ( findEnumByName( theMarker, inTable ) );
+			alloc.deallocate( reinterpret_cast<PxU8*>( theValue ) );
+		}
+	}
+
+	template<typename TDataType>
+	PX_INLINE void stringToEnumType( const char* strData, TDataType& ioType, const PxU32ToName* inTable )
+	{
+		ioType = static_cast<TDataType>( findEnumByName( strData, inTable ) );
+	}
+
+	template<typename TDataType>
+	PX_INLINE bool readProperty( XmlReader& inReader, const char* pname, TDataType& ioType )
+	{
+		const char* value;
+		if ( inReader.read( pname, value ) )
+		{
+			stringToType( value, ioType );
+			return true;
+		}
+		return false;
+	}
+	
+	template<typename TObjType>
+	inline TObjType* findReferencedObject( PxCollection& collection, PxSerialObjectId id)
+	{
+		PX_ASSERT(id > 0);
+		TObjType* outObject = static_cast<TObjType*>(const_cast<PxBase*>(collection.find(id)));
+		if (outObject == NULL)
+		{
+			Ps::getFoundation().error(PxErrorCode::eINVALID_PARAMETER, __FILE__, __LINE__, 
+				"PxSerialization::createCollectionFromXml: "
+				"Reference to ID %d cannot be resolved. Make sure externalRefs collection is specified if required and "
+				"check Xml file for completeness.",
+				id);
+		}
+		return outObject;
+	}
+
+	template<typename TObjType>
+	inline bool readReference( XmlReader& inReader, PxCollection& collection, TObjType*& outObject )
+	{
+		PxSerialObjectId theId;
+		const char* theValue = inReader.getCurrentItemValue();
+		strto( theId, theValue );
+		if( theId == 0)
+		{
+			// the NULL pointer is a valid pointer if the input id is 0
+			outObject = NULL;
+			return true;
+		}
+		else
+		{
+			outObject = findReferencedObject<TObjType>(collection, theId);
+			return outObject != NULL;
+		}
+	}
+	
+	template<typename TObjType>
+	inline bool readReference( XmlReader& inReader, PxCollection& inCollection, const char* pname, TObjType*& outObject )
+	{
+		outObject = NULL;
+		PxSerialObjectId theId = 0;
+		if (readProperty ( inReader, pname, theId ) && theId )
+		{
+			outObject = findReferencedObject<TObjType>(inCollection, theId);
+		}
+		// the NULL pointer is a valid pointer if the input id is 0
+		return (outObject != NULL) || 0 == theId;
+	}
+
+	template<typename TEnumType, typename TStorageType>
+	inline bool readFlagsProperty( XmlReader& reader, XmlMemoryAllocator& allocator, const char* pname, const PxU32ToName* inConversions, PxFlags<TEnumType,TStorageType>& outFlags )
+	{
+		const char* value;
+		if ( reader.read( pname, value ) )
+		{
+			PxU32 tempValue = 0;
+			stringToFlagsType( value, allocator, tempValue, inConversions );
+			outFlags = PxFlags<TEnumType,TStorageType>(Ps::to16(tempValue) );
+			return true;
+		}
+		return false;
+	}
+
+	template<typename TObjType, typename TReaderType, typename TInfoType>
+	inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj, TInfoType& info);
+	template<typename TObjType, typename TReaderType>
+	inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj);
+	
+	template<typename TReaderType, typename TGeomType>
+	inline PxGeometry* parseGeometry( TReaderType& reader, TGeomType& /*inGeom*/)
+	{	
+		PxAllocatorCallback& inAllocator = reader.mAllocator.getAllocator();
+		
+		TGeomType* shape = PX_PLACEMENT_NEW((inAllocator.allocate(sizeof(TGeomType), "parseGeometry",  __FILE__, __LINE__ )), TGeomType);
+		PxClassInfoTraits<TGeomType> info;
+		readComplexObj( reader, shape);
+		return shape;
+	}
+	
+
+	template<typename TReaderType>
+	inline void parseShape( TReaderType& visitor, PxGeometry*& outResult, Ps::Array<PxMaterial*>& outMaterials)
+	{
+		XmlReader& theReader( visitor.mReader );
+		PxCollection& collection = visitor.mCollection;
+		visitor.pushCurrentContext();
+		if ( visitor.gotoTopName() )
+		{
+			visitor.pushCurrentContext();
+			if ( visitor.gotoChild( "Materials" ) )
+			{
+				for( bool matSuccess = visitor.gotoFirstChild(); matSuccess;
+					matSuccess = visitor.gotoNextSibling() )
+				{
+					PxMaterial* material = NULL;					
+					if(!readReference<PxMaterial>( theReader, collection, material ))
+						visitor.mHadError = true;
+					if ( material ) 
+						outMaterials.pushBack( material );
+				}
+			}
+			visitor.popCurrentContext();
+			visitor.pushCurrentContext();
+
+			PxPlaneGeometry			plane;
+			PxHeightFieldGeometry	heightField;
+			PxSphereGeometry		sphere;
+			PxTriangleMeshGeometry	mesh;
+			PxConvexMeshGeometry	convex;
+			PxBoxGeometry			box;
+			PxCapsuleGeometry		capsule;
+			if ( visitor.gotoChild( "Geometry" ) )
+			{
+				if ( visitor.gotoFirstChild() )
+				{
+					const char* geomTypeName = visitor.getCurrentItemName();
+
+					if ( physx::shdfnd::stricmp( geomTypeName, "PxSphereGeometry" ) == 0 ) outResult = parseGeometry(visitor, sphere);
+					else if ( physx::shdfnd::stricmp( geomTypeName, "PxPlaneGeometry" ) == 0 ) outResult = parseGeometry(visitor, plane);
+					else if ( physx::shdfnd::stricmp( geomTypeName, "PxCapsuleGeometry" ) == 0 ) outResult = parseGeometry(visitor, capsule);
+					else if ( physx::shdfnd::stricmp( geomTypeName, "PxBoxGeometry" ) == 0 ) outResult = parseGeometry(visitor, box);
+					else if ( physx::shdfnd::stricmp( geomTypeName, "PxConvexMeshGeometry" ) == 0 ) outResult = parseGeometry(visitor, convex);
+					else if ( physx::shdfnd::stricmp( geomTypeName, "PxTriangleMeshGeometry" ) == 0 ) outResult = parseGeometry(visitor, mesh);
+					else if ( physx::shdfnd::stricmp( geomTypeName, "PxHeightFieldGeometry" ) == 0 ) outResult = parseGeometry(visitor, heightField);
+					else
+						PX_ASSERT( false );
+				}
+			}
+			visitor.popCurrentContext();
+		}
+		visitor.popCurrentContext();
+
+		return;
+	}
+
+	template<typename TReaderType, typename TObjType>
+	inline void readShapesProperty( TReaderType& visitor, TObjType* inObj, const PxRigidActorShapeCollection* inProp = NULL, bool isSharedShape = false )
+	{
+		PX_UNUSED(isSharedShape);
+		PX_UNUSED(inProp);
+
+		XmlReader& theReader( visitor.mReader );
+		PxCollection& collection( visitor.mCollection );
+
+		visitor.pushCurrentContext();
+		if ( visitor.gotoTopName() )
+		{
+			//uggh working around the shape collection api.
+			//read out materials and geometry
+			for ( bool success = visitor.gotoFirstChild(); success; 
+					success = visitor.gotoNextSibling() )
+			{
+				if( 0 == physx::shdfnd::stricmp( visitor.getCurrentItemName(), "PxShapeRef" ) )
+				{
+					PxShape* shape = NULL;
+					if(!readReference<PxShape>( theReader, collection, shape ))
+						visitor.mHadError = true;
+					if(shape)
+						inObj->attachShape( *shape );
+				}
+				else
+				{
+					Ps::Array<PxMaterial*> materials;
+					PxGeometry* geometry = NULL;
+					parseShape( visitor, geometry, materials);
+					PxShape* theShape = NULL;
+					if ( materials.size() )
+					{
+						theShape = visitor.mArgs.physics.createShape( *geometry, materials.begin(), Ps::to16(materials.size()), true );
+						if ( theShape )
+						{
+							readComplexObj( visitor, theShape );
+		          			
+					        if(theShape) 
+							{
+								inObj->attachShape(*theShape);						
+								collection.add( *theShape );
+							}
+						}
+					}
+
+					switch(geometry->getType())
+					{
+					case PxGeometryType::eSPHERE :
+						static_cast<PxSphereGeometry*>(geometry)->~PxSphereGeometry();
+						break;
+					case PxGeometryType::ePLANE :
+						static_cast<PxPlaneGeometry*>(geometry)->~PxPlaneGeometry();
+						break;
+					case PxGeometryType::eCAPSULE :
+						static_cast<PxCapsuleGeometry*>(geometry)->~PxCapsuleGeometry();
+						break;
+					case PxGeometryType::eBOX :
+						static_cast<PxBoxGeometry*>(geometry)->~PxBoxGeometry();
+						break;
+					case PxGeometryType::eCONVEXMESH :
+						static_cast<PxConvexMeshGeometry*>(geometry)->~PxConvexMeshGeometry();
+						break;
+					case PxGeometryType::eTRIANGLEMESH :
+						static_cast<PxTriangleMeshGeometry*>(geometry)->~PxTriangleMeshGeometry();
+						break;
+					case PxGeometryType::eHEIGHTFIELD :
+						static_cast<PxHeightFieldGeometry*>(geometry)->~PxHeightFieldGeometry();
+						break;
+
+					case PxGeometryType::eGEOMETRY_COUNT:
+					case PxGeometryType::eINVALID:
+						PX_ASSERT(0);			
+					}		
+					visitor.mAllocator.getAllocator().deallocate(geometry);
+				}				
+			}
+		}
+		visitor.popCurrentContext();
+	}
+
+	struct ReaderNameStackEntry : NameStackEntry
+	{
+		bool		mValid;
+		ReaderNameStackEntry( const char* nm, bool valid ) : NameStackEntry(nm), mValid(valid) {}
+	};
+
+	typedef PxProfileArray<ReaderNameStackEntry> TReaderNameStack;
+
+	template<typename TObjType>
+	struct RepXVisitorReaderBase
+	{
+
+	protected:
+		RepXVisitorReaderBase<TObjType>& operator=(const RepXVisitorReaderBase<TObjType>&);
+	public:
+		TReaderNameStack&		mNames;
+		PxProfileArray<PxU32>&	mContexts;
+		PxRepXInstantiationArgs	mArgs;
+		XmlReader&				mReader;
+		TObjType*				mObj;
+		XmlMemoryAllocator&		mAllocator;
+		PxCollection&			mCollection;		
+		bool					mValid;	
+		bool&                   mHadError;
+
+		RepXVisitorReaderBase( TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, TObjType* obj
+								, XmlMemoryAllocator&	alloc, PxCollection& collection, bool& hadError )
+			: mNames( names )
+			, mContexts( contexts )
+			, mArgs( args )
+			, mReader( reader )
+			, mObj( obj )
+			, mAllocator( alloc )
+			, mCollection( collection )
+			, mValid( true )
+			, mHadError(hadError)
+		{
+		}
+		RepXVisitorReaderBase( const RepXVisitorReaderBase& other )
+			: mNames( other.mNames )
+			, mContexts( other.mContexts )
+			, mArgs( other.mArgs )
+			, mReader( other.mReader )
+			, mObj( other.mObj )
+			, mAllocator( other.mAllocator )
+			, mCollection( other.mCollection )
+			, mValid( other.mValid )
+			, mHadError( other.mHadError )
+		{
+		}
+
+		
+		void pushName( const char* name )
+		{
+			gotoTopName();
+			mNames.pushBack( ReaderNameStackEntry( name, mValid ) );
+		}
+		void pushBracketedName( const char* name ) { pushName( name ); }
+		void popName()
+		{
+			if ( mNames.size() )
+			{
+				if ( mNames.back().mOpen && mNames.back().mValid )
+					mReader.leaveChild();
+				mNames.popBack();
+			}
+			mValid =true;
+			if ( mNames.size() && mNames.back().mValid == false )
+				mValid = false;
+		}
+
+		void pushCurrentContext()
+		{
+			mContexts.pushBack( static_cast<PxU32>( mNames.size() ) );
+		}
+		void popCurrentContext()
+		{
+			if ( mContexts.size() )
+			{
+				PxU32 depth = mContexts.back();
+				PX_ASSERT( mNames.size() >= depth );
+				while( mNames.size() > depth )
+					popName();
+				mContexts.popBack();
+			}
+		}
+
+		bool updateLastEntryAfterOpen()
+		{
+			mNames.back().mValid = mValid;
+			mNames.back().mOpen = mValid;
+			return mValid;
+		}
+
+		bool gotoTopName()
+		{
+			if ( mNames.size() && mNames.back().mOpen == false )
+			{
+				if ( mValid )
+					mValid = mReader.gotoChild( mNames.back().mName );
+				updateLastEntryAfterOpen();
+			}
+			return mValid;
+		}
+
+		bool isValid() const { return mValid; }
+
+		bool gotoChild( const char* name )
+		{
+			pushName( name );
+			return gotoTopName();
+		}
+
+		bool gotoFirstChild()
+		{
+			pushName( "__child" );
+			if ( mValid ) mValid = mReader.gotoFirstChild();
+			return updateLastEntryAfterOpen();
+		}
+
+		bool gotoNextSibling()
+		{
+			bool retval = mValid;
+			if ( mValid ) retval = mReader.gotoNextSibling();
+			return retval;
+		}
+
+		const char* getCurrentItemName() { if (mValid ) return mReader.getCurrentItemName(); return ""; }
+		
+		const char* topName() const
+		{
+			if ( mNames.size() ) return mNames.back().mName;
+			PX_ASSERT( false );
+			return "bad__repx__name";
+		}
+
+		const char* getCurrentValue()
+		{
+			const char* value = NULL;
+			if ( isValid() && mReader.read( topName(), value ) )
+				return value;
+			return NULL;
+		}
+
+		template<typename TDataType>
+		bool readProperty(TDataType& outType)
+		{
+			const char* value = getCurrentValue();
+			if ( value && *value )
+			{
+				stringToType( value, outType );
+				return true;
+			}
+			return false;
+		}
+
+		template<typename TDataType>
+		bool readExtendedIndexProperty(TDataType& outType)
+		{
+			const char* value = mReader.getCurrentItemValue();
+			if ( value && *value )
+			{
+				stringToType( value, outType );
+				return true;
+			}
+			return false;
+		}
+
+
+		template<typename TRefType>
+		bool readReference(TRefType*& outRef)
+		{
+			return physx::Sn::readReference<TRefType>( mReader, mCollection, topName(), outRef );
+		}
+		
+		inline bool readProperty(const char*& outProp )
+		{
+			outProp = "";
+			const char* value = getCurrentValue();
+			if ( value && *value && mArgs.stringTable )
+			{
+				outProp = mArgs.stringTable->allocateStr( value );
+				return true;
+			}
+			return false;
+		}
+
+		inline bool readProperty(PxConvexMesh*& outProp )
+		{
+			return readReference<PxConvexMesh>( outProp );
+		}
+		
+		inline bool readProperty(PxTriangleMesh*& outProp )
+		{
+			return readReference<PxTriangleMesh>( outProp );
+		}
+		inline bool readProperty(PxBVH33TriangleMesh*& outProp )
+		{
+			return readReference<PxBVH33TriangleMesh>( outProp );
+		}
+		inline bool readProperty(PxBVH34TriangleMesh*& outProp )
+		{
+			return readReference<PxBVH34TriangleMesh>( outProp );
+		}
+		
+		inline bool readProperty(PxHeightField*& outProp )
+		{
+			return readReference<PxHeightField>( outProp );
+		}
+
+		inline bool readProperty( PxRigidActor *& outProp )
+		{
+			return readReference<PxRigidActor>( outProp );
+		}
+
+		template<typename TAccessorType>
+		void simpleProperty( PxU32 /*key*/, TAccessorType& inProp )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			TPropertyType value;
+			if ( readProperty( value ) )
+				inProp.set( mObj, value );
+		}
+		
+		template<typename TAccessorType>
+		void enumProperty( PxU32 /*key*/, TAccessorType& inProp, const PxU32ToName* inConversions )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			const char* strVal = getCurrentValue();
+			if ( strVal && *strVal )
+			{
+				TPropertyType pval;
+				stringToEnumType( strVal, pval, inConversions );
+				inProp.set( mObj, pval );
+			}
+		}
+
+		template<typename TAccessorType>
+		void flagsProperty( PxU32 /*key*/, const TAccessorType& inProp, const PxU32ToName* inConversions )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			typedef typename TPropertyType::InternalType TInternalType;
+
+			const char* strVal = getCurrentValue();
+			if ( strVal && *strVal )
+			{
+				PxU32 tempValue = 0;
+				stringToFlagsType( strVal, mAllocator, tempValue, inConversions );
+				inProp.set( mObj, TPropertyType(TInternalType( tempValue )));
+			}
+		}
+	
+		template<typename TAccessorType, typename TInfoType>
+		void complexProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			if ( gotoTopName() )
+			{
+				TPropertyType propVal = inProp.get( mObj );
+				readComplexObj( *this, &propVal, inInfo );
+				inProp.set( mObj, propVal );
+			}
+		}
+		
+		template<typename TAccessorType, typename TInfoType>
+		void bufferCollectionProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			Ps::InlineArray<TPropertyType,5> theData;
+	
+			this->pushCurrentContext();
+			if (  this->gotoTopName() )
+			{
+				for ( bool success =  this->gotoFirstChild(); success; 
+						success =  this->gotoNextSibling() )
+				{
+					TPropertyType propVal;
+					readComplexObj( *this, &propVal, inInfo );
+					theData.pushBack(propVal);
+				}	
+			}
+			this->popCurrentContext();
+
+			inProp.set( mObj, theData.begin(), theData.size() );
+			
+		}
+		
+		template<typename TAccessorType, typename TInfoType>
+		void extendedIndexedProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+		
+			this->pushCurrentContext();
+			if (  this->gotoTopName() )
+			{
+				PxU32 index = 0;
+				for ( bool success =  this->gotoFirstChild(); success; 
+						success =  this->gotoNextSibling() )
+				{
+					TPropertyType propVal;
+					readComplexObj( *this, &propVal, inInfo );
+					inProp.set(mObj, index, propVal);
+					++index;
+				}	
+			}
+			this->popCurrentContext();
+		}
+		
+		template<typename TAccessorType, typename TInfoType>
+		void PxFixedSizeLookupTableProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			const_cast<TAccessorType&>(inProp).clear( mObj );
+
+			this->pushCurrentContext();
+			if (  this->gotoTopName() )
+			{
+				for ( bool success =  this->gotoFirstChild(); success; 
+						success =  this->gotoNextSibling() )
+				{
+					TPropertyType propXVal;
+					readComplexObj( *this, &propXVal, inInfo );
+					
+					if(this->gotoNextSibling())
+					{
+						TPropertyType propYVal;
+						readComplexObj( *this, &propYVal, inInfo );
+						const_cast<TAccessorType&>(inProp).addPair(mObj, propXVal, propYVal);
+					}					
+				}	
+			}
+			this->popCurrentContext();
+		}
+
+		void handleShapes( const PxRigidActorShapeCollection& inProp )
+		{
+			physx::Sn::readShapesProperty( *this, mObj, &inProp );		
+		}
+	};
+	
+	template<typename TObjType>
+	struct RepXVisitorReader : public RepXVisitorReaderBase<TObjType>
+	{
+		RepXVisitorReader( TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, TObjType* obj
+								, XmlMemoryAllocator&	alloc, PxCollection& collection, bool& ret)
+			: RepXVisitorReaderBase<TObjType>( names, contexts, args, reader, obj, alloc, collection, ret)
+		{
+		}
+		RepXVisitorReader( const RepXVisitorReader<TObjType>& other )
+			: RepXVisitorReaderBase<TObjType>( other )
+		{
+		}
+	};
+
+	// Specialized template to load dynamic rigid, to determine the kinematic state first
+	template<>
+	struct RepXVisitorReader<PxRigidDynamic> : public RepXVisitorReaderBase<PxRigidDynamic>
+	{
+		RepXVisitorReader( TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, PxRigidDynamic* obj
+								, XmlMemoryAllocator&	alloc, PxCollection& collection, bool& ret)
+			: RepXVisitorReaderBase<PxRigidDynamic>( names, contexts, args, reader, obj, alloc, collection, ret)
+		{
+		}
+		RepXVisitorReader( const RepXVisitorReader<PxRigidDynamic>& other )
+			: RepXVisitorReaderBase<PxRigidDynamic>( other )
+		{
+		}
+
+		void handleShapes( const PxRigidActorShapeCollection& inProp )
+		{
+			// Need to read the parental actor to check if actor is kinematic
+			// in that case we need to apply the kinematic flag before a shape is set
+			XmlReaderWriter* parentReader = static_cast<XmlReaderWriter*>(mReader.getParentReader());
+			if(mObj)
+			{
+				const char* value;
+				if (parentReader->read( "RigidBodyFlags", value ))
+				{
+					if(strstr(value, "eKINEMATIC"))
+					{						
+						mObj->setRigidBodyFlag(PxRigidBodyFlag::eKINEMATIC, true);
+					}
+				}
+			}
+			physx::Sn::readShapesProperty( *this, mObj, &inProp );		
+			parentReader->release();
+		}
+
+
+		template<typename TAccessorType>
+		void simpleProperty( PxU32 /*key*/, TAccessorType& inProp )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			TPropertyType value;
+			if (readProperty(value))
+			{
+				// If the rigid body is kinematic, we cannot set the LinearVelocity or AngularVelocity
+				const bool kinematic = (mObj->getRigidBodyFlags() & PxRigidBodyFlag::eKINEMATIC);
+				if(kinematic && (inProp.mProperty.mKey == PxPropertyInfoName::PxRigidBody_LinearVelocity || inProp.mProperty.mKey == PxPropertyInfoName::PxRigidBody_AngularVelocity))
+					return;
+
+				inProp.set(mObj, value );
+			}
+		}
+	private:		
+		RepXVisitorReader<PxRigidDynamic>& operator=(const  RepXVisitorReader<PxRigidDynamic>&);			
+	};
+	
+	template<>
+	struct RepXVisitorReader<PxShape> : public RepXVisitorReaderBase<PxShape>
+	{
+		RepXVisitorReader( TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, PxShape* obj
+								, XmlMemoryAllocator&	alloc, PxCollection& collection, bool& ret )
+			: RepXVisitorReaderBase<PxShape>( names, contexts, args, reader, obj, alloc, collection, ret )
+		{
+		}
+		RepXVisitorReader( const RepXVisitorReader<PxShape>& other )
+			: RepXVisitorReaderBase<PxShape>( other )
+		{
+		}
+		void handleShapeMaterials( const PxShapeMaterialsProperty& ) //these were handled during construction.
+		{
+		}
+		void handleGeometryProperty( const PxShapeGeometryProperty& )
+		{
+		}
+	private:
+		 RepXVisitorReader<PxShape>& operator=(const  RepXVisitorReader<PxShape>&);
+	};
+
+	template<>
+	struct RepXVisitorReader<PxArticulationLink> : public RepXVisitorReaderBase<PxArticulationLink>
+	{
+		RepXVisitorReader( TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, PxArticulationLink* obj
+								, XmlMemoryAllocator&	alloc, PxCollection& collection, bool& ret )
+			: RepXVisitorReaderBase<PxArticulationLink>( names, contexts, args, reader, obj, alloc, collection, ret )
+		{
+		}
+		RepXVisitorReader( const RepXVisitorReader<PxArticulationLink>& other )
+			: RepXVisitorReaderBase<PxArticulationLink>( other )
+		{
+		}
+		void handleIncomingJoint( const TIncomingJointPropType& prop )
+		{
+			pushName( "Joint" );
+			if ( gotoTopName() )
+			{
+				PxArticulationJoint* theJoint( prop.get( mObj ) );
+				readComplexObj( *this, theJoint );
+				
+				//Add joint to PxCollection, since PxArticulation requires PxArticulationLink and joint.
+				mCollection.add( *theJoint );
+			}
+			popName();
+		}
+	private:
+		RepXVisitorReader<PxArticulationLink>& operator=(const RepXVisitorReader<PxArticulationLink>&);
+	};
+	
+	inline void readProperty( RepXVisitorReaderBase<PxArticulation>& inSerializer, PxArticulation* inObj, const PxArticulationLinkCollectionProp& /*inProp*/)
+	{
+		PxProfileAllocatorWrapper theWrapper( inSerializer.mAllocator.getAllocator() );
+		PxCollection& collection( inSerializer.mCollection );
+
+		TArticulationLinkLinkMap linkRemapMap( theWrapper );
+		inSerializer.pushCurrentContext();
+		if( inSerializer.gotoTopName() )
+		{
+			for ( bool links = inSerializer.gotoFirstChild();
+				links != false;
+				links = inSerializer.gotoNextSibling() )
+			{
+				//Need enough information to create the link...
+				PxSerialObjectId theParentPtr = 0;
+				const PxArticulationLink* theParentLink = NULL;
+				if ( inSerializer.mReader.read( "Parent", theParentPtr ) )
+				{
+					const TArticulationLinkLinkMap::Entry* theRemappedParent( linkRemapMap.find( theParentPtr ) );
+					//If we have a valid at write time, we had better have a valid parent at read time.
+					PX_ASSERT( theRemappedParent );
+					theParentLink = theRemappedParent->second;
+				}
+				PxArticulationLink* newLink = inObj->createLink( const_cast<PxArticulationLink*>( theParentLink ), PxTransform(PxIdentity) );
+				PxSerialObjectId theIdPtr = 0;
+				inSerializer.mReader.read( "Id", theIdPtr );
+
+				linkRemapMap.insert( theIdPtr, newLink );
+				readComplexObj( inSerializer, newLink );
+				
+				//Add link to PxCollection, since PxArticulation requires PxArticulationLink and joint.
+				collection.add( *newLink, theIdPtr );
+			}
+		}
+		inSerializer.popCurrentContext();
+	}
+	
+	template<>
+	struct RepXVisitorReader<PxArticulation> : public RepXVisitorReaderBase<PxArticulation>
+	{
+		RepXVisitorReader( TReaderNameStack& names, PxProfileArray<PxU32>& contexts, const PxRepXInstantiationArgs& args, XmlReader& reader, PxArticulation* obj
+								, XmlMemoryAllocator&	alloc, PxCollection& collection, bool& ret)
+			: RepXVisitorReaderBase<PxArticulation>( names, contexts, args, reader, obj, alloc, collection, ret)
+		{
+		}
+		RepXVisitorReader( const RepXVisitorReader<PxArticulation>& other )
+			: RepXVisitorReaderBase<PxArticulation>( other )
+		{
+		}
+		
+		void handleArticulationLinks( const PxArticulationLinkCollectionProp& inProp )
+		{
+			physx::Sn::readProperty( *this, mObj, inProp );
+		}
+	};
+
+	template<typename TObjType, typename TInfoType>
+	inline bool readAllProperties( PxRepXInstantiationArgs args, TReaderNameStack& names, PxProfileArray<PxU32>& contexts, XmlReader& reader, TObjType* obj, XmlMemoryAllocator& alloc, PxCollection& collection, TInfoType& info )
+	{
+		bool hadError = false;
+		RepXVisitorReader<TObjType> theReader( names, contexts, args, reader, obj, alloc, collection, hadError);
+		RepXPropertyFilter<RepXVisitorReader<TObjType> > theOp( theReader );
+		info.visitBaseProperties( theOp );
+		info.visitInstanceProperties( theOp );
+		return !hadError;
+	}
+
+	
+	template<typename TObjType>
+	inline bool readAllProperties( PxRepXInstantiationArgs args, XmlReader& reader, TObjType* obj, XmlMemoryAllocator& alloc, PxCollection& collection )
+	{
+		PxProfileAllocatorWrapper wrapper( alloc.getAllocator() );
+		TReaderNameStack names( wrapper );
+		PxProfileArray<PxU32> contexts( wrapper );
+		PxClassInfoTraits<TObjType> info;
+		return readAllProperties( args, names, contexts, reader, obj, alloc, collection, info.Info );
+	}
+	
+	template<typename TObjType, typename TReaderType, typename TInfoType>
+	inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj, TInfoType& info)
+	{
+		if(!readAllProperties( oldVisitor.mArgs, oldVisitor.mNames, oldVisitor.mContexts, oldVisitor.mReader, inObj, oldVisitor.mAllocator, oldVisitor.mCollection, info ))
+			oldVisitor.mHadError = true;
+	}
+
+	template<typename TObjType, typename TReaderType, typename TInfoType>
+	inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj, const TInfoType& info)
+	{
+		if(!readAllProperties( oldVisitor.mArgs, oldVisitor.mNames, oldVisitor.mContexts, oldVisitor.mReader, inObj, oldVisitor.mAllocator, oldVisitor.mCollection, info ))
+			oldVisitor.mHadError = true;
+	}
+
+	template<typename TObjType, typename TReaderType>
+	inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj, const PxUnknownClassInfo& /*info*/)
+	{
+		const char* value = oldVisitor.mReader.getCurrentItemValue();
+		if ( value && *value )
+		{
+			stringToType( value, *inObj );
+			return;
+		}
+		oldVisitor.mHadError = true;		
+	}
+
+	template<typename TObjType, typename TReaderType>
+	inline void readComplexObj( TReaderType& oldVisitor, TObjType* inObj)
+	{
+		PxClassInfoTraits<TObjType> info;
+		if(!readAllProperties( oldVisitor.mArgs, oldVisitor.mNames, oldVisitor.mContexts, oldVisitor.mReader, inObj, oldVisitor.mAllocator, oldVisitor.mCollection, info.Info ))
+			oldVisitor.mHadError = true;
+	}
+
+} }
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlVisitorWriter.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlVisitorWriter.h
new file mode 100644
index 00000000..76bf66cd
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlVisitorWriter.h
@@ -0,0 +1,765 @@
+// 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_XML_VISITOR_WRITER_H
+#define PX_XML_VISITOR_WRITER_H
+
+#include "PsInlineArray.h"
+#include "CmPhysXCommon.h"
+#include "RepXMetaDataPropertyVisitor.h"
+#include "SnPxStreamOperators.h"
+#include "SnXmlMemoryPoolStreams.h"
+#include "SnXmlWriter.h"
+#include "SnXmlImpl.h"
+#include "PsFoundation.h"
+
+namespace physx { namespace Sn {
+
+	template<typename TDataType>
+	inline void writeReference( XmlWriter& writer, PxCollection& inCollection, const char* inPropName, const TDataType* inDatatype )
+	{
+		const PxBase* s =  static_cast<const PxBase*>( inDatatype ) ;
+		if( inDatatype && !inCollection.contains( *const_cast<PxBase*>(s) ))
+		{
+			Ps::getFoundation().error(PxErrorCode::eINTERNAL_ERROR, __FILE__, __LINE__,
+				"PxSerialization::serializeCollectionToXml: Reference \"%s\" could not be resolved.", inPropName);
+		}
+		
+		PxSerialObjectId theId = 0;
+		if( s )
+		{
+			theId = inCollection.getId( *s );
+			if( theId == 0 )
+				theId = PX_PROFILE_POINTER_TO_U64( inDatatype );
+		}	
+		
+		writer.write( inPropName, PxCreateRepXObject( inDatatype, theId ) );
+	}
+
+	inline void writeProperty( XmlWriter& inWriter, MemoryBuffer& inBuffer, const char* inProp )
+	{
+		PxU8 data = 0;
+		inBuffer.write( &data, sizeof(PxU8) );
+		inWriter.write( inProp, reinterpret_cast<const char*>( inBuffer.mBuffer ) );
+		inBuffer.clear();
+	}
+
+	template<typename TDataType>
+	inline void writeProperty( XmlWriter& inWriter, PxCollection&, MemoryBuffer& inBuffer, const char* inPropName, TDataType inValue )
+	{
+		inBuffer << inValue;
+		writeProperty( inWriter, inBuffer, inPropName );
+	}
+	
+	inline void writeProperty( XmlWriter& writer,  PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxConvexMesh* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxConvexMesh* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+#ifdef REMOVED
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxTriangleMesh* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+	
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxTriangleMesh* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+#endif
+
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxBVH33TriangleMesh* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+	
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxBVH33TriangleMesh* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxBVH34TriangleMesh* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+	
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxBVH34TriangleMesh* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxHeightField* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxHeightField* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, const PxRigidActor* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxArticulation* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+	
+	inline void writeProperty( XmlWriter& writer, PxCollection& inCollection, MemoryBuffer& /*inBuffer*/, const char* inPropName, PxRigidActor* inDatatype )
+	{
+		writeReference( writer, inCollection, inPropName, inDatatype );
+	}
+
+	inline void writeFlagsProperty( XmlWriter& inWriter, MemoryBuffer& tempBuf, const char* inPropName, PxU32 inFlags, const PxU32ToName* inTable )
+	{
+		if ( inTable )
+		{
+			PxU32 flagValue( inFlags );
+			if ( flagValue )
+			{
+				for ( PxU32 idx =0; inTable[idx].mName != NULL; ++idx )
+				{
+					if ( (inTable[idx].mValue & flagValue) == inTable[idx].mValue )
+					{
+						if ( tempBuf.mWriteOffset != 0 )
+							tempBuf << "|";
+						tempBuf << inTable[idx].mName;
+					}
+				}
+				writeProperty( inWriter, tempBuf, inPropName );
+			}
+		}
+	}
+
+	inline void writeFlagsBuffer( MemoryBuffer& tempBuf, PxU32 flagValue, const PxU32ToName* inTable )
+	{
+		PX_ASSERT(inTable);
+		bool added = false;
+
+		if ( flagValue )
+		{					
+			for ( PxU32 item =0; inTable[item].mName != NULL; ++item )
+			{
+				if ( (inTable[item].mValue & flagValue) != 0 )
+				{
+					if ( added )
+						tempBuf << "|";
+					tempBuf << inTable[item].mName;
+					added = true;
+				}
+			}	
+		}
+	}
+
+	inline void writePxVec3( PxOutputStream& inStream, const PxVec3& inVec ) { inStream << inVec; }
+	
+
+	template<typename TDataType>
+	inline const TDataType& PtrAccess( const TDataType* inPtr, PxU32 inIndex )
+	{
+		return inPtr[inIndex];
+	}
+	
+	template<typename TDataType>
+	inline void BasicDatatypeWrite( PxOutputStream& inStream, const TDataType& item ) { inStream << item; }
+	
+	template<typename TObjType, typename TAccessOperator, typename TWriteOperator>
+	inline void writeBuffer( XmlWriter& inWriter, MemoryBuffer& inTempBuffer
+							, PxU32 inObjPerLine, const TObjType* inObjType, TAccessOperator inAccessOperator
+							, PxU32 inBufSize, const char* inPropName, TWriteOperator inOperator )
+	{
+		if ( inBufSize && inObjType )
+		{
+			for ( PxU32 idx = 0; idx < inBufSize; ++idx )
+			{
+				if ( idx && ( idx % inObjPerLine == 0 ) )
+					inTempBuffer << "\n\t\t\t";
+				else
+					inTempBuffer << " ";
+				inOperator( inTempBuffer, inAccessOperator( inObjType, idx ) );
+			}
+			writeProperty( inWriter, inTempBuffer, inPropName );
+		}
+	}
+
+	template<typename TDataType, typename TAccessOperator, typename TWriteOperator>
+	inline void writeStrideBuffer( XmlWriter& inWriter, MemoryBuffer& inTempBuffer
+							, PxU32 inObjPerLine, PxStrideIterator<const TDataType>& inData, TAccessOperator inAccessOperator
+							, PxU32 inBufSize, const char* inPropName, PxU32 /*inStride*/, TWriteOperator inOperator )
+	{
+		if ( inBufSize && &inData[0])
+		{
+			for ( PxU32 idx = 0; idx < inBufSize; ++idx )
+			{
+				if ( idx && ( idx % inObjPerLine == 0 ) )
+					inTempBuffer << "\n\t\t\t";
+				else
+					inTempBuffer << " ";
+				
+				inOperator( inTempBuffer, inAccessOperator( &inData[idx], 0  ) );
+			}
+			writeProperty( inWriter, inTempBuffer, inPropName );
+		}
+	}
+	
+
+	template<typename TDataType, typename TAccessOperator>
+	inline void writeStrideFlags( XmlWriter& inWriter, MemoryBuffer& inTempBuffer
+							, PxU32 inObjPerLine, PxStrideIterator<const TDataType>& inData, TAccessOperator /*inAccessOperator*/
+							, PxU32 inBufSize, const char* inPropName, const PxU32ToName* inTable)
+	{		
+		if ( inBufSize && &inData[0])
+		{
+			for ( PxU32 idx = 0; idx < inBufSize; ++idx )
+			{	
+				writeFlagsBuffer(inTempBuffer, inData[idx], inTable);
+
+				if ( idx && ( idx % inObjPerLine == 0 ) )
+					inTempBuffer << "\n\t\t\t";
+				else
+					inTempBuffer << " ";
+			}
+			writeProperty( inWriter, inTempBuffer, inPropName );
+		}
+	}
+
+	template<typename TDataType, typename TWriteOperator>
+	inline void writeBuffer( XmlWriter& inWriter, MemoryBuffer& inTempBuffer
+							, PxU32 inObjPerLine, const TDataType* inBuffer
+							, PxU32 inBufSize, const char* inPropName, TWriteOperator inOperator )
+	{
+		writeBuffer( inWriter, inTempBuffer, inObjPerLine, inBuffer, PtrAccess<TDataType>, inBufSize, inPropName, inOperator );
+	}
+
+	template<typename TEnumType>
+	inline void writeEnumProperty( XmlWriter& inWriter, const char* inPropName, TEnumType inEnumValue, const PxU32ToName* inConversions )
+	{
+		PxU32 theValue = static_cast<PxU32>( inEnumValue );
+		for ( const PxU32ToName* conv = inConversions; conv->mName != NULL; ++conv )
+			if ( conv->mValue == theValue ) inWriter.write( inPropName, conv->mName );
+	}
+	
+	
+		
+	template<typename TObjType, typename TWriterType, typename TInfoType>
+	inline void handleComplexObj( TWriterType& oldVisitor, const TObjType* inObj, TInfoType& info);
+
+	template<typename TCollectionType, typename TVisitor, typename TPropType, typename TInfoType >
+	void handleComplexCollection( TVisitor& visitor, const TPropType& inProp, const char* childName, TInfoType& inInfo )
+	{
+		PxU32 count( inProp.size( visitor.mObj ) );
+		if ( count )
+		{
+			Ps::InlineArray<TCollectionType*,5> theData;
+			theData.resize( count );
+			inProp.get( visitor.mObj, theData.begin(), count );
+			for( PxU32 idx =0; idx < count; ++idx )
+			{
+				visitor.pushName( childName );
+				handleComplexObj( visitor, theData[idx], inInfo );
+				visitor.popName();
+			}
+		}
+	}
+
+	template<typename TCollectionType, typename TVisitor, typename TPropType, typename TInfoType >
+	void handleBufferCollection( TVisitor& visitor, const TPropType& inProp, const char* childName, TInfoType& inInfo )
+	{
+		PxU32 count( inProp.size( visitor.mObj ) );
+		if ( count )
+		{
+			Ps::InlineArray<TCollectionType*,5> theData;
+			theData.resize( count );
+			inProp.get( visitor.mObj, theData.begin());
+
+			for( PxU32 idx =0; idx < count; ++idx )
+			{
+				visitor.pushName( childName );
+				handleComplexObj( visitor, theData[idx], inInfo );
+				visitor.popName();
+			}
+		}
+	}
+
+	template<typename TVisitor>
+	void handleShapes( TVisitor& visitor, const PxRigidActorShapeCollection& inProp )
+	{
+		PxShapeGeneratedInfo theInfo;
+		
+		PxU32 count( inProp.size( visitor.mObj ) );
+		if ( count )
+		{
+			Ps::InlineArray<PxShape*,5> theData;
+			theData.resize( count );
+			inProp.get( visitor.mObj, theData.begin(), count );
+			for( PxU32 idx = 0; idx < count; ++idx )
+			{
+				const PxShape* shape = theData[idx];
+				visitor.pushName( "PxShape" );
+				
+				if( !shape->isExclusive() )
+				{
+					writeReference( visitor.mWriter, visitor.mCollection, "PxShapeRef", shape );
+				}
+				else
+				{
+					handleComplexObj( visitor, shape, theInfo );
+				}
+				visitor.popName();
+			}
+		}
+	}
+
+	template<typename TVisitor>
+	void handleShapeMaterials( TVisitor& visitor, const PxShapeMaterialsProperty& inProp )
+	{
+		PxU32 count( inProp.size( visitor.mObj ) );
+		if ( count )
+		{
+			Ps::InlineArray<PxMaterial*,5> theData;
+			theData.resize( count );
+			inProp.get( visitor.mObj, theData.begin(), count );
+			visitor.pushName( "PxMaterialRef" );
+			
+			for( PxU32 idx =0; idx < count; ++idx )
+				writeReference( visitor.mWriter, visitor.mCollection, "PxMaterialRef", theData[idx] );
+			visitor.popName();
+		}
+	}
+
+	template<typename TObjType>
+	struct RepXVisitorWriterBase
+	{
+		TNameStack&	mNameStack;
+		XmlWriter&					mWriter;
+		const TObjType*				mObj;
+		MemoryBuffer&				mTempBuffer;
+		PxCollection&				mCollection;
+
+		RepXVisitorWriterBase( TNameStack& ns, XmlWriter& writer, const TObjType* obj, MemoryBuffer& buf, PxCollection& collection )
+			: mNameStack( ns )
+			, mWriter( writer )
+			, mObj( obj )
+			, mTempBuffer( buf )
+			, mCollection( collection )
+		{
+		}
+
+		RepXVisitorWriterBase( const RepXVisitorWriterBase<TObjType>& other )
+			: mNameStack( other.mNameStack )
+			, mWriter( other.mWriter )
+			, mObj( other.mObj )
+			, mTempBuffer( other.mTempBuffer )
+			, mCollection( other.mCollection )
+		{
+		}
+
+		RepXVisitorWriterBase& operator=( const RepXVisitorWriterBase& ){ PX_ASSERT( false ); return *this; }
+
+		void gotoTopName()
+		{
+			if ( mNameStack.size() && mNameStack.back().mOpen == false ) 
+			{
+				mWriter.addAndGotoChild( mNameStack.back().mName );
+				mNameStack.back().mOpen = true;
+			}
+		}
+
+		void pushName( const char* inName ) 
+		{ 
+			gotoTopName();
+			mNameStack.pushBack( inName ); 
+		}
+
+		void pushBracketedName( const char* inName ) { pushName( inName ); }
+		void popName() 
+		{ 
+			if ( mNameStack.size() )
+			{
+				if ( mNameStack.back().mOpen )
+					mWriter.leaveChild();
+				mNameStack.popBack(); 
+			}
+		}
+
+		const char* topName() const
+		{
+			if ( mNameStack.size() ) return mNameStack.back().mName;
+			PX_ASSERT( false );
+			return "bad__repx__name";
+		}
+
+		template<typename TAccessorType>
+		void simpleProperty( PxU32 /*key*/, TAccessorType& inProp )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			TPropertyType propVal = inProp.get( mObj );
+			writeProperty( mWriter, mCollection, mTempBuffer, topName(), propVal );
+		}
+		
+		template<typename TAccessorType>
+		void enumProperty( PxU32 /*key*/, TAccessorType& inProp, const PxU32ToName* inConversions )
+		{
+			writeEnumProperty( mWriter, topName(),  inProp.get( mObj ), inConversions );
+		}
+
+		template<typename TAccessorType>
+		void flagsProperty( PxU32 /*key*/, const TAccessorType& inProp, const PxU32ToName* inConversions )
+		{
+			writeFlagsProperty( mWriter, mTempBuffer, topName(), inProp.get( mObj ), inConversions );
+		}
+
+		template<typename TAccessorType, typename TInfoType>
+		void complexProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			TPropertyType propVal = inProp.get( mObj );
+			handleComplexObj( *this, &propVal, inInfo );
+		}
+		
+		template<typename TAccessorType, typename TInfoType>
+		void bufferCollectionProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			
+			PxU32 count( inProp.size( mObj ) );
+			Ps::InlineArray<TPropertyType,5> theData;
+			theData.resize( count );
+	
+			PxClassInfoTraits<TInfoType> theTraits;
+			PX_UNUSED(theTraits);
+			PxU32 numItems = inProp.get( mObj, theData.begin(), count );
+			PX_ASSERT( numItems == count );
+			for( PxU32 idx =0; idx < numItems; ++idx )
+			{
+				pushName( inProp.name() );
+				handleComplexObj( *this, &theData[idx], inInfo );
+				popName();
+			}
+		}
+		
+		template<typename TAccessorType, typename TInfoType>
+		void extendedIndexedProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& /*inInfo */)
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			
+			PxU32 count( inProp.size( mObj ) );
+			Ps::InlineArray<TPropertyType,5> theData;
+			theData.resize( count );
+	
+			for(PxU32 i = 0; i < count; ++i)
+			{
+				char buffer[32] = { 0 };
+				sprintf( buffer, "id_%u", i );
+				pushName( buffer );
+				
+				TPropertyType propVal = inProp.get( mObj, i );
+				TInfoType& infoType = PxClassInfoTraits<TPropertyType>().Info;
+				handleComplexObj(*this, &propVal, infoType);
+				popName();
+			}		
+		}
+		
+		template<typename TAccessorType, typename TInfoType>
+		void PxFixedSizeLookupTableProperty( PxU32* /*key*/, TAccessorType& inProp, TInfoType& /*inInfo */)
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			PxU32 count( inProp.size( mObj ) );
+			
+			PxU32 index = 0;
+			for(PxU32 i = 0; i < count; ++i)
+			{
+				char buffer[32] = { 0 };
+				sprintf( buffer, "id_%u", index++ );
+				pushName( buffer );
+				TPropertyType propVal = inProp.getX( mObj , i);
+				writeProperty( mWriter, mCollection, mTempBuffer, topName(), propVal );
+				popName();
+
+				sprintf( buffer, "id_%u", index++ );
+				pushName( buffer );
+				propVal = inProp.getY( mObj , i);
+				writeProperty( mWriter, mCollection, mTempBuffer, topName(), propVal );
+				popName();
+			}	
+		}
+
+
+		void handleShapes( const PxRigidActorShapeCollection& inProp )
+		{
+			physx::Sn::handleShapes( *this, inProp );
+		}
+
+		void handleShapeMaterials( const PxShapeMaterialsProperty& inProp )
+		{
+			physx::Sn::handleShapeMaterials( *this, inProp );
+		}
+	};
+
+	template<typename TObjType>
+	struct RepXVisitorWriter : RepXVisitorWriterBase<TObjType>
+	{
+		RepXVisitorWriter( TNameStack& ns, XmlWriter& writer, const TObjType* obj, MemoryBuffer& buf, PxCollection& collection )
+			: RepXVisitorWriterBase<TObjType>( ns, writer, obj, buf, collection )
+		{
+		}
+
+		RepXVisitorWriter( const RepXVisitorWriter<TObjType>& other )
+			: RepXVisitorWriterBase<TObjType>( other )
+		{
+		}
+	};
+
+	template<>
+	struct RepXVisitorWriter<PxArticulationLink> : RepXVisitorWriterBase<PxArticulationLink>
+	{
+		RepXVisitorWriter( TNameStack& ns, XmlWriter& writer, const PxArticulationLink* obj, MemoryBuffer& buf, PxCollection& collection )
+			: RepXVisitorWriterBase<PxArticulationLink>( ns, writer, obj, buf, collection )
+		{
+		}
+
+		RepXVisitorWriter( const RepXVisitorWriter<PxArticulationLink>& other )
+			: RepXVisitorWriterBase<PxArticulationLink>( other )
+		{
+		}
+
+		void handleIncomingJoint( const TIncomingJointPropType& prop )
+		{
+			const PxArticulationJoint* theJoint( prop.get( mObj ) );
+			if ( theJoint )
+			{
+				PxArticulationJointGeneratedInfo info;
+				pushName( "Joint" );
+				handleComplexObj( *this, theJoint, info );
+				popName();
+			}
+		}
+	};
+	
+	typedef PxProfileHashMap< const PxSerialObjectId, const PxArticulationLink* > TArticulationLinkLinkMap;
+	
+	template<>
+	struct RepXVisitorWriter<PxArticulation> : RepXVisitorWriterBase<PxArticulation>
+	{
+		TArticulationLinkLinkMap& mArticulationLinkParents;
+
+		RepXVisitorWriter( TNameStack& ns, XmlWriter& writer, const PxArticulation* inArticulation, MemoryBuffer& buf, PxCollection& collection, TArticulationLinkLinkMap* artMap = NULL )
+			: RepXVisitorWriterBase<PxArticulation>( ns, writer, inArticulation, buf, collection )
+			, mArticulationLinkParents( *artMap )
+		{
+			Ps::InlineArray<PxArticulationLink*, 64, PxProfileWrapperReflectionAllocator<PxArticulationLink*> > linkList( PxProfileWrapperReflectionAllocator<PxArticulationLink*>( buf.mManager->getWrapper() ) );
+			PxU32 numLinks = inArticulation->getNbLinks();
+			linkList.resize( numLinks );
+			inArticulation->getLinks( linkList.begin(), numLinks );
+			for ( PxU32 idx = 0; idx < numLinks; ++idx )
+			{
+				const PxArticulationLink* theLink( linkList[idx] );
+				
+				Ps::InlineArray<PxArticulationLink*, 64> theChildList;
+				PxU32 numChildren = theLink->getNbChildren();
+				theChildList.resize( numChildren );
+				theLink->getChildren( theChildList.begin(), numChildren );
+				for ( PxU32 childIdx = 0; childIdx < numChildren; ++childIdx )
+					mArticulationLinkParents.insert( PX_PROFILE_POINTER_TO_U64(theChildList[childIdx]), theLink );
+			}
+		}
+
+		RepXVisitorWriter( const RepXVisitorWriter<PxArticulation>& other )
+			: RepXVisitorWriterBase<PxArticulation>( other )
+			, mArticulationLinkParents( other.mArticulationLinkParents )
+		{
+		}
+		template<typename TAccessorType, typename TInfoType>
+		void complexProperty( PxU32* /*key*/, const TAccessorType& inProp, TInfoType& inInfo )
+		{
+			typedef typename TAccessorType::prop_type TPropertyType;
+			TPropertyType propVal = inProp.get( mObj );
+			handleComplexObj( *this, &propVal, inInfo );
+		}
+
+		void writeArticulationLink( const PxArticulationLink* inLink )
+		{
+			pushName( "PxArticulationLink" );
+			gotoTopName();
+
+			const TArticulationLinkLinkMap::Entry* theParentPtr = mArticulationLinkParents.find( PX_PROFILE_POINTER_TO_U64(inLink) );
+			if ( theParentPtr != NULL )
+				writeProperty( mWriter, mCollection, mTempBuffer, "Parent",  theParentPtr->second );
+			writeProperty( mWriter, mCollection, mTempBuffer, "Id", inLink  );
+
+			PxArticulationLinkGeneratedInfo info;
+			handleComplexObj( *this, inLink, info );
+			popName();
+		}
+
+		void recurseAddLinkAndChildren( const PxArticulationLink* inLink, Ps::InlineArray<const PxArticulationLink*, 64>& ioLinks )
+		{
+			ioLinks.pushBack( inLink );
+			Ps::InlineArray<PxArticulationLink*, 8> theChildren;
+			PxU32 childCount( inLink->getNbChildren() );
+			theChildren.resize( childCount );
+			inLink->getChildren( theChildren.begin(), childCount );
+			for ( PxU32 idx = 0; idx < childCount; ++idx )
+				recurseAddLinkAndChildren( theChildren[idx], ioLinks );
+		}
+
+		void handleArticulationLinks( const PxArticulationLinkCollectionProp& inProp )
+		{
+			//topologically sort the links as per my discussion with Dilip because
+			//links aren't guaranteed to have the parents before the children in the
+			//overall link list and it is unlikely to be done by beta 1.
+			PxU32 count( inProp.size( mObj ) );
+			if ( count )
+			{
+				Ps::InlineArray<PxArticulationLink*, 64> theLinks;
+				theLinks.resize( count );
+				inProp.get( mObj, theLinks.begin(), count );
+				
+				Ps::InlineArray<const PxArticulationLink*, 64> theSortedLinks;
+				for ( PxU32 idx = 0; idx < count; ++idx )
+				{
+					const PxArticulationLink* theLink( theLinks[idx] );
+					if ( mArticulationLinkParents.find( PX_PROFILE_POINTER_TO_U64(theLink) ) == NULL )
+						recurseAddLinkAndChildren( theLink, theSortedLinks );
+				}	
+				PX_ASSERT( theSortedLinks.size() == count );
+				for ( PxU32 idx = 0; idx < count; ++idx )
+					writeArticulationLink( theSortedLinks[idx] );
+				popName();
+			}
+		}
+	private:
+		RepXVisitorWriter<PxArticulation>& operator=(const RepXVisitorWriter<PxArticulation>&);
+	};
+	
+	template<>
+	struct RepXVisitorWriter<PxShape> : RepXVisitorWriterBase<PxShape>
+	{
+		RepXVisitorWriter( TNameStack& ns, XmlWriter& writer, const PxShape* obj, MemoryBuffer& buf, PxCollection& collection )
+			: RepXVisitorWriterBase<PxShape>( ns, writer, obj, buf, collection )
+		{
+		}
+
+		RepXVisitorWriter( const RepXVisitorWriter<PxShape>& other )
+			: RepXVisitorWriterBase<PxShape>( other )
+		{
+		}
+
+		template<typename GeometryType>
+		inline void writeGeometryProperty( const PxShapeGeometryProperty& inProp, const char* inTypeName )
+		{
+			pushName( "Geometry" );
+			pushName( inTypeName );
+			GeometryType theType;
+			inProp.getGeometry( mObj, theType );
+			PxClassInfoTraits<GeometryType> theTraits;
+			PxU32 count = theTraits.Info.totalPropertyCount();
+			if(count)
+			{				
+				handleComplexObj( *this, &theType, theTraits.Info);
+			}
+			else
+			{
+				writeProperty(mWriter, mTempBuffer, inTypeName);
+			}
+			popName();
+			popName();
+		}
+
+		void handleGeometryProperty( const PxShapeGeometryProperty& inProp )
+		{
+			switch( mObj->getGeometryType() )
+			{
+				case PxGeometryType::eSPHERE: writeGeometryProperty<PxSphereGeometry>( inProp, "PxSphereGeometry" ); break;
+				case PxGeometryType::ePLANE: writeGeometryProperty<PxPlaneGeometry>( inProp, "PxPlaneGeometry" ); break;
+				case PxGeometryType::eCAPSULE: writeGeometryProperty<PxCapsuleGeometry>( inProp, "PxCapsuleGeometry" ); break;
+				case PxGeometryType::eBOX: writeGeometryProperty<PxBoxGeometry>( inProp, "PxBoxGeometry" ); break;
+				case PxGeometryType::eCONVEXMESH: writeGeometryProperty<PxConvexMeshGeometry>( inProp, "PxConvexMeshGeometry" ); break;
+				case PxGeometryType::eTRIANGLEMESH: writeGeometryProperty<PxTriangleMeshGeometry>( inProp, "PxTriangleMeshGeometry" ); break;
+				case PxGeometryType::eHEIGHTFIELD: writeGeometryProperty<PxHeightFieldGeometry>( inProp, "PxHeightFieldGeometry" ); break;
+				case PxGeometryType::eINVALID:
+				case PxGeometryType::eGEOMETRY_COUNT:
+					PX_ASSERT( false );
+			}
+		}
+	};
+	
+	template<typename TObjType>
+	inline void writeAllProperties( TNameStack& inNameStack, const TObjType* inObj, XmlWriter& writer, MemoryBuffer& buffer, PxCollection& collection )
+	{
+		RepXVisitorWriter<TObjType> newVisitor( inNameStack, writer, inObj, buffer, collection );
+		RepXPropertyFilter<RepXVisitorWriter<TObjType> > theOp( newVisitor );
+		PxClassInfoTraits<TObjType> info;
+		info.Info.visitBaseProperties( theOp );
+		info.Info.visitInstanceProperties( theOp );
+	}
+	
+	template<typename TObjType>
+	inline void writeAllProperties( TNameStack& inNameStack, TObjType* inObj, XmlWriter& writer, MemoryBuffer& buffer, PxCollection& collection )
+	{
+		RepXVisitorWriter<TObjType> newVisitor( inNameStack, writer, inObj, buffer, collection );
+		RepXPropertyFilter<RepXVisitorWriter<TObjType> > theOp( newVisitor );
+		PxClassInfoTraits<TObjType> info;
+		info.Info.visitBaseProperties( theOp );
+		info.Info.visitInstanceProperties( theOp );
+	}
+	
+	template<typename TObjType>
+	inline void writeAllProperties( const TObjType* inObj, XmlWriter& writer, MemoryBuffer& buffer, PxCollection& collection )
+	{
+		TNameStack theNames( buffer.mManager->getWrapper() );
+		writeAllProperties( theNames, inObj, writer, buffer, collection );
+	}
+	
+	template<typename TObjType, typename TWriterType, typename TInfoType>
+	inline void handleComplexObj( TWriterType& oldVisitor, const TObjType* inObj, const TInfoType& /*info*/)
+	{
+		writeAllProperties( oldVisitor.mNameStack, inObj, oldVisitor.mWriter, oldVisitor.mTempBuffer, oldVisitor.mCollection );
+	}
+
+	template<typename TObjType, typename TWriterType, typename TInfoType>
+	inline void handleComplexObj( TWriterType& oldVisitor, const TObjType* inObj, TInfoType& /*info*/)
+	{
+		writeAllProperties( oldVisitor.mNameStack, inObj, oldVisitor.mWriter, oldVisitor.mTempBuffer, oldVisitor.mCollection );
+	}
+
+	template<typename TObjType, typename TWriterType>
+	inline void handleComplexObj( TWriterType& oldVisitor, const TObjType* inObj, const PxUnknownClassInfo& /*info*/)
+	{
+		writeProperty( oldVisitor.mWriter, oldVisitor.mCollection, oldVisitor.mTempBuffer, oldVisitor.topName(), *inObj );
+	}
+	
+} }
+#endif
diff --git a/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlWriter.h b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlWriter.h
new file mode 100644
index 00000000..afea8aa0
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXExtensions/src/serialization/Xml/SnXmlWriter.h
@@ -0,0 +1,57 @@
+// 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_XML_WRITER_H
+#define PX_XML_WRITER_H
+
+#include "foundation/PxSimpleTypes.h"
+
+namespace physx {
+
+	struct PxRepXObject;
+
+	/** 
+	 *	Writer used by extensions to write elements to a file or database
+	 */
+	class XmlWriter
+	{
+	protected:
+		virtual ~XmlWriter(){}
+	public:
+		/** Write a key-value pair into the current item */
+		virtual void write( const char* inName, const char* inData ) = 0;
+		/** Write an object id into the current item */
+		virtual void write( const char* inName, const PxRepXObject& inLiveObject ) = 0;
+		/** Add a child that then becomes the current context */
+		virtual void addAndGotoChild( const char* inName ) = 0;
+		/** Leave the current child */
+		virtual void leaveChild() = 0;
+	};
+} 
+
+#endif