Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

4 files changed, 1716 insertions, 0 deletions

diff --git a/PhysX_3.4/Source/PhysXMetaData/extensions/include/PxExtensionAutoGeneratedMetaDataObjectNames.h b/PhysX_3.4/Source/PhysXMetaData/extensions/include/PxExtensionAutoGeneratedMetaDataObjectNames.h
new file mode 100644
index 00000000..02ad0962
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/extensions/include/PxExtensionAutoGeneratedMetaDataObjectNames.h
@@ -0,0 +1,144 @@
+// 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
+
+PxJoint_PropertiesStart,
+PxJoint_Actors,
+PxJoint_LocalPose,
+PxJoint_RelativeTransform,
+PxJoint_RelativeLinearVelocity,
+PxJoint_RelativeAngularVelocity,
+PxJoint_BreakForce,
+PxJoint_ConstraintFlags,
+PxJoint_InvMassScale0,
+PxJoint_InvInertiaScale0,
+PxJoint_InvMassScale1,
+PxJoint_InvInertiaScale1,
+PxJoint_Constraint,
+PxJoint_Name,
+PxJoint_Scene,
+PxJoint_UserData,
+PxJoint_PropertiesStop,
+PxD6Joint_PropertiesStart,
+PxD6Joint_Motion,
+PxD6Joint_Twist,
+PxD6Joint_SwingYAngle,
+PxD6Joint_SwingZAngle,
+PxD6Joint_LinearLimit,
+PxD6Joint_TwistLimit,
+PxD6Joint_SwingLimit,
+PxD6Joint_Drive,
+PxD6Joint_DrivePosition,
+PxD6Joint_DriveVelocity,
+PxD6Joint_ProjectionLinearTolerance,
+PxD6Joint_ProjectionAngularTolerance,
+PxD6Joint_ConcreteTypeName,
+PxD6Joint_PropertiesStop,
+PxDistanceJoint_PropertiesStart,
+PxDistanceJoint_Distance,
+PxDistanceJoint_MinDistance,
+PxDistanceJoint_MaxDistance,
+PxDistanceJoint_Tolerance,
+PxDistanceJoint_Stiffness,
+PxDistanceJoint_Damping,
+PxDistanceJoint_DistanceJointFlags,
+PxDistanceJoint_ConcreteTypeName,
+PxDistanceJoint_PropertiesStop,
+PxFixedJoint_PropertiesStart,
+PxFixedJoint_ProjectionLinearTolerance,
+PxFixedJoint_ProjectionAngularTolerance,
+PxFixedJoint_ConcreteTypeName,
+PxFixedJoint_PropertiesStop,
+PxPrismaticJoint_PropertiesStart,
+PxPrismaticJoint_Position,
+PxPrismaticJoint_Velocity,
+PxPrismaticJoint_Limit,
+PxPrismaticJoint_PrismaticJointFlags,
+PxPrismaticJoint_ProjectionLinearTolerance,
+PxPrismaticJoint_ProjectionAngularTolerance,
+PxPrismaticJoint_ConcreteTypeName,
+PxPrismaticJoint_PropertiesStop,
+PxRevoluteJoint_PropertiesStart,
+PxRevoluteJoint_Angle,
+PxRevoluteJoint_Velocity,
+PxRevoluteJoint_Limit,
+PxRevoluteJoint_DriveVelocity,
+PxRevoluteJoint_DriveForceLimit,
+PxRevoluteJoint_DriveGearRatio,
+PxRevoluteJoint_RevoluteJointFlags,
+PxRevoluteJoint_ProjectionLinearTolerance,
+PxRevoluteJoint_ProjectionAngularTolerance,
+PxRevoluteJoint_ConcreteTypeName,
+PxRevoluteJoint_PropertiesStop,
+PxSphericalJoint_PropertiesStart,
+PxSphericalJoint_LimitCone,
+PxSphericalJoint_SphericalJointFlags,
+PxSphericalJoint_ProjectionLinearTolerance,
+PxSphericalJoint_ConcreteTypeName,
+PxSphericalJoint_PropertiesStop,
+PxJointLimitParameters_PropertiesStart,
+PxJointLimitParameters_Restitution,
+PxJointLimitParameters_BounceThreshold,
+PxJointLimitParameters_Stiffness,
+PxJointLimitParameters_Damping,
+PxJointLimitParameters_ContactDistance,
+PxJointLimitParameters_PropertiesStop,
+PxJointLinearLimit_PropertiesStart,
+PxJointLinearLimit_Value,
+PxJointLinearLimit_PropertiesStop,
+PxJointLinearLimitPair_PropertiesStart,
+PxJointLinearLimitPair_Upper,
+PxJointLinearLimitPair_Lower,
+PxJointLinearLimitPair_PropertiesStop,
+PxJointAngularLimitPair_PropertiesStart,
+PxJointAngularLimitPair_Upper,
+PxJointAngularLimitPair_Lower,
+PxJointAngularLimitPair_PropertiesStop,
+PxJointLimitCone_PropertiesStart,
+PxJointLimitCone_YAngle,
+PxJointLimitCone_ZAngle,
+PxJointLimitCone_PropertiesStop,
+PxSpring_PropertiesStart,
+PxSpring_Stiffness,
+PxSpring_Damping,
+PxSpring_PropertiesStop,
+PxD6JointDrive_PropertiesStart,
+PxD6JointDrive_ForceLimit,
+PxD6JointDrive_Flags,
+PxD6JointDrive_PropertiesStop,
+
+
+#undef THERE_IS_NO_INCLUDE_GUARD_HERE_FOR_A_REASON
diff --git a/PhysX_3.4/Source/PhysXMetaData/extensions/include/PxExtensionAutoGeneratedMetaDataObjects.h b/PhysX_3.4/Source/PhysXMetaData/extensions/include/PxExtensionAutoGeneratedMetaDataObjects.h
new file mode 100644
index 00000000..fc6388b1
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/extensions/include/PxExtensionAutoGeneratedMetaDataObjects.h
@@ -0,0 +1,1077 @@
+// 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 PxExtensionsPropertyInfoName
+	static PxU32ToName g_physx__PxJointActorIndex__EnumConversion[] = {
+		{ "eACTOR0", static_cast<PxU32>( physx::PxJointActorIndex::eACTOR0 ) },
+		{ "eACTOR1", static_cast<PxU32>( physx::PxJointActorIndex::eACTOR1 ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxJointActorIndex::Enum > { PxEnumTraits() : NameConversion( g_physx__PxJointActorIndex__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxJoint;
+	struct PxJointGeneratedValues
+	{
+		PxRigidActor * Actors[2];
+		PxTransform LocalPose[physx::PxJointActorIndex::COUNT];
+		PxTransform RelativeTransform;
+		PxVec3 RelativeLinearVelocity;
+		PxVec3 RelativeAngularVelocity;
+		PxReal BreakForce[2];
+		PxConstraintFlags ConstraintFlags;
+		PxReal InvMassScale0;
+		PxReal InvInertiaScale0;
+		PxReal InvMassScale1;
+		PxReal InvInertiaScale1;
+		PxConstraint * Constraint;
+		const char * Name;
+		PxScene * Scene;
+		void * UserData;
+		  PxJointGeneratedValues( const PxJoint* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, Actors, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, LocalPose, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, RelativeTransform, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, RelativeLinearVelocity, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, RelativeAngularVelocity, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, BreakForce, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, ConstraintFlags, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, InvMassScale0, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, InvInertiaScale0, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, InvMassScale1, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, InvInertiaScale1, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, Constraint, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, Name, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, Scene, PxJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJoint, UserData, PxJointGeneratedValues)
+	struct PxJointGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxJoint"; }
+		PxRangePropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_Actors, PxJoint, PxRigidActor * > Actors;
+		PxIndexedPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_LocalPose, PxJoint, PxJointActorIndex::Enum, PxTransform > LocalPose;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_RelativeTransform, PxJoint, PxTransform > RelativeTransform;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_RelativeLinearVelocity, PxJoint, PxVec3 > RelativeLinearVelocity;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_RelativeAngularVelocity, PxJoint, PxVec3 > RelativeAngularVelocity;
+		PxRangePropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_BreakForce, PxJoint, PxReal > BreakForce;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_ConstraintFlags, PxJoint, PxConstraintFlags, PxConstraintFlags > ConstraintFlags;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_InvMassScale0, PxJoint, PxReal, PxReal > InvMassScale0;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_InvInertiaScale0, PxJoint, PxReal, PxReal > InvInertiaScale0;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_InvMassScale1, PxJoint, PxReal, PxReal > InvMassScale1;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_InvInertiaScale1, PxJoint, PxReal, PxReal > InvInertiaScale1;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_Constraint, PxJoint, PxConstraint * > Constraint;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_Name, PxJoint, const char *, const char * > Name;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_Scene, PxJoint, PxScene * > Scene;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJoint_UserData, PxJoint, void *, void * > UserData;
+
+		 PxJointGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxJoint*>(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( Actors, inStartIndex + 0 );; 
+			inOperator( LocalPose, inStartIndex + 1 );; 
+			inOperator( RelativeTransform, inStartIndex + 2 );; 
+			inOperator( RelativeLinearVelocity, inStartIndex + 3 );; 
+			inOperator( RelativeAngularVelocity, inStartIndex + 4 );; 
+			inOperator( BreakForce, inStartIndex + 5 );; 
+			inOperator( ConstraintFlags, inStartIndex + 6 );; 
+			inOperator( InvMassScale0, inStartIndex + 7 );; 
+			inOperator( InvInertiaScale0, inStartIndex + 8 );; 
+			inOperator( InvMassScale1, inStartIndex + 9 );; 
+			inOperator( InvInertiaScale1, inStartIndex + 10 );; 
+			inOperator( Constraint, inStartIndex + 11 );; 
+			inOperator( Name, inStartIndex + 12 );; 
+			inOperator( Scene, inStartIndex + 13 );; 
+			inOperator( UserData, inStartIndex + 14 );; 
+			return 15 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxJoint>
+	{ 
+		PxJointGeneratedInfo Info;
+		const PxJointGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxD6Axis__EnumConversion[] = {
+		{ "eX", static_cast<PxU32>( physx::PxD6Axis::eX ) },
+		{ "eY", static_cast<PxU32>( physx::PxD6Axis::eY ) },
+		{ "eZ", static_cast<PxU32>( physx::PxD6Axis::eZ ) },
+		{ "eTWIST", static_cast<PxU32>( physx::PxD6Axis::eTWIST ) },
+		{ "eSWING1", static_cast<PxU32>( physx::PxD6Axis::eSWING1 ) },
+		{ "eSWING2", static_cast<PxU32>( physx::PxD6Axis::eSWING2 ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxD6Axis::Enum > { PxEnumTraits() : NameConversion( g_physx__PxD6Axis__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxD6Motion__EnumConversion[] = {
+		{ "eLOCKED", static_cast<PxU32>( physx::PxD6Motion::eLOCKED ) },
+		{ "eLIMITED", static_cast<PxU32>( physx::PxD6Motion::eLIMITED ) },
+		{ "eFREE", static_cast<PxU32>( physx::PxD6Motion::eFREE ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxD6Motion::Enum > { PxEnumTraits() : NameConversion( g_physx__PxD6Motion__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	static PxU32ToName g_physx__PxD6Drive__EnumConversion[] = {
+		{ "eX", static_cast<PxU32>( physx::PxD6Drive::eX ) },
+		{ "eY", static_cast<PxU32>( physx::PxD6Drive::eY ) },
+		{ "eZ", static_cast<PxU32>( physx::PxD6Drive::eZ ) },
+		{ "eSWING", static_cast<PxU32>( physx::PxD6Drive::eSWING ) },
+		{ "eTWIST", static_cast<PxU32>( physx::PxD6Drive::eTWIST ) },
+		{ "eSLERP", static_cast<PxU32>( physx::PxD6Drive::eSLERP ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxD6Drive::Enum > { PxEnumTraits() : NameConversion( g_physx__PxD6Drive__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxD6Joint;
+	struct PxD6JointGeneratedValues
+		: PxJointGeneratedValues	{
+		PxD6Motion::Enum Motion[physx::PxD6Axis::eCOUNT];
+		PxReal Twist;
+		PxReal SwingYAngle;
+		PxReal SwingZAngle;
+		PxJointLinearLimit LinearLimit;
+		PxJointAngularLimitPair TwistLimit;
+		PxJointLimitCone SwingLimit;
+		PxD6JointDrive Drive[physx::PxD6Drive::eCOUNT];
+		PxTransform DrivePosition;
+		PxVec3 DriveVelocity[2];
+		PxReal ProjectionLinearTolerance;
+		PxReal ProjectionAngularTolerance;
+		const char * ConcreteTypeName;
+		  PxD6JointGeneratedValues( const PxD6Joint* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, Motion, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, Twist, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, SwingYAngle, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, SwingZAngle, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, LinearLimit, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, TwistLimit, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, SwingLimit, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, Drive, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, DrivePosition, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, DriveVelocity, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, ProjectionLinearTolerance, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, ProjectionAngularTolerance, PxD6JointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6Joint, ConcreteTypeName, PxD6JointGeneratedValues)
+	struct PxD6JointGeneratedInfo
+		: PxJointGeneratedInfo
+	{
+		static const char* getClassName() { return "PxD6Joint"; }
+		PxIndexedPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_Motion, PxD6Joint, PxD6Axis::Enum, PxD6Motion::Enum > Motion;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_Twist, PxD6Joint, PxReal > Twist;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_SwingYAngle, PxD6Joint, PxReal > SwingYAngle;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_SwingZAngle, PxD6Joint, PxReal > SwingZAngle;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_LinearLimit, PxD6Joint, const PxJointLinearLimit &, PxJointLinearLimit > LinearLimit;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_TwistLimit, PxD6Joint, const PxJointAngularLimitPair &, PxJointAngularLimitPair > TwistLimit;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_SwingLimit, PxD6Joint, const PxJointLimitCone &, PxJointLimitCone > SwingLimit;
+		PxIndexedPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_Drive, PxD6Joint, PxD6Drive::Enum, PxD6JointDrive > Drive;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_DrivePosition, PxD6Joint, const PxTransform &, PxTransform > DrivePosition;
+		PxRangePropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_DriveVelocity, PxD6Joint, PxVec3 > DriveVelocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_ProjectionLinearTolerance, PxD6Joint, PxReal, PxReal > ProjectionLinearTolerance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_ProjectionAngularTolerance, PxD6Joint, PxReal, PxReal > ProjectionAngularTolerance;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6Joint_ConcreteTypeName, PxD6Joint, const char * > ConcreteTypeName;
+
+		 PxD6JointGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxD6Joint*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxJointGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxJointGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxJointGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 13; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxJointGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Motion, inStartIndex + 0 );; 
+			inOperator( Twist, inStartIndex + 1 );; 
+			inOperator( SwingYAngle, inStartIndex + 2 );; 
+			inOperator( SwingZAngle, inStartIndex + 3 );; 
+			inOperator( LinearLimit, inStartIndex + 4 );; 
+			inOperator( TwistLimit, inStartIndex + 5 );; 
+			inOperator( SwingLimit, inStartIndex + 6 );; 
+			inOperator( Drive, inStartIndex + 7 );; 
+			inOperator( DrivePosition, inStartIndex + 8 );; 
+			inOperator( DriveVelocity, inStartIndex + 9 );; 
+			inOperator( ProjectionLinearTolerance, inStartIndex + 10 );; 
+			inOperator( ProjectionAngularTolerance, inStartIndex + 11 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 12 );; 
+			return 13 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxD6Joint>
+	{ 
+		PxD6JointGeneratedInfo Info;
+		const PxD6JointGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxDistanceJointFlag__EnumConversion[] = {
+		{ "eMAX_DISTANCE_ENABLED", static_cast<PxU32>( physx::PxDistanceJointFlag::eMAX_DISTANCE_ENABLED ) },
+		{ "eMIN_DISTANCE_ENABLED", static_cast<PxU32>( physx::PxDistanceJointFlag::eMIN_DISTANCE_ENABLED ) },
+		{ "eSPRING_ENABLED", static_cast<PxU32>( physx::PxDistanceJointFlag::eSPRING_ENABLED ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxDistanceJointFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxDistanceJointFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxDistanceJoint;
+	struct PxDistanceJointGeneratedValues
+		: PxJointGeneratedValues	{
+		PxReal Distance;
+		PxReal MinDistance;
+		PxReal MaxDistance;
+		PxReal Tolerance;
+		PxReal Stiffness;
+		PxReal Damping;
+		PxDistanceJointFlags DistanceJointFlags;
+		const char * ConcreteTypeName;
+		  PxDistanceJointGeneratedValues( const PxDistanceJoint* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxDistanceJoint, Distance, PxDistanceJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxDistanceJoint, MinDistance, PxDistanceJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxDistanceJoint, MaxDistance, PxDistanceJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxDistanceJoint, Tolerance, PxDistanceJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxDistanceJoint, Stiffness, PxDistanceJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxDistanceJoint, Damping, PxDistanceJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxDistanceJoint, DistanceJointFlags, PxDistanceJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxDistanceJoint, ConcreteTypeName, PxDistanceJointGeneratedValues)
+	struct PxDistanceJointGeneratedInfo
+		: PxJointGeneratedInfo
+	{
+		static const char* getClassName() { return "PxDistanceJoint"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxDistanceJoint_Distance, PxDistanceJoint, PxReal > Distance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxDistanceJoint_MinDistance, PxDistanceJoint, PxReal, PxReal > MinDistance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxDistanceJoint_MaxDistance, PxDistanceJoint, PxReal, PxReal > MaxDistance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxDistanceJoint_Tolerance, PxDistanceJoint, PxReal, PxReal > Tolerance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxDistanceJoint_Stiffness, PxDistanceJoint, PxReal, PxReal > Stiffness;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxDistanceJoint_Damping, PxDistanceJoint, PxReal, PxReal > Damping;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxDistanceJoint_DistanceJointFlags, PxDistanceJoint, PxDistanceJointFlags, PxDistanceJointFlags > DistanceJointFlags;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxDistanceJoint_ConcreteTypeName, PxDistanceJoint, const char * > ConcreteTypeName;
+
+		 PxDistanceJointGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxDistanceJoint*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxJointGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxJointGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxJointGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 8; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxJointGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Distance, inStartIndex + 0 );; 
+			inOperator( MinDistance, inStartIndex + 1 );; 
+			inOperator( MaxDistance, inStartIndex + 2 );; 
+			inOperator( Tolerance, inStartIndex + 3 );; 
+			inOperator( Stiffness, inStartIndex + 4 );; 
+			inOperator( Damping, inStartIndex + 5 );; 
+			inOperator( DistanceJointFlags, inStartIndex + 6 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 7 );; 
+			return 8 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxDistanceJoint>
+	{ 
+		PxDistanceJointGeneratedInfo Info;
+		const PxDistanceJointGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxFixedJoint;
+	struct PxFixedJointGeneratedValues
+		: PxJointGeneratedValues	{
+		PxReal ProjectionLinearTolerance;
+		PxReal ProjectionAngularTolerance;
+		const char * ConcreteTypeName;
+		  PxFixedJointGeneratedValues( const PxFixedJoint* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxFixedJoint, ProjectionLinearTolerance, PxFixedJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxFixedJoint, ProjectionAngularTolerance, PxFixedJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxFixedJoint, ConcreteTypeName, PxFixedJointGeneratedValues)
+	struct PxFixedJointGeneratedInfo
+		: PxJointGeneratedInfo
+	{
+		static const char* getClassName() { return "PxFixedJoint"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxFixedJoint_ProjectionLinearTolerance, PxFixedJoint, PxReal, PxReal > ProjectionLinearTolerance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxFixedJoint_ProjectionAngularTolerance, PxFixedJoint, PxReal, PxReal > ProjectionAngularTolerance;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxFixedJoint_ConcreteTypeName, PxFixedJoint, const char * > ConcreteTypeName;
+
+		 PxFixedJointGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxFixedJoint*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxJointGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxJointGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxJointGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 3; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxJointGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( ProjectionLinearTolerance, inStartIndex + 0 );; 
+			inOperator( ProjectionAngularTolerance, inStartIndex + 1 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 2 );; 
+			return 3 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxFixedJoint>
+	{ 
+		PxFixedJointGeneratedInfo Info;
+		const PxFixedJointGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxPrismaticJointFlag__EnumConversion[] = {
+		{ "eLIMIT_ENABLED", static_cast<PxU32>( physx::PxPrismaticJointFlag::eLIMIT_ENABLED ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxPrismaticJointFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxPrismaticJointFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxPrismaticJoint;
+	struct PxPrismaticJointGeneratedValues
+		: PxJointGeneratedValues	{
+		PxReal Position;
+		PxReal Velocity;
+		PxJointLinearLimitPair Limit;
+		PxPrismaticJointFlags PrismaticJointFlags;
+		PxReal ProjectionLinearTolerance;
+		PxReal ProjectionAngularTolerance;
+		const char * ConcreteTypeName;
+		  PxPrismaticJointGeneratedValues( const PxPrismaticJoint* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxPrismaticJoint, Position, PxPrismaticJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxPrismaticJoint, Velocity, PxPrismaticJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxPrismaticJoint, Limit, PxPrismaticJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxPrismaticJoint, PrismaticJointFlags, PxPrismaticJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxPrismaticJoint, ProjectionLinearTolerance, PxPrismaticJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxPrismaticJoint, ProjectionAngularTolerance, PxPrismaticJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxPrismaticJoint, ConcreteTypeName, PxPrismaticJointGeneratedValues)
+	struct PxPrismaticJointGeneratedInfo
+		: PxJointGeneratedInfo
+	{
+		static const char* getClassName() { return "PxPrismaticJoint"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxPrismaticJoint_Position, PxPrismaticJoint, PxReal > Position;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxPrismaticJoint_Velocity, PxPrismaticJoint, PxReal > Velocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxPrismaticJoint_Limit, PxPrismaticJoint, const PxJointLinearLimitPair &, PxJointLinearLimitPair > Limit;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxPrismaticJoint_PrismaticJointFlags, PxPrismaticJoint, PxPrismaticJointFlags, PxPrismaticJointFlags > PrismaticJointFlags;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxPrismaticJoint_ProjectionLinearTolerance, PxPrismaticJoint, PxReal, PxReal > ProjectionLinearTolerance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxPrismaticJoint_ProjectionAngularTolerance, PxPrismaticJoint, PxReal, PxReal > ProjectionAngularTolerance;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxPrismaticJoint_ConcreteTypeName, PxPrismaticJoint, const char * > ConcreteTypeName;
+
+		 PxPrismaticJointGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxPrismaticJoint*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxJointGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxJointGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxJointGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 7; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxJointGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Position, inStartIndex + 0 );; 
+			inOperator( Velocity, inStartIndex + 1 );; 
+			inOperator( Limit, inStartIndex + 2 );; 
+			inOperator( PrismaticJointFlags, inStartIndex + 3 );; 
+			inOperator( ProjectionLinearTolerance, inStartIndex + 4 );; 
+			inOperator( ProjectionAngularTolerance, inStartIndex + 5 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 6 );; 
+			return 7 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxPrismaticJoint>
+	{ 
+		PxPrismaticJointGeneratedInfo Info;
+		const PxPrismaticJointGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxRevoluteJointFlag__EnumConversion[] = {
+		{ "eLIMIT_ENABLED", static_cast<PxU32>( physx::PxRevoluteJointFlag::eLIMIT_ENABLED ) },
+		{ "eDRIVE_ENABLED", static_cast<PxU32>( physx::PxRevoluteJointFlag::eDRIVE_ENABLED ) },
+		{ "eDRIVE_FREESPIN", static_cast<PxU32>( physx::PxRevoluteJointFlag::eDRIVE_FREESPIN ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxRevoluteJointFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxRevoluteJointFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxRevoluteJoint;
+	struct PxRevoluteJointGeneratedValues
+		: PxJointGeneratedValues	{
+		PxReal Angle;
+		PxReal Velocity;
+		PxJointAngularLimitPair Limit;
+		PxReal DriveVelocity;
+		PxReal DriveForceLimit;
+		PxReal DriveGearRatio;
+		PxRevoluteJointFlags RevoluteJointFlags;
+		PxReal ProjectionLinearTolerance;
+		PxReal ProjectionAngularTolerance;
+		const char * ConcreteTypeName;
+		  PxRevoluteJointGeneratedValues( const PxRevoluteJoint* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRevoluteJoint, Angle, PxRevoluteJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRevoluteJoint, Velocity, PxRevoluteJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRevoluteJoint, Limit, PxRevoluteJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRevoluteJoint, DriveVelocity, PxRevoluteJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRevoluteJoint, DriveForceLimit, PxRevoluteJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRevoluteJoint, DriveGearRatio, PxRevoluteJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRevoluteJoint, RevoluteJointFlags, PxRevoluteJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRevoluteJoint, ProjectionLinearTolerance, PxRevoluteJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRevoluteJoint, ProjectionAngularTolerance, PxRevoluteJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxRevoluteJoint, ConcreteTypeName, PxRevoluteJointGeneratedValues)
+	struct PxRevoluteJointGeneratedInfo
+		: PxJointGeneratedInfo
+	{
+		static const char* getClassName() { return "PxRevoluteJoint"; }
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxRevoluteJoint_Angle, PxRevoluteJoint, PxReal > Angle;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxRevoluteJoint_Velocity, PxRevoluteJoint, PxReal > Velocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRevoluteJoint_Limit, PxRevoluteJoint, const PxJointAngularLimitPair &, PxJointAngularLimitPair > Limit;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRevoluteJoint_DriveVelocity, PxRevoluteJoint, PxReal, PxReal > DriveVelocity;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRevoluteJoint_DriveForceLimit, PxRevoluteJoint, PxReal, PxReal > DriveForceLimit;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRevoluteJoint_DriveGearRatio, PxRevoluteJoint, PxReal, PxReal > DriveGearRatio;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRevoluteJoint_RevoluteJointFlags, PxRevoluteJoint, PxRevoluteJointFlags, PxRevoluteJointFlags > RevoluteJointFlags;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRevoluteJoint_ProjectionLinearTolerance, PxRevoluteJoint, PxReal, PxReal > ProjectionLinearTolerance;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxRevoluteJoint_ProjectionAngularTolerance, PxRevoluteJoint, PxReal, PxReal > ProjectionAngularTolerance;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxRevoluteJoint_ConcreteTypeName, PxRevoluteJoint, const char * > ConcreteTypeName;
+
+		 PxRevoluteJointGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxRevoluteJoint*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxJointGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxJointGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxJointGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 10; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxJointGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Angle, inStartIndex + 0 );; 
+			inOperator( Velocity, inStartIndex + 1 );; 
+			inOperator( Limit, inStartIndex + 2 );; 
+			inOperator( DriveVelocity, inStartIndex + 3 );; 
+			inOperator( DriveForceLimit, inStartIndex + 4 );; 
+			inOperator( DriveGearRatio, inStartIndex + 5 );; 
+			inOperator( RevoluteJointFlags, inStartIndex + 6 );; 
+			inOperator( ProjectionLinearTolerance, inStartIndex + 7 );; 
+			inOperator( ProjectionAngularTolerance, inStartIndex + 8 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 9 );; 
+			return 10 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxRevoluteJoint>
+	{ 
+		PxRevoluteJointGeneratedInfo Info;
+		const PxRevoluteJointGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxSphericalJointFlag__EnumConversion[] = {
+		{ "eLIMIT_ENABLED", static_cast<PxU32>( physx::PxSphericalJointFlag::eLIMIT_ENABLED ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxSphericalJointFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxSphericalJointFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxSphericalJoint;
+	struct PxSphericalJointGeneratedValues
+		: PxJointGeneratedValues	{
+		PxJointLimitCone LimitCone;
+		PxSphericalJointFlags SphericalJointFlags;
+		PxReal ProjectionLinearTolerance;
+		const char * ConcreteTypeName;
+		  PxSphericalJointGeneratedValues( const PxSphericalJoint* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSphericalJoint, LimitCone, PxSphericalJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSphericalJoint, SphericalJointFlags, PxSphericalJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSphericalJoint, ProjectionLinearTolerance, PxSphericalJointGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSphericalJoint, ConcreteTypeName, PxSphericalJointGeneratedValues)
+	struct PxSphericalJointGeneratedInfo
+		: PxJointGeneratedInfo
+	{
+		static const char* getClassName() { return "PxSphericalJoint"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSphericalJoint_LimitCone, PxSphericalJoint, const PxJointLimitCone &, PxJointLimitCone > LimitCone;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSphericalJoint_SphericalJointFlags, PxSphericalJoint, PxSphericalJointFlags, PxSphericalJointFlags > SphericalJointFlags;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSphericalJoint_ProjectionLinearTolerance, PxSphericalJoint, PxReal, PxReal > ProjectionLinearTolerance;
+		PxReadOnlyPropertyInfo<PX_PROPERTY_INFO_NAME::PxSphericalJoint_ConcreteTypeName, PxSphericalJoint, const char * > ConcreteTypeName;
+
+		 PxSphericalJointGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxSphericalJoint*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxJointGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxJointGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxJointGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 4; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxJointGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( LimitCone, inStartIndex + 0 );; 
+			inOperator( SphericalJointFlags, inStartIndex + 1 );; 
+			inOperator( ProjectionLinearTolerance, inStartIndex + 2 );; 
+			inOperator( ConcreteTypeName, inStartIndex + 3 );; 
+			return 4 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxSphericalJoint>
+	{ 
+		PxSphericalJointGeneratedInfo Info;
+		const PxSphericalJointGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxJointLimitParameters;
+	struct PxJointLimitParametersGeneratedValues
+	{
+		PxReal Restitution;
+		PxReal BounceThreshold;
+		PxReal Stiffness;
+		PxReal Damping;
+		PxReal ContactDistance;
+		  PxJointLimitParametersGeneratedValues( const PxJointLimitParameters* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointLimitParameters, Restitution, PxJointLimitParametersGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointLimitParameters, BounceThreshold, PxJointLimitParametersGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointLimitParameters, Stiffness, PxJointLimitParametersGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointLimitParameters, Damping, PxJointLimitParametersGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointLimitParameters, ContactDistance, PxJointLimitParametersGeneratedValues)
+	struct PxJointLimitParametersGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxJointLimitParameters"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointLimitParameters_Restitution, PxJointLimitParameters, PxReal, PxReal > Restitution;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointLimitParameters_BounceThreshold, PxJointLimitParameters, PxReal, PxReal > BounceThreshold;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointLimitParameters_Stiffness, PxJointLimitParameters, PxReal, PxReal > Stiffness;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointLimitParameters_Damping, PxJointLimitParameters, PxReal, PxReal > Damping;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointLimitParameters_ContactDistance, PxJointLimitParameters, PxReal, PxReal > ContactDistance;
+
+		 PxJointLimitParametersGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxJointLimitParameters*>(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 5; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Restitution, inStartIndex + 0 );; 
+			inOperator( BounceThreshold, inStartIndex + 1 );; 
+			inOperator( Stiffness, inStartIndex + 2 );; 
+			inOperator( Damping, inStartIndex + 3 );; 
+			inOperator( ContactDistance, inStartIndex + 4 );; 
+			return 5 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxJointLimitParameters>
+	{ 
+		PxJointLimitParametersGeneratedInfo Info;
+		const PxJointLimitParametersGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxJointLinearLimit;
+	struct PxJointLinearLimitGeneratedValues
+		: PxJointLimitParametersGeneratedValues	{
+		PxReal Value;
+		  PxJointLinearLimitGeneratedValues( const PxJointLinearLimit* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointLinearLimit, Value, PxJointLinearLimitGeneratedValues)
+	struct PxJointLinearLimitGeneratedInfo
+		: PxJointLimitParametersGeneratedInfo
+	{
+		static const char* getClassName() { return "PxJointLinearLimit"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointLinearLimit_Value, PxJointLinearLimit, PxReal, PxReal > Value;
+
+		 PxJointLinearLimitGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxJointLinearLimit*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxJointLimitParametersGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxJointLimitParametersGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxJointLimitParametersGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 1; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxJointLimitParametersGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Value, inStartIndex + 0 );; 
+			return 1 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxJointLinearLimit>
+	{ 
+		PxJointLinearLimitGeneratedInfo Info;
+		const PxJointLinearLimitGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxJointLinearLimitPair;
+	struct PxJointLinearLimitPairGeneratedValues
+		: PxJointLimitParametersGeneratedValues	{
+		PxReal Upper;
+		PxReal Lower;
+		  PxJointLinearLimitPairGeneratedValues( const PxJointLinearLimitPair* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointLinearLimitPair, Upper, PxJointLinearLimitPairGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointLinearLimitPair, Lower, PxJointLinearLimitPairGeneratedValues)
+	struct PxJointLinearLimitPairGeneratedInfo
+		: PxJointLimitParametersGeneratedInfo
+	{
+		static const char* getClassName() { return "PxJointLinearLimitPair"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointLinearLimitPair_Upper, PxJointLinearLimitPair, PxReal, PxReal > Upper;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointLinearLimitPair_Lower, PxJointLinearLimitPair, PxReal, PxReal > Lower;
+
+		 PxJointLinearLimitPairGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxJointLinearLimitPair*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxJointLimitParametersGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxJointLimitParametersGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxJointLimitParametersGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxJointLimitParametersGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Upper, inStartIndex + 0 );; 
+			inOperator( Lower, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxJointLinearLimitPair>
+	{ 
+		PxJointLinearLimitPairGeneratedInfo Info;
+		const PxJointLinearLimitPairGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxJointAngularLimitPair;
+	struct PxJointAngularLimitPairGeneratedValues
+		: PxJointLimitParametersGeneratedValues	{
+		PxReal Upper;
+		PxReal Lower;
+		  PxJointAngularLimitPairGeneratedValues( const PxJointAngularLimitPair* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointAngularLimitPair, Upper, PxJointAngularLimitPairGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointAngularLimitPair, Lower, PxJointAngularLimitPairGeneratedValues)
+	struct PxJointAngularLimitPairGeneratedInfo
+		: PxJointLimitParametersGeneratedInfo
+	{
+		static const char* getClassName() { return "PxJointAngularLimitPair"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointAngularLimitPair_Upper, PxJointAngularLimitPair, PxReal, PxReal > Upper;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointAngularLimitPair_Lower, PxJointAngularLimitPair, PxReal, PxReal > Lower;
+
+		 PxJointAngularLimitPairGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxJointAngularLimitPair*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxJointLimitParametersGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxJointLimitParametersGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxJointLimitParametersGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxJointLimitParametersGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( Upper, inStartIndex + 0 );; 
+			inOperator( Lower, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxJointAngularLimitPair>
+	{ 
+		PxJointAngularLimitPairGeneratedInfo Info;
+		const PxJointAngularLimitPairGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxJointLimitCone;
+	struct PxJointLimitConeGeneratedValues
+		: PxJointLimitParametersGeneratedValues	{
+		PxReal YAngle;
+		PxReal ZAngle;
+		  PxJointLimitConeGeneratedValues( const PxJointLimitCone* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointLimitCone, YAngle, PxJointLimitConeGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxJointLimitCone, ZAngle, PxJointLimitConeGeneratedValues)
+	struct PxJointLimitConeGeneratedInfo
+		: PxJointLimitParametersGeneratedInfo
+	{
+		static const char* getClassName() { return "PxJointLimitCone"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointLimitCone_YAngle, PxJointLimitCone, PxReal, PxReal > YAngle;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxJointLimitCone_ZAngle, PxJointLimitCone, PxReal, PxReal > ZAngle;
+
+		 PxJointLimitConeGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxJointLimitCone*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxJointLimitParametersGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxJointLimitParametersGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxJointLimitParametersGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxJointLimitParametersGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( YAngle, inStartIndex + 0 );; 
+			inOperator( ZAngle, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxJointLimitCone>
+	{ 
+		PxJointLimitConeGeneratedInfo Info;
+		const PxJointLimitConeGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	class PxSpring;
+	struct PxSpringGeneratedValues
+	{
+		PxReal Stiffness;
+		PxReal Damping;
+		  PxSpringGeneratedValues( const PxSpring* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSpring, Stiffness, PxSpringGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxSpring, Damping, PxSpringGeneratedValues)
+	struct PxSpringGeneratedInfo
+
+	{
+		static const char* getClassName() { return "PxSpring"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSpring_Stiffness, PxSpring, PxReal, PxReal > Stiffness;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxSpring_Damping, PxSpring, PxReal, PxReal > Damping;
+
+		 PxSpringGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxSpring*>(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( Damping, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxSpring>
+	{ 
+		PxSpringGeneratedInfo Info;
+		const PxSpringGeneratedInfo* getInfo() { return &Info; }
+	};
+
+	static PxU32ToName g_physx__PxD6JointDriveFlag__EnumConversion[] = {
+		{ "eACCELERATION", static_cast<PxU32>( physx::PxD6JointDriveFlag::eACCELERATION ) },
+		{ NULL, 0 }
+	};
+
+template<> struct PxEnumTraits< physx::PxD6JointDriveFlag::Enum > { PxEnumTraits() : NameConversion( g_physx__PxD6JointDriveFlag__EnumConversion ) {} const PxU32ToName* NameConversion; }; 
+	class PxD6JointDrive;
+	struct PxD6JointDriveGeneratedValues
+		: PxSpringGeneratedValues	{
+		PxReal ForceLimit;
+		PxD6JointDriveFlags Flags;
+		  PxD6JointDriveGeneratedValues( const PxD6JointDrive* inSource );
+	};
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6JointDrive, ForceLimit, PxD6JointDriveGeneratedValues)
+	DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( PxD6JointDrive, Flags, PxD6JointDriveGeneratedValues)
+	struct PxD6JointDriveGeneratedInfo
+		: PxSpringGeneratedInfo
+	{
+		static const char* getClassName() { return "PxD6JointDrive"; }
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6JointDrive_ForceLimit, PxD6JointDrive, PxReal, PxReal > ForceLimit;
+		PxPropertyInfo<PX_PROPERTY_INFO_NAME::PxD6JointDrive_Flags, PxD6JointDrive, PxD6JointDriveFlags, PxD6JointDriveFlags > Flags;
+
+		 PxD6JointDriveGeneratedInfo();
+		template<typename TReturnType, typename TOperator>
+		TReturnType visitType( TOperator inOperator ) const
+		{
+			return inOperator( reinterpret_cast<PxD6JointDrive*>(NULL) );
+		}
+		template<typename TOperator>
+		void visitBases( TOperator inOperator )
+		{
+			PX_UNUSED(inOperator);
+			inOperator( *static_cast<PxSpringGeneratedInfo*>( this ) );
+		}
+		template<typename TOperator>
+		PxU32 visitBaseProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inStartIndex = PxSpringGeneratedInfo::visitBaseProperties( inOperator, inStartIndex );
+			inStartIndex = PxSpringGeneratedInfo::visitInstanceProperties( inOperator, inStartIndex );
+			return inStartIndex;
+		}
+		static PxU32 instancePropertyCount() { return 2; }
+		static PxU32 totalPropertyCount() { return instancePropertyCount()
+				+ PxSpringGeneratedInfo::totalPropertyCount(); }
+		template<typename TOperator>
+		PxU32 visitInstanceProperties( TOperator inOperator, PxU32 inStartIndex = 0 ) const
+		{
+			PX_UNUSED(inOperator);
+			PX_UNUSED(inStartIndex);
+			inOperator( ForceLimit, inStartIndex + 0 );; 
+			inOperator( Flags, inStartIndex + 1 );; 
+			return 2 + inStartIndex;
+		}
+	};
+	template<> struct PxClassInfoTraits<PxD6JointDrive>
+	{ 
+		PxD6JointDriveGeneratedInfo Info;
+		const PxD6JointDriveGeneratedInfo* 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/extensions/include/PxExtensionMetaDataObjects.h b/PhysX_3.4/Source/PhysXMetaData/extensions/include/PxExtensionMetaDataObjects.h
new file mode 100644
index 00000000..11c4575b
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/extensions/include/PxExtensionMetaDataObjects.h
@@ -0,0 +1,72 @@
+// 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_EXTENSION_METADATAOBJECTS_H
+#define PX_EXTENSION_METADATAOBJECTS_H
+#include "PxPhysicsAPI.h"
+#include "extensions/PxExtensionsAPI.h"
+#include "PxMetaDataObjects.h"
+
+/** \addtogroup physics
+@{
+*/
+
+namespace physx
+{
+
+class PxD6Joint;
+class PxJointLimitPair;
+class PxJointLimitCone;
+
+struct PxExtensionsPropertyInfoName
+{
+	enum Enum
+	{
+		Unnamed = PxPropertyInfoName::LastPxPropertyInfoName,
+#include "PxExtensionAutoGeneratedMetaDataObjectNames.h"
+		LastPxPropertyInfoName
+	};
+};
+
+#define DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP( type, prop, valueStruct )																			\
+	template<> struct PxPropertyToValueStructMemberMap< PxExtensionsPropertyInfoName::type##_##prop >											\
+	{																																			\
+		PxU32 Offset;																															\
+		PxPropertyToValueStructMemberMap< PxExtensionsPropertyInfoName::type##_##prop >() : Offset( PX_OFFSET_OF_RT( valueStruct, prop ) ) {}	\
+		template<typename TOperator> void visitProp( TOperator inOperator, valueStruct& inStruct ) { inOperator( inStruct.prop );	}			\
+	};
+
+#include "PxExtensionAutoGeneratedMetaDataObjects.h"
+
+#undef DEFINE_PROPERTY_TO_VALUE_STRUCT_MAP
+
+}
+
+/** @} */
+#endif
diff --git a/PhysX_3.4/Source/PhysXMetaData/extensions/src/PxExtensionAutoGeneratedMetaDataObjects.cpp b/PhysX_3.4/Source/PhysXMetaData/extensions/src/PxExtensionAutoGeneratedMetaDataObjects.cpp
new file mode 100644
index 00000000..251e8e46
--- /dev/null
+++ b/PhysX_3.4/Source/PhysXMetaData/extensions/src/PxExtensionAutoGeneratedMetaDataObjects.cpp
@@ -0,0 +1,423 @@
+// 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 "PxExtensionMetaDataObjects.h"
+#include "PxPhysicsAPI.h"
+#include "PxMetaDataCppPrefix.h"
+#include "PxExtensionsAPI.h"
+using namespace physx;
+void setPxJoint_Actors( PxJoint* inObj, PxRigidActor * inArg0, PxRigidActor * inArg1 ) { inObj->setActors( inArg0, inArg1 ); }
+void getPxJoint_Actors( const PxJoint* inObj, PxRigidActor *& inArg0, PxRigidActor *& inArg1 ) { inObj->getActors( inArg0, inArg1 ); }
+void setPxJoint_LocalPose( PxJoint* inObj, PxJointActorIndex::Enum inIndex, PxTransform inArg ){ inObj->setLocalPose( inIndex, inArg ); }
+PxTransform getPxJoint_LocalPose( const PxJoint* inObj, PxJointActorIndex::Enum inIndex ) { return inObj->getLocalPose( inIndex ); }
+PxTransform getPxJoint_RelativeTransform( const PxJoint* inObj ) { return inObj->getRelativeTransform(); }
+PxVec3 getPxJoint_RelativeLinearVelocity( const PxJoint* inObj ) { return inObj->getRelativeLinearVelocity(); }
+PxVec3 getPxJoint_RelativeAngularVelocity( const PxJoint* inObj ) { return inObj->getRelativeAngularVelocity(); }
+void setPxJoint_BreakForce( PxJoint* inObj, PxReal inArg0, PxReal inArg1 ) { inObj->setBreakForce( inArg0, inArg1 ); }
+void getPxJoint_BreakForce( const PxJoint* inObj, PxReal& inArg0, PxReal& inArg1 ) { inObj->getBreakForce( inArg0, inArg1 ); }
+void setPxJoint_ConstraintFlags( PxJoint* inObj, PxConstraintFlags inArg){ inObj->setConstraintFlags( inArg ); }
+PxConstraintFlags getPxJoint_ConstraintFlags( const PxJoint* inObj ) { return inObj->getConstraintFlags(); }
+void setPxJoint_InvMassScale0( PxJoint* inObj, PxReal inArg){ inObj->setInvMassScale0( inArg ); }
+PxReal getPxJoint_InvMassScale0( const PxJoint* inObj ) { return inObj->getInvMassScale0(); }
+void setPxJoint_InvInertiaScale0( PxJoint* inObj, PxReal inArg){ inObj->setInvInertiaScale0( inArg ); }
+PxReal getPxJoint_InvInertiaScale0( const PxJoint* inObj ) { return inObj->getInvInertiaScale0(); }
+void setPxJoint_InvMassScale1( PxJoint* inObj, PxReal inArg){ inObj->setInvMassScale1( inArg ); }
+PxReal getPxJoint_InvMassScale1( const PxJoint* inObj ) { return inObj->getInvMassScale1(); }
+void setPxJoint_InvInertiaScale1( PxJoint* inObj, PxReal inArg){ inObj->setInvInertiaScale1( inArg ); }
+PxReal getPxJoint_InvInertiaScale1( const PxJoint* inObj ) { return inObj->getInvInertiaScale1(); }
+PxConstraint * getPxJoint_Constraint( const PxJoint* inObj ) { return inObj->getConstraint(); }
+void setPxJoint_Name( PxJoint* inObj, const char * inArg){ inObj->setName( inArg ); }
+const char * getPxJoint_Name( const PxJoint* inObj ) { return inObj->getName(); }
+PxScene * getPxJoint_Scene( const PxJoint* inObj ) { return inObj->getScene(); }
+inline void * getPxJointUserData( const PxJoint* inOwner ) { return inOwner->userData; }
+inline void setPxJointUserData( PxJoint* inOwner, void * inData) { inOwner->userData = inData; }
+ PxJointGeneratedInfo::PxJointGeneratedInfo()
+	: Actors( "Actors", "actor0", "actor1", setPxJoint_Actors, getPxJoint_Actors)
+	, LocalPose( "LocalPose", setPxJoint_LocalPose, getPxJoint_LocalPose)
+	, RelativeTransform( "RelativeTransform", getPxJoint_RelativeTransform)
+	, RelativeLinearVelocity( "RelativeLinearVelocity", getPxJoint_RelativeLinearVelocity)
+	, RelativeAngularVelocity( "RelativeAngularVelocity", getPxJoint_RelativeAngularVelocity)
+	, BreakForce( "BreakForce", "force", "torque", setPxJoint_BreakForce, getPxJoint_BreakForce)
+	, ConstraintFlags( "ConstraintFlags", setPxJoint_ConstraintFlags, getPxJoint_ConstraintFlags)
+	, InvMassScale0( "InvMassScale0", setPxJoint_InvMassScale0, getPxJoint_InvMassScale0)
+	, InvInertiaScale0( "InvInertiaScale0", setPxJoint_InvInertiaScale0, getPxJoint_InvInertiaScale0)
+	, InvMassScale1( "InvMassScale1", setPxJoint_InvMassScale1, getPxJoint_InvMassScale1)
+	, InvInertiaScale1( "InvInertiaScale1", setPxJoint_InvInertiaScale1, getPxJoint_InvInertiaScale1)
+	, Constraint( "Constraint", getPxJoint_Constraint)
+	, Name( "Name", setPxJoint_Name, getPxJoint_Name)
+	, Scene( "Scene", getPxJoint_Scene)
+	, UserData( "UserData", setPxJointUserData, getPxJointUserData )
+{}
+ PxJointGeneratedValues::PxJointGeneratedValues( const PxJoint* inSource )
+		:RelativeTransform( getPxJoint_RelativeTransform( inSource ) )
+		,RelativeLinearVelocity( getPxJoint_RelativeLinearVelocity( inSource ) )
+		,RelativeAngularVelocity( getPxJoint_RelativeAngularVelocity( inSource ) )
+		,ConstraintFlags( getPxJoint_ConstraintFlags( inSource ) )
+		,InvMassScale0( getPxJoint_InvMassScale0( inSource ) )
+		,InvInertiaScale0( getPxJoint_InvInertiaScale0( inSource ) )
+		,InvMassScale1( getPxJoint_InvMassScale1( inSource ) )
+		,InvInertiaScale1( getPxJoint_InvInertiaScale1( inSource ) )
+		,Constraint( getPxJoint_Constraint( inSource ) )
+		,Name( getPxJoint_Name( inSource ) )
+		,Scene( getPxJoint_Scene( inSource ) )
+		,UserData( inSource->userData )
+{
+	PX_UNUSED(inSource);
+	getPxJoint_Actors( inSource, Actors[0], Actors[1] );
+		for ( PxU32 idx = 0; idx < static_cast<PxU32>( physx::PxJointActorIndex::COUNT ); ++idx )
+		LocalPose[idx] = getPxJoint_LocalPose( inSource, static_cast< PxJointActorIndex::Enum >( idx ) );
+	getPxJoint_BreakForce( inSource, BreakForce[0], BreakForce[1] );
+}
+void setPxD6Joint_Motion( PxD6Joint* inObj, PxD6Axis::Enum inIndex, PxD6Motion::Enum inArg ){ inObj->setMotion( inIndex, inArg ); }
+PxD6Motion::Enum getPxD6Joint_Motion( const PxD6Joint* inObj, PxD6Axis::Enum inIndex ) { return inObj->getMotion( inIndex ); }
+PxReal getPxD6Joint_Twist( const PxD6Joint* inObj ) { return inObj->getTwist(); }
+PxReal getPxD6Joint_SwingYAngle( const PxD6Joint* inObj ) { return inObj->getSwingYAngle(); }
+PxReal getPxD6Joint_SwingZAngle( const PxD6Joint* inObj ) { return inObj->getSwingZAngle(); }
+void setPxD6Joint_LinearLimit( PxD6Joint* inObj, const PxJointLinearLimit & inArg){ inObj->setLinearLimit( inArg ); }
+PxJointLinearLimit getPxD6Joint_LinearLimit( const PxD6Joint* inObj ) { return inObj->getLinearLimit(); }
+void setPxD6Joint_TwistLimit( PxD6Joint* inObj, const PxJointAngularLimitPair & inArg){ inObj->setTwistLimit( inArg ); }
+PxJointAngularLimitPair getPxD6Joint_TwistLimit( const PxD6Joint* inObj ) { return inObj->getTwistLimit(); }
+void setPxD6Joint_SwingLimit( PxD6Joint* inObj, const PxJointLimitCone & inArg){ inObj->setSwingLimit( inArg ); }
+PxJointLimitCone getPxD6Joint_SwingLimit( const PxD6Joint* inObj ) { return inObj->getSwingLimit(); }
+void setPxD6Joint_Drive( PxD6Joint* inObj, PxD6Drive::Enum inIndex, PxD6JointDrive inArg ){ inObj->setDrive( inIndex, inArg ); }
+PxD6JointDrive getPxD6Joint_Drive( const PxD6Joint* inObj, PxD6Drive::Enum inIndex ) { return inObj->getDrive( inIndex ); }
+void setPxD6Joint_DrivePosition( PxD6Joint* inObj, const PxTransform & inArg){ inObj->setDrivePosition( inArg ); }
+PxTransform getPxD6Joint_DrivePosition( const PxD6Joint* inObj ) { return inObj->getDrivePosition(); }
+void setPxD6Joint_DriveVelocity( PxD6Joint* inObj, PxVec3 inArg0, PxVec3 inArg1 ) { inObj->setDriveVelocity( inArg0, inArg1 ); }
+void getPxD6Joint_DriveVelocity( const PxD6Joint* inObj, PxVec3& inArg0, PxVec3& inArg1 ) { inObj->getDriveVelocity( inArg0, inArg1 ); }
+void setPxD6Joint_ProjectionLinearTolerance( PxD6Joint* inObj, PxReal inArg){ inObj->setProjectionLinearTolerance( inArg ); }
+PxReal getPxD6Joint_ProjectionLinearTolerance( const PxD6Joint* inObj ) { return inObj->getProjectionLinearTolerance(); }
+void setPxD6Joint_ProjectionAngularTolerance( PxD6Joint* inObj, PxReal inArg){ inObj->setProjectionAngularTolerance( inArg ); }
+PxReal getPxD6Joint_ProjectionAngularTolerance( const PxD6Joint* inObj ) { return inObj->getProjectionAngularTolerance(); }
+const char * getPxD6Joint_ConcreteTypeName( const PxD6Joint* inObj ) { return inObj->getConcreteTypeName(); }
+ PxD6JointGeneratedInfo::PxD6JointGeneratedInfo()
+	: Motion( "Motion", setPxD6Joint_Motion, getPxD6Joint_Motion)
+	, Twist( "Twist", getPxD6Joint_Twist)
+	, SwingYAngle( "SwingYAngle", getPxD6Joint_SwingYAngle)
+	, SwingZAngle( "SwingZAngle", getPxD6Joint_SwingZAngle)
+	, LinearLimit( "LinearLimit", setPxD6Joint_LinearLimit, getPxD6Joint_LinearLimit)
+	, TwistLimit( "TwistLimit", setPxD6Joint_TwistLimit, getPxD6Joint_TwistLimit)
+	, SwingLimit( "SwingLimit", setPxD6Joint_SwingLimit, getPxD6Joint_SwingLimit)
+	, Drive( "Drive", setPxD6Joint_Drive, getPxD6Joint_Drive)
+	, DrivePosition( "DrivePosition", setPxD6Joint_DrivePosition, getPxD6Joint_DrivePosition)
+	, DriveVelocity( "DriveVelocity", "linear", "angular", setPxD6Joint_DriveVelocity, getPxD6Joint_DriveVelocity)
+	, ProjectionLinearTolerance( "ProjectionLinearTolerance", setPxD6Joint_ProjectionLinearTolerance, getPxD6Joint_ProjectionLinearTolerance)
+	, ProjectionAngularTolerance( "ProjectionAngularTolerance", setPxD6Joint_ProjectionAngularTolerance, getPxD6Joint_ProjectionAngularTolerance)
+	, ConcreteTypeName( "ConcreteTypeName", getPxD6Joint_ConcreteTypeName)
+{}
+ PxD6JointGeneratedValues::PxD6JointGeneratedValues( const PxD6Joint* inSource )
+		:PxJointGeneratedValues( inSource )
+		,Twist( getPxD6Joint_Twist( inSource ) )
+		,SwingYAngle( getPxD6Joint_SwingYAngle( inSource ) )
+		,SwingZAngle( getPxD6Joint_SwingZAngle( inSource ) )
+		,LinearLimit( getPxD6Joint_LinearLimit( inSource ) )
+		,TwistLimit( getPxD6Joint_TwistLimit( inSource ) )
+		,SwingLimit( getPxD6Joint_SwingLimit( inSource ) )
+		,DrivePosition( getPxD6Joint_DrivePosition( inSource ) )
+		,ProjectionLinearTolerance( getPxD6Joint_ProjectionLinearTolerance( inSource ) )
+		,ProjectionAngularTolerance( getPxD6Joint_ProjectionAngularTolerance( inSource ) )
+		,ConcreteTypeName( getPxD6Joint_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+		for ( PxU32 idx = 0; idx < static_cast<PxU32>( physx::PxD6Axis::eCOUNT ); ++idx )
+		Motion[idx] = getPxD6Joint_Motion( inSource, static_cast< PxD6Axis::Enum >( idx ) );
+		for ( PxU32 idx = 0; idx < static_cast<PxU32>( physx::PxD6Drive::eCOUNT ); ++idx )
+		Drive[idx] = getPxD6Joint_Drive( inSource, static_cast< PxD6Drive::Enum >( idx ) );
+	getPxD6Joint_DriveVelocity( inSource, DriveVelocity[0], DriveVelocity[1] );
+}
+PxReal getPxDistanceJoint_Distance( const PxDistanceJoint* inObj ) { return inObj->getDistance(); }
+void setPxDistanceJoint_MinDistance( PxDistanceJoint* inObj, PxReal inArg){ inObj->setMinDistance( inArg ); }
+PxReal getPxDistanceJoint_MinDistance( const PxDistanceJoint* inObj ) { return inObj->getMinDistance(); }
+void setPxDistanceJoint_MaxDistance( PxDistanceJoint* inObj, PxReal inArg){ inObj->setMaxDistance( inArg ); }
+PxReal getPxDistanceJoint_MaxDistance( const PxDistanceJoint* inObj ) { return inObj->getMaxDistance(); }
+void setPxDistanceJoint_Tolerance( PxDistanceJoint* inObj, PxReal inArg){ inObj->setTolerance( inArg ); }
+PxReal getPxDistanceJoint_Tolerance( const PxDistanceJoint* inObj ) { return inObj->getTolerance(); }
+void setPxDistanceJoint_Stiffness( PxDistanceJoint* inObj, PxReal inArg){ inObj->setStiffness( inArg ); }
+PxReal getPxDistanceJoint_Stiffness( const PxDistanceJoint* inObj ) { return inObj->getStiffness(); }
+void setPxDistanceJoint_Damping( PxDistanceJoint* inObj, PxReal inArg){ inObj->setDamping( inArg ); }
+PxReal getPxDistanceJoint_Damping( const PxDistanceJoint* inObj ) { return inObj->getDamping(); }
+void setPxDistanceJoint_DistanceJointFlags( PxDistanceJoint* inObj, PxDistanceJointFlags inArg){ inObj->setDistanceJointFlags( inArg ); }
+PxDistanceJointFlags getPxDistanceJoint_DistanceJointFlags( const PxDistanceJoint* inObj ) { return inObj->getDistanceJointFlags(); }
+const char * getPxDistanceJoint_ConcreteTypeName( const PxDistanceJoint* inObj ) { return inObj->getConcreteTypeName(); }
+ PxDistanceJointGeneratedInfo::PxDistanceJointGeneratedInfo()
+	: Distance( "Distance", getPxDistanceJoint_Distance)
+	, MinDistance( "MinDistance", setPxDistanceJoint_MinDistance, getPxDistanceJoint_MinDistance)
+	, MaxDistance( "MaxDistance", setPxDistanceJoint_MaxDistance, getPxDistanceJoint_MaxDistance)
+	, Tolerance( "Tolerance", setPxDistanceJoint_Tolerance, getPxDistanceJoint_Tolerance)
+	, Stiffness( "Stiffness", setPxDistanceJoint_Stiffness, getPxDistanceJoint_Stiffness)
+	, Damping( "Damping", setPxDistanceJoint_Damping, getPxDistanceJoint_Damping)
+	, DistanceJointFlags( "DistanceJointFlags", setPxDistanceJoint_DistanceJointFlags, getPxDistanceJoint_DistanceJointFlags)
+	, ConcreteTypeName( "ConcreteTypeName", getPxDistanceJoint_ConcreteTypeName)
+{}
+ PxDistanceJointGeneratedValues::PxDistanceJointGeneratedValues( const PxDistanceJoint* inSource )
+		:PxJointGeneratedValues( inSource )
+		,Distance( getPxDistanceJoint_Distance( inSource ) )
+		,MinDistance( getPxDistanceJoint_MinDistance( inSource ) )
+		,MaxDistance( getPxDistanceJoint_MaxDistance( inSource ) )
+		,Tolerance( getPxDistanceJoint_Tolerance( inSource ) )
+		,Stiffness( getPxDistanceJoint_Stiffness( inSource ) )
+		,Damping( getPxDistanceJoint_Damping( inSource ) )
+		,DistanceJointFlags( getPxDistanceJoint_DistanceJointFlags( inSource ) )
+		,ConcreteTypeName( getPxDistanceJoint_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+void setPxFixedJoint_ProjectionLinearTolerance( PxFixedJoint* inObj, PxReal inArg){ inObj->setProjectionLinearTolerance( inArg ); }
+PxReal getPxFixedJoint_ProjectionLinearTolerance( const PxFixedJoint* inObj ) { return inObj->getProjectionLinearTolerance(); }
+void setPxFixedJoint_ProjectionAngularTolerance( PxFixedJoint* inObj, PxReal inArg){ inObj->setProjectionAngularTolerance( inArg ); }
+PxReal getPxFixedJoint_ProjectionAngularTolerance( const PxFixedJoint* inObj ) { return inObj->getProjectionAngularTolerance(); }
+const char * getPxFixedJoint_ConcreteTypeName( const PxFixedJoint* inObj ) { return inObj->getConcreteTypeName(); }
+ PxFixedJointGeneratedInfo::PxFixedJointGeneratedInfo()
+	: ProjectionLinearTolerance( "ProjectionLinearTolerance", setPxFixedJoint_ProjectionLinearTolerance, getPxFixedJoint_ProjectionLinearTolerance)
+	, ProjectionAngularTolerance( "ProjectionAngularTolerance", setPxFixedJoint_ProjectionAngularTolerance, getPxFixedJoint_ProjectionAngularTolerance)
+	, ConcreteTypeName( "ConcreteTypeName", getPxFixedJoint_ConcreteTypeName)
+{}
+ PxFixedJointGeneratedValues::PxFixedJointGeneratedValues( const PxFixedJoint* inSource )
+		:PxJointGeneratedValues( inSource )
+		,ProjectionLinearTolerance( getPxFixedJoint_ProjectionLinearTolerance( inSource ) )
+		,ProjectionAngularTolerance( getPxFixedJoint_ProjectionAngularTolerance( inSource ) )
+		,ConcreteTypeName( getPxFixedJoint_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+PxReal getPxPrismaticJoint_Position( const PxPrismaticJoint* inObj ) { return inObj->getPosition(); }
+PxReal getPxPrismaticJoint_Velocity( const PxPrismaticJoint* inObj ) { return inObj->getVelocity(); }
+void setPxPrismaticJoint_Limit( PxPrismaticJoint* inObj, const PxJointLinearLimitPair & inArg){ inObj->setLimit( inArg ); }
+PxJointLinearLimitPair getPxPrismaticJoint_Limit( const PxPrismaticJoint* inObj ) { return inObj->getLimit(); }
+void setPxPrismaticJoint_PrismaticJointFlags( PxPrismaticJoint* inObj, PxPrismaticJointFlags inArg){ inObj->setPrismaticJointFlags( inArg ); }
+PxPrismaticJointFlags getPxPrismaticJoint_PrismaticJointFlags( const PxPrismaticJoint* inObj ) { return inObj->getPrismaticJointFlags(); }
+void setPxPrismaticJoint_ProjectionLinearTolerance( PxPrismaticJoint* inObj, PxReal inArg){ inObj->setProjectionLinearTolerance( inArg ); }
+PxReal getPxPrismaticJoint_ProjectionLinearTolerance( const PxPrismaticJoint* inObj ) { return inObj->getProjectionLinearTolerance(); }
+void setPxPrismaticJoint_ProjectionAngularTolerance( PxPrismaticJoint* inObj, PxReal inArg){ inObj->setProjectionAngularTolerance( inArg ); }
+PxReal getPxPrismaticJoint_ProjectionAngularTolerance( const PxPrismaticJoint* inObj ) { return inObj->getProjectionAngularTolerance(); }
+const char * getPxPrismaticJoint_ConcreteTypeName( const PxPrismaticJoint* inObj ) { return inObj->getConcreteTypeName(); }
+ PxPrismaticJointGeneratedInfo::PxPrismaticJointGeneratedInfo()
+	: Position( "Position", getPxPrismaticJoint_Position)
+	, Velocity( "Velocity", getPxPrismaticJoint_Velocity)
+	, Limit( "Limit", setPxPrismaticJoint_Limit, getPxPrismaticJoint_Limit)
+	, PrismaticJointFlags( "PrismaticJointFlags", setPxPrismaticJoint_PrismaticJointFlags, getPxPrismaticJoint_PrismaticJointFlags)
+	, ProjectionLinearTolerance( "ProjectionLinearTolerance", setPxPrismaticJoint_ProjectionLinearTolerance, getPxPrismaticJoint_ProjectionLinearTolerance)
+	, ProjectionAngularTolerance( "ProjectionAngularTolerance", setPxPrismaticJoint_ProjectionAngularTolerance, getPxPrismaticJoint_ProjectionAngularTolerance)
+	, ConcreteTypeName( "ConcreteTypeName", getPxPrismaticJoint_ConcreteTypeName)
+{}
+ PxPrismaticJointGeneratedValues::PxPrismaticJointGeneratedValues( const PxPrismaticJoint* inSource )
+		:PxJointGeneratedValues( inSource )
+		,Position( getPxPrismaticJoint_Position( inSource ) )
+		,Velocity( getPxPrismaticJoint_Velocity( inSource ) )
+		,Limit( getPxPrismaticJoint_Limit( inSource ) )
+		,PrismaticJointFlags( getPxPrismaticJoint_PrismaticJointFlags( inSource ) )
+		,ProjectionLinearTolerance( getPxPrismaticJoint_ProjectionLinearTolerance( inSource ) )
+		,ProjectionAngularTolerance( getPxPrismaticJoint_ProjectionAngularTolerance( inSource ) )
+		,ConcreteTypeName( getPxPrismaticJoint_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+PxReal getPxRevoluteJoint_Angle( const PxRevoluteJoint* inObj ) { return inObj->getAngle(); }
+PxReal getPxRevoluteJoint_Velocity( const PxRevoluteJoint* inObj ) { return inObj->getVelocity(); }
+void setPxRevoluteJoint_Limit( PxRevoluteJoint* inObj, const PxJointAngularLimitPair & inArg){ inObj->setLimit( inArg ); }
+PxJointAngularLimitPair getPxRevoluteJoint_Limit( const PxRevoluteJoint* inObj ) { return inObj->getLimit(); }
+void setPxRevoluteJoint_DriveVelocity( PxRevoluteJoint* inObj, PxReal inArg){ inObj->setDriveVelocity( inArg ); }
+PxReal getPxRevoluteJoint_DriveVelocity( const PxRevoluteJoint* inObj ) { return inObj->getDriveVelocity(); }
+void setPxRevoluteJoint_DriveForceLimit( PxRevoluteJoint* inObj, PxReal inArg){ inObj->setDriveForceLimit( inArg ); }
+PxReal getPxRevoluteJoint_DriveForceLimit( const PxRevoluteJoint* inObj ) { return inObj->getDriveForceLimit(); }
+void setPxRevoluteJoint_DriveGearRatio( PxRevoluteJoint* inObj, PxReal inArg){ inObj->setDriveGearRatio( inArg ); }
+PxReal getPxRevoluteJoint_DriveGearRatio( const PxRevoluteJoint* inObj ) { return inObj->getDriveGearRatio(); }
+void setPxRevoluteJoint_RevoluteJointFlags( PxRevoluteJoint* inObj, PxRevoluteJointFlags inArg){ inObj->setRevoluteJointFlags( inArg ); }
+PxRevoluteJointFlags getPxRevoluteJoint_RevoluteJointFlags( const PxRevoluteJoint* inObj ) { return inObj->getRevoluteJointFlags(); }
+void setPxRevoluteJoint_ProjectionLinearTolerance( PxRevoluteJoint* inObj, PxReal inArg){ inObj->setProjectionLinearTolerance( inArg ); }
+PxReal getPxRevoluteJoint_ProjectionLinearTolerance( const PxRevoluteJoint* inObj ) { return inObj->getProjectionLinearTolerance(); }
+void setPxRevoluteJoint_ProjectionAngularTolerance( PxRevoluteJoint* inObj, PxReal inArg){ inObj->setProjectionAngularTolerance( inArg ); }
+PxReal getPxRevoluteJoint_ProjectionAngularTolerance( const PxRevoluteJoint* inObj ) { return inObj->getProjectionAngularTolerance(); }
+const char * getPxRevoluteJoint_ConcreteTypeName( const PxRevoluteJoint* inObj ) { return inObj->getConcreteTypeName(); }
+ PxRevoluteJointGeneratedInfo::PxRevoluteJointGeneratedInfo()
+	: Angle( "Angle", getPxRevoluteJoint_Angle)
+	, Velocity( "Velocity", getPxRevoluteJoint_Velocity)
+	, Limit( "Limit", setPxRevoluteJoint_Limit, getPxRevoluteJoint_Limit)
+	, DriveVelocity( "DriveVelocity", setPxRevoluteJoint_DriveVelocity, getPxRevoluteJoint_DriveVelocity)
+	, DriveForceLimit( "DriveForceLimit", setPxRevoluteJoint_DriveForceLimit, getPxRevoluteJoint_DriveForceLimit)
+	, DriveGearRatio( "DriveGearRatio", setPxRevoluteJoint_DriveGearRatio, getPxRevoluteJoint_DriveGearRatio)
+	, RevoluteJointFlags( "RevoluteJointFlags", setPxRevoluteJoint_RevoluteJointFlags, getPxRevoluteJoint_RevoluteJointFlags)
+	, ProjectionLinearTolerance( "ProjectionLinearTolerance", setPxRevoluteJoint_ProjectionLinearTolerance, getPxRevoluteJoint_ProjectionLinearTolerance)
+	, ProjectionAngularTolerance( "ProjectionAngularTolerance", setPxRevoluteJoint_ProjectionAngularTolerance, getPxRevoluteJoint_ProjectionAngularTolerance)
+	, ConcreteTypeName( "ConcreteTypeName", getPxRevoluteJoint_ConcreteTypeName)
+{}
+ PxRevoluteJointGeneratedValues::PxRevoluteJointGeneratedValues( const PxRevoluteJoint* inSource )
+		:PxJointGeneratedValues( inSource )
+		,Angle( getPxRevoluteJoint_Angle( inSource ) )
+		,Velocity( getPxRevoluteJoint_Velocity( inSource ) )
+		,Limit( getPxRevoluteJoint_Limit( inSource ) )
+		,DriveVelocity( getPxRevoluteJoint_DriveVelocity( inSource ) )
+		,DriveForceLimit( getPxRevoluteJoint_DriveForceLimit( inSource ) )
+		,DriveGearRatio( getPxRevoluteJoint_DriveGearRatio( inSource ) )
+		,RevoluteJointFlags( getPxRevoluteJoint_RevoluteJointFlags( inSource ) )
+		,ProjectionLinearTolerance( getPxRevoluteJoint_ProjectionLinearTolerance( inSource ) )
+		,ProjectionAngularTolerance( getPxRevoluteJoint_ProjectionAngularTolerance( inSource ) )
+		,ConcreteTypeName( getPxRevoluteJoint_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+void setPxSphericalJoint_LimitCone( PxSphericalJoint* inObj, const PxJointLimitCone & inArg){ inObj->setLimitCone( inArg ); }
+PxJointLimitCone getPxSphericalJoint_LimitCone( const PxSphericalJoint* inObj ) { return inObj->getLimitCone(); }
+void setPxSphericalJoint_SphericalJointFlags( PxSphericalJoint* inObj, PxSphericalJointFlags inArg){ inObj->setSphericalJointFlags( inArg ); }
+PxSphericalJointFlags getPxSphericalJoint_SphericalJointFlags( const PxSphericalJoint* inObj ) { return inObj->getSphericalJointFlags(); }
+void setPxSphericalJoint_ProjectionLinearTolerance( PxSphericalJoint* inObj, PxReal inArg){ inObj->setProjectionLinearTolerance( inArg ); }
+PxReal getPxSphericalJoint_ProjectionLinearTolerance( const PxSphericalJoint* inObj ) { return inObj->getProjectionLinearTolerance(); }
+const char * getPxSphericalJoint_ConcreteTypeName( const PxSphericalJoint* inObj ) { return inObj->getConcreteTypeName(); }
+ PxSphericalJointGeneratedInfo::PxSphericalJointGeneratedInfo()
+	: LimitCone( "LimitCone", setPxSphericalJoint_LimitCone, getPxSphericalJoint_LimitCone)
+	, SphericalJointFlags( "SphericalJointFlags", setPxSphericalJoint_SphericalJointFlags, getPxSphericalJoint_SphericalJointFlags)
+	, ProjectionLinearTolerance( "ProjectionLinearTolerance", setPxSphericalJoint_ProjectionLinearTolerance, getPxSphericalJoint_ProjectionLinearTolerance)
+	, ConcreteTypeName( "ConcreteTypeName", getPxSphericalJoint_ConcreteTypeName)
+{}
+ PxSphericalJointGeneratedValues::PxSphericalJointGeneratedValues( const PxSphericalJoint* inSource )
+		:PxJointGeneratedValues( inSource )
+		,LimitCone( getPxSphericalJoint_LimitCone( inSource ) )
+		,SphericalJointFlags( getPxSphericalJoint_SphericalJointFlags( inSource ) )
+		,ProjectionLinearTolerance( getPxSphericalJoint_ProjectionLinearTolerance( inSource ) )
+		,ConcreteTypeName( getPxSphericalJoint_ConcreteTypeName( inSource ) )
+{
+	PX_UNUSED(inSource);
+}
+inline PxReal getPxJointLimitParametersRestitution( const PxJointLimitParameters* inOwner ) { return inOwner->restitution; }
+inline void setPxJointLimitParametersRestitution( PxJointLimitParameters* inOwner, PxReal inData) { inOwner->restitution = inData; }
+inline PxReal getPxJointLimitParametersBounceThreshold( const PxJointLimitParameters* inOwner ) { return inOwner->bounceThreshold; }
+inline void setPxJointLimitParametersBounceThreshold( PxJointLimitParameters* inOwner, PxReal inData) { inOwner->bounceThreshold = inData; }
+inline PxReal getPxJointLimitParametersStiffness( const PxJointLimitParameters* inOwner ) { return inOwner->stiffness; }
+inline void setPxJointLimitParametersStiffness( PxJointLimitParameters* inOwner, PxReal inData) { inOwner->stiffness = inData; }
+inline PxReal getPxJointLimitParametersDamping( const PxJointLimitParameters* inOwner ) { return inOwner->damping; }
+inline void setPxJointLimitParametersDamping( PxJointLimitParameters* inOwner, PxReal inData) { inOwner->damping = inData; }
+inline PxReal getPxJointLimitParametersContactDistance( const PxJointLimitParameters* inOwner ) { return inOwner->contactDistance; }
+inline void setPxJointLimitParametersContactDistance( PxJointLimitParameters* inOwner, PxReal inData) { inOwner->contactDistance = inData; }
+ PxJointLimitParametersGeneratedInfo::PxJointLimitParametersGeneratedInfo()
+	: Restitution( "Restitution", setPxJointLimitParametersRestitution, getPxJointLimitParametersRestitution )
+	, BounceThreshold( "BounceThreshold", setPxJointLimitParametersBounceThreshold, getPxJointLimitParametersBounceThreshold )
+	, Stiffness( "Stiffness", setPxJointLimitParametersStiffness, getPxJointLimitParametersStiffness )
+	, Damping( "Damping", setPxJointLimitParametersDamping, getPxJointLimitParametersDamping )
+	, ContactDistance( "ContactDistance", setPxJointLimitParametersContactDistance, getPxJointLimitParametersContactDistance )
+{}
+ PxJointLimitParametersGeneratedValues::PxJointLimitParametersGeneratedValues( const PxJointLimitParameters* inSource )
+		:Restitution( inSource->restitution )
+		,BounceThreshold( inSource->bounceThreshold )
+		,Stiffness( inSource->stiffness )
+		,Damping( inSource->damping )
+		,ContactDistance( inSource->contactDistance )
+{
+	PX_UNUSED(inSource);
+}
+inline PxReal getPxJointLinearLimitValue( const PxJointLinearLimit* inOwner ) { return inOwner->value; }
+inline void setPxJointLinearLimitValue( PxJointLinearLimit* inOwner, PxReal inData) { inOwner->value = inData; }
+ PxJointLinearLimitGeneratedInfo::PxJointLinearLimitGeneratedInfo()
+	: Value( "Value", setPxJointLinearLimitValue, getPxJointLinearLimitValue )
+{}
+ PxJointLinearLimitGeneratedValues::PxJointLinearLimitGeneratedValues( const PxJointLinearLimit* inSource )
+		:PxJointLimitParametersGeneratedValues( inSource )
+		,Value( inSource->value )
+{
+	PX_UNUSED(inSource);
+}
+inline PxReal getPxJointLinearLimitPairUpper( const PxJointLinearLimitPair* inOwner ) { return inOwner->upper; }
+inline void setPxJointLinearLimitPairUpper( PxJointLinearLimitPair* inOwner, PxReal inData) { inOwner->upper = inData; }
+inline PxReal getPxJointLinearLimitPairLower( const PxJointLinearLimitPair* inOwner ) { return inOwner->lower; }
+inline void setPxJointLinearLimitPairLower( PxJointLinearLimitPair* inOwner, PxReal inData) { inOwner->lower = inData; }
+ PxJointLinearLimitPairGeneratedInfo::PxJointLinearLimitPairGeneratedInfo()
+	: Upper( "Upper", setPxJointLinearLimitPairUpper, getPxJointLinearLimitPairUpper )
+	, Lower( "Lower", setPxJointLinearLimitPairLower, getPxJointLinearLimitPairLower )
+{}
+ PxJointLinearLimitPairGeneratedValues::PxJointLinearLimitPairGeneratedValues( const PxJointLinearLimitPair* inSource )
+		:PxJointLimitParametersGeneratedValues( inSource )
+		,Upper( inSource->upper )
+		,Lower( inSource->lower )
+{
+	PX_UNUSED(inSource);
+}
+inline PxReal getPxJointAngularLimitPairUpper( const PxJointAngularLimitPair* inOwner ) { return inOwner->upper; }
+inline void setPxJointAngularLimitPairUpper( PxJointAngularLimitPair* inOwner, PxReal inData) { inOwner->upper = inData; }
+inline PxReal getPxJointAngularLimitPairLower( const PxJointAngularLimitPair* inOwner ) { return inOwner->lower; }
+inline void setPxJointAngularLimitPairLower( PxJointAngularLimitPair* inOwner, PxReal inData) { inOwner->lower = inData; }
+ PxJointAngularLimitPairGeneratedInfo::PxJointAngularLimitPairGeneratedInfo()
+	: Upper( "Upper", setPxJointAngularLimitPairUpper, getPxJointAngularLimitPairUpper )
+	, Lower( "Lower", setPxJointAngularLimitPairLower, getPxJointAngularLimitPairLower )
+{}
+ PxJointAngularLimitPairGeneratedValues::PxJointAngularLimitPairGeneratedValues( const PxJointAngularLimitPair* inSource )
+		:PxJointLimitParametersGeneratedValues( inSource )
+		,Upper( inSource->upper )
+		,Lower( inSource->lower )
+{
+	PX_UNUSED(inSource);
+}
+inline PxReal getPxJointLimitConeYAngle( const PxJointLimitCone* inOwner ) { return inOwner->yAngle; }
+inline void setPxJointLimitConeYAngle( PxJointLimitCone* inOwner, PxReal inData) { inOwner->yAngle = inData; }
+inline PxReal getPxJointLimitConeZAngle( const PxJointLimitCone* inOwner ) { return inOwner->zAngle; }
+inline void setPxJointLimitConeZAngle( PxJointLimitCone* inOwner, PxReal inData) { inOwner->zAngle = inData; }
+ PxJointLimitConeGeneratedInfo::PxJointLimitConeGeneratedInfo()
+	: YAngle( "YAngle", setPxJointLimitConeYAngle, getPxJointLimitConeYAngle )
+	, ZAngle( "ZAngle", setPxJointLimitConeZAngle, getPxJointLimitConeZAngle )
+{}
+ PxJointLimitConeGeneratedValues::PxJointLimitConeGeneratedValues( const PxJointLimitCone* inSource )
+		:PxJointLimitParametersGeneratedValues( inSource )
+		,YAngle( inSource->yAngle )
+		,ZAngle( inSource->zAngle )
+{
+	PX_UNUSED(inSource);
+}
+inline PxReal getPxSpringStiffness( const PxSpring* inOwner ) { return inOwner->stiffness; }
+inline void setPxSpringStiffness( PxSpring* inOwner, PxReal inData) { inOwner->stiffness = inData; }
+inline PxReal getPxSpringDamping( const PxSpring* inOwner ) { return inOwner->damping; }
+inline void setPxSpringDamping( PxSpring* inOwner, PxReal inData) { inOwner->damping = inData; }
+ PxSpringGeneratedInfo::PxSpringGeneratedInfo()
+	: Stiffness( "Stiffness", setPxSpringStiffness, getPxSpringStiffness )
+	, Damping( "Damping", setPxSpringDamping, getPxSpringDamping )
+{}
+ PxSpringGeneratedValues::PxSpringGeneratedValues( const PxSpring* inSource )
+		:Stiffness( inSource->stiffness )
+		,Damping( inSource->damping )
+{
+	PX_UNUSED(inSource);
+}
+inline PxReal getPxD6JointDriveForceLimit( const PxD6JointDrive* inOwner ) { return inOwner->forceLimit; }
+inline void setPxD6JointDriveForceLimit( PxD6JointDrive* inOwner, PxReal inData) { inOwner->forceLimit = inData; }
+inline PxD6JointDriveFlags getPxD6JointDriveFlags( const PxD6JointDrive* inOwner ) { return inOwner->flags; }
+inline void setPxD6JointDriveFlags( PxD6JointDrive* inOwner, PxD6JointDriveFlags inData) { inOwner->flags = inData; }
+ PxD6JointDriveGeneratedInfo::PxD6JointDriveGeneratedInfo()
+	: ForceLimit( "ForceLimit", setPxD6JointDriveForceLimit, getPxD6JointDriveForceLimit )
+	, Flags( "Flags", setPxD6JointDriveFlags, getPxD6JointDriveFlags )
+{}
+ PxD6JointDriveGeneratedValues::PxD6JointDriveGeneratedValues( const PxD6JointDrive* inSource )
+		:PxSpringGeneratedValues( inSource )
+		,ForceLimit( inSource->forceLimit )
+		,Flags( inSource->flags )
+{
+	PX_UNUSED(inSource);
+}