Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

32 files changed, 5828 insertions, 0 deletions

diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p0_0p1.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p0_0p1.h
new file mode 100644
index 00000000..817ce7a7
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p0_0p1.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_0P0_0P1H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_0p0.h"
+#include "BasicIOSAssetParam_0p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p0, 
+						nvidia::parameterized::BasicIOSAssetParam_0p1, 
+						nvidia::parameterized::BasicIOSAssetParam_0p0::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_0p1::ClassVersion>
+						ConversionBasicIOSAssetParam_0p0_0p1Parent;
+
+class ConversionBasicIOSAssetParam_0p0_0p1: public ConversionBasicIOSAssetParam_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_0p0_0p1(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p0_0p1Parent(t) {}
+
+	bool convert()
+	{
+		// just take the default values (scaleSceneGravity = 1.0, externalAcceleration=0,0,0)
+		return true;
+	}
+};
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p1_0p2.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p1_0p2.h
new file mode 100644
index 00000000..247b1a1c
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p1_0p2.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_0P1_0P2H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P1_0P2H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_0p1.h"
+#include "BasicIOSAssetParam_0p2.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p1, 
+						nvidia::parameterized::BasicIOSAssetParam_0p2, 
+						nvidia::parameterized::BasicIOSAssetParam_0p1::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_0p2::ClassVersion>
+						ConversionBasicIOSAssetParam_0p1_0p2Parent;
+
+class ConversionBasicIOSAssetParam_0p1_0p2: public ConversionBasicIOSAssetParam_0p1_0p2Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p1_0p2));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p1_0p2)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_0p1_0p2(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p1_0p2Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p2_0p3.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p2_0p3.h
new file mode 100644
index 00000000..1e8840b5
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p2_0p3.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_0P2_0P3H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P2_0P3H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_0p2.h"
+#include "BasicIOSAssetParam_0p3.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p2, 
+						nvidia::parameterized::BasicIOSAssetParam_0p3, 
+						nvidia::parameterized::BasicIOSAssetParam_0p2::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_0p3::ClassVersion>
+						ConversionBasicIOSAssetParam_0p2_0p3Parent;
+
+class ConversionBasicIOSAssetParam_0p2_0p3: public ConversionBasicIOSAssetParam_0p2_0p3Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p2_0p3));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p2_0p3)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_0p2_0p3(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p2_0p3Parent(t) {}
+
+	bool convert()
+	{
+		// Inherit median from legacy asset
+		mNewData->particleMass.center = mLegacyData->particleMass;
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p3_0p4.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p3_0p4.h
new file mode 100644
index 00000000..ff0e5d50
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p3_0p4.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_0P3_0P4H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P3_0P4H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_0p3.h"
+#include "BasicIOSAssetParam_0p4.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p3, 
+						nvidia::parameterized::BasicIOSAssetParam_0p4, 
+						nvidia::parameterized::BasicIOSAssetParam_0p3::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_0p4::ClassVersion>
+						ConversionBasicIOSAssetParam_0p3_0p4Parent;
+
+class ConversionBasicIOSAssetParam_0p3_0p4: public ConversionBasicIOSAssetParam_0p3_0p4Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p3_0p4));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p3_0p4)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_0p3_0p4(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p3_0p4Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		// copy 'collisionGroupMaskName' to 'collisionFilterDataName'
+		NvParameterized::Handle handle(*mNewData, "collisionFilterDataName");
+		handle.setParamString(mLegacyData->collisionGroupMaskName);
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p4_0p5.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p4_0p5.h
new file mode 100644
index 00000000..3131e3a2
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p4_0p5.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_0P4_0P5H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P4_0P5H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_0p4.h"
+#include "BasicIOSAssetParam_0p5.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p4, 
+						nvidia::parameterized::BasicIOSAssetParam_0p5, 
+						nvidia::parameterized::BasicIOSAssetParam_0p4::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_0p5::ClassVersion>
+						ConversionBasicIOSAssetParam_0p4_0p5Parent;
+
+class ConversionBasicIOSAssetParam_0p4_0p5: public ConversionBasicIOSAssetParam_0p4_0p5Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p4_0p5));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p4_0p5)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_0p4_0p5(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p4_0p5Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p5_0p6.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p5_0p6.h
new file mode 100644
index 00000000..35966e61
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p5_0p6.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_0P5_0P6H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P5_0P6H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_0p5.h"
+#include "BasicIOSAssetParam_0p6.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p5, 
+						nvidia::parameterized::BasicIOSAssetParam_0p6, 
+						nvidia::parameterized::BasicIOSAssetParam_0p5::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_0p6::ClassVersion>
+						ConversionBasicIOSAssetParam_0p5_0p6Parent;
+
+class ConversionBasicIOSAssetParam_0p5_0p6: public ConversionBasicIOSAssetParam_0p5_0p6Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p5_0p6));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p5_0p6)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_0p5_0p6(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p5_0p6Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p6_0p7.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p6_0p7.h
new file mode 100644
index 00000000..5f808e89
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p6_0p7.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_0P6_0P7H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P6_0P7H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_0p6.h"
+#include "BasicIOSAssetParam_0p7.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p6, 
+						nvidia::parameterized::BasicIOSAssetParam_0p7, 
+						nvidia::parameterized::BasicIOSAssetParam_0p6::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_0p7::ClassVersion>
+						ConversionBasicIOSAssetParam_0p6_0p7Parent;
+
+class ConversionBasicIOSAssetParam_0p6_0p7: public ConversionBasicIOSAssetParam_0p6_0p7Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p6_0p7));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p6_0p7)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_0p6_0p7(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p6_0p7Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p7_0p8.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p7_0p8.h
new file mode 100644
index 00000000..78af5db2
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p7_0p8.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_0P7_0P8H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P7_0P8H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_0p7.h"
+#include "BasicIOSAssetParam_0p8.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p7, 
+						nvidia::parameterized::BasicIOSAssetParam_0p8, 
+						nvidia::parameterized::BasicIOSAssetParam_0p7::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_0p8::ClassVersion>
+						ConversionBasicIOSAssetParam_0p7_0p8Parent;
+
+class ConversionBasicIOSAssetParam_0p7_0p8: public ConversionBasicIOSAssetParam_0p7_0p8Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p7_0p8));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p7_0p8)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_0p7_0p8(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p7_0p8Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p8_0p9.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p8_0p9.h
new file mode 100644
index 00000000..58cadf7b
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p8_0p9.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_0P8_0P9H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P8_0P9H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_0p8.h"
+#include "BasicIOSAssetParam_0p9.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p8, 
+						nvidia::parameterized::BasicIOSAssetParam_0p9, 
+						nvidia::parameterized::BasicIOSAssetParam_0p8::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_0p9::ClassVersion>
+						ConversionBasicIOSAssetParam_0p8_0p9Parent;
+
+class ConversionBasicIOSAssetParam_0p8_0p9: public ConversionBasicIOSAssetParam_0p8_0p9Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p8_0p9));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p8_0p9)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_0p8_0p9(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p8_0p9Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		// Old
+		// UseFakeDensityDistance
+		// FakeDensityDistance
+		// UseFakeDensityGrid
+		// FakeDensityGridSize
+		// FakeDensityGridMaxCellCount
+		// FakeDensityGridResolution
+
+		// New
+		// FakeDensityGrid.Enabled
+		// FakeDensityGrid.FrustumMode
+		// FakeDensityGrid.GridResolution
+		// FakeDensityGrid.NormalParams.GridSize
+		// FakeDensityGrid.NormalParams.GridMaxCellCount
+		// FakeDensityGrid.FrustumParams.GridSize
+		// FakeDensityGrid.FrustumParams.GridMaxCellCount
+
+		// Don't transfer anything.
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p9_1p0.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p9_1p0.h
new file mode 100644
index 00000000..066602f8
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_0p9_1p0.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_0P9_1P0H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_0P9_1P0H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_0p9.h"
+#include "BasicIOSAssetParam_1p0.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_0p9, 
+						nvidia::parameterized::BasicIOSAssetParam_1p0, 
+						nvidia::parameterized::BasicIOSAssetParam_0p9::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_1p0::ClassVersion>
+						ConversionBasicIOSAssetParam_0p9_1p0Parent;
+
+class ConversionBasicIOSAssetParam_0p9_1p0: public ConversionBasicIOSAssetParam_0p9_1p0Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_0p9_1p0));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_0p9_1p0)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_0p9_1p0(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_0p9_1p0Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		mNewData->GridDensityGrid.Enabled = mLegacyData->FakeDensityGrid.Enabled;
+		mNewData->GridDensityGrid.FrustumParams.GridMaxCellCount = mLegacyData->FakeDensityGrid.FrustumParams.GridMaxCellCount;
+		mNewData->GridDensityGrid.FrustumParams.GridSize = mLegacyData->FakeDensityGrid.FrustumParams.GridSize;
+
+		NvParameterized::Handle hEnumNew(*mNewData, "GridDensityGrid.GridResolution");  //convert FDG -> GDG
+		NvParameterized::Handle hEnumOld(*mLegacyData, "FakeDensityGrid.GridResolution");  
+		PX_ASSERT(hEnumNew.isValid());
+		PX_ASSERT(hEnumOld.isValid());
+
+		const NvParameterized::Definition* paramDefOld;
+		paramDefOld = hEnumOld.parameterDefinition();
+		int32_t index = paramDefOld->enumValIndex(mLegacyData->FakeDensityGrid.GridResolution);
+
+		const NvParameterized::Definition* paramDefNew;
+		paramDefNew = hEnumNew.parameterDefinition();
+		hEnumNew.setParamEnum(paramDefNew->enumVal(index));
+		
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p0_1p1.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p0_1p1.h
new file mode 100644
index 00000000..81a0a723
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p0_1p1.h
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_1P0_1P1H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_1P0_1P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_1p0.h"
+#include "BasicIOSAssetParam_1p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_1p0, 
+						nvidia::parameterized::BasicIOSAssetParam_1p1, 
+						nvidia::parameterized::BasicIOSAssetParam_1p0::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_1p1::ClassVersion>
+						ConversionBasicIOSAssetParam_1p0_1p1Parent;
+
+class ConversionBasicIOSAssetParam_1p0_1p1: public ConversionBasicIOSAssetParam_1p0_1p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_1p0_1p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_1p0_1p1)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_1p0_1p1(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_1p0_1p1Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		mNewData->GridDensity.Enabled = mLegacyData->GridDensityGrid.Enabled;
+		// mNewData->GridDensity.Resolution = mLegacyData->GridDensityGrid.GridResolution;
+		mNewData->GridDensity.GridSize = mLegacyData->GridDensityGrid.FrustumParams.GridSize;
+		mNewData->GridDensity.MaxCellCount = mLegacyData->GridDensityGrid.FrustumParams.GridMaxCellCount;
+
+		// enums are strings, better do it the safe way
+		NvParameterized::Handle hEnumNew(*mNewData, "GridDensity.Resolution");
+		NvParameterized::Handle hEnumOld(*mLegacyData, "GridDensityGrid.GridResolution");
+		PX_ASSERT(hEnumNew.isValid());
+		PX_ASSERT(hEnumOld.isValid());
+
+		const NvParameterized::Definition* paramDefOld;
+		paramDefOld = hEnumOld.parameterDefinition();
+		int32_t index = paramDefOld->enumValIndex(mLegacyData->GridDensityGrid.GridResolution);
+
+		const NvParameterized::Definition* paramDefNew;
+		paramDefNew = hEnumNew.parameterDefinition();
+		hEnumNew.setParamEnum(paramDefNew->enumVal(index));
+		
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p1_1p2.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p1_1p2.h
new file mode 100644
index 00000000..b576ff30
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p1_1p2.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_1P1_1P2H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_1P1_1P2H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_1p1.h"
+#include "BasicIOSAssetParam_1p2.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_1p1, 
+						nvidia::parameterized::BasicIOSAssetParam_1p2, 
+						nvidia::parameterized::BasicIOSAssetParam_1p1::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_1p2::ClassVersion>
+						ConversionBasicIOSAssetParam_1p1_1p2Parent;
+
+class ConversionBasicIOSAssetParam_1p1_1p2: public ConversionBasicIOSAssetParam_1p1_1p2Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_1p1_1p2));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_1p1_1p2)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_1p1_1p2(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_1p1_1p2Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p2_1p3.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p2_1p3.h
new file mode 100644
index 00000000..2eac6ef3
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p2_1p3.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_1P2_1P3H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_1P2_1P3H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_1p2.h"
+#include "BasicIOSAssetParam_1p3.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_1p2, 
+						nvidia::parameterized::BasicIOSAssetParam_1p3, 
+						nvidia::parameterized::BasicIOSAssetParam_1p2::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_1p3::ClassVersion>
+						ConversionBasicIOSAssetParam_1p2_1p3Parent;
+
+class ConversionBasicIOSAssetParam_1p2_1p3: public ConversionBasicIOSAssetParam_1p2_1p3Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_1p2_1p3));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_1p2_1p3)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_1p2_1p3(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_1p2_1p3Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p3_1p4.h b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p3_1p4.h
new file mode 100644
index 00000000..56368e3b
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/ConversionBasicIOSAssetParam_1p3_1p4.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+
+#ifndef MODULE_CONVERSIONBASICIOSASSETPARAM_1P3_1P4H_H
+#define MODULE_CONVERSIONBASICIOSASSETPARAM_1P3_1P4H_H
+
+#include "NvParamConversionTemplate.h"
+#include "BasicIOSAssetParam_1p3.h"
+#include "BasicIOSAssetParam_1p4.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::BasicIOSAssetParam_1p3, 
+						nvidia::parameterized::BasicIOSAssetParam_1p4, 
+						nvidia::parameterized::BasicIOSAssetParam_1p3::ClassVersion, 
+						nvidia::parameterized::BasicIOSAssetParam_1p4::ClassVersion>
+						ConversionBasicIOSAssetParam_1p3_1p4Parent;
+
+class ConversionBasicIOSAssetParam_1p3_1p4: public ConversionBasicIOSAssetParam_1p3_1p4Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionBasicIOSAssetParam_1p3_1p4));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionBasicIOSAssetParam_1p3_1p4)(t) : 0;
+	}
+
+protected:
+	ConversionBasicIOSAssetParam_1p3_1p4(NvParameterized::Traits* t) : ConversionBasicIOSAssetParam_1p3_1p4Parent(t) {}
+
+	const NvParameterized::PrefVer* getPreferredVersions() const
+	{
+		static NvParameterized::PrefVer prefVers[] =
+		{
+			//TODO:
+			//	Add your preferred versions for included references here.
+			//	Entry format is
+			//		{ (const char*)longName, (uint32_t)preferredVersion }
+
+			{ 0, 0 } // Terminator (do not remove!)
+		};
+
+		return prefVers;
+	}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData has already been initialized with default values
+		//		- same-named/same-typed members have already been copied
+		//			from mLegacyData to mNewData
+		//		- included references were moved to mNewData
+		//			(and updated to preferred versions according to getPreferredVersions)
+		//
+		//	For more info see the versioning wiki.
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p0.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p0.h
new file mode 100644
index 00000000..2c9f6c76
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p0.h
@@ -0,0 +1,233 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_0p0_h
+#define HEADER_BasicIOSAssetParam_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+
+};
+
+static const uint32_t checksum[] = { 0x13e90d7d, 0x9644d70e, 0x92bd7f6c, 0xa4c80d68, };
+
+} // namespace BasicIOSAssetParam_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_0p0 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p0NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_0p0NS::checksum);
+		return BasicIOSAssetParam_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_0p0* tmpThis = const_cast<BasicIOSAssetParam_0p0*>(this);
+		return *(static_cast<BasicIOSAssetParam_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p0), BasicIOSAssetParam_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p1.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p1.h
new file mode 100644
index 00000000..a65bf702
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p1.h
@@ -0,0 +1,235 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_0p1_h
+#define HEADER_BasicIOSAssetParam_0p1_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_0p1NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+
+};
+
+static const uint32_t checksum[] = { 0xfef11c54, 0x679c8a6e, 0xb38c2860, 0x9eb5ca69, };
+
+} // namespace BasicIOSAssetParam_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_0p1 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p1NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)1;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_0p1NS::checksum);
+		return BasicIOSAssetParam_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_0p1NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_0p1* tmpThis = const_cast<BasicIOSAssetParam_0p1*>(this);
+		return *(static_cast<BasicIOSAssetParam_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_0p1NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p1), BasicIOSAssetParam_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_0p1 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_0p1::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p2.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p2.h
new file mode 100644
index 00000000..9d9325ac
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p2.h
@@ -0,0 +1,238 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_0p2_h
+#define HEADER_BasicIOSAssetParam_0p2_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_0p2NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	NvParameterized::DummyStringStruct collisionGroupName;
+	NvParameterized::DummyStringStruct collisionGroupMaskName;
+	float particleMass;
+
+};
+
+static const uint32_t checksum[] = { 0x76342808, 0xfd820291, 0xf3442960, 0x52c21a2a, };
+
+} // namespace BasicIOSAssetParam_0p2NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_0p2 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p2NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_0p2(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_0p2();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)2;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_0p2NS::checksum);
+		return BasicIOSAssetParam_0p2NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_0p2NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_0p2* tmpThis = const_cast<BasicIOSAssetParam_0p2*>(this);
+		return *(static_cast<BasicIOSAssetParam_0p2NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_0p2NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_0p2NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_0p2Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_0p2::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p2), BasicIOSAssetParam_0p2::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p2");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p2)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p2)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p2::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p2");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_0p2 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_0p2*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_0p2::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_0p2::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_0p2::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_0p2::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p3.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p3.h
new file mode 100644
index 00000000..0bde55dc
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p3.h
@@ -0,0 +1,245 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_0p3_h
+#define HEADER_BasicIOSAssetParam_0p3_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_0p3NS
+{
+
+struct RandomF32_Type;
+
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	NvParameterized::DummyStringStruct collisionGroupName;
+	NvParameterized::DummyStringStruct collisionGroupMaskName;
+	RandomF32_Type particleMass;
+
+};
+
+static const uint32_t checksum[] = { 0x3b2fd8d7, 0x3393dc25, 0x6c4e302a, 0x80a29e81, };
+
+} // namespace BasicIOSAssetParam_0p3NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_0p3 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p3NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_0p3(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_0p3();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)3;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_0p3NS::checksum);
+		return BasicIOSAssetParam_0p3NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_0p3NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_0p3* tmpThis = const_cast<BasicIOSAssetParam_0p3*>(this);
+		return *(static_cast<BasicIOSAssetParam_0p3NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_0p3NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_0p3NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_0p3Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_0p3::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p3), BasicIOSAssetParam_0p3::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p3::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p3");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p3)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p3)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p3::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p3::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p3");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_0p3 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_0p3*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_0p3::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_0p3::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_0p3::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_0p3::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p4.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p4.h
new file mode 100644
index 00000000..d3ca37da
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p4.h
@@ -0,0 +1,250 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_0p4_h
+#define HEADER_BasicIOSAssetParam_0p4_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_0p4NS
+{
+
+struct RandomF32_Type;
+
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	RandomF32_Type particleMass;
+	NvParameterized::DummyStringStruct collisionFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool staticCollision;
+	float restitutionForStaticShapes;
+	bool dynamicCollision;
+	float restitutionForDynamicShapes;
+	float collisionDistanceMultiplier;
+
+};
+
+static const uint32_t checksum[] = { 0x0cb6a84c, 0x48e1978e, 0x961cee62, 0x01d7d95b, };
+
+} // namespace BasicIOSAssetParam_0p4NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_0p4 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p4NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_0p4(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_0p4();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)4;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_0p4NS::checksum);
+		return BasicIOSAssetParam_0p4NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_0p4NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_0p4* tmpThis = const_cast<BasicIOSAssetParam_0p4*>(this);
+		return *(static_cast<BasicIOSAssetParam_0p4NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_0p4NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_0p4NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_0p4Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_0p4::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p4), BasicIOSAssetParam_0p4::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p4::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p4");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p4)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p4)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p4::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p4::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p4");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_0p4 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_0p4*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_0p4::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_0p4::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_0p4::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_0p4::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p5.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p5.h
new file mode 100644
index 00000000..fbb91543
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p5.h
@@ -0,0 +1,251 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_0p5_h
+#define HEADER_BasicIOSAssetParam_0p5_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_0p5NS
+{
+
+struct RandomF32_Type;
+
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	RandomF32_Type particleMass;
+	NvParameterized::DummyStringStruct collisionFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool staticCollision;
+	float restitutionForStaticShapes;
+	bool dynamicCollision;
+	float restitutionForDynamicShapes;
+	float collisionDistanceMultiplier;
+	float collisionThreshold;
+
+};
+
+static const uint32_t checksum[] = { 0x7af510ee, 0x7cf95f56, 0x5c6c9a11, 0xca6f7260, };
+
+} // namespace BasicIOSAssetParam_0p5NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_0p5 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p5NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_0p5(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_0p5();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)5;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_0p5NS::checksum);
+		return BasicIOSAssetParam_0p5NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_0p5NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_0p5* tmpThis = const_cast<BasicIOSAssetParam_0p5*>(this);
+		return *(static_cast<BasicIOSAssetParam_0p5NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_0p5NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_0p5NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_0p5Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_0p5::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p5), BasicIOSAssetParam_0p5::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p5::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p5");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p5)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p5)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p5::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p5::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p5");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_0p5 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_0p5*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_0p5::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_0p5::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_0p5::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_0p5::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p6.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p6.h
new file mode 100644
index 00000000..3323fd4f
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p6.h
@@ -0,0 +1,253 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_0p6_h
+#define HEADER_BasicIOSAssetParam_0p6_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_0p6NS
+{
+
+struct RandomF32_Type;
+
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	RandomF32_Type particleMass;
+	NvParameterized::DummyStringStruct collisionFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool staticCollision;
+	float restitutionForStaticShapes;
+	bool dynamicCollision;
+	float restitutionForDynamicShapes;
+	float collisionDistanceMultiplier;
+	float collisionThreshold;
+	bool collisionWithConvex;
+	bool collisionWithTriangleMesh;
+
+};
+
+static const uint32_t checksum[] = { 0xf6d69e51, 0x7edca183, 0xb8953089, 0xdd758d6f, };
+
+} // namespace BasicIOSAssetParam_0p6NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_0p6 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p6NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_0p6(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_0p6();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)6;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_0p6NS::checksum);
+		return BasicIOSAssetParam_0p6NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_0p6NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_0p6* tmpThis = const_cast<BasicIOSAssetParam_0p6*>(this);
+		return *(static_cast<BasicIOSAssetParam_0p6NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_0p6NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_0p6NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_0p6Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_0p6::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p6), BasicIOSAssetParam_0p6::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p6::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p6");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p6)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p6)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p6::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p6::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p6");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_0p6 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_0p6*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_0p6::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_0p6::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_0p6::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_0p6::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p7.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p7.h
new file mode 100644
index 00000000..42e2fd6d
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p7.h
@@ -0,0 +1,254 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_0p7_h
+#define HEADER_BasicIOSAssetParam_0p7_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_0p7NS
+{
+
+struct RandomF32_Type;
+
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	uint32_t maxCollidingObjects;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	RandomF32_Type particleMass;
+	NvParameterized::DummyStringStruct collisionFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool staticCollision;
+	float restitutionForStaticShapes;
+	bool dynamicCollision;
+	float restitutionForDynamicShapes;
+	float collisionDistanceMultiplier;
+	float collisionThreshold;
+	bool collisionWithConvex;
+	bool collisionWithTriangleMesh;
+
+};
+
+static const uint32_t checksum[] = { 0xd08a68f8, 0xdfb2b2cb, 0x04b13ed2, 0x8ac33237, };
+
+} // namespace BasicIOSAssetParam_0p7NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_0p7 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p7NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_0p7(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_0p7();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)7;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_0p7NS::checksum);
+		return BasicIOSAssetParam_0p7NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_0p7NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_0p7* tmpThis = const_cast<BasicIOSAssetParam_0p7*>(this);
+		return *(static_cast<BasicIOSAssetParam_0p7NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_0p7NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_0p7NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_0p7Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_0p7::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p7), BasicIOSAssetParam_0p7::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p7::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p7");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p7)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p7)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p7::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p7::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p7");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_0p7 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_0p7*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_0p7::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_0p7::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_0p7::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_0p7::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p8.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p8.h
new file mode 100644
index 00000000..dd139f24
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p8.h
@@ -0,0 +1,260 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_0p8_h
+#define HEADER_BasicIOSAssetParam_0p8_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_0p8NS
+{
+
+struct RandomF32_Type;
+
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	uint32_t maxCollidingObjects;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	RandomF32_Type particleMass;
+	NvParameterized::DummyStringStruct collisionFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool staticCollision;
+	float restitutionForStaticShapes;
+	bool dynamicCollision;
+	float restitutionForDynamicShapes;
+	float collisionDistanceMultiplier;
+	float collisionThreshold;
+	bool collisionWithConvex;
+	bool collisionWithTriangleMesh;
+	bool UseFakeDensityDistance;
+	float FakeDensityDistance;
+	bool UseFakeDensityGrid;
+	float FakeDensityGridSize;
+	uint32_t FakeDensityGridMaxCellCount;
+	const char* FakeDensityGridResolution;
+
+};
+
+static const uint32_t checksum[] = { 0x200e5368, 0x7869390f, 0x538d6f82, 0xca3a948f, };
+
+} // namespace BasicIOSAssetParam_0p8NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_0p8 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p8NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_0p8(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_0p8();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)8;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_0p8NS::checksum);
+		return BasicIOSAssetParam_0p8NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_0p8NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_0p8* tmpThis = const_cast<BasicIOSAssetParam_0p8*>(this);
+		return *(static_cast<BasicIOSAssetParam_0p8NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_0p8NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_0p8NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_0p8Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_0p8::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p8), BasicIOSAssetParam_0p8::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p8::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p8");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p8)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p8)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p8::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p8::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p8");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_0p8 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_0p8*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_0p8::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_0p8::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_0p8::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_0p8::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p9.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p9.h
new file mode 100644
index 00000000..29228940
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_0p9.h
@@ -0,0 +1,270 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_0p9_h
+#define HEADER_BasicIOSAssetParam_0p9_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_0p9NS
+{
+
+struct RandomF32_Type;
+struct FakeDensityGridNonSharedParams_Type;
+struct FakeDensityGridParams_Type;
+
+struct FakeDensityGridNonSharedParams_Type
+{
+	float GridSize;
+	uint32_t GridMaxCellCount;
+};
+struct FakeDensityGridParams_Type
+{
+	bool Enabled;
+	bool FrustumMode;
+	const char* GridResolution;
+	FakeDensityGridNonSharedParams_Type NormalParams;
+	FakeDensityGridNonSharedParams_Type FrustumParams;
+};
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	uint32_t maxCollidingObjects;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	RandomF32_Type particleMass;
+	NvParameterized::DummyStringStruct collisionFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool staticCollision;
+	float restitutionForStaticShapes;
+	bool dynamicCollision;
+	float restitutionForDynamicShapes;
+	float collisionDistanceMultiplier;
+	float collisionThreshold;
+	bool collisionWithConvex;
+	bool collisionWithTriangleMesh;
+	FakeDensityGridParams_Type FakeDensityGrid;
+
+};
+
+static const uint32_t checksum[] = { 0x6e9af62c, 0x78c430f2, 0x556ec540, 0x264551cc, };
+
+} // namespace BasicIOSAssetParam_0p9NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_0p9 : public NvParameterized::NvParameters, public BasicIOSAssetParam_0p9NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_0p9(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_0p9();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)9;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_0p9NS::checksum);
+		return BasicIOSAssetParam_0p9NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_0p9NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_0p9* tmpThis = const_cast<BasicIOSAssetParam_0p9*>(this);
+		return *(static_cast<BasicIOSAssetParam_0p9NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_0p9NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_0p9NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_0p9Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_0p9::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_0p9), BasicIOSAssetParam_0p9::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_0p9::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p9");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_0p9)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_0p9)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_0p9::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_0p9::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_0p9");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_0p9 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_0p9*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_0p9::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_0p9::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_0p9::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_0p9::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p0.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p0.h
new file mode 100644
index 00000000..516d30f2
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p0.h
@@ -0,0 +1,268 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_1p0_h
+#define HEADER_BasicIOSAssetParam_1p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_1p0NS
+{
+
+struct RandomF32_Type;
+struct GridDensityGridNonSharedParams_Type;
+struct GridDensityGridParams_Type;
+
+struct GridDensityGridNonSharedParams_Type
+{
+	float GridSize;
+	uint32_t GridMaxCellCount;
+};
+struct GridDensityGridParams_Type
+{
+	bool Enabled;
+	const char* GridResolution;
+	GridDensityGridNonSharedParams_Type FrustumParams;
+};
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	uint32_t maxCollidingObjects;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	RandomF32_Type particleMass;
+	NvParameterized::DummyStringStruct collisionFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool staticCollision;
+	float restitutionForStaticShapes;
+	bool dynamicCollision;
+	float restitutionForDynamicShapes;
+	float collisionDistanceMultiplier;
+	float collisionThreshold;
+	bool collisionWithConvex;
+	bool collisionWithTriangleMesh;
+	GridDensityGridParams_Type GridDensityGrid;
+
+};
+
+static const uint32_t checksum[] = { 0x0ec8eaad, 0xe41b35e0, 0x0495591a, 0x41cce2f3, };
+
+} // namespace BasicIOSAssetParam_1p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_1p0 : public NvParameterized::NvParameters, public BasicIOSAssetParam_1p0NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_1p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_1p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)1 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_1p0NS::checksum);
+		return BasicIOSAssetParam_1p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_1p0NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_1p0* tmpThis = const_cast<BasicIOSAssetParam_1p0*>(this);
+		return *(static_cast<BasicIOSAssetParam_1p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_1p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_1p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_1p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_1p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_1p0), BasicIOSAssetParam_1p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_1p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_1p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_1p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_1p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_1p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_1p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_1p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_1p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_1p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_1p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_1p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p1.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p1.h
new file mode 100644
index 00000000..f87af5fe
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p1.h
@@ -0,0 +1,263 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_1p1_h
+#define HEADER_BasicIOSAssetParam_1p1_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_1p1NS
+{
+
+struct RandomF32_Type;
+struct GridDensityParams_Type;
+
+struct GridDensityParams_Type
+{
+	bool Enabled;
+	const char* Resolution;
+	float GridSize;
+	uint32_t MaxCellCount;
+};
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	uint32_t maxCollidingObjects;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	RandomF32_Type particleMass;
+	NvParameterized::DummyStringStruct collisionFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool staticCollision;
+	float restitutionForStaticShapes;
+	bool dynamicCollision;
+	float restitutionForDynamicShapes;
+	float collisionDistanceMultiplier;
+	float collisionThreshold;
+	bool collisionWithConvex;
+	bool collisionWithTriangleMesh;
+	GridDensityParams_Type GridDensity;
+
+};
+
+static const uint32_t checksum[] = { 0xb9cf2ef9, 0x026f63d8, 0xf432a6a2, 0x5405c67a, };
+
+} // namespace BasicIOSAssetParam_1p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_1p1 : public NvParameterized::NvParameters, public BasicIOSAssetParam_1p1NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_1p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_1p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)1 << 16) + (uint32_t)1;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_1p1NS::checksum);
+		return BasicIOSAssetParam_1p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_1p1NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_1p1* tmpThis = const_cast<BasicIOSAssetParam_1p1*>(this);
+		return *(static_cast<BasicIOSAssetParam_1p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_1p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_1p1NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_1p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_1p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_1p1), BasicIOSAssetParam_1p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_1p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_1p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_1p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_1p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_1p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_1p1 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_1p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_1p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_1p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_1p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_1p1::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p2.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p2.h
new file mode 100644
index 00000000..8422a370
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p2.h
@@ -0,0 +1,264 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_1p2_h
+#define HEADER_BasicIOSAssetParam_1p2_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_1p2NS
+{
+
+struct RandomF32_Type;
+struct GridDensityParams_Type;
+
+struct GridDensityParams_Type
+{
+	bool Enabled;
+	const char* Resolution;
+	float GridSize;
+	uint32_t MaxCellCount;
+};
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	uint32_t maxCollidingObjects;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	RandomF32_Type particleMass;
+	NvParameterized::DummyStringStruct collisionFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool staticCollision;
+	float restitutionForStaticShapes;
+	bool dynamicCollision;
+	float restitutionForDynamicShapes;
+	float collisionDistanceMultiplier;
+	float collisionThreshold;
+	bool collisionWithConvex;
+	bool collisionWithTriangleMesh;
+	GridDensityParams_Type GridDensity;
+	bool enableTemperatureBuffer;
+
+};
+
+static const uint32_t checksum[] = { 0xc3985a5c, 0x2317e2e4, 0xb76060b8, 0x57d78da2, };
+
+} // namespace BasicIOSAssetParam_1p2NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_1p2 : public NvParameterized::NvParameters, public BasicIOSAssetParam_1p2NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_1p2(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_1p2();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)1 << 16) + (uint32_t)2;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_1p2NS::checksum);
+		return BasicIOSAssetParam_1p2NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_1p2NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_1p2* tmpThis = const_cast<BasicIOSAssetParam_1p2*>(this);
+		return *(static_cast<BasicIOSAssetParam_1p2NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_1p2NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_1p2NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_1p2Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_1p2::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_1p2), BasicIOSAssetParam_1p2::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_1p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p2");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_1p2)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_1p2)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_1p2::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_1p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p2");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_1p2 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_1p2*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_1p2::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_1p2::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_1p2::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_1p2::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p3.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p3.h
new file mode 100644
index 00000000..bdf71e5f
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p3.h
@@ -0,0 +1,281 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_1p3_h
+#define HEADER_BasicIOSAssetParam_1p3_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_1p3NS
+{
+
+struct RandomF32_Type;
+struct GridDensityParams_Type;
+struct ParticleToGridCouplingParams_Type;
+struct GridToParticleCouplingParams_Type;
+
+struct ParticleToGridCouplingParams_Type
+{
+	float accelTimeConstant;
+	float decelTimeConstant;
+	float thresholdMultiplier;
+};
+struct GridDensityParams_Type
+{
+	bool Enabled;
+	const char* Resolution;
+	float GridSize;
+	uint32_t MaxCellCount;
+};
+struct GridToParticleCouplingParams_Type
+{
+	float accelTimeConstant;
+	float decelTimeConstant;
+	float thresholdMultiplier;
+};
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	uint32_t maxCollidingObjects;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	RandomF32_Type particleMass;
+	NvParameterized::DummyStringStruct collisionFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool staticCollision;
+	float restitutionForStaticShapes;
+	bool dynamicCollision;
+	float restitutionForDynamicShapes;
+	float collisionDistanceMultiplier;
+	float collisionThreshold;
+	bool collisionWithConvex;
+	bool collisionWithTriangleMesh;
+	GridDensityParams_Type GridDensity;
+	bool enableTemperatureBuffer;
+	bool enableCouplingOverride;
+	ParticleToGridCouplingParams_Type particleToGridCoupling;
+	GridToParticleCouplingParams_Type gridToParticleCoupling;
+
+};
+
+static const uint32_t checksum[] = { 0xce8e2592, 0xae4fe7ed, 0x0e4024c0, 0x2142d36e, };
+
+} // namespace BasicIOSAssetParam_1p3NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_1p3 : public NvParameterized::NvParameters, public BasicIOSAssetParam_1p3NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_1p3(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_1p3();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)1 << 16) + (uint32_t)3;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_1p3NS::checksum);
+		return BasicIOSAssetParam_1p3NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_1p3NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_1p3* tmpThis = const_cast<BasicIOSAssetParam_1p3*>(this);
+		return *(static_cast<BasicIOSAssetParam_1p3NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_1p3NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_1p3NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_1p3Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_1p3::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_1p3), BasicIOSAssetParam_1p3::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_1p3::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p3");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_1p3)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_1p3)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_1p3::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_1p3::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p3");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_1p3 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_1p3*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_1p3::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_1p3::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_1p3::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_1p3::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p4.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p4.h
new file mode 100644
index 00000000..b1a9c607
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIOSAssetParam_1p4.h
@@ -0,0 +1,282 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIOSAssetParam_1p4_h
+#define HEADER_BasicIOSAssetParam_1p4_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIOSAssetParam_1p4NS
+{
+
+struct RandomF32_Type;
+struct GridDensityParams_Type;
+struct ParticleToGridCouplingParams_Type;
+struct GridToParticleCouplingParams_Type;
+
+struct ParticleToGridCouplingParams_Type
+{
+	float accelTimeConstant;
+	float decelTimeConstant;
+	float thresholdMultiplier;
+};
+struct GridDensityParams_Type
+{
+	bool Enabled;
+	const char* Resolution;
+	float GridSize;
+	uint32_t MaxCellCount;
+};
+struct GridToParticleCouplingParams_Type
+{
+	float accelTimeConstant;
+	float decelTimeConstant;
+	float thresholdMultiplier;
+};
+struct RandomF32_Type
+{
+	float center;
+	float spread;
+	const char* type;
+};
+
+struct ParametersStruct
+{
+
+	float restDensity;
+	float particleRadius;
+	uint32_t maxParticleCount;
+	float maxInjectedParticleCount;
+	uint32_t maxCollidingObjects;
+	float sceneGravityScale;
+	physx::PxVec3 externalAcceleration;
+	RandomF32_Type particleMass;
+	NvParameterized::DummyStringStruct collisionFilterDataName;
+	NvParameterized::DummyStringStruct fieldSamplerFilterDataName;
+	bool staticCollision;
+	float restitutionForStaticShapes;
+	bool dynamicCollision;
+	float restitutionForDynamicShapes;
+	float collisionDistanceMultiplier;
+	float collisionThreshold;
+	bool collisionWithConvex;
+	bool collisionWithTriangleMesh;
+	GridDensityParams_Type GridDensity;
+	bool enableTemperatureBuffer;
+	bool enableDensityBuffer;
+	bool enableCouplingOverride;
+	ParticleToGridCouplingParams_Type particleToGridCoupling;
+	GridToParticleCouplingParams_Type gridToParticleCoupling;
+
+};
+
+static const uint32_t checksum[] = { 0xd1ae20ca, 0xe79f585e, 0x9ab86d65, 0x9964607a, };
+
+} // namespace BasicIOSAssetParam_1p4NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIOSAssetParam_1p4 : public NvParameterized::NvParameters, public BasicIOSAssetParam_1p4NS::ParametersStruct
+{
+public:
+	BasicIOSAssetParam_1p4(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIOSAssetParam_1p4();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIOSAssetParam");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)1 << 16) + (uint32_t)4;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIOSAssetParam_1p4NS::checksum);
+		return BasicIOSAssetParam_1p4NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIOSAssetParam_1p4NS::ParametersStruct& parameters(void) const
+	{
+		BasicIOSAssetParam_1p4* tmpThis = const_cast<BasicIOSAssetParam_1p4*>(this);
+		return *(static_cast<BasicIOSAssetParam_1p4NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIOSAssetParam_1p4NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIOSAssetParam_1p4NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIOSAssetParam_1p4Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIOSAssetParam_1p4::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIOSAssetParam_1p4), BasicIOSAssetParam_1p4::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIOSAssetParam_1p4::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p4");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIOSAssetParam_1p4)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIOSAssetParam_1p4)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIOSAssetParam_1p4::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIOSAssetParam_1p4::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIOSAssetParam_1p4");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIOSAssetParam_1p4 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIOSAssetParam_1p4*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIOSAssetParam_1p4::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIOSAssetParam_1p4::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIOSAssetParam_1p4::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIOSAssetParam_1p4::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosDebugRenderParams_0p0.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosDebugRenderParams_0p0.h
new file mode 100644
index 00000000..b3aed4cf
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosDebugRenderParams_0p0.h
@@ -0,0 +1,232 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIosDebugRenderParams_0p0_h
+#define HEADER_BasicIosDebugRenderParams_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIosDebugRenderParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	bool VISUALIZE_BASIC_IOS_ACTOR;
+	bool VISUALIZE_BASIC_IOS_COLLIDE_SHAPES;
+	bool VISUALIZE_BASIC_IOS_GRID_DENSITY;
+
+};
+
+static const uint32_t checksum[] = { 0xfdf6893d, 0xf8944ef9, 0x2d74bc9a, 0x7fb067bf, };
+
+} // namespace BasicIosDebugRenderParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIosDebugRenderParams_0p0 : public NvParameterized::NvParameters, public BasicIosDebugRenderParams_0p0NS::ParametersStruct
+{
+public:
+	BasicIosDebugRenderParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIosDebugRenderParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIosDebugRenderParams");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIosDebugRenderParams_0p0NS::checksum);
+		return BasicIosDebugRenderParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIosDebugRenderParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BasicIosDebugRenderParams_0p0* tmpThis = const_cast<BasicIosDebugRenderParams_0p0*>(this);
+		return *(static_cast<BasicIosDebugRenderParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIosDebugRenderParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIosDebugRenderParams_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIosDebugRenderParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIosDebugRenderParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIosDebugRenderParams_0p0), BasicIosDebugRenderParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIosDebugRenderParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIosDebugRenderParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIosDebugRenderParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIosDebugRenderParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIosDebugRenderParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIosDebugRenderParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIosDebugRenderParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIosDebugRenderParams_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIosDebugRenderParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIosDebugRenderParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIosDebugRenderParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIosDebugRenderParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIosDebugRenderParams_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosModuleParameters_0p0.h b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosModuleParameters_0p0.h
new file mode 100644
index 00000000..051a3103
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/BasicIosModuleParameters_0p0.h
@@ -0,0 +1,230 @@
+// 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-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_BasicIosModuleParameters_0p0_h
+#define HEADER_BasicIosModuleParameters_0p0_h
+
+#include "NvParametersTypes.h"
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+#include "nvparameterized/NvParameterized.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "NvParameters.h"
+#include "NvTraitsInternal.h"
+#endif
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+#if PX_VC
+#pragma warning(push)
+#pragma warning(disable: 4324) // structure was padded due to __declspec(align())
+#endif
+
+namespace BasicIosModuleParameters_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	uint32_t unused;
+
+};
+
+static const uint32_t checksum[] = { 0x3fbae874, 0x2a648c69, 0x7ac9c757, 0x46be4dcd, };
+
+} // namespace BasicIosModuleParameters_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class BasicIosModuleParameters_0p0 : public NvParameterized::NvParameters, public BasicIosModuleParameters_0p0NS::ParametersStruct
+{
+public:
+	BasicIosModuleParameters_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~BasicIosModuleParameters_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("BasicIosModuleParameters");
+	}
+
+	const char* className(void) const
+	{
+		return(staticClassName());
+	}
+
+	static const uint32_t ClassVersion = ((uint32_t)0 << 16) + (uint32_t)0;
+
+	static uint32_t staticVersion(void)
+	{
+		return ClassVersion;
+	}
+
+	uint32_t version(void) const
+	{
+		return(staticVersion());
+	}
+
+	static const uint32_t ClassAlignment = 8;
+
+	static const uint32_t* staticChecksum(uint32_t& bits)
+	{
+		bits = 8 * sizeof(BasicIosModuleParameters_0p0NS::checksum);
+		return BasicIosModuleParameters_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const BasicIosModuleParameters_0p0NS::ParametersStruct& parameters(void) const
+	{
+		BasicIosModuleParameters_0p0* tmpThis = const_cast<BasicIosModuleParameters_0p0*>(this);
+		return *(static_cast<BasicIosModuleParameters_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	BasicIosModuleParameters_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<BasicIosModuleParameters_0p0NS::ParametersStruct*>(this));
+	}
+
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle) const;
+	virtual NvParameterized::ErrorType getParameterHandle(const char* long_name, NvParameterized::Handle& handle);
+
+	void initDefaults(void);
+
+protected:
+
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void);
+	virtual const NvParameterized::DefinitionImpl* getParameterDefinitionTree(void) const;
+
+
+	virtual void getVarPtr(const NvParameterized::Handle& handle, void*& ptr, size_t& offset) const;
+
+private:
+
+	void buildTree(void);
+	void initDynamicArrays(void);
+	void initStrings(void);
+	void initReferences(void);
+	void freeDynamicArrays(void);
+	void freeStrings(void);
+	void freeReferences(void);
+
+	static bool mBuiltFlag;
+	static NvParameterized::MutexType mBuiltFlagMutex;
+};
+
+class BasicIosModuleParameters_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		BasicIosModuleParameters_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(BasicIosModuleParameters_0p0), BasicIosModuleParameters_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, BasicIosModuleParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIosModuleParameters_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(BasicIosModuleParameters_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, BasicIosModuleParameters_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, BasicIosModuleParameters_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, BasicIosModuleParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class BasicIosModuleParameters_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of BasicIosModuleParameters_0p0 here
+		// but it may call default constructors of members and spoil the data
+		NV_PARAM_PLACEMENT_NEW(bufObj, NvParameterized::NvParameters)(paramTraits, bufStart, refCount);
+
+		// Init vtable (everything else is already initialized)
+		*(const char**)bufObj = vptr;
+
+		return (BasicIosModuleParameters_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (BasicIosModuleParameters_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (BasicIosModuleParameters_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (BasicIosModuleParameters_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (BasicIosModuleParameters_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif
diff --git a/APEX_1.4/module/basicios_legacy/include/autogen/ModuleBasicIOSLegacyRegistration.h b/APEX_1.4/module/basicios_legacy/include/autogen/ModuleBasicIOSLegacyRegistration.h
new file mode 100644
index 00000000..ca1002c7
--- /dev/null
+++ b/APEX_1.4/module/basicios_legacy/include/autogen/ModuleBasicIOSLegacyRegistration.h
@@ -0,0 +1,416 @@
+/*
+ * Copyright (c) 2008-2015, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * NVIDIA CORPORATION and its licensors retain all intellectual property
+ * and proprietary rights in and to this software, 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.
+ */
+
+#ifndef MODULE_MODULEBASICIOSLEGACYREGISTRATIONH_H
+#define MODULE_MODULEBASICIOSLEGACYREGISTRATIONH_H
+
+#include "PsAllocator.h"
+#include "NvRegistrationsForTraitsBase.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "PxAssert.h"
+#include <stdint.h>
+
+// INCLUDE GENERATED FACTORIES
+#include "BasicIOSAssetParam_0p0.h"
+#include "BasicIOSAssetParam_0p1.h"
+#include "BasicIOSAssetParam_0p2.h"
+#include "BasicIOSAssetParam_0p3.h"
+#include "BasicIOSAssetParam_0p4.h"
+#include "BasicIOSAssetParam_0p5.h"
+#include "BasicIOSAssetParam_0p6.h"
+#include "BasicIOSAssetParam_0p7.h"
+#include "BasicIOSAssetParam_0p8.h"
+#include "BasicIOSAssetParam_0p9.h"
+#include "BasicIOSAssetParam_1p0.h"
+#include "BasicIOSAssetParam_1p1.h"
+#include "BasicIOSAssetParam_1p2.h"
+#include "BasicIOSAssetParam_1p3.h"
+#include "BasicIOSAssetParam_1p4.h"
+#include "BasicIosDebugRenderParams_0p0.h"
+#include "BasicIosModuleParameters_0p0.h"
+
+
+// INCLUDE GENERATED CONVERSION
+#include "ConversionBasicIOSAssetParam_0p0_0p1.h"
+#include "ConversionBasicIOSAssetParam_0p1_0p2.h"
+#include "ConversionBasicIOSAssetParam_0p2_0p3.h"
+#include "ConversionBasicIOSAssetParam_0p3_0p4.h"
+#include "ConversionBasicIOSAssetParam_0p4_0p5.h"
+#include "ConversionBasicIOSAssetParam_0p5_0p6.h"
+#include "ConversionBasicIOSAssetParam_0p6_0p7.h"
+#include "ConversionBasicIOSAssetParam_0p7_0p8.h"
+#include "ConversionBasicIOSAssetParam_0p8_0p9.h"
+#include "ConversionBasicIOSAssetParam_0p9_1p0.h"
+#include "ConversionBasicIOSAssetParam_1p0_1p1.h"
+#include "ConversionBasicIOSAssetParam_1p1_1p2.h"
+#include "ConversionBasicIOSAssetParam_1p2_1p3.h"
+#include "ConversionBasicIOSAssetParam_1p3_1p4.h"
+
+
+// global namespace
+
+class ModuleBasicIOSLegacyRegistration : public NvParameterized::RegistrationsForTraitsBase
+{
+public:
+	static void invokeRegistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleBasicIOSLegacyRegistration().registerAll(*parameterizedTraits);
+		}
+	}
+
+	static void invokeUnregistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleBasicIOSLegacyRegistration().unregisterAll(*parameterizedTraits);
+		}
+	}
+
+	void registerAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		::NvParameterized::Factory* factoriesToRegister[] = {
+// REGISTER GENERATED FACTORIES
+			new nvidia::parameterized::BasicIOSAssetParam_0p0Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p1Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p2Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p3Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p4Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p5Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p6Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p7Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p8Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p9Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_1p0Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_1p1Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_1p2Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_1p3Factory(),
+
+		};
+
+		for (size_t i = 0; i < sizeof(factoriesToRegister)/sizeof(factoriesToRegister[0]); ++i)
+		{
+			parameterizedTraits.registerFactory(*factoriesToRegister[i]);
+		}
+	}
+
+	virtual void registerAvailableConverters(NvParameterized::Traits& parameterizedTraits)
+	{
+// REGISTER GENERATED CONVERSION
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p1_0p2 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p2_0p3 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p3_0p4 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p4_0p5 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p5_0p6 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p6_0p7 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p7_0p8 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p8_0p9 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p9_1p0 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p0_1p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p1_1p2 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p2_1p3 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p3_1p4 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+
+	}
+
+	void unregisterAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		struct FactoryDesc
+		{
+			const char* name;
+			uint32_t version;
+		};
+
+		::NvParameterized::Factory* factoriesToUnregister[] = {
+// UNREGISTER GENERATED FACTORIES
+			new nvidia::parameterized::BasicIOSAssetParam_0p0Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p1Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p2Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p3Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p4Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p5Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p6Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p7Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p8Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_0p9Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_1p0Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_1p1Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_1p2Factory(),
+			new nvidia::parameterized::BasicIOSAssetParam_1p3Factory(),
+
+		};
+
+		for (size_t i = 0; i < sizeof(factoriesToUnregister)/sizeof(factoriesToUnregister[0]); ++i)
+		{
+			::NvParameterized::Factory* removedFactory = parameterizedTraits.removeFactory(factoriesToUnregister[i]->getClassName(), factoriesToUnregister[i]->getVersion());
+			if (!removedFactory) 
+			{
+				PX_ASSERT_WITH_MESSAGE(0, "Factory can not be removed!");
+			}
+			else
+			{
+				removedFactory->freeParameterDefinitionTable(&parameterizedTraits);
+				delete removedFactory;
+				delete factoriesToUnregister[i];
+			}
+		}
+	}
+
+	virtual void unregisterAvailableConverters(NvParameterized::Traits& parameterizedTraits)
+	{
+// UNREGISTER GENERATED CONVERSION
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p0_0p1 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p1_0p2 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p2_0p3 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p3_0p4 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p4_0p5 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p5_0p6 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p6_0p7 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p7_0p8 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p8_0p9 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_0p9_1p0 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p0_1p1 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p1_1p2 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p2_1p3 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionBasicIOSAssetParam_1p3_1p4 ConverterToUnregister;
+			::NvParameterized::Conversion* removedConv = parameterizedTraits.removeConversion(ConverterToUnregister::TOldClass::staticClassName(),
+								ConverterToUnregister::TOldClass::ClassVersion,
+								ConverterToUnregister::TNewClass::ClassVersion);
+			if (removedConv) {
+				removedConv->~Conversion(); parameterizedTraits.free(removedConv); // PLACEMENT DELETE 
+			} else {
+				// assert("Conversion was not found");
+			}
+			}
+
+	}
+
+};
+
+// global namespace
+
+#endif