Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

121 files changed, 38436 insertions, 0 deletions

diff --git a/APEX_1.4/module/iofx_legacy/include/ConversionIofxAssetParameters_0p0_0p1.h b/APEX_1.4/module/iofx_legacy/include/ConversionIofxAssetParameters_0p0_0p1.h
new file mode 100644
index 00000000..777f989a
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionIofxAssetParameters_0p0_0p1.h
@@ -0,0 +1,185 @@
+/*
+ * 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_CONVERSIONIOFXASSETPARAMETERS_0P0_0P1H_H
+#define MODULE_CONVERSIONIOFXASSETPARAMETERS_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "IofxAssetParameters_0p0.h"
+#include "IofxAssetParameters_0p1.h"
+
+#include "nvparameterized/NvParamUtils.h"
+
+#define PARAM_RET(x) if( (x) != NvParameterized::ERROR_NONE ) \
+		{ PX_ASSERT(0 && "INVALID Parameter"); return false; }
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::IofxAssetParameters_0p0, 
+						nvidia::parameterized::IofxAssetParameters_0p1, 
+						nvidia::parameterized::IofxAssetParameters_0p0::ClassVersion, 
+						nvidia::parameterized::IofxAssetParameters_0p1::ClassVersion>
+						ConversionIofxAssetParameters_0p0_0p1Parent;
+
+class ConversionIofxAssetParameters_0p0_0p1: public ConversionIofxAssetParameters_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionIofxAssetParameters_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionIofxAssetParameters_0p0_0p1)(t) : 0;
+	}
+
+private:
+	ConversionIofxAssetParameters_0p0_0p1(NvParameterized::Traits* t) : ConversionIofxAssetParameters_0p0_0p1Parent(t) {}
+	// TODO: make it a generic "array copy" method
+	bool deepCopyModifiers(NvParameterized::Interface* newModListParams, const char* modListString)
+	{
+		int32_t arraySize = 0, modIgnoreCount = 0;
+		NvParameterized::Handle hOld(*mLegacyData, modListString);
+		NvParameterized::Handle hNew(*newModListParams, modListString);
+
+		PX_ASSERT(hOld.isValid() && hNew.isValid());
+
+		// resize the new array
+		NvParameterized::getParamArraySize(*mLegacyData, modListString, arraySize);
+		PARAM_RET(hNew.resizeArray(arraySize));
+
+		// copy the modifiers
+		for (int32_t i = 0; i < arraySize; i++)
+		{
+			NvParameterized::Interface* curOldMod = NULL;
+
+			PARAM_RET(hNew.set(i - modIgnoreCount));
+			PARAM_RET(hOld.set(i));
+
+			PARAM_RET(hOld.getParamRef(curOldMod));
+			PX_ASSERT(curOldMod);
+
+			if (!nvidia::strcmp(curOldMod->className(), "RotationModifierParams") &&
+			        !nvidia::strcmp(newModListParams->className(), "SpriteIofxParameters"))
+			{
+				modIgnoreCount++;
+
+				hNew.popIndex();
+				hOld.popIndex();
+				continue;
+			}
+
+			PARAM_RET(hNew.setParamRef(curOldMod));
+			PARAM_RET(hOld.setParamRef(0));
+
+			hNew.popIndex();
+			hOld.popIndex();
+		}
+
+		if (modIgnoreCount)
+		{
+			PARAM_RET(hNew.resizeArray(arraySize - modIgnoreCount));
+		}
+
+		return true;
+	}
+
+	bool copyRenderMeshList(NvParameterized::Interface* meshIofxParams)
+	{
+		char indexedWeightString[32];
+
+		NvParameterized::Handle hOld(*mLegacyData, "renderMeshList");
+		PX_ASSERT(hOld.isValid());
+
+		NvParameterized::Handle hNew(*meshIofxParams, "renderMeshList");
+		PX_ASSERT(hNew.isValid());
+
+		int32_t arraySize = 0;
+		PARAM_RET(hOld.getArraySize(arraySize));
+		PARAM_RET(hNew.resizeArray(arraySize));
+
+		for (int32_t i = 0; i < arraySize; i++)
+		{
+			PARAM_RET(hNew.set(i));
+			PARAM_RET(hOld.set(i));
+
+			// first handle the weight
+			uint32_t oldWeight;
+			shdfnd::snprintf(indexedWeightString, sizeof(indexedWeightString), "renderMeshList[%i].weight", i);
+			NvParameterized::getParamU32(*mLegacyData, indexedWeightString, oldWeight);
+			NvParameterized::setParamU32(*meshIofxParams, indexedWeightString, oldWeight);
+
+			// then get the meshAssetName (named ref)
+			NvParameterized::Handle hChild(mLegacyData);
+			PARAM_RET(hOld.getChildHandle(mLegacyData, "meshAssetName", hChild));
+			PX_ASSERT(hOld.isValid());
+
+			NvParameterized::Interface* oldMeshRef = NULL;
+
+			PARAM_RET(hChild.getParamRef(oldMeshRef));
+			PARAM_RET(hChild.setParamRef(0));
+			PX_ASSERT(oldMeshRef);
+
+			PARAM_RET(hNew.getChildHandle(meshIofxParams, "meshAssetName", hChild));
+			PARAM_RET(hChild.setParamRef(oldMeshRef));
+
+			hNew.popIndex();
+			hOld.popIndex();
+		}
+
+		return true;
+	}
+
+protected:
+
+	bool convert()
+	{
+		// if sprite name is present, then it's a sprite modifier, else, mesh
+		NvParameterized::Interface* iofxType = 0;
+		if (mLegacyData->spriteMaterialName && mLegacyData->spriteMaterialName->name())
+		{
+			// create new sprite type
+
+			iofxType = mTraits->createNvParameterized("SpriteIofxParameters", 0);
+			PX_ASSERT(iofxType);
+
+			// copy the new spriteMaterialName named reference
+			NvParameterized::Handle h(*iofxType, "spriteMaterialName");
+			h.setParamRef(mLegacyData->spriteMaterialName);
+			mLegacyData->spriteMaterialName = 0;
+		}
+		else
+		{
+			// create new mesh iofx type
+
+			iofxType = mTraits->createNvParameterized("MeshIofxParameters", 0);
+			PX_ASSERT(iofxType);
+
+			// copy the renderMeshList array (renderMesh names and weights)
+			copyRenderMeshList(iofxType);
+		}
+
+		// deep copy the spawn and continuous list
+		deepCopyModifiers(iofxType, "spawnModifierList");
+		deepCopyModifiers(iofxType, "continuousModifierList");
+
+		mNewData->iofxType = iofxType;
+
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/iofx_legacy/include/ConversionIofxAssetParameters_0p1_0p2.h b/APEX_1.4/module/iofx_legacy/include/ConversionIofxAssetParameters_0p1_0p2.h
new file mode 100644
index 00000000..49edc8d0
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionIofxAssetParameters_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_CONVERSIONIOFXASSETPARAMETERS_0P1_0P2H_H
+#define MODULE_CONVERSIONIOFXASSETPARAMETERS_0P1_0P2H_H
+
+#include "NvParamConversionTemplate.h"
+#include "IofxAssetParameters_0p1.h"
+#include "IofxAssetParameters_0p2.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::IofxAssetParameters_0p1, 
+						nvidia::parameterized::IofxAssetParameters_0p2, 
+						nvidia::parameterized::IofxAssetParameters_0p1::ClassVersion, 
+						nvidia::parameterized::IofxAssetParameters_0p2::ClassVersion>
+						ConversionIofxAssetParameters_0p1_0p2Parent;
+
+class ConversionIofxAssetParameters_0p1_0p2: public ConversionIofxAssetParameters_0p1_0p2Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionIofxAssetParameters_0p1_0p2));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionIofxAssetParameters_0p1_0p2)(t) : 0;
+	}
+
+protected:
+	ConversionIofxAssetParameters_0p1_0p2(NvParameterized::Traits* t) : ConversionIofxAssetParameters_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/iofx_legacy/include/ConversionMeshIofxParameters_0p0_0p1.h b/APEX_1.4/module/iofx_legacy/include/ConversionMeshIofxParameters_0p0_0p1.h
new file mode 100644
index 00000000..523ea3b2
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionMeshIofxParameters_0p0_0p1.h
@@ -0,0 +1,64 @@
+/*
+ * 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_CONVERSIONMESHIOFXPARAMETERS_0P0_0P1H_H
+#define MODULE_CONVERSIONMESHIOFXPARAMETERS_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "MeshIofxParameters_0p0.h"
+#include "MeshIofxParameters_0p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::MeshIofxParameters_0p0, 
+						nvidia::parameterized::MeshIofxParameters_0p1, 
+						nvidia::parameterized::MeshIofxParameters_0p0::ClassVersion, 
+						nvidia::parameterized::MeshIofxParameters_0p1::ClassVersion>
+						ConversionMeshIofxParameters_0p0_0p1Parent;
+
+class ConversionMeshIofxParameters_0p0_0p1: public ConversionMeshIofxParameters_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionMeshIofxParameters_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionMeshIofxParameters_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionMeshIofxParameters_0p0_0p1(NvParameterized::Traits* t) : ConversionMeshIofxParameters_0p0_0p1Parent(t) {}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData was initialized with default values
+		//		- same-named/same-typed members were 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/iofx_legacy/include/ConversionMeshIofxParameters_0p1_0p2.h b/APEX_1.4/module/iofx_legacy/include/ConversionMeshIofxParameters_0p1_0p2.h
new file mode 100644
index 00000000..c3c493fb
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionMeshIofxParameters_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_CONVERSIONMESHIOFXPARAMETERS_0P1_0P2H_H
+#define MODULE_CONVERSIONMESHIOFXPARAMETERS_0P1_0P2H_H
+
+#include "NvParamConversionTemplate.h"
+#include "MeshIofxParameters_0p1.h"
+#include "MeshIofxParameters_0p2.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::MeshIofxParameters_0p1, 
+						nvidia::parameterized::MeshIofxParameters_0p2, 
+						nvidia::parameterized::MeshIofxParameters_0p1::ClassVersion, 
+						nvidia::parameterized::MeshIofxParameters_0p2::ClassVersion>
+						ConversionMeshIofxParameters_0p1_0p2Parent;
+
+class ConversionMeshIofxParameters_0p1_0p2: public ConversionMeshIofxParameters_0p1_0p2Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionMeshIofxParameters_0p1_0p2));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionMeshIofxParameters_0p1_0p2)(t) : 0;
+	}
+
+protected:
+	ConversionMeshIofxParameters_0p1_0p2(NvParameterized::Traits* t) : ConversionMeshIofxParameters_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/iofx_legacy/include/ConversionMeshIofxParameters_0p2_0p3.h b/APEX_1.4/module/iofx_legacy/include/ConversionMeshIofxParameters_0p2_0p3.h
new file mode 100644
index 00000000..19cbbd79
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionMeshIofxParameters_0p2_0p3.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_CONVERSIONMESHIOFXPARAMETERS_0P2_0P3H_H
+#define MODULE_CONVERSIONMESHIOFXPARAMETERS_0P2_0P3H_H
+
+#include "NvParamConversionTemplate.h"
+#include "MeshIofxParameters_0p2.h"
+#include "MeshIofxParameters_0p3.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::MeshIofxParameters_0p2, 
+						nvidia::parameterized::MeshIofxParameters_0p3, 
+						nvidia::parameterized::MeshIofxParameters_0p2::ClassVersion, 
+						nvidia::parameterized::MeshIofxParameters_0p3::ClassVersion>
+						ConversionMeshIofxParameters_0p2_0p3Parent;
+
+class ConversionMeshIofxParameters_0p2_0p3: public ConversionMeshIofxParameters_0p2_0p3Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionMeshIofxParameters_0p2_0p3));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionMeshIofxParameters_0p2_0p3)(t) : 0;
+	}
+
+protected:
+	ConversionMeshIofxParameters_0p2_0p3(NvParameterized::Traits* t) : ConversionMeshIofxParameters_0p2_0p3Parent(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/iofx_legacy/include/ConversionMeshIofxParameters_0p3_0p4.h b/APEX_1.4/module/iofx_legacy/include/ConversionMeshIofxParameters_0p3_0p4.h
new file mode 100644
index 00000000..574f976c
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionMeshIofxParameters_0p3_0p4.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_CONVERSIONMESHIOFXPARAMETERS_0P3_0P4H_H
+#define MODULE_CONVERSIONMESHIOFXPARAMETERS_0P3_0P4H_H
+
+#include "NvParamConversionTemplate.h"
+#include "MeshIofxParameters_0p3.h"
+#include "MeshIofxParameters_0p4.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::MeshIofxParameters_0p3, 
+						nvidia::parameterized::MeshIofxParameters_0p4, 
+						nvidia::parameterized::MeshIofxParameters_0p3::ClassVersion, 
+						nvidia::parameterized::MeshIofxParameters_0p4::ClassVersion>
+						ConversionMeshIofxParameters_0p3_0p4Parent;
+
+class ConversionMeshIofxParameters_0p3_0p4: public ConversionMeshIofxParameters_0p3_0p4Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionMeshIofxParameters_0p3_0p4));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionMeshIofxParameters_0p3_0p4)(t) : 0;
+	}
+
+protected:
+	ConversionMeshIofxParameters_0p3_0p4(NvParameterized::Traits* t) : ConversionMeshIofxParameters_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()
+	{
+		//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/iofx_legacy/include/ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1.h b/APEX_1.4/module/iofx_legacy/include/ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1.h
new file mode 100644
index 00000000..e9254c3f
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1.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_CONVERSIONORIENTSCALEALONGSCREENVELOCITYMODIFIERPARAMS_0P0_0P1H_H
+#define MODULE_CONVERSIONORIENTSCALEALONGSCREENVELOCITYMODIFIERPARAMS_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "OrientScaleAlongScreenVelocityModifierParams_0p0.h"
+#include "OrientScaleAlongScreenVelocityModifierParams_0p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::OrientScaleAlongScreenVelocityModifierParams_0p0, 
+						nvidia::parameterized::OrientScaleAlongScreenVelocityModifierParams_0p1, 
+						nvidia::parameterized::OrientScaleAlongScreenVelocityModifierParams_0p0::ClassVersion, 
+						nvidia::parameterized::OrientScaleAlongScreenVelocityModifierParams_0p1::ClassVersion>
+						ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1Parent;
+
+class ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1: public ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1(NvParameterized::Traits* t) : ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1Parent(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/iofx_legacy/include/ConversionRotationModifierParams_0p0_0p1.h b/APEX_1.4/module/iofx_legacy/include/ConversionRotationModifierParams_0p0_0p1.h
new file mode 100644
index 00000000..d61b5bfe
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionRotationModifierParams_0p0_0p1.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_CONVERSIONROTATIONMODIFIERPARAMS_0P0_0P1H_H
+#define MODULE_CONVERSIONROTATIONMODIFIERPARAMS_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "RotationModifierParams_0p0.h"
+#include "RotationModifierParams_0p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::RotationModifierParams_0p0, 
+						nvidia::parameterized::RotationModifierParams_0p1, 
+						nvidia::parameterized::RotationModifierParams_0p0::ClassVersion, 
+						nvidia::parameterized::RotationModifierParams_0p1::ClassVersion>
+						ConversionRotationModifierParams_0p0_0p1Parent;
+
+class ConversionRotationModifierParams_0p0_0p1: public ConversionRotationModifierParams_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionRotationModifierParams_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionRotationModifierParams_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionRotationModifierParams_0p0_0p1(NvParameterized::Traits* t) : ConversionRotationModifierParams_0p0_0p1Parent(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/iofx_legacy/include/ConversionRotationModifierParams_0p1_0p2.h b/APEX_1.4/module/iofx_legacy/include/ConversionRotationModifierParams_0p1_0p2.h
new file mode 100644
index 00000000..24100cd0
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionRotationModifierParams_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_CONVERSIONROTATIONMODIFIERPARAMS_0P1_0P2H_H
+#define MODULE_CONVERSIONROTATIONMODIFIERPARAMS_0P1_0P2H_H
+
+#include "NvParamConversionTemplate.h"
+#include "RotationModifierParams_0p1.h"
+#include "RotationModifierParams_0p2.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::RotationModifierParams_0p1, 
+						nvidia::parameterized::RotationModifierParams_0p2, 
+						nvidia::parameterized::RotationModifierParams_0p1::ClassVersion, 
+						nvidia::parameterized::RotationModifierParams_0p2::ClassVersion>
+						ConversionRotationModifierParams_0p1_0p2Parent;
+
+class ConversionRotationModifierParams_0p1_0p2: public ConversionRotationModifierParams_0p1_0p2Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionRotationModifierParams_0p1_0p2));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionRotationModifierParams_0p1_0p2)(t) : 0;
+	}
+
+protected:
+	ConversionRotationModifierParams_0p1_0p2(NvParameterized::Traits* t) : ConversionRotationModifierParams_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/iofx_legacy/include/ConversionSpriteIofxParameters_0p0_0p1.h b/APEX_1.4/module/iofx_legacy/include/ConversionSpriteIofxParameters_0p0_0p1.h
new file mode 100644
index 00000000..29eb7c1c
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionSpriteIofxParameters_0p0_0p1.h
@@ -0,0 +1,64 @@
+/*
+ * 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_CONVERSIONSPRITEIOFXPARAMETERS_0P0_0P1H_H
+#define MODULE_CONVERSIONSPRITEIOFXPARAMETERS_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "SpriteIofxParameters_0p0.h"
+#include "SpriteIofxParameters_0p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::SpriteIofxParameters_0p0, 
+						nvidia::parameterized::SpriteIofxParameters_0p1, 
+						nvidia::parameterized::SpriteIofxParameters_0p0::ClassVersion, 
+						nvidia::parameterized::SpriteIofxParameters_0p1::ClassVersion>
+						ConversionSpriteIofxParameters_0p0_0p1Parent;
+
+class ConversionSpriteIofxParameters_0p0_0p1: public ConversionSpriteIofxParameters_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionSpriteIofxParameters_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionSpriteIofxParameters_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionSpriteIofxParameters_0p0_0p1(NvParameterized::Traits* t) : ConversionSpriteIofxParameters_0p0_0p1Parent(t) {}
+
+	bool convert()
+	{
+		//TODO:
+		//	Write custom conversion code here using mNewData and mLegacyData members.
+		//
+		//	Note that
+		//		- mNewData was initialized with default values
+		//		- same-named/same-typed members were 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/iofx_legacy/include/ConversionSpriteIofxParameters_0p1_0p2.h b/APEX_1.4/module/iofx_legacy/include/ConversionSpriteIofxParameters_0p1_0p2.h
new file mode 100644
index 00000000..b43b524b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionSpriteIofxParameters_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_CONVERSIONSPRITEIOFXPARAMETERS_0P1_0P2H_H
+#define MODULE_CONVERSIONSPRITEIOFXPARAMETERS_0P1_0P2H_H
+
+#include "NvParamConversionTemplate.h"
+#include "SpriteIofxParameters_0p1.h"
+#include "SpriteIofxParameters_0p2.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::SpriteIofxParameters_0p1, 
+						nvidia::parameterized::SpriteIofxParameters_0p2, 
+						nvidia::parameterized::SpriteIofxParameters_0p1::ClassVersion, 
+						nvidia::parameterized::SpriteIofxParameters_0p2::ClassVersion>
+						ConversionSpriteIofxParameters_0p1_0p2Parent;
+
+class ConversionSpriteIofxParameters_0p1_0p2: public ConversionSpriteIofxParameters_0p1_0p2Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionSpriteIofxParameters_0p1_0p2));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionSpriteIofxParameters_0p1_0p2)(t) : 0;
+	}
+
+protected:
+	ConversionSpriteIofxParameters_0p1_0p2(NvParameterized::Traits* t) : ConversionSpriteIofxParameters_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/iofx_legacy/include/ConversionSpriteIofxParameters_0p2_0p3.h b/APEX_1.4/module/iofx_legacy/include/ConversionSpriteIofxParameters_0p2_0p3.h
new file mode 100644
index 00000000..2690ff0e
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionSpriteIofxParameters_0p2_0p3.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_CONVERSIONSPRITEIOFXPARAMETERS_0P2_0P3H_H
+#define MODULE_CONVERSIONSPRITEIOFXPARAMETERS_0P2_0P3H_H
+
+#include "NvParamConversionTemplate.h"
+#include "SpriteIofxParameters_0p2.h"
+#include "SpriteIofxParameters_0p3.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::SpriteIofxParameters_0p2, 
+						nvidia::parameterized::SpriteIofxParameters_0p3, 
+						nvidia::parameterized::SpriteIofxParameters_0p2::ClassVersion, 
+						nvidia::parameterized::SpriteIofxParameters_0p3::ClassVersion>
+						ConversionSpriteIofxParameters_0p2_0p3Parent;
+
+class ConversionSpriteIofxParameters_0p2_0p3: public ConversionSpriteIofxParameters_0p2_0p3Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionSpriteIofxParameters_0p2_0p3));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionSpriteIofxParameters_0p2_0p3)(t) : 0;
+	}
+
+protected:
+	ConversionSpriteIofxParameters_0p2_0p3(NvParameterized::Traits* t) : ConversionSpriteIofxParameters_0p2_0p3Parent(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/iofx_legacy/include/ConversionSpriteIofxParameters_0p3_0p4.h b/APEX_1.4/module/iofx_legacy/include/ConversionSpriteIofxParameters_0p3_0p4.h
new file mode 100644
index 00000000..fb0b5a2b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/ConversionSpriteIofxParameters_0p3_0p4.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_CONVERSIONSPRITEIOFXPARAMETERS_0P3_0P4H_H
+#define MODULE_CONVERSIONSPRITEIOFXPARAMETERS_0P3_0P4H_H
+
+#include "NvParamConversionTemplate.h"
+#include "SpriteIofxParameters_0p3.h"
+#include "SpriteIofxParameters_0p4.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::SpriteIofxParameters_0p3, 
+						nvidia::parameterized::SpriteIofxParameters_0p4, 
+						nvidia::parameterized::SpriteIofxParameters_0p3::ClassVersion, 
+						nvidia::parameterized::SpriteIofxParameters_0p4::ClassVersion>
+						ConversionSpriteIofxParameters_0p3_0p4Parent;
+
+class ConversionSpriteIofxParameters_0p3_0p4: public ConversionSpriteIofxParameters_0p3_0p4Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionSpriteIofxParameters_0p3_0p4));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionSpriteIofxParameters_0p3_0p4)(t) : 0;
+	}
+
+protected:
+	ConversionSpriteIofxParameters_0p3_0p4(NvParameterized::Traits* t) : ConversionSpriteIofxParameters_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()
+	{
+		//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/iofx_legacy/include/IofxLegacyRender.h b/APEX_1.4/module/iofx_legacy/include/IofxLegacyRender.h
new file mode 100644
index 00000000..b821790b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/IofxLegacyRender.h
@@ -0,0 +1,179 @@
+/*
+ * 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 __IOFX_LEGACY_RENDER_H__
+#define __IOFX_LEGACY_RENDER_H__
+
+#include "Px.h"
+#include "Renderable.h"
+#include "PsUserAllocated.h"
+#include "ApexRenderable.h"
+#include "ApexRWLockable.h"
+
+#include "iofx/IofxRenderable.h"
+#include "iofx/IofxRenderCallback.h"
+
+#include "ApexSDKIntl.h"
+#include "Scene.h"
+#include "PxTaskManager.h"
+
+
+namespace nvidia
+{
+namespace apex
+{
+namespace legacy
+{
+
+
+class IofxLegacyRenderable : public Renderable, public ApexRenderable, public UserAllocated, public ApexRWLockable
+{
+public:
+	virtual	physx::PxBounds3	getBounds() const
+	{
+		return ApexRenderable::getBounds();
+	}
+	virtual	void				lockRenderResources()
+	{
+		ApexRenderable::renderDataLock();
+	}
+	virtual	void				unlockRenderResources()
+	{
+		ApexRenderable::renderDataUnLock();
+	}
+
+	void update()
+	{
+		ApexRenderable::mRenderBounds = mRenderable.getBounds();
+	}
+
+protected:
+	IofxLegacyRenderable(const IofxRenderable& renderable)
+		: mRenderable(renderable)
+	{
+	}
+
+	const IofxRenderable&	mRenderable;
+};
+
+
+class IofxLegacySpriteRenderable : public IofxLegacyRenderable
+{
+public:
+	IofxLegacySpriteRenderable(const IofxRenderable& renderable)
+		: IofxLegacyRenderable(renderable)
+		, mRenderResource(NULL)
+	{
+	}
+	virtual ~IofxLegacySpriteRenderable()
+	{
+		if (mRenderResource != NULL)
+		{
+			GetInternalApexSDK()->getUserRenderResourceManager()->releaseResource(*mRenderResource);
+		}
+	}
+
+	virtual void updateRenderResources(bool rewriteBuffers, void* userRenderData);
+	virtual void dispatchRenderResources(UserRenderer& renderer);
+
+private:
+	UserRenderResource*	mRenderResource;
+};
+
+
+class IofxLegacyMeshRenderable : public IofxLegacyRenderable
+{
+public:
+	IofxLegacyMeshRenderable(const IofxRenderable& renderable)
+		: IofxLegacyRenderable(renderable)
+		, mRenderMeshActor(NULL)
+	{
+	}
+	virtual ~IofxLegacyMeshRenderable()
+	{
+		if (mRenderMeshActor != NULL)
+		{
+			mRenderMeshActor->release();
+		}
+	}
+
+	virtual void updateRenderResources(bool rewriteBuffers, void* userRenderData);
+	virtual void dispatchRenderResources(UserRenderer& renderer);
+
+private:
+	RenderMeshActor* loadRenderMeshActor(const IofxMeshRenderData* meshRenderData);
+
+	RenderMeshActor*		mRenderMeshActor;
+};
+
+
+class IofxLegacyRenderCallback : public IofxRenderCallback, public UserAllocated
+{
+public:
+	IofxLegacyRenderCallback(const Scene* apexScene)
+	{
+		mGpuDispatcher = apexScene->getTaskManager()->getGpuDispatcher();
+	}
+
+	virtual void onCreatedIofxRenderable(IofxRenderable& renderable)
+	{
+		IofxLegacyRenderable* legacyRenderable = NULL;
+		switch (renderable.getType())
+		{
+		case IofxRenderable::SPRITE:
+			legacyRenderable = PX_NEW(IofxLegacySpriteRenderable)(renderable);
+			break;
+		case IofxRenderable::MESH:
+			legacyRenderable = PX_NEW(IofxLegacyMeshRenderable)(renderable);
+			break;
+		default:
+			PX_ALWAYS_ASSERT();
+		}
+		renderable.userData = legacyRenderable;
+	}
+
+	virtual void onUpdatedIofxRenderable(IofxRenderable& renderable)
+	{
+		IofxLegacyRenderable* legacyRenderable = static_cast<IofxLegacyRenderable*>(renderable.userData);
+		if (legacyRenderable != NULL)
+		{
+			legacyRenderable->update();
+		}
+	}
+
+	virtual void onReleasingIofxRenderable(IofxRenderable& renderable)
+	{
+		IofxLegacyRenderable* legacyRenderable = static_cast<IofxLegacyRenderable*>(renderable.userData);
+		if (legacyRenderable != NULL)
+		{
+			PX_DELETE(legacyRenderable);
+			renderable.userData = NULL;
+		}
+	}
+
+	virtual bool getIofxSpriteRenderLayout(IofxSpriteRenderLayout& spriteRenderLayout, uint32_t spriteCount, uint32_t spriteSemanticsBitmap, RenderInteropFlags::Enum interopFlags);
+
+	virtual bool getIofxMeshRenderLayout(IofxMeshRenderLayout& meshRenderLayout, uint32_t meshCount, uint32_t meshSemanticsBitmap, RenderInteropFlags::Enum interopFlags);
+
+	virtual UserRenderBuffer* createRenderBuffer(const UserRenderBufferDesc& );
+
+	virtual UserRenderSurface* createRenderSurface(const UserRenderSurfaceDesc& );
+
+private:
+	PxGpuDispatcher* mGpuDispatcher;
+};
+
+
+}
+}
+} // namespace nvidia
+
+#endif /* __IOFX_LEGACY_RENDER_H__ */
diff --git a/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsDensityCompositeModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsDensityCompositeModifierParams_0p0.h
new file mode 100644
index 00000000..82129200
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsDensityCompositeModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_ColorVsDensityCompositeModifierParams_0p0_h
+#define HEADER_ColorVsDensityCompositeModifierParams_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 ColorVsDensityCompositeModifierParams_0p0NS
+{
+
+struct colorDensityStruct_Type;
+
+struct colorDensityStruct_DynamicArray1D_Type
+{
+	colorDensityStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct colorDensityStruct_Type
+{
+	float density;
+	physx::PxVec4 color;
+};
+
+struct ParametersStruct
+{
+
+	colorDensityStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x6ee7f5a0, 0xedd1e5d5, 0x6169ab3c, 0x868306ec, };
+
+} // namespace ColorVsDensityCompositeModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsDensityCompositeModifierParams_0p0 : public NvParameterized::NvParameters, public ColorVsDensityCompositeModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ColorVsDensityCompositeModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsDensityCompositeModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsDensityCompositeModifierParams");
+	}
+
+	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(ColorVsDensityCompositeModifierParams_0p0NS::checksum);
+		return ColorVsDensityCompositeModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsDensityCompositeModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ColorVsDensityCompositeModifierParams_0p0* tmpThis = const_cast<ColorVsDensityCompositeModifierParams_0p0*>(this);
+		return *(static_cast<ColorVsDensityCompositeModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsDensityCompositeModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsDensityCompositeModifierParams_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 ColorVsDensityCompositeModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsDensityCompositeModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsDensityCompositeModifierParams_0p0), ColorVsDensityCompositeModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsDensityCompositeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsDensityCompositeModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsDensityCompositeModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsDensityCompositeModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsDensityCompositeModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsDensityCompositeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsDensityCompositeModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsDensityCompositeModifierParams_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 (ColorVsDensityCompositeModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsDensityCompositeModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsDensityCompositeModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsDensityCompositeModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsDensityCompositeModifierParams_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/iofx_legacy/include/autogen/ColorVsDensityModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsDensityModifierParams_0p0.h
new file mode 100644
index 00000000..d395d0ae
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsDensityModifierParams_0p0.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_ColorVsDensityModifierParams_0p0_h
+#define HEADER_ColorVsDensityModifierParams_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 ColorVsDensityModifierParams_0p0NS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* colorChannel;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xbd1ead31, 0x79bc4460, 0x6a89ef07, 0xbbe13350, };
+
+} // namespace ColorVsDensityModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsDensityModifierParams_0p0 : public NvParameterized::NvParameters, public ColorVsDensityModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ColorVsDensityModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsDensityModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsDensityModifierParams");
+	}
+
+	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(ColorVsDensityModifierParams_0p0NS::checksum);
+		return ColorVsDensityModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsDensityModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ColorVsDensityModifierParams_0p0* tmpThis = const_cast<ColorVsDensityModifierParams_0p0*>(this);
+		return *(static_cast<ColorVsDensityModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsDensityModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsDensityModifierParams_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 ColorVsDensityModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsDensityModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsDensityModifierParams_0p0), ColorVsDensityModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsDensityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsDensityModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsDensityModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsDensityModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsDensityModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsDensityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsDensityModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsDensityModifierParams_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 (ColorVsDensityModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsDensityModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsDensityModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsDensityModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsDensityModifierParams_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/iofx_legacy/include/autogen/ColorVsLifeCompositeModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsLifeCompositeModifierParams_0p0.h
new file mode 100644
index 00000000..cc3c24af
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsLifeCompositeModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_ColorVsLifeCompositeModifierParams_0p0_h
+#define HEADER_ColorVsLifeCompositeModifierParams_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 ColorVsLifeCompositeModifierParams_0p0NS
+{
+
+struct colorLifeStruct_Type;
+
+struct colorLifeStruct_DynamicArray1D_Type
+{
+	colorLifeStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct colorLifeStruct_Type
+{
+	float lifeRemaining;
+	physx::PxVec4 color;
+};
+
+struct ParametersStruct
+{
+
+	colorLifeStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x2ee279f3, 0x6440bf5b, 0x26d89b02, 0xc90fa659, };
+
+} // namespace ColorVsLifeCompositeModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsLifeCompositeModifierParams_0p0 : public NvParameterized::NvParameters, public ColorVsLifeCompositeModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ColorVsLifeCompositeModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsLifeCompositeModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsLifeCompositeModifierParams");
+	}
+
+	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(ColorVsLifeCompositeModifierParams_0p0NS::checksum);
+		return ColorVsLifeCompositeModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsLifeCompositeModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ColorVsLifeCompositeModifierParams_0p0* tmpThis = const_cast<ColorVsLifeCompositeModifierParams_0p0*>(this);
+		return *(static_cast<ColorVsLifeCompositeModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsLifeCompositeModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsLifeCompositeModifierParams_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 ColorVsLifeCompositeModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsLifeCompositeModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsLifeCompositeModifierParams_0p0), ColorVsLifeCompositeModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsLifeCompositeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsLifeCompositeModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsLifeCompositeModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsLifeCompositeModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsLifeCompositeModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsLifeCompositeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsLifeCompositeModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsLifeCompositeModifierParams_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 (ColorVsLifeCompositeModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsLifeCompositeModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsLifeCompositeModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsLifeCompositeModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsLifeCompositeModifierParams_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/iofx_legacy/include/autogen/ColorVsLifeModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsLifeModifierParams_0p0.h
new file mode 100644
index 00000000..582a8ac2
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsLifeModifierParams_0p0.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_ColorVsLifeModifierParams_0p0_h
+#define HEADER_ColorVsLifeModifierParams_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 ColorVsLifeModifierParams_0p0NS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* colorChannel;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x6273c5a3, 0xe1a0df26, 0x77f5af16, 0x6a54d1e7, };
+
+} // namespace ColorVsLifeModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsLifeModifierParams_0p0 : public NvParameterized::NvParameters, public ColorVsLifeModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ColorVsLifeModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsLifeModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsLifeModifierParams");
+	}
+
+	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(ColorVsLifeModifierParams_0p0NS::checksum);
+		return ColorVsLifeModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsLifeModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ColorVsLifeModifierParams_0p0* tmpThis = const_cast<ColorVsLifeModifierParams_0p0*>(this);
+		return *(static_cast<ColorVsLifeModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsLifeModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsLifeModifierParams_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 ColorVsLifeModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsLifeModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsLifeModifierParams_0p0), ColorVsLifeModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsLifeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsLifeModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsLifeModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsLifeModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsLifeModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsLifeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsLifeModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsLifeModifierParams_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 (ColorVsLifeModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsLifeModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsLifeModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsLifeModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsLifeModifierParams_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/iofx_legacy/include/autogen/ColorVsTemperatureCompositeModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsTemperatureCompositeModifierParams_0p0.h
new file mode 100644
index 00000000..7e6b563e
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsTemperatureCompositeModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_ColorVsTemperatureCompositeModifierParams_0p0_h
+#define HEADER_ColorVsTemperatureCompositeModifierParams_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 ColorVsTemperatureCompositeModifierParams_0p0NS
+{
+
+struct colorTemperatureStruct_Type;
+
+struct colorTemperatureStruct_DynamicArray1D_Type
+{
+	colorTemperatureStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct colorTemperatureStruct_Type
+{
+	float temperature;
+	physx::PxVec4 color;
+};
+
+struct ParametersStruct
+{
+
+	colorTemperatureStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xb5bad295, 0x1bbde1e7, 0xb10b2dc3, 0xde67581e, };
+
+} // namespace ColorVsTemperatureCompositeModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsTemperatureCompositeModifierParams_0p0 : public NvParameterized::NvParameters, public ColorVsTemperatureCompositeModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ColorVsTemperatureCompositeModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsTemperatureCompositeModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsTemperatureCompositeModifierParams");
+	}
+
+	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(ColorVsTemperatureCompositeModifierParams_0p0NS::checksum);
+		return ColorVsTemperatureCompositeModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsTemperatureCompositeModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ColorVsTemperatureCompositeModifierParams_0p0* tmpThis = const_cast<ColorVsTemperatureCompositeModifierParams_0p0*>(this);
+		return *(static_cast<ColorVsTemperatureCompositeModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsTemperatureCompositeModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsTemperatureCompositeModifierParams_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 ColorVsTemperatureCompositeModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsTemperatureCompositeModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsTemperatureCompositeModifierParams_0p0), ColorVsTemperatureCompositeModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsTemperatureCompositeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsTemperatureCompositeModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsTemperatureCompositeModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsTemperatureCompositeModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsTemperatureCompositeModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsTemperatureCompositeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsTemperatureCompositeModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsTemperatureCompositeModifierParams_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 (ColorVsTemperatureCompositeModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsTemperatureCompositeModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsTemperatureCompositeModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsTemperatureCompositeModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsTemperatureCompositeModifierParams_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/iofx_legacy/include/autogen/ColorVsTemperatureModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsTemperatureModifierParams_0p0.h
new file mode 100644
index 00000000..ad95f92a
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsTemperatureModifierParams_0p0.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_ColorVsTemperatureModifierParams_0p0_h
+#define HEADER_ColorVsTemperatureModifierParams_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 ColorVsTemperatureModifierParams_0p0NS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* colorChannel;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xe539a2ca, 0x44cf1564, 0xa6a2c047, 0xec15660d, };
+
+} // namespace ColorVsTemperatureModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsTemperatureModifierParams_0p0 : public NvParameterized::NvParameters, public ColorVsTemperatureModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ColorVsTemperatureModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsTemperatureModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsTemperatureModifierParams");
+	}
+
+	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(ColorVsTemperatureModifierParams_0p0NS::checksum);
+		return ColorVsTemperatureModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsTemperatureModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ColorVsTemperatureModifierParams_0p0* tmpThis = const_cast<ColorVsTemperatureModifierParams_0p0*>(this);
+		return *(static_cast<ColorVsTemperatureModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsTemperatureModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsTemperatureModifierParams_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 ColorVsTemperatureModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsTemperatureModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsTemperatureModifierParams_0p0), ColorVsTemperatureModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsTemperatureModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsTemperatureModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsTemperatureModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsTemperatureModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsTemperatureModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsTemperatureModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsTemperatureModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsTemperatureModifierParams_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 (ColorVsTemperatureModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsTemperatureModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsTemperatureModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsTemperatureModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsTemperatureModifierParams_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/iofx_legacy/include/autogen/ColorVsVelocityCompositeModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsVelocityCompositeModifierParams_0p0.h
new file mode 100644
index 00000000..ce0b397f
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsVelocityCompositeModifierParams_0p0.h
@@ -0,0 +1,246 @@
+// 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_ColorVsVelocityCompositeModifierParams_0p0_h
+#define HEADER_ColorVsVelocityCompositeModifierParams_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 ColorVsVelocityCompositeModifierParams_0p0NS
+{
+
+struct colorVelocityStruct_Type;
+
+struct colorVelocityStruct_DynamicArray1D_Type
+{
+	colorVelocityStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct colorVelocityStruct_Type
+{
+	float velocity;
+	physx::PxVec4 color;
+};
+
+struct ParametersStruct
+{
+
+	float velocity0;
+	float velocity1;
+	colorVelocityStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x85918a9e, 0x651f465d, 0x179721b9, 0x3bbd630d, };
+
+} // namespace ColorVsVelocityCompositeModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsVelocityCompositeModifierParams_0p0 : public NvParameterized::NvParameters, public ColorVsVelocityCompositeModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ColorVsVelocityCompositeModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsVelocityCompositeModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsVelocityCompositeModifierParams");
+	}
+
+	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(ColorVsVelocityCompositeModifierParams_0p0NS::checksum);
+		return ColorVsVelocityCompositeModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsVelocityCompositeModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ColorVsVelocityCompositeModifierParams_0p0* tmpThis = const_cast<ColorVsVelocityCompositeModifierParams_0p0*>(this);
+		return *(static_cast<ColorVsVelocityCompositeModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsVelocityCompositeModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsVelocityCompositeModifierParams_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 ColorVsVelocityCompositeModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsVelocityCompositeModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsVelocityCompositeModifierParams_0p0), ColorVsVelocityCompositeModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsVelocityCompositeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsVelocityCompositeModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsVelocityCompositeModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsVelocityCompositeModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsVelocityCompositeModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsVelocityCompositeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsVelocityCompositeModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsVelocityCompositeModifierParams_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 (ColorVsVelocityCompositeModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsVelocityCompositeModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsVelocityCompositeModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsVelocityCompositeModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsVelocityCompositeModifierParams_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/iofx_legacy/include/autogen/ColorVsVelocityModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsVelocityModifierParams_0p0.h
new file mode 100644
index 00000000..227713c2
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ColorVsVelocityModifierParams_0p0.h
@@ -0,0 +1,247 @@
+// 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_ColorVsVelocityModifierParams_0p0_h
+#define HEADER_ColorVsVelocityModifierParams_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 ColorVsVelocityModifierParams_0p0NS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* colorChannel;
+	float velocity0;
+	float velocity1;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x4c79c470, 0xac91d48e, 0xa4578ba1, 0x9c1ae2f2, };
+
+} // namespace ColorVsVelocityModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ColorVsVelocityModifierParams_0p0 : public NvParameterized::NvParameters, public ColorVsVelocityModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ColorVsVelocityModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ColorVsVelocityModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ColorVsVelocityModifierParams");
+	}
+
+	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(ColorVsVelocityModifierParams_0p0NS::checksum);
+		return ColorVsVelocityModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ColorVsVelocityModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ColorVsVelocityModifierParams_0p0* tmpThis = const_cast<ColorVsVelocityModifierParams_0p0*>(this);
+		return *(static_cast<ColorVsVelocityModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ColorVsVelocityModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ColorVsVelocityModifierParams_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 ColorVsVelocityModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ColorVsVelocityModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ColorVsVelocityModifierParams_0p0), ColorVsVelocityModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ColorVsVelocityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsVelocityModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ColorVsVelocityModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ColorVsVelocityModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ColorVsVelocityModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ColorVsVelocityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ColorVsVelocityModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ColorVsVelocityModifierParams_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 (ColorVsVelocityModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ColorVsVelocityModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ColorVsVelocityModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ColorVsVelocityModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ColorVsVelocityModifierParams_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/iofx_legacy/include/autogen/InitialColorModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/InitialColorModifierParams_0p0.h
new file mode 100644
index 00000000..ad7e9799
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/InitialColorModifierParams_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_InitialColorModifierParams_0p0_h
+#define HEADER_InitialColorModifierParams_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 InitialColorModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxVec4 color;
+
+};
+
+static const uint32_t checksum[] = { 0xeede1183, 0x3f1f709f, 0x0957a3e8, 0x4a27910f, };
+
+} // namespace InitialColorModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class InitialColorModifierParams_0p0 : public NvParameterized::NvParameters, public InitialColorModifierParams_0p0NS::ParametersStruct
+{
+public:
+	InitialColorModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~InitialColorModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("InitialColorModifierParams");
+	}
+
+	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(InitialColorModifierParams_0p0NS::checksum);
+		return InitialColorModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const InitialColorModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		InitialColorModifierParams_0p0* tmpThis = const_cast<InitialColorModifierParams_0p0*>(this);
+		return *(static_cast<InitialColorModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	InitialColorModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<InitialColorModifierParams_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 InitialColorModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		InitialColorModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(InitialColorModifierParams_0p0), InitialColorModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, InitialColorModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class InitialColorModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(InitialColorModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, InitialColorModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, InitialColorModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, InitialColorModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class InitialColorModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of InitialColorModifierParams_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 (InitialColorModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (InitialColorModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (InitialColorModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (InitialColorModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (InitialColorModifierParams_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/iofx_legacy/include/autogen/IofxAssetParameters_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/IofxAssetParameters_0p0.h
new file mode 100644
index 00000000..5a635b2f
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/IofxAssetParameters_0p0.h
@@ -0,0 +1,255 @@
+// 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_IofxAssetParameters_0p0_h
+#define HEADER_IofxAssetParameters_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 IofxAssetParameters_0p0NS
+{
+
+struct meshProperties_Type;
+
+struct meshProperties_DynamicArray1D_Type
+{
+	meshProperties_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct meshProperties_Type
+{
+	NvParameterized::Interface* meshAssetName;
+	uint32_t weight;
+};
+
+struct ParametersStruct
+{
+
+	meshProperties_DynamicArray1D_Type renderMeshList;
+	NvParameterized::Interface* spriteMaterialName;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0xd0fecc63, 0x54e1d41d, 0x01415624, 0x6c76ef09, };
+
+} // namespace IofxAssetParameters_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class IofxAssetParameters_0p0 : public NvParameterized::NvParameters, public IofxAssetParameters_0p0NS::ParametersStruct
+{
+public:
+	IofxAssetParameters_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~IofxAssetParameters_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("IofxAssetParameters");
+	}
+
+	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(IofxAssetParameters_0p0NS::checksum);
+		return IofxAssetParameters_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const IofxAssetParameters_0p0NS::ParametersStruct& parameters(void) const
+	{
+		IofxAssetParameters_0p0* tmpThis = const_cast<IofxAssetParameters_0p0*>(this);
+		return *(static_cast<IofxAssetParameters_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	IofxAssetParameters_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<IofxAssetParameters_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 IofxAssetParameters_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		IofxAssetParameters_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(IofxAssetParameters_0p0), IofxAssetParameters_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, IofxAssetParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxAssetParameters_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(IofxAssetParameters_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, IofxAssetParameters_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, IofxAssetParameters_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, IofxAssetParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxAssetParameters_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of IofxAssetParameters_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 (IofxAssetParameters_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (IofxAssetParameters_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (IofxAssetParameters_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (IofxAssetParameters_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (IofxAssetParameters_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/iofx_legacy/include/autogen/IofxAssetParameters_0p1.h b/APEX_1.4/module/iofx_legacy/include/autogen/IofxAssetParameters_0p1.h
new file mode 100644
index 00000000..39fca56b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/IofxAssetParameters_0p1.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_IofxAssetParameters_0p1_h
+#define HEADER_IofxAssetParameters_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 IofxAssetParameters_0p1NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* iofxType;
+
+};
+
+static const uint32_t checksum[] = { 0x4f59ea8d, 0xffdb948a, 0x87165d25, 0xda1345f1, };
+
+} // namespace IofxAssetParameters_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class IofxAssetParameters_0p1 : public NvParameterized::NvParameters, public IofxAssetParameters_0p1NS::ParametersStruct
+{
+public:
+	IofxAssetParameters_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~IofxAssetParameters_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("IofxAssetParameters");
+	}
+
+	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(IofxAssetParameters_0p1NS::checksum);
+		return IofxAssetParameters_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const IofxAssetParameters_0p1NS::ParametersStruct& parameters(void) const
+	{
+		IofxAssetParameters_0p1* tmpThis = const_cast<IofxAssetParameters_0p1*>(this);
+		return *(static_cast<IofxAssetParameters_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	IofxAssetParameters_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<IofxAssetParameters_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 IofxAssetParameters_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		IofxAssetParameters_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(IofxAssetParameters_0p1), IofxAssetParameters_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, IofxAssetParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxAssetParameters_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(IofxAssetParameters_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, IofxAssetParameters_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, IofxAssetParameters_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, IofxAssetParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxAssetParameters_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of IofxAssetParameters_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 (IofxAssetParameters_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (IofxAssetParameters_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (IofxAssetParameters_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (IofxAssetParameters_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (IofxAssetParameters_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/iofx_legacy/include/autogen/IofxAssetParameters_0p2.h b/APEX_1.4/module/iofx_legacy/include/autogen/IofxAssetParameters_0p2.h
new file mode 100644
index 00000000..c51fc5db
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/IofxAssetParameters_0p2.h
@@ -0,0 +1,237 @@
+// 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_IofxAssetParameters_0p2_h
+#define HEADER_IofxAssetParameters_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 IofxAssetParameters_0p2NS
+{
+
+struct outputProperties_Type;
+
+struct outputProperties_Type
+{
+	bool useUserSemantic;
+	bool useFloat4Color;
+};
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* iofxType;
+	outputProperties_Type renderOutput;
+
+};
+
+static const uint32_t checksum[] = { 0xbb5add57, 0xf771d298, 0xcd7c3bc3, 0x921baa57, };
+
+} // namespace IofxAssetParameters_0p2NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class IofxAssetParameters_0p2 : public NvParameterized::NvParameters, public IofxAssetParameters_0p2NS::ParametersStruct
+{
+public:
+	IofxAssetParameters_0p2(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~IofxAssetParameters_0p2();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("IofxAssetParameters");
+	}
+
+	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(IofxAssetParameters_0p2NS::checksum);
+		return IofxAssetParameters_0p2NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const IofxAssetParameters_0p2NS::ParametersStruct& parameters(void) const
+	{
+		IofxAssetParameters_0p2* tmpThis = const_cast<IofxAssetParameters_0p2*>(this);
+		return *(static_cast<IofxAssetParameters_0p2NS::ParametersStruct*>(tmpThis));
+	}
+
+	IofxAssetParameters_0p2NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<IofxAssetParameters_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 IofxAssetParameters_0p2Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		IofxAssetParameters_0p2::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(IofxAssetParameters_0p2), IofxAssetParameters_0p2::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, IofxAssetParameters_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxAssetParameters_0p2");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(IofxAssetParameters_0p2)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, IofxAssetParameters_0p2)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, IofxAssetParameters_0p2::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, IofxAssetParameters_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxAssetParameters_0p2");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of IofxAssetParameters_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 (IofxAssetParameters_0p2*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (IofxAssetParameters_0p2::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (IofxAssetParameters_0p2::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (IofxAssetParameters_0p2::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (IofxAssetParameters_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/iofx_legacy/include/autogen/IofxDebugRenderParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/IofxDebugRenderParams_0p0.h
new file mode 100644
index 00000000..bd8fbe98
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/IofxDebugRenderParams_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_IofxDebugRenderParams_0p0_h
+#define HEADER_IofxDebugRenderParams_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 IofxDebugRenderParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	bool VISUALIZE_IOFX_ACTOR;
+	bool VISUALIZE_IOFX_BOUNDING_BOX;
+	bool VISUALIZE_IOFX_ACTOR_NAME;
+
+};
+
+static const uint32_t checksum[] = { 0xa907935c, 0x197f0683, 0x47c3ea05, 0x61985bda, };
+
+} // namespace IofxDebugRenderParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class IofxDebugRenderParams_0p0 : public NvParameterized::NvParameters, public IofxDebugRenderParams_0p0NS::ParametersStruct
+{
+public:
+	IofxDebugRenderParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~IofxDebugRenderParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("IofxDebugRenderParams");
+	}
+
+	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(IofxDebugRenderParams_0p0NS::checksum);
+		return IofxDebugRenderParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const IofxDebugRenderParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		IofxDebugRenderParams_0p0* tmpThis = const_cast<IofxDebugRenderParams_0p0*>(this);
+		return *(static_cast<IofxDebugRenderParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	IofxDebugRenderParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<IofxDebugRenderParams_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 IofxDebugRenderParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		IofxDebugRenderParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(IofxDebugRenderParams_0p0), IofxDebugRenderParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, IofxDebugRenderParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxDebugRenderParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(IofxDebugRenderParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, IofxDebugRenderParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, IofxDebugRenderParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, IofxDebugRenderParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxDebugRenderParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of IofxDebugRenderParams_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 (IofxDebugRenderParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (IofxDebugRenderParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (IofxDebugRenderParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (IofxDebugRenderParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (IofxDebugRenderParams_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/iofx_legacy/include/autogen/IofxModuleParameters_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/IofxModuleParameters_0p0.h
new file mode 100644
index 00000000..dbb98b2a
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/IofxModuleParameters_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_IofxModuleParameters_0p0_h
+#define HEADER_IofxModuleParameters_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 IofxModuleParameters_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	uint32_t unused;
+
+};
+
+static const uint32_t checksum[] = { 0x70f85d6f, 0xc44790e5, 0x2f3cd6fd, 0x9d4a542b, };
+
+} // namespace IofxModuleParameters_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class IofxModuleParameters_0p0 : public NvParameterized::NvParameters, public IofxModuleParameters_0p0NS::ParametersStruct
+{
+public:
+	IofxModuleParameters_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~IofxModuleParameters_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("IofxModuleParameters");
+	}
+
+	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(IofxModuleParameters_0p0NS::checksum);
+		return IofxModuleParameters_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const IofxModuleParameters_0p0NS::ParametersStruct& parameters(void) const
+	{
+		IofxModuleParameters_0p0* tmpThis = const_cast<IofxModuleParameters_0p0*>(this);
+		return *(static_cast<IofxModuleParameters_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	IofxModuleParameters_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<IofxModuleParameters_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 IofxModuleParameters_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		IofxModuleParameters_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(IofxModuleParameters_0p0), IofxModuleParameters_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, IofxModuleParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxModuleParameters_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(IofxModuleParameters_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, IofxModuleParameters_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, IofxModuleParameters_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, IofxModuleParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class IofxModuleParameters_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of IofxModuleParameters_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 (IofxModuleParameters_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (IofxModuleParameters_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (IofxModuleParameters_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (IofxModuleParameters_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (IofxModuleParameters_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/iofx_legacy/include/autogen/MeshIofxParameters_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/MeshIofxParameters_0p0.h
new file mode 100644
index 00000000..322a8727
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/MeshIofxParameters_0p0.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_MeshIofxParameters_0p0_h
+#define HEADER_MeshIofxParameters_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 MeshIofxParameters_0p0NS
+{
+
+struct meshProperties_Type;
+
+struct meshProperties_DynamicArray1D_Type
+{
+	meshProperties_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct meshProperties_Type
+{
+	NvParameterized::Interface* meshAssetName;
+	uint32_t weight;
+};
+
+struct ParametersStruct
+{
+
+	meshProperties_DynamicArray1D_Type renderMeshList;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0xa0c3f29f, 0x5dfadb24, 0xca44ca2c, 0x76243c01, };
+
+} // namespace MeshIofxParameters_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class MeshIofxParameters_0p0 : public NvParameterized::NvParameters, public MeshIofxParameters_0p0NS::ParametersStruct
+{
+public:
+	MeshIofxParameters_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~MeshIofxParameters_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("MeshIofxParameters");
+	}
+
+	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(MeshIofxParameters_0p0NS::checksum);
+		return MeshIofxParameters_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const MeshIofxParameters_0p0NS::ParametersStruct& parameters(void) const
+	{
+		MeshIofxParameters_0p0* tmpThis = const_cast<MeshIofxParameters_0p0*>(this);
+		return *(static_cast<MeshIofxParameters_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	MeshIofxParameters_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<MeshIofxParameters_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 MeshIofxParameters_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		MeshIofxParameters_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(MeshIofxParameters_0p0), MeshIofxParameters_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, MeshIofxParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(MeshIofxParameters_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, MeshIofxParameters_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, MeshIofxParameters_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, MeshIofxParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of MeshIofxParameters_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 (MeshIofxParameters_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (MeshIofxParameters_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (MeshIofxParameters_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (MeshIofxParameters_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (MeshIofxParameters_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/iofx_legacy/include/autogen/MeshIofxParameters_0p1.h b/APEX_1.4/module/iofx_legacy/include/autogen/MeshIofxParameters_0p1.h
new file mode 100644
index 00000000..2eb450bd
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/MeshIofxParameters_0p1.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_MeshIofxParameters_0p1_h
+#define HEADER_MeshIofxParameters_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 MeshIofxParameters_0p1NS
+{
+
+struct meshProperties_Type;
+
+struct meshProperties_DynamicArray1D_Type
+{
+	meshProperties_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct meshProperties_Type
+{
+	NvParameterized::Interface* meshAssetName;
+	uint32_t weight;
+};
+
+struct ParametersStruct
+{
+
+	meshProperties_DynamicArray1D_Type renderMeshList;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0x68878fe3, 0xe53d77a0, 0x5178ce8f, 0x88a54038, };
+
+} // namespace MeshIofxParameters_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class MeshIofxParameters_0p1 : public NvParameterized::NvParameters, public MeshIofxParameters_0p1NS::ParametersStruct
+{
+public:
+	MeshIofxParameters_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~MeshIofxParameters_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("MeshIofxParameters");
+	}
+
+	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(MeshIofxParameters_0p1NS::checksum);
+		return MeshIofxParameters_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const MeshIofxParameters_0p1NS::ParametersStruct& parameters(void) const
+	{
+		MeshIofxParameters_0p1* tmpThis = const_cast<MeshIofxParameters_0p1*>(this);
+		return *(static_cast<MeshIofxParameters_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	MeshIofxParameters_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<MeshIofxParameters_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 MeshIofxParameters_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		MeshIofxParameters_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(MeshIofxParameters_0p1), MeshIofxParameters_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, MeshIofxParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(MeshIofxParameters_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, MeshIofxParameters_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, MeshIofxParameters_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, MeshIofxParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of MeshIofxParameters_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 (MeshIofxParameters_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (MeshIofxParameters_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (MeshIofxParameters_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (MeshIofxParameters_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (MeshIofxParameters_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/iofx_legacy/include/autogen/MeshIofxParameters_0p2.h b/APEX_1.4/module/iofx_legacy/include/autogen/MeshIofxParameters_0p2.h
new file mode 100644
index 00000000..32bba331
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/MeshIofxParameters_0p2.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_MeshIofxParameters_0p2_h
+#define HEADER_MeshIofxParameters_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 MeshIofxParameters_0p2NS
+{
+
+struct meshProperties_Type;
+
+struct meshProperties_DynamicArray1D_Type
+{
+	meshProperties_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct meshProperties_Type
+{
+	NvParameterized::Interface* meshAssetName;
+	uint32_t weight;
+};
+
+struct ParametersStruct
+{
+
+	meshProperties_DynamicArray1D_Type renderMeshList;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0x01219894, 0xa1dc10d6, 0x3868a537, 0x2d1c47d1, };
+
+} // namespace MeshIofxParameters_0p2NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class MeshIofxParameters_0p2 : public NvParameterized::NvParameters, public MeshIofxParameters_0p2NS::ParametersStruct
+{
+public:
+	MeshIofxParameters_0p2(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~MeshIofxParameters_0p2();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("MeshIofxParameters");
+	}
+
+	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(MeshIofxParameters_0p2NS::checksum);
+		return MeshIofxParameters_0p2NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const MeshIofxParameters_0p2NS::ParametersStruct& parameters(void) const
+	{
+		MeshIofxParameters_0p2* tmpThis = const_cast<MeshIofxParameters_0p2*>(this);
+		return *(static_cast<MeshIofxParameters_0p2NS::ParametersStruct*>(tmpThis));
+	}
+
+	MeshIofxParameters_0p2NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<MeshIofxParameters_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 MeshIofxParameters_0p2Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		MeshIofxParameters_0p2::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(MeshIofxParameters_0p2), MeshIofxParameters_0p2::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, MeshIofxParameters_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters_0p2");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(MeshIofxParameters_0p2)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, MeshIofxParameters_0p2)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, MeshIofxParameters_0p2::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, MeshIofxParameters_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters_0p2");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of MeshIofxParameters_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 (MeshIofxParameters_0p2*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (MeshIofxParameters_0p2::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (MeshIofxParameters_0p2::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (MeshIofxParameters_0p2::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (MeshIofxParameters_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/iofx_legacy/include/autogen/MeshIofxParameters_0p3.h b/APEX_1.4/module/iofx_legacy/include/autogen/MeshIofxParameters_0p3.h
new file mode 100644
index 00000000..784d5226
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/MeshIofxParameters_0p3.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_MeshIofxParameters_0p3_h
+#define HEADER_MeshIofxParameters_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 MeshIofxParameters_0p3NS
+{
+
+struct meshProperties_Type;
+
+struct meshProperties_DynamicArray1D_Type
+{
+	meshProperties_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct meshProperties_Type
+{
+	NvParameterized::Interface* meshAssetName;
+	uint32_t weight;
+};
+
+struct ParametersStruct
+{
+
+	meshProperties_DynamicArray1D_Type renderMeshList;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0x3c0c42df, 0x4d3621ee, 0x5b48542e, 0xa83ea448, };
+
+} // namespace MeshIofxParameters_0p3NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class MeshIofxParameters_0p3 : public NvParameterized::NvParameters, public MeshIofxParameters_0p3NS::ParametersStruct
+{
+public:
+	MeshIofxParameters_0p3(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~MeshIofxParameters_0p3();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("MeshIofxParameters");
+	}
+
+	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(MeshIofxParameters_0p3NS::checksum);
+		return MeshIofxParameters_0p3NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const MeshIofxParameters_0p3NS::ParametersStruct& parameters(void) const
+	{
+		MeshIofxParameters_0p3* tmpThis = const_cast<MeshIofxParameters_0p3*>(this);
+		return *(static_cast<MeshIofxParameters_0p3NS::ParametersStruct*>(tmpThis));
+	}
+
+	MeshIofxParameters_0p3NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<MeshIofxParameters_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 MeshIofxParameters_0p3Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		MeshIofxParameters_0p3::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(MeshIofxParameters_0p3), MeshIofxParameters_0p3::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, MeshIofxParameters_0p3::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters_0p3");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(MeshIofxParameters_0p3)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, MeshIofxParameters_0p3)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, MeshIofxParameters_0p3::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, MeshIofxParameters_0p3::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters_0p3");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of MeshIofxParameters_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 (MeshIofxParameters_0p3*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (MeshIofxParameters_0p3::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (MeshIofxParameters_0p3::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (MeshIofxParameters_0p3::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (MeshIofxParameters_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/iofx_legacy/include/autogen/MeshIofxParameters_0p4.h b/APEX_1.4/module/iofx_legacy/include/autogen/MeshIofxParameters_0p4.h
new file mode 100644
index 00000000..3876f6e5
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/MeshIofxParameters_0p4.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_MeshIofxParameters_0p4_h
+#define HEADER_MeshIofxParameters_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 MeshIofxParameters_0p4NS
+{
+
+struct meshProperties_Type;
+
+struct meshProperties_DynamicArray1D_Type
+{
+	meshProperties_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct meshProperties_Type
+{
+	NvParameterized::Interface* meshAssetName;
+	uint32_t weight;
+};
+
+struct ParametersStruct
+{
+
+	meshProperties_DynamicArray1D_Type renderMeshList;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0x823a573c, 0xd18e2215, 0x6fc4db63, 0x3df0022a, };
+
+} // namespace MeshIofxParameters_0p4NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class MeshIofxParameters_0p4 : public NvParameterized::NvParameters, public MeshIofxParameters_0p4NS::ParametersStruct
+{
+public:
+	MeshIofxParameters_0p4(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~MeshIofxParameters_0p4();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("MeshIofxParameters");
+	}
+
+	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(MeshIofxParameters_0p4NS::checksum);
+		return MeshIofxParameters_0p4NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const MeshIofxParameters_0p4NS::ParametersStruct& parameters(void) const
+	{
+		MeshIofxParameters_0p4* tmpThis = const_cast<MeshIofxParameters_0p4*>(this);
+		return *(static_cast<MeshIofxParameters_0p4NS::ParametersStruct*>(tmpThis));
+	}
+
+	MeshIofxParameters_0p4NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<MeshIofxParameters_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 MeshIofxParameters_0p4Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		MeshIofxParameters_0p4::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(MeshIofxParameters_0p4), MeshIofxParameters_0p4::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, MeshIofxParameters_0p4::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters_0p4");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(MeshIofxParameters_0p4)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, MeshIofxParameters_0p4)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, MeshIofxParameters_0p4::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, MeshIofxParameters_0p4::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class MeshIofxParameters_0p4");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of MeshIofxParameters_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 (MeshIofxParameters_0p4*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (MeshIofxParameters_0p4::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (MeshIofxParameters_0p4::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (MeshIofxParameters_0p4::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (MeshIofxParameters_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/iofx_legacy/include/autogen/ModuleIOFXLegacyRegistration.h b/APEX_1.4/module/iofx_legacy/include/autogen/ModuleIOFXLegacyRegistration.h
new file mode 100644
index 00000000..ed0c211b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ModuleIOFXLegacyRegistration.h
@@ -0,0 +1,430 @@
+/*
+ * 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_MODULEIOFXLEGACYREGISTRATIONH_H
+#define MODULE_MODULEIOFXLEGACYREGISTRATIONH_H
+
+#include "PsAllocator.h"
+#include "NvRegistrationsForTraitsBase.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "PxAssert.h"
+#include <stdint.h>
+
+// INCLUDE GENERATED FACTORIES
+#include "IofxAssetParameters_0p0.h"
+#include "IofxAssetParameters_0p1.h"
+#include "MeshIofxParameters_0p0.h"
+#include "MeshIofxParameters_0p1.h"
+#include "MeshIofxParameters_0p2.h"
+#include "MeshIofxParameters_0p3.h"
+#include "OrientScaleAlongScreenVelocityModifierParams_0p0.h"
+#include "RotationModifierParams_0p0.h"
+#include "RotationModifierParams_0p1.h"
+#include "SpriteIofxParameters_0p0.h"
+#include "SpriteIofxParameters_0p1.h"
+#include "SpriteIofxParameters_0p2.h"
+#include "SpriteIofxParameters_0p3.h"
+#include "IofxDebugRenderParams_0p0.h"
+#include "IofxAssetParameters_0p2.h"
+#include "MeshIofxParameters_0p4.h"
+#include "SpriteIofxParameters_0p4.h"
+#include "RotationModifierParams_0p2.h"
+#include "SimpleScaleModifierParams_0p0.h"
+#include "ScaleByMassModifierParams_0p0.h"
+#include "RandomScaleModifierParams_0p0.h"
+#include "ColorVsLifeModifierParams_0p0.h"
+#include "ColorVsLifeCompositeModifierParams_0p0.h"
+#include "InitialColorModifierParams_0p0.h"
+#include "ScaleVsLifeModifierParams_0p0.h"
+#include "ScaleVsLife3DModifierParams_0p0.h"
+#include "ScaleVsLife2DModifierParams_0p0.h"
+#include "ScaleVsDensityModifierParams_0p0.h"
+#include "ScaleVsDensity3DModifierParams_0p0.h"
+#include "ScaleVsDensity2DModifierParams_0p0.h"
+#include "ScaleVsCameraDistanceModifierParams_0p0.h"
+#include "ScaleVsCameraDistance3DModifierParams_0p0.h"
+#include "ScaleVsCameraDistance2DModifierParams_0p0.h"
+#include "ColorVsDensityModifierParams_0p0.h"
+#include "ColorVsDensityCompositeModifierParams_0p0.h"
+#include "SubtextureVsLifeModifierParams_0p0.h"
+#include "OrientAlongVelocityModifierParams_0p0.h"
+#include "ScaleAlongVelocityModifierParams_0p0.h"
+#include "RandomSubtextureModifierParams_0p0.h"
+#include "RandomRotationModifierParams_0p0.h"
+#include "ViewDirectionSortingModifierParams_0p0.h"
+#include "RotationRateModifierParams_0p0.h"
+#include "RotationRateVsLifeModifierParams_0p0.h"
+#include "OrientScaleAlongScreenVelocityModifierParams_0p1.h"
+#include "ColorVsVelocityModifierParams_0p0.h"
+#include "ColorVsVelocityCompositeModifierParams_0p0.h"
+#include "ColorVsTemperatureModifierParams_0p0.h"
+#include "ColorVsTemperatureCompositeModifierParams_0p0.h"
+#include "ScaleVsTemperatureModifierParams_0p0.h"
+#include "ScaleVsTemperature3DModifierParams_0p0.h"
+#include "ScaleVsTemperature2DModifierParams_0p0.h"
+#include "IofxModuleParameters_0p0.h"
+
+
+// INCLUDE GENERATED CONVERSION
+#include "ConversionIofxAssetParameters_0p0_0p1.h"
+#include "ConversionIofxAssetParameters_0p1_0p2.h"
+#include "ConversionMeshIofxParameters_0p0_0p1.h"
+#include "ConversionMeshIofxParameters_0p1_0p2.h"
+#include "ConversionMeshIofxParameters_0p2_0p3.h"
+#include "ConversionMeshIofxParameters_0p3_0p4.h"
+#include "ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1.h"
+#include "ConversionRotationModifierParams_0p0_0p1.h"
+#include "ConversionRotationModifierParams_0p1_0p2.h"
+#include "ConversionSpriteIofxParameters_0p0_0p1.h"
+#include "ConversionSpriteIofxParameters_0p1_0p2.h"
+#include "ConversionSpriteIofxParameters_0p2_0p3.h"
+#include "ConversionSpriteIofxParameters_0p3_0p4.h"
+
+
+// global namespace
+
+class ModuleIOFXLegacyRegistration : public NvParameterized::RegistrationsForTraitsBase
+{
+public:
+	static void invokeRegistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleIOFXLegacyRegistration().registerAll(*parameterizedTraits);
+		}
+	}
+
+	static void invokeUnregistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleIOFXLegacyRegistration().unregisterAll(*parameterizedTraits);
+		}
+	}
+
+	void registerAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		::NvParameterized::Factory* factoriesToRegister[] = {
+// REGISTER GENERATED FACTORIES
+			new nvidia::parameterized::IofxAssetParameters_0p0Factory(),
+			new nvidia::parameterized::IofxAssetParameters_0p1Factory(),
+			new nvidia::parameterized::MeshIofxParameters_0p0Factory(),
+			new nvidia::parameterized::MeshIofxParameters_0p1Factory(),
+			new nvidia::parameterized::MeshIofxParameters_0p2Factory(),
+			new nvidia::parameterized::MeshIofxParameters_0p3Factory(),
+			new nvidia::parameterized::OrientScaleAlongScreenVelocityModifierParams_0p0Factory(),
+			new nvidia::parameterized::RotationModifierParams_0p0Factory(),
+			new nvidia::parameterized::RotationModifierParams_0p1Factory(),
+			new nvidia::parameterized::SpriteIofxParameters_0p0Factory(),
+			new nvidia::parameterized::SpriteIofxParameters_0p1Factory(),
+			new nvidia::parameterized::SpriteIofxParameters_0p2Factory(),
+			new nvidia::parameterized::SpriteIofxParameters_0p3Factory(),
+
+		};
+
+		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::ConversionIofxAssetParameters_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionIofxAssetParameters_0p1_0p2 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionMeshIofxParameters_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionMeshIofxParameters_0p1_0p2 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionMeshIofxParameters_0p2_0p3 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionMeshIofxParameters_0p3_0p4 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionOrientScaleAlongScreenVelocityModifierParams_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionRotationModifierParams_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionRotationModifierParams_0p1_0p2 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionSpriteIofxParameters_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionSpriteIofxParameters_0p1_0p2 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionSpriteIofxParameters_0p2_0p3 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionSpriteIofxParameters_0p3_0p4 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::IofxAssetParameters_0p0Factory(),
+			new nvidia::parameterized::IofxAssetParameters_0p1Factory(),
+			new nvidia::parameterized::MeshIofxParameters_0p0Factory(),
+			new nvidia::parameterized::MeshIofxParameters_0p1Factory(),
+			new nvidia::parameterized::MeshIofxParameters_0p2Factory(),
+			new nvidia::parameterized::MeshIofxParameters_0p3Factory(),
+			new nvidia::parameterized::OrientScaleAlongScreenVelocityModifierParams_0p0Factory(),
+			new nvidia::parameterized::RotationModifierParams_0p0Factory(),
+			new nvidia::parameterized::RotationModifierParams_0p1Factory(),
+			new nvidia::parameterized::SpriteIofxParameters_0p0Factory(),
+			new nvidia::parameterized::SpriteIofxParameters_0p1Factory(),
+			new nvidia::parameterized::SpriteIofxParameters_0p2Factory(),
+			new nvidia::parameterized::SpriteIofxParameters_0p3Factory(),
+
+		};
+
+		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::ConversionIofxAssetParameters_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::ConversionIofxAssetParameters_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::ConversionMeshIofxParameters_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::ConversionMeshIofxParameters_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::ConversionMeshIofxParameters_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::ConversionMeshIofxParameters_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::ConversionOrientScaleAlongScreenVelocityModifierParams_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::ConversionRotationModifierParams_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::ConversionRotationModifierParams_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::ConversionSpriteIofxParameters_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::ConversionSpriteIofxParameters_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::ConversionSpriteIofxParameters_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::ConversionSpriteIofxParameters_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");
+			}
+			}
+
+	}
+
+};
+
+// global namespace
+
+#endif
diff --git a/APEX_1.4/module/iofx_legacy/include/autogen/OrientAlongVelocityModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/OrientAlongVelocityModifierParams_0p0.h
new file mode 100644
index 00000000..eee5d40a
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/OrientAlongVelocityModifierParams_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_OrientAlongVelocityModifierParams_0p0_h
+#define HEADER_OrientAlongVelocityModifierParams_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 OrientAlongVelocityModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxVec3 modelForward;
+
+};
+
+static const uint32_t checksum[] = { 0xbec07bae, 0xf99a7cd3, 0xa819cd23, 0xe75ba471, };
+
+} // namespace OrientAlongVelocityModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class OrientAlongVelocityModifierParams_0p0 : public NvParameterized::NvParameters, public OrientAlongVelocityModifierParams_0p0NS::ParametersStruct
+{
+public:
+	OrientAlongVelocityModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~OrientAlongVelocityModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("OrientAlongVelocityModifierParams");
+	}
+
+	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(OrientAlongVelocityModifierParams_0p0NS::checksum);
+		return OrientAlongVelocityModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const OrientAlongVelocityModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		OrientAlongVelocityModifierParams_0p0* tmpThis = const_cast<OrientAlongVelocityModifierParams_0p0*>(this);
+		return *(static_cast<OrientAlongVelocityModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	OrientAlongVelocityModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<OrientAlongVelocityModifierParams_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 OrientAlongVelocityModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		OrientAlongVelocityModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(OrientAlongVelocityModifierParams_0p0), OrientAlongVelocityModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, OrientAlongVelocityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class OrientAlongVelocityModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(OrientAlongVelocityModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, OrientAlongVelocityModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, OrientAlongVelocityModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, OrientAlongVelocityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class OrientAlongVelocityModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of OrientAlongVelocityModifierParams_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 (OrientAlongVelocityModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (OrientAlongVelocityModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (OrientAlongVelocityModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (OrientAlongVelocityModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (OrientAlongVelocityModifierParams_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/iofx_legacy/include/autogen/OrientScaleAlongScreenVelocityModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/OrientScaleAlongScreenVelocityModifierParams_0p0.h
new file mode 100644
index 00000000..523d869f
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/OrientScaleAlongScreenVelocityModifierParams_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_OrientScaleAlongScreenVelocityModifierParams_0p0_h
+#define HEADER_OrientScaleAlongScreenVelocityModifierParams_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 OrientScaleAlongScreenVelocityModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float scalePerVelocity;
+
+};
+
+static const uint32_t checksum[] = { 0xf08408dd, 0x7267c270, 0x443cb618, 0x54d60d9e, };
+
+} // namespace OrientScaleAlongScreenVelocityModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class OrientScaleAlongScreenVelocityModifierParams_0p0 : public NvParameterized::NvParameters, public OrientScaleAlongScreenVelocityModifierParams_0p0NS::ParametersStruct
+{
+public:
+	OrientScaleAlongScreenVelocityModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~OrientScaleAlongScreenVelocityModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("OrientScaleAlongScreenVelocityModifierParams");
+	}
+
+	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(OrientScaleAlongScreenVelocityModifierParams_0p0NS::checksum);
+		return OrientScaleAlongScreenVelocityModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const OrientScaleAlongScreenVelocityModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		OrientScaleAlongScreenVelocityModifierParams_0p0* tmpThis = const_cast<OrientScaleAlongScreenVelocityModifierParams_0p0*>(this);
+		return *(static_cast<OrientScaleAlongScreenVelocityModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	OrientScaleAlongScreenVelocityModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<OrientScaleAlongScreenVelocityModifierParams_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 OrientScaleAlongScreenVelocityModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		OrientScaleAlongScreenVelocityModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(OrientScaleAlongScreenVelocityModifierParams_0p0), OrientScaleAlongScreenVelocityModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, OrientScaleAlongScreenVelocityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class OrientScaleAlongScreenVelocityModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(OrientScaleAlongScreenVelocityModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, OrientScaleAlongScreenVelocityModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, OrientScaleAlongScreenVelocityModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, OrientScaleAlongScreenVelocityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class OrientScaleAlongScreenVelocityModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of OrientScaleAlongScreenVelocityModifierParams_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 (OrientScaleAlongScreenVelocityModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams_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/iofx_legacy/include/autogen/OrientScaleAlongScreenVelocityModifierParams_0p1.h b/APEX_1.4/module/iofx_legacy/include/autogen/OrientScaleAlongScreenVelocityModifierParams_0p1.h
new file mode 100644
index 00000000..77babfbf
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/OrientScaleAlongScreenVelocityModifierParams_0p1.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_OrientScaleAlongScreenVelocityModifierParams_0p1_h
+#define HEADER_OrientScaleAlongScreenVelocityModifierParams_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 OrientScaleAlongScreenVelocityModifierParams_0p1NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float scalePerVelocity;
+	float scaleChangeLimit;
+	float scaleChangeDelay;
+
+};
+
+static const uint32_t checksum[] = { 0x2a151b3c, 0x4a3faff3, 0xb9e6ebc2, 0x6ec77c7c, };
+
+} // namespace OrientScaleAlongScreenVelocityModifierParams_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class OrientScaleAlongScreenVelocityModifierParams_0p1 : public NvParameterized::NvParameters, public OrientScaleAlongScreenVelocityModifierParams_0p1NS::ParametersStruct
+{
+public:
+	OrientScaleAlongScreenVelocityModifierParams_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~OrientScaleAlongScreenVelocityModifierParams_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("OrientScaleAlongScreenVelocityModifierParams");
+	}
+
+	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(OrientScaleAlongScreenVelocityModifierParams_0p1NS::checksum);
+		return OrientScaleAlongScreenVelocityModifierParams_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const OrientScaleAlongScreenVelocityModifierParams_0p1NS::ParametersStruct& parameters(void) const
+	{
+		OrientScaleAlongScreenVelocityModifierParams_0p1* tmpThis = const_cast<OrientScaleAlongScreenVelocityModifierParams_0p1*>(this);
+		return *(static_cast<OrientScaleAlongScreenVelocityModifierParams_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	OrientScaleAlongScreenVelocityModifierParams_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<OrientScaleAlongScreenVelocityModifierParams_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 OrientScaleAlongScreenVelocityModifierParams_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		OrientScaleAlongScreenVelocityModifierParams_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(OrientScaleAlongScreenVelocityModifierParams_0p1), OrientScaleAlongScreenVelocityModifierParams_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, OrientScaleAlongScreenVelocityModifierParams_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class OrientScaleAlongScreenVelocityModifierParams_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(OrientScaleAlongScreenVelocityModifierParams_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, OrientScaleAlongScreenVelocityModifierParams_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, OrientScaleAlongScreenVelocityModifierParams_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, OrientScaleAlongScreenVelocityModifierParams_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class OrientScaleAlongScreenVelocityModifierParams_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of OrientScaleAlongScreenVelocityModifierParams_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 (OrientScaleAlongScreenVelocityModifierParams_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (OrientScaleAlongScreenVelocityModifierParams_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/iofx_legacy/include/autogen/RandomRotationModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/RandomRotationModifierParams_0p0.h
new file mode 100644
index 00000000..7da34e73
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/RandomRotationModifierParams_0p0.h
@@ -0,0 +1,231 @@
+// 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_RandomRotationModifierParams_0p0_h
+#define HEADER_RandomRotationModifierParams_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 RandomRotationModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float minRotation;
+	float maxRotation;
+
+};
+
+static const uint32_t checksum[] = { 0xa4b51fa4, 0x02427ca9, 0xff6c9fc0, 0xe34b89b6, };
+
+} // namespace RandomRotationModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RandomRotationModifierParams_0p0 : public NvParameterized::NvParameters, public RandomRotationModifierParams_0p0NS::ParametersStruct
+{
+public:
+	RandomRotationModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RandomRotationModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RandomRotationModifierParams");
+	}
+
+	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(RandomRotationModifierParams_0p0NS::checksum);
+		return RandomRotationModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RandomRotationModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		RandomRotationModifierParams_0p0* tmpThis = const_cast<RandomRotationModifierParams_0p0*>(this);
+		return *(static_cast<RandomRotationModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	RandomRotationModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RandomRotationModifierParams_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 RandomRotationModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RandomRotationModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RandomRotationModifierParams_0p0), RandomRotationModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RandomRotationModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomRotationModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RandomRotationModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RandomRotationModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RandomRotationModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RandomRotationModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomRotationModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RandomRotationModifierParams_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 (RandomRotationModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RandomRotationModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RandomRotationModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RandomRotationModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RandomRotationModifierParams_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/iofx_legacy/include/autogen/RandomScaleModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/RandomScaleModifierParams_0p0.h
new file mode 100644
index 00000000..e88a18e7
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/RandomScaleModifierParams_0p0.h
@@ -0,0 +1,231 @@
+// 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_RandomScaleModifierParams_0p0_h
+#define HEADER_RandomScaleModifierParams_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 RandomScaleModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float minScaleFactor;
+	float maxScaleFactor;
+
+};
+
+static const uint32_t checksum[] = { 0x393214a5, 0x3920927a, 0x6b466949, 0x38714cd7, };
+
+} // namespace RandomScaleModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RandomScaleModifierParams_0p0 : public NvParameterized::NvParameters, public RandomScaleModifierParams_0p0NS::ParametersStruct
+{
+public:
+	RandomScaleModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RandomScaleModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RandomScaleModifierParams");
+	}
+
+	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(RandomScaleModifierParams_0p0NS::checksum);
+		return RandomScaleModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RandomScaleModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		RandomScaleModifierParams_0p0* tmpThis = const_cast<RandomScaleModifierParams_0p0*>(this);
+		return *(static_cast<RandomScaleModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	RandomScaleModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RandomScaleModifierParams_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 RandomScaleModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RandomScaleModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RandomScaleModifierParams_0p0), RandomScaleModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RandomScaleModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomScaleModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RandomScaleModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RandomScaleModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RandomScaleModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RandomScaleModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomScaleModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RandomScaleModifierParams_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 (RandomScaleModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RandomScaleModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RandomScaleModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RandomScaleModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RandomScaleModifierParams_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/iofx_legacy/include/autogen/RandomSubtextureModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/RandomSubtextureModifierParams_0p0.h
new file mode 100644
index 00000000..03f72c7c
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/RandomSubtextureModifierParams_0p0.h
@@ -0,0 +1,231 @@
+// 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_RandomSubtextureModifierParams_0p0_h
+#define HEADER_RandomSubtextureModifierParams_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 RandomSubtextureModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float minSubtexture;
+	float maxSubtexture;
+
+};
+
+static const uint32_t checksum[] = { 0x08f8796a, 0xa2e2f9c5, 0x8997cd3a, 0xc27f7e3a, };
+
+} // namespace RandomSubtextureModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RandomSubtextureModifierParams_0p0 : public NvParameterized::NvParameters, public RandomSubtextureModifierParams_0p0NS::ParametersStruct
+{
+public:
+	RandomSubtextureModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RandomSubtextureModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RandomSubtextureModifierParams");
+	}
+
+	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(RandomSubtextureModifierParams_0p0NS::checksum);
+		return RandomSubtextureModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RandomSubtextureModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		RandomSubtextureModifierParams_0p0* tmpThis = const_cast<RandomSubtextureModifierParams_0p0*>(this);
+		return *(static_cast<RandomSubtextureModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	RandomSubtextureModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RandomSubtextureModifierParams_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 RandomSubtextureModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RandomSubtextureModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RandomSubtextureModifierParams_0p0), RandomSubtextureModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RandomSubtextureModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomSubtextureModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RandomSubtextureModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RandomSubtextureModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RandomSubtextureModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RandomSubtextureModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RandomSubtextureModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RandomSubtextureModifierParams_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 (RandomSubtextureModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RandomSubtextureModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RandomSubtextureModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RandomSubtextureModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RandomSubtextureModifierParams_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/iofx_legacy/include/autogen/RotationModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/RotationModifierParams_0p0.h
new file mode 100644
index 00000000..36377fd5
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/RotationModifierParams_0p0.h
@@ -0,0 +1,234 @@
+// 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_RotationModifierParams_0p0_h
+#define HEADER_RotationModifierParams_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 RotationModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	const char* rollType;
+	float maxRotationRatePerSec;
+	float maxSettleRatePerSec;
+	float inAirRotationMultiplier;
+	float collisionRotationMultiplier;
+
+};
+
+static const uint32_t checksum[] = { 0x962242b0, 0x08c5a118, 0x531f8120, 0xb59848e7, };
+
+} // namespace RotationModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RotationModifierParams_0p0 : public NvParameterized::NvParameters, public RotationModifierParams_0p0NS::ParametersStruct
+{
+public:
+	RotationModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RotationModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RotationModifierParams");
+	}
+
+	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(RotationModifierParams_0p0NS::checksum);
+		return RotationModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RotationModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		RotationModifierParams_0p0* tmpThis = const_cast<RotationModifierParams_0p0*>(this);
+		return *(static_cast<RotationModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	RotationModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RotationModifierParams_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 RotationModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RotationModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RotationModifierParams_0p0), RotationModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RotationModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RotationModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RotationModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RotationModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RotationModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RotationModifierParams_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 (RotationModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RotationModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RotationModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RotationModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RotationModifierParams_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/iofx_legacy/include/autogen/RotationModifierParams_0p1.h b/APEX_1.4/module/iofx_legacy/include/autogen/RotationModifierParams_0p1.h
new file mode 100644
index 00000000..936446aa
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/RotationModifierParams_0p1.h
@@ -0,0 +1,234 @@
+// 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_RotationModifierParams_0p1_h
+#define HEADER_RotationModifierParams_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 RotationModifierParams_0p1NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	const char* rollType;
+	float maxRotationRatePerSec;
+	float maxSettleRatePerSec;
+	float inAirRotationMultiplier;
+	float collisionRotationMultiplier;
+
+};
+
+static const uint32_t checksum[] = { 0xcf3b33a5, 0x090197ba, 0xe9b4a8b5, 0xc5d33f94, };
+
+} // namespace RotationModifierParams_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RotationModifierParams_0p1 : public NvParameterized::NvParameters, public RotationModifierParams_0p1NS::ParametersStruct
+{
+public:
+	RotationModifierParams_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RotationModifierParams_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RotationModifierParams");
+	}
+
+	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(RotationModifierParams_0p1NS::checksum);
+		return RotationModifierParams_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RotationModifierParams_0p1NS::ParametersStruct& parameters(void) const
+	{
+		RotationModifierParams_0p1* tmpThis = const_cast<RotationModifierParams_0p1*>(this);
+		return *(static_cast<RotationModifierParams_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	RotationModifierParams_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RotationModifierParams_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 RotationModifierParams_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RotationModifierParams_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RotationModifierParams_0p1), RotationModifierParams_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RotationModifierParams_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationModifierParams_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RotationModifierParams_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RotationModifierParams_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RotationModifierParams_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RotationModifierParams_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationModifierParams_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RotationModifierParams_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 (RotationModifierParams_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RotationModifierParams_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RotationModifierParams_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RotationModifierParams_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RotationModifierParams_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/iofx_legacy/include/autogen/RotationModifierParams_0p2.h b/APEX_1.4/module/iofx_legacy/include/autogen/RotationModifierParams_0p2.h
new file mode 100644
index 00000000..87512f87
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/RotationModifierParams_0p2.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_RotationModifierParams_0p2_h
+#define HEADER_RotationModifierParams_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 RotationModifierParams_0p2NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	const char* rollType;
+	float maxRotationRatePerSec;
+	float maxSettleRatePerSec;
+	float inAirRotationMultiplier;
+	float collisionRotationMultiplier;
+	bool includeVerticalDirection;
+
+};
+
+static const uint32_t checksum[] = { 0xd2cf5d27, 0xa1732803, 0xcaa84b84, 0x18ed9e7c, };
+
+} // namespace RotationModifierParams_0p2NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RotationModifierParams_0p2 : public NvParameterized::NvParameters, public RotationModifierParams_0p2NS::ParametersStruct
+{
+public:
+	RotationModifierParams_0p2(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RotationModifierParams_0p2();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RotationModifierParams");
+	}
+
+	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(RotationModifierParams_0p2NS::checksum);
+		return RotationModifierParams_0p2NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RotationModifierParams_0p2NS::ParametersStruct& parameters(void) const
+	{
+		RotationModifierParams_0p2* tmpThis = const_cast<RotationModifierParams_0p2*>(this);
+		return *(static_cast<RotationModifierParams_0p2NS::ParametersStruct*>(tmpThis));
+	}
+
+	RotationModifierParams_0p2NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RotationModifierParams_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 RotationModifierParams_0p2Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RotationModifierParams_0p2::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RotationModifierParams_0p2), RotationModifierParams_0p2::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RotationModifierParams_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationModifierParams_0p2");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RotationModifierParams_0p2)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RotationModifierParams_0p2)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RotationModifierParams_0p2::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RotationModifierParams_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationModifierParams_0p2");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RotationModifierParams_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 (RotationModifierParams_0p2*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RotationModifierParams_0p2::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RotationModifierParams_0p2::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RotationModifierParams_0p2::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RotationModifierParams_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/iofx_legacy/include/autogen/RotationRateModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/RotationRateModifierParams_0p0.h
new file mode 100644
index 00000000..742f374a
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/RotationRateModifierParams_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_RotationRateModifierParams_0p0_h
+#define HEADER_RotationRateModifierParams_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 RotationRateModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float rotationRate;
+
+};
+
+static const uint32_t checksum[] = { 0x250808c0, 0x4e8042ab, 0x9e0339e9, 0x3130e44d, };
+
+} // namespace RotationRateModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RotationRateModifierParams_0p0 : public NvParameterized::NvParameters, public RotationRateModifierParams_0p0NS::ParametersStruct
+{
+public:
+	RotationRateModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RotationRateModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RotationRateModifierParams");
+	}
+
+	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(RotationRateModifierParams_0p0NS::checksum);
+		return RotationRateModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RotationRateModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		RotationRateModifierParams_0p0* tmpThis = const_cast<RotationRateModifierParams_0p0*>(this);
+		return *(static_cast<RotationRateModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	RotationRateModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RotationRateModifierParams_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 RotationRateModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RotationRateModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RotationRateModifierParams_0p0), RotationRateModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RotationRateModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationRateModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RotationRateModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RotationRateModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RotationRateModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RotationRateModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationRateModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RotationRateModifierParams_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 (RotationRateModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RotationRateModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RotationRateModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RotationRateModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RotationRateModifierParams_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/iofx_legacy/include/autogen/RotationRateVsLifeModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/RotationRateVsLifeModifierParams_0p0.h
new file mode 100644
index 00000000..15b0e896
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/RotationRateVsLifeModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_RotationRateVsLifeModifierParams_0p0_h
+#define HEADER_RotationRateVsLifeModifierParams_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 RotationRateVsLifeModifierParams_0p0NS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x704cda91, 0xcc96c538, 0x11f054f6, 0xa3fc1c9e, };
+
+} // namespace RotationRateVsLifeModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RotationRateVsLifeModifierParams_0p0 : public NvParameterized::NvParameters, public RotationRateVsLifeModifierParams_0p0NS::ParametersStruct
+{
+public:
+	RotationRateVsLifeModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RotationRateVsLifeModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RotationRateVsLifeModifierParams");
+	}
+
+	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(RotationRateVsLifeModifierParams_0p0NS::checksum);
+		return RotationRateVsLifeModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RotationRateVsLifeModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		RotationRateVsLifeModifierParams_0p0* tmpThis = const_cast<RotationRateVsLifeModifierParams_0p0*>(this);
+		return *(static_cast<RotationRateVsLifeModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	RotationRateVsLifeModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RotationRateVsLifeModifierParams_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 RotationRateVsLifeModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RotationRateVsLifeModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RotationRateVsLifeModifierParams_0p0), RotationRateVsLifeModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RotationRateVsLifeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationRateVsLifeModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RotationRateVsLifeModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RotationRateVsLifeModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RotationRateVsLifeModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RotationRateVsLifeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RotationRateVsLifeModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RotationRateVsLifeModifierParams_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 (RotationRateVsLifeModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RotationRateVsLifeModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RotationRateVsLifeModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RotationRateVsLifeModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RotationRateVsLifeModifierParams_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/iofx_legacy/include/autogen/ScaleAlongVelocityModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleAlongVelocityModifierParams_0p0.h
new file mode 100644
index 00000000..01cd4432
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleAlongVelocityModifierParams_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_ScaleAlongVelocityModifierParams_0p0_h
+#define HEADER_ScaleAlongVelocityModifierParams_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 ScaleAlongVelocityModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	float scaleFactor;
+
+};
+
+static const uint32_t checksum[] = { 0x3c361211, 0x221d234b, 0x639bf597, 0xcca2608b, };
+
+} // namespace ScaleAlongVelocityModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleAlongVelocityModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleAlongVelocityModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleAlongVelocityModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleAlongVelocityModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleAlongVelocityModifierParams");
+	}
+
+	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(ScaleAlongVelocityModifierParams_0p0NS::checksum);
+		return ScaleAlongVelocityModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleAlongVelocityModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleAlongVelocityModifierParams_0p0* tmpThis = const_cast<ScaleAlongVelocityModifierParams_0p0*>(this);
+		return *(static_cast<ScaleAlongVelocityModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleAlongVelocityModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleAlongVelocityModifierParams_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 ScaleAlongVelocityModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleAlongVelocityModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleAlongVelocityModifierParams_0p0), ScaleAlongVelocityModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleAlongVelocityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleAlongVelocityModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleAlongVelocityModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleAlongVelocityModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleAlongVelocityModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleAlongVelocityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleAlongVelocityModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleAlongVelocityModifierParams_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 (ScaleAlongVelocityModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleAlongVelocityModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleAlongVelocityModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleAlongVelocityModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleAlongVelocityModifierParams_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/iofx_legacy/include/autogen/ScaleByMassModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleByMassModifierParams_0p0.h
new file mode 100644
index 00000000..ef98a5b5
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleByMassModifierParams_0p0.h
@@ -0,0 +1,229 @@
+// 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_ScaleByMassModifierParams_0p0_h
+#define HEADER_ScaleByMassModifierParams_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 ScaleByMassModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+
+};
+
+static const uint32_t checksum[] = { 0x0164ba51, 0x109896dc, 0x1c51ccab, 0xc0cebd7a, };
+
+} // namespace ScaleByMassModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleByMassModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleByMassModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleByMassModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleByMassModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleByMassModifierParams");
+	}
+
+	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(ScaleByMassModifierParams_0p0NS::checksum);
+		return ScaleByMassModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleByMassModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleByMassModifierParams_0p0* tmpThis = const_cast<ScaleByMassModifierParams_0p0*>(this);
+		return *(static_cast<ScaleByMassModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleByMassModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleByMassModifierParams_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 ScaleByMassModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleByMassModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleByMassModifierParams_0p0), ScaleByMassModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleByMassModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleByMassModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleByMassModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleByMassModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleByMassModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleByMassModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleByMassModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleByMassModifierParams_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 (ScaleByMassModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleByMassModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleByMassModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleByMassModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleByMassModifierParams_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/iofx_legacy/include/autogen/ScaleVsCameraDistance2DModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsCameraDistance2DModifierParams_0p0.h
new file mode 100644
index 00000000..cdec49f6
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsCameraDistance2DModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_ScaleVsCameraDistance2DModifierParams_0p0_h
+#define HEADER_ScaleVsCameraDistance2DModifierParams_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 ScaleVsCameraDistance2DModifierParams_0p0NS
+{
+
+struct scaleCameraDistanceStruct_Type;
+
+struct scaleCameraDistanceStruct_DynamicArray1D_Type
+{
+	scaleCameraDistanceStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleCameraDistanceStruct_Type
+{
+	float cameraDistance;
+	physx::PxVec2 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleCameraDistanceStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xa1847ef6, 0x35e96cc6, 0xd3de86e9, 0x977d685a, };
+
+} // namespace ScaleVsCameraDistance2DModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsCameraDistance2DModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsCameraDistance2DModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsCameraDistance2DModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsCameraDistance2DModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsCameraDistance2DModifierParams");
+	}
+
+	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(ScaleVsCameraDistance2DModifierParams_0p0NS::checksum);
+		return ScaleVsCameraDistance2DModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsCameraDistance2DModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsCameraDistance2DModifierParams_0p0* tmpThis = const_cast<ScaleVsCameraDistance2DModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsCameraDistance2DModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsCameraDistance2DModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsCameraDistance2DModifierParams_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 ScaleVsCameraDistance2DModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsCameraDistance2DModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsCameraDistance2DModifierParams_0p0), ScaleVsCameraDistance2DModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsCameraDistance2DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistance2DModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsCameraDistance2DModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsCameraDistance2DModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsCameraDistance2DModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsCameraDistance2DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistance2DModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsCameraDistance2DModifierParams_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 (ScaleVsCameraDistance2DModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsCameraDistance2DModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsCameraDistance2DModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsCameraDistance2DModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsCameraDistance2DModifierParams_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/iofx_legacy/include/autogen/ScaleVsCameraDistance3DModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsCameraDistance3DModifierParams_0p0.h
new file mode 100644
index 00000000..6317bb7c
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsCameraDistance3DModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_ScaleVsCameraDistance3DModifierParams_0p0_h
+#define HEADER_ScaleVsCameraDistance3DModifierParams_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 ScaleVsCameraDistance3DModifierParams_0p0NS
+{
+
+struct scaleCameraDistanceStruct_Type;
+
+struct scaleCameraDistanceStruct_DynamicArray1D_Type
+{
+	scaleCameraDistanceStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleCameraDistanceStruct_Type
+{
+	float cameraDistance;
+	physx::PxVec3 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleCameraDistanceStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x661390b6, 0x5566a427, 0x6507630a, 0x6aff3b6e, };
+
+} // namespace ScaleVsCameraDistance3DModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsCameraDistance3DModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsCameraDistance3DModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsCameraDistance3DModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsCameraDistance3DModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsCameraDistance3DModifierParams");
+	}
+
+	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(ScaleVsCameraDistance3DModifierParams_0p0NS::checksum);
+		return ScaleVsCameraDistance3DModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsCameraDistance3DModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsCameraDistance3DModifierParams_0p0* tmpThis = const_cast<ScaleVsCameraDistance3DModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsCameraDistance3DModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsCameraDistance3DModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsCameraDistance3DModifierParams_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 ScaleVsCameraDistance3DModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsCameraDistance3DModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsCameraDistance3DModifierParams_0p0), ScaleVsCameraDistance3DModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsCameraDistance3DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistance3DModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsCameraDistance3DModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsCameraDistance3DModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsCameraDistance3DModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsCameraDistance3DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistance3DModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsCameraDistance3DModifierParams_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 (ScaleVsCameraDistance3DModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsCameraDistance3DModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsCameraDistance3DModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsCameraDistance3DModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsCameraDistance3DModifierParams_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/iofx_legacy/include/autogen/ScaleVsCameraDistanceModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsCameraDistanceModifierParams_0p0.h
new file mode 100644
index 00000000..3f4a073f
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsCameraDistanceModifierParams_0p0.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_ScaleVsCameraDistanceModifierParams_0p0_h
+#define HEADER_ScaleVsCameraDistanceModifierParams_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 ScaleVsCameraDistanceModifierParams_0p0NS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* scaleAxis;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x2c4aba3d, 0xa1d08f53, 0xfb08d5f3, 0xe12927dd, };
+
+} // namespace ScaleVsCameraDistanceModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsCameraDistanceModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsCameraDistanceModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsCameraDistanceModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsCameraDistanceModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsCameraDistanceModifierParams");
+	}
+
+	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(ScaleVsCameraDistanceModifierParams_0p0NS::checksum);
+		return ScaleVsCameraDistanceModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsCameraDistanceModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsCameraDistanceModifierParams_0p0* tmpThis = const_cast<ScaleVsCameraDistanceModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsCameraDistanceModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsCameraDistanceModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsCameraDistanceModifierParams_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 ScaleVsCameraDistanceModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsCameraDistanceModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsCameraDistanceModifierParams_0p0), ScaleVsCameraDistanceModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsCameraDistanceModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistanceModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsCameraDistanceModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsCameraDistanceModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsCameraDistanceModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsCameraDistanceModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsCameraDistanceModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsCameraDistanceModifierParams_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 (ScaleVsCameraDistanceModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsCameraDistanceModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsCameraDistanceModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsCameraDistanceModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsCameraDistanceModifierParams_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/iofx_legacy/include/autogen/ScaleVsDensity2DModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsDensity2DModifierParams_0p0.h
new file mode 100644
index 00000000..e0749ab2
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsDensity2DModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_ScaleVsDensity2DModifierParams_0p0_h
+#define HEADER_ScaleVsDensity2DModifierParams_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 ScaleVsDensity2DModifierParams_0p0NS
+{
+
+struct scaleDensityStruct_Type;
+
+struct scaleDensityStruct_DynamicArray1D_Type
+{
+	scaleDensityStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleDensityStruct_Type
+{
+	float density;
+	physx::PxVec2 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleDensityStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x67c772d8, 0x2f573535, 0xdd3f3715, 0xea4c896d, };
+
+} // namespace ScaleVsDensity2DModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsDensity2DModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsDensity2DModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsDensity2DModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsDensity2DModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsDensity2DModifierParams");
+	}
+
+	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(ScaleVsDensity2DModifierParams_0p0NS::checksum);
+		return ScaleVsDensity2DModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsDensity2DModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsDensity2DModifierParams_0p0* tmpThis = const_cast<ScaleVsDensity2DModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsDensity2DModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsDensity2DModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsDensity2DModifierParams_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 ScaleVsDensity2DModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsDensity2DModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsDensity2DModifierParams_0p0), ScaleVsDensity2DModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsDensity2DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensity2DModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsDensity2DModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsDensity2DModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsDensity2DModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsDensity2DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensity2DModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsDensity2DModifierParams_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 (ScaleVsDensity2DModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsDensity2DModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsDensity2DModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsDensity2DModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsDensity2DModifierParams_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/iofx_legacy/include/autogen/ScaleVsDensity3DModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsDensity3DModifierParams_0p0.h
new file mode 100644
index 00000000..408036b1
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsDensity3DModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_ScaleVsDensity3DModifierParams_0p0_h
+#define HEADER_ScaleVsDensity3DModifierParams_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 ScaleVsDensity3DModifierParams_0p0NS
+{
+
+struct scaleDensityStruct_Type;
+
+struct scaleDensityStruct_DynamicArray1D_Type
+{
+	scaleDensityStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleDensityStruct_Type
+{
+	float density;
+	physx::PxVec3 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleDensityStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x0dddf0d6, 0x459996e0, 0x32b4d7ce, 0x8e0d1b52, };
+
+} // namespace ScaleVsDensity3DModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsDensity3DModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsDensity3DModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsDensity3DModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsDensity3DModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsDensity3DModifierParams");
+	}
+
+	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(ScaleVsDensity3DModifierParams_0p0NS::checksum);
+		return ScaleVsDensity3DModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsDensity3DModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsDensity3DModifierParams_0p0* tmpThis = const_cast<ScaleVsDensity3DModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsDensity3DModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsDensity3DModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsDensity3DModifierParams_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 ScaleVsDensity3DModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsDensity3DModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsDensity3DModifierParams_0p0), ScaleVsDensity3DModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsDensity3DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensity3DModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsDensity3DModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsDensity3DModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsDensity3DModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsDensity3DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensity3DModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsDensity3DModifierParams_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 (ScaleVsDensity3DModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsDensity3DModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsDensity3DModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsDensity3DModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsDensity3DModifierParams_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/iofx_legacy/include/autogen/ScaleVsDensityModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsDensityModifierParams_0p0.h
new file mode 100644
index 00000000..51793573
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsDensityModifierParams_0p0.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_ScaleVsDensityModifierParams_0p0_h
+#define HEADER_ScaleVsDensityModifierParams_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 ScaleVsDensityModifierParams_0p0NS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* scaleAxis;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x6f22ca8e, 0x609b223e, 0x81d9cacc, 0x9ca002f4, };
+
+} // namespace ScaleVsDensityModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsDensityModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsDensityModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsDensityModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsDensityModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsDensityModifierParams");
+	}
+
+	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(ScaleVsDensityModifierParams_0p0NS::checksum);
+		return ScaleVsDensityModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsDensityModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsDensityModifierParams_0p0* tmpThis = const_cast<ScaleVsDensityModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsDensityModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsDensityModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsDensityModifierParams_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 ScaleVsDensityModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsDensityModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsDensityModifierParams_0p0), ScaleVsDensityModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsDensityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensityModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsDensityModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsDensityModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsDensityModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsDensityModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsDensityModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsDensityModifierParams_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 (ScaleVsDensityModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsDensityModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsDensityModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsDensityModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsDensityModifierParams_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/iofx_legacy/include/autogen/ScaleVsLife2DModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsLife2DModifierParams_0p0.h
new file mode 100644
index 00000000..aa412f04
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsLife2DModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_ScaleVsLife2DModifierParams_0p0_h
+#define HEADER_ScaleVsLife2DModifierParams_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 ScaleVsLife2DModifierParams_0p0NS
+{
+
+struct scaleLifeStruct_Type;
+
+struct scaleLifeStruct_DynamicArray1D_Type
+{
+	scaleLifeStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleLifeStruct_Type
+{
+	float lifeRemaining;
+	physx::PxVec2 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleLifeStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x6db3956a, 0xa58c530d, 0xff315c26, 0xddb49833, };
+
+} // namespace ScaleVsLife2DModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsLife2DModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsLife2DModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsLife2DModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsLife2DModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsLife2DModifierParams");
+	}
+
+	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(ScaleVsLife2DModifierParams_0p0NS::checksum);
+		return ScaleVsLife2DModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsLife2DModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsLife2DModifierParams_0p0* tmpThis = const_cast<ScaleVsLife2DModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsLife2DModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsLife2DModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsLife2DModifierParams_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 ScaleVsLife2DModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsLife2DModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsLife2DModifierParams_0p0), ScaleVsLife2DModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsLife2DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLife2DModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsLife2DModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsLife2DModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsLife2DModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsLife2DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLife2DModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsLife2DModifierParams_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 (ScaleVsLife2DModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsLife2DModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsLife2DModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsLife2DModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsLife2DModifierParams_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/iofx_legacy/include/autogen/ScaleVsLife3DModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsLife3DModifierParams_0p0.h
new file mode 100644
index 00000000..02fc6b6b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsLife3DModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_ScaleVsLife3DModifierParams_0p0_h
+#define HEADER_ScaleVsLife3DModifierParams_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 ScaleVsLife3DModifierParams_0p0NS
+{
+
+struct scaleLifeStruct_Type;
+
+struct scaleLifeStruct_DynamicArray1D_Type
+{
+	scaleLifeStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleLifeStruct_Type
+{
+	float lifeRemaining;
+	physx::PxVec3 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleLifeStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xbaddcfda, 0x2f4deda9, 0x2c23286e, 0xf19659fd, };
+
+} // namespace ScaleVsLife3DModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsLife3DModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsLife3DModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsLife3DModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsLife3DModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsLife3DModifierParams");
+	}
+
+	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(ScaleVsLife3DModifierParams_0p0NS::checksum);
+		return ScaleVsLife3DModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsLife3DModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsLife3DModifierParams_0p0* tmpThis = const_cast<ScaleVsLife3DModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsLife3DModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsLife3DModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsLife3DModifierParams_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 ScaleVsLife3DModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsLife3DModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsLife3DModifierParams_0p0), ScaleVsLife3DModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsLife3DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLife3DModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsLife3DModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsLife3DModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsLife3DModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsLife3DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLife3DModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsLife3DModifierParams_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 (ScaleVsLife3DModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsLife3DModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsLife3DModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsLife3DModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsLife3DModifierParams_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/iofx_legacy/include/autogen/ScaleVsLifeModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsLifeModifierParams_0p0.h
new file mode 100644
index 00000000..f3f93baa
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsLifeModifierParams_0p0.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_ScaleVsLifeModifierParams_0p0_h
+#define HEADER_ScaleVsLifeModifierParams_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 ScaleVsLifeModifierParams_0p0NS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* scaleAxis;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xfed4c822, 0x131f7e2d, 0x1bedc356, 0xcbf77236, };
+
+} // namespace ScaleVsLifeModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsLifeModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsLifeModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsLifeModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsLifeModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsLifeModifierParams");
+	}
+
+	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(ScaleVsLifeModifierParams_0p0NS::checksum);
+		return ScaleVsLifeModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsLifeModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsLifeModifierParams_0p0* tmpThis = const_cast<ScaleVsLifeModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsLifeModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsLifeModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsLifeModifierParams_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 ScaleVsLifeModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsLifeModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsLifeModifierParams_0p0), ScaleVsLifeModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsLifeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLifeModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsLifeModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsLifeModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsLifeModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsLifeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsLifeModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsLifeModifierParams_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 (ScaleVsLifeModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsLifeModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsLifeModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsLifeModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsLifeModifierParams_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/iofx_legacy/include/autogen/ScaleVsTemperature2DModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsTemperature2DModifierParams_0p0.h
new file mode 100644
index 00000000..28b62ce7
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsTemperature2DModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_ScaleVsTemperature2DModifierParams_0p0_h
+#define HEADER_ScaleVsTemperature2DModifierParams_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 ScaleVsTemperature2DModifierParams_0p0NS
+{
+
+struct scaleTemperatureStruct_Type;
+
+struct scaleTemperatureStruct_DynamicArray1D_Type
+{
+	scaleTemperatureStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleTemperatureStruct_Type
+{
+	float temperature;
+	physx::PxVec2 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleTemperatureStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xd5330296, 0xc6fa1947, 0x152d1b30, 0x07453e5c, };
+
+} // namespace ScaleVsTemperature2DModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsTemperature2DModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsTemperature2DModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsTemperature2DModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsTemperature2DModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsTemperature2DModifierParams");
+	}
+
+	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(ScaleVsTemperature2DModifierParams_0p0NS::checksum);
+		return ScaleVsTemperature2DModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsTemperature2DModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsTemperature2DModifierParams_0p0* tmpThis = const_cast<ScaleVsTemperature2DModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsTemperature2DModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsTemperature2DModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsTemperature2DModifierParams_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 ScaleVsTemperature2DModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsTemperature2DModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsTemperature2DModifierParams_0p0), ScaleVsTemperature2DModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsTemperature2DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperature2DModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsTemperature2DModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsTemperature2DModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsTemperature2DModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsTemperature2DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperature2DModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsTemperature2DModifierParams_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 (ScaleVsTemperature2DModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsTemperature2DModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsTemperature2DModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsTemperature2DModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsTemperature2DModifierParams_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/iofx_legacy/include/autogen/ScaleVsTemperature3DModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsTemperature3DModifierParams_0p0.h
new file mode 100644
index 00000000..ff575570
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsTemperature3DModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_ScaleVsTemperature3DModifierParams_0p0_h
+#define HEADER_ScaleVsTemperature3DModifierParams_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 ScaleVsTemperature3DModifierParams_0p0NS
+{
+
+struct scaleTemperatureStruct_Type;
+
+struct scaleTemperatureStruct_DynamicArray1D_Type
+{
+	scaleTemperatureStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct scaleTemperatureStruct_Type
+{
+	float temperature;
+	physx::PxVec3 scale;
+};
+
+struct ParametersStruct
+{
+
+	scaleTemperatureStruct_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x25b25469, 0xa653dacc, 0x1c3167df, 0xd3a6b16f, };
+
+} // namespace ScaleVsTemperature3DModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsTemperature3DModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsTemperature3DModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsTemperature3DModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsTemperature3DModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsTemperature3DModifierParams");
+	}
+
+	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(ScaleVsTemperature3DModifierParams_0p0NS::checksum);
+		return ScaleVsTemperature3DModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsTemperature3DModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsTemperature3DModifierParams_0p0* tmpThis = const_cast<ScaleVsTemperature3DModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsTemperature3DModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsTemperature3DModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsTemperature3DModifierParams_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 ScaleVsTemperature3DModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsTemperature3DModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsTemperature3DModifierParams_0p0), ScaleVsTemperature3DModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsTemperature3DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperature3DModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsTemperature3DModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsTemperature3DModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsTemperature3DModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsTemperature3DModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperature3DModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsTemperature3DModifierParams_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 (ScaleVsTemperature3DModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsTemperature3DModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsTemperature3DModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsTemperature3DModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsTemperature3DModifierParams_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/iofx_legacy/include/autogen/ScaleVsTemperatureModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsTemperatureModifierParams_0p0.h
new file mode 100644
index 00000000..5aee61eb
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ScaleVsTemperatureModifierParams_0p0.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_ScaleVsTemperatureModifierParams_0p0_h
+#define HEADER_ScaleVsTemperatureModifierParams_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 ScaleVsTemperatureModifierParams_0p0NS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	const char* scaleAxis;
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0xd0fc7da0, 0x19500653, 0x8b0cfc22, 0xa80392bd, };
+
+} // namespace ScaleVsTemperatureModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ScaleVsTemperatureModifierParams_0p0 : public NvParameterized::NvParameters, public ScaleVsTemperatureModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ScaleVsTemperatureModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ScaleVsTemperatureModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ScaleVsTemperatureModifierParams");
+	}
+
+	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(ScaleVsTemperatureModifierParams_0p0NS::checksum);
+		return ScaleVsTemperatureModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ScaleVsTemperatureModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ScaleVsTemperatureModifierParams_0p0* tmpThis = const_cast<ScaleVsTemperatureModifierParams_0p0*>(this);
+		return *(static_cast<ScaleVsTemperatureModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ScaleVsTemperatureModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ScaleVsTemperatureModifierParams_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 ScaleVsTemperatureModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ScaleVsTemperatureModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ScaleVsTemperatureModifierParams_0p0), ScaleVsTemperatureModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ScaleVsTemperatureModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperatureModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ScaleVsTemperatureModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ScaleVsTemperatureModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ScaleVsTemperatureModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ScaleVsTemperatureModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ScaleVsTemperatureModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ScaleVsTemperatureModifierParams_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 (ScaleVsTemperatureModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ScaleVsTemperatureModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ScaleVsTemperatureModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ScaleVsTemperatureModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ScaleVsTemperatureModifierParams_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/iofx_legacy/include/autogen/SimpleScaleModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/SimpleScaleModifierParams_0p0.h
new file mode 100644
index 00000000..1ba26cf6
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/SimpleScaleModifierParams_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_SimpleScaleModifierParams_0p0_h
+#define HEADER_SimpleScaleModifierParams_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 SimpleScaleModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxVec3 scaleFactor;
+
+};
+
+static const uint32_t checksum[] = { 0x7a1ac6ca, 0x76ef1cd2, 0x991bfe05, 0x30c11a09, };
+
+} // namespace SimpleScaleModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SimpleScaleModifierParams_0p0 : public NvParameterized::NvParameters, public SimpleScaleModifierParams_0p0NS::ParametersStruct
+{
+public:
+	SimpleScaleModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SimpleScaleModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SimpleScaleModifierParams");
+	}
+
+	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(SimpleScaleModifierParams_0p0NS::checksum);
+		return SimpleScaleModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SimpleScaleModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		SimpleScaleModifierParams_0p0* tmpThis = const_cast<SimpleScaleModifierParams_0p0*>(this);
+		return *(static_cast<SimpleScaleModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	SimpleScaleModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SimpleScaleModifierParams_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 SimpleScaleModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SimpleScaleModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SimpleScaleModifierParams_0p0), SimpleScaleModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SimpleScaleModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SimpleScaleModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SimpleScaleModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SimpleScaleModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SimpleScaleModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SimpleScaleModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SimpleScaleModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SimpleScaleModifierParams_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 (SimpleScaleModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SimpleScaleModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SimpleScaleModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SimpleScaleModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SimpleScaleModifierParams_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/iofx_legacy/include/autogen/SpriteIofxParameters_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/SpriteIofxParameters_0p0.h
new file mode 100644
index 00000000..b065027b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/SpriteIofxParameters_0p0.h
@@ -0,0 +1,240 @@
+// 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_SpriteIofxParameters_0p0_h
+#define HEADER_SpriteIofxParameters_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 SpriteIofxParameters_0p0NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* spriteMaterialName;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0xed7d359d, 0xba5eb1e1, 0x9ac6c5dd, 0xb1f7ef05, };
+
+} // namespace SpriteIofxParameters_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SpriteIofxParameters_0p0 : public NvParameterized::NvParameters, public SpriteIofxParameters_0p0NS::ParametersStruct
+{
+public:
+	SpriteIofxParameters_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SpriteIofxParameters_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SpriteIofxParameters");
+	}
+
+	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(SpriteIofxParameters_0p0NS::checksum);
+		return SpriteIofxParameters_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SpriteIofxParameters_0p0NS::ParametersStruct& parameters(void) const
+	{
+		SpriteIofxParameters_0p0* tmpThis = const_cast<SpriteIofxParameters_0p0*>(this);
+		return *(static_cast<SpriteIofxParameters_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	SpriteIofxParameters_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SpriteIofxParameters_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 SpriteIofxParameters_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SpriteIofxParameters_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SpriteIofxParameters_0p0), SpriteIofxParameters_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SpriteIofxParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SpriteIofxParameters_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SpriteIofxParameters_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SpriteIofxParameters_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SpriteIofxParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SpriteIofxParameters_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 (SpriteIofxParameters_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SpriteIofxParameters_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SpriteIofxParameters_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SpriteIofxParameters_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SpriteIofxParameters_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/iofx_legacy/include/autogen/SpriteIofxParameters_0p1.h b/APEX_1.4/module/iofx_legacy/include/autogen/SpriteIofxParameters_0p1.h
new file mode 100644
index 00000000..315696ff
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/SpriteIofxParameters_0p1.h
@@ -0,0 +1,240 @@
+// 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_SpriteIofxParameters_0p1_h
+#define HEADER_SpriteIofxParameters_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 SpriteIofxParameters_0p1NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* spriteMaterialName;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0xafdd3ba3, 0x21232d96, 0xc0d0f73b, 0x0b558710, };
+
+} // namespace SpriteIofxParameters_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SpriteIofxParameters_0p1 : public NvParameterized::NvParameters, public SpriteIofxParameters_0p1NS::ParametersStruct
+{
+public:
+	SpriteIofxParameters_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SpriteIofxParameters_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SpriteIofxParameters");
+	}
+
+	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(SpriteIofxParameters_0p1NS::checksum);
+		return SpriteIofxParameters_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SpriteIofxParameters_0p1NS::ParametersStruct& parameters(void) const
+	{
+		SpriteIofxParameters_0p1* tmpThis = const_cast<SpriteIofxParameters_0p1*>(this);
+		return *(static_cast<SpriteIofxParameters_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	SpriteIofxParameters_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SpriteIofxParameters_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 SpriteIofxParameters_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SpriteIofxParameters_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SpriteIofxParameters_0p1), SpriteIofxParameters_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SpriteIofxParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SpriteIofxParameters_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SpriteIofxParameters_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SpriteIofxParameters_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SpriteIofxParameters_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SpriteIofxParameters_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 (SpriteIofxParameters_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SpriteIofxParameters_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SpriteIofxParameters_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SpriteIofxParameters_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SpriteIofxParameters_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/iofx_legacy/include/autogen/SpriteIofxParameters_0p2.h b/APEX_1.4/module/iofx_legacy/include/autogen/SpriteIofxParameters_0p2.h
new file mode 100644
index 00000000..e525483e
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/SpriteIofxParameters_0p2.h
@@ -0,0 +1,240 @@
+// 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_SpriteIofxParameters_0p2_h
+#define HEADER_SpriteIofxParameters_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 SpriteIofxParameters_0p2NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* spriteMaterialName;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0xb3736234, 0x649595fb, 0x00c6acc3, 0xd78904f6, };
+
+} // namespace SpriteIofxParameters_0p2NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SpriteIofxParameters_0p2 : public NvParameterized::NvParameters, public SpriteIofxParameters_0p2NS::ParametersStruct
+{
+public:
+	SpriteIofxParameters_0p2(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SpriteIofxParameters_0p2();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SpriteIofxParameters");
+	}
+
+	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(SpriteIofxParameters_0p2NS::checksum);
+		return SpriteIofxParameters_0p2NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SpriteIofxParameters_0p2NS::ParametersStruct& parameters(void) const
+	{
+		SpriteIofxParameters_0p2* tmpThis = const_cast<SpriteIofxParameters_0p2*>(this);
+		return *(static_cast<SpriteIofxParameters_0p2NS::ParametersStruct*>(tmpThis));
+	}
+
+	SpriteIofxParameters_0p2NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SpriteIofxParameters_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 SpriteIofxParameters_0p2Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SpriteIofxParameters_0p2::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SpriteIofxParameters_0p2), SpriteIofxParameters_0p2::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SpriteIofxParameters_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters_0p2");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SpriteIofxParameters_0p2)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SpriteIofxParameters_0p2)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SpriteIofxParameters_0p2::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SpriteIofxParameters_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters_0p2");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SpriteIofxParameters_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 (SpriteIofxParameters_0p2*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SpriteIofxParameters_0p2::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SpriteIofxParameters_0p2::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SpriteIofxParameters_0p2::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SpriteIofxParameters_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/iofx_legacy/include/autogen/SpriteIofxParameters_0p3.h b/APEX_1.4/module/iofx_legacy/include/autogen/SpriteIofxParameters_0p3.h
new file mode 100644
index 00000000..1f90773b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/SpriteIofxParameters_0p3.h
@@ -0,0 +1,240 @@
+// 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_SpriteIofxParameters_0p3_h
+#define HEADER_SpriteIofxParameters_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 SpriteIofxParameters_0p3NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* spriteMaterialName;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0x39c3504e, 0xd2ee01e7, 0xc1ff81b5, 0x6ae67fb8, };
+
+} // namespace SpriteIofxParameters_0p3NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SpriteIofxParameters_0p3 : public NvParameterized::NvParameters, public SpriteIofxParameters_0p3NS::ParametersStruct
+{
+public:
+	SpriteIofxParameters_0p3(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SpriteIofxParameters_0p3();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SpriteIofxParameters");
+	}
+
+	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(SpriteIofxParameters_0p3NS::checksum);
+		return SpriteIofxParameters_0p3NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SpriteIofxParameters_0p3NS::ParametersStruct& parameters(void) const
+	{
+		SpriteIofxParameters_0p3* tmpThis = const_cast<SpriteIofxParameters_0p3*>(this);
+		return *(static_cast<SpriteIofxParameters_0p3NS::ParametersStruct*>(tmpThis));
+	}
+
+	SpriteIofxParameters_0p3NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SpriteIofxParameters_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 SpriteIofxParameters_0p3Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SpriteIofxParameters_0p3::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SpriteIofxParameters_0p3), SpriteIofxParameters_0p3::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SpriteIofxParameters_0p3::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters_0p3");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SpriteIofxParameters_0p3)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SpriteIofxParameters_0p3)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SpriteIofxParameters_0p3::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SpriteIofxParameters_0p3::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters_0p3");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SpriteIofxParameters_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 (SpriteIofxParameters_0p3*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SpriteIofxParameters_0p3::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SpriteIofxParameters_0p3::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SpriteIofxParameters_0p3::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SpriteIofxParameters_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/iofx_legacy/include/autogen/SpriteIofxParameters_0p4.h b/APEX_1.4/module/iofx_legacy/include/autogen/SpriteIofxParameters_0p4.h
new file mode 100644
index 00000000..1d391493
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/SpriteIofxParameters_0p4.h
@@ -0,0 +1,240 @@
+// 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_SpriteIofxParameters_0p4_h
+#define HEADER_SpriteIofxParameters_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 SpriteIofxParameters_0p4NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::Interface* spriteMaterialName;
+	REF_DynamicArray1D_Type spawnModifierList;
+	REF_DynamicArray1D_Type continuousModifierList;
+
+};
+
+static const uint32_t checksum[] = { 0x9763d523, 0x7dae1ae1, 0x3bb7aa9d, 0x67a8d368, };
+
+} // namespace SpriteIofxParameters_0p4NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SpriteIofxParameters_0p4 : public NvParameterized::NvParameters, public SpriteIofxParameters_0p4NS::ParametersStruct
+{
+public:
+	SpriteIofxParameters_0p4(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SpriteIofxParameters_0p4();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SpriteIofxParameters");
+	}
+
+	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(SpriteIofxParameters_0p4NS::checksum);
+		return SpriteIofxParameters_0p4NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SpriteIofxParameters_0p4NS::ParametersStruct& parameters(void) const
+	{
+		SpriteIofxParameters_0p4* tmpThis = const_cast<SpriteIofxParameters_0p4*>(this);
+		return *(static_cast<SpriteIofxParameters_0p4NS::ParametersStruct*>(tmpThis));
+	}
+
+	SpriteIofxParameters_0p4NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SpriteIofxParameters_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 SpriteIofxParameters_0p4Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SpriteIofxParameters_0p4::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SpriteIofxParameters_0p4), SpriteIofxParameters_0p4::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SpriteIofxParameters_0p4::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters_0p4");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SpriteIofxParameters_0p4)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SpriteIofxParameters_0p4)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SpriteIofxParameters_0p4::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SpriteIofxParameters_0p4::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SpriteIofxParameters_0p4");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SpriteIofxParameters_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 (SpriteIofxParameters_0p4*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SpriteIofxParameters_0p4::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SpriteIofxParameters_0p4::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SpriteIofxParameters_0p4::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SpriteIofxParameters_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/iofx_legacy/include/autogen/SubtextureVsLifeModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/SubtextureVsLifeModifierParams_0p0.h
new file mode 100644
index 00000000..d1395b4c
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/SubtextureVsLifeModifierParams_0p0.h
@@ -0,0 +1,244 @@
+// 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_SubtextureVsLifeModifierParams_0p0_h
+#define HEADER_SubtextureVsLifeModifierParams_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 SubtextureVsLifeModifierParams_0p0NS
+{
+
+struct vec2_Type;
+
+struct vec2_DynamicArray1D_Type
+{
+	vec2_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct vec2_Type
+{
+	float x;
+	float y;
+};
+
+struct ParametersStruct
+{
+
+	vec2_DynamicArray1D_Type controlPoints;
+
+};
+
+static const uint32_t checksum[] = { 0x38be217d, 0xe6774f18, 0x591a0a04, 0x64e61b1e, };
+
+} // namespace SubtextureVsLifeModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SubtextureVsLifeModifierParams_0p0 : public NvParameterized::NvParameters, public SubtextureVsLifeModifierParams_0p0NS::ParametersStruct
+{
+public:
+	SubtextureVsLifeModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SubtextureVsLifeModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SubtextureVsLifeModifierParams");
+	}
+
+	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(SubtextureVsLifeModifierParams_0p0NS::checksum);
+		return SubtextureVsLifeModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SubtextureVsLifeModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		SubtextureVsLifeModifierParams_0p0* tmpThis = const_cast<SubtextureVsLifeModifierParams_0p0*>(this);
+		return *(static_cast<SubtextureVsLifeModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	SubtextureVsLifeModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SubtextureVsLifeModifierParams_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 SubtextureVsLifeModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SubtextureVsLifeModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SubtextureVsLifeModifierParams_0p0), SubtextureVsLifeModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SubtextureVsLifeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubtextureVsLifeModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SubtextureVsLifeModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SubtextureVsLifeModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SubtextureVsLifeModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SubtextureVsLifeModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubtextureVsLifeModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SubtextureVsLifeModifierParams_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 (SubtextureVsLifeModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SubtextureVsLifeModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SubtextureVsLifeModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SubtextureVsLifeModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SubtextureVsLifeModifierParams_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/iofx_legacy/include/autogen/ViewDirectionSortingModifierParams_0p0.h b/APEX_1.4/module/iofx_legacy/include/autogen/ViewDirectionSortingModifierParams_0p0.h
new file mode 100644
index 00000000..a35d3ae5
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/include/autogen/ViewDirectionSortingModifierParams_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_ViewDirectionSortingModifierParams_0p0_h
+#define HEADER_ViewDirectionSortingModifierParams_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 ViewDirectionSortingModifierParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	const char* sortType;
+
+};
+
+static const uint32_t checksum[] = { 0x273be54c, 0xc9bfbfeb, 0x0523921d, 0x48c3bc2d, };
+
+} // namespace ViewDirectionSortingModifierParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ViewDirectionSortingModifierParams_0p0 : public NvParameterized::NvParameters, public ViewDirectionSortingModifierParams_0p0NS::ParametersStruct
+{
+public:
+	ViewDirectionSortingModifierParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ViewDirectionSortingModifierParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ViewDirectionSortingModifierParams");
+	}
+
+	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(ViewDirectionSortingModifierParams_0p0NS::checksum);
+		return ViewDirectionSortingModifierParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ViewDirectionSortingModifierParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ViewDirectionSortingModifierParams_0p0* tmpThis = const_cast<ViewDirectionSortingModifierParams_0p0*>(this);
+		return *(static_cast<ViewDirectionSortingModifierParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ViewDirectionSortingModifierParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ViewDirectionSortingModifierParams_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 ViewDirectionSortingModifierParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ViewDirectionSortingModifierParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ViewDirectionSortingModifierParams_0p0), ViewDirectionSortingModifierParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ViewDirectionSortingModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ViewDirectionSortingModifierParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ViewDirectionSortingModifierParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ViewDirectionSortingModifierParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ViewDirectionSortingModifierParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ViewDirectionSortingModifierParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ViewDirectionSortingModifierParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ViewDirectionSortingModifierParams_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 (ViewDirectionSortingModifierParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ViewDirectionSortingModifierParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ViewDirectionSortingModifierParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ViewDirectionSortingModifierParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ViewDirectionSortingModifierParams_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/iofx_legacy/src/IofxLegacyRender.cpp b/APEX_1.4/module/iofx_legacy/src/IofxLegacyRender.cpp
new file mode 100644
index 00000000..d1ab0ab3
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/IofxLegacyRender.cpp
@@ -0,0 +1,693 @@
+/*
+ * 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.
+ */
+
+
+#include "Apex.h"
+#include "IofxLegacyRender.h"
+#include "ApexActor.h"
+#include "PxGpuDispatcher.h"
+
+namespace nvidia
+{
+namespace apex
+{
+namespace legacy
+{
+
+
+class IofxLegacyRenderData : public UserRenderData, public UserAllocated
+{
+public:
+	virtual void release()
+	{
+		if (--mRefCount == 0)
+		{
+			PX_DELETE(this);
+		}
+	}
+	virtual void addRef()
+	{
+		++mRefCount;
+	}
+protected:
+	IofxLegacyRenderData()
+		: mRefCount(0)
+	{
+	}
+	virtual ~IofxLegacyRenderData() {}
+
+	uint32_t mRefCount;
+};
+
+class IofxLegacySpriteRenderData : public IofxLegacyRenderData
+{
+public:
+	IofxLegacySpriteRenderData()
+		: mSpriteBuffer(NULL)
+		, mSurfaceRefCount(0)
+	{
+	}
+	virtual ~IofxLegacySpriteRenderData()
+	{
+		PX_ASSERT(mSurfaceRefCount == 0 && mSpriteBuffer == NULL);
+	}
+
+	uint32_t onAllocSurface()
+	{
+		if (mSpriteBuffer == NULL)
+		{
+			UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+			mSpriteBuffer = rrm->createSpriteBuffer(mSpriteBufferDesc);
+		}
+		return mSurfaceRefCount++;
+	}
+	void onReleaseSurface(uint32_t)
+	{
+		if (--mSurfaceRefCount == 0)
+		{
+			UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+			rrm->releaseSpriteBuffer(*mSpriteBuffer);
+			mSpriteBuffer = NULL;
+		}
+	}
+
+	UserRenderSpriteBufferDesc mSpriteBufferDesc;
+	UserRenderSpriteBuffer* mSpriteBuffer;
+	uint32_t mSurfaceRefCount;
+};
+
+class IofxLegacyInstanceRenderData : public IofxLegacyRenderData
+{
+public:
+	UserRenderInstanceBufferDesc mInstanceBufferDesc;
+};
+
+
+class IofxLegacySpriteRenderSurface : public UserRenderSurface, public UserAllocated
+{
+public:
+	IofxLegacySpriteRenderSurface(const UserRenderSurfaceDesc& desc)
+		: mDesc(desc)
+		, mMapBuffer(NULL)
+	{
+		IofxLegacySpriteRenderData* spriteUserData = static_cast<IofxLegacySpriteRenderData*>(mDesc.getUserData());
+		mIndex = spriteUserData->onAllocSurface();
+	}
+
+	virtual ~IofxLegacySpriteRenderSurface()
+	{
+		if (mMapBuffer)
+		{
+			physx::shdfnd::getAllocator().deallocate(mMapBuffer);
+		}
+
+		IofxLegacySpriteRenderData* spriteUserData = static_cast<IofxLegacySpriteRenderData*>(mDesc.getUserData());
+		spriteUserData->onReleaseSurface(mIndex);
+	}
+
+	virtual void release()
+	{
+		PX_DELETE(this);
+	}
+
+	PX_INLINE UserRenderSpriteBuffer* getSpriteBuffer()
+	{
+		IofxLegacySpriteRenderData* spriteUserData = static_cast<IofxLegacySpriteRenderData*>(mDesc.getUserData());
+		PX_ASSERT(spriteUserData->mSpriteBuffer);
+		return spriteUserData->mSpriteBuffer;
+	}
+
+
+	virtual bool map(RenderMapType::Enum mapType, MappedInfo& info)
+	{
+		PX_UNUSED(mapType);
+		IofxLegacySpriteRenderData* spriteUserData = static_cast<IofxLegacySpriteRenderData*>(mDesc.getUserData());
+		info.rowPitch = spriteUserData->mSpriteBufferDesc.textureDescs[mIndex].pitchBytes;
+		info.depthPitch = 0;
+		if (mMapBuffer == NULL)
+		{
+			size_t size = info.rowPitch * mDesc.height;
+			mMapBuffer = physx::shdfnd::getAllocator().allocate(size, "StagingBuffer", __FILE__, __LINE__);
+		}
+		info.pData = mMapBuffer;
+		return true;
+	}
+	virtual void unmap()
+	{
+		IofxLegacySpriteRenderData* spriteUserData = static_cast<IofxLegacySpriteRenderData*>(mDesc.getUserData());
+		uint32_t rowPitch = spriteUserData->mSpriteBufferDesc.textureDescs[mIndex].pitchBytes;
+		//TODO: copy only needed amount!
+		getSpriteBuffer()->writeTexture(mIndex, uint32_t(mDesc.width * mDesc.height), mMapBuffer, rowPitch * mDesc.height);
+	}
+
+	virtual bool getCUDAgraphicsResource(CUgraphicsResource &ret)
+	{
+		CUgraphicsResource handleList[UserRenderSpriteBufferDesc::MAX_SPRITE_TEXTURES];
+		if (getSpriteBuffer()->getInteropTextureHandleList(handleList))
+		{
+			ret = handleList[mIndex];
+			return true;
+		}
+		return false;
+	}
+
+private:
+	UserRenderSurfaceDesc		mDesc;
+	uint32_t					mIndex;
+	void*						mMapBuffer;
+};
+
+class IofxLegacyRenderBuffer : public UserRenderBuffer, public UserAllocated
+{
+public:
+	enum Flags
+	{
+		NONE = 0,
+		SPRITE_BUFFER,
+		INSTANCE_BUFFER
+	};
+
+	virtual void release()
+	{
+		PX_DELETE(this);
+	}
+
+	virtual ~IofxLegacyRenderBuffer()
+	{
+		if (mStagingBuffer)
+		{
+			physx::shdfnd::getAllocator().deallocate(mStagingBuffer);
+		}
+	}
+
+	virtual void* map(RenderMapType::Enum mapType, size_t offset, size_t size)
+	{
+		PX_UNUSED(mapType);
+		if (mStagingBuffer == NULL)
+		{
+			mStagingBuffer = physx::shdfnd::getAllocator().allocate(mDesc.size, "StagingBuffer", __FILE__, __LINE__);
+		}
+		mMapOffset = PxMin(offset, mDesc.size);
+		mMapSize = PxMin(size, mDesc.size - mMapOffset);
+		return static_cast<uint8_t*>(mStagingBuffer) + offset;
+	}
+
+protected:
+	IofxLegacyRenderBuffer(const UserRenderBufferDesc& desc)
+		: mDesc(desc)
+		, mStagingBuffer(NULL)
+		, mMapOffset(0)
+		, mMapSize(0)
+	{
+	}
+
+	UserRenderBufferDesc	mDesc;
+	void*					mStagingBuffer;
+
+	size_t					mMapOffset;
+	size_t					mMapSize;
+};
+
+class IofxLegacySpriteRenderBuffer : public IofxLegacyRenderBuffer
+{
+public:
+	IofxLegacySpriteRenderBuffer(const UserRenderBufferDesc& desc)
+		: IofxLegacyRenderBuffer(desc)
+	{
+		const UserRenderSpriteBufferDesc& spriteBufferDesc = 
+			static_cast<IofxLegacySpriteRenderData*>(desc.getUserData())->mSpriteBufferDesc;
+
+		UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+		mSpriteBuffer = rrm->createSpriteBuffer(spriteBufferDesc);
+	}
+	virtual ~IofxLegacySpriteRenderBuffer()
+	{
+		if (mSpriteBuffer)
+		{
+			UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+			rrm->releaseSpriteBuffer(*mSpriteBuffer);
+		}
+	}
+	UserRenderSpriteBuffer* getSpriteBuffer()
+	{
+		return mSpriteBuffer;
+	}
+
+	virtual void unmap()
+	{
+		if (mSpriteBuffer && mMapSize > 0)
+		{
+			const UserRenderSpriteBufferDesc& spriteBufferDesc = 
+				static_cast<IofxLegacySpriteRenderData*>(mDesc.getUserData())->mSpriteBufferDesc;
+			PX_ASSERT(spriteBufferDesc.stride > 0);
+			const uint32_t firstSprite = uint32_t(mMapOffset / spriteBufferDesc.stride);
+			const uint32_t numSprites = uint32_t(mMapSize / spriteBufferDesc.stride);
+			PX_ASSERT(firstSprite + numSprites <= spriteBufferDesc.maxSprites);
+			mSpriteBuffer->writeBuffer(static_cast<uint8_t*>(mStagingBuffer) + mMapOffset, firstSprite, numSprites);
+		}
+	}
+
+	//GPU access
+	virtual bool getCUDAgraphicsResource(CUgraphicsResource &ret)
+	{
+		if (mSpriteBuffer)
+		{
+			return mSpriteBuffer->getInteropResourceHandle(ret);
+		}
+		return false;
+	}
+
+private:
+	UserRenderSpriteBuffer* mSpriteBuffer;
+};
+
+class IofxLegacyInstanceRenderBuffer : public IofxLegacyRenderBuffer
+{
+public:
+	IofxLegacyInstanceRenderBuffer(const UserRenderBufferDesc& desc)
+		: IofxLegacyRenderBuffer(desc)
+	{
+		const UserRenderInstanceBufferDesc& instanceBufferDesc = 
+			static_cast<IofxLegacyInstanceRenderData*>(desc.getUserData())->mInstanceBufferDesc;
+
+		UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+		mInstanceBuffer = rrm->createInstanceBuffer(instanceBufferDesc);
+	}
+	virtual ~IofxLegacyInstanceRenderBuffer()
+	{
+		if (mInstanceBuffer)
+		{
+			UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+			rrm->releaseInstanceBuffer(*mInstanceBuffer);
+		}
+	}
+
+	UserRenderInstanceBuffer* getInstanceBuffer()
+	{
+		return mInstanceBuffer;
+	}
+
+	//CPU access
+	virtual void unmap()
+	{
+		if (mInstanceBuffer && mMapSize > 0)
+		{
+			const UserRenderInstanceBufferDesc& instanceBufferDesc = 
+				static_cast<IofxLegacyInstanceRenderData*>(mDesc.getUserData())->mInstanceBufferDesc;
+			PX_ASSERT(instanceBufferDesc.stride > 0);
+			const uint32_t firstInstance = uint32_t(mMapOffset / instanceBufferDesc.stride);
+			const uint32_t numInstances = uint32_t(mMapSize / instanceBufferDesc.stride);
+			PX_ASSERT(firstInstance + numInstances <= instanceBufferDesc.maxInstances);
+			mInstanceBuffer->writeBuffer(static_cast<uint8_t*>(mStagingBuffer) + mMapOffset, firstInstance, numInstances);
+		}
+	}
+
+	//GPU access
+	virtual bool getCUDAgraphicsResource(CUgraphicsResource &ret)
+	{
+		if (mInstanceBuffer)
+		{
+			return mInstanceBuffer->getInteropResourceHandle(ret);
+		}
+		return false;
+	}
+
+private:
+	UserRenderInstanceBuffer* mInstanceBuffer;
+};
+
+
+void IofxLegacySpriteRenderable::updateRenderResources(bool rewriteBuffers, void* userRenderData)
+{
+	URR_SCOPE;
+	PX_UNUSED(rewriteBuffers);
+
+	const IofxSpriteRenderData* spriteRenderData = mRenderable.getSpriteRenderData();
+	if (spriteRenderData == NULL)
+	{
+		PX_ALWAYS_ASSERT();
+		return;
+	}
+	UserRenderSpriteBuffer* spriteBuffer = NULL;
+	if (spriteRenderData->sharedRenderData->spriteRenderBuffer)
+	{
+		IofxLegacyRenderBuffer* legacyRenderBuffer = static_cast<IofxLegacyRenderBuffer*>(spriteRenderData->sharedRenderData->spriteRenderBuffer);
+		spriteBuffer = static_cast<IofxLegacySpriteRenderBuffer*>(legacyRenderBuffer)->getSpriteBuffer();
+	}
+	else if (spriteRenderData->sharedRenderData->spriteRenderSurfaces[0])
+	{
+		IofxLegacySpriteRenderSurface* legacySpriteRenderSurface = static_cast<IofxLegacySpriteRenderSurface*>(spriteRenderData->sharedRenderData->spriteRenderSurfaces[0]);
+		spriteBuffer = legacySpriteRenderSurface->getSpriteBuffer();
+	}
+
+	if (mRenderResource == NULL || mRenderResource->getSpriteBuffer() != spriteBuffer)
+	{
+		UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+
+		if (mRenderResource != NULL)
+		{
+			/* The sprite buffer was re-allocated for more semantics.  We
+			 * must release our old render resource and allocate a new one.
+			 */
+			rrm->releaseResource(*mRenderResource);
+			mRenderResource = NULL;
+		}
+
+		if (spriteBuffer != NULL)
+		{
+			UserRenderResourceDesc rDesc;
+			rDesc.spriteBuffer = spriteBuffer;
+			rDesc.firstSprite = 0;
+			rDesc.numSprites = spriteRenderData->sharedRenderData->maxObjectCount;
+			rDesc.userRenderData = userRenderData;
+			rDesc.primitives = RenderPrimitiveType::POINT_SPRITES;
+			rDesc.material = spriteRenderData->renderResource;
+
+			mRenderResource = rrm->createResource(rDesc);
+		}
+	}
+
+	if (mRenderResource != NULL)
+	{
+		PX_ASSERT( mRenderResource->getSpriteBuffer() == spriteBuffer );
+
+		mRenderResource->setSpriteBufferRange(spriteRenderData->startIndex, spriteRenderData->objectCount);
+		mRenderResource->setSpriteVisibleCount(spriteRenderData->visibleCount);
+	}
+}
+
+void IofxLegacySpriteRenderable::dispatchRenderResources(UserRenderer& renderer)
+{
+	if (mRenderResource != NULL)
+	{
+		RenderContext context;
+		context.world2local = physx::PxMat44(physx::PxIdentity);
+		context.local2world = physx::PxMat44(physx::PxIdentity);
+		context.renderResource = mRenderResource;
+		renderer.renderResource(context);
+	}
+}
+
+
+void IofxLegacyMeshRenderable::updateRenderResources(bool rewriteBuffers, void* userRenderData)
+{
+	URR_SCOPE;
+
+	const IofxMeshRenderData* meshRenderData = mRenderable.getMeshRenderData();
+	if (meshRenderData == NULL)
+	{
+		PX_ALWAYS_ASSERT();
+		return;
+	}
+
+	IofxLegacyRenderBuffer* legacyRenderBuffer = static_cast<IofxLegacyRenderBuffer*>(meshRenderData->sharedRenderData->meshRenderBuffer);
+	UserRenderInstanceBuffer* instanceBuffer = static_cast<IofxLegacyInstanceRenderBuffer*>(legacyRenderBuffer)->getInstanceBuffer();
+
+	if (mRenderMeshActor == NULL)
+	{
+		mRenderMeshActor = loadRenderMeshActor(meshRenderData);
+	}
+	if (mRenderMeshActor != NULL)
+	{
+		if (mRenderMeshActor->getInstanceBuffer() != instanceBuffer)
+		{
+			mRenderMeshActor->setInstanceBuffer(instanceBuffer);
+		}
+
+		PX_ASSERT( mRenderMeshActor->getInstanceBuffer() == instanceBuffer );
+
+		mRenderMeshActor->setInstanceBufferRange(meshRenderData->startIndex, meshRenderData->objectCount);
+		mRenderMeshActor->updateRenderResources(rewriteBuffers, userRenderData);
+	}
+}
+
+void IofxLegacyMeshRenderable::dispatchRenderResources(UserRenderer& renderer)
+{
+	PX_ASSERT(mRenderMeshActor != NULL);
+	if (mRenderMeshActor != NULL)
+	{
+		mRenderMeshActor->dispatchRenderResources(renderer);
+	}
+}
+
+RenderMeshActor* IofxLegacyMeshRenderable::loadRenderMeshActor(const IofxMeshRenderData* meshRenderData)
+{
+	RenderMeshActor* rmactor = NULL;
+	if (meshRenderData)
+	{
+		RenderMeshActorDesc renderableMeshDesc;
+		renderableMeshDesc.maxInstanceCount = meshRenderData->sharedRenderData->maxObjectCount;
+
+		RenderMeshAsset* meshAsset = static_cast<RenderMeshAsset*>(meshRenderData->renderResource);
+		if (meshAsset)
+		{
+			rmactor = meshAsset->createActor(renderableMeshDesc);
+			if (rmactor)
+			{
+				//this call is important to prevent renderResource release in case when there are no instances!
+				rmactor->setReleaseResourcesIfNothingToRender(false);
+			}
+		}
+	}
+	return rmactor;
+}
+
+
+bool IofxLegacyRenderCallback::getIofxSpriteRenderLayout(IofxSpriteRenderLayout& spriteRenderLayout, uint32_t spriteCount, uint32_t spriteSemanticsBitmap, RenderInteropFlags::Enum interopFlags)
+{
+	IofxLegacySpriteRenderData* spriteRenderData = PX_NEW(IofxLegacySpriteRenderData)();
+	UserRenderSpriteBufferDesc& spriteBufferDesc = spriteRenderData->mSpriteBufferDesc;
+
+	uint32_t legacySemanticsBitmap = 0;
+	if (spriteSemanticsBitmap & (1 << IofxRenderSemantic::POSITION))
+	{
+		legacySemanticsBitmap |= (1 << RenderSpriteSemantic::POSITION);
+	}
+	if (spriteSemanticsBitmap & (1 << IofxRenderSemantic::COLOR))
+	{
+		legacySemanticsBitmap |= (1 << RenderSpriteSemantic::COLOR);
+	}
+	if (spriteSemanticsBitmap & (1 << IofxRenderSemantic::VELOCITY))
+	{
+		legacySemanticsBitmap |= (1 << RenderSpriteSemantic::VELOCITY);
+	}
+	if (spriteSemanticsBitmap & (1 << IofxRenderSemantic::SCALE))
+	{
+		legacySemanticsBitmap |= (1 << RenderSpriteSemantic::SCALE);
+	}
+	if (spriteSemanticsBitmap & (1 << IofxRenderSemantic::LIFE_REMAIN))
+	{
+		legacySemanticsBitmap |= (1 << RenderSpriteSemantic::LIFE_REMAIN);
+	}
+	if (spriteSemanticsBitmap & (1 << IofxRenderSemantic::DENSITY))
+	{
+		legacySemanticsBitmap |= (1 << RenderSpriteSemantic::DENSITY);
+	}
+	if (spriteSemanticsBitmap & (1 << IofxRenderSemantic::SUBTEXTURE))
+	{
+		legacySemanticsBitmap |= (1 << RenderSpriteSemantic::SUBTEXTURE);
+	}
+	if (spriteSemanticsBitmap & (1 << IofxRenderSemantic::ORIENTATION))
+	{
+		legacySemanticsBitmap |= (1 << RenderSpriteSemantic::ORIENTATION);
+	}
+	if (spriteSemanticsBitmap & (1 << IofxRenderSemantic::USER_DATA))
+	{
+		legacySemanticsBitmap |= (1 << RenderSpriteSemantic::USER_DATA);
+	}
+
+	UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+	spriteBufferDesc.registerInCUDA = (interopFlags & RenderInteropFlags::CUDA_INTEROP) != 0;
+	if (spriteBufferDesc.registerInCUDA)
+	{
+		spriteBufferDesc.interopContext = mGpuDispatcher->getCudaContextManager();
+	}
+	spriteBufferDesc.hint = RenderBufferHint::DYNAMIC;
+	if (!rrm->getSpriteLayoutData(spriteCount, legacySemanticsBitmap, &spriteBufferDesc))
+	{
+		RenderDataFormat::Enum positionFormat = RenderSpriteLayoutElement::getSemanticFormat(RenderSpriteLayoutElement::POSITION_FLOAT3);
+		RenderDataFormat::Enum colorFormat = RenderSpriteLayoutElement::getSemanticFormat(RenderSpriteLayoutElement::COLOR_BGRA8);
+		const uint32_t positionElementSize = RenderDataFormat::getFormatDataSize(positionFormat);
+		const uint32_t colorElementSize = RenderDataFormat::getFormatDataSize(colorFormat);
+		spriteBufferDesc.semanticOffsets[RenderSpriteLayoutElement::POSITION_FLOAT3] = 0;
+		spriteBufferDesc.semanticOffsets[RenderSpriteLayoutElement::COLOR_BGRA8] = positionElementSize;
+		spriteBufferDesc.stride = positionElementSize + colorElementSize;
+		spriteBufferDesc.maxSprites = spriteCount;
+		spriteBufferDesc.textureCount = 0;
+	}
+
+	if (spriteBufferDesc.textureCount > 0)
+	{
+		static IofxSpriteRenderLayoutSurfaceElement::Enum convertTable[RenderSpriteTextureLayout::NUM_LAYOUTS] = {
+			IofxSpriteRenderLayoutSurfaceElement::MAX_COUNT,
+			IofxSpriteRenderLayoutSurfaceElement::POSITION_FLOAT4,
+			IofxSpriteRenderLayoutSurfaceElement::SCALE_ORIENT_SUBTEX_FLOAT4,
+			IofxSpriteRenderLayoutSurfaceElement::COLOR_RGBA8,
+			IofxSpriteRenderLayoutSurfaceElement::COLOR_BGRA8,
+			IofxSpriteRenderLayoutSurfaceElement::COLOR_FLOAT4
+		};
+
+		spriteRenderLayout.surfaceCount = spriteBufferDesc.textureCount;
+		for (uint32_t i = 0; i < spriteRenderLayout.surfaceCount; ++i)
+		{
+			spriteRenderLayout.surfaceElements[i] = convertTable[ spriteBufferDesc.textureDescs[i].layout ];
+			spriteRenderLayout.surfaceDescs[i].width = spriteBufferDesc.textureDescs[i].width;
+			spriteRenderLayout.surfaceDescs[i].height = spriteBufferDesc.textureDescs[i].height;
+			spriteRenderLayout.surfaceDescs[i].format = IofxSpriteRenderLayoutSurfaceElement::getFormat( spriteRenderLayout.surfaceElements[i] );
+
+			spriteRenderLayout.surfaceDescs[i].interopFlags = spriteBufferDesc.registerInCUDA ? 
+				RenderInteropFlags::CUDA_INTEROP : RenderInteropFlags::NO_INTEROP;
+
+			spriteRenderLayout.surfaceDescs[i].userFlags = 0;
+			spriteRenderLayout.surfaceDescs[i].setUserData(spriteRenderData);
+		}
+	}
+	else
+	{
+		static RenderSpriteLayoutElement::Enum convertTable[IofxSpriteRenderLayoutElement::MAX_COUNT] = {
+			RenderSpriteLayoutElement::POSITION_FLOAT3,
+			RenderSpriteLayoutElement::COLOR_RGBA8,
+			RenderSpriteLayoutElement::COLOR_BGRA8,
+			RenderSpriteLayoutElement::COLOR_FLOAT4,
+			RenderSpriteLayoutElement::VELOCITY_FLOAT3,
+			RenderSpriteLayoutElement::SCALE_FLOAT2,
+			RenderSpriteLayoutElement::LIFE_REMAIN_FLOAT1,
+			RenderSpriteLayoutElement::DENSITY_FLOAT1,
+			RenderSpriteLayoutElement::SUBTEXTURE_FLOAT1,
+			RenderSpriteLayoutElement::ORIENTATION_FLOAT1,
+			RenderSpriteLayoutElement::USER_DATA_UINT1
+		};
+		for (uint32_t dstElem = 0; dstElem < IofxSpriteRenderLayoutElement::MAX_COUNT; ++dstElem)
+		{
+			RenderSpriteLayoutElement::Enum srcElem = convertTable[dstElem];
+			if (srcElem < RenderSpriteLayoutElement::NUM_SEMANTICS)
+			{
+				spriteRenderLayout.offsets[dstElem] = spriteBufferDesc.semanticOffsets[srcElem];
+			}
+		}
+		spriteRenderLayout.stride = spriteBufferDesc.stride;
+		spriteRenderLayout.surfaceCount = 0;
+
+		spriteRenderLayout.bufferDesc.size = spriteRenderLayout.stride * spriteCount;
+		spriteRenderLayout.bufferDesc.interopFlags = spriteBufferDesc.registerInCUDA ? 
+			RenderInteropFlags::CUDA_INTEROP : RenderInteropFlags::NO_INTEROP;
+
+		spriteRenderLayout.bufferDesc.userFlags = IofxLegacyRenderBuffer::SPRITE_BUFFER;
+		spriteRenderLayout.bufferDesc.setUserData(spriteRenderData);
+	}
+	return true;
+}
+
+bool IofxLegacyRenderCallback::getIofxMeshRenderLayout(IofxMeshRenderLayout& meshRenderLayout, uint32_t meshCount, uint32_t meshSemanticsBitmap, RenderInteropFlags::Enum interopFlags)
+{
+	IofxLegacyInstanceRenderData* instanceRenderData = PX_NEW(IofxLegacyInstanceRenderData)();
+	UserRenderInstanceBufferDesc& instanceBufferDesc = instanceRenderData->mInstanceBufferDesc;
+
+	uint32_t legacySemanticsBitmap = 0;
+	if (meshSemanticsBitmap & (1 << IofxRenderSemantic::POSITION))
+	{
+		legacySemanticsBitmap |= (1 << RenderInstanceSemantic::POSITION);
+	}
+	if (meshSemanticsBitmap & ((1 << IofxRenderSemantic::ROTATION) | (1 << IofxRenderSemantic::SCALE)))
+	{
+		legacySemanticsBitmap |= (1 << RenderInstanceSemantic::ROTATION_SCALE);
+	}
+	if (meshSemanticsBitmap & ((1 << IofxRenderSemantic::VELOCITY) | (1 << IofxRenderSemantic::LIFE_REMAIN)))
+	{
+		legacySemanticsBitmap |= (1 << RenderInstanceSemantic::VELOCITY_LIFE);
+	}
+	if (meshSemanticsBitmap & (1 << IofxRenderSemantic::DENSITY))
+	{
+		legacySemanticsBitmap |= (1 << RenderInstanceSemantic::DENSITY);
+	}
+	if (meshSemanticsBitmap & (1 << IofxRenderSemantic::COLOR))
+	{
+		legacySemanticsBitmap |= (1 << RenderInstanceSemantic::COLOR);
+	}
+	if (meshSemanticsBitmap & (1 << IofxRenderSemantic::USER_DATA))
+	{
+		legacySemanticsBitmap |= (1 << RenderInstanceSemantic::USER_DATA);
+	}
+	UserRenderResourceManager* rrm = GetInternalApexSDK()->getUserRenderResourceManager();
+	instanceBufferDesc.registerInCUDA = (interopFlags & RenderInteropFlags::CUDA_INTEROP) != 0;
+	if (instanceBufferDesc.registerInCUDA)
+	{
+		instanceBufferDesc.interopContext = mGpuDispatcher->getCudaContextManager();
+	}
+	instanceBufferDesc.hint = RenderBufferHint::DYNAMIC;
+	if (!rrm->getInstanceLayoutData(meshCount, legacySemanticsBitmap, &instanceBufferDesc))
+	{
+		RenderDataFormat::Enum positionFormat = RenderInstanceLayoutElement::getSemanticFormat(RenderInstanceLayoutElement::POSITION_FLOAT3);
+		RenderDataFormat::Enum rotationFormat = RenderInstanceLayoutElement::getSemanticFormat(RenderInstanceLayoutElement::ROTATION_SCALE_FLOAT3x3);
+		RenderDataFormat::Enum velocityFormat = RenderInstanceLayoutElement::getSemanticFormat(RenderInstanceLayoutElement::VELOCITY_LIFE_FLOAT4);
+		const uint32_t positionElementSize = RenderDataFormat::getFormatDataSize(positionFormat);
+		const uint32_t rotationElementSize = RenderDataFormat::getFormatDataSize(rotationFormat);
+		const uint32_t velocityElementSize = RenderDataFormat::getFormatDataSize(velocityFormat);
+		instanceBufferDesc.semanticOffsets[RenderInstanceLayoutElement::POSITION_FLOAT3]         = 0;
+		instanceBufferDesc.semanticOffsets[RenderInstanceLayoutElement::ROTATION_SCALE_FLOAT3x3] = positionElementSize;
+		instanceBufferDesc.semanticOffsets[RenderInstanceLayoutElement::VELOCITY_LIFE_FLOAT4]    = positionElementSize + rotationElementSize;
+		instanceBufferDesc.stride = positionElementSize + rotationElementSize + velocityElementSize;
+		instanceBufferDesc.maxInstances = meshCount;
+	}
+
+	{
+		static RenderInstanceLayoutElement::Enum convertTable[IofxMeshRenderLayoutElement::MAX_COUNT] = {
+			RenderInstanceLayoutElement::POSITION_FLOAT3,
+			RenderInstanceLayoutElement::ROTATION_SCALE_FLOAT3x3,
+			RenderInstanceLayoutElement::POSE_FLOAT3x4,
+			RenderInstanceLayoutElement::VELOCITY_LIFE_FLOAT4,
+			RenderInstanceLayoutElement::DENSITY_FLOAT1,
+			RenderInstanceLayoutElement::COLOR_RGBA8,
+			RenderInstanceLayoutElement::COLOR_BGRA8,
+			RenderInstanceLayoutElement::COLOR_FLOAT4,
+			RenderInstanceLayoutElement::USER_DATA_UINT1
+		};
+		for (uint32_t dstElem = 0; dstElem < IofxMeshRenderLayoutElement::MAX_COUNT; ++dstElem)
+		{
+			RenderInstanceLayoutElement::Enum srcElem = convertTable[dstElem];
+			if (srcElem < RenderInstanceLayoutElement::NUM_SEMANTICS)
+			{
+				meshRenderLayout.offsets[dstElem] = instanceBufferDesc.semanticOffsets[srcElem];
+			}
+		}
+		meshRenderLayout.stride = instanceBufferDesc.stride;
+
+		meshRenderLayout.bufferDesc.size = meshRenderLayout.stride * meshCount;
+		meshRenderLayout.bufferDesc.interopFlags = instanceBufferDesc.registerInCUDA ? 
+			RenderInteropFlags::CUDA_INTEROP : RenderInteropFlags::NO_INTEROP;
+
+		meshRenderLayout.bufferDesc.userFlags = IofxLegacyRenderBuffer::INSTANCE_BUFFER;
+		meshRenderLayout.bufferDesc.setUserData(instanceRenderData);
+	}
+	return true;
+}
+
+UserRenderBuffer* IofxLegacyRenderCallback::createRenderBuffer(const UserRenderBufferDesc& bufferDesc)
+{
+	switch (bufferDesc.userFlags)
+	{
+	case IofxLegacyRenderBuffer::SPRITE_BUFFER:
+		return PX_NEW(IofxLegacySpriteRenderBuffer)(bufferDesc);
+	case IofxLegacyRenderBuffer::INSTANCE_BUFFER:
+		return PX_NEW(IofxLegacyInstanceRenderBuffer)(bufferDesc);
+	default:
+		return NULL;
+	};
+}
+
+UserRenderSurface* IofxLegacyRenderCallback::createRenderSurface(const UserRenderSurfaceDesc& bufferDesc)
+{
+	return PX_NEW(IofxLegacySpriteRenderSurface)(bufferDesc);
+}
+
+
+}
+}
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsDensityCompositeModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsDensityCompositeModifierParams_0p0.cpp
new file mode 100644
index 00000000..fa530b38
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsDensityCompositeModifierParams_0p0.cpp
@@ -0,0 +1,459 @@
+// 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
+
+
+#include "ColorVsDensityCompositeModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ColorVsDensityCompositeModifierParams_0p0NS;
+
+const char* const ColorVsDensityCompositeModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ColorVsDensityCompositeModifierParams_0p0, ColorVsDensityCompositeModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(colorDensityStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((colorDensityStruct_Type*)0)->density), NULL, 0 }, // controlPoints[].density
+	{ TYPE_VEC4, false, (size_t)(&((colorDensityStruct_Type*)0)->color), NULL, 0 }, // controlPoints[].color
+};
+
+
+bool ColorVsDensityCompositeModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsDensityCompositeModifierParams_0p0::mBuiltFlagMutex;
+
+ColorVsDensityCompositeModifierParams_0p0::ColorVsDensityCompositeModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsDensityCompositeModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsDensityCompositeModifierParams_0p0::~ColorVsDensityCompositeModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsDensityCompositeModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsDensityCompositeModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsDensityCompositeModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsDensityCompositeModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ColorVsDensityCompositeModifierParams_0p0* tmpParam = const_cast<ColorVsDensityCompositeModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsDensityCompositeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsDensityCompositeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsDensityCompositeModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsDensityCompositeModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsDensityCompositeModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsDensityCompositeModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsDensityComposite modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "colorDensityStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].density"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("density", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Density", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("color", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(16), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(16), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Color is formatted x=R, y=G, z=B, w=A", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsDensityCompositeModifierParams_0p0::initStrings(void)
+{
+}
+
+void ColorVsDensityCompositeModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(colorDensityStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsDensityCompositeModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsDensityCompositeModifierParams_0p0::initReferences(void)
+{
+}
+
+void ColorVsDensityCompositeModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsDensityCompositeModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ColorVsDensityCompositeModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsDensityModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsDensityModifierParams_0p0.cpp
new file mode 100644
index 00000000..54999f5c
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsDensityModifierParams_0p0.cpp
@@ -0,0 +1,478 @@
+// 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
+
+
+#include "ColorVsDensityModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ColorVsDensityModifierParams_0p0NS;
+
+const char* const ColorVsDensityModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ColorVsDensityModifierParams_0p0, ColorVsDensityModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->colorChannel), NULL, 0 }, // colorChannel
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ColorVsDensityModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsDensityModifierParams_0p0::mBuiltFlagMutex;
+
+ColorVsDensityModifierParams_0p0::ColorVsDensityModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsDensityModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsDensityModifierParams_0p0::~ColorVsDensityModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsDensityModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsDensityModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsDensityModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsDensityModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ColorVsDensityModifierParams_0p0* tmpParam = const_cast<ColorVsDensityModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsDensityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsDensityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsDensityModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsDensityModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsDensityModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsDensityModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsDensity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="colorChannel"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("colorChannel", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		HintTable[1].init("shortDescription", "Color channel", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "red", "green", "blue", "alpha" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 4);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[5].init("shortDescription", "Control points for a curve", true);
+		HintTable[6].init("xAxisLabel", "Density", true);
+		HintTable[7].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[5].init("shortDescription", "Control points for a curve", true);
+		HintTable[6].init("xAxisLabel", "Density", true);
+		HintTable[7].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Density", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Color", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsDensityModifierParams_0p0::initStrings(void)
+{
+}
+
+void ColorVsDensityModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsDensityModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	colorChannel = (const char*)"alpha";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsDensityModifierParams_0p0::initReferences(void)
+{
+}
+
+void ColorVsDensityModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsDensityModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ColorVsDensityModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsLifeCompositeModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsLifeCompositeModifierParams_0p0.cpp
new file mode 100644
index 00000000..9b4b840c
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsLifeCompositeModifierParams_0p0.cpp
@@ -0,0 +1,471 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#include "ColorVsLifeCompositeModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ColorVsLifeCompositeModifierParams_0p0NS;
+
+const char* const ColorVsLifeCompositeModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ColorVsLifeCompositeModifierParams_0p0, ColorVsLifeCompositeModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(colorLifeStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((colorLifeStruct_Type*)0)->lifeRemaining), NULL, 0 }, // controlPoints[].lifeRemaining
+	{ TYPE_VEC4, false, (size_t)(&((colorLifeStruct_Type*)0)->color), NULL, 0 }, // controlPoints[].color
+};
+
+
+bool ColorVsLifeCompositeModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsLifeCompositeModifierParams_0p0::mBuiltFlagMutex;
+
+ColorVsLifeCompositeModifierParams_0p0::ColorVsLifeCompositeModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsLifeCompositeModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsLifeCompositeModifierParams_0p0::~ColorVsLifeCompositeModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsLifeCompositeModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsLifeCompositeModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsLifeCompositeModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsLifeCompositeModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ColorVsLifeCompositeModifierParams_0p0* tmpParam = const_cast<ColorVsLifeCompositeModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsLifeCompositeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsLifeCompositeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsLifeCompositeModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsLifeCompositeModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsLifeCompositeModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsLifeCompositeModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsLifeComposite modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs life curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "colorLifeStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs life curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].lifeRemaining"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("lifeRemaining", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life remaining", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("color", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max_w", uint64_t(8), true);
+		HintTable[2].init("max_x", uint64_t(8), true);
+		HintTable[3].init("max_y", uint64_t(8), true);
+		HintTable[4].init("min_w", uint64_t(0), true);
+		HintTable[5].init("min_x", uint64_t(0), true);
+		HintTable[6].init("min_y", uint64_t(0), true);
+		HintTable[7].init("min_z", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#else
+
+		static HintImpl HintTable[9];
+		static Hint* HintPtrTable[9] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], &HintTable[8], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max_w", uint64_t(8), true);
+		HintTable[2].init("max_x", uint64_t(8), true);
+		HintTable[3].init("max_y", uint64_t(8), true);
+		HintTable[4].init("min_w", uint64_t(0), true);
+		HintTable[5].init("min_x", uint64_t(0), true);
+		HintTable[6].init("min_y", uint64_t(0), true);
+		HintTable[7].init("min_z", uint64_t(0), true);
+		HintTable[8].init("shortDescription", "Color is formatted x=R, y=G, z=B, w=A", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 9);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsLifeCompositeModifierParams_0p0::initStrings(void)
+{
+}
+
+void ColorVsLifeCompositeModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(colorLifeStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsLifeCompositeModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsLifeCompositeModifierParams_0p0::initReferences(void)
+{
+}
+
+void ColorVsLifeCompositeModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsLifeCompositeModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ColorVsLifeCompositeModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsLifeModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsLifeModifierParams_0p0.cpp
new file mode 100644
index 00000000..dc44d8ab
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsLifeModifierParams_0p0.cpp
@@ -0,0 +1,474 @@
+// 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
+
+
+#include "ColorVsLifeModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ColorVsLifeModifierParams_0p0NS;
+
+const char* const ColorVsLifeModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ColorVsLifeModifierParams_0p0, ColorVsLifeModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->colorChannel), NULL, 0 }, // colorChannel
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ColorVsLifeModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsLifeModifierParams_0p0::mBuiltFlagMutex;
+
+ColorVsLifeModifierParams_0p0::ColorVsLifeModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsLifeModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsLifeModifierParams_0p0::~ColorVsLifeModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsLifeModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsLifeModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsLifeModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsLifeModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ColorVsLifeModifierParams_0p0* tmpParam = const_cast<ColorVsLifeModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsLifeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsLifeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsLifeModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsLifeModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsLifeModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsLifeModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsLife modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="colorChannel"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("colorChannel", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		HintTable[1].init("shortDescription", "Color channel", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "red", "green", "blue", "alpha" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 4);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Life Time", true);
+		HintTable[2].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Life Time", true);
+		HintTable[2].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Color", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsLifeModifierParams_0p0::initStrings(void)
+{
+}
+
+void ColorVsLifeModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsLifeModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	colorChannel = (const char*)"alpha";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsLifeModifierParams_0p0::initReferences(void)
+{
+}
+
+void ColorVsLifeModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsLifeModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ColorVsLifeModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsTemperatureCompositeModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsTemperatureCompositeModifierParams_0p0.cpp
new file mode 100644
index 00000000..c0fe788b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsTemperatureCompositeModifierParams_0p0.cpp
@@ -0,0 +1,455 @@
+// 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
+
+
+#include "ColorVsTemperatureCompositeModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ColorVsTemperatureCompositeModifierParams_0p0NS;
+
+const char* const ColorVsTemperatureCompositeModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ColorVsTemperatureCompositeModifierParams_0p0, ColorVsTemperatureCompositeModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(colorTemperatureStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((colorTemperatureStruct_Type*)0)->temperature), NULL, 0 }, // controlPoints[].temperature
+	{ TYPE_VEC4, false, (size_t)(&((colorTemperatureStruct_Type*)0)->color), NULL, 0 }, // controlPoints[].color
+};
+
+
+bool ColorVsTemperatureCompositeModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsTemperatureCompositeModifierParams_0p0::mBuiltFlagMutex;
+
+ColorVsTemperatureCompositeModifierParams_0p0::ColorVsTemperatureCompositeModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsTemperatureCompositeModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsTemperatureCompositeModifierParams_0p0::~ColorVsTemperatureCompositeModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsTemperatureCompositeModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsTemperatureCompositeModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsTemperatureCompositeModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsTemperatureCompositeModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ColorVsTemperatureCompositeModifierParams_0p0* tmpParam = const_cast<ColorVsTemperatureCompositeModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsTemperatureCompositeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsTemperatureCompositeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsTemperatureCompositeModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsTemperatureCompositeModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsTemperatureCompositeModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsTemperatureCompositeModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsTemperatureComposite modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite color vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "colorTemperatureStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite color vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].temperature"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("temperature", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Temperature", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("color", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(16), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(16), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Color is formatted x=R, y=G, z=B, w=A", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsTemperatureCompositeModifierParams_0p0::initStrings(void)
+{
+}
+
+void ColorVsTemperatureCompositeModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(colorTemperatureStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsTemperatureCompositeModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsTemperatureCompositeModifierParams_0p0::initReferences(void)
+{
+}
+
+void ColorVsTemperatureCompositeModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsTemperatureCompositeModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ColorVsTemperatureCompositeModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsTemperatureModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsTemperatureModifierParams_0p0.cpp
new file mode 100644
index 00000000..e7bd0ac5
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsTemperatureModifierParams_0p0.cpp
@@ -0,0 +1,478 @@
+// 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
+
+
+#include "ColorVsTemperatureModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ColorVsTemperatureModifierParams_0p0NS;
+
+const char* const ColorVsTemperatureModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ColorVsTemperatureModifierParams_0p0, ColorVsTemperatureModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->colorChannel), NULL, 0 }, // colorChannel
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ColorVsTemperatureModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsTemperatureModifierParams_0p0::mBuiltFlagMutex;
+
+ColorVsTemperatureModifierParams_0p0::ColorVsTemperatureModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsTemperatureModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsTemperatureModifierParams_0p0::~ColorVsTemperatureModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsTemperatureModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsTemperatureModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsTemperatureModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsTemperatureModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ColorVsTemperatureModifierParams_0p0* tmpParam = const_cast<ColorVsTemperatureModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsTemperatureModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsTemperatureModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsTemperatureModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsTemperatureModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsTemperatureModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsTemperatureModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsTemperature modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="colorChannel"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("colorChannel", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		HintTable[1].init("shortDescription", "Color channel", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "red", "green", "blue", "alpha" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 4);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[5].init("shortDescription", "Control points for a curve", true);
+		HintTable[6].init("xAxisLabel", "Temperature", true);
+		HintTable[7].init("yAxisLabel", "Color", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[5].init("shortDescription", "Control points for a curve", true);
+		HintTable[6].init("xAxisLabel", "Temperature", true);
+		HintTable[7].init("yAxisLabel", "Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Temperature", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Color", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsTemperatureModifierParams_0p0::initStrings(void)
+{
+}
+
+void ColorVsTemperatureModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsTemperatureModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	colorChannel = (const char*)"alpha";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsTemperatureModifierParams_0p0::initReferences(void)
+{
+}
+
+void ColorVsTemperatureModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsTemperatureModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ColorVsTemperatureModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsVelocityCompositeModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsVelocityCompositeModifierParams_0p0.cpp
new file mode 100644
index 00000000..9722609a
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsVelocityCompositeModifierParams_0p0.cpp
@@ -0,0 +1,533 @@
+// 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
+
+
+#include "ColorVsVelocityCompositeModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ColorVsVelocityCompositeModifierParams_0p0NS;
+
+const char* const ColorVsVelocityCompositeModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ColorVsVelocityCompositeModifierParams_0p0, ColorVsVelocityCompositeModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 7;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->velocity0), NULL, 0 }, // velocity0
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->velocity1), NULL, 0 }, // velocity1
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(3), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(colorVelocityStruct_Type), CHILDREN(4), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((colorVelocityStruct_Type*)0)->velocity), NULL, 0 }, // controlPoints[].velocity
+	{ TYPE_VEC4, false, (size_t)(&((colorVelocityStruct_Type*)0)->color), NULL, 0 }, // controlPoints[].color
+};
+
+
+bool ColorVsVelocityCompositeModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsVelocityCompositeModifierParams_0p0::mBuiltFlagMutex;
+
+ColorVsVelocityCompositeModifierParams_0p0::ColorVsVelocityCompositeModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsVelocityCompositeModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsVelocityCompositeModifierParams_0p0::~ColorVsVelocityCompositeModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsVelocityCompositeModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsVelocityCompositeModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsVelocityCompositeModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsVelocityCompositeModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ColorVsVelocityCompositeModifierParams_0p0* tmpParam = const_cast<ColorVsVelocityCompositeModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsVelocityCompositeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsVelocityCompositeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsVelocityCompositeModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsVelocityCompositeModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsVelocityCompositeModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsVelocityCompositeModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsVelocityComposite modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="velocity0"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("velocity0", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("gameScale", "true", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("gameScale", "true", true);
+		HintTable[1].init("shortDescription", "First velocity point", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="velocity1"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("velocity1", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("gameScale", "true", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("gameScale", "true", true);
+		HintTable[1].init("shortDescription", "Second velocity point", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Velocity", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs velocity curve", true);
+		HintTable[5].init("xAxisLabel", "Velocity", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "colorVelocityStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Velocity", true);
+		HintTable[5].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(2), true);
+		HintTable[2].init("ColorWheel", "true", true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite color vs velocity curve", true);
+		HintTable[5].init("xAxisLabel", "Velocity", true);
+		HintTable[6].init("yAxisLabel", "Alpha + Color", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].velocity"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("velocity", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Velocity", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="controlPoints[].color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("color", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max_w", uint64_t(8), true);
+		HintTable[2].init("max_x", uint64_t(8), true);
+		HintTable[3].init("max_y", uint64_t(8), true);
+		HintTable[4].init("min_w", uint64_t(0), true);
+		HintTable[5].init("min_x", uint64_t(0), true);
+		HintTable[6].init("min_y", uint64_t(0), true);
+		HintTable[7].init("min_z", uint64_t(0), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#else
+
+		static HintImpl HintTable[9];
+		static Hint* HintPtrTable[9] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], &HintTable[8], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max_w", uint64_t(8), true);
+		HintTable[2].init("max_x", uint64_t(8), true);
+		HintTable[3].init("max_y", uint64_t(8), true);
+		HintTable[4].init("min_w", uint64_t(0), true);
+		HintTable[5].init("min_x", uint64_t(0), true);
+		HintTable[6].init("min_y", uint64_t(0), true);
+		HintTable[7].init("min_z", uint64_t(0), true);
+		HintTable[8].init("shortDescription", "Color is formatted x=R, y=G, z=B, w=A", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 9);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(4);
+
+		ParamDefTable[3].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(5);
+		Children[1] = PDEF_PTR(6);
+
+		ParamDefTable[4].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsVelocityCompositeModifierParams_0p0::initStrings(void)
+{
+}
+
+void ColorVsVelocityCompositeModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(colorVelocityStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsVelocityCompositeModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	velocity0 = float(0);
+	velocity1 = float(1);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsVelocityCompositeModifierParams_0p0::initReferences(void)
+{
+}
+
+void ColorVsVelocityCompositeModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsVelocityCompositeModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ColorVsVelocityCompositeModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsVelocityModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsVelocityModifierParams_0p0.cpp
new file mode 100644
index 00000000..488fa6e1
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ColorVsVelocityModifierParams_0p0.cpp
@@ -0,0 +1,524 @@
+// 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
+
+
+#include "ColorVsVelocityModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ColorVsVelocityModifierParams_0p0NS;
+
+const char* const ColorVsVelocityModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ColorVsVelocityModifierParams_0p0, ColorVsVelocityModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 8;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6, 7,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 4 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->colorChannel), NULL, 0 }, // colorChannel
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->velocity0), NULL, 0 }, // velocity0
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->velocity1), NULL, 0 }, // velocity1
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(4), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(5), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ColorVsVelocityModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ColorVsVelocityModifierParams_0p0::mBuiltFlagMutex;
+
+ColorVsVelocityModifierParams_0p0::ColorVsVelocityModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ColorVsVelocityModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ColorVsVelocityModifierParams_0p0::~ColorVsVelocityModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ColorVsVelocityModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ColorVsVelocityModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsVelocityModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ColorVsVelocityModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ColorVsVelocityModifierParams_0p0* tmpParam = const_cast<ColorVsVelocityModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ColorVsVelocityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ColorVsVelocityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ColorVsVelocityModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ColorVsVelocityModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ColorVsVelocityModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ColorVsVelocityModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ColorVsVelocity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="colorChannel"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("colorChannel", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "alpha", true);
+		HintTable[1].init("shortDescription", "Color channel", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "red", "green", "blue", "alpha" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 4);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="velocity0"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("velocity0", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Helpful documentation goes here", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="velocity1"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("velocity1", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Helpful documentation goes here", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Velocity", true);
+		HintTable[2].init("yAxisLabel", "Color", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Velocity", true);
+		HintTable[4].init("yAxisLabel", "Color", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Velocity", true);
+		HintTable[2].init("yAxisLabel", "Color", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Velocity", true);
+		HintTable[4].init("yAxisLabel", "Color", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Velocity", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Color", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 4);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(5);
+
+		ParamDefTable[4].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=5, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(6);
+		Children[1] = PDEF_PTR(7);
+
+		ParamDefTable[5].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ColorVsVelocityModifierParams_0p0::initStrings(void)
+{
+}
+
+void ColorVsVelocityModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ColorVsVelocityModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	colorChannel = (const char*)"alpha";
+	velocity0 = float(0);
+	velocity1 = float(1);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ColorVsVelocityModifierParams_0p0::initReferences(void)
+{
+}
+
+void ColorVsVelocityModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ColorVsVelocityModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ColorVsVelocityModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/InitialColorModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/InitialColorModifierParams_0p0.cpp
new file mode 100644
index 00000000..32cf5a05
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/InitialColorModifierParams_0p0.cpp
@@ -0,0 +1,328 @@
+// 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
+
+
+#include "InitialColorModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace InitialColorModifierParams_0p0NS;
+
+const char* const InitialColorModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<InitialColorModifierParams_0p0, InitialColorModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_VEC4, false, (size_t)(&((ParametersStruct*)0)->color), NULL, 0 }, // color
+};
+
+
+bool InitialColorModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType InitialColorModifierParams_0p0::mBuiltFlagMutex;
+
+InitialColorModifierParams_0p0::InitialColorModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &InitialColorModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+InitialColorModifierParams_0p0::~InitialColorModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void InitialColorModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~InitialColorModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* InitialColorModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* InitialColorModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	InitialColorModifierParams_0p0* tmpParam = const_cast<InitialColorModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType InitialColorModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType InitialColorModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void InitialColorModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<InitialColorModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void InitialColorModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void InitialColorModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "InitialColor modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("color", TYPE_VEC4, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(1), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("COLOR", uint64_t(1), true);
+		HintTable[1].init("max", uint64_t(1), true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Color is formatted x=R, y=G, z=B, w=A", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void InitialColorModifierParams_0p0::initStrings(void)
+{
+}
+
+void InitialColorModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void InitialColorModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	color = physx::PxVec4(initVec4(1, 1, 1, 1));
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void InitialColorModifierParams_0p0::initReferences(void)
+{
+}
+
+void InitialColorModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void InitialColorModifierParams_0p0::freeStrings(void)
+{
+}
+
+void InitialColorModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/IofxAssetParameters_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/IofxAssetParameters_0p0.cpp
new file mode 100644
index 00000000..ef8d1109
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/IofxAssetParameters_0p0.cpp
@@ -0,0 +1,640 @@
+// 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
+
+
+#include "IofxAssetParameters_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace IofxAssetParameters_0p0NS;
+
+const char* const IofxAssetParameters_0p0Factory::vptr =
+    NvParameterized::getVptr<IofxAssetParameters_0p0, IofxAssetParameters_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 10;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 5, 6, 8, 2, 3, 4, 7, 9,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 4 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->renderMeshList), CHILDREN(4), 1 }, // renderMeshList
+	{ TYPE_STRUCT, false, 1 * sizeof(meshProperties_Type), CHILDREN(5), 2 }, // renderMeshList[]
+	{ TYPE_REF, false, (size_t)(&((meshProperties_Type*)0)->meshAssetName), NULL, 0 }, // renderMeshList[].meshAssetName
+	{ TYPE_U32, false, (size_t)(&((meshProperties_Type*)0)->weight), NULL, 0 }, // renderMeshList[].weight
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->spriteMaterialName), NULL, 0 }, // spriteMaterialName
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(7), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(8), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool IofxAssetParameters_0p0::mBuiltFlag = false;
+NvParameterized::MutexType IofxAssetParameters_0p0::mBuiltFlagMutex;
+
+IofxAssetParameters_0p0::IofxAssetParameters_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &IofxAssetParameters_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+IofxAssetParameters_0p0::~IofxAssetParameters_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void IofxAssetParameters_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~IofxAssetParameters_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* IofxAssetParameters_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* IofxAssetParameters_0p0::getParameterDefinitionTree(void) const
+{
+	IofxAssetParameters_0p0* tmpParam = const_cast<IofxAssetParameters_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType IofxAssetParameters_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType IofxAssetParameters_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void IofxAssetParameters_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<IofxAssetParameters_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [1,0] - renderMeshList.meshAssetName */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void IofxAssetParameters_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void IofxAssetParameters_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="renderMeshList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("renderMeshList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[2] = { 1, 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 2);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="renderMeshList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("renderMeshList", TYPE_STRUCT, "meshProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="renderMeshList[].meshAssetName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("meshAssetName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The render mesh asset name or opaque mesh name", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexRenderMesh", "ApexOpaqueMesh" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="renderMeshList[].weight"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("weight", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The weight for this mesh (weighed against other meshes)", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="spriteMaterialName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("spriteMaterialName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The sprite material name (if this is a sprite IOFX)", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexMaterials" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "ColorVsLifeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "ColorVsDensityModifierParams", "SubtextureVsLifeModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams" };
+		ParamDefTable[6].setRefVariantVals((const char**)RefVariantVals, 13);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "ColorVsLifeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "ColorVsDensityModifierParams", "SubtextureVsLifeModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams" };
+		ParamDefTable[7].setRefVariantVals((const char**)RefVariantVals, 13);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[2].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "ColorVsLifeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "ColorVsDensityModifierParams", "SubtextureVsLifeModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ViewDirectionSortingModifierParams" };
+		ParamDefTable[8].setRefVariantVals((const char**)RefVariantVals, 14);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=9, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[9];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[2].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[9].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "ColorVsLifeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "ColorVsDensityModifierParams", "SubtextureVsLifeModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ViewDirectionSortingModifierParams" };
+		ParamDefTable[9].setRefVariantVals((const char**)RefVariantVals, 14);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[4];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(5);
+		Children[2] = PDEF_PTR(6);
+		Children[3] = PDEF_PTR(8);
+
+		ParamDefTable[0].setChildren(Children, 4);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="renderMeshList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="renderMeshList[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=6, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(7);
+
+		ParamDefTable[6].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=8, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(9);
+
+		ParamDefTable[8].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void IofxAssetParameters_0p0::initStrings(void)
+{
+}
+
+void IofxAssetParameters_0p0::initDynamicArrays(void)
+{
+	renderMeshList.buf = NULL;
+	renderMeshList.isAllocated = true;
+	renderMeshList.elementSize = sizeof(meshProperties_Type);
+	renderMeshList.arraySizes[0] = 0;
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void IofxAssetParameters_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void IofxAssetParameters_0p0::initReferences(void)
+{
+	spriteMaterialName = NULL;
+
+}
+
+void IofxAssetParameters_0p0::freeDynamicArrays(void)
+{
+	if (renderMeshList.isAllocated && renderMeshList.buf)
+	{
+		mParameterizedTraits->free(renderMeshList.buf);
+	}
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void IofxAssetParameters_0p0::freeStrings(void)
+{
+}
+
+void IofxAssetParameters_0p0::freeReferences(void)
+{
+
+	for (int i = 0; i < renderMeshList.arraySizes[0]; i++)
+	{
+		if (renderMeshList.buf[i].meshAssetName)
+		{
+			renderMeshList.buf[i].meshAssetName->destroy();
+		}
+	}
+	if (spriteMaterialName)
+	{
+		spriteMaterialName->destroy();
+	}
+
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/IofxAssetParameters_0p1.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/IofxAssetParameters_0p1.cpp
new file mode 100644
index 00000000..ba9fd1b7
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/IofxAssetParameters_0p1.cpp
@@ -0,0 +1,322 @@
+// 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
+
+
+#include "IofxAssetParameters_0p1.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace IofxAssetParameters_0p1NS;
+
+const char* const IofxAssetParameters_0p1Factory::vptr =
+    NvParameterized::getVptr<IofxAssetParameters_0p1, IofxAssetParameters_0p1::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->iofxType), NULL, 0 }, // iofxType
+};
+
+
+bool IofxAssetParameters_0p1::mBuiltFlag = false;
+NvParameterized::MutexType IofxAssetParameters_0p1::mBuiltFlagMutex;
+
+IofxAssetParameters_0p1::IofxAssetParameters_0p1(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &IofxAssetParameters_0p1FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+IofxAssetParameters_0p1::~IofxAssetParameters_0p1()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void IofxAssetParameters_0p1::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~IofxAssetParameters_0p1();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* IofxAssetParameters_0p1::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* IofxAssetParameters_0p1::getParameterDefinitionTree(void) const
+{
+	IofxAssetParameters_0p1* tmpParam = const_cast<IofxAssetParameters_0p1*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType IofxAssetParameters_0p1::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType IofxAssetParameters_0p1::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void IofxAssetParameters_0p1::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<IofxAssetParameters_0p1::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void IofxAssetParameters_0p1::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void IofxAssetParameters_0p1::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="iofxType"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("iofxType", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Contains the mesh or sprite IOFX parameters, only one may be selected", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "MeshIofxParameters", "SpriteIofxParameters" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void IofxAssetParameters_0p1::initStrings(void)
+{
+}
+
+void IofxAssetParameters_0p1::initDynamicArrays(void)
+{
+}
+
+void IofxAssetParameters_0p1::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void IofxAssetParameters_0p1::initReferences(void)
+{
+	iofxType = NULL;
+
+}
+
+void IofxAssetParameters_0p1::freeDynamicArrays(void)
+{
+}
+
+void IofxAssetParameters_0p1::freeStrings(void)
+{
+}
+
+void IofxAssetParameters_0p1::freeReferences(void)
+{
+	if (iofxType)
+	{
+		iofxType->destroy();
+	}
+
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/IofxAssetParameters_0p2.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/IofxAssetParameters_0p2.cpp
new file mode 100644
index 00000000..a673092d
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/IofxAssetParameters_0p2.cpp
@@ -0,0 +1,425 @@
+// 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
+
+
+#include "IofxAssetParameters_0p2.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace IofxAssetParameters_0p2NS;
+
+const char* const IofxAssetParameters_0p2Factory::vptr =
+    NvParameterized::getVptr<IofxAssetParameters_0p2, IofxAssetParameters_0p2::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->iofxType), NULL, 0 }, // iofxType
+	{ TYPE_STRUCT, false, (size_t)(&((ParametersStruct*)0)->renderOutput), CHILDREN(2), 2 }, // renderOutput
+	{ TYPE_BOOL, false, (size_t)(&((outputProperties_Type*)0)->useUserSemantic), NULL, 0 }, // renderOutput.useUserSemantic
+	{ TYPE_BOOL, false, (size_t)(&((outputProperties_Type*)0)->useFloat4Color), NULL, 0 }, // renderOutput.useFloat4Color
+};
+
+
+bool IofxAssetParameters_0p2::mBuiltFlag = false;
+NvParameterized::MutexType IofxAssetParameters_0p2::mBuiltFlagMutex;
+
+IofxAssetParameters_0p2::IofxAssetParameters_0p2(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &IofxAssetParameters_0p2FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+IofxAssetParameters_0p2::~IofxAssetParameters_0p2()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void IofxAssetParameters_0p2::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~IofxAssetParameters_0p2();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* IofxAssetParameters_0p2::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* IofxAssetParameters_0p2::getParameterDefinitionTree(void) const
+{
+	IofxAssetParameters_0p2* tmpParam = const_cast<IofxAssetParameters_0p2*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType IofxAssetParameters_0p2::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType IofxAssetParameters_0p2::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void IofxAssetParameters_0p2::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<IofxAssetParameters_0p2::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void IofxAssetParameters_0p2::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void IofxAssetParameters_0p2::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Contains the asset properties for an IOFX", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="iofxType"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("iofxType", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Contains the mesh or sprite IOFX parameters, only one may be selected", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "MeshIofxParameters", "SpriteIofxParameters" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="renderOutput"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("renderOutput", TYPE_STRUCT, "outputProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "render output properties", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="renderOutput.useUserSemantic"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("useUserSemantic", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "use user semantic in render output", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="renderOutput.useFloat4Color"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("useFloat4Color", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDDEN", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "use float4 color in render output", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="renderOutput"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void IofxAssetParameters_0p2::initStrings(void)
+{
+}
+
+void IofxAssetParameters_0p2::initDynamicArrays(void)
+{
+}
+
+void IofxAssetParameters_0p2::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	renderOutput.useUserSemantic = bool(false);
+	renderOutput.useFloat4Color = bool(false);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void IofxAssetParameters_0p2::initReferences(void)
+{
+	iofxType = NULL;
+
+}
+
+void IofxAssetParameters_0p2::freeDynamicArrays(void)
+{
+}
+
+void IofxAssetParameters_0p2::freeStrings(void)
+{
+}
+
+void IofxAssetParameters_0p2::freeReferences(void)
+{
+	if (iofxType)
+	{
+		iofxType->destroy();
+	}
+
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/IofxDebugRenderParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/IofxDebugRenderParams_0p0.cpp
new file mode 100644
index 00000000..b0493e95
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/IofxDebugRenderParams_0p0.cpp
@@ -0,0 +1,358 @@
+// 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
+
+
+#include "IofxDebugRenderParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace IofxDebugRenderParams_0p0NS;
+
+const char* const IofxDebugRenderParams_0p0Factory::vptr =
+    NvParameterized::getVptr<IofxDebugRenderParams_0p0, IofxDebugRenderParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 4;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_IOFX_ACTOR), NULL, 0 }, // VISUALIZE_IOFX_ACTOR
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_IOFX_BOUNDING_BOX), NULL, 0 }, // VISUALIZE_IOFX_BOUNDING_BOX
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->VISUALIZE_IOFX_ACTOR_NAME), NULL, 0 }, // VISUALIZE_IOFX_ACTOR_NAME
+};
+
+
+bool IofxDebugRenderParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType IofxDebugRenderParams_0p0::mBuiltFlagMutex;
+
+IofxDebugRenderParams_0p0::IofxDebugRenderParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &IofxDebugRenderParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+IofxDebugRenderParams_0p0::~IofxDebugRenderParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void IofxDebugRenderParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~IofxDebugRenderParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* IofxDebugRenderParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* IofxDebugRenderParams_0p0::getParameterDefinitionTree(void) const
+{
+	IofxDebugRenderParams_0p0* tmpParam = const_cast<IofxDebugRenderParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType IofxDebugRenderParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType IofxDebugRenderParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void IofxDebugRenderParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<IofxDebugRenderParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void IofxDebugRenderParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void IofxDebugRenderParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="VISUALIZE_IOFX_ACTOR"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("VISUALIZE_IOFX_ACTOR", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Render IOFX actor in view window", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="VISUALIZE_IOFX_BOUNDING_BOX"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("VISUALIZE_IOFX_BOUNDING_BOX", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Render IOFX bounding box in view window", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="VISUALIZE_IOFX_ACTOR_NAME"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("VISUALIZE_IOFX_ACTOR_NAME", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Render IOFX actor name in view window", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	mBuiltFlag = true;
+
+}
+void IofxDebugRenderParams_0p0::initStrings(void)
+{
+}
+
+void IofxDebugRenderParams_0p0::initDynamicArrays(void)
+{
+}
+
+void IofxDebugRenderParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	VISUALIZE_IOFX_ACTOR = bool(false);
+	VISUALIZE_IOFX_BOUNDING_BOX = bool(true);
+	VISUALIZE_IOFX_ACTOR_NAME = bool(true);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void IofxDebugRenderParams_0p0::initReferences(void)
+{
+}
+
+void IofxDebugRenderParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void IofxDebugRenderParams_0p0::freeStrings(void)
+{
+}
+
+void IofxDebugRenderParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/IofxModuleParameters_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/IofxModuleParameters_0p0.cpp
new file mode 100644
index 00000000..87266fde
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/IofxModuleParameters_0p0.cpp
@@ -0,0 +1,318 @@
+// 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
+
+
+#include "IofxModuleParameters_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace IofxModuleParameters_0p0NS;
+
+const char* const IofxModuleParameters_0p0Factory::vptr =
+    NvParameterized::getVptr<IofxModuleParameters_0p0, IofxModuleParameters_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_U32, false, (size_t)(&((ParametersStruct*)0)->unused), NULL, 0 }, // unused
+};
+
+
+bool IofxModuleParameters_0p0::mBuiltFlag = false;
+NvParameterized::MutexType IofxModuleParameters_0p0::mBuiltFlagMutex;
+
+IofxModuleParameters_0p0::IofxModuleParameters_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &IofxModuleParameters_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+IofxModuleParameters_0p0::~IofxModuleParameters_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void IofxModuleParameters_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~IofxModuleParameters_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* IofxModuleParameters_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* IofxModuleParameters_0p0::getParameterDefinitionTree(void) const
+{
+	IofxModuleParameters_0p0* tmpParam = const_cast<IofxModuleParameters_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType IofxModuleParameters_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType IofxModuleParameters_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void IofxModuleParameters_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<IofxModuleParameters_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void IofxModuleParameters_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void IofxModuleParameters_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "This class is used for initializing the ModuleIofx.", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="unused"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("unused", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "No parameters necessary", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void IofxModuleParameters_0p0::initStrings(void)
+{
+}
+
+void IofxModuleParameters_0p0::initDynamicArrays(void)
+{
+}
+
+void IofxModuleParameters_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	unused = uint32_t(0);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void IofxModuleParameters_0p0::initReferences(void)
+{
+}
+
+void IofxModuleParameters_0p0::freeDynamicArrays(void)
+{
+}
+
+void IofxModuleParameters_0p0::freeStrings(void)
+{
+}
+
+void IofxModuleParameters_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p0.cpp
new file mode 100644
index 00000000..98180b36
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p0.cpp
@@ -0,0 +1,623 @@
+// 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
+
+
+#include "MeshIofxParameters_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace MeshIofxParameters_0p0NS;
+
+const char* const MeshIofxParameters_0p0Factory::vptr =
+    NvParameterized::getVptr<MeshIofxParameters_0p0, MeshIofxParameters_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 9;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 5, 7, 2, 3, 4, 6, 8,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->renderMeshList), CHILDREN(3), 1 }, // renderMeshList
+	{ TYPE_STRUCT, false, 1 * sizeof(meshProperties_Type), CHILDREN(4), 2 }, // renderMeshList[]
+	{ TYPE_REF, false, (size_t)(&((meshProperties_Type*)0)->meshAssetName), NULL, 0 }, // renderMeshList[].meshAssetName
+	{ TYPE_U32, false, (size_t)(&((meshProperties_Type*)0)->weight), NULL, 0 }, // renderMeshList[].weight
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(6), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(7), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool MeshIofxParameters_0p0::mBuiltFlag = false;
+NvParameterized::MutexType MeshIofxParameters_0p0::mBuiltFlagMutex;
+
+MeshIofxParameters_0p0::MeshIofxParameters_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &MeshIofxParameters_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+MeshIofxParameters_0p0::~MeshIofxParameters_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void MeshIofxParameters_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~MeshIofxParameters_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters_0p0::getParameterDefinitionTree(void) const
+{
+	MeshIofxParameters_0p0* tmpParam = const_cast<MeshIofxParameters_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType MeshIofxParameters_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType MeshIofxParameters_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void MeshIofxParameters_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<MeshIofxParameters_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [1,0] - renderMeshList.meshAssetName */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void MeshIofxParameters_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void MeshIofxParameters_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="renderMeshList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("renderMeshList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[2] = { 1, 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 2);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="renderMeshList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("renderMeshList", TYPE_STRUCT, "meshProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="renderMeshList[].meshAssetName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("meshAssetName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The render mesh asset name or opaque mesh name", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexRenderMesh", "ApexOpaqueMesh" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="renderMeshList[].weight"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("weight", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The weight for this mesh (weighed against other meshes)", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 3);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams" };
+		ParamDefTable[6].setRefVariantVals((const char**)RefVariantVals, 3);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		HintTable[5].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[6].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams" };
+		ParamDefTable[7].setRefVariantVals((const char**)RefVariantVals, 9);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		HintTable[5].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[6].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams" };
+		ParamDefTable[8].setRefVariantVals((const char**)RefVariantVals, 9);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(5);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="renderMeshList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="renderMeshList[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=5, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(6);
+
+		ParamDefTable[5].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=7, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(8);
+
+		ParamDefTable[7].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void MeshIofxParameters_0p0::initStrings(void)
+{
+}
+
+void MeshIofxParameters_0p0::initDynamicArrays(void)
+{
+	renderMeshList.buf = NULL;
+	renderMeshList.isAllocated = true;
+	renderMeshList.elementSize = sizeof(meshProperties_Type);
+	renderMeshList.arraySizes[0] = 0;
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void MeshIofxParameters_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void MeshIofxParameters_0p0::initReferences(void)
+{
+}
+
+void MeshIofxParameters_0p0::freeDynamicArrays(void)
+{
+	if (renderMeshList.isAllocated && renderMeshList.buf)
+	{
+		mParameterizedTraits->free(renderMeshList.buf);
+	}
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void MeshIofxParameters_0p0::freeStrings(void)
+{
+}
+
+void MeshIofxParameters_0p0::freeReferences(void)
+{
+
+	for (int i = 0; i < renderMeshList.arraySizes[0]; i++)
+	{
+		if (renderMeshList.buf[i].meshAssetName)
+		{
+			renderMeshList.buf[i].meshAssetName->destroy();
+		}
+	}
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p1.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p1.cpp
new file mode 100644
index 00000000..dd210742
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p1.cpp
@@ -0,0 +1,623 @@
+// 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
+
+
+#include "MeshIofxParameters_0p1.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace MeshIofxParameters_0p1NS;
+
+const char* const MeshIofxParameters_0p1Factory::vptr =
+    NvParameterized::getVptr<MeshIofxParameters_0p1, MeshIofxParameters_0p1::ClassAlignment>();
+
+const uint32_t NumParamDefs = 9;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 5, 7, 2, 3, 4, 6, 8,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->renderMeshList), CHILDREN(3), 1 }, // renderMeshList
+	{ TYPE_STRUCT, false, 1 * sizeof(meshProperties_Type), CHILDREN(4), 2 }, // renderMeshList[]
+	{ TYPE_REF, false, (size_t)(&((meshProperties_Type*)0)->meshAssetName), NULL, 0 }, // renderMeshList[].meshAssetName
+	{ TYPE_U32, false, (size_t)(&((meshProperties_Type*)0)->weight), NULL, 0 }, // renderMeshList[].weight
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(6), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(7), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool MeshIofxParameters_0p1::mBuiltFlag = false;
+NvParameterized::MutexType MeshIofxParameters_0p1::mBuiltFlagMutex;
+
+MeshIofxParameters_0p1::MeshIofxParameters_0p1(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &MeshIofxParameters_0p1FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+MeshIofxParameters_0p1::~MeshIofxParameters_0p1()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void MeshIofxParameters_0p1::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~MeshIofxParameters_0p1();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters_0p1::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters_0p1::getParameterDefinitionTree(void) const
+{
+	MeshIofxParameters_0p1* tmpParam = const_cast<MeshIofxParameters_0p1*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType MeshIofxParameters_0p1::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType MeshIofxParameters_0p1::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void MeshIofxParameters_0p1::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<MeshIofxParameters_0p1::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [1,0] - renderMeshList.meshAssetName */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void MeshIofxParameters_0p1::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void MeshIofxParameters_0p1::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="renderMeshList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("renderMeshList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[2] = { 1, 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 2);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="renderMeshList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("renderMeshList", TYPE_STRUCT, "meshProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="renderMeshList[].meshAssetName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("meshAssetName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The render mesh asset name or opaque mesh name", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexRenderMesh", "ApexOpaqueMesh" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="renderMeshList[].weight"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("weight", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The weight for this mesh (weighed against other meshes)", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 4);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams" };
+		ParamDefTable[6].setRefVariantVals((const char**)RefVariantVals, 4);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		HintTable[5].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[6].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams" };
+		ParamDefTable[7].setRefVariantVals((const char**)RefVariantVals, 11);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		HintTable[5].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[6].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams" };
+		ParamDefTable[8].setRefVariantVals((const char**)RefVariantVals, 11);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(5);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="renderMeshList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="renderMeshList[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=5, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(6);
+
+		ParamDefTable[5].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=7, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(8);
+
+		ParamDefTable[7].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void MeshIofxParameters_0p1::initStrings(void)
+{
+}
+
+void MeshIofxParameters_0p1::initDynamicArrays(void)
+{
+	renderMeshList.buf = NULL;
+	renderMeshList.isAllocated = true;
+	renderMeshList.elementSize = sizeof(meshProperties_Type);
+	renderMeshList.arraySizes[0] = 0;
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void MeshIofxParameters_0p1::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void MeshIofxParameters_0p1::initReferences(void)
+{
+}
+
+void MeshIofxParameters_0p1::freeDynamicArrays(void)
+{
+	if (renderMeshList.isAllocated && renderMeshList.buf)
+	{
+		mParameterizedTraits->free(renderMeshList.buf);
+	}
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void MeshIofxParameters_0p1::freeStrings(void)
+{
+}
+
+void MeshIofxParameters_0p1::freeReferences(void)
+{
+
+	for (int i = 0; i < renderMeshList.arraySizes[0]; i++)
+	{
+		if (renderMeshList.buf[i].meshAssetName)
+		{
+			renderMeshList.buf[i].meshAssetName->destroy();
+		}
+	}
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p2.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p2.cpp
new file mode 100644
index 00000000..3d164a69
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p2.cpp
@@ -0,0 +1,623 @@
+// 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
+
+
+#include "MeshIofxParameters_0p2.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace MeshIofxParameters_0p2NS;
+
+const char* const MeshIofxParameters_0p2Factory::vptr =
+    NvParameterized::getVptr<MeshIofxParameters_0p2, MeshIofxParameters_0p2::ClassAlignment>();
+
+const uint32_t NumParamDefs = 9;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 5, 7, 2, 3, 4, 6, 8,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->renderMeshList), CHILDREN(3), 1 }, // renderMeshList
+	{ TYPE_STRUCT, false, 1 * sizeof(meshProperties_Type), CHILDREN(4), 2 }, // renderMeshList[]
+	{ TYPE_REF, false, (size_t)(&((meshProperties_Type*)0)->meshAssetName), NULL, 0 }, // renderMeshList[].meshAssetName
+	{ TYPE_U32, false, (size_t)(&((meshProperties_Type*)0)->weight), NULL, 0 }, // renderMeshList[].weight
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(6), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(7), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool MeshIofxParameters_0p2::mBuiltFlag = false;
+NvParameterized::MutexType MeshIofxParameters_0p2::mBuiltFlagMutex;
+
+MeshIofxParameters_0p2::MeshIofxParameters_0p2(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &MeshIofxParameters_0p2FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+MeshIofxParameters_0p2::~MeshIofxParameters_0p2()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void MeshIofxParameters_0p2::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~MeshIofxParameters_0p2();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters_0p2::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters_0p2::getParameterDefinitionTree(void) const
+{
+	MeshIofxParameters_0p2* tmpParam = const_cast<MeshIofxParameters_0p2*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType MeshIofxParameters_0p2::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType MeshIofxParameters_0p2::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void MeshIofxParameters_0p2::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<MeshIofxParameters_0p2::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [1,0] - renderMeshList.meshAssetName */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void MeshIofxParameters_0p2::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void MeshIofxParameters_0p2::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="renderMeshList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("renderMeshList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[2] = { 1, 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 2);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="renderMeshList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("renderMeshList", TYPE_STRUCT, "meshProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="renderMeshList[].meshAssetName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("meshAssetName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The render mesh asset name or opaque mesh name", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexRenderMesh", "ApexOpaqueMesh" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="renderMeshList[].weight"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("weight", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The weight for this mesh (weighed against other meshes)", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 5);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[6].setRefVariantVals((const char**)RefVariantVals, 5);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		HintTable[5].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[6].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams" };
+		ParamDefTable[7].setRefVariantVals((const char**)RefVariantVals, 11);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "RotationModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		HintTable[5].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[6].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams" };
+		ParamDefTable[8].setRefVariantVals((const char**)RefVariantVals, 11);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(5);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="renderMeshList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="renderMeshList[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=5, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(6);
+
+		ParamDefTable[5].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=7, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(8);
+
+		ParamDefTable[7].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void MeshIofxParameters_0p2::initStrings(void)
+{
+}
+
+void MeshIofxParameters_0p2::initDynamicArrays(void)
+{
+	renderMeshList.buf = NULL;
+	renderMeshList.isAllocated = true;
+	renderMeshList.elementSize = sizeof(meshProperties_Type);
+	renderMeshList.arraySizes[0] = 0;
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void MeshIofxParameters_0p2::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void MeshIofxParameters_0p2::initReferences(void)
+{
+}
+
+void MeshIofxParameters_0p2::freeDynamicArrays(void)
+{
+	if (renderMeshList.isAllocated && renderMeshList.buf)
+	{
+		mParameterizedTraits->free(renderMeshList.buf);
+	}
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void MeshIofxParameters_0p2::freeStrings(void)
+{
+}
+
+void MeshIofxParameters_0p2::freeReferences(void)
+{
+
+	for (int i = 0; i < renderMeshList.arraySizes[0]; i++)
+	{
+		if (renderMeshList.buf[i].meshAssetName)
+		{
+			renderMeshList.buf[i].meshAssetName->destroy();
+		}
+	}
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p3.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p3.cpp
new file mode 100644
index 00000000..13fa484a
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p3.cpp
@@ -0,0 +1,619 @@
+// 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
+
+
+#include "MeshIofxParameters_0p3.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace MeshIofxParameters_0p3NS;
+
+const char* const MeshIofxParameters_0p3Factory::vptr =
+    NvParameterized::getVptr<MeshIofxParameters_0p3, MeshIofxParameters_0p3::ClassAlignment>();
+
+const uint32_t NumParamDefs = 9;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 5, 7, 2, 3, 4, 6, 8,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->renderMeshList), CHILDREN(3), 1 }, // renderMeshList
+	{ TYPE_STRUCT, false, 1 * sizeof(meshProperties_Type), CHILDREN(4), 2 }, // renderMeshList[]
+	{ TYPE_REF, false, (size_t)(&((meshProperties_Type*)0)->meshAssetName), NULL, 0 }, // renderMeshList[].meshAssetName
+	{ TYPE_U32, false, (size_t)(&((meshProperties_Type*)0)->weight), NULL, 0 }, // renderMeshList[].weight
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(6), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(7), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool MeshIofxParameters_0p3::mBuiltFlag = false;
+NvParameterized::MutexType MeshIofxParameters_0p3::mBuiltFlagMutex;
+
+MeshIofxParameters_0p3::MeshIofxParameters_0p3(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &MeshIofxParameters_0p3FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+MeshIofxParameters_0p3::~MeshIofxParameters_0p3()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void MeshIofxParameters_0p3::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~MeshIofxParameters_0p3();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters_0p3::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters_0p3::getParameterDefinitionTree(void) const
+{
+	MeshIofxParameters_0p3* tmpParam = const_cast<MeshIofxParameters_0p3*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType MeshIofxParameters_0p3::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType MeshIofxParameters_0p3::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void MeshIofxParameters_0p3::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<MeshIofxParameters_0p3::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [1,0] - renderMeshList.meshAssetName */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void MeshIofxParameters_0p3::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void MeshIofxParameters_0p3::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="renderMeshList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("renderMeshList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[2] = { 1, 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 2);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="renderMeshList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("renderMeshList", TYPE_STRUCT, "meshProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="renderMeshList[].meshAssetName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("meshAssetName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The render mesh asset name or opaque mesh name", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexRenderMesh", "ApexOpaqueMesh" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="renderMeshList[].weight"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("weight", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The weight for this mesh (weighed against other meshes)", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 5);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[6].setRefVariantVals((const char**)RefVariantVals, 5);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("INCLUDED", uint64_t(1), true);
+		HintTable[4].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[5].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[7].setRefVariantVals((const char**)RefVariantVals, 12);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("INCLUDED", uint64_t(1), true);
+		HintTable[4].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[5].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[8].setRefVariantVals((const char**)RefVariantVals, 12);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(5);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="renderMeshList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="renderMeshList[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=5, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(6);
+
+		ParamDefTable[5].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=7, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(8);
+
+		ParamDefTable[7].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void MeshIofxParameters_0p3::initStrings(void)
+{
+}
+
+void MeshIofxParameters_0p3::initDynamicArrays(void)
+{
+	renderMeshList.buf = NULL;
+	renderMeshList.isAllocated = true;
+	renderMeshList.elementSize = sizeof(meshProperties_Type);
+	renderMeshList.arraySizes[0] = 0;
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void MeshIofxParameters_0p3::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void MeshIofxParameters_0p3::initReferences(void)
+{
+}
+
+void MeshIofxParameters_0p3::freeDynamicArrays(void)
+{
+	if (renderMeshList.isAllocated && renderMeshList.buf)
+	{
+		mParameterizedTraits->free(renderMeshList.buf);
+	}
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void MeshIofxParameters_0p3::freeStrings(void)
+{
+}
+
+void MeshIofxParameters_0p3::freeReferences(void)
+{
+
+	for (int i = 0; i < renderMeshList.arraySizes[0]; i++)
+	{
+		if (renderMeshList.buf[i].meshAssetName)
+		{
+			renderMeshList.buf[i].meshAssetName->destroy();
+		}
+	}
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p4.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p4.cpp
new file mode 100644
index 00000000..1d19c4ce
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/MeshIofxParameters_0p4.cpp
@@ -0,0 +1,623 @@
+// 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
+
+
+#include "MeshIofxParameters_0p4.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace MeshIofxParameters_0p4NS;
+
+const char* const MeshIofxParameters_0p4Factory::vptr =
+    NvParameterized::getVptr<MeshIofxParameters_0p4, MeshIofxParameters_0p4::ClassAlignment>();
+
+const uint32_t NumParamDefs = 9;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 5, 7, 2, 3, 4, 6, 8,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->renderMeshList), CHILDREN(3), 1 }, // renderMeshList
+	{ TYPE_STRUCT, false, 1 * sizeof(meshProperties_Type), CHILDREN(4), 2 }, // renderMeshList[]
+	{ TYPE_REF, false, (size_t)(&((meshProperties_Type*)0)->meshAssetName), NULL, 0 }, // renderMeshList[].meshAssetName
+	{ TYPE_U32, false, (size_t)(&((meshProperties_Type*)0)->weight), NULL, 0 }, // renderMeshList[].weight
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(6), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(7), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool MeshIofxParameters_0p4::mBuiltFlag = false;
+NvParameterized::MutexType MeshIofxParameters_0p4::mBuiltFlagMutex;
+
+MeshIofxParameters_0p4::MeshIofxParameters_0p4(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &MeshIofxParameters_0p4FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+MeshIofxParameters_0p4::~MeshIofxParameters_0p4()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void MeshIofxParameters_0p4::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~MeshIofxParameters_0p4();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters_0p4::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* MeshIofxParameters_0p4::getParameterDefinitionTree(void) const
+{
+	MeshIofxParameters_0p4* tmpParam = const_cast<MeshIofxParameters_0p4*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType MeshIofxParameters_0p4::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType MeshIofxParameters_0p4::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void MeshIofxParameters_0p4::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<MeshIofxParameters_0p4::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [1,0] - renderMeshList.meshAssetName */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void MeshIofxParameters_0p4::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void MeshIofxParameters_0p4::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="renderMeshList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("renderMeshList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[2] = { 1, 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 2);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="renderMeshList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("renderMeshList", TYPE_STRUCT, "meshProperties", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "An array of mesh asset names with their respective weights (if this is a render mesh IOFX)", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="renderMeshList[].meshAssetName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("meshAssetName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The render mesh asset name or opaque mesh name", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexRenderMesh", "ApexOpaqueMesh" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 2);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="renderMeshList[].weight"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("weight", TYPE_U32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "The weight for this mesh (weighed against other meshes)", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 5);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("INCLUDED", uint64_t(1), true);
+		HintTable[1].init("longDescription", "These modifiers are applied to the instanced objects at object creation.", true);
+		HintTable[2].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[6].setRefVariantVals((const char**)RefVariantVals, 5);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=7, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[7];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsTemperatureModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsTemperatureModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		HintTable[5].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[6].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[7].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsTemperature3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ColorVsTemperatureCompositeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsTemperatureModifierParams", "ScaleVsCameraDistanceModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[7].setRefVariantVals((const char**)RefVariantVals, 15);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=8, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[8];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsTemperatureModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ScaleVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ScaleVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsTemperatureModifierParams", true);
+		HintTable[4].init("INCLUDED", uint64_t(1), true);
+		HintTable[5].init("longDescription", "These modifiers are applied to the instanced objects every frame.", true);
+		HintTable[6].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[8].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ScaleVsLife3DModifierParams", "ScaleVsDensity3DModifierParams", "ScaleVsTemperature3DModifierParams", "ScaleVsCameraDistance3DModifierParams", "OrientAlongVelocityModifierParams", "ScaleAlongVelocityModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ColorVsTemperatureCompositeModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsTemperatureModifierParams", "ScaleVsCameraDistanceModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[8].setRefVariantVals((const char**)RefVariantVals, 15);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(5);
+		Children[2] = PDEF_PTR(7);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="renderMeshList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="renderMeshList[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=5, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(6);
+
+		ParamDefTable[5].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=7, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(8);
+
+		ParamDefTable[7].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void MeshIofxParameters_0p4::initStrings(void)
+{
+}
+
+void MeshIofxParameters_0p4::initDynamicArrays(void)
+{
+	renderMeshList.buf = NULL;
+	renderMeshList.isAllocated = true;
+	renderMeshList.elementSize = sizeof(meshProperties_Type);
+	renderMeshList.arraySizes[0] = 0;
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void MeshIofxParameters_0p4::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void MeshIofxParameters_0p4::initReferences(void)
+{
+}
+
+void MeshIofxParameters_0p4::freeDynamicArrays(void)
+{
+	if (renderMeshList.isAllocated && renderMeshList.buf)
+	{
+		mParameterizedTraits->free(renderMeshList.buf);
+	}
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void MeshIofxParameters_0p4::freeStrings(void)
+{
+}
+
+void MeshIofxParameters_0p4::freeReferences(void)
+{
+
+	for (int i = 0; i < renderMeshList.arraySizes[0]; i++)
+	{
+		if (renderMeshList.buf[i].meshAssetName)
+		{
+			renderMeshList.buf[i].meshAssetName->destroy();
+		}
+	}
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ModuleIOFXLegacy.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ModuleIOFXLegacy.cpp
new file mode 100644
index 00000000..6d615d4b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ModuleIOFXLegacy.cpp
@@ -0,0 +1,86 @@
+/*
+* 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.
+*
+* This code was autogenerated from ModuleIOFXLegacy.template
+*/
+
+#include "ApexUsingNamespace.h"
+#include "Apex.h"
+#include "ApexLegacyModule.h"
+#include "ApexRWLockable.h"
+#include "legacy/ModuleIofxLegacy.h"
+#include "IofxLegacyRender.h"
+#include "PsHashMap.h"
+
+#include "ModuleIOFXLegacyRegistration.h"
+
+namespace nvidia 
+{ 
+namespace apex
+{
+namespace legacy
+{
+
+class ModuleIOFXLegacy : public TApexLegacyModule<ModuleIofxLegacy>, public ApexRWLockable
+{
+public:
+	APEX_RW_LOCKABLE_BOILERPLATE
+
+	ModuleIOFXLegacy(ApexSDKIntl* inSdk)
+	{
+  	  mName = "IOFX_Legacy";
+	  mSdk = inSdk;
+	  mApiProxy = this;
+	  ModuleIOFXLegacyRegistration::invokeRegistration(mSdk->getParameterizedTraits());
+        }
+
+	virtual nvidia::apex::IofxRenderCallback* getIofxLegacyRenderCallback(const Scene& apexScene)
+	{
+		IofxLegacyRenderCallback* &renderCallback = mSceneCallbackMap[&apexScene];
+		if (renderCallback == NULL)
+		{
+			renderCallback = PX_NEW(IofxLegacyRenderCallback)(&apexScene);
+		}
+		return renderCallback;
+	}
+
+
+    virtual ~ModuleIOFXLegacy()
+	{
+		for (SceneCallbackMap_t::Iterator it = mSceneCallbackMap.getIterator(); !it.done(); ++it)
+		{
+			IofxLegacyRenderCallback* renderCallback = it->second;
+			if (renderCallback)
+			{
+				PX_DELETE(renderCallback);
+			}
+		}
+	}
+
+protected:
+	void releaseLegacyObjects()
+        {
+          ModuleIOFXLegacyRegistration::invokeUnregistration(mSdk->getParameterizedTraits());
+        }
+
+private:
+	typedef nvidia::shdfnd::HashMap<const Scene*, IofxLegacyRenderCallback*> SceneCallbackMap_t;
+	SceneCallbackMap_t mSceneCallbackMap;
+};
+
+void instantiateModuleIOFXLegacy()
+{
+	ApexSDKIntl *sdk = GetInternalApexSDK();
+	ModuleIOFXLegacy *impl = PX_NEW(ModuleIOFXLegacy)(sdk);
+	sdk->registerExternalModule((Module *) impl, (ModuleIntl *) impl);
+}
+
+}
+}
+}
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/OrientAlongVelocityModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/OrientAlongVelocityModifierParams_0p0.cpp
new file mode 100644
index 00000000..c3126dd8
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/OrientAlongVelocityModifierParams_0p0.cpp
@@ -0,0 +1,318 @@
+// 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
+
+
+#include "OrientAlongVelocityModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace OrientAlongVelocityModifierParams_0p0NS;
+
+const char* const OrientAlongVelocityModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<OrientAlongVelocityModifierParams_0p0, OrientAlongVelocityModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->modelForward), NULL, 0 }, // modelForward
+};
+
+
+bool OrientAlongVelocityModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType OrientAlongVelocityModifierParams_0p0::mBuiltFlagMutex;
+
+OrientAlongVelocityModifierParams_0p0::OrientAlongVelocityModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &OrientAlongVelocityModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+OrientAlongVelocityModifierParams_0p0::~OrientAlongVelocityModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void OrientAlongVelocityModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~OrientAlongVelocityModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* OrientAlongVelocityModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* OrientAlongVelocityModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	OrientAlongVelocityModifierParams_0p0* tmpParam = const_cast<OrientAlongVelocityModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType OrientAlongVelocityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType OrientAlongVelocityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void OrientAlongVelocityModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<OrientAlongVelocityModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void OrientAlongVelocityModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void OrientAlongVelocityModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "OrientAlongVelocity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="modelForward"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("modelForward", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Model forward", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void OrientAlongVelocityModifierParams_0p0::initStrings(void)
+{
+}
+
+void OrientAlongVelocityModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void OrientAlongVelocityModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	modelForward = physx::PxVec3(init(0, 1, 0));
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void OrientAlongVelocityModifierParams_0p0::initReferences(void)
+{
+}
+
+void OrientAlongVelocityModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void OrientAlongVelocityModifierParams_0p0::freeStrings(void)
+{
+}
+
+void OrientAlongVelocityModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/OrientScaleAlongScreenVelocityModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/OrientScaleAlongScreenVelocityModifierParams_0p0.cpp
new file mode 100644
index 00000000..e9f3f6ca
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/OrientScaleAlongScreenVelocityModifierParams_0p0.cpp
@@ -0,0 +1,325 @@
+// 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
+
+
+#include "OrientScaleAlongScreenVelocityModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace OrientScaleAlongScreenVelocityModifierParams_0p0NS;
+
+const char* const OrientScaleAlongScreenVelocityModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<OrientScaleAlongScreenVelocityModifierParams_0p0, OrientScaleAlongScreenVelocityModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->scalePerVelocity), NULL, 0 }, // scalePerVelocity
+};
+
+
+bool OrientScaleAlongScreenVelocityModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType OrientScaleAlongScreenVelocityModifierParams_0p0::mBuiltFlagMutex;
+
+OrientScaleAlongScreenVelocityModifierParams_0p0::OrientScaleAlongScreenVelocityModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &OrientScaleAlongScreenVelocityModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+OrientScaleAlongScreenVelocityModifierParams_0p0::~OrientScaleAlongScreenVelocityModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~OrientScaleAlongScreenVelocityModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* OrientScaleAlongScreenVelocityModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* OrientScaleAlongScreenVelocityModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	OrientScaleAlongScreenVelocityModifierParams_0p0* tmpParam = const_cast<OrientScaleAlongScreenVelocityModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType OrientScaleAlongScreenVelocityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType OrientScaleAlongScreenVelocityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<OrientScaleAlongScreenVelocityModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void OrientScaleAlongScreenVelocityModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void OrientScaleAlongScreenVelocityModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "OrientScaleAlongScreenVelocity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scalePerVelocity"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scalePerVelocity", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("longDescription", "Scale(Velocity) = 1 + |Velocity| * scalePerVelocity", true);
+		HintTable[2].init("shortDescription", "Scale per velocity", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void OrientScaleAlongScreenVelocityModifierParams_0p0::initStrings(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scalePerVelocity = float(0.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p0::initReferences(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p0::freeStrings(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/OrientScaleAlongScreenVelocityModifierParams_0p1.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/OrientScaleAlongScreenVelocityModifierParams_0p1.cpp
new file mode 100644
index 00000000..195d33d0
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/OrientScaleAlongScreenVelocityModifierParams_0p1.cpp
@@ -0,0 +1,395 @@
+// 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
+
+
+#include "OrientScaleAlongScreenVelocityModifierParams_0p1.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace OrientScaleAlongScreenVelocityModifierParams_0p1NS;
+
+const char* const OrientScaleAlongScreenVelocityModifierParams_0p1Factory::vptr =
+    NvParameterized::getVptr<OrientScaleAlongScreenVelocityModifierParams_0p1, OrientScaleAlongScreenVelocityModifierParams_0p1::ClassAlignment>();
+
+const uint32_t NumParamDefs = 4;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->scalePerVelocity), NULL, 0 }, // scalePerVelocity
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->scaleChangeLimit), NULL, 0 }, // scaleChangeLimit
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->scaleChangeDelay), NULL, 0 }, // scaleChangeDelay
+};
+
+
+bool OrientScaleAlongScreenVelocityModifierParams_0p1::mBuiltFlag = false;
+NvParameterized::MutexType OrientScaleAlongScreenVelocityModifierParams_0p1::mBuiltFlagMutex;
+
+OrientScaleAlongScreenVelocityModifierParams_0p1::OrientScaleAlongScreenVelocityModifierParams_0p1(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &OrientScaleAlongScreenVelocityModifierParams_0p1FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+OrientScaleAlongScreenVelocityModifierParams_0p1::~OrientScaleAlongScreenVelocityModifierParams_0p1()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p1::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~OrientScaleAlongScreenVelocityModifierParams_0p1();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* OrientScaleAlongScreenVelocityModifierParams_0p1::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* OrientScaleAlongScreenVelocityModifierParams_0p1::getParameterDefinitionTree(void) const
+{
+	OrientScaleAlongScreenVelocityModifierParams_0p1* tmpParam = const_cast<OrientScaleAlongScreenVelocityModifierParams_0p1*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType OrientScaleAlongScreenVelocityModifierParams_0p1::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType OrientScaleAlongScreenVelocityModifierParams_0p1::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p1::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<OrientScaleAlongScreenVelocityModifierParams_0p1::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void OrientScaleAlongScreenVelocityModifierParams_0p1::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void OrientScaleAlongScreenVelocityModifierParams_0p1::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "OrientScaleAlongScreenVelocity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scalePerVelocity"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scalePerVelocity", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("longDescription", "Scale(Velocity) = 1 + |Velocity| * scalePerVelocity", true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Scale per velocity", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="scaleChangeLimit"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("scaleChangeLimit", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("longDescription", "This value limits the scale change per unit time, set to 0 to disable the limit", true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Scale change limimt", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="scaleChangeDelay"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("scaleChangeDelay", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("longDescription", "This value is proportional to a delay in time of the scale change, set to 0 to disable the delay", true);
+		HintTable[2].init("min", uint64_t(0), true);
+		HintTable[3].init("shortDescription", "Scale change delay", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	mBuiltFlag = true;
+
+}
+void OrientScaleAlongScreenVelocityModifierParams_0p1::initStrings(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p1::initDynamicArrays(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p1::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scalePerVelocity = float(0.0f);
+	scaleChangeLimit = float(0.0f);
+	scaleChangeDelay = float(0.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p1::initReferences(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p1::freeDynamicArrays(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p1::freeStrings(void)
+{
+}
+
+void OrientScaleAlongScreenVelocityModifierParams_0p1::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/RandomRotationModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/RandomRotationModifierParams_0p0.cpp
new file mode 100644
index 00000000..23a204e3
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/RandomRotationModifierParams_0p0.cpp
@@ -0,0 +1,355 @@
+// 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
+
+
+#include "RandomRotationModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace RandomRotationModifierParams_0p0NS;
+
+const char* const RandomRotationModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<RandomRotationModifierParams_0p0, RandomRotationModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->minRotation), NULL, 0 }, // minRotation
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxRotation), NULL, 0 }, // maxRotation
+};
+
+
+bool RandomRotationModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType RandomRotationModifierParams_0p0::mBuiltFlagMutex;
+
+RandomRotationModifierParams_0p0::RandomRotationModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RandomRotationModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RandomRotationModifierParams_0p0::~RandomRotationModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RandomRotationModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RandomRotationModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RandomRotationModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RandomRotationModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	RandomRotationModifierParams_0p0* tmpParam = const_cast<RandomRotationModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RandomRotationModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RandomRotationModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RandomRotationModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RandomRotationModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RandomRotationModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RandomRotationModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "RandomRotation modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="minRotation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("minRotation", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Minimum rotation in degrees", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="maxRotation"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("maxRotation", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Maximum rotation in degrees", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RandomRotationModifierParams_0p0::initStrings(void)
+{
+}
+
+void RandomRotationModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void RandomRotationModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	minRotation = float(0.0f);
+	maxRotation = float(0.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RandomRotationModifierParams_0p0::initReferences(void)
+{
+}
+
+void RandomRotationModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void RandomRotationModifierParams_0p0::freeStrings(void)
+{
+}
+
+void RandomRotationModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/RandomScaleModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/RandomScaleModifierParams_0p0.cpp
new file mode 100644
index 00000000..28b2636b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/RandomScaleModifierParams_0p0.cpp
@@ -0,0 +1,355 @@
+// 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
+
+
+#include "RandomScaleModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace RandomScaleModifierParams_0p0NS;
+
+const char* const RandomScaleModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<RandomScaleModifierParams_0p0, RandomScaleModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->minScaleFactor), NULL, 0 }, // minScaleFactor
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxScaleFactor), NULL, 0 }, // maxScaleFactor
+};
+
+
+bool RandomScaleModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType RandomScaleModifierParams_0p0::mBuiltFlagMutex;
+
+RandomScaleModifierParams_0p0::RandomScaleModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RandomScaleModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RandomScaleModifierParams_0p0::~RandomScaleModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RandomScaleModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RandomScaleModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RandomScaleModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RandomScaleModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	RandomScaleModifierParams_0p0* tmpParam = const_cast<RandomScaleModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RandomScaleModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RandomScaleModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RandomScaleModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RandomScaleModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RandomScaleModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RandomScaleModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "RandomScale modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="minScaleFactor"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("minScaleFactor", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Scale factor", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="maxScaleFactor"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("maxScaleFactor", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Scale factor", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RandomScaleModifierParams_0p0::initStrings(void)
+{
+}
+
+void RandomScaleModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void RandomScaleModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	minScaleFactor = float(1.0f);
+	maxScaleFactor = float(1.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RandomScaleModifierParams_0p0::initReferences(void)
+{
+}
+
+void RandomScaleModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void RandomScaleModifierParams_0p0::freeStrings(void)
+{
+}
+
+void RandomScaleModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/RandomSubtextureModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/RandomSubtextureModifierParams_0p0.cpp
new file mode 100644
index 00000000..8dd3145e
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/RandomSubtextureModifierParams_0p0.cpp
@@ -0,0 +1,355 @@
+// 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
+
+
+#include "RandomSubtextureModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace RandomSubtextureModifierParams_0p0NS;
+
+const char* const RandomSubtextureModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<RandomSubtextureModifierParams_0p0, RandomSubtextureModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 3;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->minSubtexture), NULL, 0 }, // minSubtexture
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxSubtexture), NULL, 0 }, // maxSubtexture
+};
+
+
+bool RandomSubtextureModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType RandomSubtextureModifierParams_0p0::mBuiltFlagMutex;
+
+RandomSubtextureModifierParams_0p0::RandomSubtextureModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RandomSubtextureModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RandomSubtextureModifierParams_0p0::~RandomSubtextureModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RandomSubtextureModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RandomSubtextureModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RandomSubtextureModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RandomSubtextureModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	RandomSubtextureModifierParams_0p0* tmpParam = const_cast<RandomSubtextureModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RandomSubtextureModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RandomSubtextureModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RandomSubtextureModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RandomSubtextureModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RandomSubtextureModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RandomSubtextureModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "RandomSubtexture modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="minSubtexture"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("minSubtexture", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Minimum subtexture index", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="maxSubtexture"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("maxSubtexture", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Maximum subtexture index", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RandomSubtextureModifierParams_0p0::initStrings(void)
+{
+}
+
+void RandomSubtextureModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void RandomSubtextureModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	minSubtexture = float(0.0f);
+	maxSubtexture = float(0.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RandomSubtextureModifierParams_0p0::initReferences(void)
+{
+}
+
+void RandomSubtextureModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void RandomSubtextureModifierParams_0p0::freeStrings(void)
+{
+}
+
+void RandomSubtextureModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/RotationModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/RotationModifierParams_0p0.cpp
new file mode 100644
index 00000000..14f4079c
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/RotationModifierParams_0p0.cpp
@@ -0,0 +1,440 @@
+// 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
+
+
+#include "RotationModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace RotationModifierParams_0p0NS;
+
+const char* const RotationModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<RotationModifierParams_0p0, RotationModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 5 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->rollType), NULL, 0 }, // rollType
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxRotationRatePerSec), NULL, 0 }, // maxRotationRatePerSec
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxSettleRatePerSec), NULL, 0 }, // maxSettleRatePerSec
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->inAirRotationMultiplier), NULL, 0 }, // inAirRotationMultiplier
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->collisionRotationMultiplier), NULL, 0 }, // collisionRotationMultiplier
+};
+
+
+bool RotationModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType RotationModifierParams_0p0::mBuiltFlagMutex;
+
+RotationModifierParams_0p0::RotationModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RotationModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RotationModifierParams_0p0::~RotationModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RotationModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RotationModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RotationModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RotationModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	RotationModifierParams_0p0* tmpParam = const_cast<RotationModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RotationModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RotationModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RotationModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RotationModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RotationModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RotationModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="rollType"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("rollType", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "SPHERICAL", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "SPHERICAL", true);
+		HintTable[1].init("shortDescription", "Roll type", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "SPHERICAL", "CUBIC", "FLAT_X", "FLAT_Y", "FLAT_Z", "LONG_X", "LONG_Y", "LONG_Z", "SPRITE" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 9);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="maxRotationRatePerSec"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("maxRotationRatePerSec", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Maximum rotation rate for instanced mesh objects", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="maxSettleRatePerSec"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("maxSettleRatePerSec", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Maximum settle rate for instanced mesh objects", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="inAirRotationMultiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("inAirRotationMultiplier", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "This value is multiplied by the rotation delta to increase or decrease rotations/frame if there are no particle collisions", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="collisionRotationMultiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("collisionRotationMultiplier", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "This value is multiplied by the rotation delta to increase or decrease rotations/frame while colliding objects", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[5];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+		Children[4] = PDEF_PTR(5);
+
+		ParamDefTable[0].setChildren(Children, 5);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RotationModifierParams_0p0::initStrings(void)
+{
+}
+
+void RotationModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void RotationModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	rollType = (const char*)"SPHERICAL";
+	maxRotationRatePerSec = float(0.0f);
+	maxSettleRatePerSec = float(1.0f);
+	inAirRotationMultiplier = float(1.0f);
+	collisionRotationMultiplier = float(1.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RotationModifierParams_0p0::initReferences(void)
+{
+}
+
+void RotationModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void RotationModifierParams_0p0::freeStrings(void)
+{
+}
+
+void RotationModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/RotationModifierParams_0p1.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/RotationModifierParams_0p1.cpp
new file mode 100644
index 00000000..38188961
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/RotationModifierParams_0p1.cpp
@@ -0,0 +1,440 @@
+// 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
+
+
+#include "RotationModifierParams_0p1.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace RotationModifierParams_0p1NS;
+
+const char* const RotationModifierParams_0p1Factory::vptr =
+    NvParameterized::getVptr<RotationModifierParams_0p1, RotationModifierParams_0p1::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 5 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->rollType), NULL, 0 }, // rollType
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxRotationRatePerSec), NULL, 0 }, // maxRotationRatePerSec
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxSettleRatePerSec), NULL, 0 }, // maxSettleRatePerSec
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->inAirRotationMultiplier), NULL, 0 }, // inAirRotationMultiplier
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->collisionRotationMultiplier), NULL, 0 }, // collisionRotationMultiplier
+};
+
+
+bool RotationModifierParams_0p1::mBuiltFlag = false;
+NvParameterized::MutexType RotationModifierParams_0p1::mBuiltFlagMutex;
+
+RotationModifierParams_0p1::RotationModifierParams_0p1(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RotationModifierParams_0p1FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RotationModifierParams_0p1::~RotationModifierParams_0p1()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RotationModifierParams_0p1::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RotationModifierParams_0p1();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RotationModifierParams_0p1::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RotationModifierParams_0p1::getParameterDefinitionTree(void) const
+{
+	RotationModifierParams_0p1* tmpParam = const_cast<RotationModifierParams_0p1*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RotationModifierParams_0p1::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RotationModifierParams_0p1::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RotationModifierParams_0p1::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RotationModifierParams_0p1::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RotationModifierParams_0p1::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RotationModifierParams_0p1::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="rollType"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("rollType", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "SPHERICAL", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "SPHERICAL", true);
+		HintTable[1].init("shortDescription", "Roll type", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "SPHERICAL", "CUBIC", "FLAT_X", "FLAT_Y", "FLAT_Z", "LONG_X", "LONG_Y", "LONG_Z" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 8);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="maxRotationRatePerSec"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("maxRotationRatePerSec", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Maximum rotation rate for instanced mesh objects", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="maxSettleRatePerSec"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("maxSettleRatePerSec", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Maximum settle rate for instanced mesh objects", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="inAirRotationMultiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("inAirRotationMultiplier", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "This value is multiplied by the rotation delta to increase or decrease rotations/frame if there are no particle collisions", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="collisionRotationMultiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("collisionRotationMultiplier", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "This value is multiplied by the rotation delta to increase or decrease rotations/frame while colliding objects", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[5];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+		Children[4] = PDEF_PTR(5);
+
+		ParamDefTable[0].setChildren(Children, 5);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RotationModifierParams_0p1::initStrings(void)
+{
+}
+
+void RotationModifierParams_0p1::initDynamicArrays(void)
+{
+}
+
+void RotationModifierParams_0p1::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	rollType = (const char*)"SPHERICAL";
+	maxRotationRatePerSec = float(0.0f);
+	maxSettleRatePerSec = float(1.0f);
+	inAirRotationMultiplier = float(1.0f);
+	collisionRotationMultiplier = float(1.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RotationModifierParams_0p1::initReferences(void)
+{
+}
+
+void RotationModifierParams_0p1::freeDynamicArrays(void)
+{
+}
+
+void RotationModifierParams_0p1::freeStrings(void)
+{
+}
+
+void RotationModifierParams_0p1::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/RotationModifierParams_0p2.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/RotationModifierParams_0p2.cpp
new file mode 100644
index 00000000..5d46b21a
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/RotationModifierParams_0p2.cpp
@@ -0,0 +1,481 @@
+// 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
+
+
+#include "RotationModifierParams_0p2.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace RotationModifierParams_0p2NS;
+
+const char* const RotationModifierParams_0p2Factory::vptr =
+    NvParameterized::getVptr<RotationModifierParams_0p2, RotationModifierParams_0p2::ClassAlignment>();
+
+const uint32_t NumParamDefs = 7;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5, 6,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 6 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->rollType), NULL, 0 }, // rollType
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxRotationRatePerSec), NULL, 0 }, // maxRotationRatePerSec
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->maxSettleRatePerSec), NULL, 0 }, // maxSettleRatePerSec
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->inAirRotationMultiplier), NULL, 0 }, // inAirRotationMultiplier
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->collisionRotationMultiplier), NULL, 0 }, // collisionRotationMultiplier
+	{ TYPE_BOOL, false, (size_t)(&((ParametersStruct*)0)->includeVerticalDirection), NULL, 0 }, // includeVerticalDirection
+};
+
+
+bool RotationModifierParams_0p2::mBuiltFlag = false;
+NvParameterized::MutexType RotationModifierParams_0p2::mBuiltFlagMutex;
+
+RotationModifierParams_0p2::RotationModifierParams_0p2(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RotationModifierParams_0p2FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RotationModifierParams_0p2::~RotationModifierParams_0p2()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RotationModifierParams_0p2::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RotationModifierParams_0p2();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RotationModifierParams_0p2::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RotationModifierParams_0p2::getParameterDefinitionTree(void) const
+{
+	RotationModifierParams_0p2* tmpParam = const_cast<RotationModifierParams_0p2*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RotationModifierParams_0p2::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RotationModifierParams_0p2::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RotationModifierParams_0p2::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RotationModifierParams_0p2::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RotationModifierParams_0p2::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RotationModifierParams_0p2::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Rotation modifier parameters.", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="rollType"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("rollType", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "SPHERICAL", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "SPHERICAL", true);
+		HintTable[1].init("shortDescription", "Roll type", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "SPHERICAL", "CUBIC", "FLAT_X", "FLAT_Y", "FLAT_Z", "LONG_X", "LONG_Y", "LONG_Z" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 8);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="maxRotationRatePerSec"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("maxRotationRatePerSec", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Maximum rotation rate for instanced mesh objects", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="maxSettleRatePerSec"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("maxSettleRatePerSec", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Maximum settle rate for instanced mesh objects", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="inAirRotationMultiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("inAirRotationMultiplier", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "This value is multiplied by the rotation delta to increase or decrease rotations/frame if there are no particle collisions", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="collisionRotationMultiplier"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("collisionRotationMultiplier", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "This value is multiplied by the rotation delta to increase or decrease rotations/frame while colliding objects", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=6, longName="includeVerticalDirection"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[6];
+		ParamDef->init("includeVerticalDirection", TYPE_BOOL, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "false", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "false", true);
+		HintTable[1].init("shortDescription", "If false, the vertical speed of the object does not affect the rotation", true);
+		ParamDefTable[6].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[6];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(3);
+		Children[3] = PDEF_PTR(4);
+		Children[4] = PDEF_PTR(5);
+		Children[5] = PDEF_PTR(6);
+
+		ParamDefTable[0].setChildren(Children, 6);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RotationModifierParams_0p2::initStrings(void)
+{
+}
+
+void RotationModifierParams_0p2::initDynamicArrays(void)
+{
+}
+
+void RotationModifierParams_0p2::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	rollType = (const char*)"SPHERICAL";
+	maxRotationRatePerSec = float(0.0f);
+	maxSettleRatePerSec = float(1.0f);
+	inAirRotationMultiplier = float(1.0f);
+	collisionRotationMultiplier = float(1.0f);
+	includeVerticalDirection = bool(false);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RotationModifierParams_0p2::initReferences(void)
+{
+}
+
+void RotationModifierParams_0p2::freeDynamicArrays(void)
+{
+}
+
+void RotationModifierParams_0p2::freeStrings(void)
+{
+}
+
+void RotationModifierParams_0p2::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/RotationRateModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/RotationRateModifierParams_0p0.cpp
new file mode 100644
index 00000000..b68150ea
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/RotationRateModifierParams_0p0.cpp
@@ -0,0 +1,324 @@
+// 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
+
+
+#include "RotationRateModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace RotationRateModifierParams_0p0NS;
+
+const char* const RotationRateModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<RotationRateModifierParams_0p0, RotationRateModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->rotationRate), NULL, 0 }, // rotationRate
+};
+
+
+bool RotationRateModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType RotationRateModifierParams_0p0::mBuiltFlagMutex;
+
+RotationRateModifierParams_0p0::RotationRateModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RotationRateModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RotationRateModifierParams_0p0::~RotationRateModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RotationRateModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RotationRateModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RotationRateModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RotationRateModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	RotationRateModifierParams_0p0* tmpParam = const_cast<RotationRateModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RotationRateModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RotationRateModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RotationRateModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RotationRateModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RotationRateModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RotationRateModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "RotationRate modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="rotationRate"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("rotationRate", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Rotation Rate (revs/sec) for sprite objects", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RotationRateModifierParams_0p0::initStrings(void)
+{
+}
+
+void RotationRateModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void RotationRateModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	rotationRate = float(0.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RotationRateModifierParams_0p0::initReferences(void)
+{
+}
+
+void RotationRateModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void RotationRateModifierParams_0p0::freeStrings(void)
+{
+}
+
+void RotationRateModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/RotationRateVsLifeModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/RotationRateVsLifeModifierParams_0p0.cpp
new file mode 100644
index 00000000..f96b4687
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/RotationRateVsLifeModifierParams_0p0.cpp
@@ -0,0 +1,441 @@
+// 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
+
+
+#include "RotationRateVsLifeModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace RotationRateVsLifeModifierParams_0p0NS;
+
+const char* const RotationRateVsLifeModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<RotationRateVsLifeModifierParams_0p0, RotationRateVsLifeModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool RotationRateVsLifeModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType RotationRateVsLifeModifierParams_0p0::mBuiltFlagMutex;
+
+RotationRateVsLifeModifierParams_0p0::RotationRateVsLifeModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &RotationRateVsLifeModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+RotationRateVsLifeModifierParams_0p0::~RotationRateVsLifeModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void RotationRateVsLifeModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~RotationRateVsLifeModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* RotationRateVsLifeModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* RotationRateVsLifeModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	RotationRateVsLifeModifierParams_0p0* tmpParam = const_cast<RotationRateVsLifeModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType RotationRateVsLifeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType RotationRateVsLifeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void RotationRateVsLifeModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<RotationRateVsLifeModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void RotationRateVsLifeModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void RotationRateVsLifeModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "RotationRateVsLife modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Rotation Rate (revs/sec)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[4].init("shortDescription", "Control points for a curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "Rotation Rate (revs/sec)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Rotation Rate (revs/sec)", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[4].init("shortDescription", "Control points for a curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "Rotation Rate (revs/sec)", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Life time", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Rotation rate (revs/sec)", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void RotationRateVsLifeModifierParams_0p0::initStrings(void)
+{
+}
+
+void RotationRateVsLifeModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void RotationRateVsLifeModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void RotationRateVsLifeModifierParams_0p0::initReferences(void)
+{
+}
+
+void RotationRateVsLifeModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void RotationRateVsLifeModifierParams_0p0::freeStrings(void)
+{
+}
+
+void RotationRateVsLifeModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleAlongVelocityModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleAlongVelocityModifierParams_0p0.cpp
new file mode 100644
index 00000000..8359aa61
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleAlongVelocityModifierParams_0p0.cpp
@@ -0,0 +1,324 @@
+// 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
+
+
+#include "ScaleAlongVelocityModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleAlongVelocityModifierParams_0p0NS;
+
+const char* const ScaleAlongVelocityModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleAlongVelocityModifierParams_0p0, ScaleAlongVelocityModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_F32, false, (size_t)(&((ParametersStruct*)0)->scaleFactor), NULL, 0 }, // scaleFactor
+};
+
+
+bool ScaleAlongVelocityModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleAlongVelocityModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleAlongVelocityModifierParams_0p0::ScaleAlongVelocityModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleAlongVelocityModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleAlongVelocityModifierParams_0p0::~ScaleAlongVelocityModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleAlongVelocityModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleAlongVelocityModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleAlongVelocityModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleAlongVelocityModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleAlongVelocityModifierParams_0p0* tmpParam = const_cast<ScaleAlongVelocityModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleAlongVelocityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleAlongVelocityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleAlongVelocityModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleAlongVelocityModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleAlongVelocityModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleAlongVelocityModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleAlongVelocity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleFactor"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleFactor", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", uint64_t(1), true);
+		HintTable[1].init("shortDescription", "Scale factor", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleAlongVelocityModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleAlongVelocityModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void ScaleAlongVelocityModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleFactor = float(1.0f);
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleAlongVelocityModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleAlongVelocityModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void ScaleAlongVelocityModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleAlongVelocityModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleByMassModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleByMassModifierParams_0p0.cpp
new file mode 100644
index 00000000..30bc5297
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleByMassModifierParams_0p0.cpp
@@ -0,0 +1,280 @@
+// 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
+
+
+#include "ScaleByMassModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleByMassModifierParams_0p0NS;
+
+const char* const ScaleByMassModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleByMassModifierParams_0p0, ScaleByMassModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 1;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, NULL, 0 },
+};
+
+
+bool ScaleByMassModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleByMassModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleByMassModifierParams_0p0::ScaleByMassModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleByMassModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleByMassModifierParams_0p0::~ScaleByMassModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleByMassModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleByMassModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleByMassModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleByMassModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleByMassModifierParams_0p0* tmpParam = const_cast<ScaleByMassModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleByMassModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleByMassModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleByMassModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleByMassModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleByMassModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleByMassModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleByMass modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleByMassModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleByMassModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void ScaleByMassModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleByMassModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleByMassModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void ScaleByMassModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleByMassModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsCameraDistance2DModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsCameraDistance2DModifierParams_0p0.cpp
new file mode 100644
index 00000000..1899c83b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsCameraDistance2DModifierParams_0p0.cpp
@@ -0,0 +1,451 @@
+// 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
+
+
+#include "ScaleVsCameraDistance2DModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsCameraDistance2DModifierParams_0p0NS;
+
+const char* const ScaleVsCameraDistance2DModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsCameraDistance2DModifierParams_0p0, ScaleVsCameraDistance2DModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleCameraDistanceStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleCameraDistanceStruct_Type*)0)->cameraDistance), NULL, 0 }, // controlPoints[].cameraDistance
+	{ TYPE_VEC2, false, (size_t)(&((scaleCameraDistanceStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsCameraDistance2DModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsCameraDistance2DModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsCameraDistance2DModifierParams_0p0::ScaleVsCameraDistance2DModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsCameraDistance2DModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsCameraDistance2DModifierParams_0p0::~ScaleVsCameraDistance2DModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsCameraDistance2DModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsCameraDistance2DModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistance2DModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistance2DModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsCameraDistance2DModifierParams_0p0* tmpParam = const_cast<ScaleVsCameraDistance2DModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistance2DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistance2DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsCameraDistance2DModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsCameraDistance2DModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsCameraDistance2DModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsCameraDistance2DModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsCameraDistance2D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 2D scale vs camera distance curve", true);
+		HintTable[4].init("xAxisLabel", "Camera Distance", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleCameraDistanceStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 2D scale vs camera distance curve", true);
+		HintTable[4].init("xAxisLabel", "Camera Distance", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].cameraDistance"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("cameraDistance", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Camera distance", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC2, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsCameraDistance2DModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsCameraDistance2DModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleCameraDistanceStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsCameraDistance2DModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsCameraDistance2DModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsCameraDistance2DModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsCameraDistance2DModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsCameraDistance2DModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsCameraDistance3DModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsCameraDistance3DModifierParams_0p0.cpp
new file mode 100644
index 00000000..9ae166d2
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsCameraDistance3DModifierParams_0p0.cpp
@@ -0,0 +1,451 @@
+// 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
+
+
+#include "ScaleVsCameraDistance3DModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsCameraDistance3DModifierParams_0p0NS;
+
+const char* const ScaleVsCameraDistance3DModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsCameraDistance3DModifierParams_0p0, ScaleVsCameraDistance3DModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleCameraDistanceStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleCameraDistanceStruct_Type*)0)->cameraDistance), NULL, 0 }, // controlPoints[].cameraDistance
+	{ TYPE_VEC3, false, (size_t)(&((scaleCameraDistanceStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsCameraDistance3DModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsCameraDistance3DModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsCameraDistance3DModifierParams_0p0::ScaleVsCameraDistance3DModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsCameraDistance3DModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsCameraDistance3DModifierParams_0p0::~ScaleVsCameraDistance3DModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsCameraDistance3DModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsCameraDistance3DModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistance3DModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistance3DModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsCameraDistance3DModifierParams_0p0* tmpParam = const_cast<ScaleVsCameraDistance3DModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistance3DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistance3DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsCameraDistance3DModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsCameraDistance3DModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsCameraDistance3DModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsCameraDistance3DModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsCameraDistance3D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 3D scale vs camera distance curve", true);
+		HintTable[4].init("xAxisLabel", "Camera Distance", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleCameraDistanceStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 3D scale vs camera distance curve", true);
+		HintTable[4].init("xAxisLabel", "Camera Distance", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].cameraDistance"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("cameraDistance", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Camera distance", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsCameraDistance3DModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsCameraDistance3DModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleCameraDistanceStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsCameraDistance3DModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsCameraDistance3DModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsCameraDistance3DModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsCameraDistance3DModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsCameraDistance3DModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsCameraDistanceModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsCameraDistanceModifierParams_0p0.cpp
new file mode 100644
index 00000000..e62e6f4c
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsCameraDistanceModifierParams_0p0.cpp
@@ -0,0 +1,466 @@
+// 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
+
+
+#include "ScaleVsCameraDistanceModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsCameraDistanceModifierParams_0p0NS;
+
+const char* const ScaleVsCameraDistanceModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsCameraDistanceModifierParams_0p0, ScaleVsCameraDistanceModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->scaleAxis), NULL, 0 }, // scaleAxis
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ScaleVsCameraDistanceModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsCameraDistanceModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsCameraDistanceModifierParams_0p0::ScaleVsCameraDistanceModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsCameraDistanceModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsCameraDistanceModifierParams_0p0::~ScaleVsCameraDistanceModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsCameraDistanceModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsCameraDistanceModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistanceModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsCameraDistanceModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsCameraDistanceModifierParams_0p0* tmpParam = const_cast<ScaleVsCameraDistanceModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistanceModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsCameraDistanceModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsCameraDistanceModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsCameraDistanceModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsCameraDistanceModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsCameraDistanceModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsCameraDistance modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleAxis"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleAxis", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		HintTable[1].init("shortDescription", "Scale axis to which the curve will be applied", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "xAxis", "yAxis", "zAxis" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Camera Distance", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Camera Distance", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Camera Distance", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Camera distance", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Scale", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsCameraDistanceModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsCameraDistanceModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsCameraDistanceModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleAxis = (const char*)"xAxis";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsCameraDistanceModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsCameraDistanceModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsCameraDistanceModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsCameraDistanceModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsDensity2DModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsDensity2DModifierParams_0p0.cpp
new file mode 100644
index 00000000..157079cb
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsDensity2DModifierParams_0p0.cpp
@@ -0,0 +1,455 @@
+// 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
+
+
+#include "ScaleVsDensity2DModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsDensity2DModifierParams_0p0NS;
+
+const char* const ScaleVsDensity2DModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsDensity2DModifierParams_0p0, ScaleVsDensity2DModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleDensityStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleDensityStruct_Type*)0)->density), NULL, 0 }, // controlPoints[].density
+	{ TYPE_VEC2, false, (size_t)(&((scaleDensityStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsDensity2DModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsDensity2DModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsDensity2DModifierParams_0p0::ScaleVsDensity2DModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsDensity2DModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsDensity2DModifierParams_0p0::~ScaleVsDensity2DModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsDensity2DModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsDensity2DModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensity2DModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensity2DModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsDensity2DModifierParams_0p0* tmpParam = const_cast<ScaleVsDensity2DModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsDensity2DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsDensity2DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsDensity2DModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsDensity2DModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsDensity2DModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsDensity2DModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsDensity2D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite 2D scale vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleDensityStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1000), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite 2D scale vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].density"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("density", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Density", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC2, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsDensity2DModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsDensity2DModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleDensityStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsDensity2DModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsDensity2DModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsDensity2DModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsDensity2DModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsDensity2DModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsDensity3DModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsDensity3DModifierParams_0p0.cpp
new file mode 100644
index 00000000..42c857dd
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsDensity3DModifierParams_0p0.cpp
@@ -0,0 +1,455 @@
+// 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
+
+
+#include "ScaleVsDensity3DModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsDensity3DModifierParams_0p0NS;
+
+const char* const ScaleVsDensity3DModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsDensity3DModifierParams_0p0, ScaleVsDensity3DModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleDensityStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleDensityStruct_Type*)0)->density), NULL, 0 }, // controlPoints[].density
+	{ TYPE_VEC3, false, (size_t)(&((scaleDensityStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsDensity3DModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsDensity3DModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsDensity3DModifierParams_0p0::ScaleVsDensity3DModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsDensity3DModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsDensity3DModifierParams_0p0::~ScaleVsDensity3DModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsDensity3DModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsDensity3DModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensity3DModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensity3DModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsDensity3DModifierParams_0p0* tmpParam = const_cast<ScaleVsDensity3DModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsDensity3DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsDensity3DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsDensity3DModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsDensity3DModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsDensity3DModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsDensity3DModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsDensity3D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite 3D scale vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleDensityStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("xAxisLabel", "Density", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_X_SCALE_PHYSX3", uint64_t(1), true);
+		HintTable[2].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[3].init("editorCurve", uint64_t(1), true);
+		HintTable[4].init("shortDescription", "Control points for a composite 3D scale vs density curve", true);
+		HintTable[5].init("xAxisLabel", "Density", true);
+		HintTable[6].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].density"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("density", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Density", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsDensity3DModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsDensity3DModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleDensityStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsDensity3DModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsDensity3DModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsDensity3DModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsDensity3DModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsDensity3DModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsDensityModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsDensityModifierParams_0p0.cpp
new file mode 100644
index 00000000..4e53b5a2
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsDensityModifierParams_0p0.cpp
@@ -0,0 +1,466 @@
+// 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
+
+
+#include "ScaleVsDensityModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsDensityModifierParams_0p0NS;
+
+const char* const ScaleVsDensityModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsDensityModifierParams_0p0, ScaleVsDensityModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->scaleAxis), NULL, 0 }, // scaleAxis
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ScaleVsDensityModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsDensityModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsDensityModifierParams_0p0::ScaleVsDensityModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsDensityModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsDensityModifierParams_0p0::~ScaleVsDensityModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsDensityModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsDensityModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensityModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsDensityModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsDensityModifierParams_0p0* tmpParam = const_cast<ScaleVsDensityModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsDensityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsDensityModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsDensityModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsDensityModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsDensityModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsDensityModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsDensity modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleAxis"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleAxis", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		HintTable[1].init("shortDescription", "Scale axis to which the curve will be applied", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "xAxis", "yAxis", "zAxis" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Density", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Density", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Density", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Density", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Density", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Scale", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsDensityModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsDensityModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsDensityModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleAxis = (const char*)"xAxis";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsDensityModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsDensityModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsDensityModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsDensityModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsLife2DModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsLife2DModifierParams_0p0.cpp
new file mode 100644
index 00000000..d88d2411
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsLife2DModifierParams_0p0.cpp
@@ -0,0 +1,453 @@
+// 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
+
+
+#include "ScaleVsLife2DModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsLife2DModifierParams_0p0NS;
+
+const char* const ScaleVsLife2DModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsLife2DModifierParams_0p0, ScaleVsLife2DModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleLifeStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleLifeStruct_Type*)0)->lifeRemaining), NULL, 0 }, // controlPoints[].lifeRemaining
+	{ TYPE_VEC2, false, (size_t)(&((scaleLifeStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsLife2DModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsLife2DModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsLife2DModifierParams_0p0::ScaleVsLife2DModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsLife2DModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsLife2DModifierParams_0p0::~ScaleVsLife2DModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsLife2DModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsLife2DModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLife2DModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLife2DModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsLife2DModifierParams_0p0* tmpParam = const_cast<ScaleVsLife2DModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsLife2DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsLife2DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsLife2DModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsLife2DModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsLife2DModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsLife2DModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsLife2D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite scale vs life curve", true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleLifeStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite scale vs life curve", true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].lifeRemaining"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("lifeRemaining", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life remaining", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC2, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsLife2DModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsLife2DModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleLifeStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsLife2DModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsLife2DModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsLife2DModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsLife2DModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsLife2DModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsLife3DModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsLife3DModifierParams_0p0.cpp
new file mode 100644
index 00000000..20ecece9
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsLife3DModifierParams_0p0.cpp
@@ -0,0 +1,453 @@
+// 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
+
+
+#include "ScaleVsLife3DModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsLife3DModifierParams_0p0NS;
+
+const char* const ScaleVsLife3DModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsLife3DModifierParams_0p0, ScaleVsLife3DModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleLifeStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleLifeStruct_Type*)0)->lifeRemaining), NULL, 0 }, // controlPoints[].lifeRemaining
+	{ TYPE_VEC3, false, (size_t)(&((scaleLifeStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsLife3DModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsLife3DModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsLife3DModifierParams_0p0::ScaleVsLife3DModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsLife3DModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsLife3DModifierParams_0p0::~ScaleVsLife3DModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsLife3DModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsLife3DModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLife3DModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLife3DModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsLife3DModifierParams_0p0* tmpParam = const_cast<ScaleVsLife3DModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsLife3DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsLife3DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsLife3DModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsLife3DModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsLife3DModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsLife3DModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsLife3D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite scale vs life curve", true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleLifeStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite scale vs life curve", true);
+		HintTable[4].init("xAxisLabel", "Life Time", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].lifeRemaining"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("lifeRemaining", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life remaining", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsLife3DModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsLife3DModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleLifeStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsLife3DModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsLife3DModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsLife3DModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsLife3DModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsLife3DModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsLifeModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsLifeModifierParams_0p0.cpp
new file mode 100644
index 00000000..6a95d8f4
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsLifeModifierParams_0p0.cpp
@@ -0,0 +1,474 @@
+// 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
+
+
+#include "ScaleVsLifeModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsLifeModifierParams_0p0NS;
+
+const char* const ScaleVsLifeModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsLifeModifierParams_0p0, ScaleVsLifeModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->scaleAxis), NULL, 0 }, // scaleAxis
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ScaleVsLifeModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsLifeModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsLifeModifierParams_0p0::ScaleVsLifeModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsLifeModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsLifeModifierParams_0p0::~ScaleVsLifeModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsLifeModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsLifeModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLifeModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsLifeModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsLifeModifierParams_0p0* tmpParam = const_cast<ScaleVsLifeModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsLifeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsLifeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsLifeModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsLifeModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsLifeModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsLifeModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsLife modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleAxis"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleAxis", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		HintTable[1].init("shortDescription", "Scale axis to which the curve will be applied", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "xAxis", "yAxis", "zAxis" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Life Time", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Life Time", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Scale", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsLifeModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsLifeModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsLifeModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleAxis = (const char*)"xAxis";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsLifeModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsLifeModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsLifeModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsLifeModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsTemperature2DModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsTemperature2DModifierParams_0p0.cpp
new file mode 100644
index 00000000..d1be816d
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsTemperature2DModifierParams_0p0.cpp
@@ -0,0 +1,451 @@
+// 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
+
+
+#include "ScaleVsTemperature2DModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsTemperature2DModifierParams_0p0NS;
+
+const char* const ScaleVsTemperature2DModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsTemperature2DModifierParams_0p0, ScaleVsTemperature2DModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleTemperatureStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleTemperatureStruct_Type*)0)->temperature), NULL, 0 }, // controlPoints[].temperature
+	{ TYPE_VEC2, false, (size_t)(&((scaleTemperatureStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsTemperature2DModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsTemperature2DModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsTemperature2DModifierParams_0p0::ScaleVsTemperature2DModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsTemperature2DModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsTemperature2DModifierParams_0p0::~ScaleVsTemperature2DModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsTemperature2DModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsTemperature2DModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperature2DModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperature2DModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsTemperature2DModifierParams_0p0* tmpParam = const_cast<ScaleVsTemperature2DModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsTemperature2DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsTemperature2DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsTemperature2DModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsTemperature2DModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsTemperature2DModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsTemperature2DModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsTemperature2D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 2D scale vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleTemperatureStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 2D scale vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].temperature"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("temperature", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Temperature", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC2, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsTemperature2DModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsTemperature2DModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleTemperatureStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsTemperature2DModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsTemperature2DModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsTemperature2DModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsTemperature2DModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsTemperature2DModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsTemperature3DModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsTemperature3DModifierParams_0p0.cpp
new file mode 100644
index 00000000..47b2b18f
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsTemperature3DModifierParams_0p0.cpp
@@ -0,0 +1,451 @@
+// 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
+
+
+#include "ScaleVsTemperature3DModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsTemperature3DModifierParams_0p0NS;
+
+const char* const ScaleVsTemperature3DModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsTemperature3DModifierParams_0p0, ScaleVsTemperature3DModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(scaleTemperatureStruct_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((scaleTemperatureStruct_Type*)0)->temperature), NULL, 0 }, // controlPoints[].temperature
+	{ TYPE_VEC3, false, (size_t)(&((scaleTemperatureStruct_Type*)0)->scale), NULL, 0 }, // controlPoints[].scale
+};
+
+
+bool ScaleVsTemperature3DModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsTemperature3DModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsTemperature3DModifierParams_0p0::ScaleVsTemperature3DModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsTemperature3DModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsTemperature3DModifierParams_0p0::~ScaleVsTemperature3DModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsTemperature3DModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsTemperature3DModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperature3DModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperature3DModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsTemperature3DModifierParams_0p0* tmpParam = const_cast<ScaleVsTemperature3DModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsTemperature3DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsTemperature3DModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsTemperature3DModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsTemperature3DModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsTemperature3DModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsTemperature3DModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsTemperature3D modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 3D scale vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "scaleTemperatureStruct", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(1), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("shortDescription", "Control points for a composite 3D scale vs Temperature curve", true);
+		HintTable[4].init("xAxisLabel", "Temperature", true);
+		HintTable[5].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].temperature"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("temperature", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Temperature", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].scale"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("scale", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("min", uint64_t(0), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("min", uint64_t(0), true);
+		HintTable[1].init("shortDescription", "Scale", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsTemperature3DModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsTemperature3DModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(scaleTemperatureStruct_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsTemperature3DModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsTemperature3DModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsTemperature3DModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsTemperature3DModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsTemperature3DModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsTemperatureModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsTemperatureModifierParams_0p0.cpp
new file mode 100644
index 00000000..9617d569
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ScaleVsTemperatureModifierParams_0p0.cpp
@@ -0,0 +1,466 @@
+// 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
+
+
+#include "ScaleVsTemperatureModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ScaleVsTemperatureModifierParams_0p0NS;
+
+const char* const ScaleVsTemperatureModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ScaleVsTemperatureModifierParams_0p0, ScaleVsTemperatureModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 2 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->scaleAxis), NULL, 0 }, // scaleAxis
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(2), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(3), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool ScaleVsTemperatureModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ScaleVsTemperatureModifierParams_0p0::mBuiltFlagMutex;
+
+ScaleVsTemperatureModifierParams_0p0::ScaleVsTemperatureModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ScaleVsTemperatureModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ScaleVsTemperatureModifierParams_0p0::~ScaleVsTemperatureModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ScaleVsTemperatureModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ScaleVsTemperatureModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperatureModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ScaleVsTemperatureModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ScaleVsTemperatureModifierParams_0p0* tmpParam = const_cast<ScaleVsTemperatureModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ScaleVsTemperatureModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ScaleVsTemperatureModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ScaleVsTemperatureModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ScaleVsTemperatureModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ScaleVsTemperatureModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ScaleVsTemperatureModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ScaleVsTemperature modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleAxis"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleAxis", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "xAxis", true);
+		HintTable[1].init("shortDescription", "Scale axis to which the curve will be applied", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "xAxis", "yAxis", "zAxis" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 3);
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Temperature", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("xAxisLabel", "Temperature", true);
+		HintTable[2].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#else
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("editorCurve", uint64_t(1), true);
+		HintTable[1].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[2].init("shortDescription", "Control points for a curve", true);
+		HintTable[3].init("xAxisLabel", "Temperature", true);
+		HintTable[4].init("yAxisLabel", "Scale", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Temperature", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Scale", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+
+		ParamDefTable[0].setChildren(Children, 2);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=3, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(4);
+		Children[1] = PDEF_PTR(5);
+
+		ParamDefTable[3].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ScaleVsTemperatureModifierParams_0p0::initStrings(void)
+{
+}
+
+void ScaleVsTemperatureModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void ScaleVsTemperatureModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleAxis = (const char*)"xAxis";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ScaleVsTemperatureModifierParams_0p0::initReferences(void)
+{
+}
+
+void ScaleVsTemperatureModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void ScaleVsTemperatureModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ScaleVsTemperatureModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/SimpleScaleModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/SimpleScaleModifierParams_0p0.cpp
new file mode 100644
index 00000000..a67a5aef
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/SimpleScaleModifierParams_0p0.cpp
@@ -0,0 +1,318 @@
+// 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
+
+
+#include "SimpleScaleModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace SimpleScaleModifierParams_0p0NS;
+
+const char* const SimpleScaleModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<SimpleScaleModifierParams_0p0, SimpleScaleModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_VEC3, false, (size_t)(&((ParametersStruct*)0)->scaleFactor), NULL, 0 }, // scaleFactor
+};
+
+
+bool SimpleScaleModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType SimpleScaleModifierParams_0p0::mBuiltFlagMutex;
+
+SimpleScaleModifierParams_0p0::SimpleScaleModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SimpleScaleModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SimpleScaleModifierParams_0p0::~SimpleScaleModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SimpleScaleModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SimpleScaleModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SimpleScaleModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SimpleScaleModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	SimpleScaleModifierParams_0p0* tmpParam = const_cast<SimpleScaleModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SimpleScaleModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SimpleScaleModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SimpleScaleModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SimpleScaleModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void SimpleScaleModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SimpleScaleModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "SimpleScale modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="scaleFactor"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("scaleFactor", TYPE_VEC3, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Scale factor", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SimpleScaleModifierParams_0p0::initStrings(void)
+{
+}
+
+void SimpleScaleModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void SimpleScaleModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	scaleFactor = physx::PxVec3(init(1, 1, 1));
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SimpleScaleModifierParams_0p0::initReferences(void)
+{
+}
+
+void SimpleScaleModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void SimpleScaleModifierParams_0p0::freeStrings(void)
+{
+}
+
+void SimpleScaleModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p0.cpp
new file mode 100644
index 00000000..5c5978d6
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p0.cpp
@@ -0,0 +1,530 @@
+// 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
+
+
+#include "SpriteIofxParameters_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace SpriteIofxParameters_0p0NS;
+
+const char* const SpriteIofxParameters_0p0Factory::vptr =
+    NvParameterized::getVptr<SpriteIofxParameters_0p0, SpriteIofxParameters_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 4, 3, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->spriteMaterialName), NULL, 0 }, // spriteMaterialName
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(3), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(4), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool SpriteIofxParameters_0p0::mBuiltFlag = false;
+NvParameterized::MutexType SpriteIofxParameters_0p0::mBuiltFlagMutex;
+
+SpriteIofxParameters_0p0::SpriteIofxParameters_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SpriteIofxParameters_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SpriteIofxParameters_0p0::~SpriteIofxParameters_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SpriteIofxParameters_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SpriteIofxParameters_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters_0p0::getParameterDefinitionTree(void) const
+{
+	SpriteIofxParameters_0p0* tmpParam = const_cast<SpriteIofxParameters_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SpriteIofxParameters_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SpriteIofxParameters_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void SpriteIofxParameters_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SpriteIofxParameters_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="spriteMaterialName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("spriteMaterialName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The sprite material name (if this is a sprite IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexMaterials" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 7);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 7);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "RotationModifierParams", true);
+		HintTable[6].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#else
+
+		static HintImpl HintTable[9];
+		static Hint* HintPtrTable[9] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], &HintTable[8], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "RotationModifierParams", true);
+		HintTable[6].init("INCLUDED", uint64_t(1), true);
+		HintTable[7].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[8].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 9);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams" };
+		ParamDefTable[4].setRefVariantVals((const char**)RefVariantVals, 13);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "RotationModifierParams", true);
+		HintTable[6].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#else
+
+		static HintImpl HintTable[9];
+		static Hint* HintPtrTable[9] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], &HintTable[8], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "RotationModifierParams", true);
+		HintTable[6].init("INCLUDED", uint64_t(1), true);
+		HintTable[7].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[8].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 9);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "RotationModifierParams", "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 13);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(5);
+
+		ParamDefTable[4].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SpriteIofxParameters_0p0::initStrings(void)
+{
+}
+
+void SpriteIofxParameters_0p0::initDynamicArrays(void)
+{
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void SpriteIofxParameters_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SpriteIofxParameters_0p0::initReferences(void)
+{
+	spriteMaterialName = NULL;
+
+}
+
+void SpriteIofxParameters_0p0::freeDynamicArrays(void)
+{
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void SpriteIofxParameters_0p0::freeStrings(void)
+{
+}
+
+void SpriteIofxParameters_0p0::freeReferences(void)
+{
+	if (spriteMaterialName)
+	{
+		spriteMaterialName->destroy();
+	}
+
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p1.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p1.cpp
new file mode 100644
index 00000000..50bf9118
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p1.cpp
@@ -0,0 +1,526 @@
+// 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
+
+
+#include "SpriteIofxParameters_0p1.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace SpriteIofxParameters_0p1NS;
+
+const char* const SpriteIofxParameters_0p1Factory::vptr =
+    NvParameterized::getVptr<SpriteIofxParameters_0p1, SpriteIofxParameters_0p1::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 4, 3, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->spriteMaterialName), NULL, 0 }, // spriteMaterialName
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(3), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(4), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool SpriteIofxParameters_0p1::mBuiltFlag = false;
+NvParameterized::MutexType SpriteIofxParameters_0p1::mBuiltFlagMutex;
+
+SpriteIofxParameters_0p1::SpriteIofxParameters_0p1(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SpriteIofxParameters_0p1FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SpriteIofxParameters_0p1::~SpriteIofxParameters_0p1()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SpriteIofxParameters_0p1::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SpriteIofxParameters_0p1();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters_0p1::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters_0p1::getParameterDefinitionTree(void) const
+{
+	SpriteIofxParameters_0p1* tmpParam = const_cast<SpriteIofxParameters_0p1*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters_0p1::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters_0p1::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SpriteIofxParameters_0p1::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SpriteIofxParameters_0p1::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void SpriteIofxParameters_0p1::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SpriteIofxParameters_0p1::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="spriteMaterialName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("spriteMaterialName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The sprite material name (if this is a sprite IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexMaterials" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 6);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 6);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		HintTable[6].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[7].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "RotationRateModifierParams", "RotationRateVsLifeModifierParams", "OrientScaleAlongScreenVelocityModifierParams" };
+		ParamDefTable[4].setRefVariantVals((const char**)RefVariantVals, 15);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		HintTable[6].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[7].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "RotationRateModifierParams", "RotationRateVsLifeModifierParams", "OrientScaleAlongScreenVelocityModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 15);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(5);
+
+		ParamDefTable[4].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SpriteIofxParameters_0p1::initStrings(void)
+{
+}
+
+void SpriteIofxParameters_0p1::initDynamicArrays(void)
+{
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void SpriteIofxParameters_0p1::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SpriteIofxParameters_0p1::initReferences(void)
+{
+	spriteMaterialName = NULL;
+
+}
+
+void SpriteIofxParameters_0p1::freeDynamicArrays(void)
+{
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void SpriteIofxParameters_0p1::freeStrings(void)
+{
+}
+
+void SpriteIofxParameters_0p1::freeReferences(void)
+{
+	if (spriteMaterialName)
+	{
+		spriteMaterialName->destroy();
+	}
+
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p2.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p2.cpp
new file mode 100644
index 00000000..629b9cb9
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p2.cpp
@@ -0,0 +1,526 @@
+// 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
+
+
+#include "SpriteIofxParameters_0p2.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace SpriteIofxParameters_0p2NS;
+
+const char* const SpriteIofxParameters_0p2Factory::vptr =
+    NvParameterized::getVptr<SpriteIofxParameters_0p2, SpriteIofxParameters_0p2::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 4, 3, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->spriteMaterialName), NULL, 0 }, // spriteMaterialName
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(3), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(4), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool SpriteIofxParameters_0p2::mBuiltFlag = false;
+NvParameterized::MutexType SpriteIofxParameters_0p2::mBuiltFlagMutex;
+
+SpriteIofxParameters_0p2::SpriteIofxParameters_0p2(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SpriteIofxParameters_0p2FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SpriteIofxParameters_0p2::~SpriteIofxParameters_0p2()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SpriteIofxParameters_0p2::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SpriteIofxParameters_0p2();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters_0p2::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters_0p2::getParameterDefinitionTree(void) const
+{
+	SpriteIofxParameters_0p2* tmpParam = const_cast<SpriteIofxParameters_0p2*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters_0p2::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters_0p2::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SpriteIofxParameters_0p2::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SpriteIofxParameters_0p2::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void SpriteIofxParameters_0p2::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SpriteIofxParameters_0p2::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="spriteMaterialName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("spriteMaterialName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The sprite material name (if this is a sprite IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexMaterials" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 7);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 7);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		HintTable[6].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[7].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "RotationRateModifierParams", "RotationRateVsLifeModifierParams", "OrientScaleAlongScreenVelocityModifierParams" };
+		ParamDefTable[4].setRefVariantVals((const char**)RefVariantVals, 15);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		HintTable[6].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[7].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "RotationRateModifierParams", "RotationRateVsLifeModifierParams", "OrientScaleAlongScreenVelocityModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 15);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(5);
+
+		ParamDefTable[4].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SpriteIofxParameters_0p2::initStrings(void)
+{
+}
+
+void SpriteIofxParameters_0p2::initDynamicArrays(void)
+{
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void SpriteIofxParameters_0p2::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SpriteIofxParameters_0p2::initReferences(void)
+{
+	spriteMaterialName = NULL;
+
+}
+
+void SpriteIofxParameters_0p2::freeDynamicArrays(void)
+{
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void SpriteIofxParameters_0p2::freeStrings(void)
+{
+}
+
+void SpriteIofxParameters_0p2::freeReferences(void)
+{
+	if (spriteMaterialName)
+	{
+		spriteMaterialName->destroy();
+	}
+
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p3.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p3.cpp
new file mode 100644
index 00000000..93af26e1
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p3.cpp
@@ -0,0 +1,526 @@
+// 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
+
+
+#include "SpriteIofxParameters_0p3.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace SpriteIofxParameters_0p3NS;
+
+const char* const SpriteIofxParameters_0p3Factory::vptr =
+    NvParameterized::getVptr<SpriteIofxParameters_0p3, SpriteIofxParameters_0p3::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 4, 3, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->spriteMaterialName), NULL, 0 }, // spriteMaterialName
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(3), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(4), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool SpriteIofxParameters_0p3::mBuiltFlag = false;
+NvParameterized::MutexType SpriteIofxParameters_0p3::mBuiltFlagMutex;
+
+SpriteIofxParameters_0p3::SpriteIofxParameters_0p3(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SpriteIofxParameters_0p3FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SpriteIofxParameters_0p3::~SpriteIofxParameters_0p3()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SpriteIofxParameters_0p3::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SpriteIofxParameters_0p3();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters_0p3::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters_0p3::getParameterDefinitionTree(void) const
+{
+	SpriteIofxParameters_0p3* tmpParam = const_cast<SpriteIofxParameters_0p3*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters_0p3::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters_0p3::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SpriteIofxParameters_0p3::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SpriteIofxParameters_0p3::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void SpriteIofxParameters_0p3::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SpriteIofxParameters_0p3::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="spriteMaterialName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("spriteMaterialName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The sprite material name (if this is a sprite IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexMaterials" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 7);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 7);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		HintTable[6].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[7].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "RotationRateModifierParams", "RotationRateVsLifeModifierParams", "OrientScaleAlongScreenVelocityModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[4].setRefVariantVals((const char**)RefVariantVals, 16);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[6];
+		static Hint* HintPtrTable[6] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 6);
+
+#else
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("INCLUDED", uint64_t(1), true);
+		HintTable[6].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[7].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsCameraDistanceModifierParams", "RotationRateModifierParams", "RotationRateVsLifeModifierParams", "OrientScaleAlongScreenVelocityModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 16);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(5);
+
+		ParamDefTable[4].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SpriteIofxParameters_0p3::initStrings(void)
+{
+}
+
+void SpriteIofxParameters_0p3::initDynamicArrays(void)
+{
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void SpriteIofxParameters_0p3::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SpriteIofxParameters_0p3::initReferences(void)
+{
+	spriteMaterialName = NULL;
+
+}
+
+void SpriteIofxParameters_0p3::freeDynamicArrays(void)
+{
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void SpriteIofxParameters_0p3::freeStrings(void)
+{
+}
+
+void SpriteIofxParameters_0p3::freeReferences(void)
+{
+	if (spriteMaterialName)
+	{
+		spriteMaterialName->destroy();
+	}
+
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p4.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p4.cpp
new file mode 100644
index 00000000..ac6214eb
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/SpriteIofxParameters_0p4.cpp
@@ -0,0 +1,534 @@
+// 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
+
+
+#include "SpriteIofxParameters_0p4.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace SpriteIofxParameters_0p4NS;
+
+const char* const SpriteIofxParameters_0p4Factory::vptr =
+    NvParameterized::getVptr<SpriteIofxParameters_0p4, SpriteIofxParameters_0p4::ClassAlignment>();
+
+const uint32_t NumParamDefs = 6;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 4, 3, 5,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 3 },
+	{ TYPE_REF, false, (size_t)(&((ParametersStruct*)0)->spriteMaterialName), NULL, 0 }, // spriteMaterialName
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->spawnModifierList), CHILDREN(3), 1 }, // spawnModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // spawnModifierList[]
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->continuousModifierList), CHILDREN(4), 1 }, // continuousModifierList
+	{ TYPE_REF, false, 1 * sizeof(NvParameterized::Interface*), NULL, 0 }, // continuousModifierList[]
+};
+
+
+bool SpriteIofxParameters_0p4::mBuiltFlag = false;
+NvParameterized::MutexType SpriteIofxParameters_0p4::mBuiltFlagMutex;
+
+SpriteIofxParameters_0p4::SpriteIofxParameters_0p4(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SpriteIofxParameters_0p4FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SpriteIofxParameters_0p4::~SpriteIofxParameters_0p4()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SpriteIofxParameters_0p4::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SpriteIofxParameters_0p4();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters_0p4::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SpriteIofxParameters_0p4::getParameterDefinitionTree(void) const
+{
+	SpriteIofxParameters_0p4* tmpParam = const_cast<SpriteIofxParameters_0p4*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters_0p4::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SpriteIofxParameters_0p4::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SpriteIofxParameters_0p4::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SpriteIofxParameters_0p4::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+/* [0] - spawnModifierList (not an array of structs) */
+/* [0] - continuousModifierList (not an array of structs) */
+
+void SpriteIofxParameters_0p4::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SpriteIofxParameters_0p4::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="spriteMaterialName"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("spriteMaterialName", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "The sprite material name (if this is a sprite IOFX)", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ApexMaterials" };
+		ParamDefTable[1].setRefVariantVals((const char**)RefVariantVals, 1);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="spawnModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("spawnModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[2].setRefVariantVals((const char**)RefVariantVals, 7);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="spawnModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("spawnModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[4];
+		static Hint* HintPtrTable[4] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("INCLUDED", uint64_t(1), true);
+		HintTable[2].init("longDescription", "These modifiers are applied to the instanced objects at object creation. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[3].init("shortDescription", "Spawn modifier list", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 4);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "SimpleScaleModifierParams", "RandomScaleModifierParams", "InitialColorModifierParams", "RandomSubtextureModifierParams", "RandomRotationModifierParams", "ColorVsLifeModifierParams", "ScaleByMassModifierParams" };
+		ParamDefTable[3].setRefVariantVals((const char**)RefVariantVals, 7);
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="continuousModifierList"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("continuousModifierList", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "ColorVsTemperatureModifierParams", true);
+		HintTable[6].init("HIDE_CLASS7", "ScaleVsTemperatureModifierParams", true);
+		HintTable[7].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#else
+
+		static HintImpl HintTable[10];
+		static Hint* HintPtrTable[10] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], &HintTable[8], &HintTable[9], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "ColorVsTemperatureModifierParams", true);
+		HintTable[6].init("HIDE_CLASS7", "ScaleVsTemperatureModifierParams", true);
+		HintTable[7].init("INCLUDED", uint64_t(1), true);
+		HintTable[8].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[9].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 10);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ColorVsTemperatureCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsTemperature2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ColorVsTemperatureModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsTemperatureModifierParams", "ScaleVsCameraDistanceModifierParams", "RotationRateModifierParams", "RotationRateVsLifeModifierParams", "OrientScaleAlongScreenVelocityModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[4].setRefVariantVals((const char**)RefVariantVals, 20);
+
+
+		ParamDef->setArraySize(-1);
+		static const uint8_t dynHandleIndices[1] = { 0, };
+		ParamDef->setDynamicHandleIndicesMap(dynHandleIndices, 1);
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=5, longName="continuousModifierList[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[5];
+		ParamDef->init("continuousModifierList", TYPE_REF, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[8];
+		static Hint* HintPtrTable[8] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "ColorVsTemperatureModifierParams", true);
+		HintTable[6].init("HIDE_CLASS7", "ScaleVsTemperatureModifierParams", true);
+		HintTable[7].init("INCLUDED", uint64_t(1), true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 8);
+
+#else
+
+		static HintImpl HintTable[10];
+		static Hint* HintPtrTable[10] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], &HintTable[7], &HintTable[8], &HintTable[9], };
+		HintTable[0].init("HIDE_CLASS1", "ColorVsLifeModifierParams", true);
+		HintTable[1].init("HIDE_CLASS2", "ColorVsDensityModifierParams", true);
+		HintTable[2].init("HIDE_CLASS3", "ScaleVsCameraDistanceModifierParams", true);
+		HintTable[3].init("HIDE_CLASS4", "ScaleVsDensityModifierParams", true);
+		HintTable[4].init("HIDE_CLASS5", "ScaleVsLifeModifierParams", true);
+		HintTable[5].init("HIDE_CLASS6", "ColorVsTemperatureModifierParams", true);
+		HintTable[6].init("HIDE_CLASS7", "ScaleVsTemperatureModifierParams", true);
+		HintTable[7].init("INCLUDED", uint64_t(1), true);
+		HintTable[8].init("longDescription", "These modifiers are applied to the instanced objects every frame. (Currently RotationModifierParams is unsupported for sprites)", true);
+		HintTable[9].init("shortDescription", "Continuous modifier list", true);
+		ParamDefTable[5].setHints((const NvParameterized::Hint**)HintPtrTable, 10);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+		static const char* const RefVariantVals[] = { "ColorVsLifeCompositeModifierParams", "ColorVsDensityCompositeModifierParams", "ColorVsTemperatureCompositeModifierParams", "ScaleVsLife2DModifierParams", "ScaleVsDensity2DModifierParams", "ScaleVsTemperature2DModifierParams", "ScaleVsCameraDistance2DModifierParams", "SubtextureVsLifeModifierParams", "ViewDirectionSortingModifierParams", "ColorVsLifeModifierParams", "ColorVsDensityModifierParams", "ColorVsTemperatureModifierParams", "ScaleVsLifeModifierParams", "ScaleVsDensityModifierParams", "ScaleVsTemperatureModifierParams", "ScaleVsCameraDistanceModifierParams", "RotationRateModifierParams", "RotationRateVsLifeModifierParams", "OrientScaleAlongScreenVelocityModifierParams", "ColorVsVelocityCompositeModifierParams" };
+		ParamDefTable[5].setRefVariantVals((const char**)RefVariantVals, 20);
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[3];
+		Children[0] = PDEF_PTR(1);
+		Children[1] = PDEF_PTR(2);
+		Children[2] = PDEF_PTR(4);
+
+		ParamDefTable[0].setChildren(Children, 3);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="spawnModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(3);
+
+		ParamDefTable[2].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=4, longName="continuousModifierList"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(5);
+
+		ParamDefTable[4].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SpriteIofxParameters_0p4::initStrings(void)
+{
+}
+
+void SpriteIofxParameters_0p4::initDynamicArrays(void)
+{
+	spawnModifierList.buf = NULL;
+	spawnModifierList.isAllocated = true;
+	spawnModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	spawnModifierList.arraySizes[0] = 0;
+	continuousModifierList.buf = NULL;
+	continuousModifierList.isAllocated = true;
+	continuousModifierList.elementSize = sizeof(NvParameterized::Interface*);
+	continuousModifierList.arraySizes[0] = 0;
+}
+
+void SpriteIofxParameters_0p4::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SpriteIofxParameters_0p4::initReferences(void)
+{
+	spriteMaterialName = NULL;
+
+}
+
+void SpriteIofxParameters_0p4::freeDynamicArrays(void)
+{
+	if (spawnModifierList.isAllocated && spawnModifierList.buf)
+	{
+		mParameterizedTraits->free(spawnModifierList.buf);
+	}
+	if (continuousModifierList.isAllocated && continuousModifierList.buf)
+	{
+		mParameterizedTraits->free(continuousModifierList.buf);
+	}
+}
+
+void SpriteIofxParameters_0p4::freeStrings(void)
+{
+}
+
+void SpriteIofxParameters_0p4::freeReferences(void)
+{
+	if (spriteMaterialName)
+	{
+		spriteMaterialName->destroy();
+	}
+
+
+	for (int i = 0; i < spawnModifierList.arraySizes[0]; ++i)
+	{
+		if (spawnModifierList.buf[i])
+		{
+			spawnModifierList.buf[i]->destroy();
+		}
+	}
+
+	for (int i = 0; i < continuousModifierList.arraySizes[0]; ++i)
+	{
+		if (continuousModifierList.buf[i])
+		{
+			continuousModifierList.buf[i]->destroy();
+		}
+	}
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/SubtextureVsLifeModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/SubtextureVsLifeModifierParams_0p0.cpp
new file mode 100644
index 00000000..8b2cd794
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/SubtextureVsLifeModifierParams_0p0.cpp
@@ -0,0 +1,449 @@
+// 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
+
+
+#include "SubtextureVsLifeModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace SubtextureVsLifeModifierParams_0p0NS;
+
+const char* const SubtextureVsLifeModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<SubtextureVsLifeModifierParams_0p0, SubtextureVsLifeModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 5;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1, 2, 3, 4,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ARRAY, true, (size_t)(&((ParametersStruct*)0)->controlPoints), CHILDREN(1), 1 }, // controlPoints
+	{ TYPE_STRUCT, false, 1 * sizeof(vec2_Type), CHILDREN(2), 2 }, // controlPoints[]
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->x), NULL, 0 }, // controlPoints[].x
+	{ TYPE_F32, false, (size_t)(&((vec2_Type*)0)->y), NULL, 0 }, // controlPoints[].y
+};
+
+
+bool SubtextureVsLifeModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType SubtextureVsLifeModifierParams_0p0::mBuiltFlagMutex;
+
+SubtextureVsLifeModifierParams_0p0::SubtextureVsLifeModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &SubtextureVsLifeModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+SubtextureVsLifeModifierParams_0p0::~SubtextureVsLifeModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void SubtextureVsLifeModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~SubtextureVsLifeModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* SubtextureVsLifeModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* SubtextureVsLifeModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	SubtextureVsLifeModifierParams_0p0* tmpParam = const_cast<SubtextureVsLifeModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType SubtextureVsLifeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType SubtextureVsLifeModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void SubtextureVsLifeModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<SubtextureVsLifeModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void SubtextureVsLifeModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void SubtextureVsLifeModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "SubtextureVsLife modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="controlPoints"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("controlPoints", TYPE_ARRAY, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "SubTexture", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[4].init("shortDescription", "Control points for a curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "SubTexture", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+		ParamDef->setArraySize(-1);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=2, longName="controlPoints[]"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[2];
+		ParamDef->init("controlPoints", TYPE_STRUCT, "vec2", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[5];
+		static Hint* HintPtrTable[5] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("xAxisLabel", "Life Time", true);
+		HintTable[4].init("yAxisLabel", "SubTexture", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 5);
+
+#else
+
+		static HintImpl HintTable[7];
+		static Hint* HintPtrTable[7] = { &HintTable[0], &HintTable[1], &HintTable[2], &HintTable[3], &HintTable[4], &HintTable[5], &HintTable[6], };
+		HintTable[0].init("CURVE_X_SCALE", uint64_t(1), true);
+		HintTable[1].init("CURVE_Y_SCALE", uint64_t(16), true);
+		HintTable[2].init("editorCurve", uint64_t(1), true);
+		HintTable[3].init("longDescription", "controlPoints is a sorted list of control points for a curve. Currently, the curve is a lame\nlirp'd curve. We could add support for other curvetypes in the future, either bezier curves,\nsplines, etc.\n", true);
+		HintTable[4].init("shortDescription", "Control points for a curve", true);
+		HintTable[5].init("xAxisLabel", "Life Time", true);
+		HintTable[6].init("yAxisLabel", "SubTexture", true);
+		ParamDefTable[2].setHints((const NvParameterized::Hint**)HintPtrTable, 7);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=3, longName="controlPoints[].x"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[3];
+		ParamDef->init("x", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#else
+
+		static HintImpl HintTable[3];
+		static Hint* HintPtrTable[3] = { &HintTable[0], &HintTable[1], &HintTable[2], };
+		HintTable[0].init("max", uint64_t(1), true);
+		HintTable[1].init("min", uint64_t(0), true);
+		HintTable[2].init("shortDescription", "Life time", true);
+		ParamDefTable[3].setHints((const NvParameterized::Hint**)HintPtrTable, 3);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=4, longName="controlPoints[].y"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[4];
+		ParamDef->init("y", TYPE_F32, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "Subtexture id", true);
+		ParamDefTable[4].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=1, longName="controlPoints"
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(2);
+
+		ParamDefTable[1].setChildren(Children, 1);
+	}
+
+	// SetChildren for: nodeIndex=2, longName="controlPoints[]"
+	{
+		static Definition* Children[2];
+		Children[0] = PDEF_PTR(3);
+		Children[1] = PDEF_PTR(4);
+
+		ParamDefTable[2].setChildren(Children, 2);
+	}
+
+	mBuiltFlag = true;
+
+}
+void SubtextureVsLifeModifierParams_0p0::initStrings(void)
+{
+}
+
+void SubtextureVsLifeModifierParams_0p0::initDynamicArrays(void)
+{
+	controlPoints.buf = NULL;
+	controlPoints.isAllocated = true;
+	controlPoints.elementSize = sizeof(vec2_Type);
+	controlPoints.arraySizes[0] = 0;
+}
+
+void SubtextureVsLifeModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void SubtextureVsLifeModifierParams_0p0::initReferences(void)
+{
+}
+
+void SubtextureVsLifeModifierParams_0p0::freeDynamicArrays(void)
+{
+	if (controlPoints.isAllocated && controlPoints.buf)
+	{
+		mParameterizedTraits->free(controlPoints.buf);
+	}
+}
+
+void SubtextureVsLifeModifierParams_0p0::freeStrings(void)
+{
+}
+
+void SubtextureVsLifeModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia
diff --git a/APEX_1.4/module/iofx_legacy/src/autogen/ViewDirectionSortingModifierParams_0p0.cpp b/APEX_1.4/module/iofx_legacy/src/autogen/ViewDirectionSortingModifierParams_0p0.cpp
new file mode 100644
index 00000000..4c28b19b
--- /dev/null
+++ b/APEX_1.4/module/iofx_legacy/src/autogen/ViewDirectionSortingModifierParams_0p0.cpp
@@ -0,0 +1,326 @@
+// 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
+
+
+#include "ViewDirectionSortingModifierParams_0p0.h"
+#include <string.h>
+#include <stdlib.h>
+
+using namespace NvParameterized;
+
+namespace nvidia
+{
+namespace parameterized
+{
+
+using namespace ViewDirectionSortingModifierParams_0p0NS;
+
+const char* const ViewDirectionSortingModifierParams_0p0Factory::vptr =
+    NvParameterized::getVptr<ViewDirectionSortingModifierParams_0p0, ViewDirectionSortingModifierParams_0p0::ClassAlignment>();
+
+const uint32_t NumParamDefs = 2;
+static NvParameterized::DefinitionImpl* ParamDefTable; // now allocated in buildTree [NumParamDefs];
+
+
+static const size_t ParamLookupChildrenTable[] =
+{
+	1,
+};
+
+#define TENUM(type) nvidia::##type
+#define CHILDREN(index) &ParamLookupChildrenTable[index]
+static const NvParameterized::ParamLookupNode ParamLookupTable[NumParamDefs] =
+{
+	{ TYPE_STRUCT, false, 0, CHILDREN(0), 1 },
+	{ TYPE_ENUM, false, (size_t)(&((ParametersStruct*)0)->sortType), NULL, 0 }, // sortType
+};
+
+
+bool ViewDirectionSortingModifierParams_0p0::mBuiltFlag = false;
+NvParameterized::MutexType ViewDirectionSortingModifierParams_0p0::mBuiltFlagMutex;
+
+ViewDirectionSortingModifierParams_0p0::ViewDirectionSortingModifierParams_0p0(NvParameterized::Traits* traits, void* buf, int32_t* refCount) :
+	NvParameters(traits, buf, refCount)
+{
+	//mParameterizedTraits->registerFactory(className(), &ViewDirectionSortingModifierParams_0p0FactoryInst);
+
+	if (!buf) //Do not init data if it is inplace-deserialized
+	{
+		initDynamicArrays();
+		initStrings();
+		initReferences();
+		initDefaults();
+	}
+}
+
+ViewDirectionSortingModifierParams_0p0::~ViewDirectionSortingModifierParams_0p0()
+{
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+}
+
+void ViewDirectionSortingModifierParams_0p0::destroy()
+{
+	// We cache these fields here to avoid overwrite in destructor
+	bool doDeallocateSelf = mDoDeallocateSelf;
+	NvParameterized::Traits* traits = mParameterizedTraits;
+	int32_t* refCount = mRefCount;
+	void* buf = mBuffer;
+
+	this->~ViewDirectionSortingModifierParams_0p0();
+
+	NvParameters::destroy(this, traits, doDeallocateSelf, refCount, buf);
+}
+
+const NvParameterized::DefinitionImpl* ViewDirectionSortingModifierParams_0p0::getParameterDefinitionTree(void)
+{
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+const NvParameterized::DefinitionImpl* ViewDirectionSortingModifierParams_0p0::getParameterDefinitionTree(void) const
+{
+	ViewDirectionSortingModifierParams_0p0* tmpParam = const_cast<ViewDirectionSortingModifierParams_0p0*>(this);
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+		if (!mBuiltFlag)
+		{
+			tmpParam->buildTree();
+		}
+	}
+
+	return(&ParamDefTable[0]);
+}
+
+NvParameterized::ErrorType ViewDirectionSortingModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle) const
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+NvParameterized::ErrorType ViewDirectionSortingModifierParams_0p0::getParameterHandle(const char* long_name, Handle& handle)
+{
+	ErrorType Ret = NvParameters::getParameterHandle(long_name, handle);
+	if (Ret != ERROR_NONE)
+	{
+		return(Ret);
+	}
+
+	size_t offset;
+	void* ptr;
+
+	getVarPtr(handle, ptr, offset);
+
+	if (ptr == NULL)
+	{
+		return(ERROR_INDEX_OUT_OF_RANGE);
+	}
+
+	return(ERROR_NONE);
+}
+
+void ViewDirectionSortingModifierParams_0p0::getVarPtr(const Handle& handle, void*& ptr, size_t& offset) const
+{
+	ptr = getVarPtrHelper(&ParamLookupTable[0], const_cast<ViewDirectionSortingModifierParams_0p0::ParametersStruct*>(&parameters()), handle, offset);
+}
+
+
+/* Dynamic Handle Indices */
+
+void ViewDirectionSortingModifierParams_0p0::freeParameterDefinitionTable(NvParameterized::Traits* traits)
+{
+	if (!traits)
+	{
+		return;
+	}
+
+	if (!mBuiltFlag) // Double-checked lock
+	{
+		return;
+	}
+
+	NvParameterized::MutexType::ScopedLock lock(mBuiltFlagMutex);
+
+	if (!mBuiltFlag)
+	{
+		return;
+	}
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		ParamDefTable[i].~DefinitionImpl();
+	}
+
+	traits->free(ParamDefTable);
+
+	mBuiltFlag = false;
+}
+
+#define PDEF_PTR(index) (&ParamDefTable[index])
+
+void ViewDirectionSortingModifierParams_0p0::buildTree(void)
+{
+
+	uint32_t allocSize = sizeof(NvParameterized::DefinitionImpl) * NumParamDefs;
+	ParamDefTable = (NvParameterized::DefinitionImpl*)(mParameterizedTraits->alloc(allocSize));
+	memset(ParamDefTable, 0, allocSize);
+
+	for (uint32_t i = 0; i < NumParamDefs; ++i)
+	{
+		NV_PARAM_PLACEMENT_NEW(ParamDefTable + i, NvParameterized::DefinitionImpl)(*mParameterizedTraits);
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=0, longName=""
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[0];
+		ParamDef->init("", TYPE_STRUCT, "STRUCT", true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+#else
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("shortDescription", "ViewDirectionSorting modifier parameters", true);
+		ParamDefTable[0].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+
+
+
+
+	}
+
+	// Initialize DefinitionImpl node: nodeIndex=1, longName="sortType"
+	{
+		NvParameterized::DefinitionImpl* ParamDef = &ParamDefTable[1];
+		ParamDef->init("sortType", TYPE_ENUM, NULL, true);
+
+#ifdef NV_PARAMETERIZED_HIDE_DESCRIPTIONS
+
+		static HintImpl HintTable[1];
+		static Hint* HintPtrTable[1] = { &HintTable[0], };
+		HintTable[0].init("defaultValue", "default", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 1);
+
+#else
+
+		static HintImpl HintTable[2];
+		static Hint* HintPtrTable[2] = { &HintTable[0], &HintTable[1], };
+		HintTable[0].init("defaultValue", "default", true);
+		HintTable[1].init("shortDescription", "Sort type", true);
+		ParamDefTable[1].setHints((const NvParameterized::Hint**)HintPtrTable, 2);
+
+#endif /* NV_PARAMETERIZED_HIDE_DESCRIPTIONS */
+
+		static const char* const EnumVals[] = { "default" };
+		ParamDefTable[1].setEnumVals((const char**)EnumVals, 1);
+
+
+
+
+	}
+
+	// SetChildren for: nodeIndex=0, longName=""
+	{
+		static Definition* Children[1];
+		Children[0] = PDEF_PTR(1);
+
+		ParamDefTable[0].setChildren(Children, 1);
+	}
+
+	mBuiltFlag = true;
+
+}
+void ViewDirectionSortingModifierParams_0p0::initStrings(void)
+{
+}
+
+void ViewDirectionSortingModifierParams_0p0::initDynamicArrays(void)
+{
+}
+
+void ViewDirectionSortingModifierParams_0p0::initDefaults(void)
+{
+
+	freeStrings();
+	freeReferences();
+	freeDynamicArrays();
+	sortType = (const char*)"default";
+
+	initDynamicArrays();
+	initStrings();
+	initReferences();
+}
+
+void ViewDirectionSortingModifierParams_0p0::initReferences(void)
+{
+}
+
+void ViewDirectionSortingModifierParams_0p0::freeDynamicArrays(void)
+{
+}
+
+void ViewDirectionSortingModifierParams_0p0::freeStrings(void)
+{
+}
+
+void ViewDirectionSortingModifierParams_0p0::freeReferences(void)
+{
+}
+
+} // namespace parameterized
+} // namespace nvidia