Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

11 files changed, 8487 insertions, 0 deletions

diff --git a/PhysX_3.4/Source/PhysXMetaData/core/include/PvdMetaDataDefineProperties.h b/PhysX_3.4/Source/PhysXMetaData/core/include/PvdMetaDataDefineProperties.h
new file mode 100644
index 00000000..48a8930a
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/core/include/PvdMetaDataDefineProperties.h
@@ -0,0 +1,369 @@
+// 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 PVD_META_DATA_DEFINE_PROPERTIES_H
+#define PVD_META_DATA_DEFINE_PROPERTIES_H
+
+#if PX_SUPPORT_PVD
+
+#include "PvdMetaDataPropertyVisitor.h"
+#include "PxPvdDataStreamHelpers.h"
+#include "PxPvdDataStream.h"
+#include "PxCoreUtilityTypes.h"
+
+
+namespace physx
+{
+namespace Vd
+{	
+	using namespace physx::shdfnd;
+	using namespace physx::pvdsdk;
+
+	template<typename TPropType>
+	struct PropertyDefinitionOp
+	{
+		void defineProperty( PvdPropertyDefinitionHelper& mHelper, NamespacedName mClassKey )
+		{
+			mHelper.createProperty( mClassKey, "", getPvdNamespacedNameForType<TPropType>(), PropertyType::Scalar );
+		}
+	};
+	template<>
+	struct PropertyDefinitionOp<const char*>
+	{
+		void defineProperty( PvdPropertyDefinitionHelper& mHelper, NamespacedName mClassKey )
+		{
+			mHelper.createProperty( mClassKey, "", getPvdNamespacedNameForType<StringHandle>(), PropertyType::Scalar );
+		}
+	};
+#define DEFINE_PROPERTY_DEFINITION_OP_NOP( type ) \
+	template<> struct PropertyDefinitionOp<type> { void defineProperty( PvdPropertyDefinitionHelper&, NamespacedName ){} };
+
+	//NOP out these two types.
+	DEFINE_PROPERTY_DEFINITION_OP_NOP( PxStridedData )
+	DEFINE_PROPERTY_DEFINITION_OP_NOP( PxBoundedData )
+
+#define DEFINE_PROPERTY_DEFINITION_OBJECT_REF( type )										\
+	template<> struct PropertyDefinitionOp<type> {											\
+	void defineProperty( PvdPropertyDefinitionHelper& mHelper, NamespacedName mClassKey)	\
+	{																						\
+		mHelper.createProperty( mClassKey, "", getPvdNamespacedNameForType<ObjectRef>(), PropertyType::Scalar ); \
+	}																						\
+	};
+
+	DEFINE_PROPERTY_DEFINITION_OBJECT_REF( PxTriangleMesh* )
+	DEFINE_PROPERTY_DEFINITION_OBJECT_REF( PxBVH33TriangleMesh* )
+	DEFINE_PROPERTY_DEFINITION_OBJECT_REF( PxBVH34TriangleMesh* )
+	DEFINE_PROPERTY_DEFINITION_OBJECT_REF( PxConvexMesh* )
+	DEFINE_PROPERTY_DEFINITION_OBJECT_REF( PxHeightField* )
+
+
+struct PvdClassInfoDefine
+{
+	PvdPropertyDefinitionHelper& mHelper;
+	NamespacedName mClassKey;
+
+	PvdClassInfoDefine( PvdPropertyDefinitionHelper& info, NamespacedName inClassName )
+		: mHelper( info )
+		, mClassKey( inClassName ) { }
+
+	PvdClassInfoDefine( const PvdClassInfoDefine& other )
+		: mHelper( other.mHelper )
+		, mClassKey( other.mClassKey )
+	{
+	}
+
+	void defineProperty( NamespacedName inDtype, const char* semantic = "", PropertyType::Enum inPType = PropertyType::Scalar )
+	{
+		mHelper.createProperty( mClassKey, semantic, inDtype, inPType ); 
+	}
+
+	void pushName( const char* inName )
+	{
+		mHelper.pushName( inName );
+	}
+	
+	void pushBracketedName( const char* inName) 
+	{
+		mHelper.pushBracketedName( inName );
+	}
+
+	void popName()
+	{
+		mHelper.popName();
+	}
+
+	inline void defineNameValueDefs( const PxU32ToName* theConversions )
+	{
+		while( theConversions->mName != NULL )
+		{
+			mHelper.addNamedValue( theConversions->mName, theConversions->mValue );
+			++theConversions;
+		}
+	}
+
+	template<typename TAccessorType>
+	void simpleProperty( PxU32, TAccessorType& /*inProp */)
+	{
+		typedef typename TAccessorType::prop_type TPropertyType;
+		PropertyDefinitionOp<TPropertyType>().defineProperty( mHelper, mClassKey );
+	}
+
+	template<typename TAccessorType, typename TInfoType>
+	void extendedIndexedProperty( PxU32* key, const TAccessorType& inProp, TInfoType&  )
+	{
+		simpleProperty(*key, inProp);
+	}
+
+	template<typename TDataType>
+	static NamespacedName getNameForEnumType()
+	{
+		size_t s = sizeof( TDataType );
+		switch(s)
+		{
+		case 1: return getPvdNamespacedNameForType<PxU8>();
+		case 2: return getPvdNamespacedNameForType<PxU16>();
+		case 4: return getPvdNamespacedNameForType<PxU32>();
+		default: return getPvdNamespacedNameForType<PxU64>();
+		}
+	}
+	
+	template<typename TAccessorType>
+	void enumProperty( PxU32 /*key*/, TAccessorType& /*inProp*/, const PxU32ToName* inConversions )
+	{
+		typedef typename TAccessorType::prop_type TPropType;
+		defineNameValueDefs( inConversions );
+		defineProperty( getNameForEnumType<TPropType>(), "Enumeration Value" );
+	}
+
+	template<typename TAccessorType>
+	void flagsProperty( PxU32 /*key*/, const TAccessorType& /*inAccessor*/, const PxU32ToName* inConversions )
+	{
+		typedef typename TAccessorType::prop_type TPropType;
+		defineNameValueDefs( inConversions );
+		defineProperty( getNameForEnumType<TPropType>(), "Bitflag" );
+	}
+
+	template<typename TAccessorType, typename TInfoType>
+	void complexProperty( PxU32* key, const TAccessorType& inAccessor, TInfoType& inInfo )
+	{
+		PxU32 theOffset = inAccessor.mOffset;
+		inInfo.visitBaseProperties( makePvdPropertyFilter( *this, key, &theOffset ) );
+		inInfo.visitInstanceProperties( makePvdPropertyFilter( *this, key, &theOffset ) );
+	}
+	
+	template<typename TAccessorType, typename TInfoType>
+	void bufferCollectionProperty( PxU32* key, const TAccessorType& inAccessor, TInfoType& inInfo )
+	{
+		complexProperty(key, inAccessor, inInfo);
+	}
+
+	template<PxU32 TKey, typename TObjectType, typename TPropertyType, PxU32 TEnableFlag>
+	void handleBuffer( const PxBufferPropertyInfo<TKey, TObjectType, PxStrideIterator< const TPropertyType >, TEnableFlag>& inProp )
+	{
+		mHelper.pushName( inProp.mName );
+		defineProperty( getPvdNamespacedNameForType<TPropertyType>(), "", PropertyType::Array );
+		mHelper.popName();
+	}
+	
+	template<PxU32 TKey, typename TObjectType, typename TEnumType, typename TStorageType, PxU32 TEnableFlag>
+	void handleFlagsBuffer( const PxBufferPropertyInfo<TKey, TObjectType, PxStrideIterator<const PxFlags<TEnumType, TStorageType> >, TEnableFlag>& inProp, const PxU32ToName* inConversion )
+	{
+		mHelper.pushName( inProp.mName );
+		defineNameValueDefs( inConversion );
+		defineProperty( getPvdNamespacedNameForType<TStorageType>(), "Bitflag", PropertyType::Array );
+		mHelper.popName();
+	}
+
+	template<PxU32 TKey, typename TObjectType, typename TPropertyType, PxU32 TEnableFlag>
+	void handleBuffer( const PxBufferPropertyInfo<TKey, TObjectType, const Array< TPropertyType >&, TEnableFlag>& inProp )
+	{
+		mHelper.pushName( inProp.mName );
+		defineProperty( getPvdNamespacedNameForType<TPropertyType>(), "", PropertyType::Array );
+		mHelper.popName();
+	}
+
+	template<PxU32 TKey, typename TObjectType, typename TCollectionType>
+	void handleCollection( const PxReadOnlyCollectionPropertyInfo<TKey, TObjectType, TCollectionType>& inProp )
+	{
+		mHelper.pushName( inProp.mName );
+		defineProperty( getPvdNamespacedNameForType<TCollectionType>(), "", PropertyType::Array );
+		mHelper.popName();
+	}
+	
+	template<PxU32 TKey, typename TObjectType, typename TEnumType>
+	void handleCollection( const PxReadOnlyCollectionPropertyInfo<TKey, TObjectType, TEnumType>& inProp, const PxU32ToName* inConversions )
+	{
+		mHelper.pushName( inProp.mName );
+		defineNameValueDefs( inConversions );
+		defineProperty( getNameForEnumType<TEnumType>(), "Enumeration Value", PropertyType::Array );
+		mHelper.popName();
+	}
+
+private:
+	PvdClassInfoDefine& operator=(const PvdClassInfoDefine&);
+};
+
+template<typename TPropType>
+struct SimplePropertyValueStructOp
+{
+	void addPropertyMessageArg( PvdPropertyDefinitionHelper& mHelper, PxU32 inOffset )
+	{
+		mHelper.addPropertyMessageArg<TPropType>( inOffset );
+	}
+};
+
+#define DEFINE_SIMPLE_PROPERTY_VALUE_STRUCT_OP_NOP( type ) \
+template<> struct SimplePropertyValueStructOp<type> { void addPropertyMessageArg( PvdPropertyDefinitionHelper&, PxU32 ){}};
+
+DEFINE_SIMPLE_PROPERTY_VALUE_STRUCT_OP_NOP( PxStridedData )
+DEFINE_SIMPLE_PROPERTY_VALUE_STRUCT_OP_NOP( PxBoundedData )
+
+#define DEFINE_SIMPLE_PROPERTY_VALUE_STRUCT_VOIDPTR_OP( type )						\
+template<> struct SimplePropertyValueStructOp<type> {								\
+void addPropertyMessageArg( PvdPropertyDefinitionHelper& mHelper, PxU32 inOffset )	\
+{																					\
+	mHelper.addPropertyMessageArg<VoidPtr>( inOffset );								\
+}																					\
+};
+
+DEFINE_SIMPLE_PROPERTY_VALUE_STRUCT_VOIDPTR_OP( PxTriangleMesh* )
+DEFINE_SIMPLE_PROPERTY_VALUE_STRUCT_VOIDPTR_OP( PxBVH33TriangleMesh* )
+DEFINE_SIMPLE_PROPERTY_VALUE_STRUCT_VOIDPTR_OP( PxBVH34TriangleMesh* )
+DEFINE_SIMPLE_PROPERTY_VALUE_STRUCT_VOIDPTR_OP( PxConvexMesh* )
+DEFINE_SIMPLE_PROPERTY_VALUE_STRUCT_VOIDPTR_OP( PxHeightField* )
+
+
+struct PvdClassInfoValueStructDefine
+{
+private:
+	PvdClassInfoValueStructDefine& operator=(const PvdClassInfoValueStructDefine&);
+public:
+
+	PvdPropertyDefinitionHelper& mHelper;
+
+	PvdClassInfoValueStructDefine( PvdPropertyDefinitionHelper& info )
+		: mHelper( info )
+	{ }
+
+	PvdClassInfoValueStructDefine( const PvdClassInfoValueStructDefine& other )
+		: mHelper( other.mHelper )
+	{
+	}
+
+	void defineValueStructOffset( const ValueStructOffsetRecord& inProp, PxU32 inPropSize )
+	{
+		if( inProp.mHasValidOffset )
+		{
+			switch( inPropSize )
+			{
+			case 8: mHelper.addPropertyMessageArg<PxU64>( inProp.mOffset ); break;
+			case 4: mHelper.addPropertyMessageArg<PxU32>( inProp.mOffset ); break;
+			case 2: mHelper.addPropertyMessageArg<PxU16>( inProp.mOffset ); break;
+			default: 
+				PX_ASSERT(1 == inPropSize);
+				mHelper.addPropertyMessageArg<PxU8>( inProp.mOffset ); break;
+			}
+		}
+	}
+
+	void pushName( const char* inName )
+	{
+		mHelper.pushName( inName );
+	}
+	
+	void pushBracketedName( const char* inName) 
+	{
+		mHelper.pushBracketedName( inName );
+	}
+
+	void popName()
+	{
+		mHelper.popName();
+	}
+
+    template<typename TAccessorType, typename TInfoType>
+	void bufferCollectionProperty( PxU32* /*key*/, const TAccessorType& /*inAccessor*/, TInfoType& /*inInfo*/ )
+	{
+		//complexProperty(key, inAccessor, inInfo);
+	}
+
+	template<typename TAccessorType>
+	void simpleProperty( PxU32 /*key*/, TAccessorType& inProp )
+	{
+		typedef typename TAccessorType::prop_type TPropertyType;
+		if ( inProp.mHasValidOffset )
+		{
+			SimplePropertyValueStructOp<TPropertyType>().addPropertyMessageArg( mHelper, inProp.mOffset );
+		}
+	}
+	
+	template<typename TAccessorType>
+	void enumProperty( PxU32 /*key*/, TAccessorType& inAccessor, const PxU32ToName* /*inConversions */)
+	{
+		typedef typename TAccessorType::prop_type TPropType;
+		defineValueStructOffset( inAccessor, sizeof( TPropType ) );
+	}
+
+	template<typename TAccessorType>
+	void flagsProperty( PxU32 /*key*/, const TAccessorType& inAccessor, const PxU32ToName* /*inConversions */)
+	{
+		typedef typename TAccessorType::prop_type TPropType;
+		defineValueStructOffset( inAccessor, sizeof( TPropType ) );
+	}
+
+	template<typename TAccessorType, typename TInfoType>
+	void complexProperty( PxU32* key, const TAccessorType& inAccessor, TInfoType& inInfo )
+	{
+		PxU32 theOffset = inAccessor.mOffset;
+		inInfo.visitBaseProperties( makePvdPropertyFilter( *this, key, &theOffset ) );
+		inInfo.visitInstanceProperties( makePvdPropertyFilter( *this, key, &theOffset ) );
+	}
+
+	template<PxU32 TKey, typename TObjectType, typename TCollectionType>
+	void handleCollection( const PxReadOnlyCollectionPropertyInfo<TKey, TObjectType, TCollectionType>& /*prop*/ )
+	{
+	}
+	
+	template<PxU32 TKey, typename TObjectType, typename TEnumType>
+	void handleCollection( const PxReadOnlyCollectionPropertyInfo<TKey, TObjectType, TEnumType>& /*prop*/, const PxU32ToName* /*inConversions */)
+	{
+	}
+
+    template<PxU32 TKey, typename TObjectType, typename TInfoType>
+	void handleCollection( const PxBufferCollectionPropertyInfo<TKey, TObjectType, TInfoType>& /*prop*/,  const TInfoType& /*inInfo */)
+	{
+	}
+};
+
+}
+
+}
+
+#endif
+#endif
diff --git a/PhysX_3.4/Source/PhysXMetaData/core/include/PvdMetaDataExtensions.h b/PhysX_3.4/Source/PhysXMetaData/core/include/PvdMetaDataExtensions.h
new file mode 100644
index 00000000..eea47f68
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/core/include/PvdMetaDataExtensions.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_META_DATA_EXTENSIONS_H
+#define PX_META_DATA_EXTENSIONS_H
+#include "PxMetaDataObjects.h"
+
+#if PX_SUPPORT_PVD
+#include "PxPvdObjectModelBaseTypes.h"
+
+namespace physx { namespace pvdsdk {
+
+	template<> PX_INLINE NamespacedName getPvdNamespacedNameForType<physx::PxMetaDataPlane>() { return getPvdNamespacedNameForType<PxVec4>(); }
+	template<> PX_INLINE NamespacedName getPvdNamespacedNameForType<physx::PxRigidActor*>() { return getPvdNamespacedNameForType<VoidPtr>(); }
+	
+}}
+#endif
+
+namespace physx
+{
+namespace Vd
+{
+//Additional properties that exist only in pvd land.
+struct PxPvdOnlyProperties
+{
+	enum Enum
+	{
+		FirstProp = PxPropertyInfoName::LastPxPropertyInfoName,
+		PxScene_Frame,
+		PxScene_Contacts,
+		PxScene_SimulateElapsedTime,
+#define DEFINE_ENUM_RANGE( stem, count ) \
+	stem##Begin, \
+	stem##End = stem##Begin + count
+
+		//I can't easily add up the number of required property entries, but it is large due to the below
+		//geometry count squared properties.  Thus I punt and allocate way more than I need right now.
+		DEFINE_ENUM_RANGE( PxScene_SimulationStatistics, 1000 ),
+		DEFINE_ENUM_RANGE( PxSceneDesc_Limits, PxPropertyInfoName::PxSceneLimits_PropertiesStop - PxPropertyInfoName::PxSceneLimits_PropertiesStart ),
+		DEFINE_ENUM_RANGE( PxSimulationStatistics_NumBroadPhaseAdds, PxSimulationStatistics::eVOLUME_COUNT ),
+		DEFINE_ENUM_RANGE( PxSimulationStatistics_NumBroadPhaseRemoves, PxSimulationStatistics::eVOLUME_COUNT ),
+		DEFINE_ENUM_RANGE( PxSimulationStatistics_NumShapes, PxGeometryType::eGEOMETRY_COUNT ),
+		DEFINE_ENUM_RANGE( PxSimulationStatistics_NumDiscreteContactPairs, PxGeometryType::eGEOMETRY_COUNT * PxGeometryType::eGEOMETRY_COUNT ),
+		DEFINE_ENUM_RANGE( PxSimulationStatistics_NumModifiedContactPairs, PxGeometryType::eGEOMETRY_COUNT * PxGeometryType::eGEOMETRY_COUNT ),
+		DEFINE_ENUM_RANGE( PxSimulationStatistics_NumSweptIntegrationPairs, PxGeometryType::eGEOMETRY_COUNT * PxGeometryType::eGEOMETRY_COUNT ),
+		DEFINE_ENUM_RANGE( PxSimulationStatistics_NumTriggerPairs, PxGeometryType::eGEOMETRY_COUNT * PxGeometryType::eGEOMETRY_COUNT ),
+		DEFINE_ENUM_RANGE( PxRigidDynamic_SolverIterationCounts, 2 ),
+ 		DEFINE_ENUM_RANGE( PxArticulation_SolverIterationCounts, 2 ),
+		DEFINE_ENUM_RANGE( PxArticulationJoint_SwingLimit, 2 ),
+		DEFINE_ENUM_RANGE( PxArticulationJoint_TwistLimit, 2 ),
+		DEFINE_ENUM_RANGE( PxConvexMeshGeometry_Scale, PxPropertyInfoName::PxMeshScale_PropertiesStop - PxPropertyInfoName::PxMeshScale_PropertiesStart ),
+		DEFINE_ENUM_RANGE( PxTriangleMeshGeometry_Scale, PxPropertyInfoName::PxMeshScale_PropertiesStop - PxPropertyInfoName::PxMeshScale_PropertiesStart ),
+#if PX_USE_CLOTH_API
+		DEFINE_ENUM_RANGE( PxCloth_MotionConstraintScaleBias, 2 ),
+#endif
+		
+
+#if PX_USE_PARTICLE_SYSTEM_API
+		PxParticleSystem_Positions,
+		PxParticleSystem_Velocities,
+		PxParticleSystem_RestOffsets,
+		PxParticleSystem_CollisionNormals,
+		PxParticleSystem_Flags,
+		PxParticleFluid_Densities,
+#endif
+#if PX_USE_CLOTH_API
+		PxCloth_ParticleBuffer,
+		PxCloth_ParticleAccelerations,
+		PxCloth_MotionConstraints,
+		PxCloth_CollisionSpheres,
+		PxCloth_CollisionSpherePairs,
+		PxCloth_CollisionPlanes,
+		PxCloth_CollisionConvexMasks,
+		PxCloth_CollisionTriangles,
+		PxCloth_VirtualParticles,
+		PxCloth_VirtualParticleWeights,
+		PxCloth_SeparationConstraints,
+		PxCloth_SelfCollisionIndices,
+		PxCloth_RestPositions,
+#endif
+		LastPxPvdOnlyProperty
+	};
+};
+
+template<PxU32 TKey, typename TObjectType, typename TPropertyType, PxU32 TEnableFlag>
+struct PxBufferPropertyInfo : PxReadOnlyPropertyInfo< TKey, TObjectType, TPropertyType >
+{
+	typedef PxReadOnlyPropertyInfo< TKey, TObjectType, TPropertyType > TBaseType;
+	typedef typename TBaseType::TGetterType TGetterType;
+	PxBufferPropertyInfo( const char* inName, TGetterType inGetter )
+		: TBaseType( inName, inGetter )
+	{
+	}
+	bool isEnabled( PxU32 inFlags ) const { return (inFlags & TEnableFlag) > 0; }
+};
+
+
+#define DECLARE_BUFFER_PROPERTY( objectType, baseType, propType, propName, fieldName, flagName )												\
+typedef PxBufferPropertyInfo< PxPvdOnlyProperties::baseType##_##propName, objectType, propType, flagName > T##objectType##propName##Base;		\
+inline propType get##propName( const objectType* inData ) { return inData->fieldName; }															\
+struct baseType##propName##Property : T##objectType##propName##Base																				\
+{																																				\
+	baseType##propName##Property()  : T##objectType##propName##Base( #propName, get##propName ){}												\
+};
+
+#if PX_USE_PARTICLE_SYSTEM_API
+DECLARE_BUFFER_PROPERTY( PxParticleReadData,		PxParticleSystem, PxStrideIterator<const PxVec3>,			Positions, positionBuffer, PxParticleReadDataFlag::ePOSITION_BUFFER )
+DECLARE_BUFFER_PROPERTY( PxParticleReadData,		PxParticleSystem, PxStrideIterator<const PxVec3>,			Velocities, velocityBuffer, PxParticleReadDataFlag::eVELOCITY_BUFFER )
+DECLARE_BUFFER_PROPERTY( PxParticleReadData,		PxParticleSystem, PxStrideIterator<const PxF32>,			RestOffsets, restOffsetBuffer, PxParticleReadDataFlag::eREST_OFFSET_BUFFER )
+DECLARE_BUFFER_PROPERTY( PxParticleReadData,		PxParticleSystem, PxStrideIterator<const PxVec3>,			CollisionNormals, collisionNormalBuffer, PxParticleReadDataFlag::eCOLLISION_NORMAL_BUFFER )
+DECLARE_BUFFER_PROPERTY( PxParticleReadData,		PxParticleSystem, PxStrideIterator<const PxParticleFlags>,	Flags, flagsBuffer, PxParticleReadDataFlag::eFLAGS_BUFFER )
+DECLARE_BUFFER_PROPERTY( PxParticleFluidReadData,	PxParticleFluid,  PxStrideIterator<const PxF32>,			Densities, densityBuffer, PxParticleReadDataFlag::eDENSITY_BUFFER )
+
+template<typename TOperator>
+inline void visitParticleSystemBufferProperties( TOperator inOperator )
+{
+	inOperator( PxParticleSystemPositionsProperty(), 0 );
+	inOperator( PxParticleSystemVelocitiesProperty(), 1 );
+	inOperator( PxParticleSystemRestOffsetsProperty(), 2 );
+	inOperator( PxParticleSystemCollisionNormalsProperty(), 3 );
+	inOperator( PxParticleSystemFlagsProperty(), 4 );
+}
+
+template<typename TOperator>
+inline void visitParticleFluidBufferProperties( TOperator inOperator )
+{
+	inOperator( PxParticleFluidDensitiesProperty(), 0 );
+}
+#endif // PX_USE_PARTICLE_SYSTEM_API
+
+
+template<PxU32 PropertyKey, typename TEnumType >
+struct IndexerToNameMap
+{
+	PxEnumTraits<TEnumType> Converter;
+};
+
+struct ValueStructOffsetRecord
+{
+	mutable bool	mHasValidOffset;
+	mutable PxU32	mOffset;
+	ValueStructOffsetRecord() : mHasValidOffset( false ), mOffset( 0 ) {}
+	void setupValueStructOffset( PxU32 inValue ) const
+	{
+		mHasValidOffset = true;
+		mOffset = inValue;
+	}
+};
+
+template<PxU32 TKey, typename TObjectType, typename TPropertyType>
+struct PxPvdReadOnlyPropertyAccessor : public ValueStructOffsetRecord
+{
+	typedef PxReadOnlyPropertyInfo<TKey,TObjectType,TPropertyType> TPropertyInfoType;
+	typedef TPropertyType prop_type;
+
+	const TPropertyInfoType	mProperty;
+	PxPvdReadOnlyPropertyAccessor( const TPropertyInfoType& inProp )
+		: mProperty( inProp )
+	{
+	}
+	prop_type get( const TObjectType* inObj ) const { return mProperty.get( inObj ); }
+
+private:
+	PxPvdReadOnlyPropertyAccessor& operator=(const PxPvdReadOnlyPropertyAccessor&);
+};
+
+template<PxU32 TKey, typename TObjectType, typename TPropertyType>
+struct PxBufferCollectionPropertyAccessor : public ValueStructOffsetRecord
+{
+	typedef PxBufferCollectionPropertyInfo< TKey, TObjectType, TPropertyType > TPropertyInfoType;
+	typedef TPropertyType prop_type;
+	const TPropertyInfoType& mProperty;
+	const char* mName;
+	
+	PxBufferCollectionPropertyAccessor( const TPropertyInfoType& inProp, const char* inName )
+		: mProperty( inProp )
+		, mName( inName )
+	{
+	}
+	
+	const char* name() const { return mName; }
+	PxU32 size( const TObjectType* inObj ) const { return mProperty.size( inObj ); }
+	PxU32 get( const TObjectType* inObj, prop_type* buffer, PxU32 inNumItems) const { return mProperty.get( inObj, buffer, inNumItems); }
+	void set( TObjectType* inObj, prop_type* inBuffer, PxU32 inNumItems ) const { mProperty.set( inObj, inBuffer, inNumItems ); }
+};
+
+template<PxU32 TKey, typename TObjectType, typename TIndexType, typename TPropertyType>
+struct PxPvdIndexedPropertyAccessor : public ValueStructOffsetRecord
+{
+	typedef PxIndexedPropertyInfo< TKey, TObjectType, TIndexType, TPropertyType > TPropertyInfoType;
+	typedef TPropertyType prop_type;
+	TIndexType mIndex;
+	const TPropertyInfoType& mProperty;
+	PxPvdIndexedPropertyAccessor( const TPropertyInfoType& inProp, PxU32 inIndex )
+		: mIndex( static_cast<TIndexType>( inIndex ) )
+		, mProperty( inProp )
+	{
+	}
+	prop_type get( const TObjectType* inObj ) const { return mProperty.get( inObj, mIndex ); }
+	void set( TObjectType* inObj, prop_type val ) const { mProperty.set( inObj, mIndex, val ); }
+
+	void operator = (PxPvdIndexedPropertyAccessor&) {}
+};
+
+template<PxU32 TKey, typename TObjectType, typename TIndexType, typename TPropertyType>
+struct PxPvdExtendedIndexedPropertyAccessor : public ValueStructOffsetRecord
+{
+	typedef PxExtendedIndexedPropertyInfo< TKey, TObjectType, TIndexType, TPropertyType > TPropertyInfoType;
+	typedef TPropertyType prop_type;
+	TIndexType mIndex;
+	const TPropertyInfoType& mProperty;
+	PxPvdExtendedIndexedPropertyAccessor( const TPropertyInfoType& inProp, PxU32 inIndex )
+		: mIndex( static_cast<TIndexType>( inIndex ) )
+		, mProperty( inProp )
+	{
+	}
+
+	PxU32 size( const TObjectType* inObj ) const { return mProperty.size( inObj ); }
+	prop_type get( const TObjectType* inObj, TIndexType index ) const { return mProperty.get( inObj, index ); }
+	void set( TObjectType* inObj, TIndexType index, prop_type val ) const { mProperty.set( inObj, index, val ); }
+
+	void operator = (PxPvdExtendedIndexedPropertyAccessor&) {}
+};
+
+template<PxU32 TKey, typename TObjectType, typename TIndexType, typename TPropertyType>
+struct PxPvdFixedSizeLookupTablePropertyAccessor : public ValueStructOffsetRecord
+{
+	typedef PxFixedSizeLookupTablePropertyInfo< TKey, TObjectType, TIndexType, TPropertyType > TPropertyInfoType;
+	typedef TPropertyType prop_type;
+	TIndexType	mIndex;
+	
+	const TPropertyInfoType& mProperty;
+	PxPvdFixedSizeLookupTablePropertyAccessor( const TPropertyInfoType& inProp, const PxU32 inIndex3 )
+		: mIndex( static_cast<TIndexType>( inIndex3 ) )
+		, mProperty( inProp )
+	{
+	}
+
+	PxU32 size( const TObjectType* inObj ) const { return mProperty.size( inObj ); }
+	prop_type getX( const TObjectType* inObj, const TIndexType index ) const { return mProperty.getX( inObj, index ); }
+	prop_type getY( const TObjectType* inObj, const TIndexType index ) const { return mProperty.getY( inObj, index ); }
+	void addPair(  TObjectType* inObj, const PxReal x, const PxReal y ) { const_cast<TPropertyInfoType&>(mProperty).addPair( inObj, x, y );  }
+	void clear( TObjectType* inObj ) { const_cast<TPropertyInfoType&>(mProperty).clear( inObj );  }
+	void operator = (PxPvdFixedSizeLookupTablePropertyAccessor&) {}
+};
+
+template<PxU32 TKey, typename TObjectType, typename TIdx0Type, typename TIdx1Type, typename TPropertyType>
+struct PxPvdDualIndexedPropertyAccessor : public ValueStructOffsetRecord
+{
+	typedef PxDualIndexedPropertyInfo< TKey, TObjectType, TIdx0Type, TIdx1Type, TPropertyType > TPropertyInfoType;
+	typedef TPropertyType prop_type;
+	TIdx0Type mIdx0;
+	TIdx1Type mIdx1;
+	const TPropertyInfoType& mProperty;
+
+	PxPvdDualIndexedPropertyAccessor( const TPropertyInfoType& inProp, PxU32 idx0, PxU32 idx1 )
+		: mIdx0( static_cast<TIdx0Type>( idx0 ) )
+		, mIdx1( static_cast<TIdx1Type>( idx1 ) )
+		, mProperty( inProp )
+	{
+	}
+	prop_type get( const TObjectType* inObj ) const { return mProperty.get( inObj, mIdx0, mIdx1 ); }
+	void set( TObjectType* inObj, prop_type val ) const { mProperty.set( inObj, mIdx0, mIdx1, val ); }
+
+private:
+	PxPvdDualIndexedPropertyAccessor& operator = (const PxPvdDualIndexedPropertyAccessor&);
+};
+
+template<PxU32 TKey, typename TObjectType, typename TIdx0Type, typename TIdx1Type, typename TPropertyType>
+struct PxPvdExtendedDualIndexedPropertyAccessor : public ValueStructOffsetRecord
+{
+	typedef PxExtendedDualIndexedPropertyInfo< TKey, TObjectType, TIdx0Type, TIdx1Type, TPropertyType > TPropertyInfoType;
+	typedef TPropertyType prop_type;
+	TIdx0Type mIdx0;
+	TIdx1Type mIdx1;
+	const TPropertyInfoType& mProperty;
+	
+	PxPvdExtendedDualIndexedPropertyAccessor( const TPropertyInfoType& inProp, PxU32 idx0, PxU32 idx1 )
+		: mIdx0( static_cast<TIdx0Type>( idx0 ) )
+		, mIdx1( static_cast<TIdx1Type>( idx1 ) )
+		, mProperty( inProp )
+	{
+	}
+	prop_type get( const TObjectType* inObj ) const { return mProperty.get( inObj, mIdx0, mIdx1 ); }
+	void set( TObjectType* inObj, prop_type val ) const { mProperty.set( inObj, mIdx0, mIdx1, val ); }
+
+private:
+	PxPvdExtendedDualIndexedPropertyAccessor& operator = (const PxPvdExtendedDualIndexedPropertyAccessor&);
+};
+
+template<PxU32 TKey, typename TObjType, typename TPropertyType>
+struct PxPvdRangePropertyAccessor : public ValueStructOffsetRecord
+{
+	typedef PxRangePropertyInfo<TKey, TObjType, TPropertyType> TPropertyInfoType;
+	typedef TPropertyType prop_type;
+	bool mFirstValue;
+	const TPropertyInfoType& mProperty;
+
+	PxPvdRangePropertyAccessor( const TPropertyInfoType& inProp, bool inFirstValue )
+		: mFirstValue( inFirstValue )
+		, mProperty( inProp )
+	{
+	}
+
+	prop_type get( const TObjType* inObj ) const {
+		prop_type first,second;
+		mProperty.get( inObj, first, second );
+		return mFirstValue ? first : second;
+	}
+	void set( TObjType* inObj, prop_type val ) const 
+	{ 
+		prop_type first,second;
+		mProperty.get( inObj, first, second );
+		if ( mFirstValue ) mProperty.set( inObj, val, second ); 
+		else mProperty.set( inObj, first, val );
+	}
+
+	void operator = (PxPvdRangePropertyAccessor&) {}
+};
+
+
+template<typename TDataType>
+struct IsFlagsType
+{
+	bool FlagData;
+};
+
+template<typename TEnumType, typename TStorageType>
+struct IsFlagsType<PxFlags<TEnumType, TStorageType> > 
+{
+	const PxU32ToName* FlagData;
+	IsFlagsType<PxFlags<TEnumType, TStorageType> > () : FlagData( PxEnumTraits<TEnumType>().NameConversion ) {}
+};
+
+
+
+template<typename TDataType>
+struct PvdClassForType
+{
+	bool Unknown;
+};
+
+}
+
+}
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXMetaData/core/include/PvdMetaDataPropertyVisitor.h b/PhysX_3.4/Source/PhysXMetaData/core/include/PvdMetaDataPropertyVisitor.h
new file mode 100644
index 00000000..324d3096
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/core/include/PvdMetaDataPropertyVisitor.h
@@ -0,0 +1,544 @@
+// 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_META_DATA_PROPERTY_VISITOR_H
+#define PX_META_DATA_PROPERTY_VISITOR_H
+
+#include "PvdMetaDataExtensions.h"
+namespace physx
+{
+
+namespace Vd
+{
+	
+//PVD only deals with read-only properties, indexed, and properties like this by in large.
+//so we have a filter that expands properties to a level where we can get to them and expands them into
+//named functions that make more sense and are easier to read than operator()
+template<typename TOperatorType>
+struct PvdPropertyFilter
+{
+
+private:
+	PvdPropertyFilter& operator=(const PvdPropertyFilter&);
+
+public:
+
+	TOperatorType		mOperator;
+	PxU32*				mKeyOverride;
+	PxU32*				mOffsetOverride;
+
+	PvdPropertyFilter( TOperatorType& inOperator ) 
+				: mOperator( inOperator )
+				, mKeyOverride( 0 )
+				, mOffsetOverride( 0 ) {}
+
+	PvdPropertyFilter( TOperatorType& inOperator, PxU32* inKeyOverride, PxU32* inOffsetOverride ) 
+				: mOperator( inOperator )
+				, mKeyOverride( inKeyOverride )
+				, mOffsetOverride( inOffsetOverride ) {}
+
+	PvdPropertyFilter( const PvdPropertyFilter& inOther ) : mOperator( inOther.mOperator ), mKeyOverride( inOther.mKeyOverride ), mOffsetOverride( inOther.mOffsetOverride ) {}
+
+	template<PxU32 TKey, typename TAccessorType>
+	void dispatchAccessor( PxU32 inKey, const TAccessorType& inAccessor, bool, bool, bool)
+	{
+		mOperator.simpleProperty(inKey, inAccessor );
+	}
+
+	template<PxU32 TKey, typename TAccessorType>
+	void dispatchAccessor( PxU32 inKey, const TAccessorType& inAccessor, bool, bool, const PxU32ToName* inConversions )
+	{
+		mOperator.flagsProperty(inKey, inAccessor, inConversions );
+	}
+	
+	template<PxU32 TKey, typename TAccessorType>
+	void dispatchAccessor( PxU32 inKey, const TAccessorType& inAccessor, const PxU32ToName* inConversions, bool, bool )
+	{
+		mOperator.enumProperty( inKey, inAccessor, inConversions );
+	}
+	
+	template<PxU32 TKey, typename TAccessorType, typename TInfoType>
+	void dispatchAccessor(PxU32, const TAccessorType& inAccessor, bool, const TInfoType* inInfo, bool )
+	{
+		PxU32 rangeStart = TKey;
+		PxU32& propIdx = mKeyOverride == NULL ? rangeStart : *mKeyOverride;
+		mOperator.complexProperty( &propIdx, inAccessor, *inInfo );
+	}
+
+	PxU32 getKeyValue( PxU32 inPropertyKey )
+	{
+		PxU32 retval = inPropertyKey;
+		if ( mKeyOverride )
+		{
+			retval = *mKeyOverride;
+			(*mKeyOverride)++;
+		}
+		return retval;
+	}
+
+	
+	void setupValueStructOffset( const ValueStructOffsetRecord&, bool, PxU32* ) {}
+	void setupValueStructOffset( const ValueStructOffsetRecord& inAccessor, PxU32 inOffset, PxU32* inAdditionalOffset ) 
+	{
+		//This allows us to nest properties correctly.
+		if ( inAdditionalOffset ) inOffset += *inAdditionalOffset;
+		inAccessor.setupValueStructOffset( inOffset );
+	}
+	
+	template<PxU32 TKey, typename TAccessorType>
+	void handleAccessor( PxU32 inKey, const TAccessorType& inAccessor )
+	{
+		typedef typename TAccessorType::prop_type TPropertyType;
+		dispatchAccessor<TKey>(	inKey
+								, inAccessor
+								, PxEnumTraits<TPropertyType>().NameConversion
+								, PxClassInfoTraits<TPropertyType>().getInfo()
+								, IsFlagsType<TPropertyType>().FlagData );
+	}
+
+
+	template<PxU32 TKey, typename TAccessorType>
+	void handleAccessor( const TAccessorType& inAccessor )
+	{
+		setupValueStructOffset( inAccessor, PxPropertyToValueStructMemberMap<TKey>().Offset, mOffsetOverride );
+		handleAccessor<TKey>( getKeyValue( TKey ), inAccessor );
+	}
+
+	template<PxU32 TKey, typename TObjType, typename TPropertyType>
+	void operator()( const PxReadOnlyPropertyInfo<TKey,TObjType,TPropertyType>& inProperty, PxU32 )
+	{
+		PxPvdReadOnlyPropertyAccessor< TKey, TObjType, TPropertyType > theAccessor( inProperty );
+		mOperator.pushName( inProperty.mName );
+		handleAccessor<TKey>( theAccessor );
+		mOperator.popName();
+	}
+
+	//We don't handle unbounded indexed properties
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType, typename TValueConversionType, typename TInfoType>
+	void indexedProperty( PxU32, const PxIndexedPropertyInfo<TKey, TObjType, TIndexType, TPropertyType >&, bool, TValueConversionType, const TInfoType& ) {}
+
+
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType>
+	void indexedProperty( PxU32, const PxIndexedPropertyInfo<TKey, TObjType, TIndexType, TPropertyType >& inProp, const PxU32ToName* theConversions, const PxUnknownClassInfo& )
+	{
+		mOperator.pushName( inProp.mName );
+		PxU32 rangeStart = TKey;
+		PxU32& propIdx = mKeyOverride == NULL ? rangeStart : *mKeyOverride;
+		PxU32 theOffset = 0; 
+		if ( mOffsetOverride ) theOffset = *mOffsetOverride;
+		
+		while( theConversions->mName != NULL )
+		{
+			mOperator.pushBracketedName( theConversions->mName );
+			PxPvdIndexedPropertyAccessor<TKey, TObjType, TIndexType, TPropertyType> theAccessor( inProp, theConversions->mValue );
+			setupValueStructOffset( theAccessor, PxPropertyToValueStructMemberMap<TKey>().Offset, &theOffset );
+			handleAccessor<TKey>( propIdx, theAccessor );
+			mOperator.popName();
+			++propIdx;
+			++theConversions;
+			theOffset += sizeof( TPropertyType );
+		}
+		mOperator.popName();
+	}
+
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType, typename TInfoType>
+	void indexedProperty( PxU32, const PxIndexedPropertyInfo<TKey, TObjType, TIndexType, TPropertyType >& inProp, const PxU32ToName* theConversions, const TInfoType& inInfo )
+	{
+		//ouch, not nice.  Indexed complex property.
+		mOperator.pushName( inProp.mName );
+		PxU32 propIdx = TKey;
+		PxU32 theOffset = 0; 
+		if ( mOffsetOverride ) theOffset = *mOffsetOverride;
+
+		while( theConversions->mName != NULL )
+		{
+			mOperator.pushBracketedName( theConversions->mName );
+			PxPvdIndexedPropertyAccessor<TKey, TObjType, TIndexType, TPropertyType> theAccessor( inProp, theConversions->mValue );
+			setupValueStructOffset( theAccessor, PxPropertyToValueStructMemberMap<TKey>().Offset, &theOffset );
+			PX_ASSERT( theAccessor.mHasValidOffset );			
+			mOperator.complexProperty( &propIdx, theAccessor, inInfo );
+			mOperator.popName();
+			++theConversions;
+			theOffset += sizeof( TPropertyType );
+		}
+		mOperator.popName();
+	}
+	
+	static char* myStrcat(const char* a,const char * b)
+	{
+		size_t len = strlen(a)+strlen(b);
+		char* result = new char[len+1];
+
+		strcpy(result,a);
+		strcat(result,b);
+		result[len] = 0;
+
+		return result;
+	}
+
+	template<PxU32 TKey, typename TObjType, typename TPropertyType, typename TInfoType>
+	void handleBufferCollectionProperty(PxU32 , const PxBufferCollectionPropertyInfo<TKey, TObjType, TPropertyType >& inProp, const TInfoType& inInfo)
+	{
+		//append 'Collection' to buffer properties
+		char* name = myStrcat(inProp.mName, "Collection");		
+		
+		mOperator.pushName(name);
+		PxU32 propIdx = TKey;
+		PxU32 theOffset = 0; 
+		
+		PxBufferCollectionPropertyAccessor<TKey, TObjType, TPropertyType> theAccessor( inProp, inProp.mName );
+		setupValueStructOffset( theAccessor, PxPropertyToValueStructMemberMap<TKey>().Offset, &theOffset );
+			
+		mOperator.bufferCollectionProperty( &propIdx, theAccessor, inInfo );	
+		mOperator.popName();
+		delete []name;
+	}
+
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType>
+	void operator()( const PxIndexedPropertyInfo<TKey, TObjType, TIndexType, TPropertyType >& inProp, PxU32 inIndex ) 
+	{
+		indexedProperty( inIndex, inProp, IndexerToNameMap<TKey,TIndexType>().Converter.NameConversion
+							, PxClassInfoTraits<TPropertyType>().Info );
+	}
+	
+	template<PxU32 TKey, typename TObjType, typename TPropertyType, typename TIndexType, typename TInfoType>
+	void handleExtendedIndexProperty(PxU32 inIndex, const PxExtendedIndexedPropertyInfo<TKey, TObjType, TIndexType, TPropertyType >& inProp, const TInfoType& inInfo)
+	{
+		mOperator.pushName(inProp.mName);
+		PxU32 propIdx = TKey;
+		PxU32 theOffset = 0; 
+		
+		PxPvdExtendedIndexedPropertyAccessor<TKey, TObjType, TIndexType, TPropertyType> theAccessor( inProp, inIndex );
+		setupValueStructOffset( theAccessor, PxPropertyToValueStructMemberMap<TKey>().Offset, &theOffset );
+			
+		mOperator.extendedIndexedProperty( &propIdx, theAccessor, inInfo );	
+		mOperator.popName();
+	}
+
+	template<PxU32 TKey, typename TObjType, typename TPropertyType, typename TIndexType, typename TInfoType>
+	void handlePxFixedSizeLookupTableProperty( const PxU32 inIndex, const PxFixedSizeLookupTablePropertyInfo<TKey, TObjType, TIndexType, TPropertyType >& inProp, const TInfoType& inInfo) 
+	{
+		mOperator.pushName(inProp.mName);
+		
+		PxU32 propIdx = TKey;
+		PxU32 theOffset = 0; 
+		
+		PxPvdFixedSizeLookupTablePropertyAccessor<TKey, TObjType, TIndexType, TPropertyType> theAccessor( inProp, inIndex );
+		setupValueStructOffset( theAccessor, PxPropertyToValueStructMemberMap<TKey>().Offset, &theOffset );
+			
+		mOperator.PxFixedSizeLookupTableProperty( &propIdx, theAccessor, inInfo );	
+
+		mOperator.popName();
+	}
+
+    template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType>
+	void operator()( const PxExtendedIndexedPropertyInfo<TKey, TObjType, TIndexType, TPropertyType >& inProp, PxU32 inIndex ) 
+	{
+		handleExtendedIndexProperty( inIndex, inProp, PxClassInfoTraits<TPropertyType>().Info );
+	}
+
+    template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType>
+	void operator()( const PxFixedSizeLookupTablePropertyInfo<TKey, TObjType, TIndexType, TPropertyType >& inProp, PxU32 inIndex) 
+	{
+		handlePxFixedSizeLookupTableProperty(inIndex, inProp, PxClassInfoTraits<TPropertyType>().Info);
+	}
+	
+	//We don't handle unbounded indexed properties
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TIndex2Type, typename TPropertyType, typename TNameConv, typename TNameConv2 >
+	void dualIndexedProperty( PxU32 idx, const PxDualIndexedPropertyInfo<TKey, TObjType, TIndexType, TIndex2Type, TPropertyType >&, TNameConv, TNameConv2 ) { PX_UNUSED(idx); }
+
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TIndex2Type, typename TPropertyType>
+	void dualIndexedProperty( PxU32 /*idx*/, const PxDualIndexedPropertyInfo<TKey, TObjType, TIndexType, TIndex2Type, TPropertyType >& inProp, const PxU32ToName* c1, const PxU32ToName* c2 )
+	{
+		mOperator.pushName( inProp.mName );
+		PxU32 rangeStart = TKey;
+		PxU32& propIdx = mKeyOverride == NULL ? rangeStart : *mKeyOverride;
+		PxU32 theOffset = 0; 
+		if ( mOffsetOverride ) theOffset = *mOffsetOverride;
+		while( c1->mName != NULL )
+		{
+			mOperator.pushBracketedName( c1->mName );
+			const PxU32ToName* c2Idx = c2;
+			while( c2Idx->mName != NULL )
+			{
+				mOperator.pushBracketedName( c2Idx->mName );
+				PxPvdDualIndexedPropertyAccessor<TKey, TObjType, TIndexType, TIndex2Type, TPropertyType> theAccessor( inProp, c1->mValue, c2Idx->mValue );
+				setupValueStructOffset( theAccessor, PxPropertyToValueStructMemberMap<TKey>().Offset, &theOffset );
+				handleAccessor<TKey>( propIdx, theAccessor );
+				mOperator.popName();
+				++propIdx;
+				++c2Idx;
+				theOffset += sizeof( TPropertyType );
+			}
+			mOperator.popName();
+			++c1;
+		}
+		mOperator.popName();
+	}
+
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TIndex2Type, typename TPropertyType>
+	void extendedDualIndexedProperty( PxU32 /*idx*/, const PxExtendedDualIndexedPropertyInfo<TKey, TObjType, TIndexType, TIndex2Type, TPropertyType >& inProp, PxU32 id0Count, PxU32 id1Count )
+	{
+		mOperator.pushName( inProp.mName );
+		PxU32 rangeStart = TKey;
+		PxU32& propIdx = mKeyOverride == NULL ? rangeStart : *mKeyOverride;
+		PxU32 theOffset = 0; 
+		if ( mOffsetOverride ) theOffset = *mOffsetOverride;
+		for(PxU32 i = 0; i < id0Count; ++i)
+		{
+			char buffer1[32] = { 0 };
+		    sprintf( buffer1, "eId1_%u", i );
+
+			mOperator.pushBracketedName( buffer1 );
+			for(PxU32 j = 0; j < id1Count; ++j)
+			{
+				char buffer2[32] = { 0 };
+				sprintf( buffer2, "eId2_%u", j );
+
+				mOperator.pushBracketedName( buffer2 );
+				PxPvdExtendedDualIndexedPropertyAccessor<TKey, TObjType, TIndexType, TIndex2Type, TPropertyType> theAccessor( inProp, i, j );
+				setupValueStructOffset( theAccessor, PxPropertyToValueStructMemberMap<TKey>().Offset, &theOffset );
+				handleAccessor<TKey>( propIdx, theAccessor );
+				mOperator.popName();
+				++propIdx;
+				theOffset += sizeof( TPropertyType );
+			}
+			mOperator.popName();
+		}
+		mOperator.popName();
+	}
+
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TIndex2Type, typename TPropertyType>
+	void operator()( const PxDualIndexedPropertyInfo<TKey, TObjType, TIndexType, TIndex2Type, TPropertyType >& inProp, PxU32 idx ) 
+	{
+		dualIndexedProperty( idx, inProp
+								, IndexerToNameMap<TKey,TIndexType>().Converter.NameConversion
+								, IndexerToNameMap<TKey,TIndex2Type>().Converter.NameConversion );
+	}
+	
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TIndex2Type, typename TPropertyType>
+	void operator()( const PxExtendedDualIndexedPropertyInfo<TKey, TObjType, TIndexType, TIndex2Type, TPropertyType >& inProp, PxU32 idx ) 
+	{
+		extendedDualIndexedProperty( idx, inProp, inProp.mId0Count, inProp.mId1Count );
+	}
+
+	template<PxU32 TKey, typename TObjType, typename TPropertyType>
+	void operator()( const PxRangePropertyInfo<TKey, TObjType, TPropertyType>& inProperty, PxU32 /*idx*/)
+	{
+		PxU32 rangeStart = TKey;
+		PxU32& propIdx = mKeyOverride == NULL ? rangeStart : *mKeyOverride;
+		PxU32 theOffset = 0; 
+		if ( mOffsetOverride ) theOffset = *mOffsetOverride;
+
+		mOperator.pushName( inProperty.mName );
+		mOperator.pushName( inProperty.mArg0Name );
+		PxPvdRangePropertyAccessor<TKey, TObjType, TPropertyType> theAccessor( inProperty, true );
+		setupValueStructOffset( theAccessor, PxPropertyToValueStructMemberMap<TKey>().Offset, &theOffset );
+		handleAccessor<TKey>( propIdx, theAccessor );
+		++propIdx;
+		theOffset += sizeof( TPropertyType );
+		mOperator.popName();
+		mOperator.pushName( inProperty.mArg1Name );
+		theAccessor.mFirstValue = false;
+		setupValueStructOffset( theAccessor, PxPropertyToValueStructMemberMap<TKey>().Offset, &theOffset );
+		handleAccessor<TKey>( propIdx, theAccessor );
+		mOperator.popName();
+		mOperator.popName();
+	}
+
+	template<PxU32 TKey, typename TObjType, typename TPropertyType>
+	void operator()( const PxBufferCollectionPropertyInfo<TKey, TObjType, TPropertyType>& inProp, PxU32 count )
+	{
+		handleBufferCollectionProperty( count, inProp, PxClassInfoTraits<TPropertyType>().Info );
+	}
+
+	template<PxU32 TKey, typename TObjectType, typename TPropertyType, PxU32 TEnableFlag>
+	void handleBuffer( const PxBufferPropertyInfo<TKey, TObjectType, TPropertyType, TEnableFlag>& inProp )
+	{
+		mOperator.handleBuffer( inProp );
+	}
+	
+	template<PxU32 TKey, typename TObjectType, typename TEnumType, typename TStorageType, PxU32 TEnableFlag>
+	void handleBuffer( const PxBufferPropertyInfo<TKey, TObjectType, PxStrideIterator<const PxFlags<TEnumType, TStorageType> >, TEnableFlag>& inProp )
+	{
+		mOperator.handleFlagsBuffer( inProp, PxEnumTraits<TEnumType>().NameConversion );
+	}
+
+	template<PxU32 TKey, typename TObjectType, typename TPropertyType, PxU32 TEnableFlag>
+	void operator()( const PxBufferPropertyInfo<TKey, TObjectType, TPropertyType, TEnableFlag>& inProp, PxU32 )
+	{
+		handleBuffer( inProp );
+	}
+	
+	template<PxU32 TKey, typename TObjType>
+	void operator()( const PxReadOnlyCollectionPropertyInfo<TKey, TObjType, PxU32>& prop, PxU32 ) 
+	{
+		mOperator.handleCollection( prop );
+	}
+	
+	template<PxU32 TKey, typename TObjType>
+	void operator()( const PxReadOnlyCollectionPropertyInfo<TKey, TObjType, PxReal>& prop, PxU32 ) 
+	{
+		mOperator.handleCollection( prop );
+	}
+
+	template<PxU32 TKey, typename TObjType, typename TPropertyType>
+	void operator()( const PxWriteOnlyPropertyInfo<TKey,TObjType,TPropertyType>&, PxU32 ) {}
+
+	template<PxU32 TKey, typename TObjType, typename TCollectionType>
+	void operator()( const PxReadOnlyCollectionPropertyInfo<TKey, TObjType, TCollectionType>&, PxU32 ) {}
+
+	template<PxU32 TKey, typename TObjType, typename TCollectionType, typename TFilterType>
+	void operator()( const PxReadOnlyFilteredCollectionPropertyInfo<TKey, TObjType, TCollectionType, TFilterType >&, PxU32 ) {}
+
+
+	//We don't deal with these property datatypes.
+#define DEFINE_PVD_PROPERTY_NOP(datatype) \
+	template<PxU32 TKey, typename TObjType> \
+	void operator()( const PxReadOnlyPropertyInfo<TKey,TObjType,datatype>& inProperty, PxU32 ){PX_UNUSED(inProperty); }
+	
+	DEFINE_PVD_PROPERTY_NOP( const void* )
+	DEFINE_PVD_PROPERTY_NOP( void* )
+	DEFINE_PVD_PROPERTY_NOP( PxSimulationFilterCallback * )
+	DEFINE_PVD_PROPERTY_NOP( physx::PxTaskManager * )
+	DEFINE_PVD_PROPERTY_NOP( PxSimulationFilterShader * )
+	DEFINE_PVD_PROPERTY_NOP( PxSimulationFilterShader)
+	DEFINE_PVD_PROPERTY_NOP( PxContactModifyCallback * )
+	DEFINE_PVD_PROPERTY_NOP( PxCCDContactModifyCallback * )
+	DEFINE_PVD_PROPERTY_NOP( PxSimulationEventCallback * )
+	DEFINE_PVD_PROPERTY_NOP( physx::PxGpuDispatcher* )
+	DEFINE_PVD_PROPERTY_NOP( physx::PxCpuDispatcher * )
+	DEFINE_PVD_PROPERTY_NOP( PxRigidActor )
+	DEFINE_PVD_PROPERTY_NOP( const PxRigidActor )
+	DEFINE_PVD_PROPERTY_NOP( PxRigidActor& )
+	DEFINE_PVD_PROPERTY_NOP( const PxRigidActor& )
+	DEFINE_PVD_PROPERTY_NOP( PxScene* )
+	DEFINE_PVD_PROPERTY_NOP( PxConstraint )
+	DEFINE_PVD_PROPERTY_NOP( PxConstraint* )
+	DEFINE_PVD_PROPERTY_NOP( PxConstraint& )
+	DEFINE_PVD_PROPERTY_NOP( const PxConstraint& )
+	DEFINE_PVD_PROPERTY_NOP( PxAggregate * )
+	DEFINE_PVD_PROPERTY_NOP( PxArticulation& )
+	DEFINE_PVD_PROPERTY_NOP( const PxArticulationLink * )
+	DEFINE_PVD_PROPERTY_NOP( const PxParticleFluid * )
+	DEFINE_PVD_PROPERTY_NOP( const PxParticleSystem * )
+	DEFINE_PVD_PROPERTY_NOP( const PxRigidDynamic * )
+	DEFINE_PVD_PROPERTY_NOP( const PxRigidStatic * )
+	DEFINE_PVD_PROPERTY_NOP( const PxParticleBase * )
+	DEFINE_PVD_PROPERTY_NOP( PxArticulationJoint * )
+	DEFINE_PVD_PROPERTY_NOP( const PxCloth * )
+	DEFINE_PVD_PROPERTY_NOP( PxBroadPhaseCallback * )
+	DEFINE_PVD_PROPERTY_NOP( const PxBroadPhaseRegion * )
+	DEFINE_PVD_PROPERTY_NOP( PxU32 * )
+
+};
+
+template<typename TOperator>
+inline PvdPropertyFilter<TOperator> makePvdPropertyFilter( TOperator inOperator )
+{
+	return PvdPropertyFilter<TOperator>( inOperator );
+}
+
+template<typename TOperator>
+inline PvdPropertyFilter<TOperator> makePvdPropertyFilter( TOperator inOperator, PxU32* inKey, PxU32* inOffset )
+{
+	return PvdPropertyFilter<TOperator>( inOperator, inKey, inOffset );
+}
+
+template<typename TOperator, typename TFuncType>
+inline void visitWithPvdFilter( TOperator inOperator, TFuncType inFuncType )
+{
+	PX_UNUSED(inFuncType);
+	TFuncType( makePvdPropertyFilter( inOperator ) );
+}
+
+template<typename TObjType, typename TOperator> 
+inline void visitInstancePvdProperties( TOperator inOperator )
+{
+	visitInstanceProperties<TObjType>( makePvdPropertyFilter( inOperator ) );
+}
+
+template<typename TOperator>
+struct PvdAllPropertyVisitor
+{
+	TOperator mOperator;
+	PvdAllPropertyVisitor( TOperator op ) : mOperator( op ) {}
+	template<typename TObjectType>
+	bool operator()( const TObjectType* ) { visitInstancePvdProperties<TObjectType>( mOperator ); return false; }
+};
+
+
+template<typename TOperator>
+struct PvdAllInfoVisitor
+{
+	TOperator mOperator;
+	PvdAllInfoVisitor( TOperator op ) : mOperator( op ) {}
+	template<typename TInfoType>
+	void operator()( TInfoType inInfo ) 
+	{ 
+		inInfo.template visitType<bool>( PvdAllPropertyVisitor<TOperator>( mOperator ) );
+		inInfo.visitBases( *this );
+	}
+};
+
+
+template<typename TObjType, typename TOperator> 
+inline void visitAllPvdProperties( TOperator inOperator )
+{
+	visitAllProperties<TObjType>( makePvdPropertyFilter( inOperator ) );
+}
+
+
+
+template<typename TOperator>
+inline void visitRigidDynamicPerFrameProperties( TOperator inOperator )
+{
+	PvdPropertyFilter<TOperator> theFilter( inOperator );
+	PxRigidDynamicGeneratedInfo theInfo;
+	theFilter( theInfo.GlobalPose, 0 );
+	theFilter( theInfo.LinearVelocity, 1 );
+	theFilter( theInfo.AngularVelocity, 2 );
+	theFilter( theInfo.IsSleeping, 3 );
+}
+
+template<typename TOperator>
+inline void visitArticulationLinkPerFrameProperties( TOperator inOperator )
+{
+	PvdPropertyFilter<TOperator> theFilter( inOperator );
+	PxArticulationLinkGeneratedInfo theInfo;
+	theFilter( theInfo.GlobalPose, 0 );
+	theFilter( theInfo.LinearVelocity, 1 );
+	theFilter( theInfo.AngularVelocity, 2 );
+}
+
+}
+
+}
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXMetaData/core/include/PxAutoGeneratedMetaDataObjectNames.h b/PhysX_3.4/Source/PhysXMetaData/core/include/PxAutoGeneratedMetaDataObjectNames.h
new file mode 100644
index 00000000..45022743
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/core/include/PxAutoGeneratedMetaDataObjectNames.h
@@ -0,0 +1,471 @@
+// 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.
+
+// This code is auto-generated by the PhysX Clang metadata generator.  Do not edit or be
+// prepared for your edits to be quietly ignored next time the clang metadata generator is
+// run.  You can find the most recent version of clang metadata generator by contacting
+// Chris Nuernberger <[email protected]> or Dilip or Adam.
+// The source code for the generate was at one time checked into:
+// physx/PhysXMetaDataGenerator/llvm/tools/clang/lib/Frontend/PhysXMetaDataAction.cpp
+#define THERE_IS_NO_INCLUDE_GUARD_HERE_FOR_A_REASON
+
+PxPhysics_PropertiesStart,
+PxPhysics_TolerancesScale,
+PxPhysics_TriangleMeshes,
+PxPhysics_HeightFields,
+PxPhysics_ConvexMeshes,
+PxPhysics_ClothFabrics,
+PxPhysics_Scenes,
+PxPhysics_Shapes,
+PxPhysics_Materials,
+PxPhysics_PropertiesStop,
+PxMaterial_PropertiesStart,
+PxMaterial_ReferenceCount,
+PxMaterial_DynamicFriction,
+PxMaterial_StaticFriction,
+PxMaterial_Restitution,
+PxMaterial_Flags,
+PxMaterial_FrictionCombineMode,
+PxMaterial_RestitutionCombineMode,
+PxMaterial_ConcreteTypeName,
+PxMaterial_UserData,
+PxMaterial_PropertiesStop,
+PxActor_PropertiesStart,
+PxActor_Scene,
+PxActor_Name,
+PxActor_ActorFlags,
+PxActor_DominanceGroup,
+PxActor_OwnerClient,
+PxActor_ClientBehaviorFlags,
+PxActor_Aggregate,
+PxActor_UserData,
+PxActor_PropertiesStop,
+PxRigidActor_PropertiesStart,
+PxRigidActor_GlobalPose,
+PxRigidActor_Shapes,
+PxRigidActor_Constraints,
+PxRigidActor_PropertiesStop,
+PxRigidBody_PropertiesStart,
+PxRigidBody_CMassLocalPose,
+PxRigidBody_Mass,
+PxRigidBody_InvMass,
+PxRigidBody_MassSpaceInertiaTensor,
+PxRigidBody_MassSpaceInvInertiaTensor,
+PxRigidBody_LinearVelocity,
+PxRigidBody_AngularVelocity,
+PxRigidBody_RigidBodyFlags,
+PxRigidBody_MinCCDAdvanceCoefficient,
+PxRigidBody_MaxDepenetrationVelocity,
+PxRigidBody_MaxContactImpulse,
+PxRigidBody_PropertiesStop,
+PxRigidDynamic_PropertiesStart,
+PxRigidDynamic_KinematicTarget,
+PxRigidDynamic_LinearDamping,
+PxRigidDynamic_AngularDamping,
+PxRigidDynamic_MaxAngularVelocity,
+PxRigidDynamic_IsSleeping,
+PxRigidDynamic_SleepThreshold,
+PxRigidDynamic_StabilizationThreshold,
+PxRigidDynamic_RigidDynamicLockFlags,
+PxRigidDynamic_WakeCounter,
+PxRigidDynamic_SolverIterationCounts,
+PxRigidDynamic_ContactReportThreshold,
+PxRigidDynamic_ConcreteTypeName,
+PxRigidDynamic_PropertiesStop,
+PxRigidStatic_PropertiesStart,
+PxRigidStatic_ConcreteTypeName,
+PxRigidStatic_PropertiesStop,
+PxArticulationLink_PropertiesStart,
+PxArticulationLink_InboundJoint,
+PxArticulationLink_Children,
+PxArticulationLink_ConcreteTypeName,
+PxArticulationLink_PropertiesStop,
+PxArticulationJoint_PropertiesStart,
+PxArticulationJoint_ParentPose,
+PxArticulationJoint_ChildPose,
+PxArticulationJoint_TargetOrientation,
+PxArticulationJoint_TargetVelocity,
+PxArticulationJoint_DriveType,
+PxArticulationJoint_Stiffness,
+PxArticulationJoint_Damping,
+PxArticulationJoint_InternalCompliance,
+PxArticulationJoint_ExternalCompliance,
+PxArticulationJoint_SwingLimit,
+PxArticulationJoint_TangentialStiffness,
+PxArticulationJoint_TangentialDamping,
+PxArticulationJoint_SwingLimitContactDistance,
+PxArticulationJoint_SwingLimitEnabled,
+PxArticulationJoint_TwistLimit,
+PxArticulationJoint_TwistLimitEnabled,
+PxArticulationJoint_TwistLimitContactDistance,
+PxArticulationJoint_ConcreteTypeName,
+PxArticulationJoint_PropertiesStop,
+PxArticulation_PropertiesStart,
+PxArticulation_Scene,
+PxArticulation_MaxProjectionIterations,
+PxArticulation_SeparationTolerance,
+PxArticulation_InternalDriveIterations,
+PxArticulation_ExternalDriveIterations,
+PxArticulation_SolverIterationCounts,
+PxArticulation_IsSleeping,
+PxArticulation_SleepThreshold,
+PxArticulation_StabilizationThreshold,
+PxArticulation_WakeCounter,
+PxArticulation_Links,
+PxArticulation_Name,
+PxArticulation_Aggregate,
+PxArticulation_ConcreteTypeName,
+PxArticulation_UserData,
+PxArticulation_PropertiesStop,
+PxAggregate_PropertiesStart,
+PxAggregate_MaxNbActors,
+PxAggregate_Actors,
+PxAggregate_SelfCollision,
+PxAggregate_ConcreteTypeName,
+PxAggregate_PropertiesStop,
+PxConstraint_PropertiesStart,
+PxConstraint_Scene,
+PxConstraint_Actors,
+PxConstraint_Flags,
+PxConstraint_IsValid,
+PxConstraint_BreakForce,
+PxConstraint_MinResponseThreshold,
+PxConstraint_ConcreteTypeName,
+PxConstraint_PropertiesStop,
+PxShape_PropertiesStart,
+PxShape_GeometryType,
+PxShape_Geometry,
+PxShape_LocalPose,
+PxShape_SimulationFilterData,
+PxShape_QueryFilterData,
+PxShape_Materials,
+PxShape_ContactOffset,
+PxShape_RestOffset,
+PxShape_Flags,
+PxShape_IsExclusive,
+PxShape_Name,
+PxShape_ConcreteTypeName,
+PxShape_UserData,
+PxShape_PropertiesStop,
+PxClothFabric_PropertiesStart,
+PxClothFabric_NbParticles,
+PxClothFabric_Phases,
+PxClothFabric_Sets,
+PxClothFabric_ParticleIndices,
+PxClothFabric_Restvalues,
+PxClothFabric_ReferenceCount,
+PxClothFabric_ConcreteTypeName,
+PxClothFabric_PropertiesStop,
+PxCloth_PropertiesStart,
+PxCloth_NbParticles,
+PxCloth_ClothFlags,
+PxCloth_TargetPose,
+PxCloth_GlobalPose,
+PxCloth_SolverFrequency,
+PxCloth_PreviousTimeStep,
+PxCloth_StiffnessFrequency,
+PxCloth_LinearInertiaScale,
+PxCloth_AngularInertiaScale,
+PxCloth_CentrifugalInertiaScale,
+PxCloth_InertiaScale,
+PxCloth_DampingCoefficient,
+PxCloth_LinearDragCoefficient,
+PxCloth_AngularDragCoefficient,
+PxCloth_DragCoefficient,
+PxCloth_ExternalAcceleration,
+PxCloth_WindVelocity,
+PxCloth_WindDrag,
+PxCloth_WindLift,
+PxCloth_MotionConstraintConfig,
+PxCloth_StretchConfig,
+PxCloth_TetherConfig,
+PxCloth_FrictionCoefficient,
+PxCloth_CollisionMassScale,
+PxCloth_SelfCollisionDistance,
+PxCloth_SelfCollisionStiffness,
+PxCloth_SimulationFilterData,
+PxCloth_ContactOffset,
+PxCloth_RestOffset,
+PxCloth_SleepLinearVelocity,
+PxCloth_WakeCounter,
+PxCloth_IsSleeping,
+PxCloth_ConcreteTypeName,
+PxCloth_PropertiesStop,
+PxParticleBase_PropertiesStart,
+PxParticleBase_Damping,
+PxParticleBase_ExternalAcceleration,
+PxParticleBase_ParticleMass,
+PxParticleBase_Restitution,
+PxParticleBase_DynamicFriction,
+PxParticleBase_StaticFriction,
+PxParticleBase_SimulationFilterData,
+PxParticleBase_ParticleBaseFlags,
+PxParticleBase_MaxParticles,
+PxParticleBase_MaxMotionDistance,
+PxParticleBase_RestOffset,
+PxParticleBase_ContactOffset,
+PxParticleBase_GridSize,
+PxParticleBase_ParticleReadDataFlags,
+PxParticleBase_ProjectionPlane,
+PxParticleBase_PropertiesStop,
+PxParticleFluid_PropertiesStart,
+PxParticleFluid_Stiffness,
+PxParticleFluid_Viscosity,
+PxParticleFluid_RestParticleDistance,
+PxParticleFluid_ConcreteTypeName,
+PxParticleFluid_PropertiesStop,
+PxParticleSystem_PropertiesStart,
+PxParticleSystem_ConcreteTypeName,
+PxParticleSystem_PropertiesStop,
+PxPruningStructure_PropertiesStart,
+PxPruningStructure_RigidActors,
+PxPruningStructure_ConcreteTypeName,
+PxPruningStructure_PropertiesStop,
+PxTolerancesScale_PropertiesStart,
+PxTolerancesScale_IsValid,
+PxTolerancesScale_Length,
+PxTolerancesScale_Mass,
+PxTolerancesScale_Speed,
+PxTolerancesScale_PropertiesStop,
+PxGeometry_PropertiesStart,
+PxGeometry_PropertiesStop,
+PxBoxGeometry_PropertiesStart,
+PxBoxGeometry_HalfExtents,
+PxBoxGeometry_PropertiesStop,
+PxCapsuleGeometry_PropertiesStart,
+PxCapsuleGeometry_Radius,
+PxCapsuleGeometry_HalfHeight,
+PxCapsuleGeometry_PropertiesStop,
+PxMeshScale_PropertiesStart,
+PxMeshScale_Scale,
+PxMeshScale_Rotation,
+PxMeshScale_PropertiesStop,
+PxConvexMeshGeometry_PropertiesStart,
+PxConvexMeshGeometry_Scale,
+PxConvexMeshGeometry_ConvexMesh,
+PxConvexMeshGeometry_MeshFlags,
+PxConvexMeshGeometry_PropertiesStop,
+PxSphereGeometry_PropertiesStart,
+PxSphereGeometry_IsValid,
+PxSphereGeometry_Radius,
+PxSphereGeometry_PropertiesStop,
+PxPlaneGeometry_PropertiesStart,
+PxPlaneGeometry_PropertiesStop,
+PxTriangleMeshGeometry_PropertiesStart,
+PxTriangleMeshGeometry_Scale,
+PxTriangleMeshGeometry_MeshFlags,
+PxTriangleMeshGeometry_TriangleMesh,
+PxTriangleMeshGeometry_PropertiesStop,
+PxHeightFieldGeometry_PropertiesStart,
+PxHeightFieldGeometry_HeightField,
+PxHeightFieldGeometry_HeightScale,
+PxHeightFieldGeometry_RowScale,
+PxHeightFieldGeometry_ColumnScale,
+PxHeightFieldGeometry_HeightFieldFlags,
+PxHeightFieldGeometry_PropertiesStop,
+PxHeightFieldDesc_PropertiesStart,
+PxHeightFieldDesc_IsValid,
+PxHeightFieldDesc_NbRows,
+PxHeightFieldDesc_NbColumns,
+PxHeightFieldDesc_Format,
+PxHeightFieldDesc_Samples,
+PxHeightFieldDesc_Thickness,
+PxHeightFieldDesc_ConvexEdgeThreshold,
+PxHeightFieldDesc_Flags,
+PxHeightFieldDesc_PropertiesStop,
+PxScene_PropertiesStart,
+PxScene_Flags,
+PxScene_Limits,
+PxScene_Timestamp,
+PxScene_Actors,
+PxScene_Articulations,
+PxScene_Constraints,
+PxScene_Aggregates,
+PxScene_CpuDispatcher,
+PxScene_GpuDispatcher,
+PxScene_ClothInterCollisionDistance,
+PxScene_ClothInterCollisionStiffness,
+PxScene_ClothInterCollisionNbIterations,
+PxScene_ContactModifyCallback,
+PxScene_CCDContactModifyCallback,
+PxScene_FilterShaderDataSize,
+PxScene_FilterShader,
+PxScene_FilterCallback,
+PxScene_Gravity,
+PxScene_BounceThresholdVelocity,
+PxScene_CCDMaxPasses,
+PxScene_FrictionOffsetThreshold,
+PxScene_FrictionType,
+PxScene_VisualizationCullingBox,
+PxScene_StaticStructure,
+PxScene_DynamicStructure,
+PxScene_DynamicTreeRebuildRateHint,
+PxScene_SceneQueryStaticTimestamp,
+PxScene_BroadPhaseType,
+PxScene_BroadPhaseRegions,
+PxScene_TaskManager,
+PxScene_NbContactDataBlocks,
+PxScene_MaxNbContactDataBlocksUsed,
+PxScene_ContactReportStreamBufferSize,
+PxScene_SolverBatchSize,
+PxScene_WakeCounterResetValue,
+PxScene_UserData,
+PxScene_SimulationStatistics,
+PxScene_PropertiesStop,
+PxClothParticle_PropertiesStart,
+PxClothParticle_Pos,
+PxClothParticle_InvWeight,
+PxClothParticle_PropertiesStop,
+PxClothFabricPhase_PropertiesStart,
+PxClothFabricPhase_PhaseType,
+PxClothFabricPhase_SetIndex,
+PxClothFabricPhase_PropertiesStop,
+PxSceneLimits_PropertiesStart,
+PxSceneLimits_MaxNbActors,
+PxSceneLimits_MaxNbBodies,
+PxSceneLimits_MaxNbStaticShapes,
+PxSceneLimits_MaxNbDynamicShapes,
+PxSceneLimits_MaxNbAggregates,
+PxSceneLimits_MaxNbConstraints,
+PxSceneLimits_MaxNbRegions,
+PxSceneLimits_MaxNbBroadPhaseOverlaps,
+PxSceneLimits_MaxNbObjectsPerRegion,
+PxSceneLimits_PropertiesStop,
+PxgDynamicsMemoryConfig_PropertiesStart,
+PxgDynamicsMemoryConfig_ConstraintBufferCapacity,
+PxgDynamicsMemoryConfig_ContactBufferCapacity,
+PxgDynamicsMemoryConfig_TempBufferCapacity,
+PxgDynamicsMemoryConfig_ContactStreamSize,
+PxgDynamicsMemoryConfig_PatchStreamSize,
+PxgDynamicsMemoryConfig_ForceStreamCapacity,
+PxgDynamicsMemoryConfig_HeapCapacity,
+PxgDynamicsMemoryConfig_FoundLostPairsCapacity,
+PxgDynamicsMemoryConfig_PropertiesStop,
+PxSceneDesc_PropertiesStart,
+PxSceneDesc_ToDefault,
+PxSceneDesc_IsValid,
+PxSceneDesc_Gravity,
+PxSceneDesc_SimulationEventCallback,
+PxSceneDesc_ContactModifyCallback,
+PxSceneDesc_CcdContactModifyCallback,
+PxSceneDesc_FilterShaderData,
+PxSceneDesc_FilterShaderDataSize,
+PxSceneDesc_FilterShader,
+PxSceneDesc_FilterCallback,
+PxSceneDesc_BroadPhaseType,
+PxSceneDesc_BroadPhaseCallback,
+PxSceneDesc_Limits,
+PxSceneDesc_FrictionType,
+PxSceneDesc_BounceThresholdVelocity,
+PxSceneDesc_FrictionOffsetThreshold,
+PxSceneDesc_CcdMaxSeparation,
+PxSceneDesc_Flags,
+PxSceneDesc_CpuDispatcher,
+PxSceneDesc_GpuDispatcher,
+PxSceneDesc_StaticStructure,
+PxSceneDesc_DynamicStructure,
+PxSceneDesc_DynamicTreeRebuildRateHint,
+PxSceneDesc_UserData,
+PxSceneDesc_SolverBatchSize,
+PxSceneDesc_NbContactDataBlocks,
+PxSceneDesc_MaxNbContactDataBlocks,
+PxSceneDesc_ContactReportStreamBufferSize,
+PxSceneDesc_CcdMaxPasses,
+PxSceneDesc_WakeCounterResetValue,
+PxSceneDesc_SanityBounds,
+PxSceneDesc_GpuDynamicsConfig,
+PxSceneDesc_GpuMaxNumPartitions,
+PxSceneDesc_GpuComputeVersion,
+PxSceneDesc_PropertiesStop,
+PxSimulationStatistics_PropertiesStart,
+PxSimulationStatistics_NbActiveConstraints,
+PxSimulationStatistics_NbActiveDynamicBodies,
+PxSimulationStatistics_NbActiveKinematicBodies,
+PxSimulationStatistics_NbStaticBodies,
+PxSimulationStatistics_NbDynamicBodies,
+PxSimulationStatistics_NbAggregates,
+PxSimulationStatistics_NbArticulations,
+PxSimulationStatistics_NbAxisSolverConstraints,
+PxSimulationStatistics_CompressedContactSize,
+PxSimulationStatistics_RequiredContactConstraintMemory,
+PxSimulationStatistics_PeakConstraintMemory,
+PxSimulationStatistics_NbDiscreteContactPairsTotal,
+PxSimulationStatistics_NbDiscreteContactPairsWithCacheHits,
+PxSimulationStatistics_NbDiscreteContactPairsWithContacts,
+PxSimulationStatistics_NbNewPairs,
+PxSimulationStatistics_NbLostPairs,
+PxSimulationStatistics_NbNewTouches,
+PxSimulationStatistics_NbLostTouches,
+PxSimulationStatistics_NbPartitions,
+PxSimulationStatistics_ParticlesGpuMeshCacheSize,
+PxSimulationStatistics_ParticlesGpuMeshCacheUsed,
+PxSimulationStatistics_ParticlesGpuMeshCacheHitrate,
+PxSimulationStatistics_NbDiscreteContactPairs,
+PxSimulationStatistics_NbModifiedContactPairs,
+PxSimulationStatistics_NbCCDPairs,
+PxSimulationStatistics_NbTriggerPairs,
+PxSimulationStatistics_NbBroadPhaseAdds,
+PxSimulationStatistics_NbBroadPhaseRemoves,
+PxSimulationStatistics_NbShapes,
+PxSimulationStatistics_PropertiesStop,
+PxLockedData_PropertiesStart,
+PxLockedData_PropertiesStop,
+PxParticleReadData_PropertiesStart,
+PxParticleReadData_NbValidParticles,
+PxParticleReadData_ValidParticleRange,
+PxParticleReadData_ValidParticleBitmap,
+PxParticleReadData_PositionBuffer,
+PxParticleReadData_VelocityBuffer,
+PxParticleReadData_RestOffsetBuffer,
+PxParticleReadData_FlagsBuffer,
+PxParticleReadData_CollisionNormalBuffer,
+PxParticleReadData_CollisionVelocityBuffer,
+PxParticleReadData_PropertiesStop,
+PxClothStretchConfig_PropertiesStart,
+PxClothStretchConfig_Stiffness,
+PxClothStretchConfig_StiffnessMultiplier,
+PxClothStretchConfig_CompressionLimit,
+PxClothStretchConfig_StretchLimit,
+PxClothStretchConfig_PropertiesStop,
+PxClothTetherConfig_PropertiesStart,
+PxClothTetherConfig_Stiffness,
+PxClothTetherConfig_StretchLimit,
+PxClothTetherConfig_PropertiesStop,
+PxClothMotionConstraintConfig_PropertiesStart,
+PxClothMotionConstraintConfig_Scale,
+PxClothMotionConstraintConfig_Bias,
+PxClothMotionConstraintConfig_Stiffness,
+PxClothMotionConstraintConfig_PropertiesStop,
+PxClothParticleData_PropertiesStart,
+PxClothParticleData_Particles,
+PxClothParticleData_PreviousParticles,
+PxClothParticleData_PropertiesStop,
+
+
+#undef THERE_IS_NO_INCLUDE_GUARD_HERE_FOR_A_REASON
diff --git a/PhysX_3.4/Source/PhysXMetaData/core/include/PxAutoGeneratedMetaDataObjects.h b/PhysX_3.4/Source/PhysXMetaData/core/include/PxAutoGeneratedMetaDataObjects.h
new file mode 100644
index 00000000..4dbcf1a4
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/core/include/PxAutoGeneratedMetaDataObjects.h
@@ -0,0 +1,3672 @@
+// 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.
+
+// This code is auto-generated by the PhysX Clang metadata generator.  Do not edit or be
+// prepared for your edits to be quietly ignored next time the clang metadata generator is
+// run.  You can find the most recent version of clang metadata generator by contacting
+// Chris Nuernberger <[email protected]> or Dilip or Adam.
+// The source code for the generate was at one time checked into:
+// physx/PhysXMetaDataGenerator/llvm/tools/clang/lib/Frontend/PhysXMetaDataAction.cpp
+#define THERE_IS_NO_INCLUDE_GUARD_HERE_FOR_A_REASON
+
+#define PX_PROPERTY_INFO_NAME PxPropertyInfoName
+	static PxU32ToName g_physx__PxClothFlag__EnumConversion[] = {
+		{ "eDEFAULT", static_cast<PxU32>( physx::PxClothFlag::eDEFAULT ) },
+		{ "eCUDA", static_cast<PxU32>( physx::PxClothFlag::eCUDA ) },
+		{ "eGPU", static_cast<PxU32>( physx::PxClothFlag::eGPU ) },
+		{ "eSWEPT_CONTACT", static_cast<PxU32>( physx::PxClothFlag::eSWEPT_CONTACT ) },
+		{ "eSCENE_COLLISION", static_cast<PxU32>( physx::PxClothFlag::eSCENE_COLLISION ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxClothFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxClothFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxShapeFlag__EnumConversion[] = {
+		{ "eSIMULATION_SHAPE", static_cast<PxU32>( physx::PxShapeFlag::eSIMULATION_SHAPE ) },
+		{ "eSCENE_QUERY_SHAPE", static_cast<PxU32>( physx::PxShapeFlag::eSCENE_QUERY_SHAPE ) },
+		{ "eTRIGGER_SHAPE", static_cast<PxU32>( physx::PxShapeFlag::eTRIGGER_SHAPE ) },
+		{ "eVISUALIZATION", static_cast<PxU32>( physx::PxShapeFlag::eVISUALIZATION ) },
+		{ "ePARTICLE_DRAIN", static_cast<PxU32>( physx::PxShapeFlag::ePARTICLE_DRAIN ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxShapeFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxShapeFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxPhysics;
+	struct PxPhysicsGeneratedValues
+	{
+		PxTolerancesScale TolerancesScale;
+		 PX_PHYSX_CORE_API PxPhysicsGeneratedValues( const PxPhysics* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxPhysics, TolerancesScale, PxPhysicsGeneratedValues)
+	struct PxPhysicsGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxPhysics"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxPhysics_TolerancesScale, PxPhysics, const PxTolerancesScale & > TolerancesScale;
+		PxFactoryCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxPhysics_TriangleMeshes, PxPhysics, PxTriangleMesh *, PxInputStream & > TriangleMeshes;
+		PxFactoryCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxPhysics_HeightFields, PxPhysics, PxHeightField *, PxInputStream & > HeightFields;
+		PxFactoryCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxPhysics_ConvexMeshes, PxPhysics, PxConvexMesh *, PxInputStream & > ConvexMeshes;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxPhysics_ClothFabrics, PxPhysics, PxClothFabric * > ClothFabrics;
+		PxFactoryCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxPhysics_Scenes, PxPhysics, PxScene *, const PxSceneDesc & > Scenes;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxPhysics_Shapes, PxPhysics, PxShape * > Shapes;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxPhysics_Materials, PxPhysics, PxMaterial * > Materials;
+
+		PX_PHYSX_CORE_API PxPhysicsGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxPhysics*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 8; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( TolerancesScale, inStartIndex + 0 );; 
+			inOperator( TriangleMeshes, inStartIndex + 1 );; 
+			inOperator( HeightFields, inStartIndex + 2 );; 
+			inOperator( ConvexMeshes, inStartIndex + 3 );; 
+			inOperator( ClothFabrics, inStartIndex + 4 );; 
+			inOperator( Scenes, inStartIndex + 5 );; 
+			inOperator( Shapes, inStartIndex + 6 );; 
+			inOperator( Materials, inStartIndex + 7 );; 
+			return 8 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxPhysics>
+	{ 
+		PxPhysicsGeneratedInfo Info;
+		const PxPhysicsGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxMaterialFlag__EnumConversion[] = {
+		{ "eDISABLE_FRICTION", static_cast<PxU32>( physx::PxMaterialFlag::eDISABLE_FRICTION ) },
+		{ "eDISABLE_STRONG_FRICTION", static_cast<PxU32>( physx::PxMaterialFlag::eDISABLE_STRONG_FRICTION ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxMaterialFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxMaterialFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxCombineMode__EnumConversion[] = {
+		{ "eAVERAGE", static_cast<PxU32>( physx::PxCombineMode::eAVERAGE ) },
+		{ "eMIN", static_cast<PxU32>( physx::PxCombineMode::eMIN ) },
+		{ "eMULTIPLY", static_cast<PxU32>( physx::PxCombineMode::eMULTIPLY ) },
+		{ "eMAX", static_cast<PxU32>( physx::PxCombineMode::eMAX ) },
+		{ "eN_VALUES", static_cast<PxU32>( physx::PxCombineMode::eN_VALUES ) },
+		{ "ePAD_32", static_cast<PxU32>( physx::PxCombineMode::ePAD_32 ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxCombineMode::Enum > { PxEnumTraits() : NameConversion( g_physx__PxCombineMode__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxMaterial;
+	struct PxMaterialGeneratedValues
+	{
+		PxU32 ReferenceCount;
+		PxReal DynamicFriction;
+		PxReal StaticFriction;
+		PxReal Restitution;
+		PxMaterialFlags Flags;
+		PxCombineMode::Enum FrictionCombineMode;
+		PxCombineMode::Enum RestitutionCombineMode;
+		const char * ConcreteTypeName;
+		void * UserData;
+		 PX_PHYSX_CORE_API PxMaterialGeneratedValues( const PxMaterial* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxMaterial, ReferenceCount, PxMaterialGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxMaterial, DynamicFriction, PxMaterialGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxMaterial, StaticFriction, PxMaterialGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxMaterial, Restitution, PxMaterialGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxMaterial, Flags, PxMaterialGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxMaterial, FrictionCombineMode, PxMaterialGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxMaterial, RestitutionCombineMode, PxMaterialGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxMaterial, ConcreteTypeName, PxMaterialGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxMaterial, UserData, PxMaterialGeneratedValues)
+	struct PxMaterialGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxMaterial"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxMaterial_ReferenceCount, PxMaterial, PxU32 > ReferenceCount;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxMaterial_DynamicFriction, PxMaterial, PxReal, PxReal > DynamicFriction;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxMaterial_StaticFriction, PxMaterial, PxReal, PxReal > StaticFriction;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxMaterial_Restitution, PxMaterial, PxReal, PxReal > Restitution;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxMaterial_Flags, PxMaterial, PxMaterialFlags, PxMaterialFlags > Flags;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxMaterial_FrictionCombineMode, PxMaterial, PxCombineMode::Enum, PxCombineMode::Enum > FrictionCombineMode;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxMaterial_RestitutionCombineMode, PxMaterial, PxCombineMode::Enum, PxCombineMode::Enum > RestitutionCombineMode;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxMaterial_ConcreteTypeName, PxMaterial, const char * > ConcreteTypeName;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxMaterial_UserData, PxMaterial, void *, void * > UserData;
+
+		PX_PHYSX_CORE_API PxMaterialGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxMaterial*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 9; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( ReferenceCount, inStartIndex + 0 );; 
+			inOperator( DynamicFriction, inStartIndex + 1 );; 
+			inOperator( StaticFriction, inStartIndex + 2 );; 
+			inOperator( Restitution, inStartIndex + 3 );; 
+			inOperator( Flags, inStartIndex + 4 );; 
+			inOperator( FrictionCombineMode, inStartIndex + 5 );; 
+			inOperator( RestitutionCombineMode, inStartIndex + 6 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 7 );; 
+			inOperator( UserData, inStartIndex + 8 );; 
+			return 9 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxMaterial>
+	{ 
+		PxMaterialGeneratedInfo Info;
+		const PxMaterialGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxActorType__EnumConversion[] = {
+		{ "eRIGID_STATIC", static_cast<PxU32>( physx::PxActorType::eRIGID_STATIC ) },
+		{ "eRIGID_DYNAMIC", static_cast<PxU32>( physx::PxActorType::eRIGID_DYNAMIC ) },
+		{ "ePARTICLE_SYSTEM", static_cast<PxU32>( physx::PxActorType::ePARTICLE_SYSTEM ) },
+		{ "ePARTICLE_FLUID", static_cast<PxU32>( physx::PxActorType::ePARTICLE_FLUID ) },
+		{ "eARTICULATION_LINK", static_cast<PxU32>( physx::PxActorType::eARTICULATION_LINK ) },
+		{ "eCLOTH", static_cast<PxU32>( physx::PxActorType::eCLOTH ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxActorType::Enum > { PxEnumTraits() : NameConversion( g_physx__PxActorType__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxActorFlag__EnumConversion[] = {
+		{ "eVISUALIZATION", static_cast<PxU32>( physx::PxActorFlag::eVISUALIZATION ) },
+		{ "eDISABLE_GRAVITY", static_cast<PxU32>( physx::PxActorFlag::eDISABLE_GRAVITY ) },
+		{ "eSEND_SLEEP_NOTIFIES", static_cast<PxU32>( physx::PxActorFlag::eSEND_SLEEP_NOTIFIES ) },
+		{ "eDISABLE_SIMULATION", static_cast<PxU32>( physx::PxActorFlag::eDISABLE_SIMULATION ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxActorFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxActorFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxActorClientBehaviorFlag__EnumConversion[] = {
+		{ "eREPORT_TO_FOREIGN_CLIENTS_TRIGGER_NOTIFY", static_cast<PxU32>( physx::PxActorClientBehaviorFlag::eREPORT_TO_FOREIGN_CLIENTS_TRIGGER_NOTIFY ) },
+		{ "eREPORT_TO_FOREIGN_CLIENTS_CONTACT_NOTIFY", static_cast<PxU32>( physx::PxActorClientBehaviorFlag::eREPORT_TO_FOREIGN_CLIENTS_CONTACT_NOTIFY ) },
+		{ "eREPORT_TO_FOREIGN_CLIENTS_CONSTRAINT_BREAK_NOTIFY", static_cast<PxU32>( physx::PxActorClientBehaviorFlag::eREPORT_TO_FOREIGN_CLIENTS_CONSTRAINT_BREAK_NOTIFY ) },
+		{ "eREPORT_TO_FOREIGN_CLIENTS_SCENE_QUERY", static_cast<PxU32>( physx::PxActorClientBehaviorFlag::eREPORT_TO_FOREIGN_CLIENTS_SCENE_QUERY ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxActorClientBehaviorFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxActorClientBehaviorFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxActor;
+	struct PxActorGeneratedValues
+	{
+		PxScene * Scene;
+		const char * Name;
+		PxActorFlags ActorFlags;
+		PxDominanceGroup DominanceGroup;
+		PxClientID OwnerClient;
+		PxActorClientBehaviorFlags ClientBehaviorFlags;
+		PxAggregate * Aggregate;
+		void * UserData;
+		 PX_PHYSX_CORE_API PxActorGeneratedValues( const PxActor* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxActor, Scene, PxActorGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxActor, Name, PxActorGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxActor, ActorFlags, PxActorGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxActor, DominanceGroup, PxActorGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxActor, OwnerClient, PxActorGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxActor, ClientBehaviorFlags, PxActorGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxActor, Aggregate, PxActorGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxActor, UserData, PxActorGeneratedValues)
+	struct PxActorGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxActor"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxActor_Scene, PxActor, PxScene * > Scene;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxActor_Name, PxActor, const char *, const char * > Name;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxActor_ActorFlags, PxActor, PxActorFlags, PxActorFlags > ActorFlags;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxActor_DominanceGroup, PxActor, PxDominanceGroup, PxDominanceGroup > DominanceGroup;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxActor_OwnerClient, PxActor, PxClientID, PxClientID > OwnerClient;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxActor_ClientBehaviorFlags, PxActor, PxActorClientBehaviorFlags, PxActorClientBehaviorFlags > ClientBehaviorFlags;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxActor_Aggregate, PxActor, PxAggregate * > Aggregate;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxActor_UserData, PxActor, void *, void * > UserData;
+
+		PX_PHYSX_CORE_API PxActorGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxActor*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 8; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Scene, inStartIndex + 0 );; 
+			inOperator( Name, inStartIndex + 1 );; 
+			inOperator( ActorFlags, inStartIndex + 2 );; 
+			inOperator( DominanceGroup, inStartIndex + 3 );; 
+			inOperator( OwnerClient, inStartIndex + 4 );; 
+			inOperator( ClientBehaviorFlags, inStartIndex + 5 );; 
+			inOperator( Aggregate, inStartIndex + 6 );; 
+			inOperator( UserData, inStartIndex + 7 );; 
+			return 8 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxActor>
+	{ 
+		PxActorGeneratedInfo Info;
+		const PxActorGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxRigidActor;
+	struct PxRigidActorGeneratedValues
+		: PxActorGeneratedValues	{
+		PxTransform GlobalPose;
+		 PX_PHYSX_CORE_API PxRigidActorGeneratedValues( const PxRigidActor* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidActor, GlobalPose, PxRigidActorGeneratedValues)
+	struct PxRigidActorGeneratedInfo
+		: PxActorGeneratedInfo
+	{
+		static const char* getClassName() { return "PxRigidActor"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidActor_GlobalPose, PxRigidActor, const PxTransform &, PxTransform > GlobalPose;
+		PxRigidActorShapeCollection Shapes;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidActor_Constraints, PxRigidActor, PxConstraint * > Constraints;
+
+		PX_PHYSX_CORE_API PxRigidActorGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxRigidActor*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxActorGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxActorGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxActorGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 3; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxActorGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( GlobalPose, inStartIndex + 0 );; 
+			inOperator( Shapes, inStartIndex + 1 );; 
+			inOperator( Constraints, inStartIndex + 2 );; 
+			return 3 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxRigidActor>
+	{ 
+		PxRigidActorGeneratedInfo Info;
+		const PxRigidActorGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxForceMode__EnumConversion[] = {
+		{ "eFORCE", static_cast<PxU32>( physx::PxForceMode::eFORCE ) },
+		{ "eIMPULSE", static_cast<PxU32>( physx::PxForceMode::eIMPULSE ) },
+		{ "eVELOCITY_CHANGE", static_cast<PxU32>( physx::PxForceMode::eVELOCITY_CHANGE ) },
+		{ "eACCELERATION", static_cast<PxU32>( physx::PxForceMode::eACCELERATION ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxForceMode::Enum > { PxEnumTraits() : NameConversion( g_physx__PxForceMode__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxRigidBodyFlag__EnumConversion[] = {
+		{ "eKINEMATIC", static_cast<PxU32>( physx::PxRigidBodyFlag::eKINEMATIC ) },
+		{ "eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES", static_cast<PxU32>( physx::PxRigidBodyFlag::eUSE_KINEMATIC_TARGET_FOR_SCENE_QUERIES ) },
+		{ "eENABLE_CCD", static_cast<PxU32>( physx::PxRigidBodyFlag::eENABLE_CCD ) },
+		{ "eENABLE_CCD_FRICTION", static_cast<PxU32>( physx::PxRigidBodyFlag::eENABLE_CCD_FRICTION ) },
+		{ "eENABLE_POSE_INTEGRATION_PREVIEW", static_cast<PxU32>( physx::PxRigidBodyFlag::eENABLE_POSE_INTEGRATION_PREVIEW ) },
+		{ "eENABLE_SPECULATIVE_CCD", static_cast<PxU32>( physx::PxRigidBodyFlag::eENABLE_SPECULATIVE_CCD ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxRigidBodyFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxRigidBodyFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxRigidBody;
+	struct PxRigidBodyGeneratedValues
+		: PxRigidActorGeneratedValues	{
+		PxTransform CMassLocalPose;
+		PxReal Mass;
+		PxReal InvMass;
+		PxVec3 MassSpaceInertiaTensor;
+		PxVec3 MassSpaceInvInertiaTensor;
+		PxVec3 LinearVelocity;
+		PxVec3 AngularVelocity;
+		PxRigidBodyFlags RigidBodyFlags;
+		PxReal MinCCDAdvanceCoefficient;
+		PxReal MaxDepenetrationVelocity;
+		PxReal MaxContactImpulse;
+		 PX_PHYSX_CORE_API PxRigidBodyGeneratedValues( const PxRigidBody* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidBody, CMassLocalPose, PxRigidBodyGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidBody, Mass, PxRigidBodyGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidBody, InvMass, PxRigidBodyGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidBody, MassSpaceInertiaTensor, PxRigidBodyGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidBody, MassSpaceInvInertiaTensor, PxRigidBodyGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidBody, LinearVelocity, PxRigidBodyGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidBody, AngularVelocity, PxRigidBodyGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidBody, RigidBodyFlags, PxRigidBodyGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidBody, MinCCDAdvanceCoefficient, PxRigidBodyGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidBody, MaxDepenetrationVelocity, PxRigidBodyGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidBody, MaxContactImpulse, PxRigidBodyGeneratedValues)
+	struct PxRigidBodyGeneratedInfo
+		: PxRigidActorGeneratedInfo
+	{
+		static const char* getClassName() { return "PxRigidBody"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidBody_CMassLocalPose, PxRigidBody, const PxTransform &, PxTransform > CMassLocalPose;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidBody_Mass, PxRigidBody, PxReal, PxReal > Mass;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidBody_InvMass, PxRigidBody, PxReal > InvMass;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidBody_MassSpaceInertiaTensor, PxRigidBody, const PxVec3 &, PxVec3 > MassSpaceInertiaTensor;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidBody_MassSpaceInvInertiaTensor, PxRigidBody, PxVec3 > MassSpaceInvInertiaTensor;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidBody_LinearVelocity, PxRigidBody, const PxVec3 &, PxVec3 > LinearVelocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidBody_AngularVelocity, PxRigidBody, const PxVec3 &, PxVec3 > AngularVelocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidBody_RigidBodyFlags, PxRigidBody, PxRigidBodyFlags, PxRigidBodyFlags > RigidBodyFlags;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidBody_MinCCDAdvanceCoefficient, PxRigidBody, PxReal, PxReal > MinCCDAdvanceCoefficient;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidBody_MaxDepenetrationVelocity, PxRigidBody, PxReal, PxReal > MaxDepenetrationVelocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidBody_MaxContactImpulse, PxRigidBody, PxReal, PxReal > MaxContactImpulse;
+
+		PX_PHYSX_CORE_API PxRigidBodyGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxRigidBody*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxRigidActorGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxRigidActorGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxRigidActorGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 11; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxRigidActorGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( CMassLocalPose, inStartIndex + 0 );; 
+			inOperator( Mass, inStartIndex + 1 );; 
+			inOperator( InvMass, inStartIndex + 2 );; 
+			inOperator( MassSpaceInertiaTensor, inStartIndex + 3 );; 
+			inOperator( MassSpaceInvInertiaTensor, inStartIndex + 4 );; 
+			inOperator( LinearVelocity, inStartIndex + 5 );; 
+			inOperator( AngularVelocity, inStartIndex + 6 );; 
+			inOperator( RigidBodyFlags, inStartIndex + 7 );; 
+			inOperator( MinCCDAdvanceCoefficient, inStartIndex + 8 );; 
+			inOperator( MaxDepenetrationVelocity, inStartIndex + 9 );; 
+			inOperator( MaxContactImpulse, inStartIndex + 10 );; 
+			return 11 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxRigidBody>
+	{ 
+		PxRigidBodyGeneratedInfo Info;
+		const PxRigidBodyGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxRigidDynamicLockFlag__EnumConversion[] = {
+		{ "eLOCK_LINEAR_X", static_cast<PxU32>( physx::PxRigidDynamicLockFlag::eLOCK_LINEAR_X ) },
+		{ "eLOCK_LINEAR_Y", static_cast<PxU32>( physx::PxRigidDynamicLockFlag::eLOCK_LINEAR_Y ) },
+		{ "eLOCK_LINEAR_Z", static_cast<PxU32>( physx::PxRigidDynamicLockFlag::eLOCK_LINEAR_Z ) },
+		{ "eLOCK_ANGULAR_X", static_cast<PxU32>( physx::PxRigidDynamicLockFlag::eLOCK_ANGULAR_X ) },
+		{ "eLOCK_ANGULAR_Y", static_cast<PxU32>( physx::PxRigidDynamicLockFlag::eLOCK_ANGULAR_Y ) },
+		{ "eLOCK_ANGULAR_Z", static_cast<PxU32>( physx::PxRigidDynamicLockFlag::eLOCK_ANGULAR_Z ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxRigidDynamicLockFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxRigidDynamicLockFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxRigidDynamic;
+	struct PxRigidDynamicGeneratedValues
+		: PxRigidBodyGeneratedValues	{
+		PxReal LinearDamping;
+		PxReal AngularDamping;
+		PxReal MaxAngularVelocity;
+		_Bool IsSleeping;
+		PxReal SleepThreshold;
+		PxReal StabilizationThreshold;
+		PxRigidDynamicLockFlags RigidDynamicLockFlags;
+		PxReal WakeCounter;
+		PxU32 SolverIterationCounts[2];
+		PxReal ContactReportThreshold;
+		const char * ConcreteTypeName;
+		 PX_PHYSX_CORE_API PxRigidDynamicGeneratedValues( const PxRigidDynamic* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidDynamic, LinearDamping, PxRigidDynamicGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidDynamic, AngularDamping, PxRigidDynamicGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidDynamic, MaxAngularVelocity, PxRigidDynamicGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidDynamic, IsSleeping, PxRigidDynamicGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidDynamic, SleepThreshold, PxRigidDynamicGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidDynamic, StabilizationThreshold, PxRigidDynamicGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidDynamic, RigidDynamicLockFlags, PxRigidDynamicGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidDynamic, WakeCounter, PxRigidDynamicGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidDynamic, SolverIterationCounts, PxRigidDynamicGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidDynamic, ContactReportThreshold, PxRigidDynamicGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidDynamic, ConcreteTypeName, PxRigidDynamicGeneratedValues)
+	struct PxRigidDynamicGeneratedInfo
+		: PxRigidBodyGeneratedInfo
+	{
+		static const char* getClassName() { return "PxRigidDynamic"; }
+		PxWriteOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_KinematicTarget, PxRigidDynamic, const PxTransform & > KinematicTarget;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_LinearDamping, PxRigidDynamic, PxReal, PxReal > LinearDamping;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_AngularDamping, PxRigidDynamic, PxReal, PxReal > AngularDamping;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_MaxAngularVelocity, PxRigidDynamic, PxReal, PxReal > MaxAngularVelocity;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_IsSleeping, PxRigidDynamic, _Bool > IsSleeping;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_SleepThreshold, PxRigidDynamic, PxReal, PxReal > SleepThreshold;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_StabilizationThreshold, PxRigidDynamic, PxReal, PxReal > StabilizationThreshold;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_RigidDynamicLockFlags, PxRigidDynamic, PxRigidDynamicLockFlags, PxRigidDynamicLockFlags > RigidDynamicLockFlags;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_WakeCounter, PxRigidDynamic, PxReal, PxReal > WakeCounter;
+		PxRangePropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_SolverIterationCounts, PxRigidDynamic, PxU32 > SolverIterationCounts;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_ContactReportThreshold, PxRigidDynamic, PxReal, PxReal > ContactReportThreshold;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidDynamic_ConcreteTypeName, PxRigidDynamic, const char * > ConcreteTypeName;
+
+		PX_PHYSX_CORE_API PxRigidDynamicGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxRigidDynamic*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxRigidBodyGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxRigidBodyGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxRigidBodyGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 12; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxRigidBodyGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( KinematicTarget, inStartIndex + 0 );; 
+			inOperator( LinearDamping, inStartIndex + 1 );; 
+			inOperator( AngularDamping, inStartIndex + 2 );; 
+			inOperator( MaxAngularVelocity, inStartIndex + 3 );; 
+			inOperator( IsSleeping, inStartIndex + 4 );; 
+			inOperator( SleepThreshold, inStartIndex + 5 );; 
+			inOperator( StabilizationThreshold, inStartIndex + 6 );; 
+			inOperator( RigidDynamicLockFlags, inStartIndex + 7 );; 
+			inOperator( WakeCounter, inStartIndex + 8 );; 
+			inOperator( SolverIterationCounts, inStartIndex + 9 );; 
+			inOperator( ContactReportThreshold, inStartIndex + 10 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 11 );; 
+			return 12 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxRigidDynamic>
+	{ 
+		PxRigidDynamicGeneratedInfo Info;
+		const PxRigidDynamicGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxRigidStatic;
+	struct PxRigidStaticGeneratedValues
+		: PxRigidActorGeneratedValues	{
+		const char * ConcreteTypeName;
+		 PX_PHYSX_CORE_API PxRigidStaticGeneratedValues( const PxRigidStatic* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRigidStatic, ConcreteTypeName, PxRigidStaticGeneratedValues)
+	struct PxRigidStaticGeneratedInfo
+		: PxRigidActorGeneratedInfo
+	{
+		static const char* getClassName() { return "PxRigidStatic"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxRigidStatic_ConcreteTypeName, PxRigidStatic, const char * > ConcreteTypeName;
+
+		PX_PHYSX_CORE_API PxRigidStaticGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxRigidStatic*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxRigidActorGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxRigidActorGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxRigidActorGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 1; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxRigidActorGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( ConcreteTypeName, inStartIndex + 0 );; 
+			return 1 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxRigidStatic>
+	{ 
+		PxRigidStaticGeneratedInfo Info;
+		const PxRigidStaticGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxArticulationLink;
+	struct PxArticulationLinkGeneratedValues
+		: PxRigidBodyGeneratedValues	{
+		PxArticulationJoint * InboundJoint;
+		const char * ConcreteTypeName;
+		 PX_PHYSX_CORE_API PxArticulationLinkGeneratedValues( const PxArticulationLink* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationLink, InboundJoint, PxArticulationLinkGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationLink, ConcreteTypeName, PxArticulationLinkGeneratedValues)
+	struct PxArticulationLinkGeneratedInfo
+		: PxRigidBodyGeneratedInfo
+	{
+		static const char* getClassName() { return "PxArticulationLink"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationLink_InboundJoint, PxArticulationLink, PxArticulationJoint * > InboundJoint;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationLink_Children, PxArticulationLink, PxArticulationLink * > Children;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationLink_ConcreteTypeName, PxArticulationLink, const char * > ConcreteTypeName;
+
+		PX_PHYSX_CORE_API PxArticulationLinkGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxArticulationLink*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxRigidBodyGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxRigidBodyGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxRigidBodyGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 3; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxRigidBodyGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( InboundJoint, inStartIndex + 0 );; 
+			inOperator( Children, inStartIndex + 1 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 2 );; 
+			return 3 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxArticulationLink>
+	{ 
+		PxArticulationLinkGeneratedInfo Info;
+		const PxArticulationLinkGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxArticulationJointDriveType__EnumConversion[] = {
+		{ "eTARGET", static_cast<PxU32>( physx::PxArticulationJointDriveType::eTARGET ) },
+		{ "eERROR", static_cast<PxU32>( physx::PxArticulationJointDriveType::eERROR ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxArticulationJointDriveType::Enum > { PxEnumTraits() : NameConversion( g_physx__PxArticulationJointDriveType__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxArticulationJoint;
+	struct PxArticulationJointGeneratedValues
+	{
+		PxTransform ParentPose;
+		PxTransform ChildPose;
+		PxQuat TargetOrientation;
+		PxVec3 TargetVelocity;
+		PxArticulationJointDriveType::Enum DriveType;
+		PxReal Stiffness;
+		PxReal Damping;
+		PxReal InternalCompliance;
+		PxReal ExternalCompliance;
+		PxReal SwingLimit[2];
+		PxReal TangentialStiffness;
+		PxReal TangentialDamping;
+		PxReal SwingLimitContactDistance;
+		_Bool SwingLimitEnabled;
+		PxReal TwistLimit[2];
+		_Bool TwistLimitEnabled;
+		PxReal TwistLimitContactDistance;
+		const char * ConcreteTypeName;
+		 PX_PHYSX_CORE_API PxArticulationJointGeneratedValues( const PxArticulationJoint* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, ParentPose, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, ChildPose, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, TargetOrientation, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, TargetVelocity, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, DriveType, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, Stiffness, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, Damping, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, InternalCompliance, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, ExternalCompliance, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, SwingLimit, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, TangentialStiffness, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, TangentialDamping, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, SwingLimitContactDistance, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, SwingLimitEnabled, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, TwistLimit, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, TwistLimitEnabled, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, TwistLimitContactDistance, PxArticulationJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulationJoint, ConcreteTypeName, PxArticulationJointGeneratedValues)
+	struct PxArticulationJointGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxArticulationJoint"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_ParentPose, PxArticulationJoint, const PxTransform &, PxTransform > ParentPose;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_ChildPose, PxArticulationJoint, const PxTransform &, PxTransform > ChildPose;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_TargetOrientation, PxArticulationJoint, const PxQuat &, PxQuat > TargetOrientation;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_TargetVelocity, PxArticulationJoint, const PxVec3 &, PxVec3 > TargetVelocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_DriveType, PxArticulationJoint, PxArticulationJointDriveType::Enum, PxArticulationJointDriveType::Enum > DriveType;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_Stiffness, PxArticulationJoint, PxReal, PxReal > Stiffness;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_Damping, PxArticulationJoint, PxReal, PxReal > Damping;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_InternalCompliance, PxArticulationJoint, PxReal, PxReal > InternalCompliance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_ExternalCompliance, PxArticulationJoint, PxReal, PxReal > ExternalCompliance;
+		PxRangePropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_SwingLimit, PxArticulationJoint, PxReal > SwingLimit;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_TangentialStiffness, PxArticulationJoint, PxReal, PxReal > TangentialStiffness;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_TangentialDamping, PxArticulationJoint, PxReal, PxReal > TangentialDamping;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_SwingLimitContactDistance, PxArticulationJoint, PxReal, PxReal > SwingLimitContactDistance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_SwingLimitEnabled, PxArticulationJoint, _Bool, _Bool > SwingLimitEnabled;
+		PxRangePropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_TwistLimit, PxArticulationJoint, PxReal > TwistLimit;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_TwistLimitEnabled, PxArticulationJoint, _Bool, _Bool > TwistLimitEnabled;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_TwistLimitContactDistance, PxArticulationJoint, PxReal, PxReal > TwistLimitContactDistance;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulationJoint_ConcreteTypeName, PxArticulationJoint, const char * > ConcreteTypeName;
+
+		PX_PHYSX_CORE_API PxArticulationJointGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxArticulationJoint*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 18; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( ParentPose, inStartIndex + 0 );; 
+			inOperator( ChildPose, inStartIndex + 1 );; 
+			inOperator( TargetOrientation, inStartIndex + 2 );; 
+			inOperator( TargetVelocity, inStartIndex + 3 );; 
+			inOperator( DriveType, inStartIndex + 4 );; 
+			inOperator( Stiffness, inStartIndex + 5 );; 
+			inOperator( Damping, inStartIndex + 6 );; 
+			inOperator( InternalCompliance, inStartIndex + 7 );; 
+			inOperator( ExternalCompliance, inStartIndex + 8 );; 
+			inOperator( SwingLimit, inStartIndex + 9 );; 
+			inOperator( TangentialStiffness, inStartIndex + 10 );; 
+			inOperator( TangentialDamping, inStartIndex + 11 );; 
+			inOperator( SwingLimitContactDistance, inStartIndex + 12 );; 
+			inOperator( SwingLimitEnabled, inStartIndex + 13 );; 
+			inOperator( TwistLimit, inStartIndex + 14 );; 
+			inOperator( TwistLimitEnabled, inStartIndex + 15 );; 
+			inOperator( TwistLimitContactDistance, inStartIndex + 16 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 17 );; 
+			return 18 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxArticulationJoint>
+	{ 
+		PxArticulationJointGeneratedInfo Info;
+		const PxArticulationJointGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxArticulation;
+	struct PxArticulationGeneratedValues
+	{
+		PxScene * Scene;
+		PxU32 MaxProjectionIterations;
+		PxReal SeparationTolerance;
+		PxU32 InternalDriveIterations;
+		PxU32 ExternalDriveIterations;
+		PxU32 SolverIterationCounts[2];
+		_Bool IsSleeping;
+		PxReal SleepThreshold;
+		PxReal StabilizationThreshold;
+		PxReal WakeCounter;
+		const char * Name;
+		PxAggregate * Aggregate;
+		const char * ConcreteTypeName;
+		void * UserData;
+		 PX_PHYSX_CORE_API PxArticulationGeneratedValues( const PxArticulation* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, Scene, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, MaxProjectionIterations, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, SeparationTolerance, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, InternalDriveIterations, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, ExternalDriveIterations, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, SolverIterationCounts, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, IsSleeping, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, SleepThreshold, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, StabilizationThreshold, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, WakeCounter, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, Name, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, Aggregate, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, ConcreteTypeName, PxArticulationGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxArticulation, UserData, PxArticulationGeneratedValues)
+	struct PxArticulationGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxArticulation"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_Scene, PxArticulation, PxScene * > Scene;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_MaxProjectionIterations, PxArticulation, PxU32, PxU32 > MaxProjectionIterations;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_SeparationTolerance, PxArticulation, PxReal, PxReal > SeparationTolerance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_InternalDriveIterations, PxArticulation, PxU32, PxU32 > InternalDriveIterations;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_ExternalDriveIterations, PxArticulation, PxU32, PxU32 > ExternalDriveIterations;
+		PxRangePropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_SolverIterationCounts, PxArticulation, PxU32 > SolverIterationCounts;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_IsSleeping, PxArticulation, _Bool > IsSleeping;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_SleepThreshold, PxArticulation, PxReal, PxReal > SleepThreshold;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_StabilizationThreshold, PxArticulation, PxReal, PxReal > StabilizationThreshold;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_WakeCounter, PxArticulation, PxReal, PxReal > WakeCounter;
+		PxArticulationLinkCollectionProp Links;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_Name, PxArticulation, const char *, const char * > Name;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_Aggregate, PxArticulation, PxAggregate * > Aggregate;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_ConcreteTypeName, PxArticulation, const char * > ConcreteTypeName;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxArticulation_UserData, PxArticulation, void *, void * > UserData;
+
+		PX_PHYSX_CORE_API PxArticulationGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxArticulation*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 15; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Scene, inStartIndex + 0 );; 
+			inOperator( MaxProjectionIterations, inStartIndex + 1 );; 
+			inOperator( SeparationTolerance, inStartIndex + 2 );; 
+			inOperator( InternalDriveIterations, inStartIndex + 3 );; 
+			inOperator( ExternalDriveIterations, inStartIndex + 4 );; 
+			inOperator( SolverIterationCounts, inStartIndex + 5 );; 
+			inOperator( IsSleeping, inStartIndex + 6 );; 
+			inOperator( SleepThreshold, inStartIndex + 7 );; 
+			inOperator( StabilizationThreshold, inStartIndex + 8 );; 
+			inOperator( WakeCounter, inStartIndex + 9 );; 
+			inOperator( Links, inStartIndex + 10 );; 
+			inOperator( Name, inStartIndex + 11 );; 
+			inOperator( Aggregate, inStartIndex + 12 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 13 );; 
+			inOperator( UserData, inStartIndex + 14 );; 
+			return 15 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxArticulation>
+	{ 
+		PxArticulationGeneratedInfo Info;
+		const PxArticulationGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxAggregate;
+	struct PxAggregateGeneratedValues
+	{
+		PxU32 MaxNbActors;
+		_Bool SelfCollision;
+		const char * ConcreteTypeName;
+		 PX_PHYSX_CORE_API PxAggregateGeneratedValues( const PxAggregate* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxAggregate, MaxNbActors, PxAggregateGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxAggregate, SelfCollision, PxAggregateGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxAggregate, ConcreteTypeName, PxAggregateGeneratedValues)
+	struct PxAggregateGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxAggregate"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxAggregate_MaxNbActors, PxAggregate, PxU32 > MaxNbActors;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxAggregate_Actors, PxAggregate, PxActor * > Actors;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxAggregate_SelfCollision, PxAggregate, _Bool > SelfCollision;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxAggregate_ConcreteTypeName, PxAggregate, const char * > ConcreteTypeName;
+
+		PX_PHYSX_CORE_API PxAggregateGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxAggregate*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 4; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( MaxNbActors, inStartIndex + 0 );; 
+			inOperator( Actors, inStartIndex + 1 );; 
+			inOperator( SelfCollision, inStartIndex + 2 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 3 );; 
+			return 4 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxAggregate>
+	{ 
+		PxAggregateGeneratedInfo Info;
+		const PxAggregateGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxConstraintFlag__EnumConversion[] = {
+		{ "eBROKEN", static_cast<PxU32>( physx::PxConstraintFlag::eBROKEN ) },
+		{ "ePROJECT_TO_ACTOR0", static_cast<PxU32>( physx::PxConstraintFlag::ePROJECT_TO_ACTOR0 ) },
+		{ "ePROJECT_TO_ACTOR1", static_cast<PxU32>( physx::PxConstraintFlag::ePROJECT_TO_ACTOR1 ) },
+		{ "ePROJECTION", static_cast<PxU32>( physx::PxConstraintFlag::ePROJECTION ) },
+		{ "eCOLLISION_ENABLED", static_cast<PxU32>( physx::PxConstraintFlag::eCOLLISION_ENABLED ) },
+		{ "eVISUALIZATION", static_cast<PxU32>( physx::PxConstraintFlag::eVISUALIZATION ) },
+		{ "eDRIVE_LIMITS_ARE_FORCES", static_cast<PxU32>( physx::PxConstraintFlag::eDRIVE_LIMITS_ARE_FORCES ) },
+		{ "eIMPROVED_SLERP", static_cast<PxU32>( physx::PxConstraintFlag::eIMPROVED_SLERP ) },
+		{ "eDISABLE_PREPROCESSING", static_cast<PxU32>( physx::PxConstraintFlag::eDISABLE_PREPROCESSING ) },
+		{ "eGPU_COMPATIBLE", static_cast<PxU32>( physx::PxConstraintFlag::eGPU_COMPATIBLE ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxConstraintFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxConstraintFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxConstraint;
+	struct PxConstraintGeneratedValues
+	{
+		PxScene * Scene;
+		PxRigidActor * Actors[2];
+		PxConstraintFlags Flags;
+		_Bool IsValid;
+		PxReal BreakForce[2];
+		PxReal MinResponseThreshold;
+		const char * ConcreteTypeName;
+		 PX_PHYSX_CORE_API PxConstraintGeneratedValues( const PxConstraint* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxConstraint, Scene, PxConstraintGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxConstraint, Actors, PxConstraintGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxConstraint, Flags, PxConstraintGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxConstraint, IsValid, PxConstraintGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxConstraint, BreakForce, PxConstraintGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxConstraint, MinResponseThreshold, PxConstraintGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxConstraint, ConcreteTypeName, PxConstraintGeneratedValues)
+	struct PxConstraintGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxConstraint"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxConstraint_Scene, PxConstraint, PxScene * > Scene;
+		PxRangePropertyInfo<PX_PROPERTY_INFO_NAME::PxConstraint_Actors, PxConstraint, PxRigidActor * > Actors;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxConstraint_Flags, PxConstraint, PxConstraintFlags, PxConstraintFlags > Flags;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxConstraint_IsValid, PxConstraint, _Bool > IsValid;
+		PxRangePropertyInfo<PX_PROPERTY_INFO_NAME::PxConstraint_BreakForce, PxConstraint, PxReal > BreakForce;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxConstraint_MinResponseThreshold, PxConstraint, PxReal, PxReal > MinResponseThreshold;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxConstraint_ConcreteTypeName, PxConstraint, const char * > ConcreteTypeName;
+
+		PX_PHYSX_CORE_API PxConstraintGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxConstraint*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 7; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Scene, inStartIndex + 0 );; 
+			inOperator( Actors, inStartIndex + 1 );; 
+			inOperator( Flags, inStartIndex + 2 );; 
+			inOperator( IsValid, inStartIndex + 3 );; 
+			inOperator( BreakForce, inStartIndex + 4 );; 
+			inOperator( MinResponseThreshold, inStartIndex + 5 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 6 );; 
+			return 7 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxConstraint>
+	{ 
+		PxConstraintGeneratedInfo Info;
+		const PxConstraintGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxGeometryType__EnumConversion[] = {
+		{ "eSPHERE", static_cast<PxU32>( physx::PxGeometryType::eSPHERE ) },
+		{ "ePLANE", static_cast<PxU32>( physx::PxGeometryType::ePLANE ) },
+		{ "eCAPSULE", static_cast<PxU32>( physx::PxGeometryType::eCAPSULE ) },
+		{ "eBOX", static_cast<PxU32>( physx::PxGeometryType::eBOX ) },
+		{ "eCONVEXMESH", static_cast<PxU32>( physx::PxGeometryType::eCONVEXMESH ) },
+		{ "eTRIANGLEMESH", static_cast<PxU32>( physx::PxGeometryType::eTRIANGLEMESH ) },
+		{ "eHEIGHTFIELD", static_cast<PxU32>( physx::PxGeometryType::eHEIGHTFIELD ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxGeometryType::Enum > { PxEnumTraits() : NameConversion( g_physx__PxGeometryType__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxShape;
+	struct PxShapeGeneratedValues
+	{
+		PxGeometryType::Enum GeometryType;
+		PxGeometryHolder Geometry;
+		PxTransform LocalPose;
+		PxFilterData SimulationFilterData;
+		PxFilterData QueryFilterData;
+		PxReal ContactOffset;
+		PxReal RestOffset;
+		PxShapeFlags Flags;
+		_Bool IsExclusive;
+		const char * Name;
+		const char * ConcreteTypeName;
+		void * UserData;
+		 PX_PHYSX_CORE_API PxShapeGeneratedValues( const PxShape* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, GeometryType, PxShapeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, Geometry, PxShapeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, LocalPose, PxShapeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, SimulationFilterData, PxShapeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, QueryFilterData, PxShapeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, ContactOffset, PxShapeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, RestOffset, PxShapeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, Flags, PxShapeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, IsExclusive, PxShapeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, Name, PxShapeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, ConcreteTypeName, PxShapeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxShape, UserData, PxShapeGeneratedValues)
+	struct PxShapeGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxShape"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxShape_GeometryType, PxShape, PxGeometryType::Enum > GeometryType;
+		PxShapeGeometryProperty Geometry;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxShape_LocalPose, PxShape, const PxTransform &, PxTransform > LocalPose;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxShape_SimulationFilterData, PxShape, const PxFilterData &, PxFilterData > SimulationFilterData;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxShape_QueryFilterData, PxShape, const PxFilterData &, PxFilterData > QueryFilterData;
+		PxShapeMaterialsProperty Materials;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxShape_ContactOffset, PxShape, PxReal, PxReal > ContactOffset;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxShape_RestOffset, PxShape, PxReal, PxReal > RestOffset;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxShape_Flags, PxShape, PxShapeFlags, PxShapeFlags > Flags;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxShape_IsExclusive, PxShape, _Bool > IsExclusive;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxShape_Name, PxShape, const char *, const char * > Name;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxShape_ConcreteTypeName, PxShape, const char * > ConcreteTypeName;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxShape_UserData, PxShape, void *, void * > UserData;
+
+		PX_PHYSX_CORE_API PxShapeGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxShape*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 13; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( GeometryType, inStartIndex + 0 );; 
+			inOperator( Geometry, inStartIndex + 1 );; 
+			inOperator( LocalPose, inStartIndex + 2 );; 
+			inOperator( SimulationFilterData, inStartIndex + 3 );; 
+			inOperator( QueryFilterData, inStartIndex + 4 );; 
+			inOperator( Materials, inStartIndex + 5 );; 
+			inOperator( ContactOffset, inStartIndex + 6 );; 
+			inOperator( RestOffset, inStartIndex + 7 );; 
+			inOperator( Flags, inStartIndex + 8 );; 
+			inOperator( IsExclusive, inStartIndex + 9 );; 
+			inOperator( Name, inStartIndex + 10 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 11 );; 
+			inOperator( UserData, inStartIndex + 12 );; 
+			return 13 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxShape>
+	{ 
+		PxShapeGeneratedInfo Info;
+		const PxShapeGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxClothFabric;
+	struct PxClothFabricGeneratedValues
+	{
+		PxU32 NbParticles;
+		PxU32 ReferenceCount;
+		const char * ConcreteTypeName;
+		 PX_PHYSX_CORE_API PxClothFabricGeneratedValues( const PxClothFabric* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothFabric, NbParticles, PxClothFabricGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothFabric, ReferenceCount, PxClothFabricGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothFabric, ConcreteTypeName, PxClothFabricGeneratedValues)
+	struct PxClothFabricGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxClothFabric"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothFabric_NbParticles, PxClothFabric, PxU32 > NbParticles;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothFabric_Phases, PxClothFabric, PxClothFabricPhase > Phases;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothFabric_Sets, PxClothFabric, PxU32 > Sets;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothFabric_ParticleIndices, PxClothFabric, PxU32 > ParticleIndices;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothFabric_Restvalues, PxClothFabric, PxReal > Restvalues;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothFabric_ReferenceCount, PxClothFabric, PxU32 > ReferenceCount;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothFabric_ConcreteTypeName, PxClothFabric, const char * > ConcreteTypeName;
+
+		PX_PHYSX_CORE_API PxClothFabricGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxClothFabric*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 7; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( NbParticles, inStartIndex + 0 );; 
+			inOperator( Phases, inStartIndex + 1 );; 
+			inOperator( Sets, inStartIndex + 2 );; 
+			inOperator( ParticleIndices, inStartIndex + 3 );; 
+			inOperator( Restvalues, inStartIndex + 4 );; 
+			inOperator( ReferenceCount, inStartIndex + 5 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 6 );; 
+			return 7 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxClothFabric>
+	{ 
+		PxClothFabricGeneratedInfo Info;
+		const PxClothFabricGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxDataAccessFlag__EnumConversion[] = {
+		{ "eREADABLE", static_cast<PxU32>( physx::PxDataAccessFlag::eREADABLE ) },
+		{ "eWRITABLE", static_cast<PxU32>( physx::PxDataAccessFlag::eWRITABLE ) },
+		{ "eDEVICE", static_cast<PxU32>( physx::PxDataAccessFlag::eDEVICE ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxDataAccessFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxDataAccessFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxClothFabricPhaseType__EnumConversion[] = {
+		{ "eVERTICAL", static_cast<PxU32>( physx::PxClothFabricPhaseType::eVERTICAL ) },
+		{ "eHORIZONTAL", static_cast<PxU32>( physx::PxClothFabricPhaseType::eHORIZONTAL ) },
+		{ "eBENDING", static_cast<PxU32>( physx::PxClothFabricPhaseType::eBENDING ) },
+		{ "eSHEARING", static_cast<PxU32>( physx::PxClothFabricPhaseType::eSHEARING ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxClothFabricPhaseType::Enum > { PxEnumTraits() : NameConversion( g_physx__PxClothFabricPhaseType__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxCloth;
+	struct PxClothGeneratedValues
+		: PxActorGeneratedValues	{
+		PxU32 NbParticles;
+		PxClothFlags ClothFlags;
+		PxTransform GlobalPose;
+		PxReal SolverFrequency;
+		PxReal PreviousTimeStep;
+		PxReal StiffnessFrequency;
+		PxVec3 LinearInertiaScale;
+		PxVec3 AngularInertiaScale;
+		PxVec3 CentrifugalInertiaScale;
+		PxVec3 DampingCoefficient;
+		PxVec3 LinearDragCoefficient;
+		PxVec3 AngularDragCoefficient;
+		PxVec3 ExternalAcceleration;
+		PxVec3 WindVelocity;
+		PxReal WindDrag;
+		PxReal WindLift;
+		PxClothMotionConstraintConfig MotionConstraintConfig;
+		PxClothStretchConfig StretchConfig[physx::PxClothFabricPhaseType::eCOUNT];
+		PxClothTetherConfig TetherConfig;
+		PxReal FrictionCoefficient;
+		PxReal CollisionMassScale;
+		PxReal SelfCollisionDistance;
+		PxReal SelfCollisionStiffness;
+		PxFilterData SimulationFilterData;
+		PxReal ContactOffset;
+		PxReal RestOffset;
+		PxReal SleepLinearVelocity;
+		PxReal WakeCounter;
+		_Bool IsSleeping;
+		const char * ConcreteTypeName;
+		 PX_PHYSX_CORE_API PxClothGeneratedValues( const PxCloth* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, NbParticles, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, ClothFlags, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, GlobalPose, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, SolverFrequency, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, PreviousTimeStep, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, StiffnessFrequency, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, LinearInertiaScale, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, AngularInertiaScale, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, CentrifugalInertiaScale, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, DampingCoefficient, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, LinearDragCoefficient, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, AngularDragCoefficient, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, ExternalAcceleration, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, WindVelocity, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, WindDrag, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, WindLift, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, MotionConstraintConfig, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, StretchConfig, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, TetherConfig, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, FrictionCoefficient, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, CollisionMassScale, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, SelfCollisionDistance, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, SelfCollisionStiffness, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, SimulationFilterData, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, ContactOffset, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, RestOffset, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, SleepLinearVelocity, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, WakeCounter, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, IsSleeping, PxClothGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCloth, ConcreteTypeName, PxClothGeneratedValues)
+	struct PxClothGeneratedInfo
+		: PxActorGeneratedInfo
+	{
+		static const char* getClassName() { return "PxCloth"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_NbParticles, PxCloth, PxU32 > NbParticles;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_ClothFlags, PxCloth, PxClothFlags, PxClothFlags > ClothFlags;
+		PxWriteOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_TargetPose, PxCloth, const PxTransform & > TargetPose;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_GlobalPose, PxCloth, const PxTransform &, PxTransform > GlobalPose;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_SolverFrequency, PxCloth, PxReal, PxReal > SolverFrequency;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_PreviousTimeStep, PxCloth, PxReal > PreviousTimeStep;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_StiffnessFrequency, PxCloth, PxReal, PxReal > StiffnessFrequency;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_LinearInertiaScale, PxCloth, PxVec3, PxVec3 > LinearInertiaScale;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_AngularInertiaScale, PxCloth, PxVec3, PxVec3 > AngularInertiaScale;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_CentrifugalInertiaScale, PxCloth, PxVec3, PxVec3 > CentrifugalInertiaScale;
+		PxWriteOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_InertiaScale, PxCloth, PxReal > InertiaScale;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_DampingCoefficient, PxCloth, PxVec3, PxVec3 > DampingCoefficient;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_LinearDragCoefficient, PxCloth, PxVec3, PxVec3 > LinearDragCoefficient;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_AngularDragCoefficient, PxCloth, PxVec3, PxVec3 > AngularDragCoefficient;
+		PxWriteOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_DragCoefficient, PxCloth, PxReal > DragCoefficient;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_ExternalAcceleration, PxCloth, PxVec3, PxVec3 > ExternalAcceleration;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_WindVelocity, PxCloth, PxVec3, PxVec3 > WindVelocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_WindDrag, PxCloth, PxReal, PxReal > WindDrag;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_WindLift, PxCloth, PxReal, PxReal > WindLift;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_MotionConstraintConfig, PxCloth, const PxClothMotionConstraintConfig &, PxClothMotionConstraintConfig > MotionConstraintConfig;
+		PxIndexedPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_StretchConfig, PxCloth, PxClothFabricPhaseType::Enum, PxClothStretchConfig > StretchConfig;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_TetherConfig, PxCloth, const PxClothTetherConfig &, PxClothTetherConfig > TetherConfig;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_FrictionCoefficient, PxCloth, PxReal, PxReal > FrictionCoefficient;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_CollisionMassScale, PxCloth, PxReal, PxReal > CollisionMassScale;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_SelfCollisionDistance, PxCloth, PxReal, PxReal > SelfCollisionDistance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_SelfCollisionStiffness, PxCloth, PxReal, PxReal > SelfCollisionStiffness;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_SimulationFilterData, PxCloth, const PxFilterData &, PxFilterData > SimulationFilterData;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_ContactOffset, PxCloth, PxReal, PxReal > ContactOffset;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_RestOffset, PxCloth, PxReal, PxReal > RestOffset;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_SleepLinearVelocity, PxCloth, PxReal, PxReal > SleepLinearVelocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_WakeCounter, PxCloth, PxReal, PxReal > WakeCounter;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_IsSleeping, PxCloth, _Bool > IsSleeping;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxCloth_ConcreteTypeName, PxCloth, const char * > ConcreteTypeName;
+
+		PX_PHYSX_CORE_API PxClothGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxCloth*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxActorGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxActorGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxActorGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 33; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxActorGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( NbParticles, inStartIndex + 0 );; 
+			inOperator( ClothFlags, inStartIndex + 1 );; 
+			inOperator( TargetPose, inStartIndex + 2 );; 
+			inOperator( GlobalPose, inStartIndex + 3 );; 
+			inOperator( SolverFrequency, inStartIndex + 4 );; 
+			inOperator( PreviousTimeStep, inStartIndex + 5 );; 
+			inOperator( StiffnessFrequency, inStartIndex + 6 );; 
+			inOperator( LinearInertiaScale, inStartIndex + 7 );; 
+			inOperator( AngularInertiaScale, inStartIndex + 8 );; 
+			inOperator( CentrifugalInertiaScale, inStartIndex + 9 );; 
+			inOperator( InertiaScale, inStartIndex + 10 );; 
+			inOperator( DampingCoefficient, inStartIndex + 11 );; 
+			inOperator( LinearDragCoefficient, inStartIndex + 12 );; 
+			inOperator( AngularDragCoefficient, inStartIndex + 13 );; 
+			inOperator( DragCoefficient, inStartIndex + 14 );; 
+			inOperator( ExternalAcceleration, inStartIndex + 15 );; 
+			inOperator( WindVelocity, inStartIndex + 16 );; 
+			inOperator( WindDrag, inStartIndex + 17 );; 
+			inOperator( WindLift, inStartIndex + 18 );; 
+			inOperator( MotionConstraintConfig, inStartIndex + 19 );; 
+			inOperator( StretchConfig, inStartIndex + 20 );; 
+			inOperator( TetherConfig, inStartIndex + 21 );; 
+			inOperator( FrictionCoefficient, inStartIndex + 22 );; 
+			inOperator( CollisionMassScale, inStartIndex + 23 );; 
+			inOperator( SelfCollisionDistance, inStartIndex + 24 );; 
+			inOperator( SelfCollisionStiffness, inStartIndex + 25 );; 
+			inOperator( SimulationFilterData, inStartIndex + 26 );; 
+			inOperator( ContactOffset, inStartIndex + 27 );; 
+			inOperator( RestOffset, inStartIndex + 28 );; 
+			inOperator( SleepLinearVelocity, inStartIndex + 29 );; 
+			inOperator( WakeCounter, inStartIndex + 30 );; 
+			inOperator( IsSleeping, inStartIndex + 31 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 32 );; 
+			return 33 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxCloth>
+	{ 
+		PxClothGeneratedInfo Info;
+		const PxClothGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxParticleBaseFlag__EnumConversion[] = {
+		{ "eCOLLISION_TWOWAY", static_cast<PxU32>( physx::PxParticleBaseFlag::eCOLLISION_TWOWAY ) },
+		{ "eCOLLISION_WITH_DYNAMIC_ACTORS", static_cast<PxU32>( physx::PxParticleBaseFlag::eCOLLISION_WITH_DYNAMIC_ACTORS ) },
+		{ "eENABLED", static_cast<PxU32>( physx::PxParticleBaseFlag::eENABLED ) },
+		{ "ePROJECT_TO_PLANE", static_cast<PxU32>( physx::PxParticleBaseFlag::ePROJECT_TO_PLANE ) },
+		{ "ePER_PARTICLE_REST_OFFSET", static_cast<PxU32>( physx::PxParticleBaseFlag::ePER_PARTICLE_REST_OFFSET ) },
+		{ "ePER_PARTICLE_COLLISION_CACHE_HINT", static_cast<PxU32>( physx::PxParticleBaseFlag::ePER_PARTICLE_COLLISION_CACHE_HINT ) },
+		{ "eGPU", static_cast<PxU32>( physx::PxParticleBaseFlag::eGPU ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxParticleBaseFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxParticleBaseFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxParticleReadDataFlag__EnumConversion[] = {
+		{ "ePOSITION_BUFFER", static_cast<PxU32>( physx::PxParticleReadDataFlag::ePOSITION_BUFFER ) },
+		{ "eVELOCITY_BUFFER", static_cast<PxU32>( physx::PxParticleReadDataFlag::eVELOCITY_BUFFER ) },
+		{ "eREST_OFFSET_BUFFER", static_cast<PxU32>( physx::PxParticleReadDataFlag::eREST_OFFSET_BUFFER ) },
+		{ "eFLAGS_BUFFER", static_cast<PxU32>( physx::PxParticleReadDataFlag::eFLAGS_BUFFER ) },
+		{ "eCOLLISION_NORMAL_BUFFER", static_cast<PxU32>( physx::PxParticleReadDataFlag::eCOLLISION_NORMAL_BUFFER ) },
+		{ "eCOLLISION_VELOCITY_BUFFER", static_cast<PxU32>( physx::PxParticleReadDataFlag::eCOLLISION_VELOCITY_BUFFER ) },
+		{ "eDENSITY_BUFFER", static_cast<PxU32>( physx::PxParticleReadDataFlag::eDENSITY_BUFFER ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxParticleReadDataFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxParticleReadDataFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxParticleBase;
+	struct PxParticleBaseGeneratedValues
+		: PxActorGeneratedValues	{
+		PxReal Damping;
+		PxVec3 ExternalAcceleration;
+		PxReal ParticleMass;
+		PxReal Restitution;
+		PxReal DynamicFriction;
+		PxReal StaticFriction;
+		PxFilterData SimulationFilterData;
+		PxParticleBaseFlags ParticleBaseFlags;
+		PxU32 MaxParticles;
+		PxReal MaxMotionDistance;
+		PxReal RestOffset;
+		PxReal ContactOffset;
+		PxReal GridSize;
+		PxParticleReadDataFlags ParticleReadDataFlags;
+		PxMetaDataPlane ProjectionPlane;
+		 PX_PHYSX_CORE_API PxParticleBaseGeneratedValues( const PxParticleBase* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, Damping, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, ExternalAcceleration, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, ParticleMass, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, Restitution, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, DynamicFriction, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, StaticFriction, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, SimulationFilterData, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, ParticleBaseFlags, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, MaxParticles, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, MaxMotionDistance, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, RestOffset, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, ContactOffset, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, GridSize, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, ParticleReadDataFlags, PxParticleBaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleBase, ProjectionPlane, PxParticleBaseGeneratedValues)
+	struct PxParticleBaseGeneratedInfo
+		: PxActorGeneratedInfo
+	{
+		static const char* getClassName() { return "PxParticleBase"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_Damping, PxParticleBase, PxReal, PxReal > Damping;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_ExternalAcceleration, PxParticleBase, const PxVec3 &, PxVec3 > ExternalAcceleration;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_ParticleMass, PxParticleBase, PxReal, PxReal > ParticleMass;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_Restitution, PxParticleBase, PxReal, PxReal > Restitution;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_DynamicFriction, PxParticleBase, PxReal, PxReal > DynamicFriction;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_StaticFriction, PxParticleBase, PxReal, PxReal > StaticFriction;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_SimulationFilterData, PxParticleBase, const PxFilterData &, PxFilterData > SimulationFilterData;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_ParticleBaseFlags, PxParticleBase, PxParticleBaseFlags > ParticleBaseFlags;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_MaxParticles, PxParticleBase, PxU32 > MaxParticles;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_MaxMotionDistance, PxParticleBase, PxReal, PxReal > MaxMotionDistance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_RestOffset, PxParticleBase, PxReal, PxReal > RestOffset;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_ContactOffset, PxParticleBase, PxReal, PxReal > ContactOffset;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_GridSize, PxParticleBase, PxReal, PxReal > GridSize;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleBase_ParticleReadDataFlags, PxParticleBase, PxParticleReadDataFlags > ParticleReadDataFlags;
+		ProjectionPlaneProperty ProjectionPlane;
+
+		PX_PHYSX_CORE_API PxParticleBaseGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxParticleBase*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxActorGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxActorGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxActorGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 15; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxActorGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Damping, inStartIndex + 0 );; 
+			inOperator( ExternalAcceleration, inStartIndex + 1 );; 
+			inOperator( ParticleMass, inStartIndex + 2 );; 
+			inOperator( Restitution, inStartIndex + 3 );; 
+			inOperator( DynamicFriction, inStartIndex + 4 );; 
+			inOperator( StaticFriction, inStartIndex + 5 );; 
+			inOperator( SimulationFilterData, inStartIndex + 6 );; 
+			inOperator( ParticleBaseFlags, inStartIndex + 7 );; 
+			inOperator( MaxParticles, inStartIndex + 8 );; 
+			inOperator( MaxMotionDistance, inStartIndex + 9 );; 
+			inOperator( RestOffset, inStartIndex + 10 );; 
+			inOperator( ContactOffset, inStartIndex + 11 );; 
+			inOperator( GridSize, inStartIndex + 12 );; 
+			inOperator( ParticleReadDataFlags, inStartIndex + 13 );; 
+			inOperator( ProjectionPlane, inStartIndex + 14 );; 
+			return 15 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxParticleBase>
+	{ 
+		PxParticleBaseGeneratedInfo Info;
+		const PxParticleBaseGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxParticleFluid;
+	struct PxParticleFluidGeneratedValues
+		: PxParticleBaseGeneratedValues	{
+		PxReal Stiffness;
+		PxReal Viscosity;
+		PxReal RestParticleDistance;
+		const char * ConcreteTypeName;
+		 PX_PHYSX_CORE_API PxParticleFluidGeneratedValues( const PxParticleFluid* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleFluid, Stiffness, PxParticleFluidGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleFluid, Viscosity, PxParticleFluidGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleFluid, RestParticleDistance, PxParticleFluidGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleFluid, ConcreteTypeName, PxParticleFluidGeneratedValues)
+	struct PxParticleFluidGeneratedInfo
+		: PxParticleBaseGeneratedInfo
+	{
+		static const char* getClassName() { return "PxParticleFluid"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleFluid_Stiffness, PxParticleFluid, PxReal, PxReal > Stiffness;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleFluid_Viscosity, PxParticleFluid, PxReal, PxReal > Viscosity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleFluid_RestParticleDistance, PxParticleFluid, PxReal, PxReal > RestParticleDistance;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleFluid_ConcreteTypeName, PxParticleFluid, const char * > ConcreteTypeName;
+
+		PX_PHYSX_CORE_API PxParticleFluidGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxParticleFluid*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxParticleBaseGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxParticleBaseGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxParticleBaseGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 4; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxParticleBaseGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Stiffness, inStartIndex + 0 );; 
+			inOperator( Viscosity, inStartIndex + 1 );; 
+			inOperator( RestParticleDistance, inStartIndex + 2 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 3 );; 
+			return 4 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxParticleFluid>
+	{ 
+		PxParticleFluidGeneratedInfo Info;
+		const PxParticleFluidGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxParticleSystem;
+	struct PxParticleSystemGeneratedValues
+		: PxParticleBaseGeneratedValues	{
+		const char * ConcreteTypeName;
+		 PX_PHYSX_CORE_API PxParticleSystemGeneratedValues( const PxParticleSystem* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleSystem, ConcreteTypeName, PxParticleSystemGeneratedValues)
+	struct PxParticleSystemGeneratedInfo
+		: PxParticleBaseGeneratedInfo
+	{
+		static const char* getClassName() { return "PxParticleSystem"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleSystem_ConcreteTypeName, PxParticleSystem, const char * > ConcreteTypeName;
+
+		PX_PHYSX_CORE_API PxParticleSystemGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxParticleSystem*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxParticleBaseGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxParticleBaseGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxParticleBaseGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 1; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxParticleBaseGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( ConcreteTypeName, inStartIndex + 0 );; 
+			return 1 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxParticleSystem>
+	{ 
+		PxParticleSystemGeneratedInfo Info;
+		const PxParticleSystemGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxPruningStructure;
+	struct PxPruningStructureGeneratedValues
+	{
+		const char * ConcreteTypeName;
+		 PX_PHYSX_CORE_API PxPruningStructureGeneratedValues( const PxPruningStructure* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxPruningStructure, ConcreteTypeName, PxPruningStructureGeneratedValues)
+	struct PxPruningStructureGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxPruningStructure"; }
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxPruningStructure_RigidActors, PxPruningStructure, PxRigidActor * > RigidActors;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxPruningStructure_ConcreteTypeName, PxPruningStructure, const char * > ConcreteTypeName;
+
+		PX_PHYSX_CORE_API PxPruningStructureGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxPruningStructure*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( RigidActors, inStartIndex + 0 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxPruningStructure>
+	{ 
+		PxPruningStructureGeneratedInfo Info;
+		const PxPruningStructureGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxTolerancesScale;
+	struct PxTolerancesScaleGeneratedValues
+	{
+		_Bool IsValid;
+		PxReal Length;
+		PxReal Mass;
+		PxReal Speed;
+		 PX_PHYSX_CORE_API PxTolerancesScaleGeneratedValues( const PxTolerancesScale* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxTolerancesScale, IsValid, PxTolerancesScaleGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxTolerancesScale, Length, PxTolerancesScaleGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxTolerancesScale, Mass, PxTolerancesScaleGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxTolerancesScale, Speed, PxTolerancesScaleGeneratedValues)
+	struct PxTolerancesScaleGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxTolerancesScale"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxTolerancesScale_IsValid, PxTolerancesScale, _Bool > IsValid;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxTolerancesScale_Length, PxTolerancesScale, PxReal, PxReal > Length;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxTolerancesScale_Mass, PxTolerancesScale, PxReal, PxReal > Mass;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxTolerancesScale_Speed, PxTolerancesScale, PxReal, PxReal > Speed;
+
+		PX_PHYSX_CORE_API PxTolerancesScaleGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxTolerancesScale*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 4; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( IsValid, inStartIndex + 0 );; 
+			inOperator( Length, inStartIndex + 1 );; 
+			inOperator( Mass, inStartIndex + 2 );; 
+			inOperator( Speed, inStartIndex + 3 );; 
+			return 4 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxTolerancesScale>
+	{ 
+		PxTolerancesScaleGeneratedInfo Info;
+		const PxTolerancesScaleGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxGeometry;
+	struct PxGeometryGeneratedValues
+	{
+		 PX_PHYSX_CORE_API PxGeometryGeneratedValues( const PxGeometry* inSource );
+	};
+	struct PxGeometryGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxGeometry"; }
+
+		PX_PHYSX_CORE_API PxGeometryGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxGeometry*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 0; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return 0 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxGeometry>
+	{ 
+		PxGeometryGeneratedInfo Info;
+		const PxGeometryGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxBoxGeometry;
+	struct PxBoxGeometryGeneratedValues
+		: PxGeometryGeneratedValues	{
+		PxVec3 HalfExtents;
+		 PX_PHYSX_CORE_API PxBoxGeometryGeneratedValues( const PxBoxGeometry* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxBoxGeometry, HalfExtents, PxBoxGeometryGeneratedValues)
+	struct PxBoxGeometryGeneratedInfo
+		: PxGeometryGeneratedInfo
+	{
+		static const char* getClassName() { return "PxBoxGeometry"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxBoxGeometry_HalfExtents, PxBoxGeometry, PxVec3, PxVec3 > HalfExtents;
+
+		PX_PHYSX_CORE_API PxBoxGeometryGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxBoxGeometry*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxGeometryGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxGeometryGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxGeometryGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 1; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxGeometryGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( HalfExtents, inStartIndex + 0 );; 
+			return 1 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxBoxGeometry>
+	{ 
+		PxBoxGeometryGeneratedInfo Info;
+		const PxBoxGeometryGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxCapsuleGeometry;
+	struct PxCapsuleGeometryGeneratedValues
+		: PxGeometryGeneratedValues	{
+		PxReal Radius;
+		PxReal HalfHeight;
+		 PX_PHYSX_CORE_API PxCapsuleGeometryGeneratedValues( const PxCapsuleGeometry* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCapsuleGeometry, Radius, PxCapsuleGeometryGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxCapsuleGeometry, HalfHeight, PxCapsuleGeometryGeneratedValues)
+	struct PxCapsuleGeometryGeneratedInfo
+		: PxGeometryGeneratedInfo
+	{
+		static const char* getClassName() { return "PxCapsuleGeometry"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCapsuleGeometry_Radius, PxCapsuleGeometry, PxReal, PxReal > Radius;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxCapsuleGeometry_HalfHeight, PxCapsuleGeometry, PxReal, PxReal > HalfHeight;
+
+		PX_PHYSX_CORE_API PxCapsuleGeometryGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxCapsuleGeometry*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxGeometryGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxGeometryGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxGeometryGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxGeometryGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Radius, inStartIndex + 0 );; 
+			inOperator( HalfHeight, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxCapsuleGeometry>
+	{ 
+		PxCapsuleGeometryGeneratedInfo Info;
+		const PxCapsuleGeometryGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxMeshScale;
+	struct PxMeshScaleGeneratedValues
+	{
+		PxVec3 Scale;
+		PxQuat Rotation;
+		 PX_PHYSX_CORE_API PxMeshScaleGeneratedValues( const PxMeshScale* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxMeshScale, Scale, PxMeshScaleGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxMeshScale, Rotation, PxMeshScaleGeneratedValues)
+	struct PxMeshScaleGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxMeshScale"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxMeshScale_Scale, PxMeshScale, PxVec3, PxVec3 > Scale;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxMeshScale_Rotation, PxMeshScale, PxQuat, PxQuat > Rotation;
+
+		PX_PHYSX_CORE_API PxMeshScaleGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxMeshScale*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Scale, inStartIndex + 0 );; 
+			inOperator( Rotation, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxMeshScale>
+	{ 
+		PxMeshScaleGeneratedInfo Info;
+		const PxMeshScaleGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxConvexMeshGeometryFlag__EnumConversion[] = {
+		{ "eTIGHT_BOUNDS", static_cast<PxU32>( physx::PxConvexMeshGeometryFlag::eTIGHT_BOUNDS ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxConvexMeshGeometryFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxConvexMeshGeometryFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxConvexMeshGeometry;
+	struct PxConvexMeshGeometryGeneratedValues
+		: PxGeometryGeneratedValues	{
+		PxMeshScale Scale;
+		PxConvexMesh * ConvexMesh;
+		PxConvexMeshGeometryFlags MeshFlags;
+		 PX_PHYSX_CORE_API PxConvexMeshGeometryGeneratedValues( const PxConvexMeshGeometry* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxConvexMeshGeometry, Scale, PxConvexMeshGeometryGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxConvexMeshGeometry, ConvexMesh, PxConvexMeshGeometryGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxConvexMeshGeometry, MeshFlags, PxConvexMeshGeometryGeneratedValues)
+	struct PxConvexMeshGeometryGeneratedInfo
+		: PxGeometryGeneratedInfo
+	{
+		static const char* getClassName() { return "PxConvexMeshGeometry"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxConvexMeshGeometry_Scale, PxConvexMeshGeometry, PxMeshScale, PxMeshScale > Scale;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxConvexMeshGeometry_ConvexMesh, PxConvexMeshGeometry, PxConvexMesh *, PxConvexMesh * > ConvexMesh;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxConvexMeshGeometry_MeshFlags, PxConvexMeshGeometry, PxConvexMeshGeometryFlags, PxConvexMeshGeometryFlags > MeshFlags;
+
+		PX_PHYSX_CORE_API PxConvexMeshGeometryGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxConvexMeshGeometry*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxGeometryGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxGeometryGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxGeometryGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 3; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxGeometryGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Scale, inStartIndex + 0 );; 
+			inOperator( ConvexMesh, inStartIndex + 1 );; 
+			inOperator( MeshFlags, inStartIndex + 2 );; 
+			return 3 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxConvexMeshGeometry>
+	{ 
+		PxConvexMeshGeometryGeneratedInfo Info;
+		const PxConvexMeshGeometryGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxSphereGeometry;
+	struct PxSphereGeometryGeneratedValues
+		: PxGeometryGeneratedValues	{
+		_Bool IsValid;
+		PxReal Radius;
+		 PX_PHYSX_CORE_API PxSphereGeometryGeneratedValues( const PxSphereGeometry* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSphereGeometry, IsValid, PxSphereGeometryGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSphereGeometry, Radius, PxSphereGeometryGeneratedValues)
+	struct PxSphereGeometryGeneratedInfo
+		: PxGeometryGeneratedInfo
+	{
+		static const char* getClassName() { return "PxSphereGeometry"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxSphereGeometry_IsValid, PxSphereGeometry, _Bool > IsValid;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSphereGeometry_Radius, PxSphereGeometry, PxReal, PxReal > Radius;
+
+		PX_PHYSX_CORE_API PxSphereGeometryGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxSphereGeometry*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxGeometryGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxGeometryGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxGeometryGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxGeometryGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( IsValid, inStartIndex + 0 );; 
+			inOperator( Radius, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxSphereGeometry>
+	{ 
+		PxSphereGeometryGeneratedInfo Info;
+		const PxSphereGeometryGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxPlaneGeometry;
+	struct PxPlaneGeometryGeneratedValues
+		: PxGeometryGeneratedValues	{
+		 PX_PHYSX_CORE_API PxPlaneGeometryGeneratedValues( const PxPlaneGeometry* inSource );
+	};
+	struct PxPlaneGeometryGeneratedInfo
+		: PxGeometryGeneratedInfo
+	{
+		static const char* getClassName() { return "PxPlaneGeometry"; }
+
+		PX_PHYSX_CORE_API PxPlaneGeometryGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxPlaneGeometry*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxGeometryGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxGeometryGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxGeometryGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 0; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxGeometryGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return 0 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxPlaneGeometry>
+	{ 
+		PxPlaneGeometryGeneratedInfo Info;
+		const PxPlaneGeometryGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxMeshGeometryFlag__EnumConversion[] = {
+		{ "eDOUBLE_SIDED", static_cast<PxU32>( physx::PxMeshGeometryFlag::eDOUBLE_SIDED ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxMeshGeometryFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxMeshGeometryFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxTriangleMeshGeometry;
+	struct PxTriangleMeshGeometryGeneratedValues
+		: PxGeometryGeneratedValues	{
+		PxMeshScale Scale;
+		PxMeshGeometryFlags MeshFlags;
+		PxTriangleMesh * TriangleMesh;
+		 PX_PHYSX_CORE_API PxTriangleMeshGeometryGeneratedValues( const PxTriangleMeshGeometry* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxTriangleMeshGeometry, Scale, PxTriangleMeshGeometryGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxTriangleMeshGeometry, MeshFlags, PxTriangleMeshGeometryGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxTriangleMeshGeometry, TriangleMesh, PxTriangleMeshGeometryGeneratedValues)
+	struct PxTriangleMeshGeometryGeneratedInfo
+		: PxGeometryGeneratedInfo
+	{
+		static const char* getClassName() { return "PxTriangleMeshGeometry"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxTriangleMeshGeometry_Scale, PxTriangleMeshGeometry, PxMeshScale, PxMeshScale > Scale;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxTriangleMeshGeometry_MeshFlags, PxTriangleMeshGeometry, PxMeshGeometryFlags, PxMeshGeometryFlags > MeshFlags;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxTriangleMeshGeometry_TriangleMesh, PxTriangleMeshGeometry, PxTriangleMesh *, PxTriangleMesh * > TriangleMesh;
+
+		PX_PHYSX_CORE_API PxTriangleMeshGeometryGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxTriangleMeshGeometry*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxGeometryGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxGeometryGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxGeometryGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 3; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxGeometryGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Scale, inStartIndex + 0 );; 
+			inOperator( MeshFlags, inStartIndex + 1 );; 
+			inOperator( TriangleMesh, inStartIndex + 2 );; 
+			return 3 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxTriangleMeshGeometry>
+	{ 
+		PxTriangleMeshGeometryGeneratedInfo Info;
+		const PxTriangleMeshGeometryGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxHeightFieldGeometry;
+	struct PxHeightFieldGeometryGeneratedValues
+		: PxGeometryGeneratedValues	{
+		PxHeightField * HeightField;
+		PxReal HeightScale;
+		PxReal RowScale;
+		PxReal ColumnScale;
+		PxMeshGeometryFlags HeightFieldFlags;
+		 PX_PHYSX_CORE_API PxHeightFieldGeometryGeneratedValues( const PxHeightFieldGeometry* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldGeometry, HeightField, PxHeightFieldGeometryGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldGeometry, HeightScale, PxHeightFieldGeometryGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldGeometry, RowScale, PxHeightFieldGeometryGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldGeometry, ColumnScale, PxHeightFieldGeometryGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldGeometry, HeightFieldFlags, PxHeightFieldGeometryGeneratedValues)
+	struct PxHeightFieldGeometryGeneratedInfo
+		: PxGeometryGeneratedInfo
+	{
+		static const char* getClassName() { return "PxHeightFieldGeometry"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldGeometry_HeightField, PxHeightFieldGeometry, PxHeightField *, PxHeightField * > HeightField;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldGeometry_HeightScale, PxHeightFieldGeometry, PxReal, PxReal > HeightScale;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldGeometry_RowScale, PxHeightFieldGeometry, PxReal, PxReal > RowScale;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldGeometry_ColumnScale, PxHeightFieldGeometry, PxReal, PxReal > ColumnScale;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldGeometry_HeightFieldFlags, PxHeightFieldGeometry, PxMeshGeometryFlags, PxMeshGeometryFlags > HeightFieldFlags;
+
+		PX_PHYSX_CORE_API PxHeightFieldGeometryGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxHeightFieldGeometry*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxGeometryGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxGeometryGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxGeometryGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 5; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxGeometryGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( HeightField, inStartIndex + 0 );; 
+			inOperator( HeightScale, inStartIndex + 1 );; 
+			inOperator( RowScale, inStartIndex + 2 );; 
+			inOperator( ColumnScale, inStartIndex + 3 );; 
+			inOperator( HeightFieldFlags, inStartIndex + 4 );; 
+			return 5 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxHeightFieldGeometry>
+	{ 
+		PxHeightFieldGeometryGeneratedInfo Info;
+		const PxHeightFieldGeometryGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxHeightFieldFormat__EnumConversion[] = {
+		{ "eS16_TM", static_cast<PxU32>( physx::PxHeightFieldFormat::eS16_TM ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxHeightFieldFormat::Enum > { PxEnumTraits() : NameConversion( g_physx__PxHeightFieldFormat__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxHeightFieldFlag__EnumConversion[] = {
+		{ "eNO_BOUNDARY_EDGES", static_cast<PxU32>( physx::PxHeightFieldFlag::eNO_BOUNDARY_EDGES ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxHeightFieldFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxHeightFieldFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxHeightFieldDesc;
+	struct PxHeightFieldDescGeneratedValues
+	{
+		_Bool IsValid;
+		PxU32 NbRows;
+		PxU32 NbColumns;
+		PxHeightFieldFormat::Enum Format;
+		PxStridedData Samples;
+		PxReal Thickness;
+		PxReal ConvexEdgeThreshold;
+		PxHeightFieldFlags Flags;
+		 PX_PHYSX_CORE_API PxHeightFieldDescGeneratedValues( const PxHeightFieldDesc* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldDesc, IsValid, PxHeightFieldDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldDesc, NbRows, PxHeightFieldDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldDesc, NbColumns, PxHeightFieldDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldDesc, Format, PxHeightFieldDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldDesc, Samples, PxHeightFieldDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldDesc, Thickness, PxHeightFieldDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldDesc, ConvexEdgeThreshold, PxHeightFieldDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxHeightFieldDesc, Flags, PxHeightFieldDescGeneratedValues)
+	struct PxHeightFieldDescGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxHeightFieldDesc"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldDesc_IsValid, PxHeightFieldDesc, _Bool > IsValid;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldDesc_NbRows, PxHeightFieldDesc, PxU32, PxU32 > NbRows;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldDesc_NbColumns, PxHeightFieldDesc, PxU32, PxU32 > NbColumns;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldDesc_Format, PxHeightFieldDesc, PxHeightFieldFormat::Enum, PxHeightFieldFormat::Enum > Format;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldDesc_Samples, PxHeightFieldDesc, PxStridedData, PxStridedData > Samples;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldDesc_Thickness, PxHeightFieldDesc, PxReal, PxReal > Thickness;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldDesc_ConvexEdgeThreshold, PxHeightFieldDesc, PxReal, PxReal > ConvexEdgeThreshold;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxHeightFieldDesc_Flags, PxHeightFieldDesc, PxHeightFieldFlags, PxHeightFieldFlags > Flags;
+
+		PX_PHYSX_CORE_API PxHeightFieldDescGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxHeightFieldDesc*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 8; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( IsValid, inStartIndex + 0 );; 
+			inOperator( NbRows, inStartIndex + 1 );; 
+			inOperator( NbColumns, inStartIndex + 2 );; 
+			inOperator( Format, inStartIndex + 3 );; 
+			inOperator( Samples, inStartIndex + 4 );; 
+			inOperator( Thickness, inStartIndex + 5 );; 
+			inOperator( ConvexEdgeThreshold, inStartIndex + 6 );; 
+			inOperator( Flags, inStartIndex + 7 );; 
+			return 8 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxHeightFieldDesc>
+	{ 
+		PxHeightFieldDescGeneratedInfo Info;
+		const PxHeightFieldDescGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxSceneFlag__EnumConversion[] = {
+		{ "eENABLE_ACTIVE_ACTORS", static_cast<PxU32>( physx::PxSceneFlag::eENABLE_ACTIVE_ACTORS ) },
+		{ "eENABLE_ACTIVETRANSFORMS", static_cast<PxU32>( physx::PxSceneFlag::eENABLE_ACTIVETRANSFORMS ) },
+		{ "eENABLE_CCD", static_cast<PxU32>( physx::PxSceneFlag::eENABLE_CCD ) },
+		{ "eDISABLE_CCD_RESWEEP", static_cast<PxU32>( physx::PxSceneFlag::eDISABLE_CCD_RESWEEP ) },
+		{ "eADAPTIVE_FORCE", static_cast<PxU32>( physx::PxSceneFlag::eADAPTIVE_FORCE ) },
+		{ "eENABLE_KINEMATIC_STATIC_PAIRS", static_cast<PxU32>( physx::PxSceneFlag::eENABLE_KINEMATIC_STATIC_PAIRS ) },
+		{ "eENABLE_KINEMATIC_PAIRS", static_cast<PxU32>( physx::PxSceneFlag::eENABLE_KINEMATIC_PAIRS ) },
+		{ "eENABLE_PCM", static_cast<PxU32>( physx::PxSceneFlag::eENABLE_PCM ) },
+		{ "eDISABLE_CONTACT_REPORT_BUFFER_RESIZE", static_cast<PxU32>( physx::PxSceneFlag::eDISABLE_CONTACT_REPORT_BUFFER_RESIZE ) },
+		{ "eDISABLE_CONTACT_CACHE", static_cast<PxU32>( physx::PxSceneFlag::eDISABLE_CONTACT_CACHE ) },
+		{ "eREQUIRE_RW_LOCK", static_cast<PxU32>( physx::PxSceneFlag::eREQUIRE_RW_LOCK ) },
+		{ "eENABLE_STABILIZATION", static_cast<PxU32>( physx::PxSceneFlag::eENABLE_STABILIZATION ) },
+		{ "eENABLE_AVERAGE_POINT", static_cast<PxU32>( physx::PxSceneFlag::eENABLE_AVERAGE_POINT ) },
+		{ "eDEPRECATED_TRIGGER_TRIGGER_REPORTS", static_cast<PxU32>( physx::PxSceneFlag::eDEPRECATED_TRIGGER_TRIGGER_REPORTS ) },
+		{ "eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS", static_cast<PxU32>( physx::PxSceneFlag::eEXCLUDE_KINEMATICS_FROM_ACTIVE_ACTORS ) },
+		{ "eSUPPRESS_EAGER_SCENE_QUERY_REFIT", static_cast<PxU32>( physx::PxSceneFlag::eSUPPRESS_EAGER_SCENE_QUERY_REFIT ) },
+		{ "eENABLE_GPU_DYNAMICS", static_cast<PxU32>( physx::PxSceneFlag::eENABLE_GPU_DYNAMICS ) },
+		{ "eENABLE_ENHANCED_DETERMINISM", static_cast<PxU32>( physx::PxSceneFlag::eENABLE_ENHANCED_DETERMINISM ) },
+		{ "eMUTABLE_FLAGS", static_cast<PxU32>( physx::PxSceneFlag::eMUTABLE_FLAGS ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxSceneFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxSceneFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxActorTypeFlag__EnumConversion[] = {
+		{ "eRIGID_STATIC", static_cast<PxU32>( physx::PxActorTypeFlag::eRIGID_STATIC ) },
+		{ "eRIGID_DYNAMIC", static_cast<PxU32>( physx::PxActorTypeFlag::eRIGID_DYNAMIC ) },
+		{ "ePARTICLE_SYSTEM", static_cast<PxU32>( physx::PxActorTypeFlag::ePARTICLE_SYSTEM ) },
+		{ "ePARTICLE_FLUID", static_cast<PxU32>( physx::PxActorTypeFlag::ePARTICLE_FLUID ) },
+		{ "eCLOTH", static_cast<PxU32>( physx::PxActorTypeFlag::eCLOTH ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxActorTypeFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxActorTypeFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxClientBehaviorFlag__EnumConversion[] = {
+		{ "eREPORT_FOREIGN_OBJECTS_TO_TRIGGER_NOTIFY", static_cast<PxU32>( physx::PxClientBehaviorFlag::eREPORT_FOREIGN_OBJECTS_TO_TRIGGER_NOTIFY ) },
+		{ "eREPORT_FOREIGN_OBJECTS_TO_CONTACT_NOTIFY", static_cast<PxU32>( physx::PxClientBehaviorFlag::eREPORT_FOREIGN_OBJECTS_TO_CONTACT_NOTIFY ) },
+		{ "eREPORT_FOREIGN_OBJECTS_TO_CONSTRAINT_BREAK_NOTIFY", static_cast<PxU32>( physx::PxClientBehaviorFlag::eREPORT_FOREIGN_OBJECTS_TO_CONSTRAINT_BREAK_NOTIFY ) },
+		{ "eREPORT_FOREIGN_OBJECTS_TO_SCENE_QUERY", static_cast<PxU32>( physx::PxClientBehaviorFlag::eREPORT_FOREIGN_OBJECTS_TO_SCENE_QUERY ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxClientBehaviorFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxClientBehaviorFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxFrictionType__EnumConversion[] = {
+		{ "ePATCH", static_cast<PxU32>( physx::PxFrictionType::ePATCH ) },
+		{ "eONE_DIRECTIONAL", static_cast<PxU32>( physx::PxFrictionType::eONE_DIRECTIONAL ) },
+		{ "eTWO_DIRECTIONAL", static_cast<PxU32>( physx::PxFrictionType::eTWO_DIRECTIONAL ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxFrictionType::Enum > { PxEnumTraits() : NameConversion( g_physx__PxFrictionType__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxVisualizationParameter__EnumConversion[] = {
+		{ "eSCALE", static_cast<PxU32>( physx::PxVisualizationParameter::eSCALE ) },
+		{ "eWORLD_AXES", static_cast<PxU32>( physx::PxVisualizationParameter::eWORLD_AXES ) },
+		{ "eBODY_AXES", static_cast<PxU32>( physx::PxVisualizationParameter::eBODY_AXES ) },
+		{ "eBODY_MASS_AXES", static_cast<PxU32>( physx::PxVisualizationParameter::eBODY_MASS_AXES ) },
+		{ "eBODY_LIN_VELOCITY", static_cast<PxU32>( physx::PxVisualizationParameter::eBODY_LIN_VELOCITY ) },
+		{ "eBODY_ANG_VELOCITY", static_cast<PxU32>( physx::PxVisualizationParameter::eBODY_ANG_VELOCITY ) },
+		{ "eBODY_JOINT_GROUPS", static_cast<PxU32>( physx::PxVisualizationParameter::eBODY_JOINT_GROUPS ) },
+		{ "eCONTACT_POINT", static_cast<PxU32>( physx::PxVisualizationParameter::eCONTACT_POINT ) },
+		{ "eCONTACT_NORMAL", static_cast<PxU32>( physx::PxVisualizationParameter::eCONTACT_NORMAL ) },
+		{ "eCONTACT_ERROR", static_cast<PxU32>( physx::PxVisualizationParameter::eCONTACT_ERROR ) },
+		{ "eCONTACT_FORCE", static_cast<PxU32>( physx::PxVisualizationParameter::eCONTACT_FORCE ) },
+		{ "eACTOR_AXES", static_cast<PxU32>( physx::PxVisualizationParameter::eACTOR_AXES ) },
+		{ "eCOLLISION_AABBS", static_cast<PxU32>( physx::PxVisualizationParameter::eCOLLISION_AABBS ) },
+		{ "eCOLLISION_SHAPES", static_cast<PxU32>( physx::PxVisualizationParameter::eCOLLISION_SHAPES ) },
+		{ "eCOLLISION_AXES", static_cast<PxU32>( physx::PxVisualizationParameter::eCOLLISION_AXES ) },
+		{ "eCOLLISION_COMPOUNDS", static_cast<PxU32>( physx::PxVisualizationParameter::eCOLLISION_COMPOUNDS ) },
+		{ "eCOLLISION_FNORMALS", static_cast<PxU32>( physx::PxVisualizationParameter::eCOLLISION_FNORMALS ) },
+		{ "eCOLLISION_EDGES", static_cast<PxU32>( physx::PxVisualizationParameter::eCOLLISION_EDGES ) },
+		{ "eCOLLISION_STATIC", static_cast<PxU32>( physx::PxVisualizationParameter::eCOLLISION_STATIC ) },
+		{ "eCOLLISION_DYNAMIC", static_cast<PxU32>( physx::PxVisualizationParameter::eCOLLISION_DYNAMIC ) },
+		{ "eDEPRECATED_COLLISION_PAIRS", static_cast<PxU32>( physx::PxVisualizationParameter::eDEPRECATED_COLLISION_PAIRS ) },
+		{ "eJOINT_LOCAL_FRAMES", static_cast<PxU32>( physx::PxVisualizationParameter::eJOINT_LOCAL_FRAMES ) },
+		{ "eJOINT_LIMITS", static_cast<PxU32>( physx::PxVisualizationParameter::eJOINT_LIMITS ) },
+		{ "ePARTICLE_SYSTEM_POSITION", static_cast<PxU32>( physx::PxVisualizationParameter::ePARTICLE_SYSTEM_POSITION ) },
+		{ "ePARTICLE_SYSTEM_VELOCITY", static_cast<PxU32>( physx::PxVisualizationParameter::ePARTICLE_SYSTEM_VELOCITY ) },
+		{ "ePARTICLE_SYSTEM_COLLISION_NORMAL", static_cast<PxU32>( physx::PxVisualizationParameter::ePARTICLE_SYSTEM_COLLISION_NORMAL ) },
+		{ "ePARTICLE_SYSTEM_BOUNDS", static_cast<PxU32>( physx::PxVisualizationParameter::ePARTICLE_SYSTEM_BOUNDS ) },
+		{ "ePARTICLE_SYSTEM_GRID", static_cast<PxU32>( physx::PxVisualizationParameter::ePARTICLE_SYSTEM_GRID ) },
+		{ "ePARTICLE_SYSTEM_BROADPHASE_BOUNDS", static_cast<PxU32>( physx::PxVisualizationParameter::ePARTICLE_SYSTEM_BROADPHASE_BOUNDS ) },
+		{ "ePARTICLE_SYSTEM_MAX_MOTION_DISTANCE", static_cast<PxU32>( physx::PxVisualizationParameter::ePARTICLE_SYSTEM_MAX_MOTION_DISTANCE ) },
+		{ "eCULL_BOX", static_cast<PxU32>( physx::PxVisualizationParameter::eCULL_BOX ) },
+		{ "eCLOTH_VERTICAL", static_cast<PxU32>( physx::PxVisualizationParameter::eCLOTH_VERTICAL ) },
+		{ "eCLOTH_HORIZONTAL", static_cast<PxU32>( physx::PxVisualizationParameter::eCLOTH_HORIZONTAL ) },
+		{ "eCLOTH_BENDING", static_cast<PxU32>( physx::PxVisualizationParameter::eCLOTH_BENDING ) },
+		{ "eCLOTH_SHEARING", static_cast<PxU32>( physx::PxVisualizationParameter::eCLOTH_SHEARING ) },
+		{ "eCLOTH_VIRTUAL_PARTICLES", static_cast<PxU32>( physx::PxVisualizationParameter::eCLOTH_VIRTUAL_PARTICLES ) },
+		{ "eMBP_REGIONS", static_cast<PxU32>( physx::PxVisualizationParameter::eMBP_REGIONS ) },
+		{ "eNUM_VALUES", static_cast<PxU32>( physx::PxVisualizationParameter::eNUM_VALUES ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxVisualizationParameter::Enum > { PxEnumTraits() : NameConversion( g_physx__PxVisualizationParameter__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxPruningStructureType__EnumConversion[] = {
+		{ "eNONE", static_cast<PxU32>( physx::PxPruningStructureType::eNONE ) },
+		{ "eDYNAMIC_AABB_TREE", static_cast<PxU32>( physx::PxPruningStructureType::eDYNAMIC_AABB_TREE ) },
+		{ "eSTATIC_AABB_TREE", static_cast<PxU32>( physx::PxPruningStructureType::eSTATIC_AABB_TREE ) },
+		{ "eLAST", static_cast<PxU32>( physx::PxPruningStructureType::eLAST ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxPruningStructureType::Enum > { PxEnumTraits() : NameConversion( g_physx__PxPruningStructureType__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxHitFlag__EnumConversion[] = {
+		{ "ePOSITION", static_cast<PxU32>( physx::PxHitFlag::ePOSITION ) },
+		{ "eNORMAL", static_cast<PxU32>( physx::PxHitFlag::eNORMAL ) },
+		{ "eDISTANCE", static_cast<PxU32>( physx::PxHitFlag::eDISTANCE ) },
+		{ "eUV", static_cast<PxU32>( physx::PxHitFlag::eUV ) },
+		{ "eASSUME_NO_INITIAL_OVERLAP", static_cast<PxU32>( physx::PxHitFlag::eASSUME_NO_INITIAL_OVERLAP ) },
+		{ "eMESH_MULTIPLE", static_cast<PxU32>( physx::PxHitFlag::eMESH_MULTIPLE ) },
+		{ "eMESH_ANY", static_cast<PxU32>( physx::PxHitFlag::eMESH_ANY ) },
+		{ "eMESH_BOTH_SIDES", static_cast<PxU32>( physx::PxHitFlag::eMESH_BOTH_SIDES ) },
+		{ "ePRECISE_SWEEP", static_cast<PxU32>( physx::PxHitFlag::ePRECISE_SWEEP ) },
+		{ "eMTD", static_cast<PxU32>( physx::PxHitFlag::eMTD ) },
+		{ "eFACE_INDEX", static_cast<PxU32>( physx::PxHitFlag::eFACE_INDEX ) },
+		{ "eDEFAULT", static_cast<PxU32>( physx::PxHitFlag::eDEFAULT ) },
+		{ "eMODIFIABLE_FLAGS", static_cast<PxU32>( physx::PxHitFlag::eMODIFIABLE_FLAGS ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxHitFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxHitFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxBroadPhaseType__EnumConversion[] = {
+		{ "eSAP", static_cast<PxU32>( physx::PxBroadPhaseType::eSAP ) },
+		{ "eMBP", static_cast<PxU32>( physx::PxBroadPhaseType::eMBP ) },
+		{ "eGPU", static_cast<PxU32>( physx::PxBroadPhaseType::eGPU ) },
+		{ "eLAST", static_cast<PxU32>( physx::PxBroadPhaseType::eLAST ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxBroadPhaseType::Enum > { PxEnumTraits() : NameConversion( g_physx__PxBroadPhaseType__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxScene;
+	struct PxSceneGeneratedValues
+	{
+		PxSceneFlags Flags;
+		PxSceneLimits Limits;
+		PxU32 Timestamp;
+		PxCpuDispatcher * CpuDispatcher;
+		PxGpuDispatcher * GpuDispatcher;
+		PxF32 ClothInterCollisionDistance;
+		PxF32 ClothInterCollisionStiffness;
+		PxU32 ClothInterCollisionNbIterations;
+		PxContactModifyCallback * ContactModifyCallback;
+		PxCCDContactModifyCallback * CCDContactModifyCallback;
+		PxU32 FilterShaderDataSize;
+		PxSimulationFilterShader FilterShader;
+		PxSimulationFilterCallback * FilterCallback;
+		PxVec3 Gravity;
+		PxReal BounceThresholdVelocity;
+		PxU32 CCDMaxPasses;
+		PxReal FrictionOffsetThreshold;
+		PxFrictionType::Enum FrictionType;
+		PxBounds3 VisualizationCullingBox;
+		PxPruningStructureType::Enum StaticStructure;
+		PxPruningStructureType::Enum DynamicStructure;
+		PxU32 DynamicTreeRebuildRateHint;
+		PxU32 SceneQueryStaticTimestamp;
+		PxBroadPhaseType::Enum BroadPhaseType;
+		PxTaskManager * TaskManager;
+		PxU32 MaxNbContactDataBlocksUsed;
+		PxU32 ContactReportStreamBufferSize;
+		PxU32 SolverBatchSize;
+		PxReal WakeCounterResetValue;
+		void * UserData;
+		PxSimulationStatistics SimulationStatistics;
+		 PX_PHYSX_CORE_API PxSceneGeneratedValues( const PxScene* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, Flags, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, Limits, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, Timestamp, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, CpuDispatcher, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, GpuDispatcher, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, ClothInterCollisionDistance, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, ClothInterCollisionStiffness, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, ClothInterCollisionNbIterations, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, ContactModifyCallback, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, CCDContactModifyCallback, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, FilterShaderDataSize, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, FilterShader, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, FilterCallback, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, Gravity, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, BounceThresholdVelocity, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, CCDMaxPasses, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, FrictionOffsetThreshold, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, FrictionType, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, VisualizationCullingBox, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, StaticStructure, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, DynamicStructure, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, DynamicTreeRebuildRateHint, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, SceneQueryStaticTimestamp, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, BroadPhaseType, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, TaskManager, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, MaxNbContactDataBlocksUsed, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, ContactReportStreamBufferSize, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, SolverBatchSize, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, WakeCounterResetValue, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, UserData, PxSceneGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxScene, SimulationStatistics, PxSceneGeneratedValues)
+	struct PxSceneGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxScene"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_Flags, PxScene, PxSceneFlags > Flags;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_Limits, PxScene, const PxSceneLimits &, PxSceneLimits > Limits;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_Timestamp, PxScene, PxU32 > Timestamp;
+		PxReadOnlyFilteredCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_Actors, PxScene, PxActor *, PxActorTypeFlags > Actors;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_Articulations, PxScene, PxArticulation * > Articulations;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_Constraints, PxScene, PxConstraint * > Constraints;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_Aggregates, PxScene, PxAggregate * > Aggregates;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_CpuDispatcher, PxScene, PxCpuDispatcher * > CpuDispatcher;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_GpuDispatcher, PxScene, PxGpuDispatcher * > GpuDispatcher;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_ClothInterCollisionDistance, PxScene, PxF32, PxF32 > ClothInterCollisionDistance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_ClothInterCollisionStiffness, PxScene, PxF32, PxF32 > ClothInterCollisionStiffness;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_ClothInterCollisionNbIterations, PxScene, PxU32, PxU32 > ClothInterCollisionNbIterations;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_ContactModifyCallback, PxScene, PxContactModifyCallback *, PxContactModifyCallback * > ContactModifyCallback;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_CCDContactModifyCallback, PxScene, PxCCDContactModifyCallback *, PxCCDContactModifyCallback * > CCDContactModifyCallback;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_FilterShaderDataSize, PxScene, PxU32 > FilterShaderDataSize;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_FilterShader, PxScene, PxSimulationFilterShader > FilterShader;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_FilterCallback, PxScene, PxSimulationFilterCallback * > FilterCallback;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_Gravity, PxScene, const PxVec3 &, PxVec3 > Gravity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_BounceThresholdVelocity, PxScene, const PxReal, PxReal > BounceThresholdVelocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_CCDMaxPasses, PxScene, PxU32, PxU32 > CCDMaxPasses;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_FrictionOffsetThreshold, PxScene, PxReal > FrictionOffsetThreshold;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_FrictionType, PxScene, PxFrictionType::Enum, PxFrictionType::Enum > FrictionType;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_VisualizationCullingBox, PxScene, const PxBounds3 &, const PxBounds3 & > VisualizationCullingBox;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_StaticStructure, PxScene, PxPruningStructureType::Enum > StaticStructure;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_DynamicStructure, PxScene, PxPruningStructureType::Enum > DynamicStructure;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_DynamicTreeRebuildRateHint, PxScene, PxU32, PxU32 > DynamicTreeRebuildRateHint;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_SceneQueryStaticTimestamp, PxScene, PxU32 > SceneQueryStaticTimestamp;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_BroadPhaseType, PxScene, PxBroadPhaseType::Enum > BroadPhaseType;
+		PxReadOnlyCollectionPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_BroadPhaseRegions, PxScene, PxBroadPhaseRegionInfo > BroadPhaseRegions;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_TaskManager, PxScene, PxTaskManager * > TaskManager;
+		PxWriteOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_NbContactDataBlocks, PxScene, PxU32 > NbContactDataBlocks;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_MaxNbContactDataBlocksUsed, PxScene, PxU32 > MaxNbContactDataBlocksUsed;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_ContactReportStreamBufferSize, PxScene, PxU32 > ContactReportStreamBufferSize;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_SolverBatchSize, PxScene, PxU32, PxU32 > SolverBatchSize;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_WakeCounterResetValue, PxScene, PxReal > WakeCounterResetValue;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxScene_UserData, PxScene, void *, void * > UserData;
+		SimulationStatisticsProperty SimulationStatistics;
+
+		PX_PHYSX_CORE_API PxSceneGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxScene*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 37; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Flags, inStartIndex + 0 );; 
+			inOperator( Limits, inStartIndex + 1 );; 
+			inOperator( Timestamp, inStartIndex + 2 );; 
+			inOperator( Actors, inStartIndex + 3 );; 
+			inOperator( Articulations, inStartIndex + 4 );; 
+			inOperator( Constraints, inStartIndex + 5 );; 
+			inOperator( Aggregates, inStartIndex + 6 );; 
+			inOperator( CpuDispatcher, inStartIndex + 7 );; 
+			inOperator( GpuDispatcher, inStartIndex + 8 );; 
+			inOperator( ClothInterCollisionDistance, inStartIndex + 9 );; 
+			inOperator( ClothInterCollisionStiffness, inStartIndex + 10 );; 
+			inOperator( ClothInterCollisionNbIterations, inStartIndex + 11 );; 
+			inOperator( ContactModifyCallback, inStartIndex + 12 );; 
+			inOperator( CCDContactModifyCallback, inStartIndex + 13 );; 
+			inOperator( FilterShaderDataSize, inStartIndex + 14 );; 
+			inOperator( FilterShader, inStartIndex + 15 );; 
+			inOperator( FilterCallback, inStartIndex + 16 );; 
+			inOperator( Gravity, inStartIndex + 17 );; 
+			inOperator( BounceThresholdVelocity, inStartIndex + 18 );; 
+			inOperator( CCDMaxPasses, inStartIndex + 19 );; 
+			inOperator( FrictionOffsetThreshold, inStartIndex + 20 );; 
+			inOperator( FrictionType, inStartIndex + 21 );; 
+			inOperator( VisualizationCullingBox, inStartIndex + 22 );; 
+			inOperator( StaticStructure, inStartIndex + 23 );; 
+			inOperator( DynamicStructure, inStartIndex + 24 );; 
+			inOperator( DynamicTreeRebuildRateHint, inStartIndex + 25 );; 
+			inOperator( SceneQueryStaticTimestamp, inStartIndex + 26 );; 
+			inOperator( BroadPhaseType, inStartIndex + 27 );; 
+			inOperator( BroadPhaseRegions, inStartIndex + 28 );; 
+			inOperator( TaskManager, inStartIndex + 29 );; 
+			inOperator( NbContactDataBlocks, inStartIndex + 30 );; 
+			inOperator( MaxNbContactDataBlocksUsed, inStartIndex + 31 );; 
+			inOperator( ContactReportStreamBufferSize, inStartIndex + 32 );; 
+			inOperator( SolverBatchSize, inStartIndex + 33 );; 
+			inOperator( WakeCounterResetValue, inStartIndex + 34 );; 
+			inOperator( UserData, inStartIndex + 35 );; 
+			inOperator( SimulationStatistics, inStartIndex + 36 );; 
+			return 37 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxScene>
+	{ 
+		PxSceneGeneratedInfo Info;
+		const PxSceneGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	struct PxClothParticle;
+	struct PxClothParticleGeneratedValues
+	{
+		PxVec3 Pos;
+		PxReal InvWeight;
+		 PX_PHYSX_CORE_API PxClothParticleGeneratedValues( const PxClothParticle* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothParticle, Pos, PxClothParticleGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothParticle, InvWeight, PxClothParticleGeneratedValues)
+	struct PxClothParticleGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxClothParticle"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothParticle_Pos, PxClothParticle, PxVec3, PxVec3 > Pos;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothParticle_InvWeight, PxClothParticle, PxReal, PxReal > InvWeight;
+
+		PX_PHYSX_CORE_API PxClothParticleGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxClothParticle*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Pos, inStartIndex + 0 );; 
+			inOperator( InvWeight, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxClothParticle>
+	{ 
+		PxClothParticleGeneratedInfo Info;
+		const PxClothParticleGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	struct PxClothFabricPhase;
+	struct PxClothFabricPhaseGeneratedValues
+	{
+		PxClothFabricPhaseType::Enum PhaseType;
+		PxU32 SetIndex;
+		 PX_PHYSX_CORE_API PxClothFabricPhaseGeneratedValues( const PxClothFabricPhase* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothFabricPhase, PhaseType, PxClothFabricPhaseGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothFabricPhase, SetIndex, PxClothFabricPhaseGeneratedValues)
+	struct PxClothFabricPhaseGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxClothFabricPhase"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothFabricPhase_PhaseType, PxClothFabricPhase, PxClothFabricPhaseType::Enum, PxClothFabricPhaseType::Enum > PhaseType;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothFabricPhase_SetIndex, PxClothFabricPhase, PxU32, PxU32 > SetIndex;
+
+		PX_PHYSX_CORE_API PxClothFabricPhaseGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxClothFabricPhase*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( PhaseType, inStartIndex + 0 );; 
+			inOperator( SetIndex, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxClothFabricPhase>
+	{ 
+		PxClothFabricPhaseGeneratedInfo Info;
+		const PxClothFabricPhaseGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxSceneLimits;
+	struct PxSceneLimitsGeneratedValues
+	{
+		PxU32 MaxNbActors;
+		PxU32 MaxNbBodies;
+		PxU32 MaxNbStaticShapes;
+		PxU32 MaxNbDynamicShapes;
+		PxU32 MaxNbAggregates;
+		PxU32 MaxNbConstraints;
+		PxU32 MaxNbRegions;
+		PxU32 MaxNbBroadPhaseOverlaps;
+		PxU32 MaxNbObjectsPerRegion;
+		 PX_PHYSX_CORE_API PxSceneLimitsGeneratedValues( const PxSceneLimits* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneLimits, MaxNbActors, PxSceneLimitsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneLimits, MaxNbBodies, PxSceneLimitsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneLimits, MaxNbStaticShapes, PxSceneLimitsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneLimits, MaxNbDynamicShapes, PxSceneLimitsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneLimits, MaxNbAggregates, PxSceneLimitsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneLimits, MaxNbConstraints, PxSceneLimitsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneLimits, MaxNbRegions, PxSceneLimitsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneLimits, MaxNbBroadPhaseOverlaps, PxSceneLimitsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneLimits, MaxNbObjectsPerRegion, PxSceneLimitsGeneratedValues)
+	struct PxSceneLimitsGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxSceneLimits"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneLimits_MaxNbActors, PxSceneLimits, PxU32, PxU32 > MaxNbActors;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneLimits_MaxNbBodies, PxSceneLimits, PxU32, PxU32 > MaxNbBodies;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneLimits_MaxNbStaticShapes, PxSceneLimits, PxU32, PxU32 > MaxNbStaticShapes;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneLimits_MaxNbDynamicShapes, PxSceneLimits, PxU32, PxU32 > MaxNbDynamicShapes;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneLimits_MaxNbAggregates, PxSceneLimits, PxU32, PxU32 > MaxNbAggregates;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneLimits_MaxNbConstraints, PxSceneLimits, PxU32, PxU32 > MaxNbConstraints;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneLimits_MaxNbRegions, PxSceneLimits, PxU32, PxU32 > MaxNbRegions;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneLimits_MaxNbBroadPhaseOverlaps, PxSceneLimits, PxU32, PxU32 > MaxNbBroadPhaseOverlaps;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneLimits_MaxNbObjectsPerRegion, PxSceneLimits, PxU32, PxU32 > MaxNbObjectsPerRegion;
+
+		PX_PHYSX_CORE_API PxSceneLimitsGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxSceneLimits*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 9; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( MaxNbActors, inStartIndex + 0 );; 
+			inOperator( MaxNbBodies, inStartIndex + 1 );; 
+			inOperator( MaxNbStaticShapes, inStartIndex + 2 );; 
+			inOperator( MaxNbDynamicShapes, inStartIndex + 3 );; 
+			inOperator( MaxNbAggregates, inStartIndex + 4 );; 
+			inOperator( MaxNbConstraints, inStartIndex + 5 );; 
+			inOperator( MaxNbRegions, inStartIndex + 6 );; 
+			inOperator( MaxNbBroadPhaseOverlaps, inStartIndex + 7 );; 
+			inOperator( MaxNbObjectsPerRegion, inStartIndex + 8 );; 
+			return 9 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxSceneLimits>
+	{ 
+		PxSceneLimitsGeneratedInfo Info;
+		const PxSceneLimitsGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	struct PxgDynamicsMemoryConfig;
+	struct PxgDynamicsMemoryConfigGeneratedValues
+	{
+		PxU32 ConstraintBufferCapacity;
+		PxU32 ContactBufferCapacity;
+		PxU32 TempBufferCapacity;
+		PxU32 ContactStreamSize;
+		PxU32 PatchStreamSize;
+		PxU32 ForceStreamCapacity;
+		PxU32 HeapCapacity;
+		PxU32 FoundLostPairsCapacity;
+		 PX_PHYSX_CORE_API PxgDynamicsMemoryConfigGeneratedValues( const PxgDynamicsMemoryConfig* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxgDynamicsMemoryConfig, ConstraintBufferCapacity, PxgDynamicsMemoryConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxgDynamicsMemoryConfig, ContactBufferCapacity, PxgDynamicsMemoryConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxgDynamicsMemoryConfig, TempBufferCapacity, PxgDynamicsMemoryConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxgDynamicsMemoryConfig, ContactStreamSize, PxgDynamicsMemoryConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxgDynamicsMemoryConfig, PatchStreamSize, PxgDynamicsMemoryConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxgDynamicsMemoryConfig, ForceStreamCapacity, PxgDynamicsMemoryConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxgDynamicsMemoryConfig, HeapCapacity, PxgDynamicsMemoryConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxgDynamicsMemoryConfig, FoundLostPairsCapacity, PxgDynamicsMemoryConfigGeneratedValues)
+	struct PxgDynamicsMemoryConfigGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxgDynamicsMemoryConfig"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxgDynamicsMemoryConfig_ConstraintBufferCapacity, PxgDynamicsMemoryConfig, PxU32, PxU32 > ConstraintBufferCapacity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxgDynamicsMemoryConfig_ContactBufferCapacity, PxgDynamicsMemoryConfig, PxU32, PxU32 > ContactBufferCapacity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxgDynamicsMemoryConfig_TempBufferCapacity, PxgDynamicsMemoryConfig, PxU32, PxU32 > TempBufferCapacity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxgDynamicsMemoryConfig_ContactStreamSize, PxgDynamicsMemoryConfig, PxU32, PxU32 > ContactStreamSize;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxgDynamicsMemoryConfig_PatchStreamSize, PxgDynamicsMemoryConfig, PxU32, PxU32 > PatchStreamSize;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxgDynamicsMemoryConfig_ForceStreamCapacity, PxgDynamicsMemoryConfig, PxU32, PxU32 > ForceStreamCapacity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxgDynamicsMemoryConfig_HeapCapacity, PxgDynamicsMemoryConfig, PxU32, PxU32 > HeapCapacity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxgDynamicsMemoryConfig_FoundLostPairsCapacity, PxgDynamicsMemoryConfig, PxU32, PxU32 > FoundLostPairsCapacity;
+
+		PX_PHYSX_CORE_API PxgDynamicsMemoryConfigGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxgDynamicsMemoryConfig*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 8; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( ConstraintBufferCapacity, inStartIndex + 0 );; 
+			inOperator( ContactBufferCapacity, inStartIndex + 1 );; 
+			inOperator( TempBufferCapacity, inStartIndex + 2 );; 
+			inOperator( ContactStreamSize, inStartIndex + 3 );; 
+			inOperator( PatchStreamSize, inStartIndex + 4 );; 
+			inOperator( ForceStreamCapacity, inStartIndex + 5 );; 
+			inOperator( HeapCapacity, inStartIndex + 6 );; 
+			inOperator( FoundLostPairsCapacity, inStartIndex + 7 );; 
+			return 8 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxgDynamicsMemoryConfig>
+	{ 
+		PxgDynamicsMemoryConfigGeneratedInfo Info;
+		const PxgDynamicsMemoryConfigGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxSceneDesc;
+	struct PxSceneDescGeneratedValues
+	{
+		_Bool IsValid;
+		PxVec3 Gravity;
+		PxSimulationEventCallback * SimulationEventCallback;
+		PxContactModifyCallback * ContactModifyCallback;
+		PxCCDContactModifyCallback * CcdContactModifyCallback;
+		const void * FilterShaderData;
+		PxU32 FilterShaderDataSize;
+		PxSimulationFilterShader FilterShader;
+		PxSimulationFilterCallback * FilterCallback;
+		PxBroadPhaseType::Enum BroadPhaseType;
+		PxBroadPhaseCallback * BroadPhaseCallback;
+		PxSceneLimits Limits;
+		PxFrictionType::Enum FrictionType;
+		PxReal BounceThresholdVelocity;
+		PxReal FrictionOffsetThreshold;
+		PxReal CcdMaxSeparation;
+		PxSceneFlags Flags;
+		PxCpuDispatcher * CpuDispatcher;
+		PxGpuDispatcher * GpuDispatcher;
+		PxPruningStructureType::Enum StaticStructure;
+		PxPruningStructureType::Enum DynamicStructure;
+		PxU32 DynamicTreeRebuildRateHint;
+		void * UserData;
+		PxU32 SolverBatchSize;
+		PxU32 NbContactDataBlocks;
+		PxU32 MaxNbContactDataBlocks;
+		PxU32 ContactReportStreamBufferSize;
+		PxU32 CcdMaxPasses;
+		PxReal WakeCounterResetValue;
+		PxBounds3 SanityBounds;
+		PxgDynamicsMemoryConfig GpuDynamicsConfig;
+		PxU32 GpuMaxNumPartitions;
+		PxU32 GpuComputeVersion;
+		 PX_PHYSX_CORE_API PxSceneDescGeneratedValues( const PxSceneDesc* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, IsValid, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, Gravity, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, SimulationEventCallback, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, ContactModifyCallback, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, CcdContactModifyCallback, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, FilterShaderData, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, FilterShaderDataSize, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, FilterShader, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, FilterCallback, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, BroadPhaseType, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, BroadPhaseCallback, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, Limits, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, FrictionType, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, BounceThresholdVelocity, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, FrictionOffsetThreshold, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, CcdMaxSeparation, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, Flags, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, CpuDispatcher, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, GpuDispatcher, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, StaticStructure, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, DynamicStructure, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, DynamicTreeRebuildRateHint, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, UserData, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, SolverBatchSize, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, NbContactDataBlocks, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, MaxNbContactDataBlocks, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, ContactReportStreamBufferSize, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, CcdMaxPasses, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, WakeCounterResetValue, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, SanityBounds, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, GpuDynamicsConfig, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, GpuMaxNumPartitions, PxSceneDescGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSceneDesc, GpuComputeVersion, PxSceneDescGeneratedValues)
+	struct PxSceneDescGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxSceneDesc"; }
+		PxWriteOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_ToDefault, PxSceneDesc, const PxTolerancesScale & > ToDefault;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_IsValid, PxSceneDesc, _Bool > IsValid;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_Gravity, PxSceneDesc, PxVec3, PxVec3 > Gravity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_SimulationEventCallback, PxSceneDesc, PxSimulationEventCallback *, PxSimulationEventCallback * > SimulationEventCallback;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_ContactModifyCallback, PxSceneDesc, PxContactModifyCallback *, PxContactModifyCallback * > ContactModifyCallback;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_CcdContactModifyCallback, PxSceneDesc, PxCCDContactModifyCallback *, PxCCDContactModifyCallback * > CcdContactModifyCallback;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_FilterShaderData, PxSceneDesc, const void *, const void * > FilterShaderData;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_FilterShaderDataSize, PxSceneDesc, PxU32, PxU32 > FilterShaderDataSize;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_FilterShader, PxSceneDesc, PxSimulationFilterShader, PxSimulationFilterShader > FilterShader;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_FilterCallback, PxSceneDesc, PxSimulationFilterCallback *, PxSimulationFilterCallback * > FilterCallback;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_BroadPhaseType, PxSceneDesc, PxBroadPhaseType::Enum, PxBroadPhaseType::Enum > BroadPhaseType;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_BroadPhaseCallback, PxSceneDesc, PxBroadPhaseCallback *, PxBroadPhaseCallback * > BroadPhaseCallback;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_Limits, PxSceneDesc, PxSceneLimits, PxSceneLimits > Limits;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_FrictionType, PxSceneDesc, PxFrictionType::Enum, PxFrictionType::Enum > FrictionType;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_BounceThresholdVelocity, PxSceneDesc, PxReal, PxReal > BounceThresholdVelocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_FrictionOffsetThreshold, PxSceneDesc, PxReal, PxReal > FrictionOffsetThreshold;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_CcdMaxSeparation, PxSceneDesc, PxReal, PxReal > CcdMaxSeparation;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_Flags, PxSceneDesc, PxSceneFlags, PxSceneFlags > Flags;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_CpuDispatcher, PxSceneDesc, PxCpuDispatcher *, PxCpuDispatcher * > CpuDispatcher;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_GpuDispatcher, PxSceneDesc, PxGpuDispatcher *, PxGpuDispatcher * > GpuDispatcher;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_StaticStructure, PxSceneDesc, PxPruningStructureType::Enum, PxPruningStructureType::Enum > StaticStructure;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_DynamicStructure, PxSceneDesc, PxPruningStructureType::Enum, PxPruningStructureType::Enum > DynamicStructure;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_DynamicTreeRebuildRateHint, PxSceneDesc, PxU32, PxU32 > DynamicTreeRebuildRateHint;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_UserData, PxSceneDesc, void *, void * > UserData;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_SolverBatchSize, PxSceneDesc, PxU32, PxU32 > SolverBatchSize;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_NbContactDataBlocks, PxSceneDesc, PxU32, PxU32 > NbContactDataBlocks;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_MaxNbContactDataBlocks, PxSceneDesc, PxU32, PxU32 > MaxNbContactDataBlocks;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_ContactReportStreamBufferSize, PxSceneDesc, PxU32, PxU32 > ContactReportStreamBufferSize;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_CcdMaxPasses, PxSceneDesc, PxU32, PxU32 > CcdMaxPasses;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_WakeCounterResetValue, PxSceneDesc, PxReal, PxReal > WakeCounterResetValue;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_SanityBounds, PxSceneDesc, PxBounds3, PxBounds3 > SanityBounds;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_GpuDynamicsConfig, PxSceneDesc, PxgDynamicsMemoryConfig, PxgDynamicsMemoryConfig > GpuDynamicsConfig;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_GpuMaxNumPartitions, PxSceneDesc, PxU32, PxU32 > GpuMaxNumPartitions;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSceneDesc_GpuComputeVersion, PxSceneDesc, PxU32, PxU32 > GpuComputeVersion;
+
+		PX_PHYSX_CORE_API PxSceneDescGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxSceneDesc*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 34; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( ToDefault, inStartIndex + 0 );; 
+			inOperator( IsValid, inStartIndex + 1 );; 
+			inOperator( Gravity, inStartIndex + 2 );; 
+			inOperator( SimulationEventCallback, inStartIndex + 3 );; 
+			inOperator( ContactModifyCallback, inStartIndex + 4 );; 
+			inOperator( CcdContactModifyCallback, inStartIndex + 5 );; 
+			inOperator( FilterShaderData, inStartIndex + 6 );; 
+			inOperator( FilterShaderDataSize, inStartIndex + 7 );; 
+			inOperator( FilterShader, inStartIndex + 8 );; 
+			inOperator( FilterCallback, inStartIndex + 9 );; 
+			inOperator( BroadPhaseType, inStartIndex + 10 );; 
+			inOperator( BroadPhaseCallback, inStartIndex + 11 );; 
+			inOperator( Limits, inStartIndex + 12 );; 
+			inOperator( FrictionType, inStartIndex + 13 );; 
+			inOperator( BounceThresholdVelocity, inStartIndex + 14 );; 
+			inOperator( FrictionOffsetThreshold, inStartIndex + 15 );; 
+			inOperator( CcdMaxSeparation, inStartIndex + 16 );; 
+			inOperator( Flags, inStartIndex + 17 );; 
+			inOperator( CpuDispatcher, inStartIndex + 18 );; 
+			inOperator( GpuDispatcher, inStartIndex + 19 );; 
+			inOperator( StaticStructure, inStartIndex + 20 );; 
+			inOperator( DynamicStructure, inStartIndex + 21 );; 
+			inOperator( DynamicTreeRebuildRateHint, inStartIndex + 22 );; 
+			inOperator( UserData, inStartIndex + 23 );; 
+			inOperator( SolverBatchSize, inStartIndex + 24 );; 
+			inOperator( NbContactDataBlocks, inStartIndex + 25 );; 
+			inOperator( MaxNbContactDataBlocks, inStartIndex + 26 );; 
+			inOperator( ContactReportStreamBufferSize, inStartIndex + 27 );; 
+			inOperator( CcdMaxPasses, inStartIndex + 28 );; 
+			inOperator( WakeCounterResetValue, inStartIndex + 29 );; 
+			inOperator( SanityBounds, inStartIndex + 30 );; 
+			inOperator( GpuDynamicsConfig, inStartIndex + 31 );; 
+			inOperator( GpuMaxNumPartitions, inStartIndex + 32 );; 
+			inOperator( GpuComputeVersion, inStartIndex + 33 );; 
+			return 34 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxSceneDesc>
+	{ 
+		PxSceneDescGeneratedInfo Info;
+		const PxSceneDescGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxSimulationStatistics__VolumeTypeConversion[] = {
+		{ "eRIGID_BODY", static_cast<PxU32>( physx::PxSimulationStatistics::eRIGID_BODY ) },
+		{ "ePARTICLE_SYSTEM", static_cast<PxU32>( physx::PxSimulationStatistics::ePARTICLE_SYSTEM ) },
+		{ "eCLOTH", static_cast<PxU32>( physx::PxSimulationStatistics::eCLOTH ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxSimulationStatistics::VolumeType > { PxEnumTraits() : NameConversion( g_physx__PxSimulationStatistics__VolumeTypeConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxSimulationStatistics__RbPairStatsTypeConversion[] = {
+		{ "eDISCRETE_CONTACT_PAIRS", static_cast<PxU32>( physx::PxSimulationStatistics::eDISCRETE_CONTACT_PAIRS ) },
+		{ "eCCD_PAIRS", static_cast<PxU32>( physx::PxSimulationStatistics::eCCD_PAIRS ) },
+		{ "eMODIFIED_CONTACT_PAIRS", static_cast<PxU32>( physx::PxSimulationStatistics::eMODIFIED_CONTACT_PAIRS ) },
+		{ "eTRIGGER_PAIRS", static_cast<PxU32>( physx::PxSimulationStatistics::eTRIGGER_PAIRS ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxSimulationStatistics::RbPairStatsType > { PxEnumTraits() : NameConversion( g_physx__PxSimulationStatistics__RbPairStatsTypeConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxSimulationStatistics;
+	struct PxSimulationStatisticsGeneratedValues
+	{
+		PxU32 NbActiveConstraints;
+		PxU32 NbActiveDynamicBodies;
+		PxU32 NbActiveKinematicBodies;
+		PxU32 NbStaticBodies;
+		PxU32 NbDynamicBodies;
+		PxU32 NbAggregates;
+		PxU32 NbArticulations;
+		PxU32 NbAxisSolverConstraints;
+		PxU32 CompressedContactSize;
+		PxU32 RequiredContactConstraintMemory;
+		PxU32 PeakConstraintMemory;
+		PxU32 NbDiscreteContactPairsTotal;
+		PxU32 NbDiscreteContactPairsWithCacheHits;
+		PxU32 NbDiscreteContactPairsWithContacts;
+		PxU32 NbNewPairs;
+		PxU32 NbLostPairs;
+		PxU32 NbNewTouches;
+		PxU32 NbLostTouches;
+		PxU32 NbPartitions;
+		PxU32 ParticlesGpuMeshCacheSize;
+		PxU32 ParticlesGpuMeshCacheUsed;
+		PxReal ParticlesGpuMeshCacheHitrate;
+		PxU32 NbDiscreteContactPairs[PxGeometryType::eGEOMETRY_COUNT][PxGeometryType::eGEOMETRY_COUNT];
+		PxU32 NbModifiedContactPairs[PxGeometryType::eGEOMETRY_COUNT][PxGeometryType::eGEOMETRY_COUNT];
+		PxU32 NbCCDPairs[PxGeometryType::eGEOMETRY_COUNT][PxGeometryType::eGEOMETRY_COUNT];
+		PxU32 NbTriggerPairs[PxGeometryType::eGEOMETRY_COUNT][PxGeometryType::eGEOMETRY_COUNT];
+		PxU32 NbBroadPhaseAdds[PxSimulationStatistics::eVOLUME_COUNT];
+		PxU32 NbBroadPhaseRemoves[PxSimulationStatistics::eVOLUME_COUNT];
+		PxU32 NbShapes[PxGeometryType::eGEOMETRY_COUNT];
+		 PX_PHYSX_CORE_API PxSimulationStatisticsGeneratedValues( const PxSimulationStatistics* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbActiveConstraints, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbActiveDynamicBodies, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbActiveKinematicBodies, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbStaticBodies, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbDynamicBodies, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbAggregates, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbArticulations, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbAxisSolverConstraints, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, CompressedContactSize, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, RequiredContactConstraintMemory, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, PeakConstraintMemory, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbDiscreteContactPairsTotal, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbDiscreteContactPairsWithCacheHits, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbDiscreteContactPairsWithContacts, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbNewPairs, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbLostPairs, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbNewTouches, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbLostTouches, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbPartitions, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, ParticlesGpuMeshCacheSize, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, ParticlesGpuMeshCacheUsed, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, ParticlesGpuMeshCacheHitrate, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbDiscreteContactPairs, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbModifiedContactPairs, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbCCDPairs, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbTriggerPairs, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbBroadPhaseAdds, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbBroadPhaseRemoves, PxSimulationStatisticsGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSimulationStatistics, NbShapes, PxSimulationStatisticsGeneratedValues)
+	struct PxSimulationStatisticsGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxSimulationStatistics"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbActiveConstraints, PxSimulationStatistics, PxU32, PxU32 > NbActiveConstraints;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbActiveDynamicBodies, PxSimulationStatistics, PxU32, PxU32 > NbActiveDynamicBodies;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbActiveKinematicBodies, PxSimulationStatistics, PxU32, PxU32 > NbActiveKinematicBodies;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbStaticBodies, PxSimulationStatistics, PxU32, PxU32 > NbStaticBodies;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbDynamicBodies, PxSimulationStatistics, PxU32, PxU32 > NbDynamicBodies;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbAggregates, PxSimulationStatistics, PxU32, PxU32 > NbAggregates;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbArticulations, PxSimulationStatistics, PxU32, PxU32 > NbArticulations;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbAxisSolverConstraints, PxSimulationStatistics, PxU32, PxU32 > NbAxisSolverConstraints;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_CompressedContactSize, PxSimulationStatistics, PxU32, PxU32 > CompressedContactSize;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_RequiredContactConstraintMemory, PxSimulationStatistics, PxU32, PxU32 > RequiredContactConstraintMemory;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_PeakConstraintMemory, PxSimulationStatistics, PxU32, PxU32 > PeakConstraintMemory;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbDiscreteContactPairsTotal, PxSimulationStatistics, PxU32, PxU32 > NbDiscreteContactPairsTotal;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbDiscreteContactPairsWithCacheHits, PxSimulationStatistics, PxU32, PxU32 > NbDiscreteContactPairsWithCacheHits;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbDiscreteContactPairsWithContacts, PxSimulationStatistics, PxU32, PxU32 > NbDiscreteContactPairsWithContacts;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbNewPairs, PxSimulationStatistics, PxU32, PxU32 > NbNewPairs;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbLostPairs, PxSimulationStatistics, PxU32, PxU32 > NbLostPairs;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbNewTouches, PxSimulationStatistics, PxU32, PxU32 > NbNewTouches;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbLostTouches, PxSimulationStatistics, PxU32, PxU32 > NbLostTouches;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_NbPartitions, PxSimulationStatistics, PxU32, PxU32 > NbPartitions;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_ParticlesGpuMeshCacheSize, PxSimulationStatistics, PxU32, PxU32 > ParticlesGpuMeshCacheSize;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_ParticlesGpuMeshCacheUsed, PxSimulationStatistics, PxU32, PxU32 > ParticlesGpuMeshCacheUsed;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSimulationStatistics_ParticlesGpuMeshCacheHitrate, PxSimulationStatistics, PxReal, PxReal > ParticlesGpuMeshCacheHitrate;
+		NbDiscreteContactPairsProperty NbDiscreteContactPairs;
+		NbModifiedContactPairsProperty NbModifiedContactPairs;
+		NbCCDPairsProperty NbCCDPairs;
+		NbTriggerPairsProperty NbTriggerPairs;
+		NbBroadPhaseAddsProperty NbBroadPhaseAdds;
+		NbBroadPhaseRemovesProperty NbBroadPhaseRemoves;
+		NbShapesProperty NbShapes;
+
+		PX_PHYSX_CORE_API PxSimulationStatisticsGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxSimulationStatistics*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 29; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( NbActiveConstraints, inStartIndex + 0 );; 
+			inOperator( NbActiveDynamicBodies, inStartIndex + 1 );; 
+			inOperator( NbActiveKinematicBodies, inStartIndex + 2 );; 
+			inOperator( NbStaticBodies, inStartIndex + 3 );; 
+			inOperator( NbDynamicBodies, inStartIndex + 4 );; 
+			inOperator( NbAggregates, inStartIndex + 5 );; 
+			inOperator( NbArticulations, inStartIndex + 6 );; 
+			inOperator( NbAxisSolverConstraints, inStartIndex + 7 );; 
+			inOperator( CompressedContactSize, inStartIndex + 8 );; 
+			inOperator( RequiredContactConstraintMemory, inStartIndex + 9 );; 
+			inOperator( PeakConstraintMemory, inStartIndex + 10 );; 
+			inOperator( NbDiscreteContactPairsTotal, inStartIndex + 11 );; 
+			inOperator( NbDiscreteContactPairsWithCacheHits, inStartIndex + 12 );; 
+			inOperator( NbDiscreteContactPairsWithContacts, inStartIndex + 13 );; 
+			inOperator( NbNewPairs, inStartIndex + 14 );; 
+			inOperator( NbLostPairs, inStartIndex + 15 );; 
+			inOperator( NbNewTouches, inStartIndex + 16 );; 
+			inOperator( NbLostTouches, inStartIndex + 17 );; 
+			inOperator( NbPartitions, inStartIndex + 18 );; 
+			inOperator( ParticlesGpuMeshCacheSize, inStartIndex + 19 );; 
+			inOperator( ParticlesGpuMeshCacheUsed, inStartIndex + 20 );; 
+			inOperator( ParticlesGpuMeshCacheHitrate, inStartIndex + 21 );; 
+			inOperator( NbDiscreteContactPairs, inStartIndex + 22 );; 
+			inOperator( NbModifiedContactPairs, inStartIndex + 23 );; 
+			inOperator( NbCCDPairs, inStartIndex + 24 );; 
+			inOperator( NbTriggerPairs, inStartIndex + 25 );; 
+			inOperator( NbBroadPhaseAdds, inStartIndex + 26 );; 
+			inOperator( NbBroadPhaseRemoves, inStartIndex + 27 );; 
+			inOperator( NbShapes, inStartIndex + 28 );; 
+			return 29 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxSimulationStatistics>
+	{ 
+		PxSimulationStatisticsGeneratedInfo Info;
+		const PxSimulationStatisticsGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxLockedData;
+	struct PxLockedDataGeneratedValues
+	{
+		 PX_PHYSX_CORE_API PxLockedDataGeneratedValues( const PxLockedData* inSource );
+	};
+	struct PxLockedDataGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxLockedData"; }
+
+		PX_PHYSX_CORE_API PxLockedDataGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxLockedData*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 0; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return 0 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxLockedData>
+	{ 
+		PxLockedDataGeneratedInfo Info;
+		const PxLockedDataGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxParticleReadData;
+	struct PxParticleReadDataGeneratedValues
+		: PxLockedDataGeneratedValues	{
+		PxU32 NbValidParticles;
+		PxU32 ValidParticleRange;
+		const PxU32 * ValidParticleBitmap;
+		PxStrideIterator<const PxVec3> PositionBuffer;
+		PxStrideIterator<const PxVec3> VelocityBuffer;
+		PxStrideIterator<const PxF32> RestOffsetBuffer;
+		PxStrideIterator<const PxParticleFlags> FlagsBuffer;
+		PxStrideIterator<const PxVec3> CollisionNormalBuffer;
+		PxStrideIterator<const PxVec3> CollisionVelocityBuffer;
+		 PX_PHYSX_CORE_API PxParticleReadDataGeneratedValues( const PxParticleReadData* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleReadData, NbValidParticles, PxParticleReadDataGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleReadData, ValidParticleRange, PxParticleReadDataGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleReadData, ValidParticleBitmap, PxParticleReadDataGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleReadData, PositionBuffer, PxParticleReadDataGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleReadData, VelocityBuffer, PxParticleReadDataGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleReadData, RestOffsetBuffer, PxParticleReadDataGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleReadData, FlagsBuffer, PxParticleReadDataGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleReadData, CollisionNormalBuffer, PxParticleReadDataGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxParticleReadData, CollisionVelocityBuffer, PxParticleReadDataGeneratedValues)
+	struct PxParticleReadDataGeneratedInfo
+		: PxLockedDataGeneratedInfo
+	{
+		static const char* getClassName() { return "PxParticleReadData"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleReadData_NbValidParticles, PxParticleReadData, PxU32, PxU32 > NbValidParticles;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleReadData_ValidParticleRange, PxParticleReadData, PxU32, PxU32 > ValidParticleRange;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleReadData_ValidParticleBitmap, PxParticleReadData, const PxU32 *, const PxU32 * > ValidParticleBitmap;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleReadData_PositionBuffer, PxParticleReadData, PxStrideIterator<const PxVec3>, PxStrideIterator<const PxVec3> > PositionBuffer;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleReadData_VelocityBuffer, PxParticleReadData, PxStrideIterator<const PxVec3>, PxStrideIterator<const PxVec3> > VelocityBuffer;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleReadData_RestOffsetBuffer, PxParticleReadData, PxStrideIterator<const PxF32>, PxStrideIterator<const PxF32> > RestOffsetBuffer;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleReadData_FlagsBuffer, PxParticleReadData, PxStrideIterator<const PxParticleFlags>, PxStrideIterator<const PxParticleFlags> > FlagsBuffer;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleReadData_CollisionNormalBuffer, PxParticleReadData, PxStrideIterator<const PxVec3>, PxStrideIterator<const PxVec3> > CollisionNormalBuffer;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxParticleReadData_CollisionVelocityBuffer, PxParticleReadData, PxStrideIterator<const PxVec3>, PxStrideIterator<const PxVec3> > CollisionVelocityBuffer;
+
+		PX_PHYSX_CORE_API PxParticleReadDataGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxParticleReadData*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxLockedDataGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxLockedDataGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxLockedDataGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 9; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxLockedDataGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( NbValidParticles, inStartIndex + 0 );; 
+			inOperator( ValidParticleRange, inStartIndex + 1 );; 
+			inOperator( ValidParticleBitmap, inStartIndex + 2 );; 
+			inOperator( PositionBuffer, inStartIndex + 3 );; 
+			inOperator( VelocityBuffer, inStartIndex + 4 );; 
+			inOperator( RestOffsetBuffer, inStartIndex + 5 );; 
+			inOperator( FlagsBuffer, inStartIndex + 6 );; 
+			inOperator( CollisionNormalBuffer, inStartIndex + 7 );; 
+			inOperator( CollisionVelocityBuffer, inStartIndex + 8 );; 
+			return 9 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxParticleReadData>
+	{ 
+		PxParticleReadDataGeneratedInfo Info;
+		const PxParticleReadDataGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	struct PxClothStretchConfig;
+	struct PxClothStretchConfigGeneratedValues
+	{
+		PxReal Stiffness;
+		PxReal StiffnessMultiplier;
+		PxReal CompressionLimit;
+		PxReal StretchLimit;
+		 PX_PHYSX_CORE_API PxClothStretchConfigGeneratedValues( const PxClothStretchConfig* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothStretchConfig, Stiffness, PxClothStretchConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothStretchConfig, StiffnessMultiplier, PxClothStretchConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothStretchConfig, CompressionLimit, PxClothStretchConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothStretchConfig, StretchLimit, PxClothStretchConfigGeneratedValues)
+	struct PxClothStretchConfigGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxClothStretchConfig"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothStretchConfig_Stiffness, PxClothStretchConfig, PxReal, PxReal > Stiffness;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothStretchConfig_StiffnessMultiplier, PxClothStretchConfig, PxReal, PxReal > StiffnessMultiplier;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothStretchConfig_CompressionLimit, PxClothStretchConfig, PxReal, PxReal > CompressionLimit;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothStretchConfig_StretchLimit, PxClothStretchConfig, PxReal, PxReal > StretchLimit;
+
+		PX_PHYSX_CORE_API PxClothStretchConfigGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxClothStretchConfig*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 4; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Stiffness, inStartIndex + 0 );; 
+			inOperator( StiffnessMultiplier, inStartIndex + 1 );; 
+			inOperator( CompressionLimit, inStartIndex + 2 );; 
+			inOperator( StretchLimit, inStartIndex + 3 );; 
+			return 4 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxClothStretchConfig>
+	{ 
+		PxClothStretchConfigGeneratedInfo Info;
+		const PxClothStretchConfigGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	struct PxClothTetherConfig;
+	struct PxClothTetherConfigGeneratedValues
+	{
+		PxReal Stiffness;
+		PxReal StretchLimit;
+		 PX_PHYSX_CORE_API PxClothTetherConfigGeneratedValues( const PxClothTetherConfig* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothTetherConfig, Stiffness, PxClothTetherConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothTetherConfig, StretchLimit, PxClothTetherConfigGeneratedValues)
+	struct PxClothTetherConfigGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxClothTetherConfig"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothTetherConfig_Stiffness, PxClothTetherConfig, PxReal, PxReal > Stiffness;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothTetherConfig_StretchLimit, PxClothTetherConfig, PxReal, PxReal > StretchLimit;
+
+		PX_PHYSX_CORE_API PxClothTetherConfigGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxClothTetherConfig*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Stiffness, inStartIndex + 0 );; 
+			inOperator( StretchLimit, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxClothTetherConfig>
+	{ 
+		PxClothTetherConfigGeneratedInfo Info;
+		const PxClothTetherConfigGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	struct PxClothMotionConstraintConfig;
+	struct PxClothMotionConstraintConfigGeneratedValues
+	{
+		PxReal Scale;
+		PxReal Bias;
+		PxReal Stiffness;
+		 PX_PHYSX_CORE_API PxClothMotionConstraintConfigGeneratedValues( const PxClothMotionConstraintConfig* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothMotionConstraintConfig, Scale, PxClothMotionConstraintConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothMotionConstraintConfig, Bias, PxClothMotionConstraintConfigGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothMotionConstraintConfig, Stiffness, PxClothMotionConstraintConfigGeneratedValues)
+	struct PxClothMotionConstraintConfigGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxClothMotionConstraintConfig"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothMotionConstraintConfig_Scale, PxClothMotionConstraintConfig, PxReal, PxReal > Scale;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothMotionConstraintConfig_Bias, PxClothMotionConstraintConfig, PxReal, PxReal > Bias;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothMotionConstraintConfig_Stiffness, PxClothMotionConstraintConfig, PxReal, PxReal > Stiffness;
+
+		PX_PHYSX_CORE_API PxClothMotionConstraintConfigGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxClothMotionConstraintConfig*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 3; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Scale, inStartIndex + 0 );; 
+			inOperator( Bias, inStartIndex + 1 );; 
+			inOperator( Stiffness, inStartIndex + 2 );; 
+			return 3 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxClothMotionConstraintConfig>
+	{ 
+		PxClothMotionConstraintConfigGeneratedInfo Info;
+		const PxClothMotionConstraintConfigGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxClothParticleData;
+	struct PxClothParticleDataGeneratedValues
+		: PxLockedDataGeneratedValues	{
+		PxClothParticle * Particles;
+		PxClothParticle * PreviousParticles;
+		 PX_PHYSX_CORE_API PxClothParticleDataGeneratedValues( const PxClothParticleData* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothParticleData, Particles, PxClothParticleDataGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxClothParticleData, PreviousParticles, PxClothParticleDataGeneratedValues)
+	struct PxClothParticleDataGeneratedInfo
+		: PxLockedDataGeneratedInfo
+	{
+		static const char* getClassName() { return "PxClothParticleData"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothParticleData_Particles, PxClothParticleData, PxClothParticle *, PxClothParticle * > Particles;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxClothParticleData_PreviousParticles, PxClothParticleData, PxClothParticle *, PxClothParticle * > PreviousParticles;
+
+		PX_PHYSX_CORE_API PxClothParticleDataGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxClothParticleData*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxLockedDataGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxLockedDataGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxLockedDataGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxLockedDataGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Particles, inStartIndex + 0 );; 
+			inOperator( PreviousParticles, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxClothParticleData>
+	{ 
+		PxClothParticleDataGeneratedInfo Info;
+		const PxClothParticleDataGeneratedInfo* getInfo() { return &Info; }
+	};
+
+
+
+#undef THERE_IS_NO_INCLUDE_GUARD_HERE_FOR_A_REASON
+#undef PX_PROPERTY_INFO_NAME
diff --git a/PhysX_3.4/Source/PhysXMetaData/core/include/PxMetaDataCompare.h b/PhysX_3.4/Source/PhysXMetaData/core/include/PxMetaDataCompare.h
new file mode 100644
index 00000000..8ada141b
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/core/include/PxMetaDataCompare.h
@@ -0,0 +1,387 @@
+// 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_METADATACOMPARE_H
+#define PX_METADATACOMPARE_H
+#include "PxMetaDataObjects.h"
+#include "PsInlineArray.h"
+
+//Implement a basic equality comparison system based on the meta data system.
+//if you implement a particular areequal specialized to exactly your type
+//before including this file it will be called in preference to the completely 
+//generic one shown here.
+
+
+//If you don't care about the failure prop name you are welcome to pass in 'null',
+template<typename TBaseObjType>
+bool areEqual( const TBaseObjType& lhs, const TBaseObjType& rhs, const char** outFailurePropName );
+//We don't have the ability right now to handle these types.
+inline bool areEqual( const PxParticleSystem&, const PxParticleSystem& ) { return true; }
+inline bool areEqual( const PxParticleFluid&, const PxParticleFluid& ) { return true; }
+inline bool areEqual( const PxAggregate&, const PxAggregate& ) { return true; }
+inline bool areEqual( const PxSimulationFilterShader&, const PxSimulationFilterShader&  ) { return true; }
+inline bool areEqual( const PxSimulationFilterCallback&, const PxSimulationFilterCallback& ) { return true; }
+inline bool areEqual( const PxConvexMesh&, const PxConvexMesh& ) { return true; }
+inline bool areEqual( const PxTriangleMesh&, const PxTriangleMesh& ) { return true; }
+inline bool areEqual( const PxBVH33TriangleMesh&, const PxBVH33TriangleMesh& ) { return true; }
+inline bool areEqual( const PxBVH34TriangleMesh&, const PxBVH34TriangleMesh& ) { return true; }
+inline bool areEqual( const PxHeightField&, const PxHeightField& ) { return true; }
+inline bool areEqual( const void* inLhs, const void* inRhs ) { return inLhs == inRhs; }
+inline bool areEqual( void* inLhs, void* inRhs ) { return inLhs == inRhs; }
+
+//Operators are copied, so this object needs to point
+//to the important data rather than reference or own it.
+template<typename TBaseObjType>
+struct EqualityOp
+{
+	bool* mVal;
+	const TBaseObjType* mLhs;
+	const TBaseObjType* mRhs;
+	const char** mFailurePropName;
+
+	EqualityOp( bool& inVal, const TBaseObjType& inLhs, const TBaseObjType& inRhs, const char*& inFailurePropName ) 
+		: mVal( &inVal ) 
+		, mLhs( &inLhs ) 
+		, mRhs( &inRhs )
+		, mFailurePropName( &inFailurePropName )
+	{
+	}
+
+	bool hasFailed() { return *mVal == false; }
+	//Ensure failure propagates the result a ways.
+	void update( bool inResult, const char* inName ) 
+	{ 
+		*mVal = *mVal && inResult; 
+		if ( hasFailed() )
+			*mFailurePropName = inName;
+	}
+	
+	//ignore any properties pointering back to the scene.
+	template<PxU32 TKey, typename TObjType>
+	void operator()( const PxReadOnlyPropertyInfo<TKey, TObjType, PxScene*> & inProp, PxU32 ) {}
+
+	template<PxU32 TKey, typename TObjType>
+	void operator()( const PxReadOnlyPropertyInfo<TKey, TObjType, const PxScene*> & inProp, PxU32 ) {}
+
+	//ignore all of these properties because they just point back to the 'this' object and cause
+	//a stack overflow.
+
+	//Children is unnecessary and articulation points back to the source.
+	void operator()( const PxReadOnlyCollectionPropertyInfo<PxPropertyInfoName::PxArticulationLink_Children, PxArticulationLink, PxArticulationLink* >& inProp, PxU32 ) {}
+	void operator()( const PxReadOnlyCollectionPropertyInfo<PxPropertyInfoName::PxRigidActor_Constraints, PxRigidActor, PxConstraint* >& inProp, PxU32 ){}
+	void operator()( const PxReadOnlyCollectionPropertyInfo<PxPropertyInfoName::PxAggregate_Actors, PxAggregate, PxActor* >& inProp, PxU32 ) {}
+    void operator()( const PxWriteOnlyPropertyInfo<PxPropertyInfoName::PxRigidDynamic_KinematicTarget, PxRigidDynamic, const PxTransform &  >& inProp, PxU32 ) {}
+    void operator()( const PxWriteOnlyPropertyInfo<PxPropertyInfoName::PxCloth_TargetPose, PxCloth, const PxTransform &  >& inProp, PxU32 ) {}
+	void operator()( const PxWriteOnlyPropertyInfo<PxPropertyInfoName::PxCloth_InertiaScale, PxCloth, PxReal >& inProp, PxU32 ) {}
+	void operator()( const PxWriteOnlyPropertyInfo<PxPropertyInfoName::PxCloth_DragCoefficient, PxCloth, PxReal >& inProp, PxU32 ) {}
+		
+    template<PxU32 TKey, typename TObjType, typename TGetPropType>
+	void operator()( const PxBufferCollectionPropertyInfo<TKey, TObjType, TGetPropType> & inProp, PxU32 )
+	{
+		
+	}
+	
+
+    template<PxU32 TKey, typename TObjType, typename TGetPropType>
+	void operator()( const PxReadOnlyPropertyInfo<TKey, TObjType, TGetPropType> & inProp, PxU32 )
+	{
+		if ( hasFailed() ) return;
+		TGetPropType lhs( inProp.get( mLhs ) );
+		TGetPropType rhs( inProp.get( mRhs ) );
+		update( areEqual( lhs, rhs, NULL ), inProp.mName );
+	}
+	
+	template<PxU32 TKey, typename TObjType, typename TPropType>
+	void operator()( const PxRangePropertyInfo<TKey, TObjType, TPropType> & inProp, PxU32 )
+	{
+		if ( hasFailed() ) return;
+		TPropType lhsl, lhsr, rhsl, rhsr;
+		inProp.get( mLhs, lhsl, lhsr );
+		inProp.get( mRhs, rhsl, rhsr );
+		update( areEqual( lhsl, rhsl, NULL ), inProp.mName );
+		update( areEqual( lhsr, rhsr, NULL ), inProp.mName );
+	}
+
+	//Indexed properties where we don't know the range of index types are ignored
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropType>
+	void compareIndex( const PxIndexedPropertyInfo<TKey, TObjType, TIndexType, TPropType> &, bool ) {}
+	
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropType>
+	void compareIndex( const PxIndexedPropertyInfo<TKey, TObjType, TIndexType, TPropType> &inProp, const PxU32ToName* inNames ) 
+	{
+		for ( const PxU32ToName* theName = inNames;
+			theName->mName != NULL && !hasFailed();
+			++theName )
+		{
+			TIndexType theIndex( static_cast<TIndexType>( theName->mValue ) );
+			update( areEqual( inProp.get( mLhs, theIndex ), inProp.get( mRhs, theIndex ), NULL ), inProp.mName );
+		}
+	}
+	
+	template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropType>
+	void operator()( const PxIndexedPropertyInfo<TKey, TObjType, TIndexType, TPropType> & inProp, PxU32 )
+	{
+		if ( hasFailed() ) return;
+		compareIndex( inProp, PxEnumTraits<TIndexType>().NameConversion );
+	}
+	
+	template<PxU32 TKey, typename TObjType, typename TCollectionType>
+	void operator()( const PxReadOnlyCollectionPropertyInfo<TKey, TObjType, TCollectionType> & inProp, PxU32 )
+	{
+		if ( hasFailed() ) return;
+		physx::shdfnd::InlineArray<TCollectionType, 20> lhsArray;
+		physx::shdfnd::InlineArray<TCollectionType, 20> rhsArray;
+		PxU32 size = inProp.size( mLhs );
+		if ( size != inProp.size( mRhs ) )
+			update( false, inProp.mName );
+		else
+		{
+			lhsArray.resize( size );
+			rhsArray.resize( size );
+			inProp.get( mLhs, lhsArray.begin(), size );
+			inProp.get( mRhs, rhsArray.begin(), size );
+			for ( PxU32 idx =0; idx < size && !hasFailed(); ++idx )
+				update( areEqual( lhsArray[idx], rhsArray[idx], NULL ), inProp.mName );
+		}
+	}
+
+	//Filtered collections where we can't know the range of filter values are ignored.
+	template<PxU32 TKey, typename TObjType, typename TFilterType, typename TCollectionType>
+	void compare( const PxReadOnlyFilteredCollectionPropertyInfo< TKey, TObjType, TFilterType, TCollectionType >&, bool ) {}
+
+	template<PxU32 TKey, typename TObjType, typename TFilterType, typename TCollectionType>
+	void compare( const PxReadOnlyFilteredCollectionPropertyInfo< TKey, TObjType, TFilterType, TCollectionType >& inProp, const PxU32ToName* inNames )
+	{
+		//Exaustively compare all items.
+		physx::shdfnd::InlineArray<TCollectionType*, 20> lhsArray;
+		physx::shdfnd::InlineArray<TCollectionType*, 20> rhsArray;
+		for ( const PxU32ToName* theName = inNames;
+			theName->mName != NULL && !hasFailed();
+			++theName )
+		{
+			TFilterType theFilter( static_cast<TFilterType>( theName->mValue ) );
+			PxU32 size = inProp.size( mLhs, theFilter );
+			if ( size != inProp.size( mRhs, theFilter ) )
+				update( false, inProp.mName );
+			else
+			{
+				lhsArray.resize( size );
+				rhsArray.resize( size );
+				inProp.get( mLhs, theFilter, lhsArray.begin(), size );
+				inProp.get( mRhs, theFilter, rhsArray.begin(), size );
+				for ( PxU32 idx =0; idx < size && !hasFailed(); ++idx )
+					update( areEqual( lhsArray[idx], rhsArray[idx], NULL ), inProp.mName );
+			}
+		}
+	}
+
+	template<PxU32 TKey, typename TObjType, typename TFilterType, typename TCollectionType>
+	void operator()( const PxReadOnlyFilteredCollectionPropertyInfo< TKey, TObjType, TFilterType, TCollectionType >& inProp, PxU32 )
+	{
+		if ( hasFailed() ) return;
+		compare( inProp, PxEnumTraits<TFilterType>().NameConversion );
+	}
+
+	template<typename TGeometryType, typename TPropertyType>
+	void compareGeometry( const TPropertyType& inProp )
+	{
+		TGeometryType lhs;
+		TGeometryType rhs;
+		bool lsuc = inProp.getGeometry( mLhs, lhs );
+		bool rsuc = inProp.getGeometry( mRhs, rhs );
+		if ( !( lsuc && rsuc ) )
+			update( false, inProp.mName );
+		else
+			update( areEqual( lhs, rhs, NULL ), inProp.mName );
+	}
+
+	void operator()( const PxShapeGeometryProperty& inProp, PxU32 )
+	{
+		if ( hasFailed() ) return;
+		PxGeometryType::Enum lhsType( inProp.getGeometryType( mLhs ) );
+		PxGeometryType::Enum rhsType( inProp.getGeometryType( mRhs ) );
+		if ( lhsType != rhsType )
+			update( false, inProp.mName );
+		else
+		{
+			switch( lhsType )
+			{
+			case PxGeometryType::eSPHERE: compareGeometry<PxSphereGeometry>(inProp); break;
+			case PxGeometryType::ePLANE: compareGeometry<PxPlaneGeometry>(inProp); break;
+			case PxGeometryType::eCAPSULE: compareGeometry<PxCapsuleGeometry>(inProp); break;
+			case PxGeometryType::eBOX: compareGeometry<PxBoxGeometry>(inProp); break;
+			case PxGeometryType::eCONVEXMESH: compareGeometry<PxConvexMeshGeometry>(inProp); break;
+			case PxGeometryType::eTRIANGLEMESH: compareGeometry<PxTriangleMeshGeometry>(inProp); break;
+			case PxGeometryType::eHEIGHTFIELD: compareGeometry<PxHeightFieldGeometry>(inProp); break;
+			default: PX_ASSERT( false ); break;
+			}
+		}
+	}
+};
+
+inline bool areEqual( const char* lhs, const char* rhs, const char**, const PxUnknownClassInfo& )
+{
+	if ( lhs && rhs ) return strcmp( lhs, rhs ) == 0;
+	if ( lhs || rhs ) return false;
+	return true;
+}
+
+inline bool areEqual( PxReal inLhs, PxReal inRhs )
+{
+	return PxAbs( inLhs - inRhs ) < 1e-5f;
+}
+
+inline bool areEqual( PxVec3& lhs, PxVec3& rhs ) 
+{ 
+	return areEqual( lhs.x, rhs.x )
+		&& areEqual( lhs.y, rhs.y )
+		&& areEqual( lhs.z, rhs.z );
+}
+
+inline bool areEqual( const PxVec3& lhs, const PxVec3& rhs ) 
+{ 
+	return areEqual( lhs.x, rhs.x )
+		&& areEqual( lhs.y, rhs.y )
+		&& areEqual( lhs.z, rhs.z );
+}
+
+inline bool areEqual( const PxVec4& lhs, const PxVec4& rhs ) 
+{ 
+	return areEqual( lhs.x, rhs.x )
+		&& areEqual( lhs.y, rhs.y )
+		&& areEqual( lhs.z, rhs.z )
+		&& areEqual( lhs.w, rhs.w );
+}
+
+inline bool areEqual( const PxQuat& lhs, const PxQuat& rhs )
+{
+	return areEqual( lhs.x, rhs.x )
+		&& areEqual( lhs.y, rhs.y )
+		&& areEqual( lhs.z, rhs.z )
+		&& areEqual( lhs.w, rhs.w );
+}
+
+
+inline bool areEqual( const PxTransform& lhs, const PxTransform& rhs )
+{
+	return areEqual(lhs.p, rhs.p) && areEqual(lhs.q, rhs.q);
+}
+
+
+inline bool areEqual( const PxBounds3& inLhs, const PxBounds3& inRhs )
+{
+	return areEqual(inLhs.minimum,inRhs.minimum)
+		&& areEqual(inLhs.maximum,inRhs.maximum);
+}
+
+inline bool areEqual( const PxMetaDataPlane& lhs, const PxMetaDataPlane& rhs ) 
+{ 
+	return areEqual( lhs.normal.x, rhs.normal.x )
+		&& areEqual( lhs.normal.y, rhs.normal.y )
+		&& areEqual( lhs.normal.z, rhs.normal.z )
+		&& areEqual( lhs.distance, rhs.distance );
+}
+
+template<typename TBaseObjType>
+inline bool areEqual( const TBaseObjType& lhs, const TBaseObjType& rhs ) 
+{ 
+	return lhs == rhs; 
+}
+
+//If we don't know the class type, we must result in == operator
+template<typename TBaseObjType>
+inline bool areEqual( const TBaseObjType& lhs, const TBaseObjType& rhs, const char**, const PxUnknownClassInfo& )
+{
+	return areEqual( lhs, rhs );
+}
+
+//If we don't know the class type, we must result in == operator
+template<typename TBaseObjType, typename TTraitsType>
+inline bool areEqual( const TBaseObjType& lhs, const TBaseObjType& rhs, const char** outFailurePropName, const TTraitsType& )
+{
+	const char* theFailureName = NULL;
+	bool result = true;
+	static int i = 0;
+	++i;
+	visitAllProperties<TBaseObjType>( EqualityOp<TBaseObjType>( result, lhs, rhs, theFailureName ) );
+	if ( outFailurePropName != NULL && theFailureName )
+		*outFailurePropName = theFailureName;
+	return result;
+}
+
+
+template<typename TBaseObjType>
+inline bool areEqualPointerCheck( const TBaseObjType& lhs, const TBaseObjType& rhs, const char** outFailurePropName, int ) 
+{
+	return areEqual( lhs, rhs, outFailurePropName, PxClassInfoTraits<TBaseObjType>().Info );
+}
+
+inline bool areEqualPointerCheck( const void* lhs, const void* rhs, const char**, bool )
+{
+	return lhs == rhs;
+}
+
+inline bool areEqualPointerCheck( const char* lhs, const char* rhs, const char** outFailurePropName, bool )
+{
+	bool bRet = true;
+	if ( lhs && rhs ) bRet = strcmp( lhs, rhs ) == 0;
+	else if ( lhs || rhs ) bRet = false;
+	
+	return bRet;
+}
+
+inline bool areEqualPointerCheck( void* lhs, void* rhs, const char**, bool )
+{
+	return lhs == rhs;
+}
+
+template<typename TBaseObjType>
+inline bool areEqualPointerCheck( const TBaseObjType& lhs, const TBaseObjType& rhs, const char** outFailurePropName, bool ) 
+{
+	if ( lhs && rhs )
+		return areEqual( *lhs, *rhs, outFailurePropName );
+	if ( lhs || rhs )
+		return false;
+	return true;
+}
+
+template < typename Tp >
+struct is_pointer { static const int val = 0; };
+
+template < typename Tp >
+struct is_pointer<Tp*> { static const bool val = true; };
+
+
+template<typename TBaseObjType>
+inline bool areEqual( const TBaseObjType& lhs, const TBaseObjType& rhs, const char** outFailurePropName )
+{
+	return areEqualPointerCheck( lhs, rhs, outFailurePropName, is_pointer<TBaseObjType>::val );
+}
+
+#endif
\ No newline at end of file
diff --git a/PhysX_3.4/Source/PhysXMetaData/core/include/PxMetaDataCppPrefix.h b/PhysX_3.4/Source/PhysXMetaData/core/include/PxMetaDataCppPrefix.h
new file mode 100644
index 00000000..8fd5acc0
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/core/include/PxMetaDataCppPrefix.h
@@ -0,0 +1,37 @@
+// 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_META_DATA_CPP_PREFIX_H
+#define PX_META_DATA_CPP_PREFIX_H
+
+//Header that is only included by the clang-generated cpp files.
+//Used to change compilation settings where necessary for only those files.
+
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXMetaData/core/include/PxMetaDataObjects.h b/PhysX_3.4/Source/PhysXMetaData/core/include/PxMetaDataObjects.h
new file mode 100644
index 00000000..54ae05e5
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/core/include/PxMetaDataObjects.h
@@ -0,0 +1,641 @@
+// 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_METADATAOBJECTS_H
+#define PX_METADATAOBJECTS_H
+#include "foundation/PxMemory.h"
+#include "PxPhysicsAPI.h"
+#include "PxClothTypes.h"
+#include "PxClothFabric.h"
+#include "PxCloth.h"
+#include "PxClothCollisionData.h"
+#include "PxClothParticleData.h"
+
+/** \addtogroup physics
+@{
+*/
+
+namespace physx
+{
+
+class PxArticulationLink;
+class PxArticulationJoint;
+
+struct PxPropertyInfoName
+{
+	enum Enum
+	{
+		Unnamed = 0,
+#include "PxAutoGeneratedMetaDataObjectNames.h"
+		LastPxPropertyInfoName
+	};
+};
+
+struct PxU32ToName
+{
+	const char* mName;
+	PxU32		mValue;
+};
+
+struct PxPropertyInfoBase
+{
+	const char* mName;
+	PxU32 mKey; 
+	PxPropertyInfoBase( const char* n, PxU32 inKey )
+		: mName( n )
+		, mKey( inKey )
+	{
+	}
+};
+
+template<PxU32 TKey>
+struct PxPropertyInfoParameterizedBase : public PxPropertyInfoBase
+{
+	PxPropertyInfoParameterizedBase( const char* inName )
+		: PxPropertyInfoBase( inName, TKey ) {}
+};
+
+template<PxU32 TKey, typename TObjType, typename TPropertyType>
+struct PxReadOnlyPropertyInfo : public PxPropertyInfoParameterizedBase<TKey>
+{
+	typedef TPropertyType (*TGetterType)( const TObjType* );
+	TGetterType mGetter;
+	PxReadOnlyPropertyInfo( const char* inName, TGetterType inGetter )
+		: PxPropertyInfoParameterizedBase<TKey>( inName )
+		, mGetter( inGetter ) {}
+	TPropertyType get( const TObjType* inObj ) const { return mGetter( inObj ); }
+};
+
+template<PxU32 TKey, typename TObjType, typename TPropertyType>
+struct PxWriteOnlyPropertyInfo : public PxPropertyInfoParameterizedBase<TKey>
+{
+	typedef void(*TSetterType)( TObjType*, TPropertyType inArg );
+	TSetterType mSetter;
+	PxWriteOnlyPropertyInfo( const char* inName, TSetterType inSetter )
+		: PxPropertyInfoParameterizedBase<TKey>( inName )
+		, mSetter( inSetter ) {}
+	void set( TObjType* inObj, TPropertyType inArg ) const { mSetter( inObj, inArg ); }
+};
+
+
+//Define the property types on the auto-generated objects.
+template<PxU32 TKey, typename TObjType, typename TSetPropType, typename TGetPropType>
+struct PxPropertyInfo : public PxReadOnlyPropertyInfo<TKey, TObjType, TGetPropType>
+{
+	typedef typename PxReadOnlyPropertyInfo<TKey, TObjType, TGetPropType>::TGetterType TGetterType;
+	typedef void(*TSetterType)( TObjType*, TSetPropType inArg );
+	TSetterType mSetter;
+
+	PxPropertyInfo( const char* inName, TSetterType inSetter, TGetterType inGetter )
+		: PxReadOnlyPropertyInfo<TKey, TObjType, TGetPropType>( inName, inGetter )
+		, mSetter( inSetter ) {}
+	void set( TObjType* inObj, TSetPropType inArg ) const { mSetter( inObj, inArg ); }
+};
+
+template<PxU32 TKey, typename TObjType, typename TPropertyType>
+struct PxRangePropertyInfo : public PxPropertyInfoParameterizedBase<TKey>
+{
+	typedef void (*TSetterType)( TObjType*,TPropertyType,TPropertyType);
+	typedef void (*TGetterType)( const TObjType*,TPropertyType&,TPropertyType&);
+
+	const char* mArg0Name;
+	const char* mArg1Name;
+
+	TSetterType mSetter;
+	TGetterType mGetter;
+
+	PxRangePropertyInfo( const char* name, const char* arg0Name, const char* arg1Name
+							, TSetterType setter, TGetterType getter )
+		: PxPropertyInfoParameterizedBase<TKey>( name )
+		, mArg0Name( arg0Name )
+		, mArg1Name( arg1Name )
+		, mSetter( setter )
+		, mGetter( getter )
+	{
+	}
+	void set( TObjType* inObj, TPropertyType arg0, TPropertyType arg1 ) const { mSetter( inObj, arg0, arg1 ); }
+	void get( const TObjType* inObj, TPropertyType& arg0, TPropertyType& arg1 ) const { mGetter( inObj, arg0, arg1 ); }
+};
+
+template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType>
+struct PxIndexedPropertyInfo : public PxPropertyInfoParameterizedBase<TKey>
+{
+	typedef void (*TSetterType)( TObjType*, TIndexType, TPropertyType );
+	typedef TPropertyType (*TGetterType)( const TObjType* inObj, TIndexType );
+
+	TSetterType mSetter;
+	TGetterType mGetter;
+
+	PxIndexedPropertyInfo( const char* name, TSetterType setter, TGetterType getter )
+		: PxPropertyInfoParameterizedBase<TKey>( name )
+		, mSetter( setter )
+		, mGetter( getter )
+	{
+	}
+	void set( TObjType* inObj, TIndexType inIndex, TPropertyType arg ) const { mSetter( inObj, inIndex, arg ); }
+	TPropertyType get( const TObjType* inObj, TIndexType inIndex ) const { return mGetter( inObj, inIndex ); }
+};
+
+template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType>
+struct PxExtendedIndexedPropertyInfo : public PxPropertyInfoParameterizedBase<TKey>
+{
+	typedef PxU32 (*TNbObjectsMember)( const TObjType* );
+	typedef void (*TSetterType)( TObjType*, TIndexType, TPropertyType );
+	typedef TPropertyType (*TGetterType)( const TObjType* inObj, TIndexType );
+
+	TSetterType mSetter;
+	TGetterType mGetter;
+    PxU32       mCount;
+	TNbObjectsMember	mNbObjectsMember;
+
+	PxExtendedIndexedPropertyInfo( const char* name, TGetterType getter, TNbObjectsMember inNb, TSetterType setter)
+		: PxPropertyInfoParameterizedBase<TKey>( name )
+		, mSetter( setter )
+		, mGetter( getter )
+        , mNbObjectsMember( inNb )
+	{
+	}
+
+	PxU32 size( const TObjType* inObj ) const { return mNbObjectsMember( inObj ); }
+	void set( TObjType* inObj, TIndexType inIndex, TPropertyType arg ) const { mSetter( inObj, inIndex, arg ); }
+	TPropertyType get( const TObjType* inObj, TIndexType inIndex ) const { return mGetter( inObj, inIndex ); }
+};
+
+template<PxU32 TKey, typename TObjType, typename TIndex1Type, typename TIndex2Type, typename TPropertyType>
+struct PxDualIndexedPropertyInfo : public PxPropertyInfoParameterizedBase<TKey>
+{
+	typedef void (*TSetterType)( TObjType*, TIndex1Type, TIndex2Type, TPropertyType );
+	typedef TPropertyType (*TGetterType)( const TObjType* inObj, TIndex1Type, TIndex2Type );
+
+	TSetterType mSetter;
+	TGetterType mGetter;
+
+	PxDualIndexedPropertyInfo( const char* name, TSetterType setter, TGetterType getter )
+		: PxPropertyInfoParameterizedBase<TKey>( name )
+		, mSetter( setter )
+		, mGetter( getter )
+	{
+	}
+	void set( TObjType* inObj, TIndex1Type inIdx1, TIndex2Type inIdx2, TPropertyType arg ) const { mSetter( inObj, inIdx1, inIdx2, arg ); }
+	TPropertyType get( const TObjType* inObj, TIndex1Type inIdx1, TIndex2Type inIdx2 ) const { return mGetter( inObj, inIdx1, inIdx2 ); }
+};
+
+template<PxU32 TKey, typename TObjType, typename TIndex1Type, typename TIndex2Type, typename TPropertyType>
+struct PxExtendedDualIndexedPropertyInfo : public PxPropertyInfoParameterizedBase<TKey>
+{
+	typedef void (*TSetterType)( TObjType*, TIndex1Type, TIndex2Type, TPropertyType );
+	typedef TPropertyType (*TGetterType)( const TObjType* inObj, TIndex1Type, TIndex2Type );
+
+	TSetterType mSetter;
+	TGetterType mGetter;
+	PxU32		mId0Count;
+	PxU32		mId1Count;
+
+	PxExtendedDualIndexedPropertyInfo( const char* name, TSetterType setter, TGetterType getter, PxU32 id0Count, PxU32 id1Count )
+		: PxPropertyInfoParameterizedBase<TKey>( name )
+		, mSetter( setter )
+		, mGetter( getter )
+		, mId0Count( id0Count )
+		, mId1Count( id1Count )
+	{
+	}
+
+	void set( TObjType* inObj, TIndex1Type inIdx1, TIndex2Type inIdx2, TPropertyType arg ) const { mSetter( inObj, inIdx1, inIdx2, arg ); }
+	TPropertyType get( const TObjType* inObj, TIndex1Type inIdx1, TIndex2Type inIdx2 ) const { return mGetter( inObj, inIdx1, inIdx2 ); }
+};
+
+template<PxU32 TKey, typename TObjType, typename TCollectionType>
+struct PxBufferCollectionPropertyInfo : public PxPropertyInfoParameterizedBase<TKey>
+{
+	typedef PxU32 (*TNbObjectsMember)( const TObjType* );
+	typedef PxU32 (*TGetObjectsMember)( const TObjType*, TCollectionType*, PxU32 );
+	typedef void (*TSetObjectsMember)( TObjType*, TCollectionType*, PxU32 );
+	
+	TGetObjectsMember	mGetObjectsMember;
+	TNbObjectsMember	mNbObjectsMember;
+	TSetObjectsMember	mSetObjectsMember;
+	
+	PxBufferCollectionPropertyInfo( const char* inName, TGetObjectsMember inGetter, TNbObjectsMember inNb, TSetObjectsMember inSet )
+		: PxPropertyInfoParameterizedBase<TKey>( inName )
+		, mGetObjectsMember( inGetter )
+		, mNbObjectsMember( inNb )
+		, mSetObjectsMember( inSet )
+	{
+	}
+	PxU32 size( const TObjType* inObj ) const { return mNbObjectsMember( inObj ); }
+	PxU32 get( const TObjType* inObj, TCollectionType* inBuffer, PxU32 inNumItems ) const { return mGetObjectsMember( inObj, inBuffer, inNumItems ); }
+	void set( TObjType* inObj, TCollectionType* inBuffer, PxU32 inNumItems ) const { mSetObjectsMember( inObj, inBuffer, inNumItems); }
+};
+
+template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType>
+struct PxFixedSizeLookupTablePropertyInfo : public PxPropertyInfoParameterizedBase<TKey>
+{
+	typedef PxU32 (*TNbObjectsMember)( const TObjType* );
+	typedef PxReal (*TGetXMember)( const TObjType*, PxU32 );
+	typedef PxReal (*TGetYMember)( const TObjType*, PxU32 );
+	typedef void (*TAddPairMember)( TObjType*, PxReal, PxReal );
+	typedef void (*TClearMember)( TObjType* );
+
+	TGetXMember			mGetXMember;
+	TGetYMember			mGetYMember;
+	TNbObjectsMember	mNbObjectsMember;
+	TAddPairMember		mAddPairMember;
+	TClearMember		mClearMember;
+
+	PxFixedSizeLookupTablePropertyInfo( const char* inName, TGetXMember inGetterX, TGetYMember inGetterY, TNbObjectsMember inNb, TAddPairMember inAddPair, TClearMember inClear )
+		: PxPropertyInfoParameterizedBase<TKey>( inName )
+		, mGetXMember( inGetterX )
+		, mGetYMember( inGetterY )
+		, mNbObjectsMember( inNb )
+		, mAddPairMember( inAddPair )
+		, mClearMember( inClear )
+		
+	{
+	}
+	PxU32 size( const TObjType* inObj ) const { return mNbObjectsMember( inObj ); }
+	PxReal getX( const TObjType* inObj, const PxU32 index )  const { return mGetXMember( inObj, index ); }
+	PxReal getY( const TObjType* inObj, const PxU32 index )  const { return mGetYMember( inObj, index ); }
+	void addPair( TObjType* inObj, const PxReal x, const PxReal y ) { mAddPairMember( inObj, x, y );  }
+	void clear( TObjType* inObj ) { mClearMember( inObj );  }
+};
+
+template<PxU32 TKey, typename TObjType, typename TCollectionType>
+struct PxReadOnlyCollectionPropertyInfo : public PxPropertyInfoParameterizedBase<TKey>
+{
+	typedef PxU32 (*TNbObjectsMember)( const TObjType* );
+	typedef PxU32 (*TGetObjectsMember)( const TObjType*, TCollectionType*, PxU32 );
+
+	TGetObjectsMember	mGetObjectsMember;
+	TNbObjectsMember	mNbObjectsMember;
+
+	PxReadOnlyCollectionPropertyInfo( const char* inName, TGetObjectsMember inGetter, TNbObjectsMember inNb )
+		: PxPropertyInfoParameterizedBase<TKey>( inName )
+		, mGetObjectsMember( inGetter )
+		, mNbObjectsMember( inNb )
+	{
+	}
+	PxU32 size( const TObjType* inObj ) const { return mNbObjectsMember( inObj ); }
+	PxU32 get( const TObjType* inObj, TCollectionType* inBuffer, PxU32 inBufSize ) const { return mGetObjectsMember( inObj, inBuffer, inBufSize); }
+};
+
+
+template<PxU32 TKey, typename TObjType, typename TCollectionType, typename TFilterType>
+struct PxReadOnlyFilteredCollectionPropertyInfo : public PxPropertyInfoParameterizedBase<TKey>
+{
+	typedef PxU32 (*TNbObjectsMember)( const TObjType*, TFilterType );
+	typedef PxU32 (*TGetObjectsMember)( const TObjType*, TFilterType, TCollectionType*, PxU32 );
+
+	TGetObjectsMember	mGetObjectsMember;
+	TNbObjectsMember	mNbObjectsMember;
+
+	PxReadOnlyFilteredCollectionPropertyInfo( const char* inName, TGetObjectsMember inGetter, TNbObjectsMember inNb )
+		: PxPropertyInfoParameterizedBase<TKey>( inName )
+		, mGetObjectsMember( inGetter )
+		, mNbObjectsMember( inNb )
+	{
+	}
+
+	PxU32 size( const TObjType* inObj, TFilterType inFilter ) const { return mNbObjectsMember( inObj, inFilter ); }
+	PxU32 get( const TObjType* inObj, TFilterType inFilter, TCollectionType* inBuffer, PxU32 inBufSize ) const { return mGetObjectsMember( inObj, inFilter, inBuffer, inBufSize); }
+};
+
+template<PxU32 TKey, typename TObjType, typename TCollectionType, typename TCreateArg>
+struct PxFactoryCollectionPropertyInfo : public PxReadOnlyCollectionPropertyInfo< TKey, TObjType, TCollectionType >
+{
+	typedef typename PxReadOnlyCollectionPropertyInfo< TKey, TObjType, TCollectionType >::TGetObjectsMember TGetObjectsMember;
+	typedef typename PxReadOnlyCollectionPropertyInfo< TKey, TObjType, TCollectionType >::TNbObjectsMember TNbObjectsMember;
+	typedef TCollectionType (*TCreateMember)( TObjType*, TCreateArg );
+
+	TCreateMember mCreateMember;
+	PxFactoryCollectionPropertyInfo( const char* inName, TGetObjectsMember inGetter, TNbObjectsMember inNb, TCreateMember inMember )
+		: PxReadOnlyCollectionPropertyInfo< TKey, TObjType, TCollectionType >( inName, inGetter, inNb )
+		, mCreateMember( inMember )
+	{
+	}
+	TCollectionType create( TObjType* inObj, TCreateArg inArg ) const { return mCreateMember( inObj, inArg ); }
+};
+
+
+template<PxU32 TKey, typename TObjType, typename TCollectionType>
+struct PxCollectionPropertyInfo : public PxReadOnlyCollectionPropertyInfo< TKey, TObjType, TCollectionType >
+{
+	typedef typename PxReadOnlyCollectionPropertyInfo< TKey, TObjType, TCollectionType >::TGetObjectsMember TGetObjectsMember;
+	typedef typename PxReadOnlyCollectionPropertyInfo< TKey, TObjType, TCollectionType >::TNbObjectsMember TNbObjectsMember;
+	typedef void (*TAddMember)(TObjType*, TCollectionType&);
+	typedef void (*TRemoveMember)(TObjType*, TCollectionType&);
+
+	TAddMember		mAddMember;
+	TRemoveMember	mRemoveMember;
+
+	PxCollectionPropertyInfo( const char* inName, TGetObjectsMember inGetter, TNbObjectsMember inNb, TAddMember inMember, TRemoveMember inRemoveMember )
+		: PxReadOnlyCollectionPropertyInfo< TKey, TObjType, TCollectionType >( inName, inGetter, inNb )
+		, mAddMember( inMember )
+		, mRemoveMember( inRemoveMember )
+	{
+	}
+	void add( TObjType* inObj, TCollectionType& inArg ) const { mAddMember(inObj, inArg ); }
+	void remove( TObjType* inObj, TCollectionType& inArg ) const { mRemoveMember( inObj, inArg ); }
+};
+
+template<PxU32 TKey, typename TObjType, typename TCollectionType, typename TFilterType>
+struct PxFilteredCollectionPropertyInfo : public PxReadOnlyFilteredCollectionPropertyInfo<TKey, TObjType, TCollectionType, TFilterType>
+{
+	typedef typename PxReadOnlyFilteredCollectionPropertyInfo< TKey, TObjType, TCollectionType, TFilterType >::TGetObjectsMember TGetObjectsMember;
+	typedef typename PxReadOnlyFilteredCollectionPropertyInfo< TKey, TObjType, TCollectionType, TFilterType >::TNbObjectsMember TNbObjectsMember;
+	typedef void (*TAddMember)(TObjType*, TCollectionType&);
+	typedef void (*TRemoveMember)(TObjType*, TCollectionType&);
+
+	TAddMember		mAddMember;
+	TRemoveMember	mRemoveMember;
+
+	PxFilteredCollectionPropertyInfo( const char* inName, TGetObjectsMember inGetter, TNbObjectsMember inNb, TAddMember inMember, TRemoveMember inRemoveMember )
+		: PxReadOnlyFilteredCollectionPropertyInfo<TKey, TObjType, TCollectionType, TFilterType>( inName, inGetter, inNb )
+		, mAddMember( inMember )
+		, mRemoveMember( inRemoveMember )
+	{
+	}
+	void add( TObjType* inObj, TCollectionType& inArg ) const { mAddMember(inObj, inArg ); }
+	void remove( TObjType* inObj, TCollectionType& inArg ) const { mRemoveMember( inObj, inArg ); }
+};
+
+//create a default info class for when we can't match
+//the type correctly.
+struct PxUnknownClassInfo
+{
+	static const char* getClassName() { return "__unknown_class"; }
+	template<typename TReturnType, typename TOperator>
+	TReturnType visitType( TOperator )
+	{
+		return TReturnType();
+	}
+	template<typename TOperator>
+	void visitBases( TOperator )
+	{
+	}
+	template<typename TOperator>
+	PxU32 visitBaseProperties( TOperator, PxU32 inStartIndex = 0 ) const
+	{
+		return inStartIndex;
+	}
+	template<typename TOperator>
+	PxU32 visitInstanceProperties( TOperator, PxU32 inStartIndex = 0 ) const
+	{
+		return inStartIndex;
+	}
+};
+
+template<typename TDataType>
+struct PxClassInfoTraits
+{
+	PxUnknownClassInfo Info;
+	static bool getInfo()  { return false;}	
+};
+
+//move the bool typedef to the global namespace.
+typedef bool _Bool;
+
+
+template<PxU32 TPropertyName>
+struct PxPropertyToValueStructMemberMap
+{
+	bool Offset;
+};
+
+
+#define DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( type, prop, valueStruct )																	\
+	template<> struct PxPropertyToValueStructMemberMap< PxPropertyInfoName::type##_##prop >												\
+	{																																	\
+		PxU32 Offset;																													\
+		PxPropertyToValueStructMemberMap< PxPropertyInfoName::type##_##prop >() : Offset( PX_OFFSET_OF_RT( valueStruct, prop ) ) {}		\
+		template<typename TOperator> void visitProp( TOperator inOperator, valueStruct& inStruct ) { inOperator( inStruct.prop );	}	\
+	};
+	
+
+
+struct PxShapeGeometryPropertyHelper
+{
+	PX_PHYSX_CORE_API PxGeometryType::Enum getGeometryType(const PxShape* inShape) const;
+	PX_PHYSX_CORE_API bool getGeometry(const PxShape* inShape, PxBoxGeometry& geometry) const;
+	PX_PHYSX_CORE_API bool getGeometry(const PxShape* inShape, PxSphereGeometry& geometry) const;
+	PX_PHYSX_CORE_API bool getGeometry(const PxShape* inShape, PxCapsuleGeometry& geometry) const;
+	PX_PHYSX_CORE_API bool getGeometry(const PxShape* inShape, PxPlaneGeometry& geometry) const;
+	PX_PHYSX_CORE_API bool getGeometry(const PxShape* inShape, PxConvexMeshGeometry& geometry) const;
+	PX_PHYSX_CORE_API bool getGeometry(const PxShape* inShape, PxTriangleMeshGeometry& geometry) const;
+	PX_PHYSX_CORE_API bool getGeometry(const PxShape* inShape, PxHeightFieldGeometry& geometry) const;
+};
+
+
+struct PxShapeGeometryProperty : public PxWriteOnlyPropertyInfo< PxPropertyInfoName::PxShape_Geometry, PxShape, const PxGeometry & >
+								, public PxShapeGeometryPropertyHelper
+{
+	typedef PxWriteOnlyPropertyInfo< PxPropertyInfoName::PxShape_Geometry, PxShape, const PxGeometry & >::TSetterType TSetterType;
+	typedef PxGeometryHolder (*TGetterType)( const PxShape* inObj );
+	PxShapeGeometryProperty( const char* inName, TSetterType inSetter, TGetterType )
+		: PxWriteOnlyPropertyInfo< PxPropertyInfoName::PxShape_Geometry, PxShape, const PxGeometry & >( inName, inSetter )
+	{
+	}
+};
+
+struct PxShapeMaterialsPropertyHelper
+{
+	PX_PHYSX_CORE_API void setMaterials(PxShape* inShape, PxMaterial*const* materials, PxU16 materialCount) const;
+};
+
+struct PxShapeMaterialsProperty : public PxReadOnlyCollectionPropertyInfo<PxPropertyInfoName::PxShape_Materials, PxShape, PxMaterial*>
+								, public PxShapeMaterialsPropertyHelper
+{
+	typedef PxReadOnlyCollectionPropertyInfo< PxPropertyInfoName::PxShape_Materials, PxShape, PxMaterial* >::TGetObjectsMember TGetObjectsMember;
+	typedef PxReadOnlyCollectionPropertyInfo< PxPropertyInfoName::PxShape_Materials, PxShape, PxMaterial* >::TNbObjectsMember TNbObjectsMember;
+	PxShapeMaterialsProperty( const char* inName, TGetObjectsMember inGetter, TNbObjectsMember inNb )
+		: PxReadOnlyCollectionPropertyInfo<PxPropertyInfoName::PxShape_Materials, PxShape, PxMaterial*>( inName, inGetter, inNb )
+	{
+	}
+};
+
+struct PxRigidActorShapeCollectionHelper
+{
+	PX_PHYSX_CORE_API PxShape* createShape(PxRigidActor* inActor, const PxGeometry& geometry, PxMaterial& material, PxShapeFlags shapeFlags = PxShapeFlag::eVISUALIZATION | PxShapeFlag::eSCENE_QUERY_SHAPE | PxShapeFlag::eSIMULATION_SHAPE) const;
+	PX_PHYSX_CORE_API PxShape* createShape(PxRigidActor* inActor, const PxGeometry& geometry, PxMaterial *const* materials, PxU16 materialCount, PxShapeFlags shapeFlags = PxShapeFlag::eVISUALIZATION | PxShapeFlag::eSCENE_QUERY_SHAPE | PxShapeFlag::eSIMULATION_SHAPE) const;
+};
+
+struct PxRigidActorShapeCollection : public PxReadOnlyCollectionPropertyInfo<PxPropertyInfoName::PxRigidActor_Shapes, PxRigidActor, PxShape*>
+									, public PxRigidActorShapeCollectionHelper
+{
+	typedef PxReadOnlyCollectionPropertyInfo< PxPropertyInfoName::PxRigidActor_Shapes, PxRigidActor, PxShape* >::TGetObjectsMember TGetObjectsMember;
+	typedef PxReadOnlyCollectionPropertyInfo< PxPropertyInfoName::PxRigidActor_Shapes, PxRigidActor, PxShape* >::TNbObjectsMember TNbObjectsMember;
+	PxRigidActorShapeCollection( const char* inName, TGetObjectsMember inGetter, TNbObjectsMember inNb )
+		: PxReadOnlyCollectionPropertyInfo<PxPropertyInfoName::PxRigidActor_Shapes, PxRigidActor, PxShape*>( inName, inGetter, inNb )
+	{
+	}
+};
+
+struct PxArticulationLinkCollectionPropHelper
+{
+	PX_PHYSX_CORE_API PxArticulationLink*	createLink(PxArticulation* inArticulation, PxArticulationLink* parent, const PxTransform& pose) const;
+};
+
+struct PxArticulationLinkCollectionProp : public PxReadOnlyCollectionPropertyInfo<PxPropertyInfoName::PxArticulation_Links, PxArticulation, PxArticulationLink*>
+										, public PxArticulationLinkCollectionPropHelper
+{
+	PxArticulationLinkCollectionProp( const char* inName, TGetObjectsMember inGetter, TNbObjectsMember inNb )
+		: PxReadOnlyCollectionPropertyInfo<PxPropertyInfoName::PxArticulation_Links, PxArticulation, PxArticulationLink*>( inName, inGetter, inNb )
+	{
+	}
+};
+
+template<typename TDataType>
+struct PxEnumTraits { PxEnumTraits() : NameConversion( false ) {} bool NameConversion; };
+
+#if PX_USE_CLOTH_API
+struct RestvaluesProperty : public PxReadOnlyCollectionPropertyInfo<PxPropertyInfoName::PxClothFabric_Restvalues, PxClothFabric, PxReal>
+{
+	PX_PHYSX_CORE_API RestvaluesProperty();
+};
+#endif // PX_USE_CLOTH_API
+
+struct NbBroadPhaseAddsProperty : public PxIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbBroadPhaseAdds, PxSimulationStatistics, PxSimulationStatistics::VolumeType, PxU32>
+{
+	PX_PHYSX_CORE_API NbBroadPhaseAddsProperty();
+};
+
+struct NbBroadPhaseRemovesProperty : public PxIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbBroadPhaseRemoves, PxSimulationStatistics, PxSimulationStatistics::VolumeType, PxU32>
+{
+	PX_PHYSX_CORE_API NbBroadPhaseRemovesProperty();
+};
+
+struct NbShapesProperty : public PxIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbShapes, PxSimulationStatistics, PxGeometryType::Enum, PxU32>
+{
+	PX_PHYSX_CORE_API NbShapesProperty();
+};
+
+
+struct NbDiscreteContactPairsProperty : public PxDualIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbDiscreteContactPairs
+																			, PxSimulationStatistics
+																			, PxGeometryType::Enum
+																			, PxGeometryType::Enum
+																			, PxU32> 
+{
+	PX_PHYSX_CORE_API NbDiscreteContactPairsProperty();
+};
+struct NbModifiedContactPairsProperty : public PxDualIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbModifiedContactPairs
+																			, PxSimulationStatistics
+																			, PxGeometryType::Enum
+																			, PxGeometryType::Enum
+																			, PxU32> 
+{
+	PX_PHYSX_CORE_API NbModifiedContactPairsProperty();
+};
+
+struct NbCCDPairsProperty : public PxDualIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbCCDPairs
+																			, PxSimulationStatistics
+																			, PxGeometryType::Enum
+																			, PxGeometryType::Enum
+																			, PxU32>
+{
+	PX_PHYSX_CORE_API NbCCDPairsProperty();
+};
+
+struct NbTriggerPairsProperty : public PxDualIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbTriggerPairs
+																			, PxSimulationStatistics
+																			, PxGeometryType::Enum
+																			, PxGeometryType::Enum
+																			, PxU32> 
+{
+	PX_PHYSX_CORE_API NbTriggerPairsProperty();
+};
+
+
+struct SimulationStatisticsProperty : public PxReadOnlyPropertyInfo<PxPropertyInfoName::PxScene_SimulationStatistics, PxScene, PxSimulationStatistics>
+{
+	PX_PHYSX_CORE_API SimulationStatisticsProperty();
+};
+
+struct PxMetaDataPlane
+{
+	PxVec3 normal;
+	PxReal distance;
+	PxMetaDataPlane( PxVec3 n = PxVec3( 0, 0, 0 ), PxReal d = 0 )
+		: normal( n )
+		, distance( d )
+	{
+	}
+};
+
+#if PX_USE_PARTICLE_SYSTEM_API
+struct ProjectionPlaneProperty : public PxPropertyInfo< PxPropertyInfoName::PxParticleBase_ProjectionPlane, PxParticleBase, PxMetaDataPlane, PxMetaDataPlane >
+{
+	PX_PHYSX_CORE_API ProjectionPlaneProperty();
+};
+#endif
+
+#include "PxAutoGeneratedMetaDataObjects.h"
+
+#undef DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP
+
+#if PX_USE_PARTICLE_SYSTEM_API
+	static PxU32ToName g_PxParticleFlags__Conversion[] = {
+			{ "eVALID", static_cast<PxU32>( PxParticleFlag::eVALID ) },
+			{ "eCOLLISION_WITH_STATIC", static_cast<PxU32>(PxParticleFlag::eCOLLISION_WITH_STATIC) },
+			{ "eCOLLISION_WITH_DYNAMIC", static_cast<PxU32>(PxParticleFlag::eCOLLISION_WITH_DYNAMIC) },
+			{ "eCOLLISION_WITH_DRAIN", static_cast<PxU32>(PxParticleFlag::eCOLLISION_WITH_DRAIN) },
+			{ "eSPATIAL_DATA_STRUCTURE_OVERFLOW", static_cast<PxU32>(PxParticleFlag::eSPATIAL_DATA_STRUCTURE_OVERFLOW) },
+			{ NULL, 0 },
+	};
+
+	template<> struct PxEnumTraits< PxParticleFlag::Enum > { PxEnumTraits() : NameConversion( g_PxParticleFlags__Conversion ) {} const PxU32ToName* NameConversion; }; 
+#endif
+
+static PxU32ToName g_physx__PxQueryFlag__EnumConversion[] = {
+		{ "eSTATIC", static_cast<PxU32>( PxQueryFlag::eSTATIC ) },
+		{ "eDYNAMIC", static_cast<PxU32>( PxQueryFlag::eDYNAMIC ) },
+		{ "ePREFILTER", static_cast<PxU32>( PxQueryFlag::ePREFILTER ) },
+		{ "ePOSTFILTER", static_cast<PxU32>( PxQueryFlag::ePOSTFILTER ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits<PxQueryFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxQueryFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+
+
+template<typename TObjType, typename TOperator>
+inline PxU32 visitAllProperties( TOperator inOperator )
+{
+	PxU32 thePropCount = PxClassInfoTraits<TObjType>().Info.visitBaseProperties( inOperator );
+	return PxClassInfoTraits<TObjType>().Info.visitInstanceProperties( inOperator, thePropCount );
+}
+
+template<typename TObjType, typename TOperator>
+inline void visitInstanceProperties( TOperator inOperator )
+{
+	PxClassInfoTraits<TObjType>().Info.visitInstanceProperties( inOperator, 0 );
+}
+
+}
+
+/** @} */
+#endif
diff --git a/PhysX_3.4/Source/PhysXMetaData/core/include/RepXMetaDataPropertyVisitor.h b/PhysX_3.4/Source/PhysXMetaData/core/include/RepXMetaDataPropertyVisitor.h
new file mode 100644
index 00000000..48e6d640
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/core/include/RepXMetaDataPropertyVisitor.h
@@ -0,0 +1,216 @@
+// 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_META_DATA_PROPERTY_VISITOR_H
+#define PX_REPX_META_DATA_PROPERTY_VISITOR_H
+#include "PvdMetaDataPropertyVisitor.h"
+
+namespace physx {
+
+	template<PxU32 TKey, typename TObjectType,typename TSetPropType, typename TPropertyType>
+	struct PxRepXPropertyAccessor : public Vd::ValueStructOffsetRecord
+	{
+		typedef PxPropertyInfo<TKey,TObjectType,TSetPropType,TPropertyType> TPropertyInfoType;
+		typedef TPropertyType prop_type;
+
+		const TPropertyInfoType	mProperty;
+		PxRepXPropertyAccessor( const TPropertyInfoType& inProp )
+			: mProperty( inProp )
+		{
+		}
+		prop_type get( const TObjectType* inObj ) const { return mProperty.get( inObj ); }
+		void set( TObjectType* inObj, prop_type val ) const { return mProperty.set( inObj, val ); }
+
+	private:
+		PxRepXPropertyAccessor& operator=(const PxRepXPropertyAccessor&);
+	};
+
+	template<typename TSetPropType, typename TPropertyType>
+	struct PxRepXPropertyAccessor<PxPropertyInfoName::PxRigidDynamic_WakeCounter, PxRigidDynamic, TSetPropType, TPropertyType> : public Vd::ValueStructOffsetRecord
+	{
+		typedef PxPropertyInfo<PxPropertyInfoName::PxRigidDynamic_WakeCounter,PxRigidDynamic,TSetPropType,TPropertyType> TPropertyInfoType;
+		typedef TPropertyType prop_type;
+
+		const TPropertyInfoType	mProperty;
+		PxRepXPropertyAccessor( const TPropertyInfoType& inProp )
+			: mProperty( inProp )
+		{
+		}
+		prop_type get( const PxRigidDynamic* inObj ) const { return mProperty.get( inObj ); }
+		void set( PxRigidDynamic* inObj, prop_type val ) const
+		{ 
+			PX_UNUSED(val);
+			PxRigidBodyFlags flags = inObj->getRigidBodyFlags();
+			if( !(flags & PxRigidBodyFlag::eKINEMATIC) )
+				return mProperty.set( inObj, val ); 
+		}
+	private:
+		PxRepXPropertyAccessor& operator=(const PxRepXPropertyAccessor&);
+	};
+
+	typedef PxReadOnlyPropertyInfo<PxPropertyInfoName::PxArticulationLink_InboundJoint, PxArticulationLink, PxArticulationJoint *> TIncomingJointPropType;
+
+
+	//RepX cares about fewer property types than PVD does,
+	//but I want to reuse the accessor architecture as it
+	//greatly simplifies clients dealing with complex datatypes
+	template<typename TOperatorType>
+	struct RepXPropertyFilter
+	{
+		RepXPropertyFilter<TOperatorType> &operator=(const RepXPropertyFilter<TOperatorType> &);
+
+		Vd::PvdPropertyFilter<TOperatorType> mFilter;
+		RepXPropertyFilter( TOperatorType op ) : mFilter( op ) {}
+		RepXPropertyFilter( const RepXPropertyFilter<TOperatorType>& other ) : mFilter( other.mFilter ) {}
+		
+		template<PxU32 TKey, typename TObjType, typename TPropertyType>
+		void operator()( const PxReadOnlyPropertyInfo<TKey,TObjType,TPropertyType>&, PxU32 ) {} //repx ignores read only and write only properties
+		template<PxU32 TKey, typename TObjType, typename TPropertyType>
+		void operator()( const PxWriteOnlyPropertyInfo<TKey,TObjType,TPropertyType>&, PxU32 ) {}
+		template<PxU32 TKey, typename TObjType, typename TCollectionType>
+		void operator()( const PxReadOnlyCollectionPropertyInfo<TKey, TObjType, TCollectionType>&, PxU32 ) {}
+
+		template<PxU32 TKey, typename TObjType, typename TCollectionType, typename TFilterType>
+		void operator()( const PxReadOnlyFilteredCollectionPropertyInfo<TKey, TObjType, TCollectionType, TFilterType >&, PxU32 ) {}
+		//forward these properties verbatim.
+		template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType>
+		void operator()( const PxIndexedPropertyInfo<TKey, TObjType, TIndexType, TPropertyType >& inProp, PxU32 idx ) 
+		{
+			mFilter( inProp, idx );
+		}
+        
+        template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType>
+		void operator()( const PxFixedSizeLookupTablePropertyInfo<TKey, TObjType, TIndexType,TPropertyType >& inProp, PxU32 idx ) 
+		{
+			mFilter( inProp, idx );
+		}
+			
+		template<PxU32 TKey, typename TObjType, typename TIndexType, typename TPropertyType>
+		void operator()( const PxExtendedIndexedPropertyInfo<TKey, TObjType, TIndexType, TPropertyType >& inProp, PxU32 idx) 
+		{
+            mFilter( inProp, idx);
+		}
+
+        template<PxU32 TKey, typename TObjType, typename TIndexType, typename TIndex2Type, typename TPropertyType>
+		void operator()( const PxDualIndexedPropertyInfo<TKey, TObjType, TIndexType, TIndex2Type, TPropertyType >& inProp, PxU32 idx ) 
+		{
+			mFilter( inProp, idx );
+		}
+
+		template<PxU32 TKey, typename TObjType, typename TIndexType, typename TIndex2Type, typename TPropertyType>
+		void operator()( const PxExtendedDualIndexedPropertyInfo<TKey, TObjType, TIndexType, TIndex2Type, TPropertyType >& inProp, PxU32 idx ) 
+		{
+			mFilter( inProp, idx );
+		}
+
+		template<PxU32 TKey, typename TObjType, typename TPropertyType>
+		void operator()( const PxRangePropertyInfo<TKey, TObjType, TPropertyType>& inProp, PxU32 idx )
+		{
+			mFilter( inProp, idx );
+		}
+	
+		template<PxU32 TKey, typename TObjType, typename TPropertyType>
+		void operator()( const PxBufferCollectionPropertyInfo<TKey, TObjType, TPropertyType>& inProp, PxU32 count )
+		{
+			mFilter( inProp, count );
+		}
+
+		template<PxU32 TKey, typename TObjType, typename TSetPropType, typename TPropertyType>
+		void operator()( const PxPropertyInfo<TKey,TObjType,TSetPropType,TPropertyType>& prop, PxU32 ) 
+		{
+			PxRepXPropertyAccessor< TKey, TObjType, TSetPropType, TPropertyType > theAccessor( prop );
+			mFilter.mOperator.pushName( prop.mName );
+			mFilter.template handleAccessor<TKey>( theAccessor );
+			mFilter.mOperator.popName();
+		}
+
+		void operator()( const PxRigidActorShapeCollection& inProp, PxU32 )
+		{
+			mFilter.mOperator.pushName( "Shapes" );
+			mFilter.mOperator.handleShapes( inProp );
+			mFilter.mOperator.popName();
+		}
+
+		void operator()( const PxArticulationLinkCollectionProp& inProp, PxU32 )
+		{
+			mFilter.mOperator.pushName( "Links" );
+			mFilter.mOperator.handleArticulationLinks( inProp );
+			mFilter.mOperator.popName();
+		}
+
+		void operator()( const PxShapeMaterialsProperty& inProp, PxU32 )
+		{
+			mFilter.mOperator.pushName( "Materials" );
+			mFilter.mOperator.handleShapeMaterials( inProp );
+			mFilter.mOperator.popName();
+		}
+
+		void operator()( const TIncomingJointPropType& inProp, PxU32 )
+		{
+			mFilter.mOperator.handleIncomingJoint( inProp );
+		}
+        
+        void operator()( const PxShapeGeometryProperty& inProp, PxU32 )
+		{
+			mFilter.mOperator.handleGeometryProperty( inProp );
+		}
+		
+#define DEFINE_REPX_PROPERTY_NOP(datatype)																\
+		template<PxU32 TKey, typename TObjType, typename TSetPropType>										\
+		void operator()( const PxPropertyInfo<TKey,TObjType,TSetPropType,datatype>&, PxU32 ){}
+		
+		DEFINE_REPX_PROPERTY_NOP( const void* )
+		DEFINE_REPX_PROPERTY_NOP( void* )
+		DEFINE_REPX_PROPERTY_NOP( PxSimulationFilterCallback * )
+		DEFINE_REPX_PROPERTY_NOP( physx::PxTaskManager * )
+		DEFINE_REPX_PROPERTY_NOP( PxSimulationFilterShader * )
+		DEFINE_REPX_PROPERTY_NOP( PxSimulationFilterShader)
+		DEFINE_REPX_PROPERTY_NOP( PxContactModifyCallback * )
+		DEFINE_REPX_PROPERTY_NOP( PxCCDContactModifyCallback * )
+		DEFINE_REPX_PROPERTY_NOP( PxSimulationEventCallback * )
+		DEFINE_REPX_PROPERTY_NOP( physx::PxGpuDispatcher* )
+		DEFINE_REPX_PROPERTY_NOP( physx::PxCpuDispatcher * )
+		DEFINE_REPX_PROPERTY_NOP( PxRigidActor )
+		DEFINE_REPX_PROPERTY_NOP( const PxRigidActor )
+		DEFINE_REPX_PROPERTY_NOP( PxRigidActor& )
+		DEFINE_REPX_PROPERTY_NOP( const PxRigidActor& )
+		DEFINE_REPX_PROPERTY_NOP( PxScene* )
+		DEFINE_REPX_PROPERTY_NOP( PxAggregate * )
+		DEFINE_REPX_PROPERTY_NOP( PxArticulation& )
+		DEFINE_REPX_PROPERTY_NOP( const PxArticulationLink * )
+		DEFINE_REPX_PROPERTY_NOP( const PxParticleFluid * )
+		DEFINE_REPX_PROPERTY_NOP( const PxParticleSystem * )
+		DEFINE_REPX_PROPERTY_NOP( const PxRigidDynamic * )
+		DEFINE_REPX_PROPERTY_NOP( const PxRigidStatic * )
+		DEFINE_REPX_PROPERTY_NOP( const PxParticleBase * )
+		DEFINE_REPX_PROPERTY_NOP( PxStridedData ) //These are handled in a custom fasion.
+	};
+}
+
+#endif
diff --git a/PhysX_3.4/Source/PhysXMetaData/core/src/PxAutoGeneratedMetaDataObjects.cpp b/PhysX_3.4/Source/PhysXMetaData/core/src/PxAutoGeneratedMetaDataObjects.cpp
new file mode 100644
index 00000000..92b7d886
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/core/src/PxAutoGeneratedMetaDataObjects.cpp
@@ -0,0 +1,1579 @@
+// 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.
+
+// This code is auto-generated by the PhysX Clang metadata generator.  Do not edit or be
+// prepared for your edits to be quietly ignored next time the clang metadata generator is
+// run.  You can find the most recent version of clang metadata generator by contacting
+// Chris Nuernberger <[email protected]> or Dilip or Adam.
+// The source code for the generate was at one time checked into:
+// physx/PhysXMetaDataGenerator/llvm/tools/clang/lib/Frontend/PhysXMetaDataAction.cpp
+#include "PxMetaDataObjects.h"
+#include "PxPhysicsAPI.h"
+#include "PxMetaDataCppPrefix.h"
+using namespace physx;
+const PxTolerancesScale & getPxPhysics_TolerancesScale( const PxPhysics* inObj ) { return inObj->getTolerancesScale(); }
+PxU32 getPxPhysics_TriangleMeshes( const PxPhysics* inObj, PxTriangleMesh ** outBuffer, PxU32 inBufSize ) { return inObj->getTriangleMeshes( outBuffer, inBufSize ); }
+PxU32 getNbPxPhysics_TriangleMeshes( const PxPhysics* inObj ) { return inObj->getNbTriangleMeshes(  ); }
+PxTriangleMesh * createPxPhysics_TriangleMeshes( PxPhysics* inObj, PxInputStream & inCreateParam ){ return inObj->createTriangleMesh( inCreateParam ); }
+PxU32 getPxPhysics_HeightFields( const PxPhysics* inObj, PxHeightField ** outBuffer, PxU32 inBufSize ) { return inObj->getHeightFields( outBuffer, inBufSize ); }
+PxU32 getNbPxPhysics_HeightFields( const PxPhysics* inObj ) { return inObj->getNbHeightFields(  ); }
+PxHeightField * createPxPhysics_HeightFields( PxPhysics* inObj, PxInputStream & inCreateParam ){ return inObj->createHeightField( inCreateParam ); }
+PxU32 getPxPhysics_ConvexMeshes( const PxPhysics* inObj, PxConvexMesh ** outBuffer, PxU32 inBufSize ) { return inObj->getConvexMeshes( outBuffer, inBufSize ); }
+PxU32 getNbPxPhysics_ConvexMeshes( const PxPhysics* inObj ) { return inObj->getNbConvexMeshes(  ); }
+PxConvexMesh * createPxPhysics_ConvexMeshes( PxPhysics* inObj, PxInputStream & inCreateParam ){ return inObj->createConvexMesh( inCreateParam ); }
+PxU32 getPxPhysics_ClothFabrics( const PxPhysics* inObj, PxClothFabric ** outBuffer, PxU32 inBufSize ) { return inObj->getClothFabrics( outBuffer, inBufSize ); }
+PxU32 getNbPxPhysics_ClothFabrics( const PxPhysics* inObj ) { return inObj->getNbClothFabrics(  ); }
+PxU32 getPxPhysics_Scenes( const PxPhysics* inObj, PxScene ** outBuffer, PxU32 inBufSize ) { return inObj->getScenes( outBuffer, inBufSize ); }
+PxU32 getNbPxPhysics_Scenes( const PxPhysics* inObj ) { return inObj->getNbScenes(  ); }
+PxScene * createPxPhysics_Scenes( PxPhysics* inObj, const PxSceneDesc & inCreateParam ){ return inObj->createScene( inCreateParam ); }
+PxU32 getPxPhysics_Shapes( const PxPhysics* inObj, PxShape ** outBuffer, PxU32 inBufSize ) { return inObj->getShapes( outBuffer, inBufSize ); }
+PxU32 getNbPxPhysics_Shapes( const PxPhysics* inObj ) { return inObj->getNbShapes(  ); }
+PxU32 getPxPhysics_Materials( const PxPhysics* inObj, PxMaterial ** outBuffer, PxU32 inBufSize ) { return inObj->getMaterials( outBuffer, inBufSize ); }
+PxU32 getNbPxPhysics_Materials( const PxPhysics* inObj ) { return inObj->getNbMaterials(  ); }
+PX_PHYSX_CORE_API PxPhysicsGeneratedInfo::PxPhysicsGeneratedInfo()
+	: TolerancesScale( "TolerancesScale", getPxPhysics_TolerancesScale)
+	, TriangleMeshes( "TriangleMeshes", getPxPhysics_TriangleMeshes, getNbPxPhysics_TriangleMeshes, createPxPhysics_TriangleMeshes )
+	, HeightFields( "HeightFields", getPxPhysics_HeightFields, getNbPxPhysics_HeightFields, createPxPhysics_HeightFields )
+	, ConvexMeshes( "ConvexMeshes", getPxPhysics_ConvexMeshes, getNbPxPhysics_ConvexMeshes, createPxPhysics_ConvexMeshes )
+	, ClothFabrics( "ClothFabrics", getPxPhysics_ClothFabrics, getNbPxPhysics_ClothFabrics )
+	, Scenes( "Scenes", getPxPhysics_Scenes, getNbPxPhysics_Scenes, createPxPhysics_Scenes )
+	, Shapes( "Shapes", getPxPhysics_Shapes, getNbPxPhysics_Shapes )
+	, Materials( "Materials", getPxPhysics_Materials, getNbPxPhysics_Materials )
+{}
+PX_PHYSX_CORE_API PxPhysicsGeneratedValues::PxPhysicsGeneratedValues( const PxPhysics* inSource )
+		:TolerancesScale( getPxPhysics_TolerancesScale( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+PxU32 getPxMaterial_ReferenceCount( const PxMaterial* inObj ) { return inObj->getReferenceCount(); }
+void setPxMaterial_DynamicFriction( PxMaterial* inObj, PxReal inArg){ inObj->setDynamicFriction( inArg ); }
+PxReal getPxMaterial_DynamicFriction( const PxMaterial* inObj ) { return inObj->getDynamicFriction(); }
+void setPxMaterial_StaticFriction( PxMaterial* inObj, PxReal inArg){ inObj->setStaticFriction( inArg ); }
+PxReal getPxMaterial_StaticFriction( const PxMaterial* inObj ) { return inObj->getStaticFriction(); }
+void setPxMaterial_Restitution( PxMaterial* inObj, PxReal inArg){ inObj->setRestitution( inArg ); }
+PxReal getPxMaterial_Restitution( const PxMaterial* inObj ) { return inObj->getRestitution(); }
+void setPxMaterial_Flags( PxMaterial* inObj, PxMaterialFlags inArg){ inObj->setFlags( inArg ); }
+PxMaterialFlags getPxMaterial_Flags( const PxMaterial* inObj ) { return inObj->getFlags(); }
+void setPxMaterial_FrictionCombineMode( PxMaterial* inObj, PxCombineMode::Enum inArg){ inObj->setFrictionCombineMode( inArg ); }
+PxCombineMode::Enum getPxMaterial_FrictionCombineMode( const PxMaterial* inObj ) { return inObj->getFrictionCombineMode(); }
+void setPxMaterial_RestitutionCombineMode( PxMaterial* inObj, PxCombineMode::Enum inArg){ inObj->setRestitutionCombineMode( inArg ); }
+PxCombineMode::Enum getPxMaterial_RestitutionCombineMode( const PxMaterial* inObj ) { return inObj->getRestitutionCombineMode(); }
+const char * getPxMaterial_ConcreteTypeName( const PxMaterial* inObj ) { return inObj->getConcreteTypeName(); }
+inline void * getPxMaterialUserData( const PxMaterial* inOwner ) { return inOwner->userData; }
+inline void setPxMaterialUserData( PxMaterial* inOwner, void * inData) { inOwner->userData = inData; }
+PX_PHYSX_CORE_API PxMaterialGeneratedInfo::PxMaterialGeneratedInfo()
+	: ReferenceCount( "ReferenceCount", getPxMaterial_ReferenceCount)
+	, DynamicFriction( "DynamicFriction", setPxMaterial_DynamicFriction, getPxMaterial_DynamicFriction)
+	, StaticFriction( "StaticFriction", setPxMaterial_StaticFriction, getPxMaterial_StaticFriction)
+	, Restitution( "Restitution", setPxMaterial_Restitution, getPxMaterial_Restitution)
+	, Flags( "Flags", setPxMaterial_Flags, getPxMaterial_Flags)
+	, FrictionCombineMode( "FrictionCombineMode", setPxMaterial_FrictionCombineMode, getPxMaterial_FrictionCombineMode)
+	, RestitutionCombineMode( "RestitutionCombineMode", setPxMaterial_RestitutionCombineMode, getPxMaterial_RestitutionCombineMode)
+	, ConcreteTypeName( "ConcreteTypeName", getPxMaterial_ConcreteTypeName)
+	, UserData( "UserData", setPxMaterialUserData, getPxMaterialUserData )
+{}
+PX_PHYSX_CORE_API PxMaterialGeneratedValues::PxMaterialGeneratedValues( const PxMaterial* inSource )
+		:ReferenceCount( getPxMaterial_ReferenceCount( inSource ) )
+		,DynamicFriction( getPxMaterial_DynamicFriction( inSource ) )
+		,StaticFriction( getPxMaterial_StaticFriction( inSource ) )
+		,Restitution( getPxMaterial_Restitution( inSource ) )
+		,Flags( getPxMaterial_Flags( inSource ) )
+		,FrictionCombineMode( getPxMaterial_FrictionCombineMode( inSource ) )
+		,RestitutionCombineMode( getPxMaterial_RestitutionCombineMode( inSource ) )
+		,ConcreteTypeName( getPxMaterial_ConcreteTypeName( inSource ) )
+		,UserData( inSource->userData )
+{
+	PX_UNUSED(inSource);
+}
+PxScene * getPxActor_Scene( const PxActor* inObj ) { return inObj->getScene(); }
+void setPxActor_Name( PxActor* inObj, const char * inArg){ inObj->setName( inArg ); }
+const char * getPxActor_Name( const PxActor* inObj ) { return inObj->getName(); }
+void setPxActor_ActorFlags( PxActor* inObj, PxActorFlags inArg){ inObj->setActorFlags( inArg ); }
+PxActorFlags getPxActor_ActorFlags( const PxActor* inObj ) { return inObj->getActorFlags(); }
+void setPxActor_DominanceGroup( PxActor* inObj, PxDominanceGroup inArg){ inObj->setDominanceGroup( inArg ); }
+PxDominanceGroup getPxActor_DominanceGroup( const PxActor* inObj ) { return inObj->getDominanceGroup(); }
+void setPxActor_OwnerClient( PxActor* inObj, PxClientID inArg){ inObj->setOwnerClient( inArg ); }
+PxClientID getPxActor_OwnerClient( const PxActor* inObj ) { return inObj->getOwnerClient(); }
+void setPxActor_ClientBehaviorFlags( PxActor* inObj, PxActorClientBehaviorFlags inArg){ inObj->setClientBehaviorFlags( inArg ); }
+PxActorClientBehaviorFlags getPxActor_ClientBehaviorFlags( const PxActor* inObj ) { return inObj->getClientBehaviorFlags(); }
+PxAggregate * getPxActor_Aggregate( const PxActor* inObj ) { return inObj->getAggregate(); }
+inline void * getPxActorUserData( const PxActor* inOwner ) { return inOwner->userData; }
+inline void setPxActorUserData( PxActor* inOwner, void * inData) { inOwner->userData = inData; }
+PX_PHYSX_CORE_API PxActorGeneratedInfo::PxActorGeneratedInfo()
+	: Scene( "Scene", getPxActor_Scene)
+	, Name( "Name", setPxActor_Name, getPxActor_Name)
+	, ActorFlags( "ActorFlags", setPxActor_ActorFlags, getPxActor_ActorFlags)
+	, DominanceGroup( "DominanceGroup", setPxActor_DominanceGroup, getPxActor_DominanceGroup)
+	, OwnerClient( "OwnerClient", setPxActor_OwnerClient, getPxActor_OwnerClient)
+	, ClientBehaviorFlags( "ClientBehaviorFlags", setPxActor_ClientBehaviorFlags, getPxActor_ClientBehaviorFlags)
+	, Aggregate( "Aggregate", getPxActor_Aggregate)
+	, UserData( "UserData", setPxActorUserData, getPxActorUserData )
+{}
+PX_PHYSX_CORE_API PxActorGeneratedValues::PxActorGeneratedValues( const PxActor* inSource )
+		:Scene( getPxActor_Scene( inSource ) )
+		,Name( getPxActor_Name( inSource ) )
+		,ActorFlags( getPxActor_ActorFlags( inSource ) )
+		,DominanceGroup( getPxActor_DominanceGroup( inSource ) )
+		,OwnerClient( getPxActor_OwnerClient( inSource ) )
+		,ClientBehaviorFlags( getPxActor_ClientBehaviorFlags( inSource ) )
+		,Aggregate( getPxActor_Aggregate( inSource ) )
+		,UserData( inSource->userData )
+{
+	PX_UNUSED(inSource);
+}
+void setPxRigidActor_GlobalPose( PxRigidActor* inObj, const PxTransform & inArg){ inObj->setGlobalPose( inArg ); }
+PxTransform getPxRigidActor_GlobalPose( const PxRigidActor* inObj ) { return inObj->getGlobalPose(); }
+PxU32 getPxRigidActor_Shapes( const PxRigidActor* inObj, PxShape ** outBuffer, PxU32 inBufSize ) { return inObj->getShapes( outBuffer, inBufSize ); }
+PxU32 getNbPxRigidActor_Shapes( const PxRigidActor* inObj ) { return inObj->getNbShapes(  ); }
+PxU32 getPxRigidActor_Constraints( const PxRigidActor* inObj, PxConstraint ** outBuffer, PxU32 inBufSize ) { return inObj->getConstraints( outBuffer, inBufSize ); }
+PxU32 getNbPxRigidActor_Constraints( const PxRigidActor* inObj ) { return inObj->getNbConstraints(  ); }
+PX_PHYSX_CORE_API PxRigidActorGeneratedInfo::PxRigidActorGeneratedInfo()
+	: GlobalPose( "GlobalPose", setPxRigidActor_GlobalPose, getPxRigidActor_GlobalPose)
+	, Shapes( "Shapes", getPxRigidActor_Shapes, getNbPxRigidActor_Shapes )
+	, Constraints( "Constraints", getPxRigidActor_Constraints, getNbPxRigidActor_Constraints )
+{}
+PX_PHYSX_CORE_API PxRigidActorGeneratedValues::PxRigidActorGeneratedValues( const PxRigidActor* inSource )
+		:PxActorGeneratedValues( inSource )
+		,GlobalPose( getPxRigidActor_GlobalPose( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+void setPxRigidBody_CMassLocalPose( PxRigidBody* inObj, const PxTransform & inArg){ inObj->setCMassLocalPose( inArg ); }
+PxTransform getPxRigidBody_CMassLocalPose( const PxRigidBody* inObj ) { return inObj->getCMassLocalPose(); }
+void setPxRigidBody_Mass( PxRigidBody* inObj, PxReal inArg){ inObj->setMass( inArg ); }
+PxReal getPxRigidBody_Mass( const PxRigidBody* inObj ) { return inObj->getMass(); }
+PxReal getPxRigidBody_InvMass( const PxRigidBody* inObj ) { return inObj->getInvMass(); }
+void setPxRigidBody_MassSpaceInertiaTensor( PxRigidBody* inObj, const PxVec3 & inArg){ inObj->setMassSpaceInertiaTensor( inArg ); }
+PxVec3 getPxRigidBody_MassSpaceInertiaTensor( const PxRigidBody* inObj ) { return inObj->getMassSpaceInertiaTensor(); }
+PxVec3 getPxRigidBody_MassSpaceInvInertiaTensor( const PxRigidBody* inObj ) { return inObj->getMassSpaceInvInertiaTensor(); }
+void setPxRigidBody_LinearVelocity( PxRigidBody* inObj, const PxVec3 & inArg){ inObj->setLinearVelocity( inArg ); }
+PxVec3 getPxRigidBody_LinearVelocity( const PxRigidBody* inObj ) { return inObj->getLinearVelocity(); }
+void setPxRigidBody_AngularVelocity( PxRigidBody* inObj, const PxVec3 & inArg){ inObj->setAngularVelocity( inArg ); }
+PxVec3 getPxRigidBody_AngularVelocity( const PxRigidBody* inObj ) { return inObj->getAngularVelocity(); }
+void setPxRigidBody_RigidBodyFlags( PxRigidBody* inObj, PxRigidBodyFlags inArg){ inObj->setRigidBodyFlags( inArg ); }
+PxRigidBodyFlags getPxRigidBody_RigidBodyFlags( const PxRigidBody* inObj ) { return inObj->getRigidBodyFlags(); }
+void setPxRigidBody_MinCCDAdvanceCoefficient( PxRigidBody* inObj, PxReal inArg){ inObj->setMinCCDAdvanceCoefficient( inArg ); }
+PxReal getPxRigidBody_MinCCDAdvanceCoefficient( const PxRigidBody* inObj ) { return inObj->getMinCCDAdvanceCoefficient(); }
+void setPxRigidBody_MaxDepenetrationVelocity( PxRigidBody* inObj, PxReal inArg){ inObj->setMaxDepenetrationVelocity( inArg ); }
+PxReal getPxRigidBody_MaxDepenetrationVelocity( const PxRigidBody* inObj ) { return inObj->getMaxDepenetrationVelocity(); }
+void setPxRigidBody_MaxContactImpulse( PxRigidBody* inObj, PxReal inArg){ inObj->setMaxContactImpulse( inArg ); }
+PxReal getPxRigidBody_MaxContactImpulse( const PxRigidBody* inObj ) { return inObj->getMaxContactImpulse(); }
+PX_PHYSX_CORE_API PxRigidBodyGeneratedInfo::PxRigidBodyGeneratedInfo()
+	: CMassLocalPose( "CMassLocalPose", setPxRigidBody_CMassLocalPose, getPxRigidBody_CMassLocalPose)
+	, Mass( "Mass", setPxRigidBody_Mass, getPxRigidBody_Mass)
+	, InvMass( "InvMass", getPxRigidBody_InvMass)
+	, MassSpaceInertiaTensor( "MassSpaceInertiaTensor", setPxRigidBody_MassSpaceInertiaTensor, getPxRigidBody_MassSpaceInertiaTensor)
+	, MassSpaceInvInertiaTensor( "MassSpaceInvInertiaTensor", getPxRigidBody_MassSpaceInvInertiaTensor)
+	, LinearVelocity( "LinearVelocity", setPxRigidBody_LinearVelocity, getPxRigidBody_LinearVelocity)
+	, AngularVelocity( "AngularVelocity", setPxRigidBody_AngularVelocity, getPxRigidBody_AngularVelocity)
+	, RigidBodyFlags( "RigidBodyFlags", setPxRigidBody_RigidBodyFlags, getPxRigidBody_RigidBodyFlags)
+	, MinCCDAdvanceCoefficient( "MinCCDAdvanceCoefficient", setPxRigidBody_MinCCDAdvanceCoefficient, getPxRigidBody_MinCCDAdvanceCoefficient)
+	, MaxDepenetrationVelocity( "MaxDepenetrationVelocity", setPxRigidBody_MaxDepenetrationVelocity, getPxRigidBody_MaxDepenetrationVelocity)
+	, MaxContactImpulse( "MaxContactImpulse", setPxRigidBody_MaxContactImpulse, getPxRigidBody_MaxContactImpulse)
+{}
+PX_PHYSX_CORE_API PxRigidBodyGeneratedValues::PxRigidBodyGeneratedValues( const PxRigidBody* inSource )
+		:PxRigidActorGeneratedValues( inSource )
+		,CMassLocalPose( getPxRigidBody_CMassLocalPose( inSource ) )
+		,Mass( getPxRigidBody_Mass( inSource ) )
+		,InvMass( getPxRigidBody_InvMass( inSource ) )
+		,MassSpaceInertiaTensor( getPxRigidBody_MassSpaceInertiaTensor( inSource ) )
+		,MassSpaceInvInertiaTensor( getPxRigidBody_MassSpaceInvInertiaTensor( inSource ) )
+		,LinearVelocity( getPxRigidBody_LinearVelocity( inSource ) )
+		,AngularVelocity( getPxRigidBody_AngularVelocity( inSource ) )
+		,RigidBodyFlags( getPxRigidBody_RigidBodyFlags( inSource ) )
+		,MinCCDAdvanceCoefficient( getPxRigidBody_MinCCDAdvanceCoefficient( inSource ) )
+		,MaxDepenetrationVelocity( getPxRigidBody_MaxDepenetrationVelocity( inSource ) )
+		,MaxContactImpulse( getPxRigidBody_MaxContactImpulse( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+void setPxRigidDynamic_KinematicTarget( PxRigidDynamic* inObj, const PxTransform & inArg){ inObj->setKinematicTarget( inArg ); }
+void setPxRigidDynamic_LinearDamping( PxRigidDynamic* inObj, PxReal inArg){ inObj->setLinearDamping( inArg ); }
+PxReal getPxRigidDynamic_LinearDamping( const PxRigidDynamic* inObj ) { return inObj->getLinearDamping(); }
+void setPxRigidDynamic_AngularDamping( PxRigidDynamic* inObj, PxReal inArg){ inObj->setAngularDamping( inArg ); }
+PxReal getPxRigidDynamic_AngularDamping( const PxRigidDynamic* inObj ) { return inObj->getAngularDamping(); }
+void setPxRigidDynamic_MaxAngularVelocity( PxRigidDynamic* inObj, PxReal inArg){ inObj->setMaxAngularVelocity( inArg ); }
+PxReal getPxRigidDynamic_MaxAngularVelocity( const PxRigidDynamic* inObj ) { return inObj->getMaxAngularVelocity(); }
+_Bool getPxRigidDynamic_IsSleeping( const PxRigidDynamic* inObj ) { return inObj->isSleeping(); }
+void setPxRigidDynamic_SleepThreshold( PxRigidDynamic* inObj, PxReal inArg){ inObj->setSleepThreshold( inArg ); }
+PxReal getPxRigidDynamic_SleepThreshold( const PxRigidDynamic* inObj ) { return inObj->getSleepThreshold(); }
+void setPxRigidDynamic_StabilizationThreshold( PxRigidDynamic* inObj, PxReal inArg){ inObj->setStabilizationThreshold( inArg ); }
+PxReal getPxRigidDynamic_StabilizationThreshold( const PxRigidDynamic* inObj ) { return inObj->getStabilizationThreshold(); }
+void setPxRigidDynamic_RigidDynamicLockFlags( PxRigidDynamic* inObj, PxRigidDynamicLockFlags inArg){ inObj->setRigidDynamicLockFlags( inArg ); }
+PxRigidDynamicLockFlags getPxRigidDynamic_RigidDynamicLockFlags( const PxRigidDynamic* inObj ) { return inObj->getRigidDynamicLockFlags(); }
+void setPxRigidDynamic_WakeCounter( PxRigidDynamic* inObj, PxReal inArg){ inObj->setWakeCounter( inArg ); }
+PxReal getPxRigidDynamic_WakeCounter( const PxRigidDynamic* inObj ) { return inObj->getWakeCounter(); }
+void setPxRigidDynamic_SolverIterationCounts( PxRigidDynamic* inObj, PxU32 inArg0, PxU32 inArg1 ) { inObj->setSolverIterationCounts( inArg0, inArg1 ); }
+void getPxRigidDynamic_SolverIterationCounts( const PxRigidDynamic* inObj, PxU32& inArg0, PxU32& inArg1 ) { inObj->getSolverIterationCounts( inArg0, inArg1 ); }
+void setPxRigidDynamic_ContactReportThreshold( PxRigidDynamic* inObj, PxReal inArg){ inObj->setContactReportThreshold( inArg ); }
+PxReal getPxRigidDynamic_ContactReportThreshold( const PxRigidDynamic* inObj ) { return inObj->getContactReportThreshold(); }
+const char * getPxRigidDynamic_ConcreteTypeName( const PxRigidDynamic* inObj ) { return inObj->getConcreteTypeName(); }
+PX_PHYSX_CORE_API PxRigidDynamicGeneratedInfo::PxRigidDynamicGeneratedInfo()
+	: KinematicTarget( "KinematicTarget", setPxRigidDynamic_KinematicTarget)
+	, LinearDamping( "LinearDamping", setPxRigidDynamic_LinearDamping, getPxRigidDynamic_LinearDamping)
+	, AngularDamping( "AngularDamping", setPxRigidDynamic_AngularDamping, getPxRigidDynamic_AngularDamping)
+	, MaxAngularVelocity( "MaxAngularVelocity", setPxRigidDynamic_MaxAngularVelocity, getPxRigidDynamic_MaxAngularVelocity)
+	, IsSleeping( "IsSleeping", getPxRigidDynamic_IsSleeping)
+	, SleepThreshold( "SleepThreshold", setPxRigidDynamic_SleepThreshold, getPxRigidDynamic_SleepThreshold)
+	, StabilizationThreshold( "StabilizationThreshold", setPxRigidDynamic_StabilizationThreshold, getPxRigidDynamic_StabilizationThreshold)
+	, RigidDynamicLockFlags( "RigidDynamicLockFlags", setPxRigidDynamic_RigidDynamicLockFlags, getPxRigidDynamic_RigidDynamicLockFlags)
+	, WakeCounter( "WakeCounter", setPxRigidDynamic_WakeCounter, getPxRigidDynamic_WakeCounter)
+	, SolverIterationCounts( "SolverIterationCounts", "minPositionIters", "minVelocityIters", setPxRigidDynamic_SolverIterationCounts, getPxRigidDynamic_SolverIterationCounts)
+	, ContactReportThreshold( "ContactReportThreshold", setPxRigidDynamic_ContactReportThreshold, getPxRigidDynamic_ContactReportThreshold)
+	, ConcreteTypeName( "ConcreteTypeName", getPxRigidDynamic_ConcreteTypeName)
+{}
+PX_PHYSX_CORE_API PxRigidDynamicGeneratedValues::PxRigidDynamicGeneratedValues( const PxRigidDynamic* inSource )
+		:PxRigidBodyGeneratedValues( inSource )
+		,LinearDamping( getPxRigidDynamic_LinearDamping( inSource ) )
+		,AngularDamping( getPxRigidDynamic_AngularDamping( inSource ) )
+		,MaxAngularVelocity( getPxRigidDynamic_MaxAngularVelocity( inSource ) )
+		,IsSleeping( getPxRigidDynamic_IsSleeping( inSource ) )
+		,SleepThreshold( getPxRigidDynamic_SleepThreshold( inSource ) )
+		,StabilizationThreshold( getPxRigidDynamic_StabilizationThreshold( inSource ) )
+		,RigidDynamicLockFlags( getPxRigidDynamic_RigidDynamicLockFlags( inSource ) )
+		,WakeCounter( getPxRigidDynamic_WakeCounter( inSource ) )
+		,ContactReportThreshold( getPxRigidDynamic_ContactReportThreshold( inSource ) )
+		,ConcreteTypeName( getPxRigidDynamic_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+	getPxRigidDynamic_SolverIterationCounts( inSource, SolverIterationCounts[0], SolverIterationCounts[1] );
+}
+const char * getPxRigidStatic_ConcreteTypeName( const PxRigidStatic* inObj ) { return inObj->getConcreteTypeName(); }
+PX_PHYSX_CORE_API PxRigidStaticGeneratedInfo::PxRigidStaticGeneratedInfo()
+	: ConcreteTypeName( "ConcreteTypeName", getPxRigidStatic_ConcreteTypeName)
+{}
+PX_PHYSX_CORE_API PxRigidStaticGeneratedValues::PxRigidStaticGeneratedValues( const PxRigidStatic* inSource )
+		:PxRigidActorGeneratedValues( inSource )
+		,ConcreteTypeName( getPxRigidStatic_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+PxArticulationJoint * getPxArticulationLink_InboundJoint( const PxArticulationLink* inObj ) { return inObj->getInboundJoint(); }
+PxU32 getPxArticulationLink_Children( const PxArticulationLink* inObj, PxArticulationLink ** outBuffer, PxU32 inBufSize ) { return inObj->getChildren( outBuffer, inBufSize ); }
+PxU32 getNbPxArticulationLink_Children( const PxArticulationLink* inObj ) { return inObj->getNbChildren(  ); }
+const char * getPxArticulationLink_ConcreteTypeName( const PxArticulationLink* inObj ) { return inObj->getConcreteTypeName(); }
+PX_PHYSX_CORE_API PxArticulationLinkGeneratedInfo::PxArticulationLinkGeneratedInfo()
+	: InboundJoint( "InboundJoint", getPxArticulationLink_InboundJoint)
+	, Children( "Children", getPxArticulationLink_Children, getNbPxArticulationLink_Children )
+	, ConcreteTypeName( "ConcreteTypeName", getPxArticulationLink_ConcreteTypeName)
+{}
+PX_PHYSX_CORE_API PxArticulationLinkGeneratedValues::PxArticulationLinkGeneratedValues( const PxArticulationLink* inSource )
+		:PxRigidBodyGeneratedValues( inSource )
+		,InboundJoint( getPxArticulationLink_InboundJoint( inSource ) )
+		,ConcreteTypeName( getPxArticulationLink_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+void setPxArticulationJoint_ParentPose( PxArticulationJoint* inObj, const PxTransform & inArg){ inObj->setParentPose( inArg ); }
+PxTransform getPxArticulationJoint_ParentPose( const PxArticulationJoint* inObj ) { return inObj->getParentPose(); }
+void setPxArticulationJoint_ChildPose( PxArticulationJoint* inObj, const PxTransform & inArg){ inObj->setChildPose( inArg ); }
+PxTransform getPxArticulationJoint_ChildPose( const PxArticulationJoint* inObj ) { return inObj->getChildPose(); }
+void setPxArticulationJoint_TargetOrientation( PxArticulationJoint* inObj, const PxQuat & inArg){ inObj->setTargetOrientation( inArg ); }
+PxQuat getPxArticulationJoint_TargetOrientation( const PxArticulationJoint* inObj ) { return inObj->getTargetOrientation(); }
+void setPxArticulationJoint_TargetVelocity( PxArticulationJoint* inObj, const PxVec3 & inArg){ inObj->setTargetVelocity( inArg ); }
+PxVec3 getPxArticulationJoint_TargetVelocity( const PxArticulationJoint* inObj ) { return inObj->getTargetVelocity(); }
+void setPxArticulationJoint_DriveType( PxArticulationJoint* inObj, PxArticulationJointDriveType::Enum inArg){ inObj->setDriveType( inArg ); }
+PxArticulationJointDriveType::Enum getPxArticulationJoint_DriveType( const PxArticulationJoint* inObj ) { return inObj->getDriveType(); }
+void setPxArticulationJoint_Stiffness( PxArticulationJoint* inObj, PxReal inArg){ inObj->setStiffness( inArg ); }
+PxReal getPxArticulationJoint_Stiffness( const PxArticulationJoint* inObj ) { return inObj->getStiffness(); }
+void setPxArticulationJoint_Damping( PxArticulationJoint* inObj, PxReal inArg){ inObj->setDamping( inArg ); }
+PxReal getPxArticulationJoint_Damping( const PxArticulationJoint* inObj ) { return inObj->getDamping(); }
+void setPxArticulationJoint_InternalCompliance( PxArticulationJoint* inObj, PxReal inArg){ inObj->setInternalCompliance( inArg ); }
+PxReal getPxArticulationJoint_InternalCompliance( const PxArticulationJoint* inObj ) { return inObj->getInternalCompliance(); }
+void setPxArticulationJoint_ExternalCompliance( PxArticulationJoint* inObj, PxReal inArg){ inObj->setExternalCompliance( inArg ); }
+PxReal getPxArticulationJoint_ExternalCompliance( const PxArticulationJoint* inObj ) { return inObj->getExternalCompliance(); }
+void setPxArticulationJoint_SwingLimit( PxArticulationJoint* inObj, PxReal inArg0, PxReal inArg1 ) { inObj->setSwingLimit( inArg0, inArg1 ); }
+void getPxArticulationJoint_SwingLimit( const PxArticulationJoint* inObj, PxReal& inArg0, PxReal& inArg1 ) { inObj->getSwingLimit( inArg0, inArg1 ); }
+void setPxArticulationJoint_TangentialStiffness( PxArticulationJoint* inObj, PxReal inArg){ inObj->setTangentialStiffness( inArg ); }
+PxReal getPxArticulationJoint_TangentialStiffness( const PxArticulationJoint* inObj ) { return inObj->getTangentialStiffness(); }
+void setPxArticulationJoint_TangentialDamping( PxArticulationJoint* inObj, PxReal inArg){ inObj->setTangentialDamping( inArg ); }
+PxReal getPxArticulationJoint_TangentialDamping( const PxArticulationJoint* inObj ) { return inObj->getTangentialDamping(); }
+void setPxArticulationJoint_SwingLimitContactDistance( PxArticulationJoint* inObj, PxReal inArg){ inObj->setSwingLimitContactDistance( inArg ); }
+PxReal getPxArticulationJoint_SwingLimitContactDistance( const PxArticulationJoint* inObj ) { return inObj->getSwingLimitContactDistance(); }
+void setPxArticulationJoint_SwingLimitEnabled( PxArticulationJoint* inObj, _Bool inArg){ inObj->setSwingLimitEnabled( inArg ); }
+_Bool getPxArticulationJoint_SwingLimitEnabled( const PxArticulationJoint* inObj ) { return inObj->getSwingLimitEnabled(); }
+void setPxArticulationJoint_TwistLimit( PxArticulationJoint* inObj, PxReal inArg0, PxReal inArg1 ) { inObj->setTwistLimit( inArg0, inArg1 ); }
+void getPxArticulationJoint_TwistLimit( const PxArticulationJoint* inObj, PxReal& inArg0, PxReal& inArg1 ) { inObj->getTwistLimit( inArg0, inArg1 ); }
+void setPxArticulationJoint_TwistLimitEnabled( PxArticulationJoint* inObj, _Bool inArg){ inObj->setTwistLimitEnabled( inArg ); }
+_Bool getPxArticulationJoint_TwistLimitEnabled( const PxArticulationJoint* inObj ) { return inObj->getTwistLimitEnabled(); }
+void setPxArticulationJoint_TwistLimitContactDistance( PxArticulationJoint* inObj, PxReal inArg){ inObj->setTwistLimitContactDistance( inArg ); }
+PxReal getPxArticulationJoint_TwistLimitContactDistance( const PxArticulationJoint* inObj ) { return inObj->getTwistLimitContactDistance(); }
+const char * getPxArticulationJoint_ConcreteTypeName( const PxArticulationJoint* inObj ) { return inObj->getConcreteTypeName(); }
+PX_PHYSX_CORE_API PxArticulationJointGeneratedInfo::PxArticulationJointGeneratedInfo()
+	: ParentPose( "ParentPose", setPxArticulationJoint_ParentPose, getPxArticulationJoint_ParentPose)
+	, ChildPose( "ChildPose", setPxArticulationJoint_ChildPose, getPxArticulationJoint_ChildPose)
+	, TargetOrientation( "TargetOrientation", setPxArticulationJoint_TargetOrientation, getPxArticulationJoint_TargetOrientation)
+	, TargetVelocity( "TargetVelocity", setPxArticulationJoint_TargetVelocity, getPxArticulationJoint_TargetVelocity)
+	, DriveType( "DriveType", setPxArticulationJoint_DriveType, getPxArticulationJoint_DriveType)
+	, Stiffness( "Stiffness", setPxArticulationJoint_Stiffness, getPxArticulationJoint_Stiffness)
+	, Damping( "Damping", setPxArticulationJoint_Damping, getPxArticulationJoint_Damping)
+	, InternalCompliance( "InternalCompliance", setPxArticulationJoint_InternalCompliance, getPxArticulationJoint_InternalCompliance)
+	, ExternalCompliance( "ExternalCompliance", setPxArticulationJoint_ExternalCompliance, getPxArticulationJoint_ExternalCompliance)
+	, SwingLimit( "SwingLimit", "yLimit", "zLimit", setPxArticulationJoint_SwingLimit, getPxArticulationJoint_SwingLimit)
+	, TangentialStiffness( "TangentialStiffness", setPxArticulationJoint_TangentialStiffness, getPxArticulationJoint_TangentialStiffness)
+	, TangentialDamping( "TangentialDamping", setPxArticulationJoint_TangentialDamping, getPxArticulationJoint_TangentialDamping)
+	, SwingLimitContactDistance( "SwingLimitContactDistance", setPxArticulationJoint_SwingLimitContactDistance, getPxArticulationJoint_SwingLimitContactDistance)
+	, SwingLimitEnabled( "SwingLimitEnabled", setPxArticulationJoint_SwingLimitEnabled, getPxArticulationJoint_SwingLimitEnabled)
+	, TwistLimit( "TwistLimit", "lower", "upper", setPxArticulationJoint_TwistLimit, getPxArticulationJoint_TwistLimit)
+	, TwistLimitEnabled( "TwistLimitEnabled", setPxArticulationJoint_TwistLimitEnabled, getPxArticulationJoint_TwistLimitEnabled)
+	, TwistLimitContactDistance( "TwistLimitContactDistance", setPxArticulationJoint_TwistLimitContactDistance, getPxArticulationJoint_TwistLimitContactDistance)
+	, ConcreteTypeName( "ConcreteTypeName", getPxArticulationJoint_ConcreteTypeName)
+{}
+PX_PHYSX_CORE_API PxArticulationJointGeneratedValues::PxArticulationJointGeneratedValues( const PxArticulationJoint* inSource )
+		:ParentPose( getPxArticulationJoint_ParentPose( inSource ) )
+		,ChildPose( getPxArticulationJoint_ChildPose( inSource ) )
+		,TargetOrientation( getPxArticulationJoint_TargetOrientation( inSource ) )
+		,TargetVelocity( getPxArticulationJoint_TargetVelocity( inSource ) )
+		,DriveType( getPxArticulationJoint_DriveType( inSource ) )
+		,Stiffness( getPxArticulationJoint_Stiffness( inSource ) )
+		,Damping( getPxArticulationJoint_Damping( inSource ) )
+		,InternalCompliance( getPxArticulationJoint_InternalCompliance( inSource ) )
+		,ExternalCompliance( getPxArticulationJoint_ExternalCompliance( inSource ) )
+		,TangentialStiffness( getPxArticulationJoint_TangentialStiffness( inSource ) )
+		,TangentialDamping( getPxArticulationJoint_TangentialDamping( inSource ) )
+		,SwingLimitContactDistance( getPxArticulationJoint_SwingLimitContactDistance( inSource ) )
+		,SwingLimitEnabled( getPxArticulationJoint_SwingLimitEnabled( inSource ) )
+		,TwistLimitEnabled( getPxArticulationJoint_TwistLimitEnabled( inSource ) )
+		,TwistLimitContactDistance( getPxArticulationJoint_TwistLimitContactDistance( inSource ) )
+		,ConcreteTypeName( getPxArticulationJoint_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+	getPxArticulationJoint_SwingLimit( inSource, SwingLimit[0], SwingLimit[1] );
+	getPxArticulationJoint_TwistLimit( inSource, TwistLimit[0], TwistLimit[1] );
+}
+PxScene * getPxArticulation_Scene( const PxArticulation* inObj ) { return inObj->getScene(); }
+void setPxArticulation_MaxProjectionIterations( PxArticulation* inObj, PxU32 inArg){ inObj->setMaxProjectionIterations( inArg ); }
+PxU32 getPxArticulation_MaxProjectionIterations( const PxArticulation* inObj ) { return inObj->getMaxProjectionIterations(); }
+void setPxArticulation_SeparationTolerance( PxArticulation* inObj, PxReal inArg){ inObj->setSeparationTolerance( inArg ); }
+PxReal getPxArticulation_SeparationTolerance( const PxArticulation* inObj ) { return inObj->getSeparationTolerance(); }
+void setPxArticulation_InternalDriveIterations( PxArticulation* inObj, PxU32 inArg){ inObj->setInternalDriveIterations( inArg ); }
+PxU32 getPxArticulation_InternalDriveIterations( const PxArticulation* inObj ) { return inObj->getInternalDriveIterations(); }
+void setPxArticulation_ExternalDriveIterations( PxArticulation* inObj, PxU32 inArg){ inObj->setExternalDriveIterations( inArg ); }
+PxU32 getPxArticulation_ExternalDriveIterations( const PxArticulation* inObj ) { return inObj->getExternalDriveIterations(); }
+void setPxArticulation_SolverIterationCounts( PxArticulation* inObj, PxU32 inArg0, PxU32 inArg1 ) { inObj->setSolverIterationCounts( inArg0, inArg1 ); }
+void getPxArticulation_SolverIterationCounts( const PxArticulation* inObj, PxU32& inArg0, PxU32& inArg1 ) { inObj->getSolverIterationCounts( inArg0, inArg1 ); }
+_Bool getPxArticulation_IsSleeping( const PxArticulation* inObj ) { return inObj->isSleeping(); }
+void setPxArticulation_SleepThreshold( PxArticulation* inObj, PxReal inArg){ inObj->setSleepThreshold( inArg ); }
+PxReal getPxArticulation_SleepThreshold( const PxArticulation* inObj ) { return inObj->getSleepThreshold(); }
+void setPxArticulation_StabilizationThreshold( PxArticulation* inObj, PxReal inArg){ inObj->setStabilizationThreshold( inArg ); }
+PxReal getPxArticulation_StabilizationThreshold( const PxArticulation* inObj ) { return inObj->getStabilizationThreshold(); }
+void setPxArticulation_WakeCounter( PxArticulation* inObj, PxReal inArg){ inObj->setWakeCounter( inArg ); }
+PxReal getPxArticulation_WakeCounter( const PxArticulation* inObj ) { return inObj->getWakeCounter(); }
+PxU32 getPxArticulation_Links( const PxArticulation* inObj, PxArticulationLink ** outBuffer, PxU32 inBufSize ) { return inObj->getLinks( outBuffer, inBufSize ); }
+PxU32 getNbPxArticulation_Links( const PxArticulation* inObj ) { return inObj->getNbLinks(  ); }
+void setPxArticulation_Name( PxArticulation* inObj, const char * inArg){ inObj->setName( inArg ); }
+const char * getPxArticulation_Name( const PxArticulation* inObj ) { return inObj->getName(); }
+PxAggregate * getPxArticulation_Aggregate( const PxArticulation* inObj ) { return inObj->getAggregate(); }
+const char * getPxArticulation_ConcreteTypeName( const PxArticulation* inObj ) { return inObj->getConcreteTypeName(); }
+inline void * getPxArticulationUserData( const PxArticulation* inOwner ) { return inOwner->userData; }
+inline void setPxArticulationUserData( PxArticulation* inOwner, void * inData) { inOwner->userData = inData; }
+PX_PHYSX_CORE_API PxArticulationGeneratedInfo::PxArticulationGeneratedInfo()
+	: Scene( "Scene", getPxArticulation_Scene)
+	, MaxProjectionIterations( "MaxProjectionIterations", setPxArticulation_MaxProjectionIterations, getPxArticulation_MaxProjectionIterations)
+	, SeparationTolerance( "SeparationTolerance", setPxArticulation_SeparationTolerance, getPxArticulation_SeparationTolerance)
+	, InternalDriveIterations( "InternalDriveIterations", setPxArticulation_InternalDriveIterations, getPxArticulation_InternalDriveIterations)
+	, ExternalDriveIterations( "ExternalDriveIterations", setPxArticulation_ExternalDriveIterations, getPxArticulation_ExternalDriveIterations)
+	, SolverIterationCounts( "SolverIterationCounts", "minPositionIters", "minVelocityIters", setPxArticulation_SolverIterationCounts, getPxArticulation_SolverIterationCounts)
+	, IsSleeping( "IsSleeping", getPxArticulation_IsSleeping)
+	, SleepThreshold( "SleepThreshold", setPxArticulation_SleepThreshold, getPxArticulation_SleepThreshold)
+	, StabilizationThreshold( "StabilizationThreshold", setPxArticulation_StabilizationThreshold, getPxArticulation_StabilizationThreshold)
+	, WakeCounter( "WakeCounter", setPxArticulation_WakeCounter, getPxArticulation_WakeCounter)
+	, Links( "Links", getPxArticulation_Links, getNbPxArticulation_Links )
+	, Name( "Name", setPxArticulation_Name, getPxArticulation_Name)
+	, Aggregate( "Aggregate", getPxArticulation_Aggregate)
+	, ConcreteTypeName( "ConcreteTypeName", getPxArticulation_ConcreteTypeName)
+	, UserData( "UserData", setPxArticulationUserData, getPxArticulationUserData )
+{}
+PX_PHYSX_CORE_API PxArticulationGeneratedValues::PxArticulationGeneratedValues( const PxArticulation* inSource )
+		:Scene( getPxArticulation_Scene( inSource ) )
+		,MaxProjectionIterations( getPxArticulation_MaxProjectionIterations( inSource ) )
+		,SeparationTolerance( getPxArticulation_SeparationTolerance( inSource ) )
+		,InternalDriveIterations( getPxArticulation_InternalDriveIterations( inSource ) )
+		,ExternalDriveIterations( getPxArticulation_ExternalDriveIterations( inSource ) )
+		,IsSleeping( getPxArticulation_IsSleeping( inSource ) )
+		,SleepThreshold( getPxArticulation_SleepThreshold( inSource ) )
+		,StabilizationThreshold( getPxArticulation_StabilizationThreshold( inSource ) )
+		,WakeCounter( getPxArticulation_WakeCounter( inSource ) )
+		,Name( getPxArticulation_Name( inSource ) )
+		,Aggregate( getPxArticulation_Aggregate( inSource ) )
+		,ConcreteTypeName( getPxArticulation_ConcreteTypeName( inSource ) )
+		,UserData( inSource->userData )
+{
+	PX_UNUSED(inSource);
+	getPxArticulation_SolverIterationCounts( inSource, SolverIterationCounts[0], SolverIterationCounts[1] );
+}
+PxU32 getPxAggregate_MaxNbActors( const PxAggregate* inObj ) { return inObj->getMaxNbActors(); }
+PxU32 getPxAggregate_Actors( const PxAggregate* inObj, PxActor ** outBuffer, PxU32 inBufSize ) { return inObj->getActors( outBuffer, inBufSize ); }
+PxU32 getNbPxAggregate_Actors( const PxAggregate* inObj ) { return inObj->getNbActors(  ); }
+_Bool getPxAggregate_SelfCollision( const PxAggregate* inObj ) { return inObj->getSelfCollision(); }
+const char * getPxAggregate_ConcreteTypeName( const PxAggregate* inObj ) { return inObj->getConcreteTypeName(); }
+PX_PHYSX_CORE_API PxAggregateGeneratedInfo::PxAggregateGeneratedInfo()
+	: MaxNbActors( "MaxNbActors", getPxAggregate_MaxNbActors)
+	, Actors( "Actors", getPxAggregate_Actors, getNbPxAggregate_Actors )
+	, SelfCollision( "SelfCollision", getPxAggregate_SelfCollision)
+	, ConcreteTypeName( "ConcreteTypeName", getPxAggregate_ConcreteTypeName)
+{}
+PX_PHYSX_CORE_API PxAggregateGeneratedValues::PxAggregateGeneratedValues( const PxAggregate* inSource )
+		:MaxNbActors( getPxAggregate_MaxNbActors( inSource ) )
+		,SelfCollision( getPxAggregate_SelfCollision( inSource ) )
+		,ConcreteTypeName( getPxAggregate_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+PxScene * getPxConstraint_Scene( const PxConstraint* inObj ) { return inObj->getScene(); }
+void setPxConstraint_Actors( PxConstraint* inObj, PxRigidActor * inArg0, PxRigidActor * inArg1 ) { inObj->setActors( inArg0, inArg1 ); }
+void getPxConstraint_Actors( const PxConstraint* inObj, PxRigidActor *& inArg0, PxRigidActor *& inArg1 ) { inObj->getActors( inArg0, inArg1 ); }
+void setPxConstraint_Flags( PxConstraint* inObj, PxConstraintFlags inArg){ inObj->setFlags( inArg ); }
+PxConstraintFlags getPxConstraint_Flags( const PxConstraint* inObj ) { return inObj->getFlags(); }
+_Bool getPxConstraint_IsValid( const PxConstraint* inObj ) { return inObj->isValid(); }
+void setPxConstraint_BreakForce( PxConstraint* inObj, PxReal inArg0, PxReal inArg1 ) { inObj->setBreakForce( inArg0, inArg1 ); }
+void getPxConstraint_BreakForce( const PxConstraint* inObj, PxReal& inArg0, PxReal& inArg1 ) { inObj->getBreakForce( inArg0, inArg1 ); }
+void setPxConstraint_MinResponseThreshold( PxConstraint* inObj, PxReal inArg){ inObj->setMinResponseThreshold( inArg ); }
+PxReal getPxConstraint_MinResponseThreshold( const PxConstraint* inObj ) { return inObj->getMinResponseThreshold(); }
+const char * getPxConstraint_ConcreteTypeName( const PxConstraint* inObj ) { return inObj->getConcreteTypeName(); }
+PX_PHYSX_CORE_API PxConstraintGeneratedInfo::PxConstraintGeneratedInfo()
+	: Scene( "Scene", getPxConstraint_Scene)
+	, Actors( "Actors", "actor0", "actor1", setPxConstraint_Actors, getPxConstraint_Actors)
+	, Flags( "Flags", setPxConstraint_Flags, getPxConstraint_Flags)
+	, IsValid( "IsValid", getPxConstraint_IsValid)
+	, BreakForce( "BreakForce", "linear", "angular", setPxConstraint_BreakForce, getPxConstraint_BreakForce)
+	, MinResponseThreshold( "MinResponseThreshold", setPxConstraint_MinResponseThreshold, getPxConstraint_MinResponseThreshold)
+	, ConcreteTypeName( "ConcreteTypeName", getPxConstraint_ConcreteTypeName)
+{}
+PX_PHYSX_CORE_API PxConstraintGeneratedValues::PxConstraintGeneratedValues( const PxConstraint* inSource )
+		:Scene( getPxConstraint_Scene( inSource ) )
+		,Flags( getPxConstraint_Flags( inSource ) )
+		,IsValid( getPxConstraint_IsValid( inSource ) )
+		,MinResponseThreshold( getPxConstraint_MinResponseThreshold( inSource ) )
+		,ConcreteTypeName( getPxConstraint_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+	getPxConstraint_Actors( inSource, Actors[0], Actors[1] );
+	getPxConstraint_BreakForce( inSource, BreakForce[0], BreakForce[1] );
+}
+PxGeometryType::Enum getPxShape_GeometryType( const PxShape* inObj ) { return inObj->getGeometryType(); }
+void setPxShape_Geometry( PxShape* inObj, const PxGeometry & inArg){ inObj->setGeometry( inArg ); }
+PxGeometryHolder getPxShape_Geometry( const PxShape* inObj ) { return inObj->getGeometry(); }
+void setPxShape_LocalPose( PxShape* inObj, const PxTransform & inArg){ inObj->setLocalPose( inArg ); }
+PxTransform getPxShape_LocalPose( const PxShape* inObj ) { return inObj->getLocalPose(); }
+void setPxShape_SimulationFilterData( PxShape* inObj, const PxFilterData & inArg){ inObj->setSimulationFilterData( inArg ); }
+PxFilterData getPxShape_SimulationFilterData( const PxShape* inObj ) { return inObj->getSimulationFilterData(); }
+void setPxShape_QueryFilterData( PxShape* inObj, const PxFilterData & inArg){ inObj->setQueryFilterData( inArg ); }
+PxFilterData getPxShape_QueryFilterData( const PxShape* inObj ) { return inObj->getQueryFilterData(); }
+PxU32 getPxShape_Materials( const PxShape* inObj, PxMaterial ** outBuffer, PxU32 inBufSize ) { return inObj->getMaterials( outBuffer, inBufSize ); }
+PxU32 getNbPxShape_Materials( const PxShape* inObj ) { return inObj->getNbMaterials(  ); }
+void setPxShape_ContactOffset( PxShape* inObj, PxReal inArg){ inObj->setContactOffset( inArg ); }
+PxReal getPxShape_ContactOffset( const PxShape* inObj ) { return inObj->getContactOffset(); }
+void setPxShape_RestOffset( PxShape* inObj, PxReal inArg){ inObj->setRestOffset( inArg ); }
+PxReal getPxShape_RestOffset( const PxShape* inObj ) { return inObj->getRestOffset(); }
+void setPxShape_Flags( PxShape* inObj, PxShapeFlags inArg){ inObj->setFlags( inArg ); }
+PxShapeFlags getPxShape_Flags( const PxShape* inObj ) { return inObj->getFlags(); }
+_Bool getPxShape_IsExclusive( const PxShape* inObj ) { return inObj->isExclusive(); }
+void setPxShape_Name( PxShape* inObj, const char * inArg){ inObj->setName( inArg ); }
+const char * getPxShape_Name( const PxShape* inObj ) { return inObj->getName(); }
+const char * getPxShape_ConcreteTypeName( const PxShape* inObj ) { return inObj->getConcreteTypeName(); }
+inline void * getPxShapeUserData( const PxShape* inOwner ) { return inOwner->userData; }
+inline void setPxShapeUserData( PxShape* inOwner, void * inData) { inOwner->userData = inData; }
+PX_PHYSX_CORE_API PxShapeGeneratedInfo::PxShapeGeneratedInfo()
+	: GeometryType( "GeometryType", getPxShape_GeometryType)
+	, Geometry( "Geometry", setPxShape_Geometry, getPxShape_Geometry)
+	, LocalPose( "LocalPose", setPxShape_LocalPose, getPxShape_LocalPose)
+	, SimulationFilterData( "SimulationFilterData", setPxShape_SimulationFilterData, getPxShape_SimulationFilterData)
+	, QueryFilterData( "QueryFilterData", setPxShape_QueryFilterData, getPxShape_QueryFilterData)
+	, Materials( "Materials", getPxShape_Materials, getNbPxShape_Materials )
+	, ContactOffset( "ContactOffset", setPxShape_ContactOffset, getPxShape_ContactOffset)
+	, RestOffset( "RestOffset", setPxShape_RestOffset, getPxShape_RestOffset)
+	, Flags( "Flags", setPxShape_Flags, getPxShape_Flags)
+	, IsExclusive( "IsExclusive", getPxShape_IsExclusive)
+	, Name( "Name", setPxShape_Name, getPxShape_Name)
+	, ConcreteTypeName( "ConcreteTypeName", getPxShape_ConcreteTypeName)
+	, UserData( "UserData", setPxShapeUserData, getPxShapeUserData )
+{}
+PX_PHYSX_CORE_API PxShapeGeneratedValues::PxShapeGeneratedValues( const PxShape* inSource )
+		:GeometryType( getPxShape_GeometryType( inSource ) )
+		,Geometry( getPxShape_Geometry( inSource ) )
+		,LocalPose( getPxShape_LocalPose( inSource ) )
+		,SimulationFilterData( getPxShape_SimulationFilterData( inSource ) )
+		,QueryFilterData( getPxShape_QueryFilterData( inSource ) )
+		,ContactOffset( getPxShape_ContactOffset( inSource ) )
+		,RestOffset( getPxShape_RestOffset( inSource ) )
+		,Flags( getPxShape_Flags( inSource ) )
+		,IsExclusive( getPxShape_IsExclusive( inSource ) )
+		,Name( getPxShape_Name( inSource ) )
+		,ConcreteTypeName( getPxShape_ConcreteTypeName( inSource ) )
+		,UserData( inSource->userData )
+{
+	PX_UNUSED(inSource);
+}
+PxU32 getPxClothFabric_NbParticles( const PxClothFabric* inObj ) { return inObj->getNbParticles(); }
+PxU32 getPxClothFabric_Phases( const PxClothFabric* inObj, PxClothFabricPhase* outBuffer, PxU32 inBufSize ) { return inObj->getPhases( outBuffer, inBufSize ); }
+PxU32 getNbPxClothFabric_Phases( const PxClothFabric* inObj ) { return inObj->getNbPhases(  ); }
+PxU32 getPxClothFabric_Sets( const PxClothFabric* inObj, PxU32* outBuffer, PxU32 inBufSize ) { return inObj->getSets( outBuffer, inBufSize ); }
+PxU32 getNbPxClothFabric_Sets( const PxClothFabric* inObj ) { return inObj->getNbSets(  ); }
+PxU32 getPxClothFabric_ParticleIndices( const PxClothFabric* inObj, PxU32* outBuffer, PxU32 inBufSize ) { return inObj->getParticleIndices( outBuffer, inBufSize ); }
+PxU32 getNbPxClothFabric_ParticleIndices( const PxClothFabric* inObj ) { return inObj->getNbParticleIndices(  ); }
+PxU32 getPxClothFabric_Restvalues( const PxClothFabric* inObj, PxReal* outBuffer, PxU32 inBufSize ) { return inObj->getRestvalues( outBuffer, inBufSize ); }
+PxU32 getNbPxClothFabric_Restvalues( const PxClothFabric* inObj ) { return inObj->getNbRestvalues(  ); }
+PxU32 getPxClothFabric_ReferenceCount( const PxClothFabric* inObj ) { return inObj->getReferenceCount(); }
+const char * getPxClothFabric_ConcreteTypeName( const PxClothFabric* inObj ) { return inObj->getConcreteTypeName(); }
+PX_PHYSX_CORE_API PxClothFabricGeneratedInfo::PxClothFabricGeneratedInfo()
+	: NbParticles( "NbParticles", getPxClothFabric_NbParticles)
+	, Phases( "Phases", getPxClothFabric_Phases, getNbPxClothFabric_Phases )
+	, Sets( "Sets", getPxClothFabric_Sets, getNbPxClothFabric_Sets )
+	, ParticleIndices( "ParticleIndices", getPxClothFabric_ParticleIndices, getNbPxClothFabric_ParticleIndices )
+	, Restvalues( "Restvalues", getPxClothFabric_Restvalues, getNbPxClothFabric_Restvalues )
+	, ReferenceCount( "ReferenceCount", getPxClothFabric_ReferenceCount)
+	, ConcreteTypeName( "ConcreteTypeName", getPxClothFabric_ConcreteTypeName)
+{}
+PX_PHYSX_CORE_API PxClothFabricGeneratedValues::PxClothFabricGeneratedValues( const PxClothFabric* inSource )
+		:NbParticles( getPxClothFabric_NbParticles( inSource ) )
+		,ReferenceCount( getPxClothFabric_ReferenceCount( inSource ) )
+		,ConcreteTypeName( getPxClothFabric_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+PxU32 getPxCloth_NbParticles( const PxCloth* inObj ) { return inObj->getNbParticles(); }
+void setPxCloth_ClothFlags( PxCloth* inObj, PxClothFlags inArg){ inObj->setClothFlags( inArg ); }
+PxClothFlags getPxCloth_ClothFlags( const PxCloth* inObj ) { return inObj->getClothFlags(); }
+void setPxCloth_TargetPose( PxCloth* inObj, const PxTransform & inArg){ inObj->setTargetPose( inArg ); }
+void setPxCloth_GlobalPose( PxCloth* inObj, const PxTransform & inArg){ inObj->setGlobalPose( inArg ); }
+PxTransform getPxCloth_GlobalPose( const PxCloth* inObj ) { return inObj->getGlobalPose(); }
+void setPxCloth_SolverFrequency( PxCloth* inObj, PxReal inArg){ inObj->setSolverFrequency( inArg ); }
+PxReal getPxCloth_SolverFrequency( const PxCloth* inObj ) { return inObj->getSolverFrequency(); }
+PxReal getPxCloth_PreviousTimeStep( const PxCloth* inObj ) { return inObj->getPreviousTimeStep(); }
+void setPxCloth_StiffnessFrequency( PxCloth* inObj, PxReal inArg){ inObj->setStiffnessFrequency( inArg ); }
+PxReal getPxCloth_StiffnessFrequency( const PxCloth* inObj ) { return inObj->getStiffnessFrequency(); }
+void setPxCloth_LinearInertiaScale( PxCloth* inObj, PxVec3 inArg){ inObj->setLinearInertiaScale( inArg ); }
+PxVec3 getPxCloth_LinearInertiaScale( const PxCloth* inObj ) { return inObj->getLinearInertiaScale(); }
+void setPxCloth_AngularInertiaScale( PxCloth* inObj, PxVec3 inArg){ inObj->setAngularInertiaScale( inArg ); }
+PxVec3 getPxCloth_AngularInertiaScale( const PxCloth* inObj ) { return inObj->getAngularInertiaScale(); }
+void setPxCloth_CentrifugalInertiaScale( PxCloth* inObj, PxVec3 inArg){ inObj->setCentrifugalInertiaScale( inArg ); }
+PxVec3 getPxCloth_CentrifugalInertiaScale( const PxCloth* inObj ) { return inObj->getCentrifugalInertiaScale(); }
+void setPxCloth_InertiaScale( PxCloth* inObj, PxReal inArg){ inObj->setInertiaScale( inArg ); }
+void setPxCloth_DampingCoefficient( PxCloth* inObj, PxVec3 inArg){ inObj->setDampingCoefficient( inArg ); }
+PxVec3 getPxCloth_DampingCoefficient( const PxCloth* inObj ) { return inObj->getDampingCoefficient(); }
+void setPxCloth_LinearDragCoefficient( PxCloth* inObj, PxVec3 inArg){ inObj->setLinearDragCoefficient( inArg ); }
+PxVec3 getPxCloth_LinearDragCoefficient( const PxCloth* inObj ) { return inObj->getLinearDragCoefficient(); }
+void setPxCloth_AngularDragCoefficient( PxCloth* inObj, PxVec3 inArg){ inObj->setAngularDragCoefficient( inArg ); }
+PxVec3 getPxCloth_AngularDragCoefficient( const PxCloth* inObj ) { return inObj->getAngularDragCoefficient(); }
+void setPxCloth_DragCoefficient( PxCloth* inObj, PxReal inArg){ inObj->setDragCoefficient( inArg ); }
+void setPxCloth_ExternalAcceleration( PxCloth* inObj, PxVec3 inArg){ inObj->setExternalAcceleration( inArg ); }
+PxVec3 getPxCloth_ExternalAcceleration( const PxCloth* inObj ) { return inObj->getExternalAcceleration(); }
+void setPxCloth_WindVelocity( PxCloth* inObj, PxVec3 inArg){ inObj->setWindVelocity( inArg ); }
+PxVec3 getPxCloth_WindVelocity( const PxCloth* inObj ) { return inObj->getWindVelocity(); }
+void setPxCloth_WindDrag( PxCloth* inObj, PxReal inArg){ inObj->setWindDrag( inArg ); }
+PxReal getPxCloth_WindDrag( const PxCloth* inObj ) { return inObj->getWindDrag(); }
+void setPxCloth_WindLift( PxCloth* inObj, PxReal inArg){ inObj->setWindLift( inArg ); }
+PxReal getPxCloth_WindLift( const PxCloth* inObj ) { return inObj->getWindLift(); }
+void setPxCloth_MotionConstraintConfig( PxCloth* inObj, const PxClothMotionConstraintConfig & inArg){ inObj->setMotionConstraintConfig( inArg ); }
+PxClothMotionConstraintConfig getPxCloth_MotionConstraintConfig( const PxCloth* inObj ) { return inObj->getMotionConstraintConfig(); }
+void setPxCloth_StretchConfig( PxCloth* inObj, PxClothFabricPhaseType::Enum inIndex, PxClothStretchConfig inArg ){ inObj->setStretchConfig( inIndex, inArg ); }
+PxClothStretchConfig getPxCloth_StretchConfig( const PxCloth* inObj, PxClothFabricPhaseType::Enum inIndex ) { return inObj->getStretchConfig( inIndex ); }
+void setPxCloth_TetherConfig( PxCloth* inObj, const PxClothTetherConfig & inArg){ inObj->setTetherConfig( inArg ); }
+PxClothTetherConfig getPxCloth_TetherConfig( const PxCloth* inObj ) { return inObj->getTetherConfig(); }
+void setPxCloth_FrictionCoefficient( PxCloth* inObj, PxReal inArg){ inObj->setFrictionCoefficient( inArg ); }
+PxReal getPxCloth_FrictionCoefficient( const PxCloth* inObj ) { return inObj->getFrictionCoefficient(); }
+void setPxCloth_CollisionMassScale( PxCloth* inObj, PxReal inArg){ inObj->setCollisionMassScale( inArg ); }
+PxReal getPxCloth_CollisionMassScale( const PxCloth* inObj ) { return inObj->getCollisionMassScale(); }
+void setPxCloth_SelfCollisionDistance( PxCloth* inObj, PxReal inArg){ inObj->setSelfCollisionDistance( inArg ); }
+PxReal getPxCloth_SelfCollisionDistance( const PxCloth* inObj ) { return inObj->getSelfCollisionDistance(); }
+void setPxCloth_SelfCollisionStiffness( PxCloth* inObj, PxReal inArg){ inObj->setSelfCollisionStiffness( inArg ); }
+PxReal getPxCloth_SelfCollisionStiffness( const PxCloth* inObj ) { return inObj->getSelfCollisionStiffness(); }
+void setPxCloth_SimulationFilterData( PxCloth* inObj, const PxFilterData & inArg){ inObj->setSimulationFilterData( inArg ); }
+PxFilterData getPxCloth_SimulationFilterData( const PxCloth* inObj ) { return inObj->getSimulationFilterData(); }
+void setPxCloth_ContactOffset( PxCloth* inObj, PxReal inArg){ inObj->setContactOffset( inArg ); }
+PxReal getPxCloth_ContactOffset( const PxCloth* inObj ) { return inObj->getContactOffset(); }
+void setPxCloth_RestOffset( PxCloth* inObj, PxReal inArg){ inObj->setRestOffset( inArg ); }
+PxReal getPxCloth_RestOffset( const PxCloth* inObj ) { return inObj->getRestOffset(); }
+void setPxCloth_SleepLinearVelocity( PxCloth* inObj, PxReal inArg){ inObj->setSleepLinearVelocity( inArg ); }
+PxReal getPxCloth_SleepLinearVelocity( const PxCloth* inObj ) { return inObj->getSleepLinearVelocity(); }
+void setPxCloth_WakeCounter( PxCloth* inObj, PxReal inArg){ inObj->setWakeCounter( inArg ); }
+PxReal getPxCloth_WakeCounter( const PxCloth* inObj ) { return inObj->getWakeCounter(); }
+_Bool getPxCloth_IsSleeping( const PxCloth* inObj ) { return inObj->isSleeping(); }
+const char * getPxCloth_ConcreteTypeName( const PxCloth* inObj ) { return inObj->getConcreteTypeName(); }
+PX_PHYSX_CORE_API PxClothGeneratedInfo::PxClothGeneratedInfo()
+	: NbParticles( "NbParticles", getPxCloth_NbParticles)
+	, ClothFlags( "ClothFlags", setPxCloth_ClothFlags, getPxCloth_ClothFlags)
+	, TargetPose( "TargetPose", setPxCloth_TargetPose)
+	, GlobalPose( "GlobalPose", setPxCloth_GlobalPose, getPxCloth_GlobalPose)
+	, SolverFrequency( "SolverFrequency", setPxCloth_SolverFrequency, getPxCloth_SolverFrequency)
+	, PreviousTimeStep( "PreviousTimeStep", getPxCloth_PreviousTimeStep)
+	, StiffnessFrequency( "StiffnessFrequency", setPxCloth_StiffnessFrequency, getPxCloth_StiffnessFrequency)
+	, LinearInertiaScale( "LinearInertiaScale", setPxCloth_LinearInertiaScale, getPxCloth_LinearInertiaScale)
+	, AngularInertiaScale( "AngularInertiaScale", setPxCloth_AngularInertiaScale, getPxCloth_AngularInertiaScale)
+	, CentrifugalInertiaScale( "CentrifugalInertiaScale", setPxCloth_CentrifugalInertiaScale, getPxCloth_CentrifugalInertiaScale)
+	, InertiaScale( "InertiaScale", setPxCloth_InertiaScale)
+	, DampingCoefficient( "DampingCoefficient", setPxCloth_DampingCoefficient, getPxCloth_DampingCoefficient)
+	, LinearDragCoefficient( "LinearDragCoefficient", setPxCloth_LinearDragCoefficient, getPxCloth_LinearDragCoefficient)
+	, AngularDragCoefficient( "AngularDragCoefficient", setPxCloth_AngularDragCoefficient, getPxCloth_AngularDragCoefficient)
+	, DragCoefficient( "DragCoefficient", setPxCloth_DragCoefficient)
+	, ExternalAcceleration( "ExternalAcceleration", setPxCloth_ExternalAcceleration, getPxCloth_ExternalAcceleration)
+	, WindVelocity( "WindVelocity", setPxCloth_WindVelocity, getPxCloth_WindVelocity)
+	, WindDrag( "WindDrag", setPxCloth_WindDrag, getPxCloth_WindDrag)
+	, WindLift( "WindLift", setPxCloth_WindLift, getPxCloth_WindLift)
+	, MotionConstraintConfig( "MotionConstraintConfig", setPxCloth_MotionConstraintConfig, getPxCloth_MotionConstraintConfig)
+	, StretchConfig( "StretchConfig", setPxCloth_StretchConfig, getPxCloth_StretchConfig)
+	, TetherConfig( "TetherConfig", setPxCloth_TetherConfig, getPxCloth_TetherConfig)
+	, FrictionCoefficient( "FrictionCoefficient", setPxCloth_FrictionCoefficient, getPxCloth_FrictionCoefficient)
+	, CollisionMassScale( "CollisionMassScale", setPxCloth_CollisionMassScale, getPxCloth_CollisionMassScale)
+	, SelfCollisionDistance( "SelfCollisionDistance", setPxCloth_SelfCollisionDistance, getPxCloth_SelfCollisionDistance)
+	, SelfCollisionStiffness( "SelfCollisionStiffness", setPxCloth_SelfCollisionStiffness, getPxCloth_SelfCollisionStiffness)
+	, SimulationFilterData( "SimulationFilterData", setPxCloth_SimulationFilterData, getPxCloth_SimulationFilterData)
+	, ContactOffset( "ContactOffset", setPxCloth_ContactOffset, getPxCloth_ContactOffset)
+	, RestOffset( "RestOffset", setPxCloth_RestOffset, getPxCloth_RestOffset)
+	, SleepLinearVelocity( "SleepLinearVelocity", setPxCloth_SleepLinearVelocity, getPxCloth_SleepLinearVelocity)
+	, WakeCounter( "WakeCounter", setPxCloth_WakeCounter, getPxCloth_WakeCounter)
+	, IsSleeping( "IsSleeping", getPxCloth_IsSleeping)
+	, ConcreteTypeName( "ConcreteTypeName", getPxCloth_ConcreteTypeName)
+{}
+PX_PHYSX_CORE_API PxClothGeneratedValues::PxClothGeneratedValues( const PxCloth* inSource )
+		:PxActorGeneratedValues( inSource )
+		,NbParticles( getPxCloth_NbParticles( inSource ) )
+		,ClothFlags( getPxCloth_ClothFlags( inSource ) )
+		,GlobalPose( getPxCloth_GlobalPose( inSource ) )
+		,SolverFrequency( getPxCloth_SolverFrequency( inSource ) )
+		,PreviousTimeStep( getPxCloth_PreviousTimeStep( inSource ) )
+		,StiffnessFrequency( getPxCloth_StiffnessFrequency( inSource ) )
+		,LinearInertiaScale( getPxCloth_LinearInertiaScale( inSource ) )
+		,AngularInertiaScale( getPxCloth_AngularInertiaScale( inSource ) )
+		,CentrifugalInertiaScale( getPxCloth_CentrifugalInertiaScale( inSource ) )
+		,DampingCoefficient( getPxCloth_DampingCoefficient( inSource ) )
+		,LinearDragCoefficient( getPxCloth_LinearDragCoefficient( inSource ) )
+		,AngularDragCoefficient( getPxCloth_AngularDragCoefficient( inSource ) )
+		,ExternalAcceleration( getPxCloth_ExternalAcceleration( inSource ) )
+		,WindVelocity( getPxCloth_WindVelocity( inSource ) )
+		,WindDrag( getPxCloth_WindDrag( inSource ) )
+		,WindLift( getPxCloth_WindLift( inSource ) )
+		,MotionConstraintConfig( getPxCloth_MotionConstraintConfig( inSource ) )
+		,TetherConfig( getPxCloth_TetherConfig( inSource ) )
+		,FrictionCoefficient( getPxCloth_FrictionCoefficient( inSource ) )
+		,CollisionMassScale( getPxCloth_CollisionMassScale( inSource ) )
+		,SelfCollisionDistance( getPxCloth_SelfCollisionDistance( inSource ) )
+		,SelfCollisionStiffness( getPxCloth_SelfCollisionStiffness( inSource ) )
+		,SimulationFilterData( getPxCloth_SimulationFilterData( inSource ) )
+		,ContactOffset( getPxCloth_ContactOffset( inSource ) )
+		,RestOffset( getPxCloth_RestOffset( inSource ) )
+		,SleepLinearVelocity( getPxCloth_SleepLinearVelocity( inSource ) )
+		,WakeCounter( getPxCloth_WakeCounter( inSource ) )
+		,IsSleeping( getPxCloth_IsSleeping( inSource ) )
+		,ConcreteTypeName( getPxCloth_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+		for ( PxU32 idx = 0; idx < static_cast<PxU32>( physx::PxClothFabricPhaseType::eCOUNT ); ++idx )
+		StretchConfig[idx] = getPxCloth_StretchConfig( inSource, static_cast< PxClothFabricPhaseType::Enum >( idx ) );
+}
+void setPxParticleBase_Damping( PxParticleBase* inObj, PxReal inArg){ inObj->setDamping( inArg ); }
+PxReal getPxParticleBase_Damping( const PxParticleBase* inObj ) { return inObj->getDamping(); }
+void setPxParticleBase_ExternalAcceleration( PxParticleBase* inObj, const PxVec3 & inArg){ inObj->setExternalAcceleration( inArg ); }
+PxVec3 getPxParticleBase_ExternalAcceleration( const PxParticleBase* inObj ) { return inObj->getExternalAcceleration(); }
+void setPxParticleBase_ParticleMass( PxParticleBase* inObj, PxReal inArg){ inObj->setParticleMass( inArg ); }
+PxReal getPxParticleBase_ParticleMass( const PxParticleBase* inObj ) { return inObj->getParticleMass(); }
+void setPxParticleBase_Restitution( PxParticleBase* inObj, PxReal inArg){ inObj->setRestitution( inArg ); }
+PxReal getPxParticleBase_Restitution( const PxParticleBase* inObj ) { return inObj->getRestitution(); }
+void setPxParticleBase_DynamicFriction( PxParticleBase* inObj, PxReal inArg){ inObj->setDynamicFriction( inArg ); }
+PxReal getPxParticleBase_DynamicFriction( const PxParticleBase* inObj ) { return inObj->getDynamicFriction(); }
+void setPxParticleBase_StaticFriction( PxParticleBase* inObj, PxReal inArg){ inObj->setStaticFriction( inArg ); }
+PxReal getPxParticleBase_StaticFriction( const PxParticleBase* inObj ) { return inObj->getStaticFriction(); }
+void setPxParticleBase_SimulationFilterData( PxParticleBase* inObj, const PxFilterData & inArg){ inObj->setSimulationFilterData( inArg ); }
+PxFilterData getPxParticleBase_SimulationFilterData( const PxParticleBase* inObj ) { return inObj->getSimulationFilterData(); }
+PxParticleBaseFlags getPxParticleBase_ParticleBaseFlags( const PxParticleBase* inObj ) { return inObj->getParticleBaseFlags(); }
+PxU32 getPxParticleBase_MaxParticles( const PxParticleBase* inObj ) { return inObj->getMaxParticles(); }
+void setPxParticleBase_MaxMotionDistance( PxParticleBase* inObj, PxReal inArg){ inObj->setMaxMotionDistance( inArg ); }
+PxReal getPxParticleBase_MaxMotionDistance( const PxParticleBase* inObj ) { return inObj->getMaxMotionDistance(); }
+void setPxParticleBase_RestOffset( PxParticleBase* inObj, PxReal inArg){ inObj->setRestOffset( inArg ); }
+PxReal getPxParticleBase_RestOffset( const PxParticleBase* inObj ) { return inObj->getRestOffset(); }
+void setPxParticleBase_ContactOffset( PxParticleBase* inObj, PxReal inArg){ inObj->setContactOffset( inArg ); }
+PxReal getPxParticleBase_ContactOffset( const PxParticleBase* inObj ) { return inObj->getContactOffset(); }
+void setPxParticleBase_GridSize( PxParticleBase* inObj, PxReal inArg){ inObj->setGridSize( inArg ); }
+PxReal getPxParticleBase_GridSize( const PxParticleBase* inObj ) { return inObj->getGridSize(); }
+PxParticleReadDataFlags getPxParticleBase_ParticleReadDataFlags( const PxParticleBase* inObj ) { return inObj->getParticleReadDataFlags(); }
+PX_PHYSX_CORE_API PxParticleBaseGeneratedInfo::PxParticleBaseGeneratedInfo()
+	: Damping( "Damping", setPxParticleBase_Damping, getPxParticleBase_Damping)
+	, ExternalAcceleration( "ExternalAcceleration", setPxParticleBase_ExternalAcceleration, getPxParticleBase_ExternalAcceleration)
+	, ParticleMass( "ParticleMass", setPxParticleBase_ParticleMass, getPxParticleBase_ParticleMass)
+	, Restitution( "Restitution", setPxParticleBase_Restitution, getPxParticleBase_Restitution)
+	, DynamicFriction( "DynamicFriction", setPxParticleBase_DynamicFriction, getPxParticleBase_DynamicFriction)
+	, StaticFriction( "StaticFriction", setPxParticleBase_StaticFriction, getPxParticleBase_StaticFriction)
+	, SimulationFilterData( "SimulationFilterData", setPxParticleBase_SimulationFilterData, getPxParticleBase_SimulationFilterData)
+	, ParticleBaseFlags( "ParticleBaseFlags", getPxParticleBase_ParticleBaseFlags)
+	, MaxParticles( "MaxParticles", getPxParticleBase_MaxParticles)
+	, MaxMotionDistance( "MaxMotionDistance", setPxParticleBase_MaxMotionDistance, getPxParticleBase_MaxMotionDistance)
+	, RestOffset( "RestOffset", setPxParticleBase_RestOffset, getPxParticleBase_RestOffset)
+	, ContactOffset( "ContactOffset", setPxParticleBase_ContactOffset, getPxParticleBase_ContactOffset)
+	, GridSize( "GridSize", setPxParticleBase_GridSize, getPxParticleBase_GridSize)
+	, ParticleReadDataFlags( "ParticleReadDataFlags", getPxParticleBase_ParticleReadDataFlags)
+{}
+PX_PHYSX_CORE_API PxParticleBaseGeneratedValues::PxParticleBaseGeneratedValues( const PxParticleBase* inSource )
+		:PxActorGeneratedValues( inSource )
+		,Damping( getPxParticleBase_Damping( inSource ) )
+		,ExternalAcceleration( getPxParticleBase_ExternalAcceleration( inSource ) )
+		,ParticleMass( getPxParticleBase_ParticleMass( inSource ) )
+		,Restitution( getPxParticleBase_Restitution( inSource ) )
+		,DynamicFriction( getPxParticleBase_DynamicFriction( inSource ) )
+		,StaticFriction( getPxParticleBase_StaticFriction( inSource ) )
+		,SimulationFilterData( getPxParticleBase_SimulationFilterData( inSource ) )
+		,ParticleBaseFlags( getPxParticleBase_ParticleBaseFlags( inSource ) )
+		,MaxParticles( getPxParticleBase_MaxParticles( inSource ) )
+		,MaxMotionDistance( getPxParticleBase_MaxMotionDistance( inSource ) )
+		,RestOffset( getPxParticleBase_RestOffset( inSource ) )
+		,ContactOffset( getPxParticleBase_ContactOffset( inSource ) )
+		,GridSize( getPxParticleBase_GridSize( inSource ) )
+		,ParticleReadDataFlags( getPxParticleBase_ParticleReadDataFlags( inSource ) )
+{
+	PX_UNUSED(inSource);
+	inSource->getProjectionPlane( ProjectionPlane.normal, ProjectionPlane.distance );
+}
+void setPxParticleFluid_Stiffness( PxParticleFluid* inObj, PxReal inArg){ inObj->setStiffness( inArg ); }
+PxReal getPxParticleFluid_Stiffness( const PxParticleFluid* inObj ) { return inObj->getStiffness(); }
+void setPxParticleFluid_Viscosity( PxParticleFluid* inObj, PxReal inArg){ inObj->setViscosity( inArg ); }
+PxReal getPxParticleFluid_Viscosity( const PxParticleFluid* inObj ) { return inObj->getViscosity(); }
+void setPxParticleFluid_RestParticleDistance( PxParticleFluid* inObj, PxReal inArg){ inObj->setRestParticleDistance( inArg ); }
+PxReal getPxParticleFluid_RestParticleDistance( const PxParticleFluid* inObj ) { return inObj->getRestParticleDistance(); }
+const char * getPxParticleFluid_ConcreteTypeName( const PxParticleFluid* inObj ) { return inObj->getConcreteTypeName(); }
+PX_PHYSX_CORE_API PxParticleFluidGeneratedInfo::PxParticleFluidGeneratedInfo()
+	: Stiffness( "Stiffness", setPxParticleFluid_Stiffness, getPxParticleFluid_Stiffness)
+	, Viscosity( "Viscosity", setPxParticleFluid_Viscosity, getPxParticleFluid_Viscosity)
+	, RestParticleDistance( "RestParticleDistance", setPxParticleFluid_RestParticleDistance, getPxParticleFluid_RestParticleDistance)
+	, ConcreteTypeName( "ConcreteTypeName", getPxParticleFluid_ConcreteTypeName)
+{}
+PX_PHYSX_CORE_API PxParticleFluidGeneratedValues::PxParticleFluidGeneratedValues( const PxParticleFluid* inSource )
+		:PxParticleBaseGeneratedValues( inSource )
+		,Stiffness( getPxParticleFluid_Stiffness( inSource ) )
+		,Viscosity( getPxParticleFluid_Viscosity( inSource ) )
+		,RestParticleDistance( getPxParticleFluid_RestParticleDistance( inSource ) )
+		,ConcreteTypeName( getPxParticleFluid_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+const char * getPxParticleSystem_ConcreteTypeName( const PxParticleSystem* inObj ) { return inObj->getConcreteTypeName(); }
+PX_PHYSX_CORE_API PxParticleSystemGeneratedInfo::PxParticleSystemGeneratedInfo()
+	: ConcreteTypeName( "ConcreteTypeName", getPxParticleSystem_ConcreteTypeName)
+{}
+PX_PHYSX_CORE_API PxParticleSystemGeneratedValues::PxParticleSystemGeneratedValues( const PxParticleSystem* inSource )
+		:PxParticleBaseGeneratedValues( inSource )
+		,ConcreteTypeName( getPxParticleSystem_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+PxU32 getPxPruningStructure_RigidActors( const PxPruningStructure* inObj, PxRigidActor ** outBuffer, PxU32 inBufSize ) { return inObj->getRigidActors( outBuffer, inBufSize ); }
+PxU32 getNbPxPruningStructure_RigidActors( const PxPruningStructure* inObj ) { return inObj->getNbRigidActors(  ); }
+const char * getPxPruningStructure_ConcreteTypeName( const PxPruningStructure* inObj ) { return inObj->getConcreteTypeName(); }
+PX_PHYSX_CORE_API PxPruningStructureGeneratedInfo::PxPruningStructureGeneratedInfo()
+	: RigidActors( "RigidActors", getPxPruningStructure_RigidActors, getNbPxPruningStructure_RigidActors )
+	, ConcreteTypeName( "ConcreteTypeName", getPxPruningStructure_ConcreteTypeName)
+{}
+PX_PHYSX_CORE_API PxPruningStructureGeneratedValues::PxPruningStructureGeneratedValues( const PxPruningStructure* inSource )
+		:ConcreteTypeName( getPxPruningStructure_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+_Bool getPxTolerancesScale_IsValid( const PxTolerancesScale* inObj ) { return inObj->isValid(); }
+inline PxReal getPxTolerancesScaleLength( const PxTolerancesScale* inOwner ) { return inOwner->length; }
+inline void setPxTolerancesScaleLength( PxTolerancesScale* inOwner, PxReal inData) { inOwner->length = inData; }
+inline PxReal getPxTolerancesScaleMass( const PxTolerancesScale* inOwner ) { return inOwner->mass; }
+inline void setPxTolerancesScaleMass( PxTolerancesScale* inOwner, PxReal inData) { inOwner->mass = inData; }
+inline PxReal getPxTolerancesScaleSpeed( const PxTolerancesScale* inOwner ) { return inOwner->speed; }
+inline void setPxTolerancesScaleSpeed( PxTolerancesScale* inOwner, PxReal inData) { inOwner->speed = inData; }
+PX_PHYSX_CORE_API PxTolerancesScaleGeneratedInfo::PxTolerancesScaleGeneratedInfo()
+	: IsValid( "IsValid", getPxTolerancesScale_IsValid)
+	, Length( "Length", setPxTolerancesScaleLength, getPxTolerancesScaleLength )
+	, Mass( "Mass", setPxTolerancesScaleMass, getPxTolerancesScaleMass )
+	, Speed( "Speed", setPxTolerancesScaleSpeed, getPxTolerancesScaleSpeed )
+{}
+PX_PHYSX_CORE_API PxTolerancesScaleGeneratedValues::PxTolerancesScaleGeneratedValues( const PxTolerancesScale* inSource )
+		:IsValid( getPxTolerancesScale_IsValid( inSource ) )
+		,Length( inSource->length )
+		,Mass( inSource->mass )
+		,Speed( inSource->speed )
+{
+	PX_UNUSED(inSource);
+}
+PX_PHYSX_CORE_API PxGeometryGeneratedInfo::PxGeometryGeneratedInfo()
+{}
+PX_PHYSX_CORE_API PxGeometryGeneratedValues::PxGeometryGeneratedValues( const PxGeometry* inSource )
+{
+	PX_UNUSED(inSource);
+}
+inline PxVec3 getPxBoxGeometryHalfExtents( const PxBoxGeometry* inOwner ) { return inOwner->halfExtents; }
+inline void setPxBoxGeometryHalfExtents( PxBoxGeometry* inOwner, PxVec3 inData) { inOwner->halfExtents = inData; }
+PX_PHYSX_CORE_API PxBoxGeometryGeneratedInfo::PxBoxGeometryGeneratedInfo()
+	: HalfExtents( "HalfExtents", setPxBoxGeometryHalfExtents, getPxBoxGeometryHalfExtents )
+{}
+PX_PHYSX_CORE_API PxBoxGeometryGeneratedValues::PxBoxGeometryGeneratedValues( const PxBoxGeometry* inSource )
+		:PxGeometryGeneratedValues( inSource )
+		,HalfExtents( inSource->halfExtents )
+{
+	PX_UNUSED(inSource);
+}
+inline PxReal getPxCapsuleGeometryRadius( const PxCapsuleGeometry* inOwner ) { return inOwner->radius; }
+inline void setPxCapsuleGeometryRadius( PxCapsuleGeometry* inOwner, PxReal inData) { inOwner->radius = inData; }
+inline PxReal getPxCapsuleGeometryHalfHeight( const PxCapsuleGeometry* inOwner ) { return inOwner->halfHeight; }
+inline void setPxCapsuleGeometryHalfHeight( PxCapsuleGeometry* inOwner, PxReal inData) { inOwner->halfHeight = inData; }
+PX_PHYSX_CORE_API PxCapsuleGeometryGeneratedInfo::PxCapsuleGeometryGeneratedInfo()
+	: Radius( "Radius", setPxCapsuleGeometryRadius, getPxCapsuleGeometryRadius )
+	, HalfHeight( "HalfHeight", setPxCapsuleGeometryHalfHeight, getPxCapsuleGeometryHalfHeight )
+{}
+PX_PHYSX_CORE_API PxCapsuleGeometryGeneratedValues::PxCapsuleGeometryGeneratedValues( const PxCapsuleGeometry* inSource )
+		:PxGeometryGeneratedValues( inSource )
+		,Radius( inSource->radius )
+		,HalfHeight( inSource->halfHeight )
+{
+	PX_UNUSED(inSource);
+}
+inline PxVec3 getPxMeshScaleScale( const PxMeshScale* inOwner ) { return inOwner->scale; }
+inline void setPxMeshScaleScale( PxMeshScale* inOwner, PxVec3 inData) { inOwner->scale = inData; }
+inline PxQuat getPxMeshScaleRotation( const PxMeshScale* inOwner ) { return inOwner->rotation; }
+inline void setPxMeshScaleRotation( PxMeshScale* inOwner, PxQuat inData) { inOwner->rotation = inData; }
+PX_PHYSX_CORE_API PxMeshScaleGeneratedInfo::PxMeshScaleGeneratedInfo()
+	: Scale( "Scale", setPxMeshScaleScale, getPxMeshScaleScale )
+	, Rotation( "Rotation", setPxMeshScaleRotation, getPxMeshScaleRotation )
+{}
+PX_PHYSX_CORE_API PxMeshScaleGeneratedValues::PxMeshScaleGeneratedValues( const PxMeshScale* inSource )
+		:Scale( inSource->scale )
+		,Rotation( inSource->rotation )
+{
+	PX_UNUSED(inSource);
+}
+inline PxMeshScale getPxConvexMeshGeometryScale( const PxConvexMeshGeometry* inOwner ) { return inOwner->scale; }
+inline void setPxConvexMeshGeometryScale( PxConvexMeshGeometry* inOwner, PxMeshScale inData) { inOwner->scale = inData; }
+inline PxConvexMesh * getPxConvexMeshGeometryConvexMesh( const PxConvexMeshGeometry* inOwner ) { return inOwner->convexMesh; }
+inline void setPxConvexMeshGeometryConvexMesh( PxConvexMeshGeometry* inOwner, PxConvexMesh * inData) { inOwner->convexMesh = inData; }
+inline PxConvexMeshGeometryFlags getPxConvexMeshGeometryMeshFlags( const PxConvexMeshGeometry* inOwner ) { return inOwner->meshFlags; }
+inline void setPxConvexMeshGeometryMeshFlags( PxConvexMeshGeometry* inOwner, PxConvexMeshGeometryFlags inData) { inOwner->meshFlags = inData; }
+PX_PHYSX_CORE_API PxConvexMeshGeometryGeneratedInfo::PxConvexMeshGeometryGeneratedInfo()
+	: Scale( "Scale", setPxConvexMeshGeometryScale, getPxConvexMeshGeometryScale )
+	, ConvexMesh( "ConvexMesh", setPxConvexMeshGeometryConvexMesh, getPxConvexMeshGeometryConvexMesh )
+	, MeshFlags( "MeshFlags", setPxConvexMeshGeometryMeshFlags, getPxConvexMeshGeometryMeshFlags )
+{}
+PX_PHYSX_CORE_API PxConvexMeshGeometryGeneratedValues::PxConvexMeshGeometryGeneratedValues( const PxConvexMeshGeometry* inSource )
+		:PxGeometryGeneratedValues( inSource )
+		,Scale( inSource->scale )
+		,ConvexMesh( inSource->convexMesh )
+		,MeshFlags( inSource->meshFlags )
+{
+	PX_UNUSED(inSource);
+}
+_Bool getPxSphereGeometry_IsValid( const PxSphereGeometry* inObj ) { return inObj->isValid(); }
+inline PxReal getPxSphereGeometryRadius( const PxSphereGeometry* inOwner ) { return inOwner->radius; }
+inline void setPxSphereGeometryRadius( PxSphereGeometry* inOwner, PxReal inData) { inOwner->radius = inData; }
+PX_PHYSX_CORE_API PxSphereGeometryGeneratedInfo::PxSphereGeometryGeneratedInfo()
+	: IsValid( "IsValid", getPxSphereGeometry_IsValid)
+	, Radius( "Radius", setPxSphereGeometryRadius, getPxSphereGeometryRadius )
+{}
+PX_PHYSX_CORE_API PxSphereGeometryGeneratedValues::PxSphereGeometryGeneratedValues( const PxSphereGeometry* inSource )
+		:PxGeometryGeneratedValues( inSource )
+		,IsValid( getPxSphereGeometry_IsValid( inSource ) )
+		,Radius( inSource->radius )
+{
+	PX_UNUSED(inSource);
+}
+PX_PHYSX_CORE_API PxPlaneGeometryGeneratedInfo::PxPlaneGeometryGeneratedInfo()
+{}
+PX_PHYSX_CORE_API PxPlaneGeometryGeneratedValues::PxPlaneGeometryGeneratedValues( const PxPlaneGeometry* inSource )
+		:PxGeometryGeneratedValues( inSource )
+{
+	PX_UNUSED(inSource);
+}
+inline PxMeshScale getPxTriangleMeshGeometryScale( const PxTriangleMeshGeometry* inOwner ) { return inOwner->scale; }
+inline void setPxTriangleMeshGeometryScale( PxTriangleMeshGeometry* inOwner, PxMeshScale inData) { inOwner->scale = inData; }
+inline PxMeshGeometryFlags getPxTriangleMeshGeometryMeshFlags( const PxTriangleMeshGeometry* inOwner ) { return inOwner->meshFlags; }
+inline void setPxTriangleMeshGeometryMeshFlags( PxTriangleMeshGeometry* inOwner, PxMeshGeometryFlags inData) { inOwner->meshFlags = inData; }
+inline PxTriangleMesh * getPxTriangleMeshGeometryTriangleMesh( const PxTriangleMeshGeometry* inOwner ) { return inOwner->triangleMesh; }
+inline void setPxTriangleMeshGeometryTriangleMesh( PxTriangleMeshGeometry* inOwner, PxTriangleMesh * inData) { inOwner->triangleMesh = inData; }
+PX_PHYSX_CORE_API PxTriangleMeshGeometryGeneratedInfo::PxTriangleMeshGeometryGeneratedInfo()
+	: Scale( "Scale", setPxTriangleMeshGeometryScale, getPxTriangleMeshGeometryScale )
+	, MeshFlags( "MeshFlags", setPxTriangleMeshGeometryMeshFlags, getPxTriangleMeshGeometryMeshFlags )
+	, TriangleMesh( "TriangleMesh", setPxTriangleMeshGeometryTriangleMesh, getPxTriangleMeshGeometryTriangleMesh )
+{}
+PX_PHYSX_CORE_API PxTriangleMeshGeometryGeneratedValues::PxTriangleMeshGeometryGeneratedValues( const PxTriangleMeshGeometry* inSource )
+		:PxGeometryGeneratedValues( inSource )
+		,Scale( inSource->scale )
+		,MeshFlags( inSource->meshFlags )
+		,TriangleMesh( inSource->triangleMesh )
+{
+	PX_UNUSED(inSource);
+}
+inline PxHeightField * getPxHeightFieldGeometryHeightField( const PxHeightFieldGeometry* inOwner ) { return inOwner->heightField; }
+inline void setPxHeightFieldGeometryHeightField( PxHeightFieldGeometry* inOwner, PxHeightField * inData) { inOwner->heightField = inData; }
+inline PxReal getPxHeightFieldGeometryHeightScale( const PxHeightFieldGeometry* inOwner ) { return inOwner->heightScale; }
+inline void setPxHeightFieldGeometryHeightScale( PxHeightFieldGeometry* inOwner, PxReal inData) { inOwner->heightScale = inData; }
+inline PxReal getPxHeightFieldGeometryRowScale( const PxHeightFieldGeometry* inOwner ) { return inOwner->rowScale; }
+inline void setPxHeightFieldGeometryRowScale( PxHeightFieldGeometry* inOwner, PxReal inData) { inOwner->rowScale = inData; }
+inline PxReal getPxHeightFieldGeometryColumnScale( const PxHeightFieldGeometry* inOwner ) { return inOwner->columnScale; }
+inline void setPxHeightFieldGeometryColumnScale( PxHeightFieldGeometry* inOwner, PxReal inData) { inOwner->columnScale = inData; }
+inline PxMeshGeometryFlags getPxHeightFieldGeometryHeightFieldFlags( const PxHeightFieldGeometry* inOwner ) { return inOwner->heightFieldFlags; }
+inline void setPxHeightFieldGeometryHeightFieldFlags( PxHeightFieldGeometry* inOwner, PxMeshGeometryFlags inData) { inOwner->heightFieldFlags = inData; }
+PX_PHYSX_CORE_API PxHeightFieldGeometryGeneratedInfo::PxHeightFieldGeometryGeneratedInfo()
+	: HeightField( "HeightField", setPxHeightFieldGeometryHeightField, getPxHeightFieldGeometryHeightField )
+	, HeightScale( "HeightScale", setPxHeightFieldGeometryHeightScale, getPxHeightFieldGeometryHeightScale )
+	, RowScale( "RowScale", setPxHeightFieldGeometryRowScale, getPxHeightFieldGeometryRowScale )
+	, ColumnScale( "ColumnScale", setPxHeightFieldGeometryColumnScale, getPxHeightFieldGeometryColumnScale )
+	, HeightFieldFlags( "HeightFieldFlags", setPxHeightFieldGeometryHeightFieldFlags, getPxHeightFieldGeometryHeightFieldFlags )
+{}
+PX_PHYSX_CORE_API PxHeightFieldGeometryGeneratedValues::PxHeightFieldGeometryGeneratedValues( const PxHeightFieldGeometry* inSource )
+		:PxGeometryGeneratedValues( inSource )
+		,HeightField( inSource->heightField )
+		,HeightScale( inSource->heightScale )
+		,RowScale( inSource->rowScale )
+		,ColumnScale( inSource->columnScale )
+		,HeightFieldFlags( inSource->heightFieldFlags )
+{
+	PX_UNUSED(inSource);
+}
+_Bool getPxHeightFieldDesc_IsValid( const PxHeightFieldDesc* inObj ) { return inObj->isValid(); }
+inline PxU32 getPxHeightFieldDescNbRows( const PxHeightFieldDesc* inOwner ) { return inOwner->nbRows; }
+inline void setPxHeightFieldDescNbRows( PxHeightFieldDesc* inOwner, PxU32 inData) { inOwner->nbRows = inData; }
+inline PxU32 getPxHeightFieldDescNbColumns( const PxHeightFieldDesc* inOwner ) { return inOwner->nbColumns; }
+inline void setPxHeightFieldDescNbColumns( PxHeightFieldDesc* inOwner, PxU32 inData) { inOwner->nbColumns = inData; }
+inline PxHeightFieldFormat::Enum getPxHeightFieldDescFormat( const PxHeightFieldDesc* inOwner ) { return inOwner->format; }
+inline void setPxHeightFieldDescFormat( PxHeightFieldDesc* inOwner, PxHeightFieldFormat::Enum inData) { inOwner->format = inData; }
+inline PxStridedData getPxHeightFieldDescSamples( const PxHeightFieldDesc* inOwner ) { return inOwner->samples; }
+inline void setPxHeightFieldDescSamples( PxHeightFieldDesc* inOwner, PxStridedData inData) { inOwner->samples = inData; }
+inline PxReal getPxHeightFieldDescThickness( const PxHeightFieldDesc* inOwner ) { return inOwner->thickness; }
+inline void setPxHeightFieldDescThickness( PxHeightFieldDesc* inOwner, PxReal inData) { inOwner->thickness = inData; }
+inline PxReal getPxHeightFieldDescConvexEdgeThreshold( const PxHeightFieldDesc* inOwner ) { return inOwner->convexEdgeThreshold; }
+inline void setPxHeightFieldDescConvexEdgeThreshold( PxHeightFieldDesc* inOwner, PxReal inData) { inOwner->convexEdgeThreshold = inData; }
+inline PxHeightFieldFlags getPxHeightFieldDescFlags( const PxHeightFieldDesc* inOwner ) { return inOwner->flags; }
+inline void setPxHeightFieldDescFlags( PxHeightFieldDesc* inOwner, PxHeightFieldFlags inData) { inOwner->flags = inData; }
+PX_PHYSX_CORE_API PxHeightFieldDescGeneratedInfo::PxHeightFieldDescGeneratedInfo()
+	: IsValid( "IsValid", getPxHeightFieldDesc_IsValid)
+	, NbRows( "NbRows", setPxHeightFieldDescNbRows, getPxHeightFieldDescNbRows )
+	, NbColumns( "NbColumns", setPxHeightFieldDescNbColumns, getPxHeightFieldDescNbColumns )
+	, Format( "Format", setPxHeightFieldDescFormat, getPxHeightFieldDescFormat )
+	, Samples( "Samples", setPxHeightFieldDescSamples, getPxHeightFieldDescSamples )
+	, Thickness( "Thickness", setPxHeightFieldDescThickness, getPxHeightFieldDescThickness )
+	, ConvexEdgeThreshold( "ConvexEdgeThreshold", setPxHeightFieldDescConvexEdgeThreshold, getPxHeightFieldDescConvexEdgeThreshold )
+	, Flags( "Flags", setPxHeightFieldDescFlags, getPxHeightFieldDescFlags )
+{}
+PX_PHYSX_CORE_API PxHeightFieldDescGeneratedValues::PxHeightFieldDescGeneratedValues( const PxHeightFieldDesc* inSource )
+		:IsValid( getPxHeightFieldDesc_IsValid( inSource ) )
+		,NbRows( inSource->nbRows )
+		,NbColumns( inSource->nbColumns )
+		,Format( inSource->format )
+		,Samples( inSource->samples )
+		,Thickness( inSource->thickness )
+		,ConvexEdgeThreshold( inSource->convexEdgeThreshold )
+		,Flags( inSource->flags )
+{
+	PX_UNUSED(inSource);
+}
+PxSceneFlags getPxScene_Flags( const PxScene* inObj ) { return inObj->getFlags(); }
+void setPxScene_Limits( PxScene* inObj, const PxSceneLimits & inArg){ inObj->setLimits( inArg ); }
+PxSceneLimits getPxScene_Limits( const PxScene* inObj ) { return inObj->getLimits(); }
+PxU32 getPxScene_Timestamp( const PxScene* inObj ) { return inObj->getTimestamp(); }
+PxU32 getPxScene_Actors( const PxScene* inObj, PxActorTypeFlags inFilter, PxActor ** outBuffer, PxU32 inBufSize ) { return inObj->getActors( inFilter, outBuffer, inBufSize ); }
+PxU32 getNbPxScene_Actors( const PxScene* inObj, PxActorTypeFlags inFilter ) { return inObj->getNbActors( inFilter ); }
+PxU32 getPxScene_Articulations( const PxScene* inObj, PxArticulation ** outBuffer, PxU32 inBufSize ) { return inObj->getArticulations( outBuffer, inBufSize ); }
+PxU32 getNbPxScene_Articulations( const PxScene* inObj ) { return inObj->getNbArticulations(  ); }
+PxU32 getPxScene_Constraints( const PxScene* inObj, PxConstraint ** outBuffer, PxU32 inBufSize ) { return inObj->getConstraints( outBuffer, inBufSize ); }
+PxU32 getNbPxScene_Constraints( const PxScene* inObj ) { return inObj->getNbConstraints(  ); }
+PxU32 getPxScene_Aggregates( const PxScene* inObj, PxAggregate ** outBuffer, PxU32 inBufSize ) { return inObj->getAggregates( outBuffer, inBufSize ); }
+PxU32 getNbPxScene_Aggregates( const PxScene* inObj ) { return inObj->getNbAggregates(  ); }
+PxCpuDispatcher * getPxScene_CpuDispatcher( const PxScene* inObj ) { return inObj->getCpuDispatcher(); }
+PxGpuDispatcher * getPxScene_GpuDispatcher( const PxScene* inObj ) { return inObj->getGpuDispatcher(); }
+void setPxScene_ClothInterCollisionDistance( PxScene* inObj, PxF32 inArg){ inObj->setClothInterCollisionDistance( inArg ); }
+PxF32 getPxScene_ClothInterCollisionDistance( const PxScene* inObj ) { return inObj->getClothInterCollisionDistance(); }
+void setPxScene_ClothInterCollisionStiffness( PxScene* inObj, PxF32 inArg){ inObj->setClothInterCollisionStiffness( inArg ); }
+PxF32 getPxScene_ClothInterCollisionStiffness( const PxScene* inObj ) { return inObj->getClothInterCollisionStiffness(); }
+void setPxScene_ClothInterCollisionNbIterations( PxScene* inObj, PxU32 inArg){ inObj->setClothInterCollisionNbIterations( inArg ); }
+PxU32 getPxScene_ClothInterCollisionNbIterations( const PxScene* inObj ) { return inObj->getClothInterCollisionNbIterations(); }
+void setPxScene_ContactModifyCallback( PxScene* inObj, PxContactModifyCallback * inArg){ inObj->setContactModifyCallback( inArg ); }
+PxContactModifyCallback * getPxScene_ContactModifyCallback( const PxScene* inObj ) { return inObj->getContactModifyCallback(); }
+void setPxScene_CCDContactModifyCallback( PxScene* inObj, PxCCDContactModifyCallback * inArg){ inObj->setCCDContactModifyCallback( inArg ); }
+PxCCDContactModifyCallback * getPxScene_CCDContactModifyCallback( const PxScene* inObj ) { return inObj->getCCDContactModifyCallback(); }
+PxU32 getPxScene_FilterShaderDataSize( const PxScene* inObj ) { return inObj->getFilterShaderDataSize(); }
+PxSimulationFilterShader getPxScene_FilterShader( const PxScene* inObj ) { return inObj->getFilterShader(); }
+PxSimulationFilterCallback * getPxScene_FilterCallback( const PxScene* inObj ) { return inObj->getFilterCallback(); }
+void setPxScene_Gravity( PxScene* inObj, const PxVec3 & inArg){ inObj->setGravity( inArg ); }
+PxVec3 getPxScene_Gravity( const PxScene* inObj ) { return inObj->getGravity(); }
+void setPxScene_BounceThresholdVelocity( PxScene* inObj, const PxReal inArg){ inObj->setBounceThresholdVelocity( inArg ); }
+PxReal getPxScene_BounceThresholdVelocity( const PxScene* inObj ) { return inObj->getBounceThresholdVelocity(); }
+void setPxScene_CCDMaxPasses( PxScene* inObj, PxU32 inArg){ inObj->setCCDMaxPasses( inArg ); }
+PxU32 getPxScene_CCDMaxPasses( const PxScene* inObj ) { return inObj->getCCDMaxPasses(); }
+PxReal getPxScene_FrictionOffsetThreshold( const PxScene* inObj ) { return inObj->getFrictionOffsetThreshold(); }
+void setPxScene_FrictionType( PxScene* inObj, PxFrictionType::Enum inArg){ inObj->setFrictionType( inArg ); }
+PxFrictionType::Enum getPxScene_FrictionType( const PxScene* inObj ) { return inObj->getFrictionType(); }
+void setPxScene_VisualizationCullingBox( PxScene* inObj, const PxBounds3 & inArg){ inObj->setVisualizationCullingBox( inArg ); }
+const PxBounds3 & getPxScene_VisualizationCullingBox( const PxScene* inObj ) { return inObj->getVisualizationCullingBox(); }
+PxPruningStructureType::Enum getPxScene_StaticStructure( const PxScene* inObj ) { return inObj->getStaticStructure(); }
+PxPruningStructureType::Enum getPxScene_DynamicStructure( const PxScene* inObj ) { return inObj->getDynamicStructure(); }
+void setPxScene_DynamicTreeRebuildRateHint( PxScene* inObj, PxU32 inArg){ inObj->setDynamicTreeRebuildRateHint( inArg ); }
+PxU32 getPxScene_DynamicTreeRebuildRateHint( const PxScene* inObj ) { return inObj->getDynamicTreeRebuildRateHint(); }
+PxU32 getPxScene_SceneQueryStaticTimestamp( const PxScene* inObj ) { return inObj->getSceneQueryStaticTimestamp(); }
+PxBroadPhaseType::Enum getPxScene_BroadPhaseType( const PxScene* inObj ) { return inObj->getBroadPhaseType(); }
+PxU32 getPxScene_BroadPhaseRegions( const PxScene* inObj, PxBroadPhaseRegionInfo* outBuffer, PxU32 inBufSize ) { return inObj->getBroadPhaseRegions( outBuffer, inBufSize ); }
+PxU32 getNbPxScene_BroadPhaseRegions( const PxScene* inObj ) { return inObj->getNbBroadPhaseRegions(  ); }
+PxTaskManager * getPxScene_TaskManager( const PxScene* inObj ) { return inObj->getTaskManager(); }
+void setPxScene_NbContactDataBlocks( PxScene* inObj, PxU32 inArg){ inObj->setNbContactDataBlocks( inArg ); }
+PxU32 getPxScene_MaxNbContactDataBlocksUsed( const PxScene* inObj ) { return inObj->getMaxNbContactDataBlocksUsed(); }
+PxU32 getPxScene_ContactReportStreamBufferSize( const PxScene* inObj ) { return inObj->getContactReportStreamBufferSize(); }
+void setPxScene_SolverBatchSize( PxScene* inObj, PxU32 inArg){ inObj->setSolverBatchSize( inArg ); }
+PxU32 getPxScene_SolverBatchSize( const PxScene* inObj ) { return inObj->getSolverBatchSize(); }
+PxReal getPxScene_WakeCounterResetValue( const PxScene* inObj ) { return inObj->getWakeCounterResetValue(); }
+inline void * getPxSceneUserData( const PxScene* inOwner ) { return inOwner->userData; }
+inline void setPxSceneUserData( PxScene* inOwner, void * inData) { inOwner->userData = inData; }
+PX_PHYSX_CORE_API PxSceneGeneratedInfo::PxSceneGeneratedInfo()
+	: Flags( "Flags", getPxScene_Flags)
+	, Limits( "Limits", setPxScene_Limits, getPxScene_Limits)
+	, Timestamp( "Timestamp", getPxScene_Timestamp)
+	, Actors( "Actors", getPxScene_Actors, getNbPxScene_Actors )
+	, Articulations( "Articulations", getPxScene_Articulations, getNbPxScene_Articulations )
+	, Constraints( "Constraints", getPxScene_Constraints, getNbPxScene_Constraints )
+	, Aggregates( "Aggregates", getPxScene_Aggregates, getNbPxScene_Aggregates )
+	, CpuDispatcher( "CpuDispatcher", getPxScene_CpuDispatcher)
+	, GpuDispatcher( "GpuDispatcher", getPxScene_GpuDispatcher)
+	, ClothInterCollisionDistance( "ClothInterCollisionDistance", setPxScene_ClothInterCollisionDistance, getPxScene_ClothInterCollisionDistance)
+	, ClothInterCollisionStiffness( "ClothInterCollisionStiffness", setPxScene_ClothInterCollisionStiffness, getPxScene_ClothInterCollisionStiffness)
+	, ClothInterCollisionNbIterations( "ClothInterCollisionNbIterations", setPxScene_ClothInterCollisionNbIterations, getPxScene_ClothInterCollisionNbIterations)
+	, ContactModifyCallback( "ContactModifyCallback", setPxScene_ContactModifyCallback, getPxScene_ContactModifyCallback)
+	, CCDContactModifyCallback( "CCDContactModifyCallback", setPxScene_CCDContactModifyCallback, getPxScene_CCDContactModifyCallback)
+	, FilterShaderDataSize( "FilterShaderDataSize", getPxScene_FilterShaderDataSize)
+	, FilterShader( "FilterShader", getPxScene_FilterShader)
+	, FilterCallback( "FilterCallback", getPxScene_FilterCallback)
+	, Gravity( "Gravity", setPxScene_Gravity, getPxScene_Gravity)
+	, BounceThresholdVelocity( "BounceThresholdVelocity", setPxScene_BounceThresholdVelocity, getPxScene_BounceThresholdVelocity)
+	, CCDMaxPasses( "CCDMaxPasses", setPxScene_CCDMaxPasses, getPxScene_CCDMaxPasses)
+	, FrictionOffsetThreshold( "FrictionOffsetThreshold", getPxScene_FrictionOffsetThreshold)
+	, FrictionType( "FrictionType", setPxScene_FrictionType, getPxScene_FrictionType)
+	, VisualizationCullingBox( "VisualizationCullingBox", setPxScene_VisualizationCullingBox, getPxScene_VisualizationCullingBox)
+	, StaticStructure( "StaticStructure", getPxScene_StaticStructure)
+	, DynamicStructure( "DynamicStructure", getPxScene_DynamicStructure)
+	, DynamicTreeRebuildRateHint( "DynamicTreeRebuildRateHint", setPxScene_DynamicTreeRebuildRateHint, getPxScene_DynamicTreeRebuildRateHint)
+	, SceneQueryStaticTimestamp( "SceneQueryStaticTimestamp", getPxScene_SceneQueryStaticTimestamp)
+	, BroadPhaseType( "BroadPhaseType", getPxScene_BroadPhaseType)
+	, BroadPhaseRegions( "BroadPhaseRegions", getPxScene_BroadPhaseRegions, getNbPxScene_BroadPhaseRegions )
+	, TaskManager( "TaskManager", getPxScene_TaskManager)
+	, NbContactDataBlocks( "NbContactDataBlocks", setPxScene_NbContactDataBlocks)
+	, MaxNbContactDataBlocksUsed( "MaxNbContactDataBlocksUsed", getPxScene_MaxNbContactDataBlocksUsed)
+	, ContactReportStreamBufferSize( "ContactReportStreamBufferSize", getPxScene_ContactReportStreamBufferSize)
+	, SolverBatchSize( "SolverBatchSize", setPxScene_SolverBatchSize, getPxScene_SolverBatchSize)
+	, WakeCounterResetValue( "WakeCounterResetValue", getPxScene_WakeCounterResetValue)
+	, UserData( "UserData", setPxSceneUserData, getPxSceneUserData )
+{}
+PX_PHYSX_CORE_API PxSceneGeneratedValues::PxSceneGeneratedValues( const PxScene* inSource )
+		:Flags( getPxScene_Flags( inSource ) )
+		,Limits( getPxScene_Limits( inSource ) )
+		,Timestamp( getPxScene_Timestamp( inSource ) )
+		,CpuDispatcher( getPxScene_CpuDispatcher( inSource ) )
+		,GpuDispatcher( getPxScene_GpuDispatcher( inSource ) )
+		,ClothInterCollisionDistance( getPxScene_ClothInterCollisionDistance( inSource ) )
+		,ClothInterCollisionStiffness( getPxScene_ClothInterCollisionStiffness( inSource ) )
+		,ClothInterCollisionNbIterations( getPxScene_ClothInterCollisionNbIterations( inSource ) )
+		,ContactModifyCallback( getPxScene_ContactModifyCallback( inSource ) )
+		,CCDContactModifyCallback( getPxScene_CCDContactModifyCallback( inSource ) )
+		,FilterShaderDataSize( getPxScene_FilterShaderDataSize( inSource ) )
+		,FilterShader( getPxScene_FilterShader( inSource ) )
+		,FilterCallback( getPxScene_FilterCallback( inSource ) )
+		,Gravity( getPxScene_Gravity( inSource ) )
+		,BounceThresholdVelocity( getPxScene_BounceThresholdVelocity( inSource ) )
+		,CCDMaxPasses( getPxScene_CCDMaxPasses( inSource ) )
+		,FrictionOffsetThreshold( getPxScene_FrictionOffsetThreshold( inSource ) )
+		,FrictionType( getPxScene_FrictionType( inSource ) )
+		,VisualizationCullingBox( getPxScene_VisualizationCullingBox( inSource ) )
+		,StaticStructure( getPxScene_StaticStructure( inSource ) )
+		,DynamicStructure( getPxScene_DynamicStructure( inSource ) )
+		,DynamicTreeRebuildRateHint( getPxScene_DynamicTreeRebuildRateHint( inSource ) )
+		,SceneQueryStaticTimestamp( getPxScene_SceneQueryStaticTimestamp( inSource ) )
+		,BroadPhaseType( getPxScene_BroadPhaseType( inSource ) )
+		,TaskManager( getPxScene_TaskManager( inSource ) )
+		,MaxNbContactDataBlocksUsed( getPxScene_MaxNbContactDataBlocksUsed( inSource ) )
+		,ContactReportStreamBufferSize( getPxScene_ContactReportStreamBufferSize( inSource ) )
+		,SolverBatchSize( getPxScene_SolverBatchSize( inSource ) )
+		,WakeCounterResetValue( getPxScene_WakeCounterResetValue( inSource ) )
+		,UserData( inSource->userData )
+{
+	PX_UNUSED(inSource);
+	inSource->getSimulationStatistics(SimulationStatistics);
+}
+inline PxVec3 getPxClothParticlePos( const PxClothParticle* inOwner ) { return inOwner->pos; }
+inline void setPxClothParticlePos( PxClothParticle* inOwner, PxVec3 inData) { inOwner->pos = inData; }
+inline PxReal getPxClothParticleInvWeight( const PxClothParticle* inOwner ) { return inOwner->invWeight; }
+inline void setPxClothParticleInvWeight( PxClothParticle* inOwner, PxReal inData) { inOwner->invWeight = inData; }
+PX_PHYSX_CORE_API PxClothParticleGeneratedInfo::PxClothParticleGeneratedInfo()
+	: Pos( "Pos", setPxClothParticlePos, getPxClothParticlePos )
+	, InvWeight( "InvWeight", setPxClothParticleInvWeight, getPxClothParticleInvWeight )
+{}
+PX_PHYSX_CORE_API PxClothParticleGeneratedValues::PxClothParticleGeneratedValues( const PxClothParticle* inSource )
+		:Pos( inSource->pos )
+		,InvWeight( inSource->invWeight )
+{
+	PX_UNUSED(inSource);
+}
+inline PxClothFabricPhaseType::Enum getPxClothFabricPhasePhaseType( const PxClothFabricPhase* inOwner ) { return inOwner->phaseType; }
+inline void setPxClothFabricPhasePhaseType( PxClothFabricPhase* inOwner, PxClothFabricPhaseType::Enum inData) { inOwner->phaseType = inData; }
+inline PxU32 getPxClothFabricPhaseSetIndex( const PxClothFabricPhase* inOwner ) { return inOwner->setIndex; }
+inline void setPxClothFabricPhaseSetIndex( PxClothFabricPhase* inOwner, PxU32 inData) { inOwner->setIndex = inData; }
+PX_PHYSX_CORE_API PxClothFabricPhaseGeneratedInfo::PxClothFabricPhaseGeneratedInfo()
+	: PhaseType( "PhaseType", setPxClothFabricPhasePhaseType, getPxClothFabricPhasePhaseType )
+	, SetIndex( "SetIndex", setPxClothFabricPhaseSetIndex, getPxClothFabricPhaseSetIndex )
+{}
+PX_PHYSX_CORE_API PxClothFabricPhaseGeneratedValues::PxClothFabricPhaseGeneratedValues( const PxClothFabricPhase* inSource )
+		:PhaseType( inSource->phaseType )
+		,SetIndex( inSource->setIndex )
+{
+	PX_UNUSED(inSource);
+}
+inline PxU32 getPxSceneLimitsMaxNbActors( const PxSceneLimits* inOwner ) { return inOwner->maxNbActors; }
+inline void setPxSceneLimitsMaxNbActors( PxSceneLimits* inOwner, PxU32 inData) { inOwner->maxNbActors = inData; }
+inline PxU32 getPxSceneLimitsMaxNbBodies( const PxSceneLimits* inOwner ) { return inOwner->maxNbBodies; }
+inline void setPxSceneLimitsMaxNbBodies( PxSceneLimits* inOwner, PxU32 inData) { inOwner->maxNbBodies = inData; }
+inline PxU32 getPxSceneLimitsMaxNbStaticShapes( const PxSceneLimits* inOwner ) { return inOwner->maxNbStaticShapes; }
+inline void setPxSceneLimitsMaxNbStaticShapes( PxSceneLimits* inOwner, PxU32 inData) { inOwner->maxNbStaticShapes = inData; }
+inline PxU32 getPxSceneLimitsMaxNbDynamicShapes( const PxSceneLimits* inOwner ) { return inOwner->maxNbDynamicShapes; }
+inline void setPxSceneLimitsMaxNbDynamicShapes( PxSceneLimits* inOwner, PxU32 inData) { inOwner->maxNbDynamicShapes = inData; }
+inline PxU32 getPxSceneLimitsMaxNbAggregates( const PxSceneLimits* inOwner ) { return inOwner->maxNbAggregates; }
+inline void setPxSceneLimitsMaxNbAggregates( PxSceneLimits* inOwner, PxU32 inData) { inOwner->maxNbAggregates = inData; }
+inline PxU32 getPxSceneLimitsMaxNbConstraints( const PxSceneLimits* inOwner ) { return inOwner->maxNbConstraints; }
+inline void setPxSceneLimitsMaxNbConstraints( PxSceneLimits* inOwner, PxU32 inData) { inOwner->maxNbConstraints = inData; }
+inline PxU32 getPxSceneLimitsMaxNbRegions( const PxSceneLimits* inOwner ) { return inOwner->maxNbRegions; }
+inline void setPxSceneLimitsMaxNbRegions( PxSceneLimits* inOwner, PxU32 inData) { inOwner->maxNbRegions = inData; }
+inline PxU32 getPxSceneLimitsMaxNbBroadPhaseOverlaps( const PxSceneLimits* inOwner ) { return inOwner->maxNbBroadPhaseOverlaps; }
+inline void setPxSceneLimitsMaxNbBroadPhaseOverlaps( PxSceneLimits* inOwner, PxU32 inData) { inOwner->maxNbBroadPhaseOverlaps = inData; }
+inline PxU32 getPxSceneLimitsMaxNbObjectsPerRegion( const PxSceneLimits* inOwner ) { return inOwner->maxNbObjectsPerRegion; }
+inline void setPxSceneLimitsMaxNbObjectsPerRegion( PxSceneLimits* inOwner, PxU32 inData) { inOwner->maxNbObjectsPerRegion = inData; }
+PX_PHYSX_CORE_API PxSceneLimitsGeneratedInfo::PxSceneLimitsGeneratedInfo()
+	: MaxNbActors( "MaxNbActors", setPxSceneLimitsMaxNbActors, getPxSceneLimitsMaxNbActors )
+	, MaxNbBodies( "MaxNbBodies", setPxSceneLimitsMaxNbBodies, getPxSceneLimitsMaxNbBodies )
+	, MaxNbStaticShapes( "MaxNbStaticShapes", setPxSceneLimitsMaxNbStaticShapes, getPxSceneLimitsMaxNbStaticShapes )
+	, MaxNbDynamicShapes( "MaxNbDynamicShapes", setPxSceneLimitsMaxNbDynamicShapes, getPxSceneLimitsMaxNbDynamicShapes )
+	, MaxNbAggregates( "MaxNbAggregates", setPxSceneLimitsMaxNbAggregates, getPxSceneLimitsMaxNbAggregates )
+	, MaxNbConstraints( "MaxNbConstraints", setPxSceneLimitsMaxNbConstraints, getPxSceneLimitsMaxNbConstraints )
+	, MaxNbRegions( "MaxNbRegions", setPxSceneLimitsMaxNbRegions, getPxSceneLimitsMaxNbRegions )
+	, MaxNbBroadPhaseOverlaps( "MaxNbBroadPhaseOverlaps", setPxSceneLimitsMaxNbBroadPhaseOverlaps, getPxSceneLimitsMaxNbBroadPhaseOverlaps )
+	, MaxNbObjectsPerRegion( "MaxNbObjectsPerRegion", setPxSceneLimitsMaxNbObjectsPerRegion, getPxSceneLimitsMaxNbObjectsPerRegion )
+{}
+PX_PHYSX_CORE_API PxSceneLimitsGeneratedValues::PxSceneLimitsGeneratedValues( const PxSceneLimits* inSource )
+		:MaxNbActors( inSource->maxNbActors )
+		,MaxNbBodies( inSource->maxNbBodies )
+		,MaxNbStaticShapes( inSource->maxNbStaticShapes )
+		,MaxNbDynamicShapes( inSource->maxNbDynamicShapes )
+		,MaxNbAggregates( inSource->maxNbAggregates )
+		,MaxNbConstraints( inSource->maxNbConstraints )
+		,MaxNbRegions( inSource->maxNbRegions )
+		,MaxNbBroadPhaseOverlaps( inSource->maxNbBroadPhaseOverlaps )
+		,MaxNbObjectsPerRegion( inSource->maxNbObjectsPerRegion )
+{
+	PX_UNUSED(inSource);
+}
+inline PxU32 getPxgDynamicsMemoryConfigConstraintBufferCapacity( const PxgDynamicsMemoryConfig* inOwner ) { return inOwner->constraintBufferCapacity; }
+inline void setPxgDynamicsMemoryConfigConstraintBufferCapacity( PxgDynamicsMemoryConfig* inOwner, PxU32 inData) { inOwner->constraintBufferCapacity = inData; }
+inline PxU32 getPxgDynamicsMemoryConfigContactBufferCapacity( const PxgDynamicsMemoryConfig* inOwner ) { return inOwner->contactBufferCapacity; }
+inline void setPxgDynamicsMemoryConfigContactBufferCapacity( PxgDynamicsMemoryConfig* inOwner, PxU32 inData) { inOwner->contactBufferCapacity = inData; }
+inline PxU32 getPxgDynamicsMemoryConfigTempBufferCapacity( const PxgDynamicsMemoryConfig* inOwner ) { return inOwner->tempBufferCapacity; }
+inline void setPxgDynamicsMemoryConfigTempBufferCapacity( PxgDynamicsMemoryConfig* inOwner, PxU32 inData) { inOwner->tempBufferCapacity = inData; }
+inline PxU32 getPxgDynamicsMemoryConfigContactStreamSize( const PxgDynamicsMemoryConfig* inOwner ) { return inOwner->contactStreamSize; }
+inline void setPxgDynamicsMemoryConfigContactStreamSize( PxgDynamicsMemoryConfig* inOwner, PxU32 inData) { inOwner->contactStreamSize = inData; }
+inline PxU32 getPxgDynamicsMemoryConfigPatchStreamSize( const PxgDynamicsMemoryConfig* inOwner ) { return inOwner->patchStreamSize; }
+inline void setPxgDynamicsMemoryConfigPatchStreamSize( PxgDynamicsMemoryConfig* inOwner, PxU32 inData) { inOwner->patchStreamSize = inData; }
+inline PxU32 getPxgDynamicsMemoryConfigForceStreamCapacity( const PxgDynamicsMemoryConfig* inOwner ) { return inOwner->forceStreamCapacity; }
+inline void setPxgDynamicsMemoryConfigForceStreamCapacity( PxgDynamicsMemoryConfig* inOwner, PxU32 inData) { inOwner->forceStreamCapacity = inData; }
+inline PxU32 getPxgDynamicsMemoryConfigHeapCapacity( const PxgDynamicsMemoryConfig* inOwner ) { return inOwner->heapCapacity; }
+inline void setPxgDynamicsMemoryConfigHeapCapacity( PxgDynamicsMemoryConfig* inOwner, PxU32 inData) { inOwner->heapCapacity = inData; }
+inline PxU32 getPxgDynamicsMemoryConfigFoundLostPairsCapacity( const PxgDynamicsMemoryConfig* inOwner ) { return inOwner->foundLostPairsCapacity; }
+inline void setPxgDynamicsMemoryConfigFoundLostPairsCapacity( PxgDynamicsMemoryConfig* inOwner, PxU32 inData) { inOwner->foundLostPairsCapacity = inData; }
+PX_PHYSX_CORE_API PxgDynamicsMemoryConfigGeneratedInfo::PxgDynamicsMemoryConfigGeneratedInfo()
+	: ConstraintBufferCapacity( "ConstraintBufferCapacity", setPxgDynamicsMemoryConfigConstraintBufferCapacity, getPxgDynamicsMemoryConfigConstraintBufferCapacity )
+	, ContactBufferCapacity( "ContactBufferCapacity", setPxgDynamicsMemoryConfigContactBufferCapacity, getPxgDynamicsMemoryConfigContactBufferCapacity )
+	, TempBufferCapacity( "TempBufferCapacity", setPxgDynamicsMemoryConfigTempBufferCapacity, getPxgDynamicsMemoryConfigTempBufferCapacity )
+	, ContactStreamSize( "ContactStreamSize", setPxgDynamicsMemoryConfigContactStreamSize, getPxgDynamicsMemoryConfigContactStreamSize )
+	, PatchStreamSize( "PatchStreamSize", setPxgDynamicsMemoryConfigPatchStreamSize, getPxgDynamicsMemoryConfigPatchStreamSize )
+	, ForceStreamCapacity( "ForceStreamCapacity", setPxgDynamicsMemoryConfigForceStreamCapacity, getPxgDynamicsMemoryConfigForceStreamCapacity )
+	, HeapCapacity( "HeapCapacity", setPxgDynamicsMemoryConfigHeapCapacity, getPxgDynamicsMemoryConfigHeapCapacity )
+	, FoundLostPairsCapacity( "FoundLostPairsCapacity", setPxgDynamicsMemoryConfigFoundLostPairsCapacity, getPxgDynamicsMemoryConfigFoundLostPairsCapacity )
+{}
+PX_PHYSX_CORE_API PxgDynamicsMemoryConfigGeneratedValues::PxgDynamicsMemoryConfigGeneratedValues( const PxgDynamicsMemoryConfig* inSource )
+		:ConstraintBufferCapacity( inSource->constraintBufferCapacity )
+		,ContactBufferCapacity( inSource->contactBufferCapacity )
+		,TempBufferCapacity( inSource->tempBufferCapacity )
+		,ContactStreamSize( inSource->contactStreamSize )
+		,PatchStreamSize( inSource->patchStreamSize )
+		,ForceStreamCapacity( inSource->forceStreamCapacity )
+		,HeapCapacity( inSource->heapCapacity )
+		,FoundLostPairsCapacity( inSource->foundLostPairsCapacity )
+{
+	PX_UNUSED(inSource);
+}
+void setPxSceneDesc_ToDefault( PxSceneDesc* inObj, const PxTolerancesScale & inArg){ inObj->setToDefault( inArg ); }
+_Bool getPxSceneDesc_IsValid( const PxSceneDesc* inObj ) { return inObj->isValid(); }
+inline PxVec3 getPxSceneDescGravity( const PxSceneDesc* inOwner ) { return inOwner->gravity; }
+inline void setPxSceneDescGravity( PxSceneDesc* inOwner, PxVec3 inData) { inOwner->gravity = inData; }
+inline PxSimulationEventCallback * getPxSceneDescSimulationEventCallback( const PxSceneDesc* inOwner ) { return inOwner->simulationEventCallback; }
+inline void setPxSceneDescSimulationEventCallback( PxSceneDesc* inOwner, PxSimulationEventCallback * inData) { inOwner->simulationEventCallback = inData; }
+inline PxContactModifyCallback * getPxSceneDescContactModifyCallback( const PxSceneDesc* inOwner ) { return inOwner->contactModifyCallback; }
+inline void setPxSceneDescContactModifyCallback( PxSceneDesc* inOwner, PxContactModifyCallback * inData) { inOwner->contactModifyCallback = inData; }
+inline PxCCDContactModifyCallback * getPxSceneDescCcdContactModifyCallback( const PxSceneDesc* inOwner ) { return inOwner->ccdContactModifyCallback; }
+inline void setPxSceneDescCcdContactModifyCallback( PxSceneDesc* inOwner, PxCCDContactModifyCallback * inData) { inOwner->ccdContactModifyCallback = inData; }
+inline const void * getPxSceneDescFilterShaderData( const PxSceneDesc* inOwner ) { return inOwner->filterShaderData; }
+inline void setPxSceneDescFilterShaderData( PxSceneDesc* inOwner, const void * inData) { inOwner->filterShaderData = inData; }
+inline PxU32 getPxSceneDescFilterShaderDataSize( const PxSceneDesc* inOwner ) { return inOwner->filterShaderDataSize; }
+inline void setPxSceneDescFilterShaderDataSize( PxSceneDesc* inOwner, PxU32 inData) { inOwner->filterShaderDataSize = inData; }
+inline PxSimulationFilterShader getPxSceneDescFilterShader( const PxSceneDesc* inOwner ) { return inOwner->filterShader; }
+inline void setPxSceneDescFilterShader( PxSceneDesc* inOwner, PxSimulationFilterShader inData) { inOwner->filterShader = inData; }
+inline PxSimulationFilterCallback * getPxSceneDescFilterCallback( const PxSceneDesc* inOwner ) { return inOwner->filterCallback; }
+inline void setPxSceneDescFilterCallback( PxSceneDesc* inOwner, PxSimulationFilterCallback * inData) { inOwner->filterCallback = inData; }
+inline PxBroadPhaseType::Enum getPxSceneDescBroadPhaseType( const PxSceneDesc* inOwner ) { return inOwner->broadPhaseType; }
+inline void setPxSceneDescBroadPhaseType( PxSceneDesc* inOwner, PxBroadPhaseType::Enum inData) { inOwner->broadPhaseType = inData; }
+inline PxBroadPhaseCallback * getPxSceneDescBroadPhaseCallback( const PxSceneDesc* inOwner ) { return inOwner->broadPhaseCallback; }
+inline void setPxSceneDescBroadPhaseCallback( PxSceneDesc* inOwner, PxBroadPhaseCallback * inData) { inOwner->broadPhaseCallback = inData; }
+inline PxSceneLimits getPxSceneDescLimits( const PxSceneDesc* inOwner ) { return inOwner->limits; }
+inline void setPxSceneDescLimits( PxSceneDesc* inOwner, PxSceneLimits inData) { inOwner->limits = inData; }
+inline PxFrictionType::Enum getPxSceneDescFrictionType( const PxSceneDesc* inOwner ) { return inOwner->frictionType; }
+inline void setPxSceneDescFrictionType( PxSceneDesc* inOwner, PxFrictionType::Enum inData) { inOwner->frictionType = inData; }
+inline PxReal getPxSceneDescBounceThresholdVelocity( const PxSceneDesc* inOwner ) { return inOwner->bounceThresholdVelocity; }
+inline void setPxSceneDescBounceThresholdVelocity( PxSceneDesc* inOwner, PxReal inData) { inOwner->bounceThresholdVelocity = inData; }
+inline PxReal getPxSceneDescFrictionOffsetThreshold( const PxSceneDesc* inOwner ) { return inOwner->frictionOffsetThreshold; }
+inline void setPxSceneDescFrictionOffsetThreshold( PxSceneDesc* inOwner, PxReal inData) { inOwner->frictionOffsetThreshold = inData; }
+inline PxReal getPxSceneDescCcdMaxSeparation( const PxSceneDesc* inOwner ) { return inOwner->ccdMaxSeparation; }
+inline void setPxSceneDescCcdMaxSeparation( PxSceneDesc* inOwner, PxReal inData) { inOwner->ccdMaxSeparation = inData; }
+inline PxSceneFlags getPxSceneDescFlags( const PxSceneDesc* inOwner ) { return inOwner->flags; }
+inline void setPxSceneDescFlags( PxSceneDesc* inOwner, PxSceneFlags inData) { inOwner->flags = inData; }
+inline PxCpuDispatcher * getPxSceneDescCpuDispatcher( const PxSceneDesc* inOwner ) { return inOwner->cpuDispatcher; }
+inline void setPxSceneDescCpuDispatcher( PxSceneDesc* inOwner, PxCpuDispatcher * inData) { inOwner->cpuDispatcher = inData; }
+inline PxGpuDispatcher * getPxSceneDescGpuDispatcher( const PxSceneDesc* inOwner ) { return inOwner->gpuDispatcher; }
+inline void setPxSceneDescGpuDispatcher( PxSceneDesc* inOwner, PxGpuDispatcher * inData) { inOwner->gpuDispatcher = inData; }
+inline PxPruningStructureType::Enum getPxSceneDescStaticStructure( const PxSceneDesc* inOwner ) { return inOwner->staticStructure; }
+inline void setPxSceneDescStaticStructure( PxSceneDesc* inOwner, PxPruningStructureType::Enum inData) { inOwner->staticStructure = inData; }
+inline PxPruningStructureType::Enum getPxSceneDescDynamicStructure( const PxSceneDesc* inOwner ) { return inOwner->dynamicStructure; }
+inline void setPxSceneDescDynamicStructure( PxSceneDesc* inOwner, PxPruningStructureType::Enum inData) { inOwner->dynamicStructure = inData; }
+inline PxU32 getPxSceneDescDynamicTreeRebuildRateHint( const PxSceneDesc* inOwner ) { return inOwner->dynamicTreeRebuildRateHint; }
+inline void setPxSceneDescDynamicTreeRebuildRateHint( PxSceneDesc* inOwner, PxU32 inData) { inOwner->dynamicTreeRebuildRateHint = inData; }
+inline void * getPxSceneDescUserData( const PxSceneDesc* inOwner ) { return inOwner->userData; }
+inline void setPxSceneDescUserData( PxSceneDesc* inOwner, void * inData) { inOwner->userData = inData; }
+inline PxU32 getPxSceneDescSolverBatchSize( const PxSceneDesc* inOwner ) { return inOwner->solverBatchSize; }
+inline void setPxSceneDescSolverBatchSize( PxSceneDesc* inOwner, PxU32 inData) { inOwner->solverBatchSize = inData; }
+inline PxU32 getPxSceneDescNbContactDataBlocks( const PxSceneDesc* inOwner ) { return inOwner->nbContactDataBlocks; }
+inline void setPxSceneDescNbContactDataBlocks( PxSceneDesc* inOwner, PxU32 inData) { inOwner->nbContactDataBlocks = inData; }
+inline PxU32 getPxSceneDescMaxNbContactDataBlocks( const PxSceneDesc* inOwner ) { return inOwner->maxNbContactDataBlocks; }
+inline void setPxSceneDescMaxNbContactDataBlocks( PxSceneDesc* inOwner, PxU32 inData) { inOwner->maxNbContactDataBlocks = inData; }
+inline PxU32 getPxSceneDescContactReportStreamBufferSize( const PxSceneDesc* inOwner ) { return inOwner->contactReportStreamBufferSize; }
+inline void setPxSceneDescContactReportStreamBufferSize( PxSceneDesc* inOwner, PxU32 inData) { inOwner->contactReportStreamBufferSize = inData; }
+inline PxU32 getPxSceneDescCcdMaxPasses( const PxSceneDesc* inOwner ) { return inOwner->ccdMaxPasses; }
+inline void setPxSceneDescCcdMaxPasses( PxSceneDesc* inOwner, PxU32 inData) { inOwner->ccdMaxPasses = inData; }
+inline PxReal getPxSceneDescWakeCounterResetValue( const PxSceneDesc* inOwner ) { return inOwner->wakeCounterResetValue; }
+inline void setPxSceneDescWakeCounterResetValue( PxSceneDesc* inOwner, PxReal inData) { inOwner->wakeCounterResetValue = inData; }
+inline PxBounds3 getPxSceneDescSanityBounds( const PxSceneDesc* inOwner ) { return inOwner->sanityBounds; }
+inline void setPxSceneDescSanityBounds( PxSceneDesc* inOwner, PxBounds3 inData) { inOwner->sanityBounds = inData; }
+inline PxgDynamicsMemoryConfig getPxSceneDescGpuDynamicsConfig( const PxSceneDesc* inOwner ) { return inOwner->gpuDynamicsConfig; }
+inline void setPxSceneDescGpuDynamicsConfig( PxSceneDesc* inOwner, PxgDynamicsMemoryConfig inData) { inOwner->gpuDynamicsConfig = inData; }
+inline PxU32 getPxSceneDescGpuMaxNumPartitions( const PxSceneDesc* inOwner ) { return inOwner->gpuMaxNumPartitions; }
+inline void setPxSceneDescGpuMaxNumPartitions( PxSceneDesc* inOwner, PxU32 inData) { inOwner->gpuMaxNumPartitions = inData; }
+inline PxU32 getPxSceneDescGpuComputeVersion( const PxSceneDesc* inOwner ) { return inOwner->gpuComputeVersion; }
+inline void setPxSceneDescGpuComputeVersion( PxSceneDesc* inOwner, PxU32 inData) { inOwner->gpuComputeVersion = inData; }
+PX_PHYSX_CORE_API PxSceneDescGeneratedInfo::PxSceneDescGeneratedInfo()
+	: ToDefault( "ToDefault", setPxSceneDesc_ToDefault)
+	, IsValid( "IsValid", getPxSceneDesc_IsValid)
+	, Gravity( "Gravity", setPxSceneDescGravity, getPxSceneDescGravity )
+	, SimulationEventCallback( "SimulationEventCallback", setPxSceneDescSimulationEventCallback, getPxSceneDescSimulationEventCallback )
+	, ContactModifyCallback( "ContactModifyCallback", setPxSceneDescContactModifyCallback, getPxSceneDescContactModifyCallback )
+	, CcdContactModifyCallback( "CcdContactModifyCallback", setPxSceneDescCcdContactModifyCallback, getPxSceneDescCcdContactModifyCallback )
+	, FilterShaderData( "FilterShaderData", setPxSceneDescFilterShaderData, getPxSceneDescFilterShaderData )
+	, FilterShaderDataSize( "FilterShaderDataSize", setPxSceneDescFilterShaderDataSize, getPxSceneDescFilterShaderDataSize )
+	, FilterShader( "FilterShader", setPxSceneDescFilterShader, getPxSceneDescFilterShader )
+	, FilterCallback( "FilterCallback", setPxSceneDescFilterCallback, getPxSceneDescFilterCallback )
+	, BroadPhaseType( "BroadPhaseType", setPxSceneDescBroadPhaseType, getPxSceneDescBroadPhaseType )
+	, BroadPhaseCallback( "BroadPhaseCallback", setPxSceneDescBroadPhaseCallback, getPxSceneDescBroadPhaseCallback )
+	, Limits( "Limits", setPxSceneDescLimits, getPxSceneDescLimits )
+	, FrictionType( "FrictionType", setPxSceneDescFrictionType, getPxSceneDescFrictionType )
+	, BounceThresholdVelocity( "BounceThresholdVelocity", setPxSceneDescBounceThresholdVelocity, getPxSceneDescBounceThresholdVelocity )
+	, FrictionOffsetThreshold( "FrictionOffsetThreshold", setPxSceneDescFrictionOffsetThreshold, getPxSceneDescFrictionOffsetThreshold )
+	, CcdMaxSeparation( "CcdMaxSeparation", setPxSceneDescCcdMaxSeparation, getPxSceneDescCcdMaxSeparation )
+	, Flags( "Flags", setPxSceneDescFlags, getPxSceneDescFlags )
+	, CpuDispatcher( "CpuDispatcher", setPxSceneDescCpuDispatcher, getPxSceneDescCpuDispatcher )
+	, GpuDispatcher( "GpuDispatcher", setPxSceneDescGpuDispatcher, getPxSceneDescGpuDispatcher )
+	, StaticStructure( "StaticStructure", setPxSceneDescStaticStructure, getPxSceneDescStaticStructure )
+	, DynamicStructure( "DynamicStructure", setPxSceneDescDynamicStructure, getPxSceneDescDynamicStructure )
+	, DynamicTreeRebuildRateHint( "DynamicTreeRebuildRateHint", setPxSceneDescDynamicTreeRebuildRateHint, getPxSceneDescDynamicTreeRebuildRateHint )
+	, UserData( "UserData", setPxSceneDescUserData, getPxSceneDescUserData )
+	, SolverBatchSize( "SolverBatchSize", setPxSceneDescSolverBatchSize, getPxSceneDescSolverBatchSize )
+	, NbContactDataBlocks( "NbContactDataBlocks", setPxSceneDescNbContactDataBlocks, getPxSceneDescNbContactDataBlocks )
+	, MaxNbContactDataBlocks( "MaxNbContactDataBlocks", setPxSceneDescMaxNbContactDataBlocks, getPxSceneDescMaxNbContactDataBlocks )
+	, ContactReportStreamBufferSize( "ContactReportStreamBufferSize", setPxSceneDescContactReportStreamBufferSize, getPxSceneDescContactReportStreamBufferSize )
+	, CcdMaxPasses( "CcdMaxPasses", setPxSceneDescCcdMaxPasses, getPxSceneDescCcdMaxPasses )
+	, WakeCounterResetValue( "WakeCounterResetValue", setPxSceneDescWakeCounterResetValue, getPxSceneDescWakeCounterResetValue )
+	, SanityBounds( "SanityBounds", setPxSceneDescSanityBounds, getPxSceneDescSanityBounds )
+	, GpuDynamicsConfig( "GpuDynamicsConfig", setPxSceneDescGpuDynamicsConfig, getPxSceneDescGpuDynamicsConfig )
+	, GpuMaxNumPartitions( "GpuMaxNumPartitions", setPxSceneDescGpuMaxNumPartitions, getPxSceneDescGpuMaxNumPartitions )
+	, GpuComputeVersion( "GpuComputeVersion", setPxSceneDescGpuComputeVersion, getPxSceneDescGpuComputeVersion )
+{}
+PX_PHYSX_CORE_API PxSceneDescGeneratedValues::PxSceneDescGeneratedValues( const PxSceneDesc* inSource )
+		:IsValid( getPxSceneDesc_IsValid( inSource ) )
+		,Gravity( inSource->gravity )
+		,SimulationEventCallback( inSource->simulationEventCallback )
+		,ContactModifyCallback( inSource->contactModifyCallback )
+		,CcdContactModifyCallback( inSource->ccdContactModifyCallback )
+		,FilterShaderData( inSource->filterShaderData )
+		,FilterShaderDataSize( inSource->filterShaderDataSize )
+		,FilterShader( inSource->filterShader )
+		,FilterCallback( inSource->filterCallback )
+		,BroadPhaseType( inSource->broadPhaseType )
+		,BroadPhaseCallback( inSource->broadPhaseCallback )
+		,Limits( inSource->limits )
+		,FrictionType( inSource->frictionType )
+		,BounceThresholdVelocity( inSource->bounceThresholdVelocity )
+		,FrictionOffsetThreshold( inSource->frictionOffsetThreshold )
+		,CcdMaxSeparation( inSource->ccdMaxSeparation )
+		,Flags( inSource->flags )
+		,CpuDispatcher( inSource->cpuDispatcher )
+		,GpuDispatcher( inSource->gpuDispatcher )
+		,StaticStructure( inSource->staticStructure )
+		,DynamicStructure( inSource->dynamicStructure )
+		,DynamicTreeRebuildRateHint( inSource->dynamicTreeRebuildRateHint )
+		,UserData( inSource->userData )
+		,SolverBatchSize( inSource->solverBatchSize )
+		,NbContactDataBlocks( inSource->nbContactDataBlocks )
+		,MaxNbContactDataBlocks( inSource->maxNbContactDataBlocks )
+		,ContactReportStreamBufferSize( inSource->contactReportStreamBufferSize )
+		,CcdMaxPasses( inSource->ccdMaxPasses )
+		,WakeCounterResetValue( inSource->wakeCounterResetValue )
+		,SanityBounds( inSource->sanityBounds )
+		,GpuDynamicsConfig( inSource->gpuDynamicsConfig )
+		,GpuMaxNumPartitions( inSource->gpuMaxNumPartitions )
+		,GpuComputeVersion( inSource->gpuComputeVersion )
+{
+	PX_UNUSED(inSource);
+}
+inline PxU32 getPxSimulationStatisticsNbActiveConstraints( const PxSimulationStatistics* inOwner ) { return inOwner->nbActiveConstraints; }
+inline void setPxSimulationStatisticsNbActiveConstraints( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbActiveConstraints = inData; }
+inline PxU32 getPxSimulationStatisticsNbActiveDynamicBodies( const PxSimulationStatistics* inOwner ) { return inOwner->nbActiveDynamicBodies; }
+inline void setPxSimulationStatisticsNbActiveDynamicBodies( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbActiveDynamicBodies = inData; }
+inline PxU32 getPxSimulationStatisticsNbActiveKinematicBodies( const PxSimulationStatistics* inOwner ) { return inOwner->nbActiveKinematicBodies; }
+inline void setPxSimulationStatisticsNbActiveKinematicBodies( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbActiveKinematicBodies = inData; }
+inline PxU32 getPxSimulationStatisticsNbStaticBodies( const PxSimulationStatistics* inOwner ) { return inOwner->nbStaticBodies; }
+inline void setPxSimulationStatisticsNbStaticBodies( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbStaticBodies = inData; }
+inline PxU32 getPxSimulationStatisticsNbDynamicBodies( const PxSimulationStatistics* inOwner ) { return inOwner->nbDynamicBodies; }
+inline void setPxSimulationStatisticsNbDynamicBodies( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbDynamicBodies = inData; }
+inline PxU32 getPxSimulationStatisticsNbAggregates( const PxSimulationStatistics* inOwner ) { return inOwner->nbAggregates; }
+inline void setPxSimulationStatisticsNbAggregates( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbAggregates = inData; }
+inline PxU32 getPxSimulationStatisticsNbArticulations( const PxSimulationStatistics* inOwner ) { return inOwner->nbArticulations; }
+inline void setPxSimulationStatisticsNbArticulations( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbArticulations = inData; }
+inline PxU32 getPxSimulationStatisticsNbAxisSolverConstraints( const PxSimulationStatistics* inOwner ) { return inOwner->nbAxisSolverConstraints; }
+inline void setPxSimulationStatisticsNbAxisSolverConstraints( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbAxisSolverConstraints = inData; }
+inline PxU32 getPxSimulationStatisticsCompressedContactSize( const PxSimulationStatistics* inOwner ) { return inOwner->compressedContactSize; }
+inline void setPxSimulationStatisticsCompressedContactSize( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->compressedContactSize = inData; }
+inline PxU32 getPxSimulationStatisticsRequiredContactConstraintMemory( const PxSimulationStatistics* inOwner ) { return inOwner->requiredContactConstraintMemory; }
+inline void setPxSimulationStatisticsRequiredContactConstraintMemory( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->requiredContactConstraintMemory = inData; }
+inline PxU32 getPxSimulationStatisticsPeakConstraintMemory( const PxSimulationStatistics* inOwner ) { return inOwner->peakConstraintMemory; }
+inline void setPxSimulationStatisticsPeakConstraintMemory( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->peakConstraintMemory = inData; }
+inline PxU32 getPxSimulationStatisticsNbDiscreteContactPairsTotal( const PxSimulationStatistics* inOwner ) { return inOwner->nbDiscreteContactPairsTotal; }
+inline void setPxSimulationStatisticsNbDiscreteContactPairsTotal( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbDiscreteContactPairsTotal = inData; }
+inline PxU32 getPxSimulationStatisticsNbDiscreteContactPairsWithCacheHits( const PxSimulationStatistics* inOwner ) { return inOwner->nbDiscreteContactPairsWithCacheHits; }
+inline void setPxSimulationStatisticsNbDiscreteContactPairsWithCacheHits( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbDiscreteContactPairsWithCacheHits = inData; }
+inline PxU32 getPxSimulationStatisticsNbDiscreteContactPairsWithContacts( const PxSimulationStatistics* inOwner ) { return inOwner->nbDiscreteContactPairsWithContacts; }
+inline void setPxSimulationStatisticsNbDiscreteContactPairsWithContacts( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbDiscreteContactPairsWithContacts = inData; }
+inline PxU32 getPxSimulationStatisticsNbNewPairs( const PxSimulationStatistics* inOwner ) { return inOwner->nbNewPairs; }
+inline void setPxSimulationStatisticsNbNewPairs( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbNewPairs = inData; }
+inline PxU32 getPxSimulationStatisticsNbLostPairs( const PxSimulationStatistics* inOwner ) { return inOwner->nbLostPairs; }
+inline void setPxSimulationStatisticsNbLostPairs( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbLostPairs = inData; }
+inline PxU32 getPxSimulationStatisticsNbNewTouches( const PxSimulationStatistics* inOwner ) { return inOwner->nbNewTouches; }
+inline void setPxSimulationStatisticsNbNewTouches( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbNewTouches = inData; }
+inline PxU32 getPxSimulationStatisticsNbLostTouches( const PxSimulationStatistics* inOwner ) { return inOwner->nbLostTouches; }
+inline void setPxSimulationStatisticsNbLostTouches( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbLostTouches = inData; }
+inline PxU32 getPxSimulationStatisticsNbPartitions( const PxSimulationStatistics* inOwner ) { return inOwner->nbPartitions; }
+inline void setPxSimulationStatisticsNbPartitions( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->nbPartitions = inData; }
+inline PxU32 getPxSimulationStatisticsParticlesGpuMeshCacheSize( const PxSimulationStatistics* inOwner ) { return inOwner->particlesGpuMeshCacheSize; }
+inline void setPxSimulationStatisticsParticlesGpuMeshCacheSize( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->particlesGpuMeshCacheSize = inData; }
+inline PxU32 getPxSimulationStatisticsParticlesGpuMeshCacheUsed( const PxSimulationStatistics* inOwner ) { return inOwner->particlesGpuMeshCacheUsed; }
+inline void setPxSimulationStatisticsParticlesGpuMeshCacheUsed( PxSimulationStatistics* inOwner, PxU32 inData) { inOwner->particlesGpuMeshCacheUsed = inData; }
+inline PxReal getPxSimulationStatisticsParticlesGpuMeshCacheHitrate( const PxSimulationStatistics* inOwner ) { return inOwner->particlesGpuMeshCacheHitrate; }
+inline void setPxSimulationStatisticsParticlesGpuMeshCacheHitrate( PxSimulationStatistics* inOwner, PxReal inData) { inOwner->particlesGpuMeshCacheHitrate = inData; }
+PX_PHYSX_CORE_API PxSimulationStatisticsGeneratedInfo::PxSimulationStatisticsGeneratedInfo()
+	: NbActiveConstraints( "NbActiveConstraints", setPxSimulationStatisticsNbActiveConstraints, getPxSimulationStatisticsNbActiveConstraints )
+	, NbActiveDynamicBodies( "NbActiveDynamicBodies", setPxSimulationStatisticsNbActiveDynamicBodies, getPxSimulationStatisticsNbActiveDynamicBodies )
+	, NbActiveKinematicBodies( "NbActiveKinematicBodies", setPxSimulationStatisticsNbActiveKinematicBodies, getPxSimulationStatisticsNbActiveKinematicBodies )
+	, NbStaticBodies( "NbStaticBodies", setPxSimulationStatisticsNbStaticBodies, getPxSimulationStatisticsNbStaticBodies )
+	, NbDynamicBodies( "NbDynamicBodies", setPxSimulationStatisticsNbDynamicBodies, getPxSimulationStatisticsNbDynamicBodies )
+	, NbAggregates( "NbAggregates", setPxSimulationStatisticsNbAggregates, getPxSimulationStatisticsNbAggregates )
+	, NbArticulations( "NbArticulations", setPxSimulationStatisticsNbArticulations, getPxSimulationStatisticsNbArticulations )
+	, NbAxisSolverConstraints( "NbAxisSolverConstraints", setPxSimulationStatisticsNbAxisSolverConstraints, getPxSimulationStatisticsNbAxisSolverConstraints )
+	, CompressedContactSize( "CompressedContactSize", setPxSimulationStatisticsCompressedContactSize, getPxSimulationStatisticsCompressedContactSize )
+	, RequiredContactConstraintMemory( "RequiredContactConstraintMemory", setPxSimulationStatisticsRequiredContactConstraintMemory, getPxSimulationStatisticsRequiredContactConstraintMemory )
+	, PeakConstraintMemory( "PeakConstraintMemory", setPxSimulationStatisticsPeakConstraintMemory, getPxSimulationStatisticsPeakConstraintMemory )
+	, NbDiscreteContactPairsTotal( "NbDiscreteContactPairsTotal", setPxSimulationStatisticsNbDiscreteContactPairsTotal, getPxSimulationStatisticsNbDiscreteContactPairsTotal )
+	, NbDiscreteContactPairsWithCacheHits( "NbDiscreteContactPairsWithCacheHits", setPxSimulationStatisticsNbDiscreteContactPairsWithCacheHits, getPxSimulationStatisticsNbDiscreteContactPairsWithCacheHits )
+	, NbDiscreteContactPairsWithContacts( "NbDiscreteContactPairsWithContacts", setPxSimulationStatisticsNbDiscreteContactPairsWithContacts, getPxSimulationStatisticsNbDiscreteContactPairsWithContacts )
+	, NbNewPairs( "NbNewPairs", setPxSimulationStatisticsNbNewPairs, getPxSimulationStatisticsNbNewPairs )
+	, NbLostPairs( "NbLostPairs", setPxSimulationStatisticsNbLostPairs, getPxSimulationStatisticsNbLostPairs )
+	, NbNewTouches( "NbNewTouches", setPxSimulationStatisticsNbNewTouches, getPxSimulationStatisticsNbNewTouches )
+	, NbLostTouches( "NbLostTouches", setPxSimulationStatisticsNbLostTouches, getPxSimulationStatisticsNbLostTouches )
+	, NbPartitions( "NbPartitions", setPxSimulationStatisticsNbPartitions, getPxSimulationStatisticsNbPartitions )
+	, ParticlesGpuMeshCacheSize( "ParticlesGpuMeshCacheSize", setPxSimulationStatisticsParticlesGpuMeshCacheSize, getPxSimulationStatisticsParticlesGpuMeshCacheSize )
+	, ParticlesGpuMeshCacheUsed( "ParticlesGpuMeshCacheUsed", setPxSimulationStatisticsParticlesGpuMeshCacheUsed, getPxSimulationStatisticsParticlesGpuMeshCacheUsed )
+	, ParticlesGpuMeshCacheHitrate( "ParticlesGpuMeshCacheHitrate", setPxSimulationStatisticsParticlesGpuMeshCacheHitrate, getPxSimulationStatisticsParticlesGpuMeshCacheHitrate )
+{}
+PX_PHYSX_CORE_API PxSimulationStatisticsGeneratedValues::PxSimulationStatisticsGeneratedValues( const PxSimulationStatistics* inSource )
+		:NbActiveConstraints( inSource->nbActiveConstraints )
+		,NbActiveDynamicBodies( inSource->nbActiveDynamicBodies )
+		,NbActiveKinematicBodies( inSource->nbActiveKinematicBodies )
+		,NbStaticBodies( inSource->nbStaticBodies )
+		,NbDynamicBodies( inSource->nbDynamicBodies )
+		,NbAggregates( inSource->nbAggregates )
+		,NbArticulations( inSource->nbArticulations )
+		,NbAxisSolverConstraints( inSource->nbAxisSolverConstraints )
+		,CompressedContactSize( inSource->compressedContactSize )
+		,RequiredContactConstraintMemory( inSource->requiredContactConstraintMemory )
+		,PeakConstraintMemory( inSource->peakConstraintMemory )
+		,NbDiscreteContactPairsTotal( inSource->nbDiscreteContactPairsTotal )
+		,NbDiscreteContactPairsWithCacheHits( inSource->nbDiscreteContactPairsWithCacheHits )
+		,NbDiscreteContactPairsWithContacts( inSource->nbDiscreteContactPairsWithContacts )
+		,NbNewPairs( inSource->nbNewPairs )
+		,NbLostPairs( inSource->nbLostPairs )
+		,NbNewTouches( inSource->nbNewTouches )
+		,NbLostTouches( inSource->nbLostTouches )
+		,NbPartitions( inSource->nbPartitions )
+		,ParticlesGpuMeshCacheSize( inSource->particlesGpuMeshCacheSize )
+		,ParticlesGpuMeshCacheUsed( inSource->particlesGpuMeshCacheUsed )
+		,ParticlesGpuMeshCacheHitrate( inSource->particlesGpuMeshCacheHitrate )
+{
+	PX_UNUSED(inSource);
+	PxMemCopy( NbDiscreteContactPairs, inSource->nbDiscreteContactPairs, sizeof( NbDiscreteContactPairs ) );
+	PxMemCopy( NbModifiedContactPairs, inSource->nbModifiedContactPairs, sizeof( NbModifiedContactPairs ) );
+	PxMemCopy( NbCCDPairs, inSource->nbCCDPairs, sizeof( NbCCDPairs ) );
+	PxMemCopy( NbTriggerPairs, inSource->nbTriggerPairs, sizeof( NbTriggerPairs ) );
+	PxMemCopy( NbBroadPhaseAdds, inSource->nbBroadPhaseAdds, sizeof( NbBroadPhaseAdds ) );
+	PxMemCopy( NbBroadPhaseRemoves, inSource->nbBroadPhaseRemoves, sizeof( NbBroadPhaseRemoves ) );
+	PxMemCopy( NbShapes, inSource->nbShapes, sizeof( NbShapes ) );
+}
+PX_PHYSX_CORE_API PxLockedDataGeneratedInfo::PxLockedDataGeneratedInfo()
+{}
+PX_PHYSX_CORE_API PxLockedDataGeneratedValues::PxLockedDataGeneratedValues( const PxLockedData* inSource )
+{
+	PX_UNUSED(inSource);
+}
+inline PxU32 getPxParticleReadDataNbValidParticles( const PxParticleReadData* inOwner ) { return inOwner->nbValidParticles; }
+inline void setPxParticleReadDataNbValidParticles( PxParticleReadData* inOwner, PxU32 inData) { inOwner->nbValidParticles = inData; }
+inline PxU32 getPxParticleReadDataValidParticleRange( const PxParticleReadData* inOwner ) { return inOwner->validParticleRange; }
+inline void setPxParticleReadDataValidParticleRange( PxParticleReadData* inOwner, PxU32 inData) { inOwner->validParticleRange = inData; }
+inline const PxU32 * getPxParticleReadDataValidParticleBitmap( const PxParticleReadData* inOwner ) { return inOwner->validParticleBitmap; }
+inline void setPxParticleReadDataValidParticleBitmap( PxParticleReadData* inOwner, const PxU32 * inData) { inOwner->validParticleBitmap = inData; }
+inline PxStrideIterator<const PxVec3> getPxParticleReadDataPositionBuffer( const PxParticleReadData* inOwner ) { return inOwner->positionBuffer; }
+inline void setPxParticleReadDataPositionBuffer( PxParticleReadData* inOwner, PxStrideIterator<const PxVec3> inData) { inOwner->positionBuffer = inData; }
+inline PxStrideIterator<const PxVec3> getPxParticleReadDataVelocityBuffer( const PxParticleReadData* inOwner ) { return inOwner->velocityBuffer; }
+inline void setPxParticleReadDataVelocityBuffer( PxParticleReadData* inOwner, PxStrideIterator<const PxVec3> inData) { inOwner->velocityBuffer = inData; }
+inline PxStrideIterator<const PxF32> getPxParticleReadDataRestOffsetBuffer( const PxParticleReadData* inOwner ) { return inOwner->restOffsetBuffer; }
+inline void setPxParticleReadDataRestOffsetBuffer( PxParticleReadData* inOwner, PxStrideIterator<const PxF32> inData) { inOwner->restOffsetBuffer = inData; }
+inline PxStrideIterator<const PxParticleFlags> getPxParticleReadDataFlagsBuffer( const PxParticleReadData* inOwner ) { return inOwner->flagsBuffer; }
+inline void setPxParticleReadDataFlagsBuffer( PxParticleReadData* inOwner, PxStrideIterator<const PxParticleFlags> inData) { inOwner->flagsBuffer = inData; }
+inline PxStrideIterator<const PxVec3> getPxParticleReadDataCollisionNormalBuffer( const PxParticleReadData* inOwner ) { return inOwner->collisionNormalBuffer; }
+inline void setPxParticleReadDataCollisionNormalBuffer( PxParticleReadData* inOwner, PxStrideIterator<const PxVec3> inData) { inOwner->collisionNormalBuffer = inData; }
+inline PxStrideIterator<const PxVec3> getPxParticleReadDataCollisionVelocityBuffer( const PxParticleReadData* inOwner ) { return inOwner->collisionVelocityBuffer; }
+inline void setPxParticleReadDataCollisionVelocityBuffer( PxParticleReadData* inOwner, PxStrideIterator<const PxVec3> inData) { inOwner->collisionVelocityBuffer = inData; }
+PX_PHYSX_CORE_API PxParticleReadDataGeneratedInfo::PxParticleReadDataGeneratedInfo()
+	: NbValidParticles( "NbValidParticles", setPxParticleReadDataNbValidParticles, getPxParticleReadDataNbValidParticles )
+	, ValidParticleRange( "ValidParticleRange", setPxParticleReadDataValidParticleRange, getPxParticleReadDataValidParticleRange )
+	, ValidParticleBitmap( "ValidParticleBitmap", setPxParticleReadDataValidParticleBitmap, getPxParticleReadDataValidParticleBitmap )
+	, PositionBuffer( "PositionBuffer", setPxParticleReadDataPositionBuffer, getPxParticleReadDataPositionBuffer )
+	, VelocityBuffer( "VelocityBuffer", setPxParticleReadDataVelocityBuffer, getPxParticleReadDataVelocityBuffer )
+	, RestOffsetBuffer( "RestOffsetBuffer", setPxParticleReadDataRestOffsetBuffer, getPxParticleReadDataRestOffsetBuffer )
+	, FlagsBuffer( "FlagsBuffer", setPxParticleReadDataFlagsBuffer, getPxParticleReadDataFlagsBuffer )
+	, CollisionNormalBuffer( "CollisionNormalBuffer", setPxParticleReadDataCollisionNormalBuffer, getPxParticleReadDataCollisionNormalBuffer )
+	, CollisionVelocityBuffer( "CollisionVelocityBuffer", setPxParticleReadDataCollisionVelocityBuffer, getPxParticleReadDataCollisionVelocityBuffer )
+{}
+PX_PHYSX_CORE_API PxParticleReadDataGeneratedValues::PxParticleReadDataGeneratedValues( const PxParticleReadData* inSource )
+		:PxLockedDataGeneratedValues( inSource )
+		,NbValidParticles( inSource->nbValidParticles )
+		,ValidParticleRange( inSource->validParticleRange )
+		,ValidParticleBitmap( inSource->validParticleBitmap )
+		,PositionBuffer( inSource->positionBuffer )
+		,VelocityBuffer( inSource->velocityBuffer )
+		,RestOffsetBuffer( inSource->restOffsetBuffer )
+		,FlagsBuffer( inSource->flagsBuffer )
+		,CollisionNormalBuffer( inSource->collisionNormalBuffer )
+		,CollisionVelocityBuffer( inSource->collisionVelocityBuffer )
+{
+	PX_UNUSED(inSource);
+}
+inline PxReal getPxClothStretchConfigStiffness( const PxClothStretchConfig* inOwner ) { return inOwner->stiffness; }
+inline void setPxClothStretchConfigStiffness( PxClothStretchConfig* inOwner, PxReal inData) { inOwner->stiffness = inData; }
+inline PxReal getPxClothStretchConfigStiffnessMultiplier( const PxClothStretchConfig* inOwner ) { return inOwner->stiffnessMultiplier; }
+inline void setPxClothStretchConfigStiffnessMultiplier( PxClothStretchConfig* inOwner, PxReal inData) { inOwner->stiffnessMultiplier = inData; }
+inline PxReal getPxClothStretchConfigCompressionLimit( const PxClothStretchConfig* inOwner ) { return inOwner->compressionLimit; }
+inline void setPxClothStretchConfigCompressionLimit( PxClothStretchConfig* inOwner, PxReal inData) { inOwner->compressionLimit = inData; }
+inline PxReal getPxClothStretchConfigStretchLimit( const PxClothStretchConfig* inOwner ) { return inOwner->stretchLimit; }
+inline void setPxClothStretchConfigStretchLimit( PxClothStretchConfig* inOwner, PxReal inData) { inOwner->stretchLimit = inData; }
+PX_PHYSX_CORE_API PxClothStretchConfigGeneratedInfo::PxClothStretchConfigGeneratedInfo()
+	: Stiffness( "Stiffness", setPxClothStretchConfigStiffness, getPxClothStretchConfigStiffness )
+	, StiffnessMultiplier( "StiffnessMultiplier", setPxClothStretchConfigStiffnessMultiplier, getPxClothStretchConfigStiffnessMultiplier )
+	, CompressionLimit( "CompressionLimit", setPxClothStretchConfigCompressionLimit, getPxClothStretchConfigCompressionLimit )
+	, StretchLimit( "StretchLimit", setPxClothStretchConfigStretchLimit, getPxClothStretchConfigStretchLimit )
+{}
+PX_PHYSX_CORE_API PxClothStretchConfigGeneratedValues::PxClothStretchConfigGeneratedValues( const PxClothStretchConfig* inSource )
+		:Stiffness( inSource->stiffness )
+		,StiffnessMultiplier( inSource->stiffnessMultiplier )
+		,CompressionLimit( inSource->compressionLimit )
+		,StretchLimit( inSource->stretchLimit )
+{
+	PX_UNUSED(inSource);
+}
+inline PxReal getPxClothTetherConfigStiffness( const PxClothTetherConfig* inOwner ) { return inOwner->stiffness; }
+inline void setPxClothTetherConfigStiffness( PxClothTetherConfig* inOwner, PxReal inData) { inOwner->stiffness = inData; }
+inline PxReal getPxClothTetherConfigStretchLimit( const PxClothTetherConfig* inOwner ) { return inOwner->stretchLimit; }
+inline void setPxClothTetherConfigStretchLimit( PxClothTetherConfig* inOwner, PxReal inData) { inOwner->stretchLimit = inData; }
+PX_PHYSX_CORE_API PxClothTetherConfigGeneratedInfo::PxClothTetherConfigGeneratedInfo()
+	: Stiffness( "Stiffness", setPxClothTetherConfigStiffness, getPxClothTetherConfigStiffness )
+	, StretchLimit( "StretchLimit", setPxClothTetherConfigStretchLimit, getPxClothTetherConfigStretchLimit )
+{}
+PX_PHYSX_CORE_API PxClothTetherConfigGeneratedValues::PxClothTetherConfigGeneratedValues( const PxClothTetherConfig* inSource )
+		:Stiffness( inSource->stiffness )
+		,StretchLimit( inSource->stretchLimit )
+{
+	PX_UNUSED(inSource);
+}
+inline PxReal getPxClothMotionConstraintConfigScale( const PxClothMotionConstraintConfig* inOwner ) { return inOwner->scale; }
+inline void setPxClothMotionConstraintConfigScale( PxClothMotionConstraintConfig* inOwner, PxReal inData) { inOwner->scale = inData; }
+inline PxReal getPxClothMotionConstraintConfigBias( const PxClothMotionConstraintConfig* inOwner ) { return inOwner->bias; }
+inline void setPxClothMotionConstraintConfigBias( PxClothMotionConstraintConfig* inOwner, PxReal inData) { inOwner->bias = inData; }
+inline PxReal getPxClothMotionConstraintConfigStiffness( const PxClothMotionConstraintConfig* inOwner ) { return inOwner->stiffness; }
+inline void setPxClothMotionConstraintConfigStiffness( PxClothMotionConstraintConfig* inOwner, PxReal inData) { inOwner->stiffness = inData; }
+PX_PHYSX_CORE_API PxClothMotionConstraintConfigGeneratedInfo::PxClothMotionConstraintConfigGeneratedInfo()
+	: Scale( "Scale", setPxClothMotionConstraintConfigScale, getPxClothMotionConstraintConfigScale )
+	, Bias( "Bias", setPxClothMotionConstraintConfigBias, getPxClothMotionConstraintConfigBias )
+	, Stiffness( "Stiffness", setPxClothMotionConstraintConfigStiffness, getPxClothMotionConstraintConfigStiffness )
+{}
+PX_PHYSX_CORE_API PxClothMotionConstraintConfigGeneratedValues::PxClothMotionConstraintConfigGeneratedValues( const PxClothMotionConstraintConfig* inSource )
+		:Scale( inSource->scale )
+		,Bias( inSource->bias )
+		,Stiffness( inSource->stiffness )
+{
+	PX_UNUSED(inSource);
+}
+inline PxClothParticle * getPxClothParticleDataParticles( const PxClothParticleData* inOwner ) { return inOwner->particles; }
+inline void setPxClothParticleDataParticles( PxClothParticleData* inOwner, PxClothParticle * inData) { inOwner->particles = inData; }
+inline PxClothParticle * getPxClothParticleDataPreviousParticles( const PxClothParticleData* inOwner ) { return inOwner->previousParticles; }
+inline void setPxClothParticleDataPreviousParticles( PxClothParticleData* inOwner, PxClothParticle * inData) { inOwner->previousParticles = inData; }
+PX_PHYSX_CORE_API PxClothParticleDataGeneratedInfo::PxClothParticleDataGeneratedInfo()
+	: Particles( "Particles", setPxClothParticleDataParticles, getPxClothParticleDataParticles )
+	, PreviousParticles( "PreviousParticles", setPxClothParticleDataPreviousParticles, getPxClothParticleDataPreviousParticles )
+{}
+PX_PHYSX_CORE_API PxClothParticleDataGeneratedValues::PxClothParticleDataGeneratedValues( const PxClothParticleData* inSource )
+		:PxLockedDataGeneratedValues( inSource )
+		,Particles( inSource->particles )
+		,PreviousParticles( inSource->previousParticles )
+{
+	PX_UNUSED(inSource);
+}
diff --git a/PhysX_3.4/Source/PhysXMetaData/core/src/PxMetaDataObjects.cpp b/PhysX_3.4/Source/PhysXMetaData/core/src/PxMetaDataObjects.cpp
new file mode 100644
index 00000000..8154a0e3
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/core/src/PxMetaDataObjects.cpp
@@ -0,0 +1,198 @@
+// 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 "PsFoundation.h"
+#include "PsUtilities.h"
+#include "CmPhysXCommon.h"
+
+#include "PxMetaDataObjects.h"
+#include "PxPhysicsAPI.h"
+#include "NpClothFabric.h"
+
+using namespace physx;
+
+PX_PHYSX_CORE_API PxGeometryType::Enum PxShapeGeometryPropertyHelper::getGeometryType(const PxShape* inShape) const { return inShape->getGeometryType(); }
+PX_PHYSX_CORE_API bool PxShapeGeometryPropertyHelper::getGeometry(const PxShape* inShape, PxBoxGeometry& geometry) const { return inShape->getBoxGeometry( geometry ); }
+PX_PHYSX_CORE_API bool PxShapeGeometryPropertyHelper::getGeometry(const PxShape* inShape, PxSphereGeometry& geometry) const { return inShape->getSphereGeometry( geometry ); }
+PX_PHYSX_CORE_API bool PxShapeGeometryPropertyHelper::getGeometry(const PxShape* inShape, PxCapsuleGeometry& geometry) const { return inShape->getCapsuleGeometry( geometry ); }
+PX_PHYSX_CORE_API bool PxShapeGeometryPropertyHelper::getGeometry(const PxShape* inShape, PxPlaneGeometry& geometry) const { return inShape->getPlaneGeometry( geometry ); }
+PX_PHYSX_CORE_API bool PxShapeGeometryPropertyHelper::getGeometry(const PxShape* inShape, PxConvexMeshGeometry& geometry) const { return inShape->getConvexMeshGeometry( geometry ); }
+PX_PHYSX_CORE_API bool PxShapeGeometryPropertyHelper::getGeometry(const PxShape* inShape, PxTriangleMeshGeometry& geometry) const { return inShape->getTriangleMeshGeometry( geometry ); }
+PX_PHYSX_CORE_API bool PxShapeGeometryPropertyHelper::getGeometry(const PxShape* inShape, PxHeightFieldGeometry& geometry) const { return inShape->getHeightFieldGeometry( geometry ); }
+
+PX_PHYSX_CORE_API void PxShapeMaterialsPropertyHelper::setMaterials(PxShape* inShape, PxMaterial*const* materials, PxU16 materialCount) const
+{
+	inShape->setMaterials( materials, materialCount );
+}
+
+PX_PHYSX_CORE_API PxShape* PxRigidActorShapeCollectionHelper::createShape(PxRigidActor* inActor, const PxGeometry& geometry, PxMaterial& material,
+														PxShapeFlags shapeFlags ) const
+{
+	return PxRigidActorExt::createExclusiveShape(*inActor, geometry, material, shapeFlags );
+}
+PX_PHYSX_CORE_API PxShape* PxRigidActorShapeCollectionHelper::createShape(PxRigidActor* inActor, const PxGeometry& geometry, PxMaterial *const* materials,
+														PxU16 materialCount, PxShapeFlags shapeFlags ) const
+{
+	return PxRigidActorExt::createExclusiveShape(*inActor, geometry, materials, materialCount, shapeFlags );
+}
+
+PX_PHYSX_CORE_API PxArticulationLink*	PxArticulationLinkCollectionPropHelper::createLink(PxArticulation* inArticulation, PxArticulationLink* parent,
+																	   const PxTransform& pose) const
+{
+	PX_CHECK_AND_RETURN_NULL(pose.isValid(), "PxArticulationLinkCollectionPropHelper::createLink pose is not valid.");
+	return inArticulation->createLink(parent, pose );
+}
+
+
+
+/*
+	typedef void (*TSetterType)( TObjType*, TIndexType, TPropertyType );
+	typedef TPropertyType (*TGetterType)( const TObjType* inObj, TIndexType );
+	*/
+
+inline void SetNbBroadPhaseAdd( PxSimulationStatistics* inStats, PxSimulationStatistics::VolumeType data, PxU32 val ) { inStats->nbBroadPhaseAdds[data] = val; }
+inline PxU32 GetNbBroadPhaseAdd( const PxSimulationStatistics* inStats, PxSimulationStatistics::VolumeType data) { return inStats->nbBroadPhaseAdds[data]; }
+
+
+PX_PHYSX_CORE_API NbBroadPhaseAddsProperty::NbBroadPhaseAddsProperty()
+	: PxIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbBroadPhaseAdds
+			, PxSimulationStatistics
+			, PxSimulationStatistics::VolumeType
+			, PxU32> ( "NbBroadPhaseAdds", SetNbBroadPhaseAdd, GetNbBroadPhaseAdd )
+{
+}
+
+inline void SetNbBroadPhaseRemove( PxSimulationStatistics* inStats, PxSimulationStatistics::VolumeType data, PxU32 val ) { inStats->nbBroadPhaseRemoves[data] = val; }
+inline PxU32 GetNbBroadPhaseRemove( const PxSimulationStatistics* inStats, PxSimulationStatistics::VolumeType data) { return inStats->nbBroadPhaseRemoves[data]; }
+
+
+PX_PHYSX_CORE_API NbBroadPhaseRemovesProperty::NbBroadPhaseRemovesProperty()
+	: PxIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbBroadPhaseRemoves
+			, PxSimulationStatistics
+			, PxSimulationStatistics::VolumeType
+			, PxU32> ( "NbBroadPhaseRemoves", SetNbBroadPhaseRemove, GetNbBroadPhaseRemove )
+{
+}
+
+inline void SetNbShape( PxSimulationStatistics* inStats, PxGeometryType::Enum data, PxU32 val ) { inStats->nbShapes[data] = val; }
+inline PxU32 GetNbShape( const PxSimulationStatistics* inStats, PxGeometryType::Enum data) { return inStats->nbShapes[data]; }
+
+
+PX_PHYSX_CORE_API NbShapesProperty::NbShapesProperty()
+	: PxIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbShapes
+			, PxSimulationStatistics
+			, PxGeometryType::Enum
+			, PxU32> ( "NbShapes", SetNbShape, GetNbShape )
+{
+}
+
+
+inline void SetNbDiscreteContactPairs( PxSimulationStatistics* inStats, PxGeometryType::Enum idx1, PxGeometryType::Enum idx2, PxU32 val ) { inStats->nbDiscreteContactPairs[idx1][idx2] = val; }
+inline PxU32 GetNbDiscreteContactPairs( const PxSimulationStatistics* inStats, PxGeometryType::Enum idx1, PxGeometryType::Enum idx2 ) { return inStats->nbDiscreteContactPairs[idx1][idx2]; }
+PX_PHYSX_CORE_API NbDiscreteContactPairsProperty::NbDiscreteContactPairsProperty()
+								: PxDualIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbDiscreteContactPairs
+															, PxSimulationStatistics
+															, PxGeometryType::Enum
+															, PxGeometryType::Enum
+															, PxU32> ( "NbDiscreteContactPairs", SetNbDiscreteContactPairs, GetNbDiscreteContactPairs )
+{
+}
+
+inline void SetNbModifiedContactPairs( PxSimulationStatistics* inStats, PxGeometryType::Enum idx1, PxGeometryType::Enum idx2, PxU32 val ) { inStats->nbModifiedContactPairs[idx1][idx2] = val; }
+inline PxU32 GetNbModifiedContactPairs( const PxSimulationStatistics* inStats, PxGeometryType::Enum idx1, PxGeometryType::Enum idx2 ) { return inStats->nbModifiedContactPairs[idx1][idx2]; }
+PX_PHYSX_CORE_API NbModifiedContactPairsProperty::NbModifiedContactPairsProperty()
+								: PxDualIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbModifiedContactPairs
+															, PxSimulationStatistics
+															, PxGeometryType::Enum
+															, PxGeometryType::Enum
+															, PxU32> ( "NbModifiedContactPairs", SetNbModifiedContactPairs, GetNbModifiedContactPairs )
+{
+}
+
+inline void SetNbCCDPairs( PxSimulationStatistics* inStats, PxGeometryType::Enum idx1, PxGeometryType::Enum idx2, PxU32 val ) { inStats->nbCCDPairs[idx1][idx2] = val; }
+inline PxU32 GetNbCCDPairs( const PxSimulationStatistics* inStats, PxGeometryType::Enum idx1, PxGeometryType::Enum idx2 ) { return inStats->nbCCDPairs[idx1][idx2]; }
+PX_PHYSX_CORE_API NbCCDPairsProperty::NbCCDPairsProperty()
+								: PxDualIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbCCDPairs
+															, PxSimulationStatistics
+															, PxGeometryType::Enum
+															, PxGeometryType::Enum
+															, PxU32> ( "NbCCDPairs", SetNbCCDPairs, GetNbCCDPairs )
+{
+}
+
+inline void SetNbTriggerPairs( PxSimulationStatistics* inStats, PxGeometryType::Enum idx1, PxGeometryType::Enum idx2, PxU32 val ) { inStats->nbTriggerPairs[idx1][idx2] = val; }
+inline PxU32 GetNbTriggerPairs( const PxSimulationStatistics* inStats, PxGeometryType::Enum idx1, PxGeometryType::Enum idx2 ) { return inStats->nbTriggerPairs[idx1][idx2]; }
+PX_PHYSX_CORE_API NbTriggerPairsProperty::NbTriggerPairsProperty()
+								: PxDualIndexedPropertyInfo<PxPropertyInfoName::PxSimulationStatistics_NbTriggerPairs
+															, PxSimulationStatistics
+															, PxGeometryType::Enum
+															, PxGeometryType::Enum
+															, PxU32> ( "NbTriggerPairs", SetNbTriggerPairs, GetNbTriggerPairs )
+{
+}
+
+inline PxSimulationStatistics GetStats( const PxScene* inScene ) { PxSimulationStatistics stats; inScene->getSimulationStatistics( stats ); return stats; }
+PX_PHYSX_CORE_API SimulationStatisticsProperty::SimulationStatisticsProperty() 
+	: PxReadOnlyPropertyInfo<PxPropertyInfoName::PxScene_SimulationStatistics, PxScene, PxSimulationStatistics >( "SimulationStatistics", GetStats )
+{
+}
+
+#if PX_USE_PARTICLE_SYSTEM_API
+inline void SetProjectionPlane( PxParticleBase* inBase, PxMetaDataPlane inPlane ) { inBase->setProjectionPlane( inPlane.normal, inPlane.distance ); } 
+inline PxMetaDataPlane GetProjectionPlane( const PxParticleBase* inBase ) 
+{ 
+	PxMetaDataPlane retval;
+	inBase->getProjectionPlane( retval.normal, retval.distance ); 
+	return retval;
+}
+
+PX_PHYSX_CORE_API ProjectionPlaneProperty::ProjectionPlaneProperty() 
+	: PxPropertyInfo< PxPropertyInfoName::PxParticleBase_ProjectionPlane, PxParticleBase, PxMetaDataPlane, PxMetaDataPlane >( "ProjectionPlane", SetProjectionPlane, GetProjectionPlane )
+{
+}
+#endif // PX_USE_PARTICLE_SYSTEM_API
+
+#if PX_USE_CLOTH_API
+inline PxU32 GetNbPxClothFabric_Restvalues( const PxClothFabric* fabric ) { return fabric->getNbParticleIndices()/2; }
+inline PxU32 GetPxClothFabric_Restvalues( const PxClothFabric* fabric, PxReal* outBuffer, PxU32 outBufLen ){ return fabric->getRestvalues( outBuffer, outBufLen ); }
+
+PX_PHYSX_CORE_API RestvaluesProperty::RestvaluesProperty()
+	: PxReadOnlyCollectionPropertyInfo<PxPropertyInfoName::PxClothFabric_Restvalues, PxClothFabric, PxReal>( "Restvalues", GetPxClothFabric_Restvalues, GetNbPxClothFabric_Restvalues )
+{
+}
+
+inline PxU32 GetNbPxClothFabric_PhaseTypes( const PxClothFabric* fabric ) { return fabric->getNbPhases(); }
+inline PxU32 GetPxClothFabric_PhaseTypes( const PxClothFabric* fabric, PxClothFabricPhaseType::Enum* outBuffer, PxU32 outBufLen )
+{
+	PxU32 numItems = PxMin( outBufLen, fabric->getNbPhases() );
+	for ( PxU32 idx = 0; idx < numItems; ++idx )
+		outBuffer[idx] =(static_cast<const NpClothFabric*> (fabric))->getPhaseType( idx );
+	return numItems;
+}
+#endif // PX_USE_CLOTH_API