Initial commit:

PhysX 3.4.0 Update @ 21294896
APEX 1.4.0 Update @ 21275617

[CL 21300167]

55 files changed, 12863 insertions, 0 deletions

diff --git a/APEX_1.4/module/particles_legacy/include/ConversionEffectPackageAssetParams_0p0_0p1.h b/APEX_1.4/module/particles_legacy/include/ConversionEffectPackageAssetParams_0p0_0p1.h
new file mode 100644
index 00000000..9cedd55d
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/ConversionEffectPackageAssetParams_0p0_0p1.h
@@ -0,0 +1,83 @@
+/*
+ * 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_CONVERSIONEFFECTPACKAGEASSETPARAMS_0P0_0P1H_H
+#define MODULE_CONVERSIONEFFECTPACKAGEASSETPARAMS_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "EffectPackageAssetParams_0p0.h"
+#include "EffectPackageAssetParams_0p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::EffectPackageAssetParams_0p0, 
+						nvidia::parameterized::EffectPackageAssetParams_0p1, 
+						nvidia::parameterized::EffectPackageAssetParams_0p0::ClassVersion, 
+						nvidia::parameterized::EffectPackageAssetParams_0p1::ClassVersion>
+						ConversionEffectPackageAssetParams_0p0_0p1Parent;
+
+class ConversionEffectPackageAssetParams_0p0_0p1: public ConversionEffectPackageAssetParams_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionEffectPackageAssetParams_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionEffectPackageAssetParams_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionEffectPackageAssetParams_0p0_0p1(NvParameterized::Traits* t) : ConversionEffectPackageAssetParams_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.
+		if (mNewData->LODSettings.FadeDistanceBegin > mNewData->LODSettings.FadeDistanceEnd)
+		{
+			mNewData->LODSettings.FadeDistanceBegin = mNewData->LODSettings.FadeDistanceEnd;
+		}
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/particles_legacy/include/ConversionEffectPackageDatabaseParams_0p0_0p1.h b/APEX_1.4/module/particles_legacy/include/ConversionEffectPackageDatabaseParams_0p0_0p1.h
new file mode 100644
index 00000000..ae7177b0
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/ConversionEffectPackageDatabaseParams_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_CONVERSIONEFFECTPACKAGEDATABASEPARAMS_0P0_0P1H_H
+#define MODULE_CONVERSIONEFFECTPACKAGEDATABASEPARAMS_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "EffectPackageDatabaseParams_0p0.h"
+#include "EffectPackageDatabaseParams_0p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::EffectPackageDatabaseParams_0p0, 
+						nvidia::parameterized::EffectPackageDatabaseParams_0p1, 
+						nvidia::parameterized::EffectPackageDatabaseParams_0p0::ClassVersion, 
+						nvidia::parameterized::EffectPackageDatabaseParams_0p1::ClassVersion>
+						ConversionEffectPackageDatabaseParams_0p0_0p1Parent;
+
+class ConversionEffectPackageDatabaseParams_0p0_0p1: public ConversionEffectPackageDatabaseParams_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionEffectPackageDatabaseParams_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionEffectPackageDatabaseParams_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionEffectPackageDatabaseParams_0p0_0p1(NvParameterized::Traits* t) : ConversionEffectPackageDatabaseParams_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/particles_legacy/include/ConversionGraphicsMaterialData_0p0_0p1.h b/APEX_1.4/module/particles_legacy/include/ConversionGraphicsMaterialData_0p0_0p1.h
new file mode 100644
index 00000000..0ca5bdda
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/ConversionGraphicsMaterialData_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_CONVERSIONGRAPHICSMATERIALDATA_0P0_0P1H_H
+#define MODULE_CONVERSIONGRAPHICSMATERIALDATA_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "GraphicsMaterialData_0p0.h"
+#include "GraphicsMaterialData_0p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::GraphicsMaterialData_0p0, 
+						nvidia::parameterized::GraphicsMaterialData_0p1, 
+						nvidia::parameterized::GraphicsMaterialData_0p0::ClassVersion, 
+						nvidia::parameterized::GraphicsMaterialData_0p1::ClassVersion>
+						ConversionGraphicsMaterialData_0p0_0p1Parent;
+
+class ConversionGraphicsMaterialData_0p0_0p1: public ConversionGraphicsMaterialData_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionGraphicsMaterialData_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionGraphicsMaterialData_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionGraphicsMaterialData_0p0_0p1(NvParameterized::Traits* t) : ConversionGraphicsMaterialData_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/particles_legacy/include/ConversionGraphicsMaterialData_0p1_0p2.h b/APEX_1.4/module/particles_legacy/include/ConversionGraphicsMaterialData_0p1_0p2.h
new file mode 100644
index 00000000..347be037
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/ConversionGraphicsMaterialData_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_CONVERSIONGRAPHICSMATERIALDATA_0P1_0P2H_H
+#define MODULE_CONVERSIONGRAPHICSMATERIALDATA_0P1_0P2H_H
+
+#include "NvParamConversionTemplate.h"
+#include "GraphicsMaterialData_0p1.h"
+#include "GraphicsMaterialData_0p2.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::GraphicsMaterialData_0p1, 
+						nvidia::parameterized::GraphicsMaterialData_0p2, 
+						nvidia::parameterized::GraphicsMaterialData_0p1::ClassVersion, 
+						nvidia::parameterized::GraphicsMaterialData_0p2::ClassVersion>
+						ConversionGraphicsMaterialData_0p1_0p2Parent;
+
+class ConversionGraphicsMaterialData_0p1_0p2: public ConversionGraphicsMaterialData_0p1_0p2Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionGraphicsMaterialData_0p1_0p2));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionGraphicsMaterialData_0p1_0p2)(t) : 0;
+	}
+
+protected:
+	ConversionGraphicsMaterialData_0p1_0p2(NvParameterized::Traits* t) : ConversionGraphicsMaterialData_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/particles_legacy/include/ConversionGraphicsMaterialData_0p2_0p3.h b/APEX_1.4/module/particles_legacy/include/ConversionGraphicsMaterialData_0p2_0p3.h
new file mode 100644
index 00000000..e89f6142
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/ConversionGraphicsMaterialData_0p2_0p3.h
@@ -0,0 +1,81 @@
+/*
+ * 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_CONVERSIONGRAPHICSMATERIALDATA_0P2_0P3H_H
+#define MODULE_CONVERSIONGRAPHICSMATERIALDATA_0P2_0P3H_H
+
+#include "NvParamConversionTemplate.h"
+#include "GraphicsMaterialData_0p2.h"
+#include "GraphicsMaterialData_0p3.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::GraphicsMaterialData_0p2, 
+						nvidia::parameterized::GraphicsMaterialData_0p3, 
+						nvidia::parameterized::GraphicsMaterialData_0p2::ClassVersion, 
+						nvidia::parameterized::GraphicsMaterialData_0p3::ClassVersion>
+						ConversionGraphicsMaterialData_0p2_0p3Parent;
+
+class ConversionGraphicsMaterialData_0p2_0p3: public ConversionGraphicsMaterialData_0p2_0p3Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionGraphicsMaterialData_0p2_0p3));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionGraphicsMaterialData_0p2_0p3)(t) : 0;
+	}
+
+protected:
+	ConversionGraphicsMaterialData_0p2_0p3(NvParameterized::Traits* t) : ConversionGraphicsMaterialData_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.
+		mNewData->PSM_Frustum.FrustumDepth = mLegacyData->PSM_Frustum.FrustumDistance;
+		mNewData->PSM_Frustum.FrustumSize = mLegacyData->PSM_Frustum.FrustumExtents.maxElement();
+		return true;
+	}
+};
+
+
+}
+}
+} //nvidia::apex::legacy
+
+#endif
diff --git a/APEX_1.4/module/particles_legacy/include/ConversionGraphicsMaterialData_0p3_0p4.h b/APEX_1.4/module/particles_legacy/include/ConversionGraphicsMaterialData_0p3_0p4.h
new file mode 100644
index 00000000..ccc72972
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/ConversionGraphicsMaterialData_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_CONVERSIONGRAPHICSMATERIALDATA_0P3_0P4H_H
+#define MODULE_CONVERSIONGRAPHICSMATERIALDATA_0P3_0P4H_H
+
+#include "NvParamConversionTemplate.h"
+#include "GraphicsMaterialData_0p3.h"
+#include "GraphicsMaterialData_0p4.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::GraphicsMaterialData_0p3, 
+						nvidia::parameterized::GraphicsMaterialData_0p4, 
+						nvidia::parameterized::GraphicsMaterialData_0p3::ClassVersion, 
+						nvidia::parameterized::GraphicsMaterialData_0p4::ClassVersion>
+						ConversionGraphicsMaterialData_0p3_0p4Parent;
+
+class ConversionGraphicsMaterialData_0p3_0p4: public ConversionGraphicsMaterialData_0p3_0p4Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionGraphicsMaterialData_0p3_0p4));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionGraphicsMaterialData_0p3_0p4)(t) : 0;
+	}
+
+protected:
+	ConversionGraphicsMaterialData_0p3_0p4(NvParameterized::Traits* t) : ConversionGraphicsMaterialData_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/particles_legacy/include/ConversionVolumeRenderMaterialData_0p0_0p1.h b/APEX_1.4/module/particles_legacy/include/ConversionVolumeRenderMaterialData_0p0_0p1.h
new file mode 100644
index 00000000..caf6a153
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/ConversionVolumeRenderMaterialData_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_CONVERSIONVOLUMERENDERMATERIALDATA_0P0_0P1H_H
+#define MODULE_CONVERSIONVOLUMERENDERMATERIALDATA_0P0_0P1H_H
+
+#include "NvParamConversionTemplate.h"
+#include "VolumeRenderMaterialData_0p0.h"
+#include "VolumeRenderMaterialData_0p1.h"
+
+namespace nvidia {
+namespace apex {
+namespace legacy {
+
+
+typedef NvParameterized::ParamConversionTemplate<nvidia::parameterized::VolumeRenderMaterialData_0p0, 
+						nvidia::parameterized::VolumeRenderMaterialData_0p1, 
+						nvidia::parameterized::VolumeRenderMaterialData_0p0::ClassVersion, 
+						nvidia::parameterized::VolumeRenderMaterialData_0p1::ClassVersion>
+						ConversionVolumeRenderMaterialData_0p0_0p1Parent;
+
+class ConversionVolumeRenderMaterialData_0p0_0p1: public ConversionVolumeRenderMaterialData_0p0_0p1Parent
+{
+public:
+	static NvParameterized::Conversion* Create(NvParameterized::Traits* t)
+	{
+		void* buf = t->alloc(sizeof(ConversionVolumeRenderMaterialData_0p0_0p1));
+		return buf ? PX_PLACEMENT_NEW(buf, ConversionVolumeRenderMaterialData_0p0_0p1)(t) : 0;
+	}
+
+protected:
+	ConversionVolumeRenderMaterialData_0p0_0p1(NvParameterized::Traits* t) : ConversionVolumeRenderMaterialData_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/particles_legacy/include/autogen/AttractorFieldSamplerData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/AttractorFieldSamplerData_0p0.h
new file mode 100644
index 00000000..94d130fb
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/AttractorFieldSamplerData_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_AttractorFieldSamplerData_0p0_h
+#define HEADER_AttractorFieldSamplerData_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 AttractorFieldSamplerData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* AttractorFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0xad0ce7f8, 0x2fb85c3b, 0x5bd65a2b, 0x570e1992, };
+
+} // namespace AttractorFieldSamplerData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class AttractorFieldSamplerData_0p0 : public NvParameterized::NvParameters, public AttractorFieldSamplerData_0p0NS::ParametersStruct
+{
+public:
+	AttractorFieldSamplerData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~AttractorFieldSamplerData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("AttractorFieldSamplerData");
+	}
+
+	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(AttractorFieldSamplerData_0p0NS::checksum);
+		return AttractorFieldSamplerData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const AttractorFieldSamplerData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		AttractorFieldSamplerData_0p0* tmpThis = const_cast<AttractorFieldSamplerData_0p0*>(this);
+		return *(static_cast<AttractorFieldSamplerData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	AttractorFieldSamplerData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<AttractorFieldSamplerData_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 AttractorFieldSamplerData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		AttractorFieldSamplerData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(AttractorFieldSamplerData_0p0), AttractorFieldSamplerData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, AttractorFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFieldSamplerData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(AttractorFieldSamplerData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, AttractorFieldSamplerData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, AttractorFieldSamplerData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, AttractorFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFieldSamplerData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of AttractorFieldSamplerData_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 (AttractorFieldSamplerData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (AttractorFieldSamplerData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (AttractorFieldSamplerData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (AttractorFieldSamplerData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (AttractorFieldSamplerData_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/particles_legacy/include/autogen/AttractorFieldSamplerEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/AttractorFieldSamplerEffect_0p0.h
new file mode 100644
index 00000000..f1b50e23
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/AttractorFieldSamplerEffect_0p0.h
@@ -0,0 +1,291 @@
+// 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_AttractorFieldSamplerEffect_0p0_h
+#define HEADER_AttractorFieldSamplerEffect_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 AttractorFieldSamplerEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* AttractorFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x360b5cf0, 0x2facb742, 0x97891fde, 0xc949869a, };
+
+} // namespace AttractorFieldSamplerEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class AttractorFieldSamplerEffect_0p0 : public NvParameterized::NvParameters, public AttractorFieldSamplerEffect_0p0NS::ParametersStruct
+{
+public:
+	AttractorFieldSamplerEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~AttractorFieldSamplerEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("AttractorFieldSamplerEffect");
+	}
+
+	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(AttractorFieldSamplerEffect_0p0NS::checksum);
+		return AttractorFieldSamplerEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const AttractorFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		AttractorFieldSamplerEffect_0p0* tmpThis = const_cast<AttractorFieldSamplerEffect_0p0*>(this);
+		return *(static_cast<AttractorFieldSamplerEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	AttractorFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<AttractorFieldSamplerEffect_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 AttractorFieldSamplerEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		AttractorFieldSamplerEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(AttractorFieldSamplerEffect_0p0), AttractorFieldSamplerEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, AttractorFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFieldSamplerEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(AttractorFieldSamplerEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, AttractorFieldSamplerEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, AttractorFieldSamplerEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, AttractorFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class AttractorFieldSamplerEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of AttractorFieldSamplerEffect_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 (AttractorFieldSamplerEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (AttractorFieldSamplerEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (AttractorFieldSamplerEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (AttractorFieldSamplerEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (AttractorFieldSamplerEffect_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/particles_legacy/include/autogen/EffectPackageActorParams_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageActorParams_0p0.h
new file mode 100644
index 00000000..1ff0d0e9
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageActorParams_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_EffectPackageActorParams_0p0_h
+#define HEADER_EffectPackageActorParams_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 EffectPackageActorParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	physx::PxTransform InitialPose;
+	float objectScale;
+	bool Enabled;
+
+};
+
+static const uint32_t checksum[] = { 0xb5e9f529, 0x94a2ff3d, 0x5955c2b8, 0x14b06ba4, };
+
+} // namespace EffectPackageActorParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageActorParams_0p0 : public NvParameterized::NvParameters, public EffectPackageActorParams_0p0NS::ParametersStruct
+{
+public:
+	EffectPackageActorParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageActorParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageActorParams");
+	}
+
+	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(EffectPackageActorParams_0p0NS::checksum);
+		return EffectPackageActorParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageActorParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageActorParams_0p0* tmpThis = const_cast<EffectPackageActorParams_0p0*>(this);
+		return *(static_cast<EffectPackageActorParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageActorParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageActorParams_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 EffectPackageActorParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageActorParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageActorParams_0p0), EffectPackageActorParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageActorParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageActorParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageActorParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageActorParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageActorParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageActorParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageActorParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageActorParams_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 (EffectPackageActorParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageActorParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageActorParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageActorParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageActorParams_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/particles_legacy/include/autogen/EffectPackageAssetParams_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageAssetParams_0p0.h
new file mode 100644
index 00000000..56d9e378
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageAssetParams_0p0.h
@@ -0,0 +1,297 @@
+// 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_EffectPackageAssetParams_0p0_h
+#define HEADER_EffectPackageAssetParams_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 EffectPackageAssetParams_0p0NS
+{
+
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct LevelOfDetailSettings_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_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 ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct LevelOfDetailSettings_Type
+{
+	bool UniqueRenderVolume;
+	float FadeDistanceBegin;
+	float FadeDistanceEnd;
+	bool RandomizeEmitterRate;
+	float FadeOutRate;
+	bool CullByDistance;
+	bool CullOffScreen;
+	float OffScreenCullTime;
+	float NonVisibleDeleteTime;
+	float ScreenCullSize;
+	float ScreenCullDistance;
+	bool FadeEmitterRate;
+	bool FadeAttractorFieldStrength;
+	bool FadeJetFieldStrength;
+	bool FadeTurbulenceVelocity;
+	bool FadeTurbulenceNoise;
+	bool FadeTurbulenceExternalVelocity;
+	bool FadeTurbulenceVelocityWeight;
+	bool FadeHeatSourceTemperature;
+	bool FadeForceFieldStrength;
+	bool FadeForceFieldScale;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+
+struct ParametersStruct
+{
+
+	LevelOfDetailSettings_Type LODSettings;
+	EffectPath_Type Path;
+	REF_DynamicArray1D_Type Effects;
+
+};
+
+static const uint32_t checksum[] = { 0x320fe537, 0x995086b2, 0xdf05d741, 0x2afa43ec, };
+
+} // namespace EffectPackageAssetParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageAssetParams_0p0 : public NvParameterized::NvParameters, public EffectPackageAssetParams_0p0NS::ParametersStruct
+{
+public:
+	EffectPackageAssetParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageAssetParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageAssetParams");
+	}
+
+	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(EffectPackageAssetParams_0p0NS::checksum);
+		return EffectPackageAssetParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageAssetParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageAssetParams_0p0* tmpThis = const_cast<EffectPackageAssetParams_0p0*>(this);
+		return *(static_cast<EffectPackageAssetParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageAssetParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageAssetParams_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 EffectPackageAssetParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageAssetParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageAssetParams_0p0), EffectPackageAssetParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageAssetParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageAssetParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageAssetParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageAssetParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageAssetParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageAssetParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageAssetParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageAssetParams_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 (EffectPackageAssetParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageAssetParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageAssetParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageAssetParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageAssetParams_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/particles_legacy/include/autogen/EffectPackageAssetParams_0p1.h b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageAssetParams_0p1.h
new file mode 100644
index 00000000..6805064f
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageAssetParams_0p1.h
@@ -0,0 +1,298 @@
+// 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_EffectPackageAssetParams_0p1_h
+#define HEADER_EffectPackageAssetParams_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 EffectPackageAssetParams_0p1NS
+{
+
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct LevelOfDetailSettings_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_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 ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct LevelOfDetailSettings_Type
+{
+	bool UniqueRenderVolume;
+	float FadeDistanceBegin;
+	float FadeDistanceEnd;
+	bool RandomizeEmitterRate;
+	float FadeOutRate;
+	bool CullByDistance;
+	bool CullOffScreen;
+	float OffScreenCullTime;
+	float NonVisibleDeleteTime;
+	float ScreenCullSize;
+	float ScreenCullDistance;
+	bool FadeEmitterRate;
+	bool FadeAttractorFieldStrength;
+	bool FadeJetFieldStrength;
+	bool FadeTurbulenceVelocity;
+	bool FadeTurbulenceNoise;
+	bool FadeTurbulenceExternalVelocity;
+	bool FadeTurbulenceVelocityWeight;
+	bool FadeHeatSourceTemperature;
+	bool FadeForceFieldStrength;
+	bool FadeForceFieldScale;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+
+struct ParametersStruct
+{
+
+	LevelOfDetailSettings_Type LODSettings;
+	EffectPath_Type Path;
+	REF_DynamicArray1D_Type Effects;
+	NvParameterized::DummyStringStruct toolString;
+
+};
+
+static const uint32_t checksum[] = { 0xef0b8c61, 0x1da5d55a, 0x9ec764f1, 0x3f67f392, };
+
+} // namespace EffectPackageAssetParams_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageAssetParams_0p1 : public NvParameterized::NvParameters, public EffectPackageAssetParams_0p1NS::ParametersStruct
+{
+public:
+	EffectPackageAssetParams_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageAssetParams_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageAssetParams");
+	}
+
+	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(EffectPackageAssetParams_0p1NS::checksum);
+		return EffectPackageAssetParams_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageAssetParams_0p1NS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageAssetParams_0p1* tmpThis = const_cast<EffectPackageAssetParams_0p1*>(this);
+		return *(static_cast<EffectPackageAssetParams_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageAssetParams_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageAssetParams_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 EffectPackageAssetParams_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageAssetParams_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageAssetParams_0p1), EffectPackageAssetParams_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageAssetParams_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageAssetParams_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageAssetParams_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageAssetParams_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageAssetParams_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageAssetParams_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageAssetParams_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageAssetParams_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 (EffectPackageAssetParams_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageAssetParams_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageAssetParams_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageAssetParams_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageAssetParams_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/particles_legacy/include/autogen/EffectPackageData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageData_0p0.h
new file mode 100644
index 00000000..9bf100ea
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageData_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_EffectPackageData_0p0_h
+#define HEADER_EffectPackageData_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 EffectPackageData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* EffectPackage;
+
+};
+
+static const uint32_t checksum[] = { 0x5f619c90, 0xacc5a650, 0x66393099, 0x47b4a900, };
+
+} // namespace EffectPackageData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageData_0p0 : public NvParameterized::NvParameters, public EffectPackageData_0p0NS::ParametersStruct
+{
+public:
+	EffectPackageData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageData");
+	}
+
+	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(EffectPackageData_0p0NS::checksum);
+		return EffectPackageData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageData_0p0* tmpThis = const_cast<EffectPackageData_0p0*>(this);
+		return *(static_cast<EffectPackageData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageData_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 EffectPackageData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageData_0p0), EffectPackageData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageData_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 (EffectPackageData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageData_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/particles_legacy/include/autogen/EffectPackageDatabaseParams_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageDatabaseParams_0p0.h
new file mode 100644
index 00000000..605a8f4a
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageDatabaseParams_0p0.h
@@ -0,0 +1,238 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_EffectPackageDatabaseParams_0p0_h
+#define HEADER_EffectPackageDatabaseParams_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 EffectPackageDatabaseParams_0p0NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type EffectPackages;
+
+};
+
+static const uint32_t checksum[] = { 0x9296c122, 0x62de9b42, 0xf6b4d904, 0xe8cf3bf7, };
+
+} // namespace EffectPackageDatabaseParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageDatabaseParams_0p0 : public NvParameterized::NvParameters, public EffectPackageDatabaseParams_0p0NS::ParametersStruct
+{
+public:
+	EffectPackageDatabaseParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageDatabaseParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageDatabaseParams");
+	}
+
+	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(EffectPackageDatabaseParams_0p0NS::checksum);
+		return EffectPackageDatabaseParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageDatabaseParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageDatabaseParams_0p0* tmpThis = const_cast<EffectPackageDatabaseParams_0p0*>(this);
+		return *(static_cast<EffectPackageDatabaseParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageDatabaseParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageDatabaseParams_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 EffectPackageDatabaseParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageDatabaseParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageDatabaseParams_0p0), EffectPackageDatabaseParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageDatabaseParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageDatabaseParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageDatabaseParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageDatabaseParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageDatabaseParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageDatabaseParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageDatabaseParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageDatabaseParams_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 (EffectPackageDatabaseParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageDatabaseParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageDatabaseParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageDatabaseParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageDatabaseParams_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/particles_legacy/include/autogen/EffectPackageDatabaseParams_0p1.h b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageDatabaseParams_0p1.h
new file mode 100644
index 00000000..98e5897b
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageDatabaseParams_0p1.h
@@ -0,0 +1,238 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_EffectPackageDatabaseParams_0p1_h
+#define HEADER_EffectPackageDatabaseParams_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 EffectPackageDatabaseParams_0p1NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type EffectPackages;
+
+};
+
+static const uint32_t checksum[] = { 0xce64f369, 0x2fc860a4, 0x3c19c701, 0xcc66c5b3, };
+
+} // namespace EffectPackageDatabaseParams_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageDatabaseParams_0p1 : public NvParameterized::NvParameters, public EffectPackageDatabaseParams_0p1NS::ParametersStruct
+{
+public:
+	EffectPackageDatabaseParams_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageDatabaseParams_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageDatabaseParams");
+	}
+
+	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(EffectPackageDatabaseParams_0p1NS::checksum);
+		return EffectPackageDatabaseParams_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageDatabaseParams_0p1NS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageDatabaseParams_0p1* tmpThis = const_cast<EffectPackageDatabaseParams_0p1*>(this);
+		return *(static_cast<EffectPackageDatabaseParams_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageDatabaseParams_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageDatabaseParams_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 EffectPackageDatabaseParams_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageDatabaseParams_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageDatabaseParams_0p1), EffectPackageDatabaseParams_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageDatabaseParams_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageDatabaseParams_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageDatabaseParams_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageDatabaseParams_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageDatabaseParams_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageDatabaseParams_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageDatabaseParams_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageDatabaseParams_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 (EffectPackageDatabaseParams_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageDatabaseParams_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageDatabaseParams_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageDatabaseParams_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageDatabaseParams_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/particles_legacy/include/autogen/EffectPackageEmitterDatabaseParams_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageEmitterDatabaseParams_0p0.h
new file mode 100644
index 00000000..00ce1552
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageEmitterDatabaseParams_0p0.h
@@ -0,0 +1,238 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_EffectPackageEmitterDatabaseParams_0p0_h
+#define HEADER_EffectPackageEmitterDatabaseParams_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 EffectPackageEmitterDatabaseParams_0p0NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type Emitters;
+
+};
+
+static const uint32_t checksum[] = { 0x03542e55, 0x98562f65, 0x397b5760, 0xc62eb3f2, };
+
+} // namespace EffectPackageEmitterDatabaseParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageEmitterDatabaseParams_0p0 : public NvParameterized::NvParameters, public EffectPackageEmitterDatabaseParams_0p0NS::ParametersStruct
+{
+public:
+	EffectPackageEmitterDatabaseParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageEmitterDatabaseParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageEmitterDatabaseParams");
+	}
+
+	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(EffectPackageEmitterDatabaseParams_0p0NS::checksum);
+		return EffectPackageEmitterDatabaseParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageEmitterDatabaseParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageEmitterDatabaseParams_0p0* tmpThis = const_cast<EffectPackageEmitterDatabaseParams_0p0*>(this);
+		return *(static_cast<EffectPackageEmitterDatabaseParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageEmitterDatabaseParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageEmitterDatabaseParams_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 EffectPackageEmitterDatabaseParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageEmitterDatabaseParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageEmitterDatabaseParams_0p0), EffectPackageEmitterDatabaseParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageEmitterDatabaseParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageEmitterDatabaseParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageEmitterDatabaseParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageEmitterDatabaseParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageEmitterDatabaseParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageEmitterDatabaseParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageEmitterDatabaseParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageEmitterDatabaseParams_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 (EffectPackageEmitterDatabaseParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageEmitterDatabaseParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageEmitterDatabaseParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageEmitterDatabaseParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageEmitterDatabaseParams_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/particles_legacy/include/autogen/EffectPackageFieldSamplerDatabaseParams_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageFieldSamplerDatabaseParams_0p0.h
new file mode 100644
index 00000000..0c66354b
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageFieldSamplerDatabaseParams_0p0.h
@@ -0,0 +1,238 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_EffectPackageFieldSamplerDatabaseParams_0p0_h
+#define HEADER_EffectPackageFieldSamplerDatabaseParams_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 EffectPackageFieldSamplerDatabaseParams_0p0NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type FieldSamplers;
+
+};
+
+static const uint32_t checksum[] = { 0x25f62eeb, 0xf4cccc87, 0xdcd32c61, 0x8fe20316, };
+
+} // namespace EffectPackageFieldSamplerDatabaseParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageFieldSamplerDatabaseParams_0p0 : public NvParameterized::NvParameters, public EffectPackageFieldSamplerDatabaseParams_0p0NS::ParametersStruct
+{
+public:
+	EffectPackageFieldSamplerDatabaseParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageFieldSamplerDatabaseParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageFieldSamplerDatabaseParams");
+	}
+
+	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(EffectPackageFieldSamplerDatabaseParams_0p0NS::checksum);
+		return EffectPackageFieldSamplerDatabaseParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageFieldSamplerDatabaseParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageFieldSamplerDatabaseParams_0p0* tmpThis = const_cast<EffectPackageFieldSamplerDatabaseParams_0p0*>(this);
+		return *(static_cast<EffectPackageFieldSamplerDatabaseParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageFieldSamplerDatabaseParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageFieldSamplerDatabaseParams_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 EffectPackageFieldSamplerDatabaseParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageFieldSamplerDatabaseParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageFieldSamplerDatabaseParams_0p0), EffectPackageFieldSamplerDatabaseParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageFieldSamplerDatabaseParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageFieldSamplerDatabaseParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageFieldSamplerDatabaseParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageFieldSamplerDatabaseParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageFieldSamplerDatabaseParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageFieldSamplerDatabaseParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageFieldSamplerDatabaseParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageFieldSamplerDatabaseParams_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 (EffectPackageFieldSamplerDatabaseParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageFieldSamplerDatabaseParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageFieldSamplerDatabaseParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageFieldSamplerDatabaseParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageFieldSamplerDatabaseParams_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/particles_legacy/include/autogen/EffectPackageGraphicsMaterialsParams_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageGraphicsMaterialsParams_0p0.h
new file mode 100644
index 00000000..18f1963a
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageGraphicsMaterialsParams_0p0.h
@@ -0,0 +1,238 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_EffectPackageGraphicsMaterialsParams_0p0_h
+#define HEADER_EffectPackageGraphicsMaterialsParams_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 EffectPackageGraphicsMaterialsParams_0p0NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type GraphicsMaterials;
+
+};
+
+static const uint32_t checksum[] = { 0x2d879f87, 0x7b8f475b, 0xd42bfe31, 0x27efcd68, };
+
+} // namespace EffectPackageGraphicsMaterialsParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageGraphicsMaterialsParams_0p0 : public NvParameterized::NvParameters, public EffectPackageGraphicsMaterialsParams_0p0NS::ParametersStruct
+{
+public:
+	EffectPackageGraphicsMaterialsParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageGraphicsMaterialsParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageGraphicsMaterialsParams");
+	}
+
+	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(EffectPackageGraphicsMaterialsParams_0p0NS::checksum);
+		return EffectPackageGraphicsMaterialsParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageGraphicsMaterialsParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageGraphicsMaterialsParams_0p0* tmpThis = const_cast<EffectPackageGraphicsMaterialsParams_0p0*>(this);
+		return *(static_cast<EffectPackageGraphicsMaterialsParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageGraphicsMaterialsParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageGraphicsMaterialsParams_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 EffectPackageGraphicsMaterialsParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageGraphicsMaterialsParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageGraphicsMaterialsParams_0p0), EffectPackageGraphicsMaterialsParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageGraphicsMaterialsParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageGraphicsMaterialsParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageGraphicsMaterialsParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageGraphicsMaterialsParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageGraphicsMaterialsParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageGraphicsMaterialsParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageGraphicsMaterialsParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageGraphicsMaterialsParams_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 (EffectPackageGraphicsMaterialsParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageGraphicsMaterialsParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageGraphicsMaterialsParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageGraphicsMaterialsParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageGraphicsMaterialsParams_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/particles_legacy/include/autogen/EffectPackageIOFXDatabaseParams_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageIOFXDatabaseParams_0p0.h
new file mode 100644
index 00000000..c8347756
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageIOFXDatabaseParams_0p0.h
@@ -0,0 +1,238 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_EffectPackageIOFXDatabaseParams_0p0_h
+#define HEADER_EffectPackageIOFXDatabaseParams_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 EffectPackageIOFXDatabaseParams_0p0NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type GraphicsEffects;
+
+};
+
+static const uint32_t checksum[] = { 0x012bd755, 0x3845c426, 0x155f44aa, 0xeba55527, };
+
+} // namespace EffectPackageIOFXDatabaseParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageIOFXDatabaseParams_0p0 : public NvParameterized::NvParameters, public EffectPackageIOFXDatabaseParams_0p0NS::ParametersStruct
+{
+public:
+	EffectPackageIOFXDatabaseParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageIOFXDatabaseParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageIOFXDatabaseParams");
+	}
+
+	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(EffectPackageIOFXDatabaseParams_0p0NS::checksum);
+		return EffectPackageIOFXDatabaseParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageIOFXDatabaseParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageIOFXDatabaseParams_0p0* tmpThis = const_cast<EffectPackageIOFXDatabaseParams_0p0*>(this);
+		return *(static_cast<EffectPackageIOFXDatabaseParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageIOFXDatabaseParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageIOFXDatabaseParams_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 EffectPackageIOFXDatabaseParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageIOFXDatabaseParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageIOFXDatabaseParams_0p0), EffectPackageIOFXDatabaseParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageIOFXDatabaseParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageIOFXDatabaseParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageIOFXDatabaseParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageIOFXDatabaseParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageIOFXDatabaseParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageIOFXDatabaseParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageIOFXDatabaseParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageIOFXDatabaseParams_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 (EffectPackageIOFXDatabaseParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageIOFXDatabaseParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageIOFXDatabaseParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageIOFXDatabaseParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageIOFXDatabaseParams_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/particles_legacy/include/autogen/EffectPackageIOSDatabaseParams_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageIOSDatabaseParams_0p0.h
new file mode 100644
index 00000000..c4e92d77
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EffectPackageIOSDatabaseParams_0p0.h
@@ -0,0 +1,238 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_EffectPackageIOSDatabaseParams_0p0_h
+#define HEADER_EffectPackageIOSDatabaseParams_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 EffectPackageIOSDatabaseParams_0p0NS
+{
+
+
+struct REF_DynamicArray1D_Type
+{
+	NvParameterized::Interface** buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+
+struct ParametersStruct
+{
+
+	REF_DynamicArray1D_Type ParticleSimulations;
+
+};
+
+static const uint32_t checksum[] = { 0x82cbc94b, 0xb6f4c8a5, 0x5a46ce63, 0x4663e5ca, };
+
+} // namespace EffectPackageIOSDatabaseParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EffectPackageIOSDatabaseParams_0p0 : public NvParameterized::NvParameters, public EffectPackageIOSDatabaseParams_0p0NS::ParametersStruct
+{
+public:
+	EffectPackageIOSDatabaseParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EffectPackageIOSDatabaseParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EffectPackageIOSDatabaseParams");
+	}
+
+	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(EffectPackageIOSDatabaseParams_0p0NS::checksum);
+		return EffectPackageIOSDatabaseParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EffectPackageIOSDatabaseParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		EffectPackageIOSDatabaseParams_0p0* tmpThis = const_cast<EffectPackageIOSDatabaseParams_0p0*>(this);
+		return *(static_cast<EffectPackageIOSDatabaseParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	EffectPackageIOSDatabaseParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EffectPackageIOSDatabaseParams_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 EffectPackageIOSDatabaseParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EffectPackageIOSDatabaseParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EffectPackageIOSDatabaseParams_0p0), EffectPackageIOSDatabaseParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EffectPackageIOSDatabaseParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageIOSDatabaseParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EffectPackageIOSDatabaseParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EffectPackageIOSDatabaseParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EffectPackageIOSDatabaseParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EffectPackageIOSDatabaseParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EffectPackageIOSDatabaseParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EffectPackageIOSDatabaseParams_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 (EffectPackageIOSDatabaseParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EffectPackageIOSDatabaseParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EffectPackageIOSDatabaseParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EffectPackageIOSDatabaseParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EffectPackageIOSDatabaseParams_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/particles_legacy/include/autogen/EmitterData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/EmitterData_0p0.h
new file mode 100644
index 00000000..07849c6d
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EmitterData_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_EmitterData_0p0_h
+#define HEADER_EmitterData_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 EmitterData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* Emitter;
+
+};
+
+static const uint32_t checksum[] = { 0xeb7077c8, 0xa36b4a9f, 0x9095c1de, 0xc60abbf7, };
+
+} // namespace EmitterData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterData_0p0 : public NvParameterized::NvParameters, public EmitterData_0p0NS::ParametersStruct
+{
+public:
+	EmitterData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterData");
+	}
+
+	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(EmitterData_0p0NS::checksum);
+		return EmitterData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		EmitterData_0p0* tmpThis = const_cast<EmitterData_0p0*>(this);
+		return *(static_cast<EmitterData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterData_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 EmitterData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterData_0p0), EmitterData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterData_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 (EmitterData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterData_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/particles_legacy/include/autogen/EmitterEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/EmitterEffect_0p0.h
new file mode 100644
index 00000000..674dad09
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/EmitterEffect_0p0.h
@@ -0,0 +1,307 @@
+// 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_EmitterEffect_0p0_h
+#define HEADER_EmitterEffect_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 EmitterEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+struct EmitterVelocityAdjust_Type;
+struct EmitterVelocityProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct EmitterVelocityAdjust_Type
+{
+	bool AdjustEnabled;
+	float VelocityLow;
+	float VelocityHigh;
+	float LowValue;
+	float HighValue;
+};
+struct EmitterVelocityProperties_Type
+{
+	EmitterVelocityAdjust_Type AdjustLifetime;
+	EmitterVelocityAdjust_Type AdjustEmitterRate;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	EmitterVelocityProperties_Type EmitterVelocityChanges;
+	NvParameterized::Interface* Emitter;
+
+};
+
+static const uint32_t checksum[] = { 0x6625c413, 0xed57cae4, 0x3c9d8836, 0xf4105a87, };
+
+} // namespace EmitterEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class EmitterEffect_0p0 : public NvParameterized::NvParameters, public EmitterEffect_0p0NS::ParametersStruct
+{
+public:
+	EmitterEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~EmitterEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("EmitterEffect");
+	}
+
+	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(EmitterEffect_0p0NS::checksum);
+		return EmitterEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const EmitterEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		EmitterEffect_0p0* tmpThis = const_cast<EmitterEffect_0p0*>(this);
+		return *(static_cast<EmitterEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	EmitterEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<EmitterEffect_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 EmitterEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		EmitterEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(EmitterEffect_0p0), EmitterEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, EmitterEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(EmitterEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, EmitterEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, EmitterEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, EmitterEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class EmitterEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of EmitterEffect_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 (EmitterEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (EmitterEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (EmitterEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (EmitterEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (EmitterEffect_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/particles_legacy/include/autogen/FlameEmitterData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/FlameEmitterData_0p0.h
new file mode 100644
index 00000000..3f0122fb
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/FlameEmitterData_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_FlameEmitterData_0p0_h
+#define HEADER_FlameEmitterData_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 FlameEmitterData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* FlameEmitter;
+
+};
+
+static const uint32_t checksum[] = { 0x90a03422, 0x50c8e759, 0xf9df589f, 0x56836e65, };
+
+} // namespace FlameEmitterData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class FlameEmitterData_0p0 : public NvParameterized::NvParameters, public FlameEmitterData_0p0NS::ParametersStruct
+{
+public:
+	FlameEmitterData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~FlameEmitterData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("FlameEmitterData");
+	}
+
+	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(FlameEmitterData_0p0NS::checksum);
+		return FlameEmitterData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const FlameEmitterData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		FlameEmitterData_0p0* tmpThis = const_cast<FlameEmitterData_0p0*>(this);
+		return *(static_cast<FlameEmitterData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	FlameEmitterData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<FlameEmitterData_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 FlameEmitterData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		FlameEmitterData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(FlameEmitterData_0p0), FlameEmitterData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, FlameEmitterData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class FlameEmitterData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(FlameEmitterData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, FlameEmitterData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, FlameEmitterData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, FlameEmitterData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class FlameEmitterData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of FlameEmitterData_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 (FlameEmitterData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (FlameEmitterData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (FlameEmitterData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (FlameEmitterData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (FlameEmitterData_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/particles_legacy/include/autogen/FlameEmitterEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/FlameEmitterEffect_0p0.h
new file mode 100644
index 00000000..45de5ca3
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/FlameEmitterEffect_0p0.h
@@ -0,0 +1,291 @@
+// 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_FlameEmitterEffect_0p0_h
+#define HEADER_FlameEmitterEffect_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 FlameEmitterEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* FlameEmitter;
+
+};
+
+static const uint32_t checksum[] = { 0xb3b9f3eb, 0xe8fbc19a, 0xb1474af1, 0xf5ede5b6, };
+
+} // namespace FlameEmitterEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class FlameEmitterEffect_0p0 : public NvParameterized::NvParameters, public FlameEmitterEffect_0p0NS::ParametersStruct
+{
+public:
+	FlameEmitterEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~FlameEmitterEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("FlameEmitterEffect");
+	}
+
+	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(FlameEmitterEffect_0p0NS::checksum);
+		return FlameEmitterEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const FlameEmitterEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		FlameEmitterEffect_0p0* tmpThis = const_cast<FlameEmitterEffect_0p0*>(this);
+		return *(static_cast<FlameEmitterEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	FlameEmitterEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<FlameEmitterEffect_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 FlameEmitterEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		FlameEmitterEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(FlameEmitterEffect_0p0), FlameEmitterEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, FlameEmitterEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class FlameEmitterEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(FlameEmitterEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, FlameEmitterEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, FlameEmitterEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, FlameEmitterEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class FlameEmitterEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of FlameEmitterEffect_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 (FlameEmitterEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (FlameEmitterEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (FlameEmitterEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (FlameEmitterEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (FlameEmitterEffect_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/particles_legacy/include/autogen/ForceFieldData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/ForceFieldData_0p0.h
new file mode 100644
index 00000000..56a50d5a
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/ForceFieldData_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_ForceFieldData_0p0_h
+#define HEADER_ForceFieldData_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 ForceFieldData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* ForceField;
+
+};
+
+static const uint32_t checksum[] = { 0x0c7aa318, 0x555a616b, 0x584651f3, 0xec048707, };
+
+} // namespace ForceFieldData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ForceFieldData_0p0 : public NvParameterized::NvParameters, public ForceFieldData_0p0NS::ParametersStruct
+{
+public:
+	ForceFieldData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ForceFieldData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ForceFieldData");
+	}
+
+	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(ForceFieldData_0p0NS::checksum);
+		return ForceFieldData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ForceFieldData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ForceFieldData_0p0* tmpThis = const_cast<ForceFieldData_0p0*>(this);
+		return *(static_cast<ForceFieldData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ForceFieldData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ForceFieldData_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 ForceFieldData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ForceFieldData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ForceFieldData_0p0), ForceFieldData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ForceFieldData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ForceFieldData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ForceFieldData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ForceFieldData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ForceFieldData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ForceFieldData_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 (ForceFieldData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ForceFieldData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ForceFieldData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ForceFieldData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ForceFieldData_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/particles_legacy/include/autogen/ForceFieldEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/ForceFieldEffect_0p0.h
new file mode 100644
index 00000000..760f13b2
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/ForceFieldEffect_0p0.h
@@ -0,0 +1,291 @@
+// 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_ForceFieldEffect_0p0_h
+#define HEADER_ForceFieldEffect_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 ForceFieldEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* ForceField;
+
+};
+
+static const uint32_t checksum[] = { 0x2b5fd898, 0x8edc0468, 0x993e03e6, 0x7223fc69, };
+
+} // namespace ForceFieldEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ForceFieldEffect_0p0 : public NvParameterized::NvParameters, public ForceFieldEffect_0p0NS::ParametersStruct
+{
+public:
+	ForceFieldEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ForceFieldEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ForceFieldEffect");
+	}
+
+	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(ForceFieldEffect_0p0NS::checksum);
+		return ForceFieldEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ForceFieldEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ForceFieldEffect_0p0* tmpThis = const_cast<ForceFieldEffect_0p0*>(this);
+		return *(static_cast<ForceFieldEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ForceFieldEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ForceFieldEffect_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 ForceFieldEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ForceFieldEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ForceFieldEffect_0p0), ForceFieldEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ForceFieldEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ForceFieldEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ForceFieldEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ForceFieldEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ForceFieldEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ForceFieldEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ForceFieldEffect_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 (ForceFieldEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ForceFieldEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ForceFieldEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ForceFieldEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ForceFieldEffect_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/particles_legacy/include/autogen/GraphicsEffectData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsEffectData_0p0.h
new file mode 100644
index 00000000..ff452827
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsEffectData_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_GraphicsEffectData_0p0_h
+#define HEADER_GraphicsEffectData_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 GraphicsEffectData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* IOFX;
+
+};
+
+static const uint32_t checksum[] = { 0xe35d59af, 0xb5a73c73, 0x8c86843a, 0x40cac44d, };
+
+} // namespace GraphicsEffectData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class GraphicsEffectData_0p0 : public NvParameterized::NvParameters, public GraphicsEffectData_0p0NS::ParametersStruct
+{
+public:
+	GraphicsEffectData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~GraphicsEffectData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("GraphicsEffectData");
+	}
+
+	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(GraphicsEffectData_0p0NS::checksum);
+		return GraphicsEffectData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const GraphicsEffectData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		GraphicsEffectData_0p0* tmpThis = const_cast<GraphicsEffectData_0p0*>(this);
+		return *(static_cast<GraphicsEffectData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	GraphicsEffectData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<GraphicsEffectData_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 GraphicsEffectData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		GraphicsEffectData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(GraphicsEffectData_0p0), GraphicsEffectData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, GraphicsEffectData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsEffectData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(GraphicsEffectData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, GraphicsEffectData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, GraphicsEffectData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, GraphicsEffectData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsEffectData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of GraphicsEffectData_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 (GraphicsEffectData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (GraphicsEffectData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (GraphicsEffectData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (GraphicsEffectData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (GraphicsEffectData_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/particles_legacy/include/autogen/GraphicsMaterialData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsMaterialData_0p0.h
new file mode 100644
index 00000000..4134003f
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsMaterialData_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_GraphicsMaterialData_0p0_h
+#define HEADER_GraphicsMaterialData_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 GraphicsMaterialData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::DummyStringStruct ApplicationMaterialName;
+	NvParameterized::DummyStringStruct UserProperties;
+	const char* RenderTechnique;
+	NvParameterized::DummyStringStruct DiffuseTexture;
+	uint32_t CellColumn;
+	uint32_t CellRow;
+	uint32_t CellCount;
+	bool CrossBlend;
+	float ColorMultiplier;
+	bool UsePSM;
+	const char* Resolution;
+	uint32_t FullResPercent;
+	uint32_t HalfResPercent;
+	float PSM_ShadowBias;
+
+};
+
+static const uint32_t checksum[] = { 0xe6fa2a97, 0x37b7d4f4, 0xed45f7e2, 0x7c4154ac, };
+
+} // namespace GraphicsMaterialData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class GraphicsMaterialData_0p0 : public NvParameterized::NvParameters, public GraphicsMaterialData_0p0NS::ParametersStruct
+{
+public:
+	GraphicsMaterialData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~GraphicsMaterialData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("GraphicsMaterialData");
+	}
+
+	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(GraphicsMaterialData_0p0NS::checksum);
+		return GraphicsMaterialData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const GraphicsMaterialData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		GraphicsMaterialData_0p0* tmpThis = const_cast<GraphicsMaterialData_0p0*>(this);
+		return *(static_cast<GraphicsMaterialData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	GraphicsMaterialData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<GraphicsMaterialData_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 GraphicsMaterialData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		GraphicsMaterialData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(GraphicsMaterialData_0p0), GraphicsMaterialData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, GraphicsMaterialData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(GraphicsMaterialData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, GraphicsMaterialData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, GraphicsMaterialData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, GraphicsMaterialData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of GraphicsMaterialData_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 (GraphicsMaterialData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (GraphicsMaterialData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (GraphicsMaterialData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (GraphicsMaterialData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (GraphicsMaterialData_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/particles_legacy/include/autogen/GraphicsMaterialData_0p1.h b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsMaterialData_0p1.h
new file mode 100644
index 00000000..ed95f955
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsMaterialData_0p1.h
@@ -0,0 +1,250 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_GraphicsMaterialData_0p1_h
+#define HEADER_GraphicsMaterialData_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 GraphicsMaterialData_0p1NS
+{
+
+struct FrustumPSM_Type;
+
+struct FrustumPSM_Type
+{
+	bool OrthographicProjection;
+};
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::DummyStringStruct ApplicationMaterialName;
+	NvParameterized::DummyStringStruct UserProperties;
+	const char* RenderTechnique;
+	NvParameterized::DummyStringStruct DiffuseTexture;
+	uint32_t CellColumn;
+	uint32_t CellRow;
+	uint32_t CellCount;
+	bool CrossBlend;
+	float ColorMultiplier;
+	bool UsePSM;
+	const char* Resolution;
+	uint32_t FullResPercent;
+	uint32_t HalfResPercent;
+	float PSM_ShadowBias;
+	FrustumPSM_Type PSM_Frustum;
+
+};
+
+static const uint32_t checksum[] = { 0x71f8d641, 0x37867c93, 0xcda4836e, 0x9f884be3, };
+
+} // namespace GraphicsMaterialData_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class GraphicsMaterialData_0p1 : public NvParameterized::NvParameters, public GraphicsMaterialData_0p1NS::ParametersStruct
+{
+public:
+	GraphicsMaterialData_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~GraphicsMaterialData_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("GraphicsMaterialData");
+	}
+
+	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(GraphicsMaterialData_0p1NS::checksum);
+		return GraphicsMaterialData_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const GraphicsMaterialData_0p1NS::ParametersStruct& parameters(void) const
+	{
+		GraphicsMaterialData_0p1* tmpThis = const_cast<GraphicsMaterialData_0p1*>(this);
+		return *(static_cast<GraphicsMaterialData_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	GraphicsMaterialData_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<GraphicsMaterialData_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 GraphicsMaterialData_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		GraphicsMaterialData_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(GraphicsMaterialData_0p1), GraphicsMaterialData_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, GraphicsMaterialData_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(GraphicsMaterialData_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, GraphicsMaterialData_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, GraphicsMaterialData_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, GraphicsMaterialData_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of GraphicsMaterialData_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 (GraphicsMaterialData_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (GraphicsMaterialData_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (GraphicsMaterialData_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (GraphicsMaterialData_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (GraphicsMaterialData_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/particles_legacy/include/autogen/GraphicsMaterialData_0p2.h b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsMaterialData_0p2.h
new file mode 100644
index 00000000..1d6ecb28
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsMaterialData_0p2.h
@@ -0,0 +1,253 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_GraphicsMaterialData_0p2_h
+#define HEADER_GraphicsMaterialData_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 GraphicsMaterialData_0p2NS
+{
+
+struct FrustumPSM_Type;
+
+struct FrustumPSM_Type
+{
+	bool ShowFrustum;
+	bool OrthographicProjection;
+	float FrustumDistance;
+	physx::PxVec3 FrustumExtents;
+};
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::DummyStringStruct ApplicationMaterialName;
+	NvParameterized::DummyStringStruct UserProperties;
+	const char* RenderTechnique;
+	NvParameterized::DummyStringStruct DiffuseTexture;
+	uint32_t CellColumn;
+	uint32_t CellRow;
+	uint32_t CellCount;
+	bool CrossBlend;
+	float ColorMultiplier;
+	bool UsePSM;
+	const char* Resolution;
+	uint32_t FullResPercent;
+	uint32_t HalfResPercent;
+	float PSM_ShadowBias;
+	FrustumPSM_Type PSM_Frustum;
+
+};
+
+static const uint32_t checksum[] = { 0x231adc7c, 0x1c73422c, 0x46bf3eb3, 0xfa3556c5, };
+
+} // namespace GraphicsMaterialData_0p2NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class GraphicsMaterialData_0p2 : public NvParameterized::NvParameters, public GraphicsMaterialData_0p2NS::ParametersStruct
+{
+public:
+	GraphicsMaterialData_0p2(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~GraphicsMaterialData_0p2();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("GraphicsMaterialData");
+	}
+
+	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(GraphicsMaterialData_0p2NS::checksum);
+		return GraphicsMaterialData_0p2NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const GraphicsMaterialData_0p2NS::ParametersStruct& parameters(void) const
+	{
+		GraphicsMaterialData_0p2* tmpThis = const_cast<GraphicsMaterialData_0p2*>(this);
+		return *(static_cast<GraphicsMaterialData_0p2NS::ParametersStruct*>(tmpThis));
+	}
+
+	GraphicsMaterialData_0p2NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<GraphicsMaterialData_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 GraphicsMaterialData_0p2Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		GraphicsMaterialData_0p2::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(GraphicsMaterialData_0p2), GraphicsMaterialData_0p2::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, GraphicsMaterialData_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData_0p2");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(GraphicsMaterialData_0p2)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, GraphicsMaterialData_0p2)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, GraphicsMaterialData_0p2::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, GraphicsMaterialData_0p2::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData_0p2");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of GraphicsMaterialData_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 (GraphicsMaterialData_0p2*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (GraphicsMaterialData_0p2::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (GraphicsMaterialData_0p2::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (GraphicsMaterialData_0p2::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (GraphicsMaterialData_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/particles_legacy/include/autogen/GraphicsMaterialData_0p3.h b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsMaterialData_0p3.h
new file mode 100644
index 00000000..1cc0cdb5
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsMaterialData_0p3.h
@@ -0,0 +1,252 @@
+// 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_GraphicsMaterialData_0p3_h
+#define HEADER_GraphicsMaterialData_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 GraphicsMaterialData_0p3NS
+{
+
+struct FrustumPSM_Type;
+
+struct FrustumPSM_Type
+{
+	bool ShowFrustum;
+	float FrustumDepth;
+	float FrustumSize;
+};
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::DummyStringStruct ApplicationMaterialName;
+	NvParameterized::DummyStringStruct UserProperties;
+	const char* RenderTechnique;
+	NvParameterized::DummyStringStruct DiffuseTexture;
+	uint32_t CellColumn;
+	uint32_t CellRow;
+	uint32_t CellCount;
+	bool CrossBlend;
+	float ColorMultiplier;
+	bool UsePSM;
+	const char* Resolution;
+	uint32_t FullResPercent;
+	uint32_t HalfResPercent;
+	float PSM_ShadowBias;
+	FrustumPSM_Type PSM_Frustum;
+
+};
+
+static const uint32_t checksum[] = { 0x7c317f89, 0x6aa9180f, 0xe048842e, 0xf50c5c30, };
+
+} // namespace GraphicsMaterialData_0p3NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class GraphicsMaterialData_0p3 : public NvParameterized::NvParameters, public GraphicsMaterialData_0p3NS::ParametersStruct
+{
+public:
+	GraphicsMaterialData_0p3(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~GraphicsMaterialData_0p3();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("GraphicsMaterialData");
+	}
+
+	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(GraphicsMaterialData_0p3NS::checksum);
+		return GraphicsMaterialData_0p3NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const GraphicsMaterialData_0p3NS::ParametersStruct& parameters(void) const
+	{
+		GraphicsMaterialData_0p3* tmpThis = const_cast<GraphicsMaterialData_0p3*>(this);
+		return *(static_cast<GraphicsMaterialData_0p3NS::ParametersStruct*>(tmpThis));
+	}
+
+	GraphicsMaterialData_0p3NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<GraphicsMaterialData_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 GraphicsMaterialData_0p3Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		GraphicsMaterialData_0p3::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(GraphicsMaterialData_0p3), GraphicsMaterialData_0p3::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, GraphicsMaterialData_0p3::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData_0p3");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(GraphicsMaterialData_0p3)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, GraphicsMaterialData_0p3)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, GraphicsMaterialData_0p3::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, GraphicsMaterialData_0p3::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData_0p3");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of GraphicsMaterialData_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 (GraphicsMaterialData_0p3*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (GraphicsMaterialData_0p3::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (GraphicsMaterialData_0p3::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (GraphicsMaterialData_0p3::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (GraphicsMaterialData_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/particles_legacy/include/autogen/GraphicsMaterialData_0p4.h b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsMaterialData_0p4.h
new file mode 100644
index 00000000..5b66268f
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/GraphicsMaterialData_0p4.h
@@ -0,0 +1,252 @@
+// 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_GraphicsMaterialData_0p4_h
+#define HEADER_GraphicsMaterialData_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 GraphicsMaterialData_0p4NS
+{
+
+struct FrustumPSM_Type;
+
+struct FrustumPSM_Type
+{
+	bool ShowFrustum;
+	float FrustumDepth;
+	float FrustumSize;
+};
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::DummyStringStruct ApplicationMaterialName;
+	NvParameterized::DummyStringStruct UserProperties;
+	const char* RenderTechnique;
+	NvParameterized::DummyStringStruct DiffuseTexture;
+	uint32_t CellColumn;
+	uint32_t CellRow;
+	uint32_t CellCount;
+	bool CrossBlend;
+	float ColorMultiplier;
+	bool UsePSM;
+	const char* Resolution;
+	uint32_t FullResPercent;
+	uint32_t HalfResPercent;
+	float PSM_ShadowBias;
+	FrustumPSM_Type PSM_Frustum;
+
+};
+
+static const uint32_t checksum[] = { 0xbf6d3670, 0xa7e5523c, 0xb276fd23, 0x81d15eb6, };
+
+} // namespace GraphicsMaterialData_0p4NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class GraphicsMaterialData_0p4 : public NvParameterized::NvParameters, public GraphicsMaterialData_0p4NS::ParametersStruct
+{
+public:
+	GraphicsMaterialData_0p4(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~GraphicsMaterialData_0p4();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("GraphicsMaterialData");
+	}
+
+	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(GraphicsMaterialData_0p4NS::checksum);
+		return GraphicsMaterialData_0p4NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const GraphicsMaterialData_0p4NS::ParametersStruct& parameters(void) const
+	{
+		GraphicsMaterialData_0p4* tmpThis = const_cast<GraphicsMaterialData_0p4*>(this);
+		return *(static_cast<GraphicsMaterialData_0p4NS::ParametersStruct*>(tmpThis));
+	}
+
+	GraphicsMaterialData_0p4NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<GraphicsMaterialData_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 GraphicsMaterialData_0p4Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		GraphicsMaterialData_0p4::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(GraphicsMaterialData_0p4), GraphicsMaterialData_0p4::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, GraphicsMaterialData_0p4::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData_0p4");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(GraphicsMaterialData_0p4)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, GraphicsMaterialData_0p4)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, GraphicsMaterialData_0p4::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, GraphicsMaterialData_0p4::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class GraphicsMaterialData_0p4");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of GraphicsMaterialData_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 (GraphicsMaterialData_0p4*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (GraphicsMaterialData_0p4::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (GraphicsMaterialData_0p4::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (GraphicsMaterialData_0p4::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (GraphicsMaterialData_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/particles_legacy/include/autogen/HeatSourceData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/HeatSourceData_0p0.h
new file mode 100644
index 00000000..0bce524c
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/HeatSourceData_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_HeatSourceData_0p0_h
+#define HEADER_HeatSourceData_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 HeatSourceData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* HeatSource;
+
+};
+
+static const uint32_t checksum[] = { 0x95cb6853, 0x83e850af, 0xe32f27b8, 0xc0ec3b33, };
+
+} // namespace HeatSourceData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class HeatSourceData_0p0 : public NvParameterized::NvParameters, public HeatSourceData_0p0NS::ParametersStruct
+{
+public:
+	HeatSourceData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~HeatSourceData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("HeatSourceData");
+	}
+
+	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(HeatSourceData_0p0NS::checksum);
+		return HeatSourceData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const HeatSourceData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		HeatSourceData_0p0* tmpThis = const_cast<HeatSourceData_0p0*>(this);
+		return *(static_cast<HeatSourceData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	HeatSourceData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<HeatSourceData_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 HeatSourceData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		HeatSourceData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(HeatSourceData_0p0), HeatSourceData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, HeatSourceData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class HeatSourceData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(HeatSourceData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, HeatSourceData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, HeatSourceData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, HeatSourceData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class HeatSourceData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of HeatSourceData_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 (HeatSourceData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (HeatSourceData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (HeatSourceData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (HeatSourceData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (HeatSourceData_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/particles_legacy/include/autogen/HeatSourceEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/HeatSourceEffect_0p0.h
new file mode 100644
index 00000000..c2c1b58e
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/HeatSourceEffect_0p0.h
@@ -0,0 +1,291 @@
+// 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_HeatSourceEffect_0p0_h
+#define HEADER_HeatSourceEffect_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 HeatSourceEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* HeatSource;
+
+};
+
+static const uint32_t checksum[] = { 0x36c6c535, 0xacde2d3c, 0x02d6822e, 0x61a889a1, };
+
+} // namespace HeatSourceEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class HeatSourceEffect_0p0 : public NvParameterized::NvParameters, public HeatSourceEffect_0p0NS::ParametersStruct
+{
+public:
+	HeatSourceEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~HeatSourceEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("HeatSourceEffect");
+	}
+
+	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(HeatSourceEffect_0p0NS::checksum);
+		return HeatSourceEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const HeatSourceEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		HeatSourceEffect_0p0* tmpThis = const_cast<HeatSourceEffect_0p0*>(this);
+		return *(static_cast<HeatSourceEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	HeatSourceEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<HeatSourceEffect_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 HeatSourceEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		HeatSourceEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(HeatSourceEffect_0p0), HeatSourceEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, HeatSourceEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class HeatSourceEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(HeatSourceEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, HeatSourceEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, HeatSourceEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, HeatSourceEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class HeatSourceEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of HeatSourceEffect_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 (HeatSourceEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (HeatSourceEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (HeatSourceEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (HeatSourceEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (HeatSourceEffect_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/particles_legacy/include/autogen/JetFieldSamplerData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/JetFieldSamplerData_0p0.h
new file mode 100644
index 00000000..afdab9e7
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/JetFieldSamplerData_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_JetFieldSamplerData_0p0_h
+#define HEADER_JetFieldSamplerData_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 JetFieldSamplerData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* JetFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x03f96027, 0x2e12817c, 0xbde0a2fa, 0xc47c7a9d, };
+
+} // namespace JetFieldSamplerData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class JetFieldSamplerData_0p0 : public NvParameterized::NvParameters, public JetFieldSamplerData_0p0NS::ParametersStruct
+{
+public:
+	JetFieldSamplerData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~JetFieldSamplerData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("JetFieldSamplerData");
+	}
+
+	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(JetFieldSamplerData_0p0NS::checksum);
+		return JetFieldSamplerData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const JetFieldSamplerData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		JetFieldSamplerData_0p0* tmpThis = const_cast<JetFieldSamplerData_0p0*>(this);
+		return *(static_cast<JetFieldSamplerData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	JetFieldSamplerData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<JetFieldSamplerData_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 JetFieldSamplerData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		JetFieldSamplerData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(JetFieldSamplerData_0p0), JetFieldSamplerData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, JetFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFieldSamplerData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(JetFieldSamplerData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, JetFieldSamplerData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, JetFieldSamplerData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, JetFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFieldSamplerData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of JetFieldSamplerData_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 (JetFieldSamplerData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (JetFieldSamplerData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (JetFieldSamplerData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (JetFieldSamplerData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (JetFieldSamplerData_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/particles_legacy/include/autogen/JetFieldSamplerEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/JetFieldSamplerEffect_0p0.h
new file mode 100644
index 00000000..d6e89b45
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/JetFieldSamplerEffect_0p0.h
@@ -0,0 +1,291 @@
+// 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_JetFieldSamplerEffect_0p0_h
+#define HEADER_JetFieldSamplerEffect_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 JetFieldSamplerEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* JetFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x7b0238b8, 0xac56941a, 0x7b0fd303, 0x27182e77, };
+
+} // namespace JetFieldSamplerEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class JetFieldSamplerEffect_0p0 : public NvParameterized::NvParameters, public JetFieldSamplerEffect_0p0NS::ParametersStruct
+{
+public:
+	JetFieldSamplerEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~JetFieldSamplerEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("JetFieldSamplerEffect");
+	}
+
+	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(JetFieldSamplerEffect_0p0NS::checksum);
+		return JetFieldSamplerEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const JetFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		JetFieldSamplerEffect_0p0* tmpThis = const_cast<JetFieldSamplerEffect_0p0*>(this);
+		return *(static_cast<JetFieldSamplerEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	JetFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<JetFieldSamplerEffect_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 JetFieldSamplerEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		JetFieldSamplerEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(JetFieldSamplerEffect_0p0), JetFieldSamplerEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, JetFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFieldSamplerEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(JetFieldSamplerEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, JetFieldSamplerEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, JetFieldSamplerEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, JetFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class JetFieldSamplerEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of JetFieldSamplerEffect_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 (JetFieldSamplerEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (JetFieldSamplerEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (JetFieldSamplerEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (JetFieldSamplerEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (JetFieldSamplerEffect_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/particles_legacy/include/autogen/ModuleParticlesLegacyRegistration.h b/APEX_1.4/module/particles_legacy/include/autogen/ModuleParticlesLegacyRegistration.h
new file mode 100644
index 00000000..c4ff4f6d
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/ModuleParticlesLegacyRegistration.h
@@ -0,0 +1,300 @@
+/*
+ * 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_MODULEPARTICLESLEGACYREGISTRATIONH_H
+#define MODULE_MODULEPARTICLESLEGACYREGISTRATIONH_H
+
+#include "PsAllocator.h"
+#include "NvRegistrationsForTraitsBase.h"
+#include "nvparameterized/NvParameterizedTraits.h"
+#include "PxAssert.h"
+#include <stdint.h>
+
+// INCLUDE GENERATED FACTORIES
+#include "EffectPackageAssetParams_0p0.h"
+#include "EffectPackageAssetParams_0p1.h"
+#include "EffectPackageDatabaseParams_0p0.h"
+#include "GraphicsMaterialData_0p0.h"
+#include "GraphicsMaterialData_0p1.h"
+#include "GraphicsMaterialData_0p2.h"
+#include "GraphicsMaterialData_0p3.h"
+#include "VolumeRenderMaterialData_0p0.h"
+#include "EffectPackageActorParams_0p0.h"
+#include "EffectPackageAssetParams_0p1.h"
+#include "HeatSourceEffect_0p0.h"
+#include "EmitterEffect_0p0.h"
+#include "ForceFieldEffect_0p0.h"
+#include "TurbulenceFieldSamplerEffect_0p0.h"
+#include "AttractorFieldSamplerEffect_0p0.h"
+#include "JetFieldSamplerEffect_0p0.h"
+#include "NoiseFieldSamplerEffect_0p0.h"
+#include "VortexFieldSamplerEffect_0p0.h"
+#include "SubstanceSourceEffect_0p0.h"
+#include "WindFieldSamplerEffect_0p0.h"
+#include "RigidBodyEffect_0p0.h"
+#include "VelocitySourceEffect_0p0.h"
+#include "FlameEmitterEffect_0p0.h"
+#include "EffectPackageDatabaseParams_0p1.h"
+#include "EffectPackageData_0p0.h"
+#include "ParticlesDebugRenderParams_0p0.h"
+#include "EffectPackageEmitterDatabaseParams_0p0.h"
+#include "EmitterData_0p0.h"
+#include "EffectPackageFieldSamplerDatabaseParams_0p0.h"
+#include "AttractorFieldSamplerData_0p0.h"
+#include "HeatSourceData_0p0.h"
+#include "JetFieldSamplerData_0p0.h"
+#include "TurbulenceFieldSamplerData_0p0.h"
+#include "ForceFieldData_0p0.h"
+#include "NoiseFieldSamplerData_0p0.h"
+#include "VortexFieldSamplerData_0p0.h"
+#include "SubstanceSourceData_0p0.h"
+#include "WindFieldSamplerData_0p0.h"
+#include "VelocitySourceData_0p0.h"
+#include "FlameEmitterData_0p0.h"
+#include "EffectPackageGraphicsMaterialsParams_0p0.h"
+#include "GraphicsMaterialData_0p4.h"
+#include "VolumeRenderMaterialData_0p1.h"
+#include "EffectPackageIOFXDatabaseParams_0p0.h"
+#include "GraphicsEffectData_0p0.h"
+#include "EffectPackageIOSDatabaseParams_0p0.h"
+#include "ParticleSimulationData_0p0.h"
+#include "ParticlesModuleParameters_0p0.h"
+
+
+// INCLUDE GENERATED CONVERSION
+#include "ConversionEffectPackageAssetParams_0p0_0p1.h"
+#include "ConversionEffectPackageDatabaseParams_0p0_0p1.h"
+#include "ConversionGraphicsMaterialData_0p0_0p1.h"
+#include "ConversionGraphicsMaterialData_0p1_0p2.h"
+#include "ConversionGraphicsMaterialData_0p2_0p3.h"
+#include "ConversionGraphicsMaterialData_0p3_0p4.h"
+#include "ConversionVolumeRenderMaterialData_0p0_0p1.h"
+
+
+// global namespace
+
+class ModuleParticlesLegacyRegistration : public NvParameterized::RegistrationsForTraitsBase
+{
+public:
+	static void invokeRegistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleParticlesLegacyRegistration().registerAll(*parameterizedTraits);
+		}
+	}
+
+	static void invokeUnregistration(NvParameterized::Traits* parameterizedTraits)
+	{
+		if (parameterizedTraits)
+		{
+			ModuleParticlesLegacyRegistration().unregisterAll(*parameterizedTraits);
+		}
+	}
+
+	void registerAvailableFactories(NvParameterized::Traits& parameterizedTraits)
+	{
+		::NvParameterized::Factory* factoriesToRegister[] = {
+// REGISTER GENERATED FACTORIES
+			new nvidia::parameterized::EffectPackageAssetParams_0p0Factory(),
+			new nvidia::parameterized::EffectPackageDatabaseParams_0p0Factory(),
+			new nvidia::parameterized::GraphicsMaterialData_0p0Factory(),
+			new nvidia::parameterized::GraphicsMaterialData_0p1Factory(),
+			new nvidia::parameterized::GraphicsMaterialData_0p2Factory(),
+			new nvidia::parameterized::GraphicsMaterialData_0p3Factory(),
+			new nvidia::parameterized::VolumeRenderMaterialData_0p0Factory(),
+
+		};
+
+		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::ConversionEffectPackageAssetParams_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionEffectPackageDatabaseParams_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionGraphicsMaterialData_0p0_0p1 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionGraphicsMaterialData_0p1_0p2 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionGraphicsMaterialData_0p2_0p3 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionGraphicsMaterialData_0p3_0p4 ConverterToRegister;
+			parameterizedTraits.registerConversion(ConverterToRegister::TOldClass::staticClassName(),
+								ConverterToRegister::TOldClass::ClassVersion,
+								ConverterToRegister::TNewClass::ClassVersion,
+								*(ConverterToRegister::Create(&parameterizedTraits)));
+			}
+			{
+			typedef nvidia::apex::legacy::ConversionVolumeRenderMaterialData_0p0_0p1 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::EffectPackageAssetParams_0p0Factory(),
+			new nvidia::parameterized::EffectPackageDatabaseParams_0p0Factory(),
+			new nvidia::parameterized::GraphicsMaterialData_0p0Factory(),
+			new nvidia::parameterized::GraphicsMaterialData_0p1Factory(),
+			new nvidia::parameterized::GraphicsMaterialData_0p2Factory(),
+			new nvidia::parameterized::GraphicsMaterialData_0p3Factory(),
+			new nvidia::parameterized::VolumeRenderMaterialData_0p0Factory(),
+
+		};
+
+		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::ConversionEffectPackageAssetParams_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::ConversionEffectPackageDatabaseParams_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::ConversionGraphicsMaterialData_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::ConversionGraphicsMaterialData_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::ConversionGraphicsMaterialData_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::ConversionGraphicsMaterialData_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::ConversionVolumeRenderMaterialData_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");
+			}
+			}
+
+	}
+
+};
+
+// global namespace
+
+#endif
diff --git a/APEX_1.4/module/particles_legacy/include/autogen/NoiseFieldSamplerData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/NoiseFieldSamplerData_0p0.h
new file mode 100644
index 00000000..9ce4b6ec
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/NoiseFieldSamplerData_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_NoiseFieldSamplerData_0p0_h
+#define HEADER_NoiseFieldSamplerData_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 NoiseFieldSamplerData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* NoiseFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0xbdfbe8fa, 0xb764fe79, 0xb6ab4054, 0x6b459674, };
+
+} // namespace NoiseFieldSamplerData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class NoiseFieldSamplerData_0p0 : public NvParameterized::NvParameters, public NoiseFieldSamplerData_0p0NS::ParametersStruct
+{
+public:
+	NoiseFieldSamplerData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~NoiseFieldSamplerData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("NoiseFieldSamplerData");
+	}
+
+	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(NoiseFieldSamplerData_0p0NS::checksum);
+		return NoiseFieldSamplerData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const NoiseFieldSamplerData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		NoiseFieldSamplerData_0p0* tmpThis = const_cast<NoiseFieldSamplerData_0p0*>(this);
+		return *(static_cast<NoiseFieldSamplerData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	NoiseFieldSamplerData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<NoiseFieldSamplerData_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 NoiseFieldSamplerData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		NoiseFieldSamplerData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(NoiseFieldSamplerData_0p0), NoiseFieldSamplerData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, NoiseFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFieldSamplerData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(NoiseFieldSamplerData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, NoiseFieldSamplerData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, NoiseFieldSamplerData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, NoiseFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFieldSamplerData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of NoiseFieldSamplerData_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 (NoiseFieldSamplerData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (NoiseFieldSamplerData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (NoiseFieldSamplerData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (NoiseFieldSamplerData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (NoiseFieldSamplerData_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/particles_legacy/include/autogen/NoiseFieldSamplerEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/NoiseFieldSamplerEffect_0p0.h
new file mode 100644
index 00000000..e8942bdc
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/NoiseFieldSamplerEffect_0p0.h
@@ -0,0 +1,291 @@
+// 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_NoiseFieldSamplerEffect_0p0_h
+#define HEADER_NoiseFieldSamplerEffect_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 NoiseFieldSamplerEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* NoiseFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x5618cee8, 0xe4396e4b, 0x83c38fec, 0x332388c5, };
+
+} // namespace NoiseFieldSamplerEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class NoiseFieldSamplerEffect_0p0 : public NvParameterized::NvParameters, public NoiseFieldSamplerEffect_0p0NS::ParametersStruct
+{
+public:
+	NoiseFieldSamplerEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~NoiseFieldSamplerEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("NoiseFieldSamplerEffect");
+	}
+
+	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(NoiseFieldSamplerEffect_0p0NS::checksum);
+		return NoiseFieldSamplerEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const NoiseFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		NoiseFieldSamplerEffect_0p0* tmpThis = const_cast<NoiseFieldSamplerEffect_0p0*>(this);
+		return *(static_cast<NoiseFieldSamplerEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	NoiseFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<NoiseFieldSamplerEffect_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 NoiseFieldSamplerEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		NoiseFieldSamplerEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(NoiseFieldSamplerEffect_0p0), NoiseFieldSamplerEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, NoiseFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFieldSamplerEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(NoiseFieldSamplerEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, NoiseFieldSamplerEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, NoiseFieldSamplerEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, NoiseFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class NoiseFieldSamplerEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of NoiseFieldSamplerEffect_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 (NoiseFieldSamplerEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (NoiseFieldSamplerEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (NoiseFieldSamplerEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (NoiseFieldSamplerEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (NoiseFieldSamplerEffect_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/particles_legacy/include/autogen/ParticleSimulationData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/ParticleSimulationData_0p0.h
new file mode 100644
index 00000000..d34025a5
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/ParticleSimulationData_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_ParticleSimulationData_0p0_h
+#define HEADER_ParticleSimulationData_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 ParticleSimulationData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* IOS;
+
+};
+
+static const uint32_t checksum[] = { 0x4ca98ba8, 0x2d988101, 0xc0f27951, 0x9b625d89, };
+
+} // namespace ParticleSimulationData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ParticleSimulationData_0p0 : public NvParameterized::NvParameters, public ParticleSimulationData_0p0NS::ParametersStruct
+{
+public:
+	ParticleSimulationData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ParticleSimulationData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ParticleSimulationData");
+	}
+
+	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(ParticleSimulationData_0p0NS::checksum);
+		return ParticleSimulationData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ParticleSimulationData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ParticleSimulationData_0p0* tmpThis = const_cast<ParticleSimulationData_0p0*>(this);
+		return *(static_cast<ParticleSimulationData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ParticleSimulationData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ParticleSimulationData_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 ParticleSimulationData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ParticleSimulationData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ParticleSimulationData_0p0), ParticleSimulationData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ParticleSimulationData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticleSimulationData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ParticleSimulationData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ParticleSimulationData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ParticleSimulationData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ParticleSimulationData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticleSimulationData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ParticleSimulationData_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 (ParticleSimulationData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ParticleSimulationData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ParticleSimulationData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ParticleSimulationData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ParticleSimulationData_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/particles_legacy/include/autogen/ParticlesDebugRenderParams_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/ParticlesDebugRenderParams_0p0.h
new file mode 100644
index 00000000..eb3cc757
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/ParticlesDebugRenderParams_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_ParticlesDebugRenderParams_0p0_h
+#define HEADER_ParticlesDebugRenderParams_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 ParticlesDebugRenderParams_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	bool VISUALIZE_HEAT_SOURCE_ACTOR;
+	bool VISUALIZE_EFFECT_PACKAGE_ACTOR;
+
+};
+
+static const uint32_t checksum[] = { 0x85e707bb, 0x319491d5, 0x1be4a6e4, 0x78bfbdf4, };
+
+} // namespace ParticlesDebugRenderParams_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ParticlesDebugRenderParams_0p0 : public NvParameterized::NvParameters, public ParticlesDebugRenderParams_0p0NS::ParametersStruct
+{
+public:
+	ParticlesDebugRenderParams_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ParticlesDebugRenderParams_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ParticlesDebugRenderParams");
+	}
+
+	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(ParticlesDebugRenderParams_0p0NS::checksum);
+		return ParticlesDebugRenderParams_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ParticlesDebugRenderParams_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ParticlesDebugRenderParams_0p0* tmpThis = const_cast<ParticlesDebugRenderParams_0p0*>(this);
+		return *(static_cast<ParticlesDebugRenderParams_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ParticlesDebugRenderParams_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ParticlesDebugRenderParams_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 ParticlesDebugRenderParams_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ParticlesDebugRenderParams_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ParticlesDebugRenderParams_0p0), ParticlesDebugRenderParams_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ParticlesDebugRenderParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticlesDebugRenderParams_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ParticlesDebugRenderParams_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ParticlesDebugRenderParams_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ParticlesDebugRenderParams_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ParticlesDebugRenderParams_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticlesDebugRenderParams_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ParticlesDebugRenderParams_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 (ParticlesDebugRenderParams_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ParticlesDebugRenderParams_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ParticlesDebugRenderParams_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ParticlesDebugRenderParams_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ParticlesDebugRenderParams_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/particles_legacy/include/autogen/ParticlesModuleParameters_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/ParticlesModuleParameters_0p0.h
new file mode 100644
index 00000000..81e4ba09
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/ParticlesModuleParameters_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_ParticlesModuleParameters_0p0_h
+#define HEADER_ParticlesModuleParameters_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 ParticlesModuleParameters_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	uint32_t unused;
+
+};
+
+static const uint32_t checksum[] = { 0xb5f7f96c, 0x545549c7, 0xb6efe84c, 0x4bdc0f31, };
+
+} // namespace ParticlesModuleParameters_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class ParticlesModuleParameters_0p0 : public NvParameterized::NvParameters, public ParticlesModuleParameters_0p0NS::ParametersStruct
+{
+public:
+	ParticlesModuleParameters_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~ParticlesModuleParameters_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("ParticlesModuleParameters");
+	}
+
+	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(ParticlesModuleParameters_0p0NS::checksum);
+		return ParticlesModuleParameters_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const ParticlesModuleParameters_0p0NS::ParametersStruct& parameters(void) const
+	{
+		ParticlesModuleParameters_0p0* tmpThis = const_cast<ParticlesModuleParameters_0p0*>(this);
+		return *(static_cast<ParticlesModuleParameters_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	ParticlesModuleParameters_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<ParticlesModuleParameters_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 ParticlesModuleParameters_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		ParticlesModuleParameters_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(ParticlesModuleParameters_0p0), ParticlesModuleParameters_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, ParticlesModuleParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticlesModuleParameters_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(ParticlesModuleParameters_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, ParticlesModuleParameters_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, ParticlesModuleParameters_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, ParticlesModuleParameters_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class ParticlesModuleParameters_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of ParticlesModuleParameters_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 (ParticlesModuleParameters_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (ParticlesModuleParameters_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (ParticlesModuleParameters_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (ParticlesModuleParameters_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (ParticlesModuleParameters_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/particles_legacy/include/autogen/RigidBodyEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/RigidBodyEffect_0p0.h
new file mode 100644
index 00000000..f57b2c53
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/RigidBodyEffect_0p0.h
@@ -0,0 +1,300 @@
+// 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_RigidBodyEffect_0p0_h
+#define HEADER_RigidBodyEffect_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 RigidBodyEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	const char* Type;
+	NvParameterized::DummyStringStruct CollisionFilterDataName;
+	bool Dynamic;
+	bool Gravity;
+	physx::PxVec3 Extents;
+	float Mass;
+	physx::PxVec3 InitialLinearVelocity;
+	physx::PxVec3 InitialAngularVelocity;
+	float LinearDamping;
+	float AngularDamping;
+
+};
+
+static const uint32_t checksum[] = { 0x9a107d98, 0x19620918, 0x9994ec69, 0x14939e5c, };
+
+} // namespace RigidBodyEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class RigidBodyEffect_0p0 : public NvParameterized::NvParameters, public RigidBodyEffect_0p0NS::ParametersStruct
+{
+public:
+	RigidBodyEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~RigidBodyEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("RigidBodyEffect");
+	}
+
+	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(RigidBodyEffect_0p0NS::checksum);
+		return RigidBodyEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const RigidBodyEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		RigidBodyEffect_0p0* tmpThis = const_cast<RigidBodyEffect_0p0*>(this);
+		return *(static_cast<RigidBodyEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	RigidBodyEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<RigidBodyEffect_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 RigidBodyEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		RigidBodyEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(RigidBodyEffect_0p0), RigidBodyEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, RigidBodyEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RigidBodyEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(RigidBodyEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, RigidBodyEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, RigidBodyEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, RigidBodyEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class RigidBodyEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of RigidBodyEffect_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 (RigidBodyEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (RigidBodyEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (RigidBodyEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (RigidBodyEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (RigidBodyEffect_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/particles_legacy/include/autogen/SubstanceSourceData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/SubstanceSourceData_0p0.h
new file mode 100644
index 00000000..764c912d
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/SubstanceSourceData_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_SubstanceSourceData_0p0_h
+#define HEADER_SubstanceSourceData_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 SubstanceSourceData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* SubstanceSource;
+
+};
+
+static const uint32_t checksum[] = { 0x79f6e8ac, 0x0efbf6f6, 0x9823c17d, 0x1736b4d9, };
+
+} // namespace SubstanceSourceData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SubstanceSourceData_0p0 : public NvParameterized::NvParameters, public SubstanceSourceData_0p0NS::ParametersStruct
+{
+public:
+	SubstanceSourceData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SubstanceSourceData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SubstanceSourceData");
+	}
+
+	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(SubstanceSourceData_0p0NS::checksum);
+		return SubstanceSourceData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SubstanceSourceData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		SubstanceSourceData_0p0* tmpThis = const_cast<SubstanceSourceData_0p0*>(this);
+		return *(static_cast<SubstanceSourceData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	SubstanceSourceData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SubstanceSourceData_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 SubstanceSourceData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SubstanceSourceData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SubstanceSourceData_0p0), SubstanceSourceData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SubstanceSourceData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubstanceSourceData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SubstanceSourceData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SubstanceSourceData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SubstanceSourceData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SubstanceSourceData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubstanceSourceData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SubstanceSourceData_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 (SubstanceSourceData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SubstanceSourceData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SubstanceSourceData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SubstanceSourceData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SubstanceSourceData_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/particles_legacy/include/autogen/SubstanceSourceEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/SubstanceSourceEffect_0p0.h
new file mode 100644
index 00000000..2f06dae7
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/SubstanceSourceEffect_0p0.h
@@ -0,0 +1,291 @@
+// 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_SubstanceSourceEffect_0p0_h
+#define HEADER_SubstanceSourceEffect_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 SubstanceSourceEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* SubstanceSource;
+
+};
+
+static const uint32_t checksum[] = { 0x171c45ff, 0xd18f749a, 0xeaca4f46, 0xec9ce317, };
+
+} // namespace SubstanceSourceEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class SubstanceSourceEffect_0p0 : public NvParameterized::NvParameters, public SubstanceSourceEffect_0p0NS::ParametersStruct
+{
+public:
+	SubstanceSourceEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~SubstanceSourceEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("SubstanceSourceEffect");
+	}
+
+	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(SubstanceSourceEffect_0p0NS::checksum);
+		return SubstanceSourceEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const SubstanceSourceEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		SubstanceSourceEffect_0p0* tmpThis = const_cast<SubstanceSourceEffect_0p0*>(this);
+		return *(static_cast<SubstanceSourceEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	SubstanceSourceEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<SubstanceSourceEffect_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 SubstanceSourceEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		SubstanceSourceEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(SubstanceSourceEffect_0p0), SubstanceSourceEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, SubstanceSourceEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubstanceSourceEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(SubstanceSourceEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, SubstanceSourceEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, SubstanceSourceEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, SubstanceSourceEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class SubstanceSourceEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of SubstanceSourceEffect_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 (SubstanceSourceEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (SubstanceSourceEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (SubstanceSourceEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (SubstanceSourceEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (SubstanceSourceEffect_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/particles_legacy/include/autogen/TurbulenceFieldSamplerData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/TurbulenceFieldSamplerData_0p0.h
new file mode 100644
index 00000000..9950cc02
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/TurbulenceFieldSamplerData_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_TurbulenceFieldSamplerData_0p0_h
+#define HEADER_TurbulenceFieldSamplerData_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 TurbulenceFieldSamplerData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* TurbulenceFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0xac373033, 0x567939b2, 0xb61686da, 0x6b9b1a7b, };
+
+} // namespace TurbulenceFieldSamplerData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class TurbulenceFieldSamplerData_0p0 : public NvParameterized::NvParameters, public TurbulenceFieldSamplerData_0p0NS::ParametersStruct
+{
+public:
+	TurbulenceFieldSamplerData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~TurbulenceFieldSamplerData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("TurbulenceFieldSamplerData");
+	}
+
+	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(TurbulenceFieldSamplerData_0p0NS::checksum);
+		return TurbulenceFieldSamplerData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const TurbulenceFieldSamplerData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		TurbulenceFieldSamplerData_0p0* tmpThis = const_cast<TurbulenceFieldSamplerData_0p0*>(this);
+		return *(static_cast<TurbulenceFieldSamplerData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	TurbulenceFieldSamplerData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<TurbulenceFieldSamplerData_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 TurbulenceFieldSamplerData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		TurbulenceFieldSamplerData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(TurbulenceFieldSamplerData_0p0), TurbulenceFieldSamplerData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, TurbulenceFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class TurbulenceFieldSamplerData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(TurbulenceFieldSamplerData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, TurbulenceFieldSamplerData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, TurbulenceFieldSamplerData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, TurbulenceFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class TurbulenceFieldSamplerData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of TurbulenceFieldSamplerData_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 (TurbulenceFieldSamplerData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (TurbulenceFieldSamplerData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (TurbulenceFieldSamplerData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (TurbulenceFieldSamplerData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (TurbulenceFieldSamplerData_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/particles_legacy/include/autogen/TurbulenceFieldSamplerEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/TurbulenceFieldSamplerEffect_0p0.h
new file mode 100644
index 00000000..ae09ade5
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/TurbulenceFieldSamplerEffect_0p0.h
@@ -0,0 +1,291 @@
+// 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_TurbulenceFieldSamplerEffect_0p0_h
+#define HEADER_TurbulenceFieldSamplerEffect_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 TurbulenceFieldSamplerEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* TurbulenceFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x34739060, 0xd18c9ccf, 0xba454bf5, 0x78f5ddbb, };
+
+} // namespace TurbulenceFieldSamplerEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class TurbulenceFieldSamplerEffect_0p0 : public NvParameterized::NvParameters, public TurbulenceFieldSamplerEffect_0p0NS::ParametersStruct
+{
+public:
+	TurbulenceFieldSamplerEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~TurbulenceFieldSamplerEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("TurbulenceFieldSamplerEffect");
+	}
+
+	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(TurbulenceFieldSamplerEffect_0p0NS::checksum);
+		return TurbulenceFieldSamplerEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const TurbulenceFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		TurbulenceFieldSamplerEffect_0p0* tmpThis = const_cast<TurbulenceFieldSamplerEffect_0p0*>(this);
+		return *(static_cast<TurbulenceFieldSamplerEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	TurbulenceFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<TurbulenceFieldSamplerEffect_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 TurbulenceFieldSamplerEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		TurbulenceFieldSamplerEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(TurbulenceFieldSamplerEffect_0p0), TurbulenceFieldSamplerEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, TurbulenceFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class TurbulenceFieldSamplerEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(TurbulenceFieldSamplerEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, TurbulenceFieldSamplerEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, TurbulenceFieldSamplerEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, TurbulenceFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class TurbulenceFieldSamplerEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of TurbulenceFieldSamplerEffect_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 (TurbulenceFieldSamplerEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (TurbulenceFieldSamplerEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (TurbulenceFieldSamplerEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (TurbulenceFieldSamplerEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (TurbulenceFieldSamplerEffect_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/particles_legacy/include/autogen/VelocitySourceData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/VelocitySourceData_0p0.h
new file mode 100644
index 00000000..b7db4bc2
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/VelocitySourceData_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_VelocitySourceData_0p0_h
+#define HEADER_VelocitySourceData_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 VelocitySourceData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* VelocitySource;
+
+};
+
+static const uint32_t checksum[] = { 0x1d529c10, 0x109f65ed, 0xa3531c3a, 0x99ada8f2, };
+
+} // namespace VelocitySourceData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VelocitySourceData_0p0 : public NvParameterized::NvParameters, public VelocitySourceData_0p0NS::ParametersStruct
+{
+public:
+	VelocitySourceData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VelocitySourceData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VelocitySourceData");
+	}
+
+	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(VelocitySourceData_0p0NS::checksum);
+		return VelocitySourceData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VelocitySourceData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		VelocitySourceData_0p0* tmpThis = const_cast<VelocitySourceData_0p0*>(this);
+		return *(static_cast<VelocitySourceData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	VelocitySourceData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VelocitySourceData_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 VelocitySourceData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VelocitySourceData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VelocitySourceData_0p0), VelocitySourceData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VelocitySourceData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VelocitySourceData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VelocitySourceData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VelocitySourceData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VelocitySourceData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VelocitySourceData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VelocitySourceData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VelocitySourceData_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 (VelocitySourceData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VelocitySourceData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VelocitySourceData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VelocitySourceData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VelocitySourceData_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/particles_legacy/include/autogen/VelocitySourceEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/VelocitySourceEffect_0p0.h
new file mode 100644
index 00000000..4e85ad23
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/VelocitySourceEffect_0p0.h
@@ -0,0 +1,291 @@
+// 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_VelocitySourceEffect_0p0_h
+#define HEADER_VelocitySourceEffect_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 VelocitySourceEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* VelocitySource;
+
+};
+
+static const uint32_t checksum[] = { 0x26b72ab9, 0x777ca701, 0x04b00529, 0xf38de506, };
+
+} // namespace VelocitySourceEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VelocitySourceEffect_0p0 : public NvParameterized::NvParameters, public VelocitySourceEffect_0p0NS::ParametersStruct
+{
+public:
+	VelocitySourceEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VelocitySourceEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VelocitySourceEffect");
+	}
+
+	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(VelocitySourceEffect_0p0NS::checksum);
+		return VelocitySourceEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VelocitySourceEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		VelocitySourceEffect_0p0* tmpThis = const_cast<VelocitySourceEffect_0p0*>(this);
+		return *(static_cast<VelocitySourceEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	VelocitySourceEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VelocitySourceEffect_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 VelocitySourceEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VelocitySourceEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VelocitySourceEffect_0p0), VelocitySourceEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VelocitySourceEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VelocitySourceEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VelocitySourceEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VelocitySourceEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VelocitySourceEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VelocitySourceEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VelocitySourceEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VelocitySourceEffect_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 (VelocitySourceEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VelocitySourceEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VelocitySourceEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VelocitySourceEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VelocitySourceEffect_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/particles_legacy/include/autogen/VolumeRenderMaterialData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/VolumeRenderMaterialData_0p0.h
new file mode 100644
index 00000000..7e5c89e7
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/VolumeRenderMaterialData_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_VolumeRenderMaterialData_0p0_h
+#define HEADER_VolumeRenderMaterialData_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 VolumeRenderMaterialData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::DummyStringStruct ApplicationMaterialName;
+	NvParameterized::DummyStringStruct UserProperties;
+	bool RenderVelocityField;
+	float TextureRangeMin;
+	float TextureRangeMax;
+	float VolumeDensity;
+	float EdgeFade;
+	float OpacityThreshold;
+	uint32_t ShadowSamples;
+	float ShadowDistance;
+	float ShadowDensity;
+	float ShadowJitter;
+	physx::PxVec4 LightColor;
+	physx::PxVec4 AbsorptionColor;
+	float LightingAmount;
+	float ShadowAmount;
+
+};
+
+static const uint32_t checksum[] = { 0x0f732a44, 0xa68012d9, 0x2a0f8218, 0x81268964, };
+
+} // namespace VolumeRenderMaterialData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VolumeRenderMaterialData_0p0 : public NvParameterized::NvParameters, public VolumeRenderMaterialData_0p0NS::ParametersStruct
+{
+public:
+	VolumeRenderMaterialData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VolumeRenderMaterialData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VolumeRenderMaterialData");
+	}
+
+	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(VolumeRenderMaterialData_0p0NS::checksum);
+		return VolumeRenderMaterialData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VolumeRenderMaterialData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		VolumeRenderMaterialData_0p0* tmpThis = const_cast<VolumeRenderMaterialData_0p0*>(this);
+		return *(static_cast<VolumeRenderMaterialData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	VolumeRenderMaterialData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VolumeRenderMaterialData_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 VolumeRenderMaterialData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VolumeRenderMaterialData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VolumeRenderMaterialData_0p0), VolumeRenderMaterialData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VolumeRenderMaterialData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VolumeRenderMaterialData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VolumeRenderMaterialData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VolumeRenderMaterialData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VolumeRenderMaterialData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VolumeRenderMaterialData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VolumeRenderMaterialData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VolumeRenderMaterialData_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 (VolumeRenderMaterialData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VolumeRenderMaterialData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VolumeRenderMaterialData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VolumeRenderMaterialData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VolumeRenderMaterialData_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/particles_legacy/include/autogen/VolumeRenderMaterialData_0p1.h b/APEX_1.4/module/particles_legacy/include/autogen/VolumeRenderMaterialData_0p1.h
new file mode 100644
index 00000000..0bd7ca09
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/VolumeRenderMaterialData_0p1.h
@@ -0,0 +1,275 @@
+// This code contains NVIDIA Confidential Information and is disclosed to you
+// under a form of NVIDIA software license agreement provided separately to you.
+//
+// Notice
+// NVIDIA Corporation and its licensors retain all intellectual property and
+// proprietary rights in and to this software and related documentation and
+// any modifications thereto. Any use, reproduction, disclosure, or
+// distribution of this software and related documentation without an express
+// license agreement from NVIDIA Corporation is strictly prohibited.
+//
+// ALL NVIDIA DESIGN SPECIFICATIONS, CODE ARE PROVIDED "AS IS.". NVIDIA MAKES
+// NO WARRANTIES, EXPRESSED, IMPLIED, STATUTORY, OR OTHERWISE WITH RESPECT TO
+// THE MATERIALS, AND EXPRESSLY DISCLAIMS ALL IMPLIED WARRANTIES OF NONINFRINGEMENT,
+// MERCHANTABILITY, AND FITNESS FOR A PARTICULAR PURPOSE.
+//
+// Information and code furnished is believed to be accurate and reliable.
+// However, NVIDIA Corporation assumes no responsibility for the consequences of use of such
+// information or for any infringement of patents or other rights of third parties that may
+// result from its use. No license is granted by implication or otherwise under any patent
+// or patent rights of NVIDIA Corporation. Details are subject to change without notice.
+// This code supersedes and replaces all information previously supplied.
+// NVIDIA Corporation products are not authorized for use as critical
+// components in life support devices or systems without express written approval of
+// NVIDIA Corporation.
+//
+// Copyright (c) 2008-2015 NVIDIA Corporation. All rights reserved.
+
+// This file was generated by NvParameterized/scripts/GenParameterized.pl
+
+
+#ifndef HEADER_VolumeRenderMaterialData_0p1_h
+#define HEADER_VolumeRenderMaterialData_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 VolumeRenderMaterialData_0p1NS
+{
+
+struct colorLifeStruct_Type;
+
+struct colorLifeStruct_DynamicArray1D_Type
+{
+	colorLifeStruct_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct colorLifeStruct_Type
+{
+	float density;
+	physx::PxVec4 color;
+};
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::DummyStringStruct ApplicationMaterialName;
+	NvParameterized::DummyStringStruct UserProperties;
+	const char* RenderMode;
+	const char* RenderMethod;
+	const char* ResolutionScale;
+	const char* FillMode;
+	bool GenerateShadows;
+	bool BlurShadows;
+	bool GenerateMipmaps;
+	bool EnableStencilOpt;
+	float StepScale;
+	float Density;
+	float EdgeFade;
+	float OpacityThreshold;
+	float RayJitter;
+	float IsoValue;
+	float IsoValueSign;
+	uint32_t ShadowSamples;
+	float ShadowDistance;
+	float ShadowDensity;
+	float ShadowJitter;
+	float ShadowAmount;
+	physx::PxVec3 LightDir;
+	physx::PxVec4 LightColor;
+	float BlockEmptyThreshold;
+	bool ReadDepth;
+	float ColorMapScale;
+	float ColorMapOffset;
+	colorLifeStruct_DynamicArray1D_Type ColorMap;
+	float TextureRangeMin;
+	float TextureRangeMax;
+
+};
+
+static const uint32_t checksum[] = { 0xfb381de2, 0xf2cfee66, 0x5b5fbef9, 0x9199ccee, };
+
+} // namespace VolumeRenderMaterialData_0p1NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VolumeRenderMaterialData_0p1 : public NvParameterized::NvParameters, public VolumeRenderMaterialData_0p1NS::ParametersStruct
+{
+public:
+	VolumeRenderMaterialData_0p1(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VolumeRenderMaterialData_0p1();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VolumeRenderMaterialData");
+	}
+
+	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(VolumeRenderMaterialData_0p1NS::checksum);
+		return VolumeRenderMaterialData_0p1NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VolumeRenderMaterialData_0p1NS::ParametersStruct& parameters(void) const
+	{
+		VolumeRenderMaterialData_0p1* tmpThis = const_cast<VolumeRenderMaterialData_0p1*>(this);
+		return *(static_cast<VolumeRenderMaterialData_0p1NS::ParametersStruct*>(tmpThis));
+	}
+
+	VolumeRenderMaterialData_0p1NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VolumeRenderMaterialData_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 VolumeRenderMaterialData_0p1Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VolumeRenderMaterialData_0p1::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VolumeRenderMaterialData_0p1), VolumeRenderMaterialData_0p1::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VolumeRenderMaterialData_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VolumeRenderMaterialData_0p1");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VolumeRenderMaterialData_0p1)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VolumeRenderMaterialData_0p1)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VolumeRenderMaterialData_0p1::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VolumeRenderMaterialData_0p1::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VolumeRenderMaterialData_0p1");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VolumeRenderMaterialData_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 (VolumeRenderMaterialData_0p1*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VolumeRenderMaterialData_0p1::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VolumeRenderMaterialData_0p1::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VolumeRenderMaterialData_0p1::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VolumeRenderMaterialData_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/particles_legacy/include/autogen/VortexFieldSamplerData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/VortexFieldSamplerData_0p0.h
new file mode 100644
index 00000000..85f876ea
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/VortexFieldSamplerData_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_VortexFieldSamplerData_0p0_h
+#define HEADER_VortexFieldSamplerData_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 VortexFieldSamplerData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* VortexFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0xe1494a82, 0xeb4d703f, 0xa17e8922, 0x25b15901, };
+
+} // namespace VortexFieldSamplerData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VortexFieldSamplerData_0p0 : public NvParameterized::NvParameters, public VortexFieldSamplerData_0p0NS::ParametersStruct
+{
+public:
+	VortexFieldSamplerData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VortexFieldSamplerData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VortexFieldSamplerData");
+	}
+
+	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(VortexFieldSamplerData_0p0NS::checksum);
+		return VortexFieldSamplerData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VortexFieldSamplerData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		VortexFieldSamplerData_0p0* tmpThis = const_cast<VortexFieldSamplerData_0p0*>(this);
+		return *(static_cast<VortexFieldSamplerData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	VortexFieldSamplerData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VortexFieldSamplerData_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 VortexFieldSamplerData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VortexFieldSamplerData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VortexFieldSamplerData_0p0), VortexFieldSamplerData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VortexFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFieldSamplerData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VortexFieldSamplerData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VortexFieldSamplerData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VortexFieldSamplerData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VortexFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFieldSamplerData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VortexFieldSamplerData_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 (VortexFieldSamplerData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VortexFieldSamplerData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VortexFieldSamplerData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VortexFieldSamplerData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VortexFieldSamplerData_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/particles_legacy/include/autogen/VortexFieldSamplerEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/VortexFieldSamplerEffect_0p0.h
new file mode 100644
index 00000000..c2bb51bd
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/VortexFieldSamplerEffect_0p0.h
@@ -0,0 +1,291 @@
+// 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_VortexFieldSamplerEffect_0p0_h
+#define HEADER_VortexFieldSamplerEffect_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 VortexFieldSamplerEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* VortexFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x2be885a4, 0xf50fd36f, 0xe78facab, 0xc365bd58, };
+
+} // namespace VortexFieldSamplerEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class VortexFieldSamplerEffect_0p0 : public NvParameterized::NvParameters, public VortexFieldSamplerEffect_0p0NS::ParametersStruct
+{
+public:
+	VortexFieldSamplerEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~VortexFieldSamplerEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("VortexFieldSamplerEffect");
+	}
+
+	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(VortexFieldSamplerEffect_0p0NS::checksum);
+		return VortexFieldSamplerEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const VortexFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		VortexFieldSamplerEffect_0p0* tmpThis = const_cast<VortexFieldSamplerEffect_0p0*>(this);
+		return *(static_cast<VortexFieldSamplerEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	VortexFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<VortexFieldSamplerEffect_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 VortexFieldSamplerEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		VortexFieldSamplerEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(VortexFieldSamplerEffect_0p0), VortexFieldSamplerEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, VortexFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFieldSamplerEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(VortexFieldSamplerEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, VortexFieldSamplerEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, VortexFieldSamplerEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, VortexFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class VortexFieldSamplerEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of VortexFieldSamplerEffect_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 (VortexFieldSamplerEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (VortexFieldSamplerEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (VortexFieldSamplerEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (VortexFieldSamplerEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (VortexFieldSamplerEffect_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/particles_legacy/include/autogen/WindFieldSamplerData_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/WindFieldSamplerData_0p0.h
new file mode 100644
index 00000000..b940eb8b
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/WindFieldSamplerData_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_WindFieldSamplerData_0p0_h
+#define HEADER_WindFieldSamplerData_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 WindFieldSamplerData_0p0NS
+{
+
+
+
+struct ParametersStruct
+{
+
+	NvParameterized::DummyStringStruct Name;
+	NvParameterized::Interface* WindFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0xe5c5674e, 0x58f8377e, 0xc3b4e486, 0x2cbdd0bc, };
+
+} // namespace WindFieldSamplerData_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class WindFieldSamplerData_0p0 : public NvParameterized::NvParameters, public WindFieldSamplerData_0p0NS::ParametersStruct
+{
+public:
+	WindFieldSamplerData_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~WindFieldSamplerData_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("WindFieldSamplerData");
+	}
+
+	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(WindFieldSamplerData_0p0NS::checksum);
+		return WindFieldSamplerData_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const WindFieldSamplerData_0p0NS::ParametersStruct& parameters(void) const
+	{
+		WindFieldSamplerData_0p0* tmpThis = const_cast<WindFieldSamplerData_0p0*>(this);
+		return *(static_cast<WindFieldSamplerData_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	WindFieldSamplerData_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<WindFieldSamplerData_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 WindFieldSamplerData_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		WindFieldSamplerData_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(WindFieldSamplerData_0p0), WindFieldSamplerData_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, WindFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFieldSamplerData_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(WindFieldSamplerData_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, WindFieldSamplerData_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, WindFieldSamplerData_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, WindFieldSamplerData_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFieldSamplerData_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of WindFieldSamplerData_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 (WindFieldSamplerData_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (WindFieldSamplerData_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (WindFieldSamplerData_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (WindFieldSamplerData_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (WindFieldSamplerData_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/particles_legacy/include/autogen/WindFieldSamplerEffect_0p0.h b/APEX_1.4/module/particles_legacy/include/autogen/WindFieldSamplerEffect_0p0.h
new file mode 100644
index 00000000..6bde9732
--- /dev/null
+++ b/APEX_1.4/module/particles_legacy/include/autogen/WindFieldSamplerEffect_0p0.h
@@ -0,0 +1,291 @@
+// 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_WindFieldSamplerEffect_0p0_h
+#define HEADER_WindFieldSamplerEffect_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 WindFieldSamplerEffect_0p0NS
+{
+
+struct TranslateObject_Type;
+struct OrientObject_Type;
+struct ControlPoint_Type;
+struct EffectPath_Type;
+struct EffectProperties_Type;
+
+struct TRANSFORM_DynamicArray1D_Type
+{
+	physx::PxTransform* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct ControlPoint_DynamicArray1D_Type
+{
+	ControlPoint_Type* buf;
+	bool isAllocated;
+	int32_t elementSize;
+	int32_t arraySizes[1];
+};
+
+struct TranslateObject_Type
+{
+	float TranslateX;
+	float TranslateY;
+	float TranslateZ;
+};
+struct ControlPoint_Type
+{
+	float x;
+	float y;
+};
+struct OrientObject_Type
+{
+	float RotateX;
+	float RotateY;
+	float RotateZ;
+};
+struct EffectPath_Type
+{
+	const char* PlaybackMode;
+	float PathDuration;
+	uint32_t LoopIndex;
+	TRANSFORM_DynamicArray1D_Type ControlPoints;
+	ControlPoint_DynamicArray1D_Type Scale;
+	ControlPoint_DynamicArray1D_Type Speed;
+};
+struct EffectProperties_Type
+{
+	NvParameterized::DummyStringStruct UserString;
+	bool Enable;
+	TranslateObject_Type Position;
+	OrientObject_Type Orientation;
+	float InitialDelayTime;
+	float Duration;
+	uint32_t RepeatCount;
+	float RepeatDelay;
+	float RandomizeRepeatTime;
+	EffectPath_Type Path;
+};
+
+struct ParametersStruct
+{
+
+	EffectProperties_Type EffectProperties;
+	NvParameterized::Interface* WindFieldSampler;
+
+};
+
+static const uint32_t checksum[] = { 0x98b44af2, 0xea3bf59f, 0xa34c5161, 0x0a087624, };
+
+} // namespace WindFieldSamplerEffect_0p0NS
+
+#ifndef NV_PARAMETERIZED_ONLY_LAYOUTS
+class WindFieldSamplerEffect_0p0 : public NvParameterized::NvParameters, public WindFieldSamplerEffect_0p0NS::ParametersStruct
+{
+public:
+	WindFieldSamplerEffect_0p0(NvParameterized::Traits* traits, void* buf = 0, int32_t* refCount = 0);
+
+	virtual ~WindFieldSamplerEffect_0p0();
+
+	virtual void destroy();
+
+	static const char* staticClassName(void)
+	{
+		return("WindFieldSamplerEffect");
+	}
+
+	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(WindFieldSamplerEffect_0p0NS::checksum);
+		return WindFieldSamplerEffect_0p0NS::checksum;
+	}
+
+	static void freeParameterDefinitionTable(NvParameterized::Traits* traits);
+
+	const uint32_t* checksum(uint32_t& bits) const
+	{
+		return staticChecksum(bits);
+	}
+
+	const WindFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void) const
+	{
+		WindFieldSamplerEffect_0p0* tmpThis = const_cast<WindFieldSamplerEffect_0p0*>(this);
+		return *(static_cast<WindFieldSamplerEffect_0p0NS::ParametersStruct*>(tmpThis));
+	}
+
+	WindFieldSamplerEffect_0p0NS::ParametersStruct& parameters(void)
+	{
+		return *(static_cast<WindFieldSamplerEffect_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 WindFieldSamplerEffect_0p0Factory : public NvParameterized::Factory
+{
+	static const char* const vptr;
+
+public:
+
+	virtual void freeParameterDefinitionTable(NvParameterized::Traits* traits)
+	{
+		WindFieldSamplerEffect_0p0::freeParameterDefinitionTable(traits);
+	}
+
+	virtual NvParameterized::Interface* create(NvParameterized::Traits* paramTraits)
+	{
+		// placement new on this class using mParameterizedTraits
+
+		void* newPtr = paramTraits->alloc(sizeof(WindFieldSamplerEffect_0p0), WindFieldSamplerEffect_0p0::ClassAlignment);
+		if (!NvParameterized::IsAligned(newPtr, WindFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFieldSamplerEffect_0p0");
+			paramTraits->free(newPtr);
+			return 0;
+		}
+
+		memset(newPtr, 0, sizeof(WindFieldSamplerEffect_0p0)); // always initialize memory allocated to zero for default values
+		return NV_PARAM_PLACEMENT_NEW(newPtr, WindFieldSamplerEffect_0p0)(paramTraits);
+	}
+
+	virtual NvParameterized::Interface* finish(NvParameterized::Traits* paramTraits, void* bufObj, void* bufStart, int32_t* refCount)
+	{
+		if (!NvParameterized::IsAligned(bufObj, WindFieldSamplerEffect_0p0::ClassAlignment)
+		        || !NvParameterized::IsAligned(bufStart, WindFieldSamplerEffect_0p0::ClassAlignment))
+		{
+			NV_PARAM_TRAITS_WARNING(paramTraits, "Unaligned memory allocation for class WindFieldSamplerEffect_0p0");
+			return 0;
+		}
+
+		// Init NvParameters-part
+		// We used to call empty constructor of WindFieldSamplerEffect_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 (WindFieldSamplerEffect_0p0*)bufObj;
+	}
+
+	virtual const char* getClassName()
+	{
+		return (WindFieldSamplerEffect_0p0::staticClassName());
+	}
+
+	virtual uint32_t getVersion()
+	{
+		return (WindFieldSamplerEffect_0p0::staticVersion());
+	}
+
+	virtual uint32_t getAlignment()
+	{
+		return (WindFieldSamplerEffect_0p0::ClassAlignment);
+	}
+
+	virtual const uint32_t* getChecksum(uint32_t& bits)
+	{
+		return (WindFieldSamplerEffect_0p0::staticChecksum(bits));
+	}
+};
+#endif // NV_PARAMETERIZED_ONLY_LAYOUTS
+
+} // namespace parameterized
+} // namespace nvidia
+
+#if PX_VC
+#pragma warning(pop)
+#endif
+
+#endif